Heros can use ability

src/main/Game.java

@@ -3,6 +3,7 @@
 import com.fasterxml.jackson.databind.node.ArrayNode;
 import fileio.ActionsInput;
 import fileio.StartGameInput;
+import main.card.Card;
 import main.card.HeroCard;
 import main.card.MinionCard;
 import main.command.*;
@@ -49,7 +50,7 @@ public final class Game {
     int round = 1;
     int playerTurn;
     ArrayList<ArrayList<MinionCard>> table = new ArrayList<ArrayList<MinionCard>>();
-    ArrayList<MinionCard> haveAttacked = new ArrayList<>();
+    ArrayList<Card> haveAttacked = new ArrayList<>();
 
     public Game(Player player1, Player player2, StartGameInput startGameInput) {
 
@@ -103,11 +104,11 @@ public void setPlayerTurn(int playerTurn) {
         this.playerTurn = playerTurn;
     }
 
-    public ArrayList<MinionCard> getHaveAttacked() {
+    public ArrayList<Card> getHaveAttacked() {
         return haveAttacked;
     }
 
-    public void cardHasAttacked(MinionCard card) {
+    public void cardHasAttacked(Card card) {
         this.haveAttacked.add(card);
     }
 
@@ -223,6 +224,7 @@ public Command getCommandObject(ActionsInput actionsInput) {
             case "cardUsesAbility" ->
                     new CardUsesAbility(this, actionsInput.getCardAttacker(), actionsInput.getCardAttacked());
             case "useAttackHero" -> new UseAttackHero(this, actionsInput.getCardAttacker());
+            case "useHeroAbility" -> new UseHeroAbility(this, actionsInput.getAffectedRow());
             case "getPlayerMana" -> new GetPlayerMana(this, actionsInput.getPlayerIdx());
             case "getCardsInHand" -> new GetCardsInHand(this, actionsInput.getPlayerIdx());
             case "getCardsOnTable" -> new GetCardsOnTable(this);

src/main/Main.java

@@ -114,7 +114,6 @@ public static void action(final String filePath1,
             }
         });
 
-        System.out.println(output);
         ObjectWriter objectWriter = objectMapper.writerWithDefaultPrettyPrinter();
         objectWriter.writeValue(new File(filePath2), output);
     }

src/main/card/HeroCard.java

@@ -1,18 +1,28 @@
 package main.card;
 
 import fileio.CardInput;
+import main.Game;
+import main.card.ability.*;
 
 import java.security.PublicKey;
 
 public class HeroCard extends Card {
     int health = 30;
+    RowAbility rowAbility;
 
     public HeroCard(int mana, String description, String[] colors, String name) {
         super(mana, description, colors, name);
     }
 
     public HeroCard(CardInput cardInput) {
         super(cardInput);
+
+        switch (name) {
+            case "Lord Royce" -> rowAbility = new SubZero();
+            case "Empress Thorina" -> rowAbility = new LowBlow();
+            case "King Mudface" -> rowAbility = new EarthBorn();
+            case "General Kocioraw" -> rowAbility = new BloodThirst();
+        }
     }
 
     public HeroCard(HeroCard heroCard) {
@@ -30,4 +40,8 @@ public void setHealth(int health) {
     public void removeHealth(int health) {
         this.health -= health;
     }
+
+    public void useHeroAbility(Game game, int affectedRow) {
+        rowAbility.use(game, affectedRow);
+    }
 }

src/main/card/MinionCard.java

@@ -56,6 +56,10 @@ public void setAttackDamage(int attackDamage) {
         this.attackDamage = attackDamage;
     }
 
+    public void addAttackDamage(int attackDamage) {
+        this.attackDamage += attackDamage;
+    }
+
     public void removeAttackDamage(int attackDamage) {
         this.attackDamage -= attackDamage;
         if (this.attackDamage < 0)

src/main/card/ability/BloodThirst.java

@@ -0,0 +1,14 @@
+package main.card.ability;
+
+import main.Game;
+import main.card.MinionCard;
+
+import java.util.ArrayList;
+
+public class BloodThirst implements RowAbility {
+    @Override
+    public void use(Game game, int affectedRow) {
+        ArrayList<MinionCard> cards = game.getRow(affectedRow);
+        cards.forEach(card -> card.addAttackDamage(1));
+    }
+}

src/main/card/ability/EarthBorn.java

@@ -0,0 +1,14 @@
+package main.card.ability;
+
+import main.Game;
+import main.card.MinionCard;
+
+import java.util.ArrayList;
+
+public class EarthBorn implements RowAbility {
+    @Override
+    public void use(Game game, int affectedRow) {
+        ArrayList<MinionCard> cards = game.getRow(affectedRow);
+        cards.forEach(card -> card.addHealth(1));
+    }
+}

src/main/card/ability/LowBlow.java

@@ -0,0 +1,22 @@
+package main.card.ability;
+
+import main.Game;
+import main.card.MinionCard;
+
+import java.util.ArrayList;
+
+public class LowBlow implements RowAbility {
+    @Override
+    public void use(Game game, int affectedRow) {
+        ArrayList<MinionCard> cards = game.getRow(affectedRow);
+
+        MinionCard maxHealth = null;
+        for (MinionCard card :
+                cards) {
+            if ( maxHealth == null || card.getAttackDamage() >= maxHealth.getAttackDamage())
+                maxHealth = card;
+        }
+
+        cards.remove(maxHealth);
+    }
+}

src/main/card/ability/SubZero.java

@@ -0,0 +1,22 @@
+package main.card.ability;
+
+import main.Game;
+import main.card.MinionCard;
+
+import java.util.ArrayList;
+
+public class SubZero implements RowAbility {
+    @Override
+    public void use(Game game, int affectedRow) {
+        ArrayList<MinionCard> cards = game.getRow(affectedRow);
+
+        MinionCard maxHealth = cards.get(0);
+        for (MinionCard card :
+            cards) {
+            if (card.getAttackDamage() > maxHealth.getAttackDamage())
+                maxHealth = card;
+        }
+
+        maxHealth.setFrozen(true);
+    }
+}

src/main/command/UseHeroAbility.java

@@ -0,0 +1,57 @@
+package main.command;
+
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import main.Game;
+import main.Player;
+import main.card.HeroCard;
+
+public class UseHeroAbility implements Command {
+    Game game;
+    int affectedRow;
+
+    public UseHeroAbility(Game game, int affectedRow) {
+        this.game = game;
+        this.affectedRow = affectedRow;
+    }
+
+    @Override
+    public void execute(ArrayNode output) {
+        boolean error = false;
+        String errorMessage = null;
+        Player player = (game.getPlayerTurn() == 1)? game.getPlayer1() : game.getPlayer2();
+        HeroCard hero = player.getHeroCard();
+
+        if (player.getMana() < hero.getMana()) {
+            error = true;
+            errorMessage = "Not enough mana to use hero's ability.";
+        }
+
+        if (!error && game.getHaveAttacked().contains(hero)) {
+            error = true;
+            errorMessage = "Hero has already attacked this turn.";
+        }
+
+        if (hero.getName().equals("Lord Royce") || hero.getName().equals("Empress Thorina")) {
+            if (!error && !game.rowBelongsToEnemy(affectedRow)) {
+                error = true;
+                errorMessage = "Selected row does not belong to the enemy.";
+            }
+        } else {
+            if (!error && game.rowBelongsToEnemy(affectedRow)) {
+                error = true;
+                errorMessage = "Selected row does not belong to the current player.";
+            }
+        }
+
+        if (error) {
+            output.addObject()
+                    .put("command", "useHeroAbility")
+                    .putPOJO("affectedRow", affectedRow)
+                    .put("error", errorMessage);
+        } else {
+            hero.useHeroAbility(game, affectedRow);
+            player.removeMana(hero.getMana());
+            game.getHaveAttacked().add(hero);
+        }
+    }
+}