Implementáld az ActionStep classt, és utána írd át a tick metódust: Lépés A karakter lép…
- User
Implementáld az ActionStep classt, és utána írd át a tick metódust:
Lépés A karakter lép a pályán, megadott irányban (jobbra, balra, fel, le)
A karakterek a pályán lépésekkel tudnak mozogni. Alapvet®en minden karakter sebessége 1, azaz lépésenként 1 mez® megtételére képes. A sebesség azonban csökkenhet, amennyiben a karakter életere és/vagy éhsége alacsony. A karakterek nem léphetnek olyan mez®re, amin víz van. Ha egy adott karakter a lépés után egy olyan mez®re kerülne (az a mez® lenne a legközelebb hozzá), ahol víz van, akkor a cselekvésnek nem lesz semmilyen hatása, a karakter marad az eredeti pozíción. Az életer® az alábbi módon befolyásolja a karakter mozgási sebességét: Életer® Szorzó [50%;100%] 1 [30%;50%) 0.9 [10%;30%) 0.75 (0%;10%) 0.6 Az éhség az alábbi módon befolyásolja a karakter mozgási sebességét: 11 Éhség Szorzó [50%;100%] 1 [20%;50%) 0.9 (0%;20%) 0.8 0% 0.5 Például ha a karakternek 38%-os életereje és 15%-os éhsége van, akkor ez egy 0.9-es és egy 0.8-as szorzót jelent, tehát a sebessége 1 * 0.9 * 0.8, azaz 0.72 lesz. A karakterek egy adott pillanatban lehetnek két mez® között is (tehát a koordinátákat valós értékként számoljuk), azonban mindig "tartoznak" egy adott mez®höz, mégpedig ahhoz, amelyik hozzájuk a legközelebb esik. A távolságot a teljes játék során valós távolságként számoljuk, tehát két egymás melletti átlós mez® távolság √ 2, azaz ∼1.41 egység
public class ActionStep extends Action { /** * A mozgás iránya. */ private final Direction direction;
/** * Az akció létrehozására szolgáló konstruktor. * * @param direction a mozgás iránya */ public ActionStep(Direction direction) { super(ActionType.STEP); this.direction = direction; } /** * A direction gettere. * @return a mozgás iránya */ public Direction getDirection() { return direction; }}
public abstract class Action { /** * Az akció típusa. * @see ActionType */ private final ActionType type;
/** * Az akció létrehozására szolgáló konstruktor. * @param type az akció típusa */ public Action(ActionType type) { this.type = type; } /** * A type gettere. * @return az akció típusa */ public ActionType getType() { return type; }}
@Override public float getSpeed() { float healthMultiplier = 1.0F; if (this.hp >= 30 && this.hp < 50) { healthMultiplier = 0.9F; } else if (this.hp >= 10 && this.hp < 30) { healthMultiplier = 0.75F; } else { healthMultiplier = 0.6F; } float hungerMultiplier = 1.0F; if (this.hunger >= 20 && this.hunger < 50) { hungerMultiplier = 0.9F; } else if (this.hunger >= 0 && this.hunger < 20) { hungerMultiplier = 0.8F; } else { hungerMultiplier = 0.5F; } return (float) (1.0 * healthMultiplier * hungerMultiplier); }public class Position { /** * vízszintes (x) irányú koordináta. */ private float x;
/** * függőleges (y) irányú koordináta. */ private float y; /** * Két paraméteres konstruktor, amely segítségével egy új pozíciót lehet létrehozni. * @param x vízszintes (x) irányú koordináta * @param y függőleges (y) irányú koordináta */ public Position(float x, float y) { this.x = x; this.y = y; } /** * Az aktuális koordinátához legközelebbi, csak egész értékű komponensekből álló koordináta kiszámítása.<br> * A kerekítés a matematika szabályainak megfelelően történik. * @return a kiszámolt pozíció */ public Position getNearestWholePosition() { int nearestX = Math.round(this.x); int nearestY = Math.round(this.y); return new Position(nearestX, nearestY); } /** * x koordináta gettere. * @return x koordináta */ public float getX() { return x; } /** * y koordináta gettere. * @return y koordináta */ public float getY() { return y; } /** * x koordináta settere. * @param x új x érték */ public void setX(float x) { this.x = x; } /** * y koordináta settere. * @param y új y érték */ public void setY(float y) { this.y = y; }}
public class Field implements BaseField{ private final int color; private final List items;
public Field(int color) { this.color = color; this.items = new ArrayList<>(); } @Override public boolean isWalkable() { return this.color != MapColors.WATER; } @Override public boolean hasTree() { return color == MapColors.TREE; } @Override public boolean hasStone() { return color == MapColors.STONE; } @Override public boolean hasTwig() { return color == MapColors.TWIG; } @Override public boolean hasBerry() { return color == MapColors.BERRY; } @Override public boolean hasCarrot() { return color == MapColors.CARROT; } @Override public boolean hasFire() { return false; } public boolean isEmptySpace(){ return color == MapColors.EMPTY; } /** * Ezen metódus segítségével a mezőn lévő tárgyak lekérdezhetők.<br> * A tömbben az a tárgy jön hamarabb, amelyik korábban került az adott mezőre.<br> * A karakter ha felvesz egy tárgyat, akkor a legkorábban a mezőre kerülő tárgyat fogja felvenni.<br> * Ha nem sikerül felvenni, akkor a (nem) felvett tárgy a tömb végére kerül. * @return a mezőn lévő tárgyak */ @Override public AbstractItem[] items() { return items.toArray(new AbstractItem[0]); }}
/** * Ez a metódus jelzi, hogy 1 időegység eltelt.<br> * A metódus először lekezeli a felhasználói inputot, majd a gépi ellenfelek cselekvését végzi el, * végül eltelik egy időegység.<br> * Csak akkor csinál bármit is, ha a játék már elkezdődött, de még nem fejeződött be. * @param action az emberi játékos által végrehajtani kívánt akció */ public void tick(Action action) { if (GameStarted && !GameEnded) { handleUserInput(action); ido++; } } public void handleUserInput(Action action) { switch (action.getType()) { case STEP -> new ActionStep(D); case STEP_AND_ATTACK -> { new ActionStep(Direction.LEFT); new ActionAttack(); } case ATTACK -> new ActionAttack(); case INTERACT -> new ActionInteract(); case CRAFT -> new ActionCraft(ItemType.PICKAXE); case COLLECT_ITEM -> new ActionCollectItem(); case DROP_ITEM -> new ActionDropItem(random.nextInt()); case EAT -> new ActionEat(random.nextInt()); case EQUIP -> new ActionEquip(random.nextInt()); case UNEQUIP -> new ActionUnequip(); case COOK -> new ActionCook(random.nextInt()); case MOVE_ITEM -> new ActionMoveItem(random.nextInt(), random.nextInt()); case SWAP_ITEMS -> new ActionSwapItems(random.nextInt(), random.nextInt()); case COMBINE_ITEMS -> new ActionCombineItems(random.nextInt(), random.nextInt()); default -> { } } } - Assistant
public class ActionStep extends Action { /** * A mozgás iránya. */ private final Direction direction;
/** * Az akció létrehozására szolgáló konstruktor. * * @param direction a mozgás iránya */ public ActionStep(Direction direction) { super(ActionType.STEP); this.direction = direction; } /** * A direction gettere. * @return a mozgás iránya */ public Direction getDirection() { return direction; } /** * Az akció végrehajtásáért felelős metódus. * * @param character a karakter, aki végrehajtja az akciót * @param map a pálya, amin a karakter található */ @Override public void execute(Character character, GameMap map) { // Megkeressük a karakter pozíciójának megfelelő mezőt a pályán Field currentField = map.getFieldAt(character.getPosition().getNearestWholePosition()); // A karakter csak akkor mozoghat, ha a mező amire lépni szeretne bejárható és nem víz if (currentField.isWalkable() && !currentField.isEmptySpace()) { // Meghatározzuk a következő pozíciót, ahová a karakter lép Position nextPosition = character.getPosition().add(direction.getDeltaX(), direction.getDeltaY()); // Megkeressük a következő pozícióhoz tartozó mezőt a pályán Field nextField = map.getFieldAt(nextPosition.getNearestWholePosition()); // Ha a következő mező is bejárható és nem víz, akkor lépünk if (nextField.isWalkable() && !nextField.isEmptySpace()) { // Megszámoljuk, hogy hány mező távolságra van a víztől int distanceToWater = map.getDistanceToWater(nextPosition); // Az alap sebesség float speed = 1.0F; // Az életerő alapján számított szorzó float healthMultiplier; if (character.getHealth() >= 50) { healthMultiplier = 1.0F; } else if (character.getHealth() >= 30) { healthMultiplier = 0.9F; } else if (character.getHealth() >= 10) { healthMultiplier = 0.75F; } else { healthMultiplier = 0.6F; } // Az éhség alapján számított szorzó float hungerMultiplier; if (character.getHunger() >= 50) { hungerMultiplier = 1.0F; } else if (character.getHunger() >= 20) { hungerMultiplier = 0.9F; } else if (character.getHunger() >= 0) { hungerMultiplier = 0.8F; } else { hungerMultiplier = 0.5F; } // A távolság alapján számított szorzó float distanceMultiplier; if (distanceToWater > 1) { distanceMultiplier = 1.0F; } else { distanceMultiplier = 0.5F; } // A végső sebesség szorzata speed = speed * healthMultiplier * hungerMultiplier * distanceMultiplier; // Az új pozíció, ahová a karakter lép Position newPosition = character.getPosition().add(direction.getDeltaX() * speed, direction.getDeltaY() * speed); // A mező, amire a karakter lép Field targetField = map.getFieldAt(newPosition.getNearestWholePosition()); // Ha ez egy étel, akkor megeszi if (targetField.hasBerry() || targetField.hasCarrot()) { character.eatFood(targetField.getFoodValue()); } // Ha ez egy kő, akkor feltölti az eszközkészletét if (targetField.hasStone()) { character.refillTools(ItemType.PICKAXE); } // Ha ez egy fa, akkor feltölti az eszközkészletét if (targetField.hasTree()) { character.refillTools(ItemType.AXE); } // A karakter lép a mezőre character.move(newPosition); } } }}
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.