fix engines bugs

.gitignore

@@ -0,0 +1 @@
+/Java-Knight/target/

Java-Knight/src/main/java/org/project/common/models/EntityDiff.java

@@ -0,0 +1,5 @@
+package org.project.common.models;
+
+public record EntityDiff(int health, int stamina, boolean lostShield, boolean lostCostume, int shieldHealth, int costumeHealth) {
+
+}

Java-Knight/src/main/java/org/project/constants/appConstants/ConsoleColor.java

@@ -1,5 +1,5 @@
 package org.project.constants.appConstants;
 
 public class ConsoleColor {
-    public static final String Reset = "\\u001B[0m";
+    public static final String Reset = "\u001B[0m";
 }

Java-Knight/src/main/java/org/project/constants/appConstants/TextColor.java

@@ -1,12 +1,12 @@
 package org.project.constants.appConstants;
 
 public class TextColor extends ConsoleColor{
-    public static String Black = "\\u001B[30m";
+    public static String Black = "\u001B[30m";
-    public static String Red = "\\u001B[31m";
+    public static String Red = "\u001B[31m";
-    public static String Green = "\\u001B[32m";
+    public static String Green = "\u001B[32m";
-    public static String Yellow = "\\u001B[33m";
+    public static String Yellow = "\u001B[33m";
-    public static String Blue = "\\u001B[34m";
+    public static String Blue = "\u001B[34m";
-    public static String Magenta = "\\u001B[35m";
+    public static String Magenta = "\u001B[35m";
-    public static String Cyan = "\\u001B[36m";
+    public static String Cyan = "\u001B[36m";
-    public static String White = "\\u001B[37m";
+    public static String White = "\u001B[37m";
 }

Java-Knight/src/main/java/org/project/engine/BattleEngine.java

