apply the final debugging

.gitignore

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

Java-Knight/src/main/java/org/project/Interface/IAttachable.java

@@ -3,6 +3,6 @@ package org.project.Interface;
 import org.project.entity.Entity;
 
 public interface IAttachable {
-    public void AttachTo(Entity entity);
-    public void DeattachFrom(Entity entity);
+    public void AttachTo(Entity entity, boolean fromInventory);
+    public void DeattachFrom(Entity entity, boolean toInventory);
 }

Java-Knight/src/main/java/org/project/Main.java

@@ -1,15 +1,49 @@
 package org.project;
 
-import org.project.location.Location;
+import org.project.constants.appConstants.GameModes;
+import org.project.constants.appConstants.TextColor;
+import org.project.engine.MainEngine;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.Scanner;
 
 public class Main {
-    public static void main(String[] args) {
-        // TODO: ADD LOCATIONS TO YOUR GAME
-        List<Location> locations = new ArrayList<>();
+    static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        boolean endGame = false;
 
-        // TODO: IMPLEMENT GAMEPLAY
+        while (true) {
+
+            System.out.println(TextColor.Cyan + "JAVA KNIGHT" + TextColor.Reset);
+            System.out.println(
+                    """
+                    0 > Single Player
+                    1 > Local Multiplayer
+                    2 > Exit
+                    """
+            );
+
+            GameModes gameMode = null;
+            while (true){
+                int choice = scanner.nextInt();
+
+                if (choice == 0) {
+                    gameMode = GameModes.SINGLE_PLAYER;
+                    break;
+                } else if (choice == 1) {
+                    gameMode = GameModes.MULTI_PLAYER_LOCAL;
+                    break;
+                } else if (choice == 2) {
+                    endGame = true;
+                    break;
+                }
+            }
+
+            if (endGame) {
+                break;
+            }
+
+            MainEngine engine = MainEngine.CreateEngine(gameMode);
+            engine.run();
+        }
     }
 }

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 Red = "\\u001B[31m";
-    public static String Green = "\\u001B[32m";
-    public static String Yellow = "\\u001B[33m";
-    public static String Blue = "\\u001B[34m";
-    public static String Magenta = "\\u001B[35m";
-    public static String Cyan = "\\u001B[36m";
-    public static String White = "\\u001B[37m";
+    public static String Black = "\u001B[30m";
+    public static String Red = "\u001B[31m";
+    public static String Green = "\u001B[32m";
+    public static String Yellow = "\u001B[33m";
+    public static String Blue = "\u001B[34m";
+    public static String Magenta = "\u001B[35m";
+    public static String Cyan = "\u001B[36m";
+    public static String White = "\u001B[37m";
 }

Java-Knight/src/main/java/org/project/constants/gameConstant/Costumes.java

@@ -0,0 +1,14 @@
+package org.project.constants.gameConstant;
+
+import org.project.item.Accessory.Costume;
+
+public final class Costumes {
+    public static Costume cheapCostume = new Costume("cheap costume", null, 40, 100, 100, 10);
+    public static Costume SteelCostume = new Costume("steel costume", null, 150, 300, 300, 30);
+    public static Costume GoldenCostume = new Costume("golden costume", null, 500, 500, 500, 100);
+    public static Costume MasterCostume = new Costume("master costume", null, 1500, 1000, 1000, 300);
+
+    public static Costume[] getCostumes() {
+        return new Costume[]{cheapCostume, SteelCostume, GoldenCostume, MasterCostume};
+    }
+}

Java-Knight/src/main/java/org/project/constants/gameConstant/PlayerRoles.java

@@ -0,0 +1,7 @@
+package org.project.constants.gameConstant;
+
+public enum PlayerRoles {
+    KNIGHT,
+    WIZARD,
+    ASSASSIN
+}

Java-Knight/src/main/java/org/project/constants/gameConstant/PlayerRolesExt.java

@@ -0,0 +1,26 @@
+package org.project.constants.gameConstant;
+
+import org.project.entity.players.Assassin;
+import org.project.entity.players.Knight;
+import org.project.entity.players.Player;
+import org.project.entity.players.Wizard;
+
+public final class PlayerRolesExt {
+    private PlayerRolesExt() {}
+
+    public static Player CreatePlayer(PlayerRoles role, String name, int level) {
+        return switch (role) {
+            case KNIGHT -> new Knight(name, level);
+            case ASSASSIN -> new Assassin(name, level);
+            case WIZARD -> new Wizard(name, level);
+        };
+    }
+
+    public static Player CreatePlayer(PlayerRoles role, String name) {
+        return switch (role) {
+            case KNIGHT -> new Knight(name);
+            case ASSASSIN -> new Assassin(name);
+            case WIZARD -> new Wizard(name);
+        };
+    }
+}

Java-Knight/src/main/java/org/project/constants/gameConstant/Shields.java

