[Anfänger] Erstellen Sie ein wettbewerbsfähiges Spiel mit grundlegenden Java-Kenntnissen
1. Zuallererst
1. Motivation
Ich habe es erstellt, weil mir klar wurde, dass "Wenn Sie die Grundlagen von Java verstehen (oder besser gesagt objektorientiert), können Sie ein wettbewerbsfähiges Spiel erstellen!" Wenn Sie denken: "Ich weiß nicht, was ich machen soll, also kenne ich die Motivation zum Lernen nicht." Ich möchte, dass Sie einen Blick darauf werfen! !!
- Erstellt mit Bezug auf "Einführung in Java 2nd Edition".
2. Ausgabe
1. Spielregeln
Ein Spiel, in dem Drachen gegeneinander kämpfen.
Wählen und generieren Sie zuerst sich selbst und den feindlichen Drachen. <Auswahl- / Generierungsphase>
Fertige dich gegenseitig und beende, wenn HP 0 erreicht.
- Details sind in den folgenden Spielregeln beschrieben.
2. Beziehung zur Objektorientierung
- Generieren Sie den ausgewählten Drachen mit sich selbst und dem Feind mithilfe der Konstruktionszeichnung (= Klasse) = objektorientierte Instanziierung
- Das Ergebnis der Verwendung der Technik (Verringerung der HP) = Verwendung von Getter und Setter finden Sie unter / aktualisieren Sie den Wert im Objekt
2. Inhalt
1. Zuallererst
1. Spielregeln
-In der Auswahl- / Generierungsphase und der Kampfphase wird die mit dem Drachen anzuwendende Technik durch Benutzerauswahl bestimmt.
-Wählen Sie einen Drachen für sich und einen für den Feind <Auswahl- / Generierungsphase>
・ Drei Drachen mit unterschiedlichen Namen, HP und Techniken stehen zur Verfügung.
・ Jeder Drache hat 3 Techniken.
・ Befiehl dem Drachen, eine Schlacht
2. Ordnerstruktur
├── DragonMain.java ├── bean │ ├── ButtleDragon.java │ ├── Action.java │ └── SimpleDragon.java └── util ├── buttle │ ├── ButtleContents.java │ ├── ButtleMain.java │ └── RandomEnemyChoice.java └── choice └── ChoiceDragon.java
Instanziieren (generieren) Sie einen Drachen mithilfe der Klassen im Bean-Ordner. In der Auswahl- / Generierungsphase Wählen Sie in der Phase "Auswahl" SimpleDragon.java aus ButtDragon.java und Action.java werden in der "Generierungs" -Stufe verwendet.
2. Gesamtverarbeitung
↓ Hauptmethode
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("Starte eine Drachenschlacht");
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
try{
//Holen Sie sich eine Liste der Drachen
ChoiceDragon.searchDrageon();
//Wähle den Drachen aus, den du erschaffen möchtest
String choiceMyDragon = null;
String choiceOpponentDragon = null;
System.out.print("Bitte wählen Sie den Drachen, den Sie verwenden, anhand der ID aus>");
choiceMyDragon = br.readLine();
System.out.print("Bitte wählen Sie den Drachen, den Ihr Gegner verwenden soll, anhand seiner ID aus>");
choiceOpponentDragon = br.readLine();
//Drachengeneration
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("Ich habe einen schwerwiegenden Fehler erhalten");
}
}
}
ChoiceDragon.searchDrageon () ;: Liste der Drachen abrufen ChoiceDragon.makeDragon ()) ;: Generiere dich und feindliche Drachen und speichere sie in "myDragon" bzw. "oppoDragon". ButtleMain.doButtle () ;: Beginne den Kampf mit "myDragon" und "oppoDragon" als Argumenten
3. Auswahl- / Generierungsphase
Holen Sie sich eine Liste der Drachen, generieren Sie den ausgewählten Drachen und verknüpfen Sie die Technik mit dem Drachen
・ Klasse (Bohne)
↓ Wird verwendet, um einen einfachen Drachen zu erzeugen. Wird verwendet, um eine Liste von IDs und Drachennamen anzuzeigen, wenn diese ohne Geschick ausgewählt werden
SimpleDragon.java
package dragon.bean;
public class SimpleDragon {
int dragonId;
String dragonName;
int hitPoint;
//Einfacher Drachenkonstrukteur
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;
}
}
↓ Wird verwendet, um einen Kampfdrachen zu erstellen. Erben Sie die einfache Drachenklasse und verfügen Sie über HP und Fähigkeiten, auf die Sie sich während des Kampfes beziehen können.
ButtleDragon.java
package dragon.bean;
package dragon.bean;
import java.util.Map;
/**
*
*Drachenklasse während des Kampfes verwendet
*Wird verwendet, um die HP zu erhöhen oder zu verringern
*/
public class ButtleDragon extends SimpleDragon {
int buttleHp;
int action1;
int action2;
int action3;
Map<Integer, Action> actions;
/**
*Kampfdrachenkonstrukteur. Der Anfangswert von HP für den Kampf ist 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;
}
}
↓ Zum Erstellen von Techniken.
Action.java
package dragon.bean;
/*
*Technikklasse während des Kampfes verwendet
*/
public class Action {
int actionId;
String actionName;
int power;
int actionPoint;
int buttleActionPoint;
/**
*Technikkonstruktor.
*MP im Kampf[buttleActionPoint]Zum Erhöhen oder Verringern verwenden
*
* @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;
}
}
・ Auserlesener Drache ↓ Holen Sie sich eine Liste, um einen Drachen auszuwählen und einen ausgewählten Drachen zu generieren. Es ist auch hier, um dem Drachen eine Fähigkeit zu geben, nachdem er erzeugt wurde.
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 {
/**
*Wähle einen Drachen aus
** Es kann gut sein, diesen Teil aus der Datenbank zu erhalten
* @throws Exception
*/
public static void searchDrageon(){
//Erstellen Sie einen Drachen, der hier ausgewählt werden kann
SimpleDragon dragon1 = new SimpleDragon(1,"Weißer Drache", 20);
SimpleDragon dragon2 = new SimpleDragon(2,"blauer Drache", 25);
SimpleDragon dragon3 = new SimpleDragon(3,"roter Drache", 15);
//Listen Sie die erstellten Drachen auf
List<SimpleDragon> choiceDragonList = new ArrayList<SimpleDragon>();
choiceDragonList.add(dragon1);
choiceDragonList.add(dragon2);
choiceDragonList.add(dragon3);
//Liste anzeigen
System.out.println("ID:\t Drachenname");
for(SimpleDragon list : choiceDragonList){
System.out.println(list.getDragonId()+":\t"+list.getDragonName());
}
}
/**
*Erstellen Sie einen Drachen aus der Liste basierend auf dem ausgewählten Wert
*Geben Sie ihnen danach eine Fertigkeit
*/
public static ButtleDragon makeDragon(int DragonId){
//Erstelle einen Drachen
ButtleDragon buttleDragon = makeButtleDragon(DragonId);
//Holen Sie sich die Trickliste
Map<Integer, Action> buttleActionMap = makeButtleAction() ;
//Gib dem Drachen die Fähigkeit
Map<Integer, Action> buttleDragonActionMap = new HashMap<>();
//Holen Sie sich die ID der Technik, die der Drache hat
int actionId_1 = buttleDragon.getAction1();
int actionId_2 = buttleDragon.getAction2();
int actionId_3 = buttleDragon.getAction3();
//Holen Sie sich die Fertigkeit des Drachen aus der Fertigkeitsliste
Action action1 = buttleActionMap.get(actionId_1);
Action action2 = buttleActionMap.get(actionId_2);
Action action3 = buttleActionMap.get(actionId_3);
//Verbinde Drachen und Techniken
buttleDragonActionMap.put(1, action1);
buttleDragonActionMap.put(2, action2);
buttleDragonActionMap.put(3, action3);
buttleDragon.setActions(buttleDragonActionMap);
return buttleDragon;
}
/**
*Erstelle einen Drachen und gib jedem eine ID in der Fertigkeitsliste.
** Ich denke, es ist besser, DB hier zu verwenden.
* @param dragonId
* @return
*/
private static ButtleDragon makeButtleDragon(int dragonId) {
ButtleDragon makeDragon = null;
//Erstellen Sie je nach Argument unterschiedliche Drachen
switch(dragonId) {
case 1:
//Die Argumente für den Konstrukteur des Kampfdrachen sind ID, Drachenname und HP.
ButtleDragon dragon1 = new ButtleDragon(1,"Weißer Drache", 20);
//Stellen Sie die Technik auf den Kampfdrachen ein
dragon1.setAction1(1);
dragon1.setAction2(2);
dragon1.setAction3(5);
makeDragon = dragon1;
break;
case 2:
ButtleDragon dragon2 = new ButtleDragon(2,"blauer Drache", 25);
dragon2.setAction1(1);
dragon2.setAction2(3);
dragon2.setAction3(5);
makeDragon = dragon2;
break;
case 3:
ButtleDragon dragon3 = new ButtleDragon(3,"roter Drache", 15);
dragon3.setAction1(1);
dragon3.setAction2(4);
dragon3.setAction3(5);
makeDragon = dragon3;
break;
}
return makeDragon;
}
/**
*Holen Sie sich die Technikliste.
** Ich denke, es ist besser, DB hier zu verwenden.
* @return
*/
private static Map<Integer, Action> makeButtleAction() {
//Deklarieren Sie eine Liste der Techniken
Action action1 = new Action(1,"Attacke\t", 2, 20);
Action action2 = new Action(2,"Weißer Atem", 4, 2);
Action action3 = new Action(3,"Blauer Atem", 3, 2);
Action action4 = new Action(4,"Roter Atem", 5, 2);
Action action5 = new Action(5,"Starker Angriff", 6, 1);
//Packe die Technikliste auf die Karte
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. Holen Sie sich eine Liste der Drachen
Führen Sie dies in der ChoiceDragon.searchDrageon-Methode aus. SimpleDragon dragon1 = new SimpleDragon () erstellt jeweils Drachen. Generieren Sie einen Drachen vom Typ SimpleDragon mit dem Konstruktor und der Speicher-ID, dem Namen bzw. der HP. Speichern Sie alle von choiceDragonList generierten Drachen in der Liste und zeigen Sie sie alle an.
2. Einen Drachen für den Kampf erzeugen
ChoiceDragon.make Machen Sie es in der Dragon-Methode. 1: Generation eines Drachen für den Kampf Generiert aus ButtleDragon (eine Klasse, die SimpleDragon die ID der zu verwendenden Technik und die HP für den Kampf (die bei Angriffen abnimmt) hinzufügt) 2: Erstellen Sie eine Liste mit Techniken Generieren Sie ID, Techniknamen, Leistung und MP als Aktion und generieren Sie eine "Techniklisten" -Karte, die ID und Aktion verknüpft. 3: Verbinde den erzeugten Drachen und die Technik Da dem Drachen die ID der zu verwendenden Technik gegeben wird, wird die zu ihm passende Technik aus der Technikliste erfasst und gespeichert.
↓ Bild
Durch Ausführen des gleichen Inhalts mit dem feindlichen Drachen werden 2 "Drachen mit Fähigkeiten" erzeugt
4. Kampfphase
↓ Die Hauptkampfmethode. Setzen Sie Ihren Zug und den Ihres Gegners fort, bis eine der HP ausgeht.
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 {
/**
*Buttles Grundfluss
* @throws IOException
*/
public static void doButtle(ButtleDragon myDragon, ButtleDragon oppoDragon) throws IOException{
boolean enemyDownFlg = false; //Feststellen, ob ein Feind gefallen ist
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("Starte die Drachenschlacht.");
do{
ButtleContents.outputActionList(myDragon);
String str = null;
str = br.readLine();
System.out.println("Dieser Angriff!");
ButtleContents.useAction(myDragon.getActions().get(Integer.parseInt(str)), myDragon, oppoDragon);
if(oppoDragon.getButtleHp() == 0){
enemyDownFlg = true;
break;
}
System.out.println("Angriff des Gegners!");
RandomEnemyChoice.randomChoice(oppoDragon,myDragon);
}while(myDragon.getButtleHp() != 0);
ButtleContents.outputResult(enemyDownFlg);
System.out.println("Der Kampf ist vorbei");
}
}
↓ Der Fluss, wenn Sie eine Technik ausführen. Zeigen Sie Text an, reduzieren Sie die HP Ihres Feindes und reduzieren Sie die MP Ihrer Fähigkeiten.
ButtleContents.java
package dragon.util.buttle;
import dragon.bean.Action;
import dragon.bean.ButtleDragon;
public class ButtleContents {
/**
*Grundlegender Technikfluss
* @param offenceAction:Angreifertechnik
* @param offenceDragon:Angreifender Drache
* @param defenceDragon:Drache verteidigen
*/
public static void useAction(Action offenceAction,ButtleDragon offenceDragon, ButtleDragon defenceDragon){
int nokoriMP = offenceAction.getActionPoint(); //Aktueller MP
//Anzeige der Angriffstechnik
String actionName = offenceAction.getActionName().replaceAll("\t", "");//Entfernen Sie das im Techniknamen enthaltene Tabulatortrennzeichen
System.out.println(offenceDragon.getDragonName()+"von"+actionName+"!!");
//Angriffstechnik
Attack(offenceAction,offenceDragon,defenceDragon);
//MP-Reduktion
nokoriMP--;
offenceAction.setButtleActionPoint(nokoriMP);
}
/**
*Fluss der Angriffstechnik
* @param offenceAction
* @param offenceDragon
* @param defenceDragon
*/
public static void Attack(Action offenceAction,ButtleDragon offenceDragon, ButtleDragon defenceDragon){
int damage = offenceAction.getPower(); //Kraft der Technik
int defenceDragonNokoriHp = 0; //HP Menge des verteidigenden Drachen mit Buttle aktualisiert
//Berechnung der verbleibenden HP des Gegners
defenceDragonNokoriHp = defenceDragon.getButtleHp() - damage;
if(defenceDragonNokoriHp <= 0){
defenceDragon.setButtleHp(0);
}else{
defenceDragon.setButtleHp(defenceDragonNokoriHp);
}
System.out.println(defenceDragon.getDragonName()+"Ist"+damage+"Verbleibende körperliche Stärke aufgrund von Schäden"+defenceDragon.getButtleHp()+"Wurde!");
}
/**
*Zeigen Sie die Technikliste an
* @param myDragon
*/
public static void outputActionList(ButtleDragon myDragon){
System.out.println("\n Befehl\t\t Name der Technik\t\t\t\t verbleibende Punkte");
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("Bitte wählen Sie eine Technik>");
}
/**
*Zeigen Sie das Ergebnis eines Sieges oder einer Niederlage an
* @param enemyDownFlg
*/
public static void outputResult(boolean enemyDownFlg){
if(enemyDownFlg){
System.out.println("\n gewonnen!");
}else{
System.out.println("\n Ich habe verloren ...");
}
}
}
↓ Der Prozess der zufälligen Entscheidung über die vom Feind zu liefernde Technik und der Lieferung der Technik
RandomEnemyChoice.java
package dragon.util.buttle;
import dragon.bean.ButtleDragon;
/**
*Eine Klasse, die zufällige Bewegungen auf der feindlichen Seite angibt
*
*/
public class RandomEnemyChoice {
/**
*Generiere zufällig Tricks und führe sie aus
* @param oppoDragon
* @param myDragon
*/
public static void randomChoice(ButtleDragon oppoDragon, ButtleDragon myDragon){
//Wählen Sie eine Technik aus, die nach dem Zufallsprinzip gespielt werden soll
int randomChoice = 0;
randomChoice = (int)(Math.random()*3 + 1);
//Führen Sie eine Technik durch
ButtleContents.useAction(oppoDragon.getActions().get(randomChoice),oppoDragon, myDragon);
}
}
1. Prozessablauf (ButtleMain.java)
Setzen Sie den Kampf fort, bis der Feind zusammenbricht (oppoDragon.getButtleHp () == 0) oder Sie zusammenbrechen (myDragon.getButtleHp () == 0). Übergeben Sie den Eingabewert für Ihren eigenen Angriff an die ButtleContents.useAction-Methode und den Zufallswert zur Verarbeitung an die ButtleContents.useAction-Methode in der RandomEnemyChoice.randomChoice-Methode.
Fahren Sie mit der Verarbeitung fort, während Sie die vom instanziierten Drachen gehaltenen Werte aktualisieren (Getter) und referenzieren (Setter).
2. Verarbeitung bei Auswahl einer Technik (ButtleContents.useAction)
1. Methodenbeschreibung
Diese Methode verwendet drei Argumente: "OffenceAction / OfferDragon / DefenseDragon". Wenn Ihr Drache in diesem Spiel mit einer Technik angreift, wird der Drache des Gegners zum verteidigenden Drachen (selbst wenn die angreifende Seite ein Feind ist, wird die verteidigende Seite zu Ihrem eigenen Drachen). Wenn Sie angreifen und der Gegner angreift, tauschen Sie einfach den Drachen aus, der an das 2. und 3. Argument übergeben wurde, und der Prozess, dass "die angreifende Seite die verteidigende Seite beschädigt hat", ist die angreifende Seite = Sie selbst, die angreifende Seite = Gilt auch für Feinde. Bei der Eingabe dieser Methode wird die vom Angreifer ausgewählte Technik als Argument übergeben (offenceAction).
2. Prozessablauf bei der Auswahl einer Technik
1: Nachrichtenanzeige 2: Angriffsverarbeitung (ButtleContents.Attack) Erhalten Sie die Kraft der Technik aus der Technik und berechnen Sie die verbleibenden HP des Verteidigers. Stellen Sie dann den berechneten Wert auf die Butttle HP des Verteidigers ein. 3: MP-Abnahme Reduzieren Sie den MP der vom Angreifer verwendeten Technik
3. Schließlich
Danke, dass Sie so weit gelesen haben! Wir würden uns freuen, wenn Sie sich vorstellen könnten, dass ein Drache erstellt / bewegt (= instanziiert / verwendet) wird, indem Sie den Inhalt lesen oder tatsächlich erstellen.
Recommended Posts