Skip to content
The Chat Archive
gpt-3.5-turbo-0301· OpenAI WildChat-4.8M (AI2)

Implementáld az ActionStep classt, és utána írd át a tick metódust: Lépés A karakter lép…

  1. 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 -> {
            }
        }
    }
    
  2. 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);
            }
        }
    }
    

    }

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.