[Débutant] Créez un jeu compétitif avec des connaissances de base sur Java
1.Tout d'abord
1. Motivation
Je l'ai créé parce que j'ai réalisé que "Si vous comprenez les bases de Java (ou plutôt orienté objet), vous pouvez créer un jeu compétitif!" Si vous pensez: «Je ne sais pas quoi faire, donc je ne connais pas la motivation pour apprendre», j'aimerais que vous jetiez un coup d'œil! !!
- Créé en référence à "Introduction à Java 2nd Edition".
2. Sortie
1. Règles du jeu
Un jeu dans lequel les dragons se battent.
Tout d'abord, sélectionnez et générez vous-même et le dragon ennemi. <Phase de sélection / génération>
Compétez-vous mutuellement et terminez lorsque les PV atteignent 0.
- Les détails sont décrits dans les règles du jeu ci-dessous.
2. Relation avec l'orientation de l'objet
- Générez le dragon sélectionné avec vous-même et l'ennemi en utilisant le dessin de conception (= classe) = instanciation orientée objet
- Se référer à / mettre à jour la valeur de l'objet pour le résultat de l'utilisation de la technique (diminution de HP) = Utilisation du getter et du setter
2. Contenu
1.Tout d'abord
1. Règles du jeu
-Dans la phase de sélection / génération et la phase de combat, la technique à utiliser avec le dragon est déterminée par la sélection de l'utilisateur.
-Sélectionnez un dragon pour vous-même et un pour l'ennemi <Phase de sélection / génération>
・ Trois dragons avec différents noms, HP et techniques sont disponibles.
・ Chaque dragon a 3 techniques.
・ Commandez au dragon d'effectuer une bataille
2. Structure des dossiers
├── DragonMain.java ├── bean │ ├── ButtleDragon.java │ ├── Action.java │ └── SimpleDragon.java └── util ├── buttle │ ├── ButtleContents.java │ ├── ButtleMain.java │ └── RandomEnemyChoice.java └── choice └── ChoiceDragon.java
Instanciez (générez) un dragon en utilisant les classes du dossier bean. En phase de sélection / génération A l'étape "sélection", sélectionnez SimpleDragon.java ButtDragon.java et Action.java sont utilisés dans l'étape de "génération".
2. Traitement global
↓ méthode principale
DragonMain.java
package dragon;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import dragon.bean.ButtleDragon;
import dragon.util.buttle.ButtleMain;
import dragon.util.choice.ChoiceDragon;
public class DragonMain{
public static void main(String[] args)throws Exception {
System.out.println("Commencez une bataille de dragon");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try{
//Obtenez une liste de dragons
ChoiceDragon.searchDrageon();
//Choisissez quel dragon créer
String choiceMyDragon = null;
String choiceOpponentDragon = null;
System.out.print("Veuillez sélectionner le dragon que vous utilisez par identifiant>");
choiceMyDragon = br.readLine();
System.out.print("Veuillez sélectionner le dragon que vous voulez que votre adversaire utilise par identifiant>");
choiceOpponentDragon = br.readLine();
//Génération de dragon
ButtleDragon myDragon = ChoiceDragon.makeDragon(Integer.parseInt(choiceMyDragon));
ButtleDragon oppoDragon = ChoiceDragon.makeDragon(Integer.parseInt(choiceOpponentDragon));
//Buttle
ButtleMain.doButtle(myDragon,oppoDragon);
}catch(Exception e){
System.out.println("J'ai une grave erreur");
}
}
}
ChoiceDragon.searchDrageon ();: Obtenir la liste des dragons ChoiceDragon.makeDragon ());: Générez vous-même et des dragons ennemis et stockez-les respectivement dans "myDragon" et "oppoDragon". ButtleMain.doButtle ();: Commencez la bataille avec "myDragon" et "oppoDragon" comme arguments
3. Phase de sélection / génération
Obtenez une liste de dragons, générez le dragon sélectionné et associez la technique au dragon
・ Classe (Bean)
↓ Utilisé pour générer un simple dragon. Utilisé pour afficher une liste d'identifiants et de noms de dragon lorsqu'ils sont sélectionnés sans compétence
SimpleDragon.java
package dragon.bean;
public class SimpleDragon {
int dragonId;
String dragonName;
int hitPoint;
//Constructeur de dragon simple
public SimpleDragon(int dragonId,String dragonName, int hitPoint){
this.dragonId = dragonId;
this.dragonName = dragonName;
this.hitPoint = hitPoint;
}
public int getDragonId() {
return dragonId;
}
public void setDragonId(int dragonId) {
this.dragonId = dragonId;
}
public String getDragonName() {
return dragonName;
}
public void setDragonName(String dragonName) {
this.dragonName = dragonName;
}
public int getHitPoint() {
return hitPoint;
}
public void setHitPoint(int hitPoint) {
this.hitPoint = hitPoint;
}
}
↓ Utilisé pour créer un dragon de combat. Hérite de la classe de dragon simple et donne-lui des HP et des compétences auxquelles se référer pendant la bataille.
ButtleDragon.java
package dragon.bean;
package dragon.bean;
import java.util.Map;
/**
*
*Classe de dragon utilisée pendant la bataille
*Utilisé pour augmenter ou diminuer HP
*/
public class ButtleDragon extends SimpleDragon {
int buttleHp;
int action1;
int action2;
int action3;
Map<Integer, Action> actions;
/**
*Constructeur de dragon de bataille. La valeur initiale de HP pour la bataille est HP
* @param dragonId
* @param dragonName
* @param hitPoint
*/
public ButtleDragon(int dragonId, String dragonName, int hitPoint) {
super(dragonId,dragonName,hitPoint);
this.buttleHp = hitPoint;
}
public int getButtleHp() {
return buttleHp;
}
public void setButtleHp(int buttleHp) {
this.buttleHp = buttleHp;
}
public int getAction1() {
return action1;
}
public void setAction1(int action1) {
this.action1 = action1;
}
public int getAction2() {
return action2;
}
public void setAction2(int action2) {
this.action2 = action2;
}
public int getAction3() {
return action3;
}
public void setAction3(int action3) {
this.action3 = action3;
}
public Map<Integer, Action> getActions() {
return actions;
}
public void setActions(Map<Integer, Action> actions) {
this.actions = actions;
}
}
↓ Utilisé pour créer des techniques.
Action.java
package dragon.bean;
/*
*Classe de technique utilisée pendant la bataille
*/
public class Action {
int actionId;
String actionName;
int power;
int actionPoint;
int buttleActionPoint;
/**
*Constructeur de technique.
*MP au combat[buttleActionPoint]Utilisez pour augmenter ou diminuer
*
* @param actionName
* @param power
* @param actionPoint
*/
public Action(int actionId,String actionName, int power, int actionPoint) {
this.actionId = actionId;
this.actionName = actionName;
this.power = power;
this.actionPoint = actionPoint;
this.buttleActionPoint = actionPoint;
}
public int getActionId() {
return actionId;
}
public void setActionId(int actionId) {
this.actionId = actionId;
}
public String getActionName() {
return actionName;
}
public void setActionName(String actionName) {
this.actionName = actionName;
}
public int getPower() {
return power;
}
public void setPower(int power) {
this.power = power;
}
public int getActionPoint() {
return actionPoint;
}
public void setActionPoint(int actionPoint) {
this.actionPoint = actionPoint;
}
public int getButtleActionPoint() {
return buttleActionPoint;
}
public void setButtleActionPoint(int buttleActionPoint) {
this.buttleActionPoint = buttleActionPoint;
}
}
・ Dragon de choix ↓ Obtenez une liste pour sélectionner un dragon et générer un dragon sélectionné. Il est également là pour donner au dragon une compétence après sa génération.
ChoiceDragon.java
package dragon.util.choice;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import dragon.bean.Action;
import dragon.bean.ButtleDragon;
import dragon.bean.SimpleDragon;
public class ChoiceDragon {
/**
*Sélectionnez un dragon
** Il peut être bon d'obtenir cette partie de la base de données
* @throws Exception
*/
public static void searchDrageon(){
//Créez un dragon qui peut être sélectionné ici
SimpleDragon dragon1 = new SimpleDragon(1,"Dragon blanc", 20);
SimpleDragon dragon2 = new SimpleDragon(2,"Dragon bleu", 25);
SimpleDragon dragon3 = new SimpleDragon(3,"Dragon Rouge", 15);
//Liste des dragons créés
List<SimpleDragon> choiceDragonList = new ArrayList<SimpleDragon>();
choiceDragonList.add(dragon1);
choiceDragonList.add(dragon2);
choiceDragonList.add(dragon3);
//Afficher la liste
System.out.println("ID:\t nom de dragon");
for(SimpleDragon list : choiceDragonList){
System.out.println(list.getDragonId()+":\t"+list.getDragonName());
}
}
/**
*Créez un dragon à partir de la liste en fonction de la valeur sélectionnée
*Après cela, donnez-leur une compétence
*/
public static ButtleDragon makeDragon(int DragonId){
//Créer un dragon
ButtleDragon buttleDragon = makeButtleDragon(DragonId);
//Obtenez la liste des astuces
Map<Integer, Action> buttleActionMap = makeButtleAction() ;
//Donnez la compétence du dragon
Map<Integer, Action> buttleDragonActionMap = new HashMap<>();
//Obtenez l'identifiant de la technique du dragon
int actionId_1 = buttleDragon.getAction1();
int actionId_2 = buttleDragon.getAction2();
int actionId_3 = buttleDragon.getAction3();
//Obtenez les compétences du dragon de la liste de compétences
Action action1 = buttleActionMap.get(actionId_1);
Action action2 = buttleActionMap.get(actionId_2);
Action action3 = buttleActionMap.get(actionId_3);
//Connectez les dragons et les techniques
buttleDragonActionMap.put(1, action1);
buttleDragonActionMap.put(2, action2);
buttleDragonActionMap.put(3, action3);
buttleDragon.setActions(buttleDragonActionMap);
return buttleDragon;
}
/**
*Créez un dragon et donnez à chacun un identifiant dans la liste de compétences.
** Je pense qu'il vaut mieux utiliser DB ici.
* @param dragonId
* @return
*/
private static ButtleDragon makeButtleDragon(int dragonId) {
ButtleDragon makeDragon = null;
//Créez différents dragons en fonction de l'argument
switch(dragonId) {
case 1:
//Les arguments du constructeur du dragon de combat sont l'ID, le nom du dragon et les HP.
ButtleDragon dragon1 = new ButtleDragon(1,"Dragon blanc", 20);
//Définissez la technique sur le dragon de combat
dragon1.setAction1(1);
dragon1.setAction2(2);
dragon1.setAction3(5);
makeDragon = dragon1;
break;
case 2:
ButtleDragon dragon2 = new ButtleDragon(2,"Dragon bleu", 25);
dragon2.setAction1(1);
dragon2.setAction2(3);
dragon2.setAction3(5);
makeDragon = dragon2;
break;
case 3:
ButtleDragon dragon3 = new ButtleDragon(3,"Dragon Rouge", 15);
dragon3.setAction1(1);
dragon3.setAction2(4);
dragon3.setAction3(5);
makeDragon = dragon3;
break;
}
return makeDragon;
}
/**
*Obtenez la liste des techniques.
** Je pense qu'il vaut mieux utiliser DB ici.
* @return
*/
private static Map<Integer, Action> makeButtleAction() {
//Déclarer une liste de techniques
Action action1 = new Action(1,"attaque\t", 2, 20);
Action action2 = new Action(2,"Souffle blanc", 4, 2);
Action action3 = new Action(3,"Souffle bleu", 3, 2);
Action action4 = new Action(4,"Souffle rouge", 5, 2);
Action action5 = new Action(5,"Attaque forte", 6, 1);
//Emballez la liste des techniques sur la carte
Map<Integer, Action> actionList = new HashMap<>();
actionList.put(1, action1);
actionList.put(2, action2);
actionList.put(3, action3);
actionList.put(4, action4);
actionList.put(5, action5);
return actionList;
}
}
1. Obtenez une liste de dragons
Faites-le dans la méthode ChoiceDragon.searchDrageon. SimpleDragon dragon1 = new SimpleDragon () crée respectivement des dragons. Générez un dragon de type SimpleDragon à l'aide du constructeur et de l'identifiant, du nom et de HP respectivement. Stockez tous les dragons générés par choiceDragonList dans la liste et affichez-les tous.
2. Générer un dragon pour la bataille
ChoiceDragon.make Faites-le dans la méthode Dragon. 1: Génération de dragon pour la bataille Généré à partir de ButtleDragon (une classe qui ajoute l'id de la technique à utiliser et les HP pour la bataille (qui diminue lors d'une attaque) à SimpleDragon) 2: Générer une liste de techniques Générez l'id, le nom de la technique, la puissance et le MP en tant qu'action, et générez une carte de «liste de techniques» qui relie l'id et l'action. 3: Connectez le dragon généré et la technique Puisque l'identifiant de la technique à utiliser est donné au dragon, la technique qui lui correspond est acquise à partir de la liste des techniques et stockée.
↓ Image
En exécutant le même contenu avec le dragon ennemi, 2 "dragons avec des compétences" seront générés
4. Phase de combat
↓ La principale méthode de combat. Continuez votre tour et celui de votre adversaire jusqu'à ce que l'un des HP soit épuisé.
ButtleMain.java
package dragon.util.buttle;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import dragon.bean.ButtleDragon;
public class ButtleMain {
/**
*Le flux de base de Buttle
* @throws IOException
*/
public static void doButtle(ButtleDragon myDragon, ButtleDragon oppoDragon) throws IOException{
boolean enemyDownFlg = false; //Déterminer si un ennemi est tombé
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Commencez la bataille de dragon.");
do{
ButtleContents.outputActionList(myDragon);
String str = null;
str = br.readLine();
System.out.println("Cette attaque!");
ButtleContents.useAction(myDragon.getActions().get(Integer.parseInt(str)), myDragon, oppoDragon);
if(oppoDragon.getButtleHp() == 0){
enemyDownFlg = true;
break;
}
System.out.println("Attaque de l'adversaire!");
RandomEnemyChoice.randomChoice(oppoDragon,myDragon);
}while(myDragon.getButtleHp() != 0);
ButtleContents.outputResult(enemyDownFlg);
System.out.println("La bataille est finie");
}
}
↓ Le flux lorsque vous exécutez une technique. Afficher le texte, réduire les HP ennemis, réduire les PM de votre compétence.
ButtleContents.java
package dragon.util.buttle;
import dragon.bean.Action;
import dragon.bean.ButtleDragon;
public class ButtleContents {
/**
*Flux technique de base
* @param offenceAction:Technique de l'attaquant
* @param offenceDragon:Attaquer le dragon
* @param defenceDragon:Défendre le dragon
*/
public static void useAction(Action offenceAction,ButtleDragon offenceDragon, ButtleDragon defenceDragon){
int nokoriMP = offenceAction.getActionPoint(); //MP actuel
//Affichage de la technique d'attaque
String actionName = offenceAction.getActionName().replaceAll("\t", "");//Supprimer le délimiteur de tabulation inclus dans le nom de la technique
System.out.println(offenceDragon.getDragonName()+"de"+actionName+"!!");
//Technique d'attaque
Attack(offenceAction,offenceDragon,defenceDragon);
//Réduction des PM
nokoriMP--;
offenceAction.setButtleActionPoint(nokoriMP);
}
/**
*Flux de technique d'attaque
* @param offenceAction
* @param offenceDragon
* @param defenceDragon
*/
public static void Attack(Action offenceAction,ButtleDragon offenceDragon, ButtleDragon defenceDragon){
int damage = offenceAction.getPower(); //Puissance de la technique
int defenceDragonNokoriHp = 0; //Le montant de HP du dragon en défense mis à jour avec le Butt
//Calcul des PV restants de l'adversaire
defenceDragonNokoriHp = defenceDragon.getButtleHp() - damage;
if(defenceDragonNokoriHp <= 0){
defenceDragon.setButtleHp(0);
}else{
defenceDragon.setButtleHp(defenceDragonNokoriHp);
}
System.out.println(defenceDragon.getDragonName()+"Est"+damage+"Force physique restante en raison de dommages"+defenceDragon.getButtleHp()+"Devenu!");
}
/**
*Afficher la liste des techniques
* @param myDragon
*/
public static void outputActionList(ButtleDragon myDragon){
System.out.println("\commande n\t\t Nom de la technique\t\t\t\t points restants");
System.out.println("\t1:\t\t"+myDragon.getActions().get(1).getActionName()+"\t\t"+myDragon.getActions().get(1).getButtleActionPoint() );
System.out.println("\t2:\t\t"+myDragon.getActions().get(2).getActionName()+"\t\t"+myDragon.getActions().get(2).getButtleActionPoint() );
System.out.println("\t3:\t\t"+myDragon.getActions().get(3).getActionName()+"\t\t"+myDragon.getActions().get(3).getButtleActionPoint() );
System.out.print("Veuillez choisir une technique>");
}
/**
*Afficher le résultat de la victoire ou de la défaite
* @param enemyDownFlg
*/
public static void outputResult(boolean enemyDownFlg){
if(enemyDownFlg){
System.out.println("\n gagné!");
}else{
System.out.println("\n j'ai perdu ...");
}
}
}
↓ Le processus consistant à décider au hasard de la technique à livrer par l'ennemi et à livrer la technique
RandomEnemyChoice.java
package dragon.util.buttle;
import dragon.bean.ButtleDragon;
/**
*Une classe qui spécifie des mouvements aléatoires du côté ennemi
*
*/
public class RandomEnemyChoice {
/**
*Générez et exécutez des figures de manière aléatoire
* @param oppoDragon
* @param myDragon
*/
public static void randomChoice(ButtleDragon oppoDragon, ButtleDragon myDragon){
//Sélectionnez une technique pour jouer au hasard
int randomChoice = 0;
randomChoice = (int)(Math.random()*3 + 1);
//Effectuer une technique
ButtleContents.useAction(oppoDragon.getActions().get(randomChoice),oppoDragon, myDragon);
}
}
1. Flux de processus (ButtleMain.java)
Continuez la bataille jusqu'à ce que l'ennemi s'effondre (oppoDragon.getButtleHp () == 0) ou que vous vous effondriez (myDragon.getButtleHp () == 0). Transmettez la valeur d'entrée à la méthode ButtleContents.useAction pour votre propre attaque et transmettez la valeur aléatoire à la méthode ButtleContents.useAction dans la méthode RandomEnemyChoice.randomChoice pour traiter l'attaque de l'ennemi.
Procéder au traitement tout en mettant à jour (getter) et en référençant (setter) les valeurs détenues par le dragon instancié.
2. Traitement lorsqu'une technique est sélectionnée (ButtleContents.useAction)
1. Description de la méthode
Cette méthode prend trois arguments, "offenceAction / offerDragon / defenseDragon". Dans ce jeu, lorsque votre dragon attaque en utilisant une technique, le dragon de l'adversaire devient le dragon défenseur (même si le côté attaquant est un ennemi, le côté défenseur devient votre propre dragon). Par conséquent, lorsque vous attaquez et lorsque l'adversaire attaque, échangez simplement le dragon passé aux 2ème et 3ème arguments, et le processus selon lequel "le côté attaquant a endommagé le côté défenseur" est le côté attaquant = vous-même, le côté attaquant = Valable également pour les ennemis. De plus, lors de la saisie de cette méthode, la technique sélectionnée par l'attaquant est passée en argument (offenceAction).
2. Flux de processus lors de la sélection d'une technique
1: affichage des messages 2: Traitement des attaques (ButtleContents.Attack) Obtenez la puissance de la technique à partir de la technique et calculez les PV restants du défenseur. Ensuite, définissez la valeur calculée sur Butttle HP du défenseur. 3: diminution de MP Réduire le PM de la technique utilisée par l'attaquant
3. Enfin
Merci d'avoir lu jusqu'ici! Nous apprécierions que vous imaginiez qu'un dragon est créé / déplacé (= instancié / utilisé) en lisant le contenu ou en le créant réellement.
Recommended Posts