@@ -7,6 +7,10 @@ public abstract class BattleEngine {
     public Entity Player2;
 
     public BattleEngine(Entity player1, Entity player2) {
+        player1.ResetStamina();
+        player1.RestoreHealth();
+        player2.RestoreHealth();
+        player2.ResetStamina();
         Player1 = player1;
         Player2 = player2;
     }

Java-Knight/src/main/java/org/project/engine/MainEngine.java

@@ -26,6 +26,7 @@ public abstract class MainEngine {
         while (true) {
             for (PlayerRoles role : roles) {
                 System.out.println(index + " > " + role.name().toLowerCase());
+                index++;
             }
             int choice = scanner.nextInt();
 

Java-Knight/src/main/java/org/project/engine/MultiPlayerBattleEngine.java

@@ -1,15 +1,177 @@
 package org.project.engine;
 
-import org.project.entity.enemies.Enemy;
+import org.project.common.models.EntityDiff;
+import org.project.constants.appConstants.TextColor;
+import org.project.constants.gameConstant.EntityState;
+import org.project.constants.gameConstant.FightMoves;
+import org.project.entity.Entity;
 import org.project.entity.players.Player;
 
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.Scanner;
+
 public class MultiPlayerBattleEngine extends BattleEngine {
+    private Player player1;
+    private Player player2;
+    private Player player1Past;
+    private Player player2Past;
+
     public MultiPlayerBattleEngine(Player player1, Player player2) {
         super(player1, player2);
+        this.player1 = (Player) Player1;
+        this.player2 = (Player) Player2;
+        player1Past = player1.copy();
+        player2Past = player2.copy();
     }
 
     @Override
     public void StartBattle() {
 
+        while (true) {
+            FightMoves player1Move = PlayerMovesMenu(player1, player2);
+            showMoveExplanation(player1Move, player1, player2);
+
+            if (player1Past.GetState() == EntityState.FROZEN) {
+                player1.SetState(EntityState.ALIVE);
+            }
+
+            EntityDiff playerDiff = getPlayerDiff(player1Past, player1);
+            EntityDiff enemyDiff = getPlayerDiff(player2Past, player2);
+
+            System.out.println();
+            showFighter(playerDiff, player1);
+            showFighter(enemyDiff, player2);
+            System.out.println();
+
+            player1Past = player1.copy();
+            player2Past = player2.copy();
+
+            FightMoves player2Move = PlayerMovesMenu(player2, player1);
+            showMoveExplanation(player2Move, player2, player1);
+
+            if (player2Past.GetState() == EntityState.FROZEN) {
+                player2.SetState(EntityState.ALIVE);
+            }
+
+            playerDiff = getPlayerDiff(player1Past, player1);
+            enemyDiff = getPlayerDiff(player2Past, player2);
+
+            System.out.println();
+            showFighter(playerDiff, player1);
+            showFighter(enemyDiff, player2);
+            System.out.println();
+
+            player1Past = player1.copy();
+            player2Past = player2.copy();
+
+            if (player2.GetState() == EntityState.DEAD) {
+                System.out.println(TextColor.Green + player1.Name + " WON!" + TextColor.Reset);
+                return;
+            }
+            else if (player1.GetState() == EntityState.DEAD) {
+                System.out.println(TextColor.Green + player2.Name + " WON!" + TextColor.Reset);
+                return;
+            }
+        }
+    }
+
+    private EntityDiff getPlayerDiff(Entity oldVersion, Entity newVersion) {
+        return new EntityDiff(
+                newVersion.Health - oldVersion.Health,
+                newVersion.GetStamina() - oldVersion.GetStamina(),
+                (newVersion.Shield == null && oldVersion.Shield != null),
+                (newVersion.Weapon == null && oldVersion.Weapon != null),
+                (newVersion.Shield != null ? newVersion.Shield.GetHealth() : 0) - (oldVersion.Shield != null ? oldVersion.Shield.GetHealth() : 0),
+                (newVersion.Costume != null ? newVersion.Costume.GetHealth() : 0) - (oldVersion.Costume != null ? oldVersion.Costume.GetHealth() : 0)
+        );
+    }
+
+    private void showFighter(EntityDiff diff, Entity entity) {
+        System.out.println(entity.Name + ":");
+
+        String color = diff.health() > 0 ? TextColor.Green : TextColor.Red;
+        String sign = diff.health() > 0 ? "+" : "-";
+        System.out.println("    Health: " + entity.Health + " " + color + sign + Math.abs(diff.health()) + TextColor.Reset);
+
+        color = diff.stamina() > 0 ? TextColor.Green : TextColor.Red;
+        sign = diff.stamina() > 0 ? "+" : "-";
+        System.out.println("    Stamina: " + entity.GetStamina() + " " + color + sign + Math.abs(diff.stamina()) + TextColor.Reset);
+
+        if (diff.lostShield()) {
+            System.out.println("    Shield: " + entity.Shield.getName() + " " + TextColor.Red + "LOST" + TextColor.Reset);
+        }
+
+        if (diff.lostCostume()) {
+            System.out.println("    Costume: " + entity.Costume.getName() + " " + TextColor.Red + "LOST" + TextColor.Reset);
+        }
+
+        if (entity.Shield != null) {
+            color = diff.shieldHealth() > 0 ? TextColor.Green : TextColor.Red;
+            sign = diff.shieldHealth() > 0 ? "+" : "-";
+            System.out.println("    Shield: " + entity.Shield.getName() + " " + color + sign + Math.abs(diff.shieldHealth()) + TextColor.Reset);
+        }
+
+        if (entity.Costume != null) {
+            color = diff.costumeHealth() > 0 ? TextColor.Green : TextColor.Red;
+            sign = diff.costumeHealth() > 0 ? "+" : "-";
+            System.out.println("    Costume: " + entity.Costume.getName() + " " + color + sign + Math.abs(diff.shieldHealth()) + TextColor.Reset);
+        }
+    }
+
+    private FightMoves PlayerMovesMenu(Player performer, Player receiver) {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println(performer.Name + " it's your turn");
+        ArrayList<FightMoves> moves = performer.GetAvailableMoves();
+
+        int index = 0;
+        Dictionary<Integer, FightMoves> dictionary = new Hashtable<>();
+
+        for (FightMoves move : moves) {
+            String result = index + " > " + move.toString();
+
+            if (move == FightMoves.SPECIAL) {
+                result += " (" + performer.GetSpecialAbilityDescription(receiver) + ")";
+            }
+
+            dictionary.put(index, move);
+            index++;
+
+            System.out.println(result);
+        }
+
+        boolean continueLoop;
+        while (true){
+            continueLoop = false;
+            int choice = scanner.nextInt();
+            FightMoves move = moves.get(choice);
+
+            switch (move) {
+                case FightMoves.LIGHT_ATTACK -> performer.LightAttack(receiver);
+                case FightMoves.HEAVY_ATTACK -> performer.HeavyAttack(receiver);
+                case FightMoves.SPECIAL -> performer.SpecialAbility(receiver);
+                case FightMoves.HEAL -> performer.HealMove();
+                case FightMoves.DEFEND -> performer.defend();
+                default -> continueLoop = true;
+            }
+
+            if (!continueLoop) {
+                return move;
+            }
+        }
+    }
+
+    private void showMoveExplanation(FightMoves move, Entity performer, Entity receiver) {
+        System.out.print(TextColor.Cyan);
+        switch (move) {
+            case FightMoves.LIGHT_ATTACK -> System.out.println(performer.Name + " performs a light attack");
+            case FightMoves.HEAVY_ATTACK -> System.out.println(performer.Name + " performs a heavy attack");
+            case FightMoves.SPECIAL -> System.out.println(performer.GetSpecialAbilityResultDescription(receiver));
+            case FightMoves.HEAL -> System.out.println(performer.Name + " heals");
+            case FightMoves.DEFEND -> System.out.println(performer.Name + " get their guard up!");
+        }
+        System.out.print(TextColor.Reset);
     }
 }

Java-Knight/src/main/java/org/project/engine/SinglePlayerBattleEngine.java

@@ -1,42 +1,70 @@
 package org.project.engine;
 
+import org.project.common.models.EntityDiff;
 import org.project.constants.appConstants.TextColor;
 import org.project.constants.gameConstant.EntityState;
 import org.project.constants.gameConstant.FightMoves;
+import org.project.entity.Entity;
 import org.project.entity.enemies.Enemy;
 import org.project.entity.players.Player;
 
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.Scanner;
+
 public class SinglePlayerBattleEngine extends BattleEngine {
     private Player player;
     private Enemy enemy;
+    private Player playerPast;
+    private Enemy enemyPast;
     public SinglePlayerBattleEngine(Player player, Enemy enemy) {
         super(player, enemy);
-        player = (Player) Player1;
+        this.player = (Player) Player1;
-        enemy = (Enemy) Player2;
+        this.enemy = (Enemy) Player2;
+        playerPast = player.copy();
+        enemyPast = enemy.copy();
     }
 
     @Override
     public void StartBattle() {
-        Player playerPast = player;
-        Enemy enemyPast = enemy;
 
         while (true) {
-            if (enemyPast.GetState() == EntityState.FROZEN) {
+            FightMoves playerMove = PlayerMovesMenu();
-                enemy.SetState(EntityState.ALIVE);
+            showMoveExplanation(playerMove, player, enemy);
-            }
+
             if (playerPast.GetState() == EntityState.FROZEN) {
                 player.SetState(EntityState.ALIVE);
             }
 
-            // TODO: get diffs
+            playerPast = player.copy();
+            enemyPast = enemy.copy();
 
-            // TODO: player round
+            EntityDiff playerDiff = getPlayerDiff(playerPast, player);
+            EntityDiff enemyDiff = getPlayerDiff(enemyPast, enemy);
 
-            // TODO: show players stats
+            System.out.println();
+            showFighter(playerDiff, player);
+            showFighter(enemyDiff, enemy);
+            System.out.println();
 
-            // TODO: bot move
             FightMoves botMove = enemy.PlayRound(player);
-            switch (botMove)
+            showMoveExplanation(botMove, enemy, player);
+
+            if (enemyPast.GetState() == EntityState.FROZEN) {
+                enemy.SetState(EntityState.ALIVE);
+            }
+
+            playerPast = player.copy();
+            enemyPast = enemy.copy();
+
+            playerDiff = getPlayerDiff(playerPast, player);
+            enemyDiff = getPlayerDiff(enemyPast, enemy);
+
+            System.out.println();
+            showFighter(playerDiff, player);
+            showFighter(enemyDiff, enemy);
+            System.out.println();
 
             if (enemy.GetState() == EntityState.DEAD) {
                 enemy.DropLoot(player);
@@ -47,9 +75,104 @@ public class SinglePlayerBattleEngine extends BattleEngine {
             else if (player.GetState() == EntityState.DEAD) {
                 return;
             }
-
-            playerPast = player;
-            enemyPast = enemy;
         }
     }
+
+    private EntityDiff getPlayerDiff(Entity oldVersion, Entity newVersion) {
+        return new EntityDiff(
+                newVersion.Health - oldVersion.Health,
+                newVersion.GetStamina() - oldVersion.GetStamina(),
+                (newVersion.Shield == null && oldVersion.Shield != null),
+                (newVersion.Weapon == null && oldVersion.Weapon != null),
+                (newVersion.Shield != null ? newVersion.Shield.GetHealth() : 0) - (oldVersion.Shield != null ? oldVersion.Shield.GetHealth() : 0),
+                (newVersion.Costume != null ? newVersion.Costume.GetHealth() : 0) - (oldVersion.Costume != null ? oldVersion.Costume.GetHealth() : 0)
+        );
+    }
+
+    private void showFighter(EntityDiff diff, Entity entity) {
+        System.out.println(entity.Name + ":");
+
+        String color = diff.health() > 0 ? TextColor.Green : TextColor.Red;
+        String sign = diff.health() > 0 ? "+" : "-";
+        System.out.println("    Health: " + entity.Health + " " + color + sign + Math.abs(diff.health()) + TextColor.Reset);
+
+        color = diff.stamina() > 0 ? TextColor.Green : TextColor.Red;
+        sign = diff.stamina() > 0 ? "+" : "-";
+        System.out.println("    Stamina: " + entity.GetStamina() + " " + color + sign + Math.abs(diff.stamina()) + TextColor.Reset);
+
+        if (diff.lostShield()) {
+            System.out.println("    Shield: " + entity.Shield.getName() + " " + TextColor.Red + "LOST" + TextColor.Reset);
+        }
+
+        if (diff.lostCostume()) {
+            System.out.println("    Costume: " + entity.Costume.getName() + " " + TextColor.Red + "LOST" + TextColor.Reset);
+        }
+
+        if (entity.Shield != null) {
+            color = diff.shieldHealth() > 0 ? TextColor.Green : TextColor.Red;
+            sign = diff.shieldHealth() > 0 ? "+" : "-";
+            System.out.println("    Shield: " + entity.Shield.getName() + " " + color + sign + Math.abs(diff.shieldHealth()) + TextColor.Reset);
+        }
+
+        if (entity.Costume != null) {
+            color = diff.costumeHealth() > 0 ? TextColor.Green : TextColor.Red;
+            sign = diff.costumeHealth() > 0 ? "+" : "-";
+            System.out.println("    Costume: " + entity.Costume.getName() + " " + color + sign + Math.abs(diff.shieldHealth()) + TextColor.Reset);
+        }
+    }
+
+    private FightMoves PlayerMovesMenu() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println(player.Name + " it's your turn");
+        ArrayList<FightMoves> moves = player.GetAvailableMoves();
+
+        int index = 0;
+        Dictionary<Integer, FightMoves> dictionary = new Hashtable<>();
+
+        for (FightMoves move : moves) {
+            String result = index + " > " + move.toString();
+
+            if (move == FightMoves.SPECIAL) {
+                result += " (" + player.GetSpecialAbilityDescription(enemy) + ")";
+            }
+
+            dictionary.put(index, move);
+            index++;
+
+            System.out.println(result);
+        }
+
+        boolean continueLoop;
+        while (true){
+            continueLoop = false;
+            int choice = scanner.nextInt();
+            FightMoves move = moves.get(choice);
+
+            switch (move) {
+                case FightMoves.LIGHT_ATTACK -> player.LightAttack(enemy);
+                case FightMoves.HEAVY_ATTACK -> player.HeavyAttack(enemy);
+                case FightMoves.SPECIAL -> player.SpecialAbility(enemy);
+                case FightMoves.HEAL -> player.HealMove();
+                case FightMoves.DEFEND -> player.defend();
+                default -> continueLoop = true;
+            }
+
+            if (!continueLoop) {
+                return move;
+            }
+        }
+    }
+
+    private void showMoveExplanation(FightMoves move, Entity performer, Entity receiver) {
+        System.out.print(TextColor.Cyan);
+        switch (move) {
+            case FightMoves.LIGHT_ATTACK -> System.out.println(performer.Name + " performs a light attack");
+            case FightMoves.HEAVY_ATTACK -> System.out.println(performer.Name + " performs a heavy attack");
+            case FightMoves.SPECIAL -> System.out.println(performer.GetSpecialAbilityResultDescription(receiver));
+            case FightMoves.HEAL -> System.out.println(performer.Name + " heals");
+            case FightMoves.DEFEND -> System.out.println(performer.Name + " get their guard up!");
+        }
+        System.out.print(TextColor.Reset);
+    }
 }

Java-Knight/src/main/java/org/project/entity/Entity.java

@@ -56,6 +56,32 @@ public abstract class Entity implements IDamageable, IHealable, IDefendable, IFi
 
     protected Entity() {}
 
+    public Entity(Entity other) {
+        this.Name = other.Name;
+        this.MaxHealth = other.MaxHealth;
+        this.Health = other.Health;
+        this.Stamina = other.Stamina;
+        this.MaxStamina = other.MaxStamina;
+        this.Money = other.Money;
+        this.BaseDamage = other.BaseDamage;
+        this.State = other.State;
+
+        this.Weapon = other.Weapon == null ? null : new Weapon(other.Weapon.getName(), this, other.Weapon.GetPrice(), other.Weapon.GetHealth(), other.Weapon.GetMaxHealth(), other.Weapon.GetDamage());
+        this.Shield = other.Shield == null ? null : new Shield(other.Shield.getName(), this, other.Shield.GetPrice(), other.Shield.GetHealth(), other.Shield.GetMaxHealth(), other.Shield.GetDefense());
+        this.Costume = other.Costume == null ? null : new Costume(other.Costume.getName(), this, other.Costume.GetPrice(), other.Costume.GetHealth(), other.Costume.GetMaxHealth(), other.Costume.GetDefense());
+
+        this.Inventory = other.Inventory == null ? null : new ArrayList<>(other.Inventory);
+        this.defencePowerUps = other.defencePowerUps == null ? null : new ArrayList<>(other.defencePowerUps);
+
+        this.DefenseBonus = other.DefenseBonus;
+        this.IsDefending = other.IsDefending;
+        this.HealAmount = other.HealAmount;
+        this.HeavyAttackStamina = other.HeavyAttackStamina;
+        this.SpecialAbilityStamina = other.SpecialAbilityStamina;
+    }
+
+    public abstract Entity copy();
+
     public int GetStamina() { return Stamina; }
 
     public void ResetStamina() { Stamina = MaxStamina; }
@@ -68,10 +94,11 @@ public abstract class Entity implements IDamageable, IHealable, IDefendable, IFi
                 Stamina = MaxStamina;
             }
         }
-
+        else {
-        Stamina -= amount;
+            Stamina -= amount;
-        if (Stamina < 0) {
+            if (Stamina < 0) {
-            Stamina = 0;
+                Stamina = 0;
+            }
         }
     }
 
@@ -146,7 +173,7 @@ public abstract class Entity implements IDamageable, IHealable, IDefendable, IFi
 
     @Override
     public void TakeDamage(int amount, AttackPowerUp[] powerUps) {
-        if (!defencePowerUps.contains(DefencePowerUp.INVISIBLE)) return;
+        if (defencePowerUps != null && !defencePowerUps.contains(DefencePowerUp.INVISIBLE)) return;
 
         IDefender[] defenders = GetDefenders();
 

Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java

@@ -26,6 +26,15 @@ public class Dragon extends Enemy {
         this("Dragon", 5000, 5000, 0, 100, EntityState.ALIVE, null, null, null, new ArrayList<>(){}, 50, false, 50, 500, 500, 1000);
     }
 
+    public Dragon (Dragon other) {
+        super(other);
+    }
+
+    @Override
+    public Dragon copy() {
+        return new Dragon(this);
+    }
+
     @Override
     public void DropLoot(Player player) {
         Key.Owner = player;

Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java

@@ -36,6 +36,14 @@ public abstract class Enemy extends Entity {
         super();
     }
 
+    public Enemy(Enemy other) {
+        super(other);
+        this.Key = new KeyItem(other.Key.getName(), other.Key.Owner);
+    }
+
+    @Override
+    public abstract Enemy copy();
+
     public void DropLoot(Player player) {
         Random random = new Random();
 

Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java

@@ -25,6 +25,15 @@ public class Goblin extends Enemy {
         this("Goblin", 75, 75, 100, 10, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 15, 100, 100, 50);
     }
 
+    public Goblin (Goblin other) {
+        super(other);
+    }
+
+    @Override
+    public Goblin copy() {
+        return new Goblin(this);
+    }
+
     @Override
     public void SpecialAbility(Entity entity) {
         ModifyStamina(SpecialAbilityStamina, false);

Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java

@@ -29,6 +29,15 @@ public class Skeleton extends Enemy {
         this("Skeleton", 125, 125, 200, 15, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 20, 100, 100, 100);
     }
 
+    public Skeleton (Skeleton other) {
+        super(other);
+    }
+
+    @Override
+    public Skeleton copy() {
+        return new Skeleton(this);
+    }
+
     @Override
     public ArrayList<FightMoves> GetAvailableMoves() {
         if (GetState() == EntityState.FROZEN || GetState() == EntityState.DEAD) return new ArrayList<>(){};

Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java

@@ -25,6 +25,15 @@ public class Vampire extends Enemy {
         this("Vampire", 150, 150, 300, 20, EntityState.ALIVE, null, null, null, new ArrayList<>(), 8, false, 30, 100, 100, 150);
     }
 
+    public Vampire (Vampire other) {
+        super(other);
+    }
+
+    @Override
+    public Vampire copy() {
+        return new Vampire(this);
+    }
+
     @Override
     public void SpecialAbility(Entity entity) {
         int curHealth = entity.Health;

Java-Knight/src/main/java/org/project/entity/players/Assassin.java

@@ -27,6 +27,15 @@ public class Assassin extends Player {
         this(name, 125, 125, 100, 15, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 35, 100, 100, 1, 0);
     }
 
+    public Assassin(Assassin other) {
+        super(other);
+    }
+
+    @Override
+    public Assassin copy() {
+        return new Assassin(this);
+    }
+
     @Override
     public void SpecialAbility(Entity entity) {
         ModifyStamina(SpecialAbilityStamina, false);

Java-Knight/src/main/java/org/project/entity/players/Knight.java

@@ -27,6 +27,15 @@ public class Knight extends Player {
         this(name, 150, 150, 100, 20, EntityState.ALIVE, null, null, null, new ArrayList<>(), 8, false, 30, 100, 100, 1, 0);
     }
 
+    public Knight(Knight other) {
+        super(other);
+    }
+
+    @Override
+    public Knight copy() {
+        return new Knight(this);
+    }
+
     @Override
     public void SpecialAbility(Entity entity) {
         ModifyStamina(SpecialAbilityStamina, false);

Java-Knight/src/main/java/org/project/entity/players/Player.java

@@ -29,9 +29,18 @@ public abstract class Player extends Entity {
         super();
     }
 
+    public Player(Player other) {
+        super(other);
+        this.Level = other.Level;
+        this.LevelProgress = other.LevelProgress;
+    }
+
+    @Override
+    public abstract Player copy();
+
     public void LevelUpTo(int level) {
         while (Level < level) {
-            LevelUp();
+            UnconditionalLevelUp();
         }
     }
 
@@ -43,19 +52,23 @@ public abstract class Player extends Entity {
         }
     }
 
+    public void UnconditionalLevelUp() {
+        Level++;
+        double upgradeRatio = (1.1 + ((double) Level * 0.02));
+        int gift = Level * 10;
+
+        MaxStamina = (int) (MaxStamina * upgradeRatio);
+        MaxHealth = (int) (MaxHealth * upgradeRatio);
+        BaseDamage = (int) (BaseDamage * upgradeRatio);
+        DefenseBonus = (int) (DefenseBonus * upgradeRatio);
+        HealAmount = (int) (HealAmount * upgradeRatio);
+        ModifyMoney(gift, true);
+    }
+
     public void LevelUp() {
         while (LevelProgress >= 100) {
-            Level++;
+            UnconditionalLevelUp();
-            double upgradeRatio = (1.1 + ((double) Level * 0.02));
-            int gift = Level * 10;
-
             LevelProgress -= 100;
-            MaxStamina = (int) (MaxStamina * upgradeRatio);
-            MaxHealth = (int) (MaxHealth * upgradeRatio);
-            BaseDamage = (int) (BaseDamage * upgradeRatio);
-            DefenseBonus = (int) (DefenseBonus * upgradeRatio);
-            HealAmount = (int) (HealAmount * upgradeRatio);
-            ModifyMoney(gift, true);
         }
     }
 
@@ -64,15 +77,15 @@ public abstract class Player extends Entity {
         int damage = GetDamage();
 
         Damage(target, (int)(damage * 0.5), new AttackPowerUp[]{});
-        ModifyStamina(MaxStamina/8, true);
+        ModifyStamina(MaxStamina/8, false);
     }
 
     @Override
     public void HeavyAttack(IDamageable target) {
         int damage = GetDamage();
-        ModifyStamina(HeavyAttackStamina, false);
 
         Damage(target, damage, new AttackPowerUp[]{});
+        ModifyStamina(HeavyAttackStamina, false);
     }
 
     @Override

Java-Knight/src/main/java/org/project/entity/players/Wizard.java

@@ -27,6 +27,15 @@ public class Wizard extends Player {
         this(name, 100, 100, 100, 15, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 40, 100, 100, 1, 0);
     }
 
+    public Wizard(Wizard other) {
+        super(other);
+    }
+
+    @Override
+    public Wizard copy() {
+        return new Wizard(this);
+    }
+
     @Override
     public void SpecialAbility(Entity entity) {
         ModifyStamina(SpecialAbilityStamina, false);