From 11216672e210c655f0edf4c81274e9d2eb981c6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bocz=C3=A1n=20Tam=C3=A1s?= Date: Mon, 24 Mar 2014 00:57:22 +0100 Subject: [PATCH] =?UTF-8?q?V=C3=A9gleges=20Szkeleton?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Barricade.java | 14 +- Construct.java | 22 +- ConstructManager.java | 49 ++- Dwarf.java | 9 + Elf.java | 8 + EndTile.java | 6 +- Enemy.java | 81 +++-- EnemyGenerator.java | 14 +- Geometry.java | 11 +- Hobbit.java | 8 + Human.java | 8 + MagicGem.java | 25 +- Mana.java | 35 +- PathGenerator.java | 24 +- PathTile.java | 20 +- Tester.java | 739 ++++++++++++++++++++++++------------------ Tile.java | 14 +- Tower.java | 24 +- Updater.java | 197 +++++++---- 19 files changed, 830 insertions(+), 478 deletions(-) diff --git a/Barricade.java b/Barricade.java index 76ae895..18606dc 100644 --- a/Barricade.java +++ b/Barricade.java @@ -1,13 +1,23 @@ public class Barricade extends Construct { - private Object speedModifier; + private int speedModifier; + /** + * visszater a a lassitas mertekevel + * @return speedModifier + */ public int getSpeedModifier() { - throw new UnsupportedOperationException(); + System.out.println("--> Barricade.getSpeedModifier()"); + System.out.println("<-- modifier"); + return speedModifier; } + /** + * A Barricade konstruktora + */ public Barricade() { System.out.println("--> Barricade()"); type = "Barricade"; //Beállítjuk a saját típusát + speedModifier = 2 ; } } \ No newline at end of file diff --git a/Construct.java b/Construct.java index 37d85d3..0eef652 100644 --- a/Construct.java +++ b/Construct.java @@ -1,13 +1,23 @@ public class Construct { protected String type; - public Updater unnamed_Updater_; - public MagicGem _construct; - + protected MagicGem gem; + + /** + * Épület típusával tér vissza + * @return a típus amivel visszatér + */ public String getType() { - return this.type; + System.out.println("--> Construct.getType()");// + System.out.println("<-- towerType");// + return this.type;// } - + + /** + * beállítja a gem attribútumot a kapott értékre + * @param gem - a kapott érték + */ public void setMagicGem(MagicGem gem) { - throw new UnsupportedOperationException(); + System.out.println("--> Construct.setMagicGem("+gem+")");// + this.gem = gem;// } } \ No newline at end of file diff --git a/ConstructManager.java b/ConstructManager.java index c582f13..456f459 100644 --- a/ConstructManager.java +++ b/ConstructManager.java @@ -14,11 +14,54 @@ public ConstructManager (Updater updater){ this.updater = updater; //Beállítjuk az updater attribútumot } - public void build(String type, Tile center) { - throw new UnsupportedOperationException(); + /** + * egy épület létrehozása + * @param type - az épület típusa, ami alapján tudja a függvény, mit hozzon létre + * @param location - egy csempe, ahova az adott épülettípust elhelyezzük + */ + public void build(String type, Tile location) { + System.out.println("--> ConstructManager.build("+type+", "+location+")"); + int cost = 20; + if (mana.hasEnough(cost)) { + location.getType(); + Construct construct = null;// + if(type == "Tower") {// + construct = new Tower(); // + }// + if(type == "Barricade") {// + construct = new Barricade();// + }// + location.addConstruct(construct); + mana.decrease(cost); + updater.addConstruct(construct); + } } + /** + * Az adott épület fejlesztése varázskÅ‘ alapján + * @param type - ennek megfelelÅ‘en fejleszti az adott épületet a varázskÅ‘vel + * @param construct az épület, amelyen a fejlesztést véghezvisszük + */ public void upgrade(String type, Construct construct) { - throw new UnsupportedOperationException(); + System.out.println("--> ConstructManager.upgrade(gemType, "+construct+")"); + int cost = 20; + if (mana.hasEnough(cost)) { + if(construct.getType() == "Tower"){ + MagicGem gem = new MagicGem(); + construct.setMagicGem(gem); + if(type == "Range") { + ((Tower)construct).setRange(20); + } + } + mana.decrease(cost); + } + } + + /** + * A mana beállítása + * @param mana - az adott mana, amit beállítunk + */ + public void setMana(Mana mana) { + this.mana = mana; } } \ No newline at end of file diff --git a/Dwarf.java b/Dwarf.java index ecd3c7e..f97c291 100644 --- a/Dwarf.java +++ b/Dwarf.java @@ -1,2 +1,11 @@ public class Dwarf extends Enemy { + + /** + * A dwarf konstruktora, beállítsa az enemy típusát 'Dwarf'-ra + */ + + public Dwarf() { + System.out.println("--> Dwarf() "); + this.type = "Dwarf"; + } } \ No newline at end of file diff --git a/Elf.java b/Elf.java index aa3139c..3bbc0be 100644 --- a/Elf.java +++ b/Elf.java @@ -1,2 +1,10 @@ public class Elf extends Enemy { + + /** + * Az Elf konstruktora, amely beállítja az Enemy típusát 'Elf' -re + */ + public Elf() { + System.out.println("--> <> "); + this.type = "Elf"; + } } \ No newline at end of file diff --git a/EndTile.java b/EndTile.java index c24da56..89cc6a8 100644 --- a/EndTile.java +++ b/EndTile.java @@ -13,11 +13,13 @@ public EndTile (Geometry geometry) { this.geometry = geometry; //Beállítjuk az Å‘t tároló Geometry-re mutató referenciát type = "EndTile"; //Beállítjuk a saját típusát } - + /** + * Az adott csempé ellenség listájához hozzáad egy ellenséget, amennyiben az szükséges + */ public void addEnemy(Enemy enemy) { System.out.println("--> EndTile.addEnemy(" + enemy +")"); enemies.add(enemy); - System.out.println("<--"); + //System.out.println("<--"); } } diff --git a/Enemy.java b/Enemy.java index c29c255..e67734b 100644 --- a/Enemy.java +++ b/Enemy.java @@ -5,9 +5,6 @@ public class Enemy { protected String type; protected int moveDelay; protected Tile currentTile; - public PathTile unnamed_PathTile_; - public EndTile unnamed_EndTile_; - public Updater unnamed_Updater_; /** @@ -15,19 +12,21 @@ public class Enemy { * @param value ennyivel sérül */ public void damage(int value) { - System.out.println("--> Enemy.damage(" + value +")"); + System.out.println("--> Enemy.damage(damage)"); if (value >= health) health = 0; else health -= value; - System.out.println("<--"); } /** * Csökkenti a moveDelay attribútum értékét egyel. */ public void decreaseMoveDelay() { - System.out.println("--> Enemy.decreaseMoveDelay"); - System.out.println("<--"); + System.out.println("--> Enemy.decreaseMoveDelay()"); + //System.out.println("<--"); + if(moveDelay!=0){ + moveDelay--; + } } /** @@ -35,7 +34,7 @@ public void decreaseMoveDelay() { */ public int getHealth() { System.out.println("--> Enemy.getHealth()"); - System.out.println("<--" + health); + System.out.println("<-- health"); return this.health; } @@ -44,7 +43,7 @@ public int getHealth() { */ public int getManaValue() { System.out.println("--> Enemy.getManaValue()"); - System.out.println("<--" + manaValue); + System.out.println("<-- reward"); return this.manaValue; } @@ -53,11 +52,17 @@ public int getManaValue() { */ public Tile getTile() { System.out.println("--> Enemy.getTile()"); - System.out.println("<--" + currentTile); + System.out.println("<-- tile"); return this.currentTile; } - + + /** + * Az ellenség típusát adja vissza + * @return maga a típus + */ public String getType() { + System.out.println("--> Enemy.getType()"); + System.out.println("<-- type"); return this.type; } @@ -69,40 +74,48 @@ public boolean move() { System.out.println("--> Enemy.move()"); decreaseMoveDelay(); - String tileType = currentTile.getType(); - - //FIXME BUG: ez bajlehet. itt elÅ‘bbre kellett hoznom a getType-ot, mert csak a PathTile-nak van getNextTile-ja és removeEnemy()-je, máson nem lehet meghívni - if (tileType == "PathTile") - { + if(moveDelay==0){ Tile nextTile = ((PathTile) currentTile).getNextTile(); nextTile.addEnemy(this); - ((PathTile) currentTile).removeEnemy(this); currentTile = nextTile; + + String tileType = currentTile.getType(); + if (tileType == "EndTile") + { + //vesztés, return true; + System.out.println("<-- reachedEnd"); + return true ; + } + + + Construct constructOnTile = currentTile.getConstruct(); + if (constructOnTile != null) + { + + int modifier = ((Barricade)(constructOnTile)).getSpeedModifier(); + setMoveDelay(modifier); + } + else + setMoveDelay(0); } - else if (tileType == "EndTile") - { - //TODO TileType==végzethegye -> vesztés, return true; - } - - Construct constructOnTile = currentTile.getConstruct(); - //FIXME BUG: itt lekérjük a típusát, hogy tudjuk, hogy Barricade-e, ez lemaradt az 5. szekv diagramról. - if (constructOnTile != null && constructOnTile.getType() == "Barricade") - { - //TODO barrikádra lépett. - } - else - setMoveDelay(0); - - //visszatérés lemaradt a szekvenciadiagramról - System.out.println("<-- false"); return false; + } /** * Beállítja a moveDelay-t a sebesség és a kapott modifier összegére. */ public void setMoveDelay(int delay) { - System.out.println("--> Enemy.setMoveDelay(" + delay + ")"); + System.out.println("--> Enemy.setMoveDelay(delay)"); + moveDelay = delay; + } + + /** + * Az ellenséghez hozzárendeli a csempét, amin tartózkodik + * @param tile - az adott csempe, amin az ellenség áll + */ + public void setTile(Tile tile){ + currentTile=tile; } } diff --git a/EnemyGenerator.java b/EnemyGenerator.java index efd3f02..d8a10d8 100644 --- a/EnemyGenerator.java +++ b/EnemyGenerator.java @@ -12,9 +12,16 @@ public EnemyGenerator (PathGenerator pathGenerator){ System.out.println("--> EnemyGenerator( " +pathGenerator+ " )"); this.pathGenerator = pathGenerator; } - - public void generateEnemies() { - throw new UnsupportedOperationException(); + /** + * Ellenségek létrehozására szolgáló függvény + * @return visszatér az adott ellenséggel + */ + public Enemy generateEnemies() { + System.out.println("--> EnemyGenerator.generateEnemies() "); + Dwarf Tyrion = new Dwarf(); + pathGenerator.start(Tyrion); + System.out.println("<-- Enemy"); + return Tyrion; } /** @@ -23,7 +30,6 @@ public void generateEnemies() { public Boolean isLastEnemyGenerated() { System.out.println("--> EnemyGenerator.isLastEnemyGenerated()"); System.out.println("<--"); - //TODO ide mit írjunk? a 10. tesztben elvileg true-val tér vissza, de megoldható return true; } } \ No newline at end of file diff --git a/Geometry.java b/Geometry.java index eb42c5e..78b4515 100644 --- a/Geometry.java +++ b/Geometry.java @@ -18,12 +18,16 @@ public Geometry() { * @return azok a csempék, amik elérhetÅ‘ek az adott pályán a megadott paraméterekkel */ public ArrayList getNearby(Tile center, int range) { - System.out.println("-->getNearby(" + center + "," + range + ")"); + System.out.println("--> Geometry.getNearby(" + center + "," + range + ")"); // teszteléshez az utolsó cellát adja vissza (ezen álljon az ellenség, ha lÅ‘ni akarunk rá) + + // a teszt target a tiles utolso eleme PathTile tesztTarget = (PathTile)tiles.get(tiles.size()-1); ArrayList targets = new ArrayList(); + // a targets lista az teszt target egz listaba agyazva targets.add(tesztTarget); - System.out.println("<-- " + targets); + //System.out.println("<-- " + targets); + System.out.println("<-- tilesInRange"); return targets; } @@ -32,11 +36,12 @@ public ArrayList getNearby(Tile center, int range) { * @return Az összes csempe */ public ArrayList getTiles() { - System.out.println("-->getTiles()"); + System.out.println("--> getTiles()"); System.out.println("<-- "+tiles); return tiles; //Visszaadja az összes csempét } + public ArrayList getTilesList() { return tiles; } diff --git a/Hobbit.java b/Hobbit.java index cabb070..fbade96 100644 --- a/Hobbit.java +++ b/Hobbit.java @@ -1,2 +1,10 @@ public class Hobbit extends Enemy { + + /** + * Hobbit osztaly konstruktora. + */ + public Hobbit() { + System.out.println("--> <> Hobbit"); + this.type = "Hobbit"; + } } \ No newline at end of file diff --git a/Human.java b/Human.java index 68e7401..26b158f 100644 --- a/Human.java +++ b/Human.java @@ -1,2 +1,10 @@ public class Human extends Enemy { + + /** + * Human osztály konstruktora. + */ + public Human() { + System.out.println("--> <> "); + this.type = "Human"; + } } \ No newline at end of file diff --git a/MagicGem.java b/MagicGem.java index d385935..d936b19 100644 --- a/MagicGem.java +++ b/MagicGem.java @@ -1,8 +1,25 @@ public class MagicGem { private String type; - public Construct _gem; - - public int getDamageBonus() { - throw new UnsupportedOperationException(); + public Construct construct; + + /** + * MagicGem konstruktora. + */ + public MagicGem () + { + System.out.println("--> MagicGem()"); + type = "MagicGem"; + } + + /** + * Visszaadja a bonusz sebzes erteket amit a MagicGem + * tud kiosztani a type altal deffinialt ellenseg ellen + * + * @param type az ellenseget tipusat adja meg + */ + public int getDamageBonus(String type) { + System.out.println("--> MagicGem.getDamageBonus(type)"); + System.out.println("<-- amount"); + return 10; } } \ No newline at end of file diff --git a/Mana.java b/Mana.java index 9f39b01..1c8f0a7 100644 --- a/Mana.java +++ b/Mana.java @@ -1,29 +1,42 @@ public class Mana { private int mana; - public ConstructManager unnamed_ConstructManager_; - public Updater unnamed_Updater_; - public void decrease(int value) { - //throw new UnsupportedOperationException(); + + /** + * A mana erteket csokknti a parameter altal + * meghatarozott mennyiseggel + * @param cost ezzel az ertekkel kel csokkenteni a mana erteket + */ + public void decrease(int cost) { + System.out.println("--> Mana.decrease(cost)"); } - public Boolean hasEnought(int value) { - //throw new UnsupportedOperationException(); - System.out.println("--> Mana.hasEnought(" + value + ")"); - System.out.println("<--" + (value <= mana)); + /** + * Lekerdezheto hogy a parameterkent kapott value erteknel nagyobb a mana erteke + * + * @param value ezzel az ertekkel tortenik az ossehasonlitas + * @return true ha van eleg mana. + */ + public Boolean hasEnough(int value) { + System.out.println("--> Mana.hasEnough(cost)"); + System.out.println("<-- Boolean"); return (value <= mana); } + /** + * Mana erteket lehet beallitani altala + * @param value ezzel az ertekkel lesz egyenlo a mana + */ public void setMana(int value) { mana = value; } /** - * Hozzáadja a jelenlegi varázserÅ‘höz a kapott értéket + * Hozzaadja a jelenlegi varazserohoz a kapott erteket * @param value ezzel inkrementál */ public void increase(int value) { - System.out.println("--> Mana.increase(" + value + ")"); - System.out.println("<--"); + System.out.println("--> Mana.increase(value)"); + //System.out.println("<--"); } } diff --git a/PathGenerator.java b/PathGenerator.java index ce19b92..c780ad6 100644 --- a/PathGenerator.java +++ b/PathGenerator.java @@ -4,16 +4,32 @@ public class PathGenerator { private ArrayList pathStarts = new ArrayList(); /** - * A PathGenerator osztály konstruktora. - * Létrehozza a kapott geometry segítségével az útvonalakat, melyeken ellenségeket indíthat el. - * @param geometry Pályát reprezentáló változó, melyen keresztül elérjük a csempéket + * A PathGenerator osztaly konstruktora. + * Letrehozza a kapott geometry segitsegevel az utvonalakat, melyeken ellensegeket indithat el. + * @param geometry Palyat reprezentáló változó, melyen keresztül elérjük a csempeket */ public PathGenerator (Geometry geometry){ System.out.println("--> PathGenerator( " +geometry+ " )"); geometry.getTiles(); //Elkérjük az összes csempét } + + /** + * A parameterkent kapott enemy-t rarakja valamelyik kezdo csempere + * @param enemy ezt a peldanyt rakja ra a csempere + */ public void start(Enemy enemy) { - throw new UnsupportedOperationException(); + System.out.println("--> PathGenerator.start(Enemy)"); + pathStarts.get(0).addEnemy(enemy); + System.out.println("<--"); + } + + + /** + * A kezdo csempek PathGenerator-ba regisztralasat vegzi + * @param pathTile ez a csempe amelyet beregisztral + */ + public void add(PathTile pathTile) { + pathStarts.add(pathTile); } } \ No newline at end of file diff --git a/PathTile.java b/PathTile.java index b09fef5..b62296f 100644 --- a/PathTile.java +++ b/PathTile.java @@ -1,7 +1,7 @@ import java.util.ArrayList; public class PathTile extends Tile { - private PathTile nextTile; + private Tile nextTile; private ArrayList enemies = new ArrayList(); /** @@ -9,7 +9,7 @@ public class PathTile extends Tile { * Beállítja típusát, és a Geometry-re mutató referenciáját. * @param geometry Az a Geometry, ami Å‘t létrehozta (és tárolja) */ - public PathTile (Geometry geometry) + public PathTile(Geometry geometry) { System.out.println("--> PathTile( "+geometry+" )"); this.geometry = geometry; //Beállítjuk az Å‘t tároló Geometry-re mutató referenciát @@ -21,8 +21,9 @@ public PathTile (Geometry geometry) * @return Az úton lévÅ‘ ellenség */ public Enemy getEnemy() { - System.out.println("--> PathTile.getEnemy()" + this); - System.out.println("<-- " + enemies.get(0)); + System.out.println("--> PathTile.getEnemy()"); + //System.out.println("<-- " + enemies.get(0)); + System.out.println("<-- Enemy"); return enemies.get(0); } @@ -32,11 +33,15 @@ public Enemy getEnemy() { */ public Tile getNextTile() { System.out.println("--> PathTile.getNextTile()"); - System.out.println("<-- " + nextTile); + System.out.println("<-- nextTile"); return nextTile; } - public void setNextTile(PathTile path) { + /** + * Beállitja a nextTile attributum erteket + * @param path ez lesz a nextTile uj erteke + */ + public void setNextTile(Tile path) { nextTile = path; } @@ -46,7 +51,6 @@ public void setNextTile(PathTile path) { */ public void removeEnemy(Enemy enemy) { System.out.println("--> PathTile.RemoveEnemy(" + enemy + ")"); - System.out.println("<-- "); enemies.remove(enemy); } @@ -57,7 +61,7 @@ public void removeEnemy(Enemy enemy) { */ public void addEnemy(Enemy enemy) { System.out.println("--> PathTile.addEnemy(" + enemy +")"); - enemies.add(enemy); System.out.println("<--"); + enemies.add(enemy); } } \ No newline at end of file diff --git a/Tester.java b/Tester.java index a07d3ec..2805080 100644 --- a/Tester.java +++ b/Tester.java @@ -1,318 +1,421 @@ - -public class Tester { - - public static void test1_init() - { - updater = new Updater(); - } - - public static void test1() - { - geometry = new Geometry(); - for(int i = 0; i < 3; i++){ - geometry.getTilesList().add(new FieldTile(geometry)); //Létrehozunk 3 csempét, melyekre tornyokat lehet építeni - geometry.getTilesList().add(new PathTile(geometry)); //Létrehozunk 3 útcsempét - } - geometry.getTilesList().add(new EndTile(geometry)); //Létrehozzuk a végzet hegyét - PathGenerator pathGenerator = new PathGenerator(geometry); - enemyGenerator = new EnemyGenerator(pathGenerator); - new ConstructManager(updater); - } - - public static void test2_init() { - updater = new Updater(); - geometry = new Geometry(); - enemyGenerator = new EnemyGenerator(pathGenerator); - pathGenerator = new PathGenerator(geometry); - PathTile currentTile = new PathTile(geometry); - } - - public static void test2() { - - } - - public static void test3_init() { - updater = new Updater(); - Hobbit frodo = new Hobbit(); - updater.addEnemy(frodo); - PathTile currentTile = new PathTile(geometry); - PathTile nextTile = new PathTile(geometry); - currentTile.setNextTile(nextTile); - } - - public static void test3() { - - } - - public static void test4_init() { - updater = new Updater(); - geometry = new Geometry(); - Hobbit frodo = new Hobbit(); - updater.addEnemy(frodo); - PathTile tile1 = new PathTile(geometry); - PathTile tile2 = new PathTile(geometry); - tile1.setNextTile(tile2); - PathTile tile3 = new PathTile(geometry); - tile2.setNextTile(tile3); - Barricade barricade = new Barricade(); - } - - public static void test4() { - - } - - - public static void test5_init() - { - updater = new Updater(); - geometry = new Geometry(); - constructManager = new ConstructManager(updater); - pathGenerator = new PathGenerator(geometry); - enemyGenerator = new EnemyGenerator(pathGenerator); - updater.setGeometry(geometry); - updater.setEnemyGenerator(enemyGenerator); - updater.setConstructManager(constructManager); - - //egy ellenség létrehozása - Elf Legolas = new Elf(); - Legolas.health = 10; - Legolas.manaValue = 5; - updater.getEnemies().add(Legolas); - - //egy torony létrehozása - Tower tower1 = new Tower(); - tower1.setDamage(20); - updater.getConstructs().add(tower1); - - // a 2 szükséges csempe elhelyezése (egyikrÅ‘l lépünk a másikra) - //geometry = new Geometry(); - PathTile start = new PathTile(geometry); - PathTile next = new PathTile(geometry); - FieldTile towerTile = new FieldTile(geometry); - geometry.getTiles().add(start); //TODO a tesztesethez kell, de a Geometry.tiles valójában private - geometry.getTiles().add(next); - start.setNextTile(next); //TODO a tesztesethez kell, de a PathTile.nextTile valójában private - - // ellenség és torony felhelyezése a csempére - Legolas.currentTile = start; - towerTile.constructOnTile = tower1; - tower1.setTowerLocation(towerTile); //TODO a tesztesethez kell, de a Tower.towerLocation valójában private - } - - public static void test5() - { - clearConsole(); - System.out.println("Teszt indítása"); - Enemy Legolas = updater.getEnemies().get(0); - Legolas.move(); - ((Tower)updater.getConstructs().get(0)).shoot(); - // if nélkül is ugyanúgy lefut, de így talán érthetÅ‘bb - if (Legolas.getHealth() <= 0 ) - { - int manaValue = Legolas.getManaValue(); - PathTile LegolasTile = (PathTile)Legolas.getTile(); //Castolhatunk, mert Legolas biztos PathTile-on áll (ha a Végzet hegyén állna, már vége lenne a játéknak). - LegolasTile.removeEnemy(Legolas); - updater.getMana().increase(manaValue); - } - - } - - public static void test6_init() { - updater = new Updater(); - geometry = new Geometry(); - Hobbit frodo = new Hobbit(); - Tower tower = new Tower(); - FieldTile towerLocation = new FieldTile(geometry); - PathTile tileInRange = new PathTile(geometry); - MagicGem gem = new MagicGem(); - - updater.addEnemy(frodo); - tower.setTowerLocation(towerLocation); - } - - public static void test6() { - - } - - public static void test7_init() { - updater = new Updater(); - ConstructManager constructManager = new ConstructManager(updater); - } - - public static void test7() { - - } - - public static void test8_init() - { - updater = new Updater(); - geometry = new Geometry(); - updater.setConstructManager(constructManager); - //PathTile location = new PathTile(geometry); - updater.getMana().setMana(30); - } - - public static void test8() - { - PathTile location = new PathTile(geometry); - - clearConsole(); - System.out.println("Teszt indítása"); - int cost = 20; - if (updater.getMana().hasEnought(cost)) { - location.getType(); - Barricade barricade = new Barricade(); - location.addConstruct(barricade); - updater.getMana().decrease(cost); - updater.addConstruct(barricade); - } - } - - public static void test9_init() { - updater = new Updater(); - geometry = new Geometry(); - ConstructManager constructManager = new ConstructManager(updater); - FieldTile towerLocation = new FieldTile(geometry); - } - - public static void test9() { - - } - - public static void test10_init() { - updater = new Updater(); - geometry = new Geometry(); - PathGenerator pathGenerator = new PathGenerator(geometry); - updater.enemyGenerator = new EnemyGenerator(pathGenerator); - Hobbit frodo = new Hobbit(); - frodo.health = 0; - frodo.manaValue = 30; - updater.addEnemy(frodo); - //Tower tower = new Tower(); - PathTile tileInRange = new PathTile(geometry); - tileInRange.addEnemy(frodo); - frodo.currentTile = tileInRange; - - } - - public static void test10() { - clearConsole(); - Hobbit Frodo = (Hobbit) updater.enemies.get(0); - // if nélkül is ugyanúgy lefut, de így talán érthetÅ‘bb - if (Frodo.getHealth() <= 0 ) - { - int manaValue = Frodo.getManaValue(); - PathTile FrodoTile = (PathTile)Frodo.getTile(); //Castolhatunk, mert az ellenség biztos PathTile-on áll (ha a Végzet hegyén állna, már vége lenne a játéknak). - // itt egy private method törli az updater enemies listájából a halott ellenséget - updater.enemies.clear(); - FrodoTile.removeEnemy(Frodo); - updater.getMana().increase(manaValue); - } - - // ha minden ellenség a pályára került, és nincs a pályán több ellenség, akkor nyert a játékos - boolean lastWave = updater.enemyGenerator.isLastEnemyGenerated(); - lastWave = true; //ebben a tesztben nincs több ellenség. - if (lastWave) - { - int numOfEnemies = updater.getNumOfEnemies(); //TODO ez private method lenne - if (numOfEnemies == 0) - updater.gameOver(true); - } - } - - - /** - * Törli a rendszer konzol tartalmát Windows, Unix és OSX rendszereken. Egyéb rendszerek konzolján lejjebb görget 30 sort. - */ - private static void clearConsole() - { - try - { - String os = System.getProperty("os.name"); - if (os.contains("Windows")) - { - Runtime.getRuntime().exec("cls"); - } - else - { - Runtime.getRuntime().exec("clear"); - } - } - catch (Exception exception) - { - for (int i = 0; i <30; i++) - System.out.println(); - } - } - - static Updater updater; - static Geometry geometry; - static ConstructManager constructManager; - static PathGenerator pathGenerator; - static EnemyGenerator enemyGenerator; - - public static void main(String[] args) - { - test10_init(); - System.out.println("!!!!!!!!!!!!!!!!"); - test10(); - - /* - switch(args[0]) { - case "1": - System.out.println(args[0]+". teszteset"); - test1_init(); - test1(); - break; - case "2": - System.out.println(args[0]+". teszteset"); - test2_init(); - test2(); - break; - case "3": - System.out.println(args[0]+". teszteset"); - test3_init(); - test3(); - break; - case "4": - System.out.println(args[0]+". teszteset"); - test4_init(); - test4(); - break; - case "5": - System.out.println(args[0]+". teszteset"); - test5_init(); - test5(); - break; - case "6": - System.out.println(args[0]+". teszteset"); - test6_init(); - test6(); - break; - case "7": - System.out.println(args[0]+". teszteset"); - test7_init(); - test7(); - break; - case "8": - System.out.println(args[0]+". teszteset"); - test8_init(); - test8(); - break; - case "9": - System.out.println(args[0]+". teszteset"); - test9_init(); - test9(); - break; - case "10": - System.out.println(args[0]+". teszteset"); - test10_init(); - test10(); - break; - default: - System.out.println("Buta vagy fiam"); - break; - } - */ - } -} + +public class Tester { + + /** + * else teszt eset inicializalasa + */ + public static void test1_init() + { + System.out.println("Inicializálás:"); + updater = new Updater(); + } + + /** + * elso teszt eset + * Jatak inditasa. + */ + public static void test1() + { + System.out.println(); + System.out.println("Teszteset:"); + updater.init(); + } + + /** + * masodik teszt eset inicializalasa + */ + public static void test2_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + + pathGenerator = new PathGenerator(geometry); + enemyGenerator = new EnemyGenerator(pathGenerator); + PathTile currentTile = new PathTile(geometry); + pathGenerator.add(currentTile); + } + + /** + * masodik teszt eset + * Letrehozunk egy ellenseget. + */ + public static void test2() { + System.out.println(); + System.out.println("Teszteset:"); + Enemy enemy = enemyGenerator.generateEnemies(); + updater.addEnemy(enemy); + } + + /** + * harmadik teszt eset inicializalasa + */ + public static void test3_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + Hobbit frodo = new Hobbit(); + updater.addEnemy(frodo); + PathTile currentTile = new PathTile(geometry); + EndTile nextTile = new EndTile(geometry); + currentTile.setNextTile(nextTile); + frodo.setTile(currentTile); + } + + /** + * harmadik teszt eset + * Egy ellenseg lep, majd mivel a Vegzet hegyere lepett, vesztunk. + */ + public static void test3() { + System.out.println(); + System.out.println("Teszteset:"); + boolean reachedEnd = (updater.enemies.get(0)).move(); + updater.gameOver(reachedEnd); + } + + + /** + * negyedik teszt eset inicializalasa + */ + public static void test4_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + + PathTile tile1 = new PathTile(geometry); + PathTile tile2 = new PathTile(geometry); + PathTile tile3 = new PathTile(geometry); + tile1.setNextTile(tile2); + tile2.setNextTile(tile3); + + Barricade barricade = new Barricade(); + tile2.addConstruct(barricade); + + Hobbit frodo = new Hobbit(); + updater.addEnemy(frodo); + frodo.setTile(tile1); + + + } + + /** + * negyedik teszt eset + * Egy ellenseg akadalyra lep, majd kesleltetve tovabblep. + */ + public static void test4() { + System.out.println(); + System.out.println("Teszteset:"); + (updater.enemies.get(0)).move(); + (updater.enemies.get(0)).move(); + (updater.enemies.get(0)).move(); + } + + /** + * otodik teszt eset inicializalasa + */ + public static void test5_init() + { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + constructManager = new ConstructManager(updater); + pathGenerator = new PathGenerator(geometry); + enemyGenerator = new EnemyGenerator(pathGenerator); + updater.setGeometry(geometry); + updater.setEnemyGenerator(enemyGenerator); + updater.setConstructManager(constructManager); + + //egy ellenség létrehozása + Elf Legolas = new Elf(); + Legolas.health = 10; + Legolas.manaValue = 5; + updater.getEnemies().add(Legolas); + + //egy torony létrehozása + Tower tower1 = new Tower(); + tower1.setDamage(20); + updater.getConstructs().add(tower1); + + // a 2 szükséges csempe elhelyezése (egyikrÅ‘l lépünk a másikra) + //geometry = new Geometry(); + PathTile start = new PathTile(geometry); + PathTile next = new PathTile(geometry); + FieldTile towerTile = new FieldTile(geometry); + geometry.getTiles().add(start); + geometry.getTiles().add(next); + start.setNextTile(next); + + // ellenség és torony felhelyezése a csempére + Legolas.currentTile = start; + towerTile.constructOnTile = tower1; + tower1.setTowerLocation(towerTile); + } + + /** + * otodik teszt eset + * Egy ellenseg lep, majd ralo egy torony, es meghal. + */ + public static void test5() + { + System.out.println(); + System.out.println("Teszteset:"); + Enemy Legolas = updater.getEnemies().get(0); + Legolas.move(); + ((Tower)updater.getConstructs().get(0)).shoot(); + // if nélkül is ugyanúgy lefut, de így talán érthetÅ‘bb + if (Legolas.getHealth() <= 0 ) + { + int manaValue = Legolas.getManaValue(); + PathTile LegolasTile = (PathTile)Legolas.getTile(); //Castolhatunk, mert Legolas biztos PathTile-on áll (ha a Végzet hegyén állna, már vége lenne a játéknak). + LegolasTile.removeEnemy(Legolas); + updater.getMana().increase(manaValue); + } + } + + + /** + * hatodik teszt eset inicializalasa + */ + public static void test6_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + FieldTile towerLocation = new FieldTile(geometry); + + + //Torony letrehozasa es felvetele a constructok koze + Tower tower = new Tower(); + updater.getConstructs().add(tower); + tower.setTowerLocation(towerLocation); + + + //Varazsko letrehozasa + MagicGem gem = new MagicGem(); + //Ellenseg letrehozasa + Hobbit frodo = new Hobbit(); + frodo.health = 50; + updater.getEnemies().add(frodo); + + //Csempe letrehozasa + PathTile tile = new PathTile(geometry); + geometry.getTiles().add(tile); + + frodo.currentTile = tile; + tile.addEnemy(frodo); + tower.setMagicGem(gem); + + } + + /** + * hatodik teszt eset + * Loves varazskovel ellatott toronnyal. + */ + public static void test6() { + System.out.println(); + System.out.println("Teszteset:"); + ((Tower) updater.constructs.get(0)).shoot(); + updater.enemies.get(0).getHealth(); + } + + /** + * hetedik teszt eset inicializalasa + */ + public static void test7_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + updater.getMana().setMana(10); + constructManager = new ConstructManager(updater); + constructManager.setMana(updater.getMana()); + } + + /** + * hetedik teszt eset + * A jatekos epiteni akar valamit, de nincs ra eleg varazsero. + */ + public static void test7() { + System.out.println(); + System.out.println("Teszteset:"); + constructManager.build("Tower", new Tile()); + } + + + /** + * nyolcadik teszt eset inicializalasa + */ + public static void test8_init() + { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + constructManager = new ConstructManager(updater); + updater.getMana().setMana(100); + updater.setConstructManager(constructManager); + constructManager.setMana(updater.getMana()); + } + + /** + * nyolcadik teszt eset + * A jatekos epit egy akadalyt. + */ + public static void test8() + { + PathTile location = new PathTile(geometry); + System.out.println(); + System.out.println("Teszteset:"); + constructManager.build("Barricade", location); + } + + + /** + * kilencedik teszt eset inicializalasa + */ + public static void test9_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + Mana mana = new Mana(); + mana.setMana(1000); + constructManager = new ConstructManager(updater); + constructManager.setMana(mana); + } + /** + * kilencedik teszt eset + * A jatekos epit egy tornyot, majd vasarol bele egy (hatotav novelo) varazskovet. + */ + public static void test9() { + FieldTile towerLocation = new FieldTile(geometry); + System.out.println(); + System.out.println("Teszteset:"); + constructManager.build("Tower", towerLocation); + constructManager.upgrade("Range", updater.getConstructs().get(updater.getConstructs().size()-1)); + } + + + /** + * tizedik teszt eset inicializalasa + */ + public static void test10_init() { + System.out.println("Inicializálás:"); + updater = new Updater(); + geometry = new Geometry(); + PathGenerator pathGenerator = new PathGenerator(geometry); + updater.enemyGenerator = new EnemyGenerator(pathGenerator); + Hobbit frodo = new Hobbit(); + frodo.health = 0; + frodo.manaValue = 30; + updater.addEnemy(frodo); + //Tower tower = new Tower(); + PathTile tileInRange = new PathTile(geometry); + tileInRange.addEnemy(frodo); + frodo.currentTile = tileInRange; + + } + + + /** + * tizedik teszt eset + * Egy torony lo egy ellensegre, aki meghal, majd mivel ez volt az utolso ellenseg, gyozunk. + */ + public static void test10() { + System.out.println(); + System.out.println("Teszteset. A teszteset loves utan kezdodik."); + Hobbit Frodo = (Hobbit) updater.enemies.get(0); + // if nélkül is ugyanúgy lefut, de így talán érthetÅ‘bb + if (Frodo.getHealth() <= 0 ) + { + int manaValue = Frodo.getManaValue(); + PathTile FrodoTile = (PathTile)Frodo.getTile(); //Castolhatunk, mert az ellenség biztos PathTile-on áll (ha a Végzet hegyén állna, már vége lenne a játéknak). + // itt egy private method törli az updater enemies listájából a halott ellenséget + updater.enemies.clear(); + FrodoTile.removeEnemy(Frodo); + updater.getMana().increase(manaValue); + } + + // ha minden ellenség a pályára került, és nincs a pályán több ellenség, akkor nyert a játékos + boolean lastWave = updater.enemyGenerator.isLastEnemyGenerated(); + lastWave = true; //ebben a tesztben nincs több ellenség. + if (lastWave) + { + int numOfEnemies = updater.getNumOfEnemies(); + if (numOfEnemies == 0) + updater.gameOver(true); + } + } + + + static Updater updater; + static Geometry geometry; + static ConstructManager constructManager; + static PathGenerator pathGenerator; + static EnemyGenerator enemyGenerator; + + /** + * A teszt esetek elinditasaert felelos. Parancssori argumentumkent megkapott + * ertek szerinti teszt eset fog lefutni + * @param args parancssori argomentumok + */ + public static void main(String[] args) + { + if (args.length == 0 || !args[0].matches("[0-9].*")) + { + System.out.println("Adja meg parameterkent a teszteset szamat! (1-10)"); + return; + } + + int teszt = Integer.parseInt(args[0]); + switch(teszt) { + case 1: + System.out.println(args[0]+". teszteset"); + test1_init(); + test1(); + break; + case 2: + System.out.println(args[0]+". teszteset"); + test2_init(); + test2(); + break; + case 3: + System.out.println(args[0]+". teszteset"); + test3_init(); + test3(); + break; + case 4: + System.out.println(args[0]+". teszteset"); + test4_init(); + test4(); + break; + case 5: + System.out.println(args[0]+". teszteset"); + test5_init(); + test5(); + break; + case 6: + System.out.println(args[0]+". teszteset"); + test6_init(); + test6(); + break; + case 7: + System.out.println(args[0]+". teszteset"); + test7_init(); + test7(); + break; + case 8: + System.out.println(args[0]+". teszteset"); + test8_init(); + test8(); + break; + case 9: + System.out.println(args[0]+". teszteset"); + test9_init(); + test9(); + break; + case 10: + System.out.println(args[0]+". teszteset"); + test10_init(); + test10(); + break; + default: + System.out.println("Adja meg parameterkent a teszteset szamat! (1-10)"); + break; + } + + } +} diff --git a/Tile.java b/Tile.java index 0779acf..69842b6 100644 --- a/Tile.java +++ b/Tile.java @@ -3,9 +3,14 @@ public class Tile { protected Geometry geometry; protected Construct constructOnTile; + + /** + * A Tile-on egy Construct elhelyezeset szavatolja + * @param construct ezt a Constructott helyezzuk el a Tile-re + */ public void addConstruct(Construct construct) { System.out.println("--> Tile.addConstruct("+construct+")"); - //System.out.println("<-- "); + constructOnTile = construct; // } /** @@ -15,7 +20,7 @@ public void addConstruct(Construct construct) { public Construct getConstruct() { System.out.println("--> Tile.getConstruct()"); - System.out.println("<-- " + constructOnTile); + System.out.println("<-- " + constructOnTile); return constructOnTile; } @@ -32,8 +37,8 @@ public Geometry getGeometry() { * Visszaadja a csempe típusát. */ public String getType() { - System.out.println("--> Tile.getType"); - System.out.println("<-- " + type); + System.out.println("--> Tile.getType()"); + System.out.println("<-- type"); return type; } @@ -41,7 +46,6 @@ public String getType() { * A kapott ellenséget felveszi az ellenségek közé, ha lehet rajta. * @param enemy a kapott ellenség */ - // FIXME Ez semmit nem csinál, mert itt nem tárolunk ellenséglistát, nincs is mihez hozzáadni. Overloadolni kell az EndTile-ban meg a Pathtile-ban, hogy csináljon is valamit. public void addEnemy(Enemy enemy) { System.out.println("--> Tile.addEnemy(" + enemy +")"); System.out.println("<--"); diff --git a/Tower.java b/Tower.java index 2f50e03..e1d0e2c 100644 --- a/Tower.java +++ b/Tower.java @@ -8,7 +8,6 @@ public class Tower extends Construct { /** * A Tower osztály konstruktora. - * Beállítja típusát, TODO és még? range stb. */ public Tower () { @@ -23,10 +22,16 @@ public Tower () */ public Enemy shoot() { System.out.println("--> Tower.shoot()"); - //FIXME BUG: towerLocationt nem adjuk meg a build diagramban, a konstruktorban kéne Geometry geometry = towerLocation.getGeometry(); ArrayList tilesInRange = geometry.getNearby(towerLocation, range); Enemy target = tilesInRange.get(0).getEnemy(); + + if (gem!=null) + { + String type = target.getType(); + gem.getDamageBonus(type); + }; + target.damage(damage); System.out.println("<--" + target); return target; @@ -40,14 +45,27 @@ public void setDamage(int damage) { this.damage = damage; } + /** + * Beallitja a torony tuzgyorsasagat + * @param rate ez a tuzgyorsasag uj erteke + */ public void setFireRate(int rate) { throw new UnsupportedOperationException(); } + /** + * Beallitja a torony hatotavolsagat + * @param range a torony uj hatotavolsaga + */ public void setRange(int range) { - throw new UnsupportedOperationException(); + System.out.println("--> Tower.setRange(int)"); + this.range = range; } + /** + * Beallitja azta referenciat amely megmondja hogy a torony melyik csempen van. + * @param loc a csempe melyre a torony epult + */ public void setTowerLocation(FieldTile loc) { towerLocation = loc; } diff --git a/Updater.java b/Updater.java index 79ec534..dbd9933 100644 --- a/Updater.java +++ b/Updater.java @@ -1,71 +1,126 @@ -import java.io.PrintStream; -import java.util.ArrayList; - - -public class Updater { - public ConstructManager constructManager; - public Geometry geometry; - public EnemyGenerator enemyGenerator; - public ArrayList enemies = new ArrayList(); - public ArrayList constructs = new ArrayList(); - public Mana mana = new Mana(); - - public ArrayList getEnemies() { - return enemies; - } - - public Mana getMana() { - return mana; - } - public ArrayList getConstructs() { - return constructs; - } - - public void addConstruct(Construct construct) { - //throw new UnsupportedOperationException(); - System.out.println("--> Updater.addConstruct(" + construct + ")"); - //System.out.println("<--"); - } - - public void addEnemy(Enemy enemy) { - System.out.println("--> Updater.addEnemy(" + enemy + ")"); - System.out.println("<--"); - enemies.add(enemy); - } - - public void gameOver(Boolean isover) { - System.out.println("--> Updater.gameOver(" + isover + ")"); - } - - public void setGeometry(Geometry geometry) { - this.geometry = geometry; - } - - public void setConstructManager(ConstructManager constructManager) { - this.constructManager = constructManager; - } - - public void setEnemyGenerator(EnemyGenerator enemyGenerator) { - this.enemyGenerator = enemyGenerator; - } - - /** - *Játék kezdeténél lefutó inicializálás. - *Létrehozza a szükséges objektumokat és - *beállítja a referenciákat. Lefutása után - *készen áll a játék a futásra. - */ - public void init() { - System.out.println("--> Updater.init()"); - /*geometry = new Geometry(); //Létrehozzuk a pályát - PathGenerator pathGenerator = new PathGenerator(geometry); //Létrehozzuk az útvonalgenerátort - enemyGenerator = new EnemyGenerator(pathGenerator); //Létrehozzuk az ellenséggenerátort útvonalgenerátor segítségével - new ConstructManager(this); */ //Létrehozzuk az épületkezelÅ‘t - } - - public int getNumOfEnemies() { - System.out.println("--> Updater.getNumOfEnemies()"); - System.out.println("<-- " + enemies.size()); - return enemies.size(); - } -} +import java.io.PrintStream; +import java.util.ArrayList; + + +public class Updater { + public ConstructManager constructManager; + public Geometry geometry; + public EnemyGenerator enemyGenerator; + public ArrayList enemies = new ArrayList(); + public ArrayList constructs = new ArrayList(); + public Mana mana = new Mana(); + + /** + * Visszadja az enemies erteket + * @return visszaadott ertek + */ + public ArrayList getEnemies() { + return enemies; + } + + + /** + * Visszaadja a Mana osztaly peldanyat + * @return Mana osztallyal + */ + public Mana getMana() { + return mana; + } + + /** + * Visszater a Constructokkal amiket az Updater tartalmaz + * @return constructokkat tartalmazo Arraylisttel + */ + public ArrayList getConstructs() { + return constructs; + } + + /** + * Uj Construct-ok felvételét teszi lehetÅ‘ve + * @param construct az uj construct erteke + */ + public void addConstruct(Construct construct) { + System.out.println("--> Updater.addConstruct(" + construct + ")"); + constructs.add(construct); + //System.out.println("<--"); + } + + /** + * Uj Enemy-k felvetelet teszi lehetove + * @param enemy + */ + public void addEnemy(Enemy enemy) { + System.out.println("--> Updater.addEnemy(" + enemy + ")"); + System.out.println("<--"); + enemies.add(enemy); + } + + /** + * Veget vet a jateknak gyozelemmel, ha igaz a parameter, vereseggel ha hamis + * @param isover + */ + public void gameOver(Boolean isover) { + System.out.println("--> Updater.gameOver(Boolean)"); + } + + /** + * Beallitja geometry valtozot + * @param geometry ez lesz az uj erteket + */ + public void setGeometry(Geometry geometry) { + this.geometry = geometry; + } + + /** + * Beallitja a constructManager valtozott + * @param constructManager a constructManager uj erteke + */ + public void setConstructManager(ConstructManager constructManager) { + this.constructManager = constructManager; + } + + /** + * Beallitja az enemyGenerator valtozott + * @param enemyGenerator a beallitando uj erteke a valtozonak. + */ + public void setEnemyGenerator(EnemyGenerator enemyGenerator) { + this.enemyGenerator = enemyGenerator; + } + + /** + *Játék kezdeténél lefutó inicializálás. + *Létrehozza a szükséges objektumokat és + *beállítja a referenciákat. Lefutása után + *készen áll a játék a futásra. + */ + public void init() { + System.out.println("--> Updater.init()"); + geometry = new Geometry(); //Létrehozzuk a pályát + for(int i = 0; i < 3; i++){ + geometry.getTilesList().add(new FieldTile(geometry)); //Létrehozunk 3 csempét, melyekre tornyokat lehet építeni + geometry.getTilesList().add(new PathTile(geometry)); //Létrehozunk 3 útcsempét + } + geometry.getTilesList().add(new EndTile(geometry)); //Létrehozzuk a végzet hegyét + PathGenerator pathGenerator = new PathGenerator(geometry); //Létrehozzuk az útvonalgenerátort + enemyGenerator = new EnemyGenerator(pathGenerator); //Létrehozzuk az ellenséggenerátort útvonalgenerátor segítségével + new ConstructManager(this); //Létrehozzuk az épületkezelÅ‘t + } + + /** + * Visszaadja a palyan levo ellensegek szamat + * @return az ellensegek szama + */ + public int getNumOfEnemies() { + System.out.println("--> Updater.getNumOfEnemies()"); + System.out.println("<-- " + enemies.size()); + return enemies.size(); + } + + /** + * Visszadja a geometry-t + * @return a geometry + */ + public Geometry getGeometry() { + return geometry; + } +}