@@ -0,0 +1,14 @@
+package org.project.constants.gameConstant;
+
+import org.project.item.Accessory.Shield;
+
+public final class Shields {
+    public static Shield WoodenShield = new Shield("wooden shield", null, 40, 100, 100, 10);
+    public static Shield SteelShield = new Shield("steel shield", null, 150, 300, 300, 30);
+    public static Shield GoldenShield = new Shield("golden shield", null, 500, 500, 500, 100);
+    public static Shield MasterShield = new Shield("master shield", null, 1500, 1000, 1000, 300);
+
+    public static Shield[] getShields() {
+        return new Shield[]{WoodenShield, SteelShield, GoldenShield, MasterShield};
+    }
+}

Java-Knight/src/main/java/org/project/constants/gameConstant/Weapons.java

@@ -0,0 +1,14 @@
+package org.project.constants.gameConstant;
+
+import org.project.item.Accessory.Weapon;
+
+public final class Weapons {
+    public static Weapon Dagger = new Weapon("dagger", null, 40, 100, 100, 10);
+    public static Weapon SteelSword = new Weapon("steel sword", null, 150, 100, 100, 30);
+    public static Weapon GoldenSword = new Weapon("golden sword", null, 500, 100, 100, 100);
+    public static Weapon MasterSword = new Weapon("master sword", null, 1500, 100, 100, 300);
+
+    public static Weapon[] getWeapons() {
+        return new Weapon[] {Dagger, SteelSword, GoldenSword, MasterSword};
+    }
+}

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

@@ -1,4 +1,19 @@
 package org.project.engine;
 
-public class BattleEngine {
+import org.project.entity.Entity;
+
+public abstract class BattleEngine {
+    public Entity Player1;
+    public Entity Player2;
+
+    public BattleEngine(Entity player1, Entity player2) {
+        player1.ResetStamina();
+        player1.RestoreHealth();
+        player2.RestoreHealth();
+        player2.ResetStamina();
+        Player1 = player1;
+        Player2 = player2;
+    }
+
+    public abstract void StartBattle();
 }

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

@@ -1,6 +1,11 @@
 package org.project.engine;
 
 import org.project.constants.appConstants.GameModes;
+import org.project.constants.gameConstant.PlayerRoles;
+import org.project.constants.gameConstant.PlayerRolesExt;
+import org.project.entity.players.Player;
+
+import java.util.Scanner;
 
 public abstract class MainEngine {
     protected MainEngine() {}
@@ -13,4 +18,38 @@ public abstract class MainEngine {
             case GameModes.MULTI_PLAYER_LOCAL -> new MultiplayerEngine();
         };
     }
+
+    protected Player RoleMenu(String name, int level) {
+        Scanner scanner = new Scanner(System.in);
+        PlayerRoles[] roles = PlayerRoles.values();
+        int index = 0;
+        while (true) {
+            for (PlayerRoles role : roles) {
+                System.out.println(index + " > " + role.name().toLowerCase());
+                index++;
+            }
+            int choice = scanner.nextInt();
+
+            if (choice >= 0 && choice < roles.length) {
+                return PlayerRolesExt.CreatePlayer(roles[choice], name, level);
+            }
+        }
+    }
+
+    protected Player RoleMenu(String name) {
+        Scanner scanner = new Scanner(System.in);
+        PlayerRoles[] roles = PlayerRoles.values();
+        int index = 0;
+        while (true) {
+            for (PlayerRoles role : roles) {
+                System.out.println(index + " > " + role.name().toLowerCase());
+                index++;
+            }
+            int choice = scanner.nextInt();
+
+            if (choice >= 0 && choice < roles.length) {
+                return PlayerRolesExt.CreatePlayer(roles[choice], name);
+            }
+        }
+    }
 }

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

@@ -1,4 +1,186 @@
 package org.project.engine;
 
-public class MultiPlayerBattleEngine {
+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 final Player player1;
+    private final 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() {
+        EntityDiff playerDiff;
+        EntityDiff enemyDiff;
+
+        while (true) {
+            if (player1.GetState() != EntityState.FROZEN) {
+                FightMoves player1Move = PlayerMovesMenu(player1, player2);
+                showMoveExplanation(player1Move, player1, player2Past);
+
+                playerDiff = getPlayerDiff(player1Past, player1);
+                enemyDiff = getPlayerDiff(player2Past, player2);
+
+                System.out.println();
+                showFighter(playerDiff, player1);
+                showFighter(enemyDiff, player2);
+                System.out.println();
+            }
+
+            if (player1.GetState() == EntityState.DEAD) {
+                System.out.println(TextColor.Green + player2.Name + " WON!" + TextColor.Reset);
+                return;
+            }
+
+            if (player1Past.GetState() == EntityState.FROZEN) {
+                player1.SetState(EntityState.ALIVE);
+            }
+
+            player1Past = player1.copy();
+            player2Past = player2.copy();
+
+
+            if (player2.GetState() != EntityState.FROZEN)
+            {
+                FightMoves player2Move = PlayerMovesMenu(player2, player1);
+                showMoveExplanation(player2Move, player2, player1Past);
+
+                playerDiff = getPlayerDiff(player1Past, player1);
+                enemyDiff = getPlayerDiff(player2Past, player2);
+
+                System.out.println();
+                showFighter(playerDiff, player1);
+                showFighter(enemyDiff, player2);
+                System.out.println();
+            }
+
+            if (player2.GetState() == EntityState.DEAD) {
+                System.out.println(TextColor.Green + player1.Name + " WON!" + TextColor.Reset);
+                return;
+            }
+
+            if (player2Past.GetState() == EntityState.FROZEN) {
+                player2.SetState(EntityState.ALIVE);
+            }
+
+            player1Past = player1.copy();
+            player2Past = player2.copy();
+        }
+    }
+
+    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/MultiplayerEngine.java

@@ -1,4 +1,39 @@
 package org.project.engine;
 
-public class MultiplayerEngine extends MainEngine{
+import org.project.constants.appConstants.TextColor;
+import org.project.entity.players.Player;
+
+import java.util.Scanner;
+
+public class MultiplayerEngine extends MainEngine {
+    public MultiplayerEngine() {
+        super();
+    }
+
+    @Override
+    public void run() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println("Player 1, Set your name:");
+        String player1Name = scanner.nextLine();
+
+        System.out.println("Player 2, Set your name:");
+        String player2Name = scanner.nextLine();
+
+        System.out.println(player1Name + ", Set the level of your character:");
+        int player1Level = scanner.nextInt();
+
+        System.out.println(player2Name + ", Set the level of your character:");
+        int player2Level = scanner.nextInt();
+
+        System.out.println(player1Name + ", Set the role of your character:");
+        Player player1 = RoleMenu(player1Name, player1Level);
+
+        System.out.println(player2Name + ", Set the role of your character:");
+        Player player2 = RoleMenu(player2Name, player2Level);
+
+        System.out.println(TextColor.Red + "Now the battle begins" + TextColor.Reset);
+        BattleEngine engine = new MultiPlayerBattleEngine(player1, player2);
+        engine.StartBattle();
+    }
 }

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

@@ -1,4 +1,185 @@
 package org.project.engine;
 
-public class SinglePlayerBattleEngine {
+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 final Player player;
+    private final Enemy enemy;
+    private Player playerPast;
+    private Enemy enemyPast;
+    public SinglePlayerBattleEngine(Player player, Enemy enemy) {
+        super(player, enemy);
+        this.player = (Player) Player1;
+        this.enemy = (Enemy) Player2;
+        playerPast = player.copy();
+        enemyPast = enemy.copy();
+    }
+
+    @Override
+    public void StartBattle() {
+        EntityDiff playerDiff;
+        EntityDiff enemyDiff;
+
+        while (true) {
+            if (player.GetState() != EntityState.FROZEN) {
+                FightMoves playerMove = PlayerMovesMenu();
+                showMoveExplanation(playerMove, player, enemyPast);
+
+                playerDiff = getPlayerDiff(playerPast, player);
+                enemyDiff = getPlayerDiff(enemyPast, enemy);
+
+                System.out.println();
+                showFighter(playerDiff, player);
+                showFighter(enemyDiff, enemy);
+                System.out.println();
+            }
+
+            if (playerPast.GetState() == EntityState.FROZEN) {
+                player.SetState(EntityState.ALIVE);
+            }
+
+            if (enemy.GetState() == EntityState.DEAD) {
+                enemy.DropLoot(player);
+                player.AddLevelProgress(enemy.LevelProgressAmount);
+                System.out.println(TextColor.Green + player.Name + " WON!" + TextColor.Reset);
+                return;
+            }
+
+            playerPast = player.copy();
+            enemyPast = enemy.copy();
+
+            if (enemy.GetState() != EntityState.FROZEN) {
+                FightMoves botMove = enemy.PlayRound(player);
+                showMoveExplanation(botMove, enemy, playerPast);
+
+                playerDiff = getPlayerDiff(playerPast, player);
+                enemyDiff = getPlayerDiff(enemyPast, enemy);
+
+                System.out.println();
+                showFighter(playerDiff, player);
+                showFighter(enemyDiff, enemy);
+                System.out.println();
+            }
+
+            if (player.GetState() == EntityState.DEAD) {
+                return;
+            }
+
+            if (enemyPast.GetState() == EntityState.FROZEN) {
+                enemy.SetState(EntityState.ALIVE);
+            }
+
+            playerPast = player.copy();
+            enemyPast = enemy.copy();
+        }
+    }
+
+    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/engine/SinglePlayerEngine.java

@@ -2,13 +2,17 @@ package org.project.engine;
 
 import org.project.constants.appConstants.ConsoleColor;
 import org.project.constants.appConstants.TextColor;
-import org.project.constants.gameConstant.ItemClass;
-import org.project.entity.players.Assassin;
-import org.project.entity.players.Knight;
+import org.project.constants.gameConstant.*;
 import org.project.entity.players.Player;
-import org.project.entity.players.Wizard;
+import org.project.item.Accessory.Accessory;
+import org.project.item.Accessory.Shield;
+import org.project.item.Item;
 import org.project.location.*;
+import org.project.util.DisplayItem;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Dictionary;
 import java.util.Scanner;
 
 public class SinglePlayerEngine extends MainEngine {
@@ -25,58 +29,78 @@ public class SinglePlayerEngine extends MainEngine {
         System.out.println(TextColor.Cyan + GetIntro() + ConsoleColor.Reset);
         System.out.println();
 
-        System.out.println("How should me call you, hero? ");
+        System.out.println("How should we call you, hero? ");
         String name = scanner.nextLine();
 
-        boolean InValidInput = false;
-        do {
-            System.out.println("Greetings, " + name + ". May we know your role? \n" +
-                    "0 > Wizard" +
-                    "1 > Assassin" +
-                    "2 > Knight");
+        System.out.println("Greetings, " + TextColor.Cyan + name + TextColor.Reset +". May we know your role? \n");
 
-            int choice = scanner.nextInt();
+        player = RoleMenu(name);
 
-            switch (choice) {
-                case 0 -> player = new Wizard(name);
-                case 1 -> player = new Assassin(name);
-                case 2 -> player = new Knight(name);
-                default -> InValidInput = true;
-            }
-        } while (InValidInput);
-
-        System.out.println("Very well, " + TextColor.Cyan + GetIntro() + ConsoleColor.Reset + " your journey begins!");
+        System.out.println("Very well, " + TextColor.Cyan + player.Name + ConsoleColor.Reset + " your journey begins!");
         System.out.println();
 
         while (true) {
-            boolean canFightDragon = false;
-            if (player.GetInventoryByClass(ItemClass.KEY).size() == 3) {
-                canFightDragon = true;
-            }
+            boolean canFightDragon = player.GetInventoryByClass(ItemClass.KEY).size() == 3;
 
             Location location = Location.RandomLocation();
-            System.out.println(GetLocationIntro(location));
 
-            while (true) {
+            boolean continueLoop = false;
+            do {
+                System.out.println(TextColor.Cyan + GetLocationIntro(location) + TextColor.Reset);
                 System.out.println("What do you do, " + player.Name + "?");
                 System.out.println(
-                        "0 > FIGHT!\n" +
-                                "1 > Go to the next location\n" +
-                                "2 > Visit the market place in the town"
+                        """
+                                0 > FIGHT!
+                                1 > Go to the next location
+                                2 > Visit the market place in the town
+                                3 > Check inventory"""
                 );
                 if (canFightDragon) {
-                    System.out.println("3 > Go to the castle to face the dragon");
+                    System.out.println("4 > Go to the castle to face the dragon");
                 }
 
                 int choice = scanner.nextInt();
 
                 switch (choice) {
                     case 0 -> {
-
+                        System.out.println(TextColor.Red + "You choice to FIGHT!" + TextColor.Reset);
+                        BattleEngine engine = new SinglePlayerBattleEngine(player, location.enemy);
+                        engine.StartBattle();
+                        continueLoop = false;
                     }
+                    case 1 -> {
+                        continueLoop = false;
+                    }
+                    case 2 -> {
+                        MarketPlace();
+                        continueLoop = false;
+                    }
+                    case 3 -> {
+                        InventoryView();
+                        continueLoop = true;
+                    }
+                    case 4 -> {
+                        if (canFightDragon) {
+                            location = new Castle();
+                            continueLoop = false;
+                        }
+                        else {
+                            continueLoop = true;
+                        }
+                    }
+                    default -> continueLoop = true;
                 }
+            } while (continueLoop);
+
+            if (player.GetState() == EntityState.DEAD) {
+                System.out.println(TextColor.Red + "Game Over!" + TextColor.Reset);
+                break;
             }
 
+            if (player.GetInventoryByClass(ItemClass.KEY).size() == 4) {
+                System.out.println(TextColor.Blue + "You WON! You saved Javanest!" + TextColor.Reset);
+                break;
+            }
         }
     }
 
@@ -85,20 +109,267 @@ public class SinglePlayerEngine extends MainEngine {
     }
 
     public String GetLocationIntro(Location location) {
-        if (location instanceof Jungle) {
-            return player.Name + " enters the woods, after a few steps, they see a green goblin searching for food a few steps away";
+        return switch (location) {
+            case Jungle jungle ->
+                    player.Name + " enters the woods, after a few steps, they see a green goblin searching for food a few steps away";
+            case GraveYard graveYard ->
+                    player.Name + " goes inside the grave ward, they cannot see further than 10 steps ahead because of the fog in the air. After lurking through out the graves, the shadow appears... It's a skeleton!";
+            case DarkCaves darkCaves ->
+                    player.Name + " dives into the darkness. As our hero was going deeper, a black smoke appears, a vampire is nearby...";
+            case Castle castle ->
+                    player.Name + " Goes through the gates, the dragon looks at " + player.Name + "... It knows that an epic battle awaits both it them";
+            case null, default -> "";
+        };
+    }
+
+    public void MarketPlace() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println(TextColor.Cyan + "You've entered the marketplace, what would you like to do?" + TextColor.Reset);
+        boolean wantsToStay = true;
+        while (wantsToStay) {
+            System.out.println("Money = " + player.GetMoney() + "\n");
+            System.out.println("""
+                    0 > Show Inventory
+                    1 > Sell Unnecessary goods
+                    2 > Sell the accessories
+                    3 > Sell the shields
+                    4 > Sell the costumes
+                    5 > Sell the Weapons
+                    6 > Buy shields
+                    7 > Buy weapon
+                    8 > Buy costume
+                    9 > Exit
+                    """);
+
+            int choice = scanner.nextInt();
+
+            switch (choice) {
+                case 0 -> {
+                    if (player.GetInventory().isEmpty()) {
+                        System.out.println(TextColor.Red + "You do not have anything at the moment" + TextColor.Reset);
+                        break;
+                    }
+                    DisplayItem.DisplayItems(player.GetInventory());
+                }
+                case 1 -> {
+                    player.SellByClass(ItemClass.UNNECESSARY);
+                    System.out.println(TextColor.Green + "Unnecessary goods sold" + TextColor.Reset);
+                }
+                case 2 -> {
+                    player.SellByClass(ItemClass.ACCESSORY);
+                    System.out.println(TextColor.Green + "accessories sold" + TextColor.Reset);
+                }
+                case 3 -> {
+                    player.SellByClass(ItemClass.SHIELD);
+                    System.out.println(TextColor.Green + "shields sold" + TextColor.Reset);
+                }
+                case 4 -> {
+                    player.SellByClass(ItemClass.COSTUME);
+                    System.out.println(TextColor.Green + "costumes sold" + TextColor.Reset);
+                }
+                case 5 -> {
+                    player.SellByClass(ItemClass.WEAPON);
+                    System.out.println(TextColor.Green + "weapons sold" + TextColor.Reset);
+                }
+                case 6 -> {
+                    System.out.println("Money = " + player.GetMoney() + "\n");
+
+                    System.out.println(TextColor.Blue + "Current shield: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Shield == null) {
+                        System.out.println(TextColor.Red + "You do not have a Shield" + TextColor.Reset);
+                    }
+                    else {
+                        item.add(player.Shield);
+                        DisplayItem.DisplayItems(item);
+                    }
+                    System.out.println(TextColor.Reset);
+
+                    ArrayList<Item> items = new ArrayList<>(Arrays.asList(Shields.getShields()));
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(items);
+
+                    System.out.println("Please set the number of the accessory you want to buy, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item shield = dictionary.get(index);
+                    Accessory accessory = (Accessory) shield;
+
+                    if (accessory != null) {
+                        if (player.GetMoney() >= accessory.GetPrice()) {
+                            if (player.Shield != null) player.Shield.DeattachFrom(player, true);
+                            accessory.AttachTo(player, false);
+                            player.ModifyMoney(accessory.GetPrice(), false);
+                        }
+                        else {
+                            System.out.println(TextColor.Red + "You do not have enough money" + TextColor.Reset);
+                        }
+                    }
+                }
+                case 7 -> {
+                    System.out.println("Money = " + player.GetMoney() + "\n");
+
+                    System.out.println(TextColor.Blue + "Current weapon: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Weapon == null) {
+                        System.out.println(TextColor.Red + "You do not have a Weapon" + TextColor.Reset);
+                    }
+                    else {
+                        item.add(player.Weapon);
+                        DisplayItem.DisplayItems(item);
+                    }
+                    System.out.println(TextColor.Reset);
+
+                    ArrayList<Item> items = new ArrayList<>(Arrays.asList(Weapons.getWeapons()));
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(items);
+
+                    System.out.println("Please set the number of the accessory you want to buy, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item weapon = dictionary.get(index);
+                    Accessory accessory = (Accessory) weapon;
+
+                    if (accessory != null) {
+                        if (player.GetMoney() >= accessory.GetPrice()) {
+                            if (player.Weapon != null) player.Weapon.DeattachFrom(player, true);
+                            accessory.AttachTo(player, false);
+                            player.ModifyMoney(accessory.GetPrice(), false);
+                        }
+                        else {
+                            System.out.println(TextColor.Red + "You do not have enough money" + TextColor.Reset);
+                        }
+                    }
+                }
+                case 8 -> {
+                    System.out.println("Money = " + player.GetMoney() + "\n");
+
+                    System.out.println(TextColor.Blue + "Current costume: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Costume == null) {
+                        System.out.println(TextColor.Red + "You do not have a Costume" + TextColor.Reset);
+                    }
+                    else {
+                        item.add(player.Costume);
+                        DisplayItem.DisplayItems(item);
+                    }
+                    System.out.println(TextColor.Reset);
+
+                    ArrayList<Item> items = new ArrayList<>(Arrays.asList(Costumes.getCostumes()));
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(items);
+
+                    System.out.println("Please set the number of the accessory you want to buy, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item costume = dictionary.get(index);
+                    Accessory accessory = (Accessory) costume;
+
+                    if (accessory != null) {
+                        if (player.GetMoney() >= accessory.GetPrice()) {
+                            if (player.Costume != null) player.Costume.DeattachFrom(player, true);
+                            accessory.AttachTo(player, false);
+                            player.ModifyMoney(accessory.GetPrice(), false);
+                        }
+                        else {
+                            System.out.println(TextColor.Red + "You do not have enough money" + TextColor.Reset);
+                        }
+                    }
+                }
+                case 9 -> wantsToStay = false;
+            }
         }
-        else if (location instanceof GraveYard) {
-            return player.Name + " goes inside the grave ward, they cannot see a more than 10 steps ahead because of the fog in the air. After lurking through out the graves, the shadow appears... It's a skeleton!";
-        }
-        else if (location instanceof DarkCaves) {
-            return player.Name + " dives into the darkness. As our hero was going deeper, a black smoke appears, a vampire is nearby...";
-        }
-        else if (location instanceof Castle) {
-            return player.Name + " Goes through the gates, the dragon looks at " + player.Name + "... It knows that an epic battle awaits both it them";
-        }
-        else {
-            return "";
+    }
+
+    public void InventoryView() {
+        Scanner scanner = new Scanner(System.in);
+
+        System.out.println(TextColor.Cyan + "You open your inventory, what would you like to do?\n" + TextColor.Reset);
+
+        boolean wantsToStay = true;
+        while (wantsToStay) {
+            System.out.println("Money = " + player.GetMoney() + "\n");
+            System.out.println("""
+                    0 > Show Inventory
+                    1 > Show Shields
+                    2 > Show Weapons
+                    3 > Show Costumes
+                    4 > Exit
+                    """);
+
+            int choice = scanner.nextInt();
+
+            switch (choice) {
+                case 0 -> {
+                    if (player.GetInventory().isEmpty()) {
+                        System.out.println(TextColor.Red + "You do not have anything at the moment" + TextColor.Reset);
+                        break;
+                    }
+                    DisplayItem.DisplayItems(player.GetInventory());
+                }
+                case 1 -> {
+                    System.out.println(TextColor.Blue + "Current shield: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Shield == null) {
+                        System.out.println(TextColor.Red + "You do not have a Shield" + TextColor.Reset);
+                        break;
+                    }
+                    item.add(player.Shield);
+                    DisplayItem.DisplayItems(item);
+                    System.out.println(TextColor.Reset);
+
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(player.GetInventoryByClass(ItemClass.SHIELD));
+
+                    System.out.println("Please set the number of the accessory you want to wear, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item shield = dictionary.get(index);
+
+                    if (shield != null) {
+                        if (player.Shield != null) player.Shield.DeattachFrom(player, true);
+                        ((Accessory) shield).AttachTo(player, true);
+                    }
+                }
+                case 2 -> {
+                    System.out.println(TextColor.Blue + "Current weapon: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Weapon == null) {
+                        System.out.println(TextColor.Red + "You do not have a Weapon" + TextColor.Reset);
+                        break;
+                    }
+                    item.add(player.Weapon);
+                    DisplayItem.DisplayItems(item);
+                    System.out.println(TextColor.Reset);
+
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(player.GetInventoryByClass(ItemClass.WEAPON));
+
+                    System.out.println("Please set the number of the accessory you want to wear, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item weapon = dictionary.get(index);
+
+                    if (weapon != null) {
+                        if (player.Weapon != null) player.Weapon.DeattachFrom(player, true);
+                        ((Accessory) weapon).AttachTo(player, true);
+                    }
+                }
+                case 3 -> {
+                    System.out.println(TextColor.Blue + "Current costume: ");
+                    ArrayList<Item> item = new ArrayList<>();
+                    if (player.Costume == null) {
+                        System.out.println(TextColor.Red + "You do not have a Costume" + TextColor.Reset);
+                        break;
+                    }
+                    item.add(player.Costume);
+                    DisplayItem.DisplayItems(item);
+                    System.out.println(TextColor.Reset);
+
+                    Dictionary<Integer, Item> dictionary = DisplayItem.MenuDisplay(player.GetInventoryByClass(ItemClass.COSTUME));
+
+                    System.out.println("Please set the number of the accessory you want to wear, set any other number to abort:");
+                    Integer index = scanner.nextInt();
+                    Item costume = dictionary.get(index);
+
+                    if (costume != null) {
+                        if (player.Costume != null) player.Costume.DeattachFrom(player, true);
+                        ((Accessory) costume).AttachTo(player, true);
+                    }
+                }
+                case 4 -> wantsToStay = false;
+            }
         }
     }
 }

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;
             }
         }
-
-        Stamina -= amount;
-        if (Stamina < 0) {
-            Stamina = 0;
+        else {
+            Stamina -= amount;
+            if (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

@@ -15,15 +15,24 @@ import java.util.ArrayList;
 public class Dragon extends Enemy {
     public Dragon (String name, int maxHealth, int health, long money, int baseDamage, EntityState state, Weapon weapon,
                     Shield shield, Costume costume, ArrayList<Item> inventory, int defenseBonus, boolean isDefending,
-                    int healAmount, int stamina, int maxStamina) {
+                    int healAmount, int stamina, int maxStamina, int levelProgressAmount) {
 
-        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina);
+        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina, levelProgressAmount);
 
         this.Key = new KeyItem("Dragon Key", this);
     }
 
     public Dragon() {
-        this("Dragon", 5000, 5000, 0, 100, EntityState.ALIVE, null, null, null, new ArrayList<>(){}, 50, false, 50, 500, 500);
+        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

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

@@ -20,20 +20,30 @@ import java.util.Random;
 
 public abstract class Enemy extends Entity {
     protected KeyItem Key;
+    public int LevelProgressAmount;
 
     public Enemy (String name, int maxHealth, int health, long money, int baseDamage, EntityState state, Weapon weapon,
                    Shield shield, Costume costume, ArrayList<Item> inventory, int defenseBonus, boolean isDefending,
-                   int healAmount, int stamina, int maxStamina) {
+                   int healAmount, int stamina, int maxStamina, int levelProgressAmount) {
 
         super(name, maxHealth, health, stamina, maxStamina, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount);
 
         Key = new KeyItem(null, this);
+        LevelProgressAmount = levelProgressAmount;
     }
 
     protected Enemy() {
         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

@@ -14,15 +14,24 @@ import java.util.ArrayList;
 public class Goblin extends Enemy {
     public Goblin (String name, int maxHealth, int health, long money, int baseDamage, EntityState state, Weapon weapon,
                     Shield shield, Costume costume, ArrayList<Item> inventory, int defenseBonus, boolean isDefending,
-                    int healAmount, int stamina, int maxStamina) {
+                    int healAmount, int stamina, int maxStamina, int levelProgressAmount) {
 
-        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina);
+        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina, levelProgressAmount);
 
         this.Key = new KeyItem("Goblin Key", this);
     }
 
     public Goblin() {
-        this("Goblin", 75, 75, 100, 10, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 15, 100, 100);
+        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

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

@@ -18,15 +18,24 @@ public class Skeleton extends Enemy {
 
     public Skeleton (String name, int maxHealth, int health, long money, int baseDamage, EntityState state, Weapon weapon,
                     Shield shield, Costume costume, ArrayList<Item> inventory, int defenseBonus, boolean isDefending,
-                    int healAmount, int stamina, int maxStamina) {
+                    int healAmount, int stamina, int maxStamina, int levelProgressAmount) {
 
-        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina);
+        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina, levelProgressAmount);
 
         this.Key = new KeyItem("Skeleton Key", this);
     }
 
     public Skeleton() {
-        this("Skeleton", 125, 125, 200, 15, EntityState.ALIVE, null, null, null, new ArrayList<>(), 5, false, 20, 100, 100);
+        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
@@ -76,6 +85,7 @@ public class Skeleton extends Enemy {
         SetState(EntityState.ALIVE);
         Health = MaxHealth / 2;
         HasRevived = true;
+        entity.SetState(EntityState.FROZEN);
     }
 
     @Override

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

@@ -14,15 +14,24 @@ import java.util.ArrayList;
 public class Vampire extends Enemy {
     public Vampire (String name, int maxHealth, int health, long money, int baseDamage, EntityState state, Weapon weapon,
                    Shield shield, Costume costume, ArrayList<Item> inventory, int defenseBonus, boolean isDefending,
-                   int healAmount, int stamina, int maxStamina) {
+                   int healAmount, int stamina, int maxStamina, int levelProgressAmount) {
 
-        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina);
+        super(name, maxHealth, health, money, baseDamage, state, weapon, shield, costume, inventory, defenseBonus, isDefending, healAmount, stamina, maxStamina, levelProgressAmount);
 
         this.Key = new KeyItem("Vampire Key", this);
     }
 
     public Vampire() {
-        this("Vampire", 150, 150, 300, 20, EntityState.ALIVE, null, null, null, new ArrayList<>(), 8, false, 30, 100, 100);
+        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

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

@@ -27,12 +27,19 @@ 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);
-        entity.SetState(EntityState.FROZEN);
         Damage(entity, GetDamage() * 3, new AttackPowerUp[]{AttackPowerUp.NO_DEFENSE});
-        Heal(MaxHealth/4);
     }
 
 

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);
@@ -36,7 +45,7 @@ public class Knight extends Player {
 
     @Override
     public String GetSpecialAbilityDescription(Entity entity) {
-        return "Slam " + entity.Name + "with your unstoppable strength and stun them for the next turn";
+        return "Slam " + entity.Name + " with your unstoppable strength and stun them for the next turn";
     }
 
     @Override

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,12 +52,11 @@ public abstract class Player extends Entity {
         }
     }
 
-    public void LevelUp() {
+    public void UnconditionalLevelUp() {
         Level++;
         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);
@@ -57,20 +65,27 @@ public abstract class Player extends Entity {
         ModifyMoney(gift, true);
     }
 
+    public void LevelUp() {
+        while (LevelProgress >= 100) {
+            UnconditionalLevelUp();
+            LevelProgress -= 100;
+        }
+    }
+
     @Override
     public void LightAttack(IDamageable target) {
         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);

Java-Knight/src/main/java/org/project/item/Accessory/Accessory.java

@@ -45,13 +45,13 @@ public abstract class Accessory extends SellableItem implements IDamageable, IAt
 
     @Override
     public void HandleZeroHealth() {
-        this.DeattachFrom(this.Owner);
+        this.DeattachFrom(this.Owner, false);
         this.Owner.Inventory.remove(this);
     }
 
     @Override
-    public abstract void AttachTo(Entity entity);
+    public abstract void AttachTo(Entity entity, boolean fromInventory);
 
     @Override
-    public abstract void DeattachFrom(Entity entity);
+    public abstract void DeattachFrom(Entity entity, boolean toInventory);
 }

Java-Knight/src/main/java/org/project/item/Accessory/Costume.java

@@ -35,14 +35,14 @@ public class Costume extends Accessory implements IDefender {
     }
 
     @Override
-    public void AttachTo(Entity entity) {
-        entity.RemoveFromInventory(this);
+    public void AttachTo(Entity entity, boolean fromInventory) {
+        if (fromInventory) entity.RemoveFromInventory(this);
         entity.Costume = this;
     }
 
     @Override
-    public void DeattachFrom(Entity entity) {
+    public void DeattachFrom(Entity entity, boolean toInventory) {
         entity.Costume = null;
-        entity.AddToInventory(this);
+        if (toInventory) entity.AddToInventory(this);
     }
 }

Java-Knight/src/main/java/org/project/item/Accessory/Shield.java

@@ -35,14 +35,14 @@ public class Shield extends Accessory implements IDefender {
     }
 
     @Override
-    public void AttachTo(Entity entity) {
-        entity.RemoveFromInventory(this);
+    public void AttachTo(Entity entity, boolean fromInventory) {
+        if (fromInventory) entity.RemoveFromInventory(this);
         entity.Shield = this;
     }
 
     @Override
-    public void DeattachFrom(Entity entity) {
+    public void DeattachFrom(Entity entity, boolean toInventory) {
         entity.Shield = null;
-        entity.AddToInventory(this);
+        if (toInventory) entity.AddToInventory(this);
     }
 }

Java-Knight/src/main/java/org/project/item/Accessory/Weapon.java

@@ -17,14 +17,14 @@ public class Weapon extends Accessory implements IDamageUtil {
     }
 
     @Override
-    public void AttachTo(Entity entity) {
-        entity.RemoveFromInventory(this);
+    public void AttachTo(Entity entity, boolean fromInventory) {
+        if (fromInventory) entity.RemoveFromInventory(this);
         entity.Weapon = this;
     }
 
     @Override
-    public void DeattachFrom(Entity entity) {
+    public void DeattachFrom(Entity entity, boolean toInventory) {
         entity.Weapon = null;
-        entity.AddToInventory(this);
+        if (toInventory) entity.AddToInventory(this);
     }
 }

Java-Knight/src/main/java/org/project/location/Location.java

@@ -26,7 +26,7 @@ public abstract class Location {
             case 0 -> new GraveYard();
             case 1 -> new DarkCaves();
             case 2 -> new Jungle();
-            default -> null;
+            default -> new Jungle();
         };
     }
 }

Java-Knight/src/main/java/org/project/util/DisplayItem.java

@@ -1,4 +1,79 @@
 package org.project.util;
 
+import org.project.Interface.IDamageUtil;
+import org.project.Interface.IDefender;
+import org.project.constants.appConstants.TextColor;
+import org.project.item.Accessory.Accessory;
+import org.project.item.Item;
+import org.project.item.KeyItem;
+import org.project.item.SellableItem;
+
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+
 public class DisplayItem {
+    public static void DisplayItems(ArrayList<Item> items) {
+        for (Item item : items) {
+            if (item == null) continue;
+
+            String result = item.getName();
+
+            if (item instanceof SellableItem) {
+                result += "\n    Price = " + ((SellableItem) item).GetPrice();
+            }
+
+            if (item instanceof Accessory) {
+                result += "\n    Health = " + ((Accessory) item).GetHealth() + "/" + ((Accessory) item).GetMaxHealth();
+            }
+
+            if (item instanceof IDamageUtil) {
+                result += "\n    Damage = " + ((IDamageUtil) item).GetDamage();
+            }
+
+            if (item instanceof IDefender) {
+                result += "\n    Defence = " + ((IDefender) item).GetDefense();
+            }
+
+            System.out.println(result);
+        }
+    }
+
+    public static Dictionary<Integer, Item> MenuDisplay(ArrayList<Item> items) {
+        int index = 0;
+        Dictionary<Integer, Item> dictionary = new Hashtable<>();
+
+        for (Item item : items) {
+            if (item == null) continue;
+
+            String result = index + " > " + item.getName();
+
+            if (item instanceof KeyItem) {
+                result += TextColor.Yellow + "    (KEY ITEM)" + TextColor.Reset;
+            }
+
+            if (item instanceof SellableItem) {
+                result += "\n    Price = " + ((SellableItem) item).GetPrice();
+            }
+
+            if (item instanceof Accessory) {
+                result += "\n    Health = " + ((Accessory) item).GetHealth() + "/" + ((Accessory) item).GetMaxHealth();
+            }
+
+            if (item instanceof IDamageUtil) {
+                result += "\n    Damage = " + ((IDamageUtil) item).GetDamage();
+            }
+
+            if (item instanceof IDefender) {
+                result += "\n    Defence = " + ((IDefender) item).GetDefense();
+            }
+
+            dictionary.put(index, item);
+            index++;
+
+            System.out.println(result);
+        }
+
+        return dictionary;
+    }
 }