From a527c5bcfaad81eb121f8946e9204c82a4cb36e7 Mon Sep 17 00:00:00 2001
From: Faraz Ardeh <fa.ardeh@gmail.com>
Date: Sun, 12 Jul 2026 19:20:33 +0330
Subject: [PATCH] Java Knight

---
 .idea/jarRepositories.xml                     |   5 +
 Java-Knight/pom.xml                           |   4 +-
 .../src/main/java/org/project/Game.java       | 345 ++++++++++++++++++
 .../src/main/java/org/project/Main.java       |  14 +-
 .../src/main/java/org/project/Merchant.java   | 100 +++++
 .../main/java/org/project/entity/Entity.java  |  24 +-
 .../org/project/entity/enemies/Dragon.java    |  30 ++
 .../org/project/entity/enemies/Enemy.java     | 129 ++++++-
 .../org/project/entity/enemies/Goblin.java    |  31 ++
 .../org/project/entity/enemies/KeyType.java   |  22 ++
 .../org/project/entity/enemies/Skeleton.java  |  31 +-
 .../org/project/entity/enemies/Vampire.java   |  28 ++
 .../org/project/entity/players/Assassin.java  |  42 +++
 .../entity/players/ICombatActions.java        |  24 ++
 .../org/project/entity/players/Knight.java    |  46 ++-
 .../org/project/entity/players/Player.java    | 287 ++++++++++++++-
 .../org/project/entity/players/Wizard.java    |  44 +++
 .../src/main/java/org/project/item/Item.java  |  15 +-
 .../java/org/project/item/armors/Armor.java   |  53 ++-
 .../org/project/item/armors/KnightArmor.java  |  14 +-
 .../org/project/item/armors/LeatherArmor.java |  12 +
 .../java/org/project/item/armors/Robe.java    |  12 +
 .../project/item/consumables/Consumable.java  |  39 +-
 .../org/project/item/consumables/Flask.java   |  19 +-
 .../project/item/consumables/ManaPotion.java  |  22 ++
 .../java/org/project/item/weapons/Dagger.java |  12 +
 .../org/project/item/weapons/GreatAxe.java    |  12 +
 .../java/org/project/item/weapons/Staff.java  |  12 +
 .../java/org/project/item/weapons/Sword.java  |  29 +-
 .../java/org/project/item/weapons/Weapon.java |  37 +-
 .../java/org/project/location/Location.java   |  31 +-
 .../java/org/project/util/ConsoleColors.java  |  55 +++
 .../src/main/java/org/project/util/Dice.java  |  26 ++
 .../target/classes/org/project/Game.class     | Bin 0 -> 10957 bytes
 .../target/classes/org/project/Main.class     | Bin 0 -> 1017 bytes
 .../target/classes/org/project/Merchant.class | Bin 0 -> 4366 bytes
 .../classes/org/project/entity/Entity.class   | Bin 0 -> 388 bytes
 .../org/project/entity/enemies/Dragon.class   | Bin 0 -> 1149 bytes
 .../org/project/entity/enemies/Enemy.class    | Bin 0 -> 3183 bytes
 .../org/project/entity/enemies/Goblin.class   | Bin 0 -> 1329 bytes
 .../org/project/entity/enemies/KeyType.class  | Bin 0 -> 1470 bytes
 .../org/project/entity/enemies/Skeleton.class | Bin 0 -> 1605 bytes
 .../org/project/entity/enemies/Vampire.class  | Bin 0 -> 1729 bytes
 .../org/project/entity/players/Assassin.class | Bin 0 -> 1941 bytes
 .../entity/players/ICombatActions.class       | Bin 0 -> 282 bytes
 .../org/project/entity/players/Knight.class   | Bin 0 -> 2187 bytes
 .../org/project/entity/players/Player.class   | Bin 0 -> 8959 bytes
 .../org/project/entity/players/Wizard.class   | Bin 0 -> 2171 bytes
 .../classes/org/project/item/Item.class       | Bin 0 -> 219 bytes
 .../org/project/item/armors/Armor.class       | Bin 0 -> 1559 bytes
 .../org/project/item/armors/KnightArmor.class | Bin 0 -> 375 bytes
 .../project/item/armors/LeatherArmor.class    | Bin 0 -> 378 bytes
 .../org/project/item/armors/Robe.class        | Bin 0 -> 351 bytes
 .../project/item/consumables/Consumable.class | Bin 0 -> 752 bytes
 .../org/project/item/consumables/Flask.class  | Bin 0 -> 1414 bytes
 .../project/item/consumables/ManaPotion.class | Bin 0 -> 1432 bytes
 .../org/project/item/weapons/Dagger.class     | Bin 0 -> 364 bytes
 .../org/project/item/weapons/GreatAxe.class   | Bin 0 -> 368 bytes
 .../org/project/item/weapons/Staff.class      | Bin 0 -> 358 bytes
 .../org/project/item/weapons/Sword.class      | Bin 0 -> 1262 bytes
 .../org/project/item/weapons/Weapon.class     | Bin 0 -> 1102 bytes
 .../org/project/location/Location.class       | Bin 0 -> 921 bytes
 .../org/project/util/ConsoleColors.class      | Bin 0 -> 1732 bytes
 .../classes/org/project/util/Dice.class       | Bin 0 -> 659 bytes
 .../compile/default-compile/createdFiles.lst  |  31 ++
 .../compile/default-compile/inputFiles.lst    |  31 ++
 README.md                                     | 328 +++++++++--------
 67 files changed, 1742 insertions(+), 254 deletions(-)
 create mode 100644 Java-Knight/src/main/java/org/project/Game.java
 create mode 100644 Java-Knight/src/main/java/org/project/Merchant.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/enemies/KeyType.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/players/Assassin.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java
 create mode 100644 Java-Knight/src/main/java/org/project/entity/players/Wizard.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/armors/LeatherArmor.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/armors/Robe.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/consumables/ManaPotion.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/weapons/Dagger.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/weapons/GreatAxe.java
 create mode 100644 Java-Knight/src/main/java/org/project/item/weapons/Staff.java
 create mode 100644 Java-Knight/src/main/java/org/project/util/ConsoleColors.java
 create mode 100644 Java-Knight/src/main/java/org/project/util/Dice.java
 create mode 100644 Java-Knight/target/classes/org/project/Game.class
 create mode 100644 Java-Knight/target/classes/org/project/Main.class
 create mode 100644 Java-Knight/target/classes/org/project/Merchant.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/Entity.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/Dragon.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/Enemy.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/Goblin.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/KeyType.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/Skeleton.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/enemies/Vampire.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/players/Assassin.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/players/ICombatActions.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/players/Knight.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/players/Player.class
 create mode 100644 Java-Knight/target/classes/org/project/entity/players/Wizard.class
 create mode 100644 Java-Knight/target/classes/org/project/item/Item.class
 create mode 100644 Java-Knight/target/classes/org/project/item/armors/Armor.class
 create mode 100644 Java-Knight/target/classes/org/project/item/armors/KnightArmor.class
 create mode 100644 Java-Knight/target/classes/org/project/item/armors/LeatherArmor.class
 create mode 100644 Java-Knight/target/classes/org/project/item/armors/Robe.class
 create mode 100644 Java-Knight/target/classes/org/project/item/consumables/Consumable.class
 create mode 100644 Java-Knight/target/classes/org/project/item/consumables/Flask.class
 create mode 100644 Java-Knight/target/classes/org/project/item/consumables/ManaPotion.class
 create mode 100644 Java-Knight/target/classes/org/project/item/weapons/Dagger.class
 create mode 100644 Java-Knight/target/classes/org/project/item/weapons/GreatAxe.class
 create mode 100644 Java-Knight/target/classes/org/project/item/weapons/Staff.class
 create mode 100644 Java-Knight/target/classes/org/project/item/weapons/Sword.class
 create mode 100644 Java-Knight/target/classes/org/project/item/weapons/Weapon.class
 create mode 100644 Java-Knight/target/classes/org/project/location/Location.class
 create mode 100644 Java-Knight/target/classes/org/project/util/ConsoleColors.class
 create mode 100644 Java-Knight/target/classes/org/project/util/Dice.class
 create mode 100644 Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
 create mode 100644 Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst

diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index 4158879..036c7e3 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -1,6 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="RemoteRepositoriesConfiguration">
+    <remote-repository>
+      <option name="id" value="central" />
+      <option name="name" value="Central Repository" />
+      <option name="url" value="https://repo.maven.apache.org/maven2" />
+    </remote-repository>
     <remote-repository>
       <option name="id" value="central" />
       <option name="name" value="Central Repository" />
diff --git a/Java-Knight/pom.xml b/Java-Knight/pom.xml
index 863ff5c..7245eaf 100644
--- a/Java-Knight/pom.xml
+++ b/Java-Knight/pom.xml
@@ -9,8 +9,8 @@
     <version>1.0-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.source>25</maven.compiler.source>
-        <maven.compiler.target>25</maven.compiler.target>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
diff --git a/Java-Knight/src/main/java/org/project/Game.java b/Java-Knight/src/main/java/org/project/Game.java
new file mode 100644
index 0000000..8b557f6
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/Game.java
@@ -0,0 +1,345 @@
+package org.project;
+
+import org.project.entity.enemies.Dragon;
+import org.project.entity.enemies.Enemy;
+import org.project.entity.enemies.KeyType;
+import org.project.entity.players.Assassin;
+import org.project.entity.players.Knight;
+import org.project.entity.players.Player;
+import org.project.entity.players.Wizard;
+import org.project.item.consumables.Consumable;
+import org.project.location.Location;
+import org.project.util.ConsoleColors;
+import org.project.util.Dice;
+
+import java.util.List;
+import java.util.Scanner;
+
+/**
+ * The main game controller. It owns the player, the world's locations and the
+ * merchant, and drives the whole flow: class selection, the exploration menu,
+ * turn-based combat, progression, and the final Dragon fight.
+ *
+ * All the polymorphism set up in the class hierarchy pays off here — the combat
+ * loop only ever calls methods on {@code Player} and {@code Enemy}, and each
+ * concrete class fills in its own behaviour.
+ */
+public class Game {
+
+    private final Scanner scanner = new Scanner(System.in);
+    private final List<Location> locations;
+    private final Merchant merchant = new Merchant(scanner);
+
+    private Player player;
+    private boolean running = true;
+
+    public Game(List<Location> locations) {
+        this.locations = locations;
+    }
+
+    // ------------------------------------------------------------------
+    //  Top-level flow
+    // ------------------------------------------------------------------
+
+    public void start() {
+        printPrologue();
+        chooseClass();
+        explorationLoop();
+    }
+
+    private void printPrologue() {
+        System.out.println(ConsoleColors.bold(ConsoleColors.CYAN + "\n=== JAVA KNIGHT ===" + ConsoleColors.RESET));
+        System.out.println(ConsoleColors.cyan(
+                "For centuries, the land of Javanest lived in peace, until a magical Dragon\n"
+                + "plunged it into darkness, cursing its people into monsters. It split the three\n"
+                + "keys to its lair among them. Collect all three keys, grow strong, and slay the\n"
+                + "Dragon to break the curse!\n"));
+    }
+
+    private void chooseClass() {
+        System.out.print("Name your hero: ");
+        String name = scanner.hasNextLine() ? scanner.nextLine().trim() : "Hero";
+        if (name.isEmpty()) {
+            name = "Hero";
+        }
+
+        System.out.println("\nChoose your class:");
+        System.out.println("1. " + ConsoleColors.cyan("Knight")
+                + "  ⚔️  Highest base damage, sturdy armor. Special: Shield Bash (stun).");
+        System.out.println("2. " + ConsoleColors.purple("Wizard")
+                + "  🧙  Highest HP. Special: Arcane Blast (damage + self-heal).");
+        System.out.println("3. " + ConsoleColors.yellow("Assassin")
+                + " 🗡️  Highest mana. Special: Vanish (dodge + guaranteed crit).");
+
+        int choice = readChoice(1, 3);
+        player = switch (choice) {
+            case 1 -> new Knight(name);
+            case 2 -> new Wizard(name);
+            default -> new Assassin(name);
+        };
+        System.out.println(ConsoleColors.green("\nWelcome, " + player.getName() + " the " + player.getClassName() + "!"));
+    }
+
+    // ------------------------------------------------------------------
+    //  Exploration menu
+    // ------------------------------------------------------------------
+
+    private void explorationLoop() {
+        while (running && player.isAlive()) {
+            Location location = locations.get(Dice.between(0, locations.size() - 1));
+            Enemy enemy = location.spawnEnemy();
+
+            System.out.println(ConsoleColors.bold("\n────────────────────────────────────────"));
+            System.out.println("You arrive at " + ConsoleColors.cyan(location.getName())
+                    + ". A wild " + ConsoleColors.red(enemy.getName()) + " appears!");
+            printKeyProgress();
+
+            // Decide what to do about this particular enemy.
+            boolean encounterOngoing = true;
+            while (encounterOngoing && running && player.isAlive()) {
+                System.out.println("\nWhat will you do?");
+                System.out.println("1. Fight the " + enemy.getName());
+                System.out.println("2. Move to another location");
+                System.out.println("3. Visit the Merchant");
+                if (player.hasAllKeys()) {
+                    System.out.println("4. " + ConsoleColors.bold("Go to the Castle to face the Dragon 🐉"));
+                }
+
+                int max = player.hasAllKeys() ? 4 : 3;
+                int choice = readChoice(1, max);
+                switch (choice) {
+                    case 1 -> {
+                        boolean won = combat(enemy);
+                        if (!won) {
+                            gameOver();
+                            return;
+                        }
+                        afterVictory(enemy);
+                        encounterOngoing = false; // move on to a new encounter
+                    }
+                    case 2 -> {
+                        System.out.println("You slip away to find another path...");
+                        encounterOngoing = false;
+                    }
+                    case 3 -> merchant.visit(player);
+                    case 4 -> {
+                        castleFight();
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    // ------------------------------------------------------------------
+    //  Combat
+    // ------------------------------------------------------------------
+
+    /** Runs a full turn-based battle. Returns true if the player survives. */
+    private boolean combat(Enemy enemy) {
+        System.out.println(ConsoleColors.bold("\nYou chose to FIGHT!"));
+
+        while (player.isAlive() && enemy.isAlive()) {
+            printCombatStatus(enemy);
+            playerTurn(enemy);
+
+            if (enemy.isAlive()) {
+                enemyTurn(enemy);
+            }
+        }
+        return player.isAlive();
+    }
+
+    private void printCombatStatus(Enemy enemy) {
+        System.out.println();
+        System.out.println(ConsoleColors.green("[" + player.getName() + " (" + player.getClassName() + ") - "
+                + player.getHp() + "/" + player.getMaxHP() + " HP | "
+                + player.getMp() + "/" + player.getMaxMP() + " Mana]  Lv." + player.getLevel()));
+        System.out.println(ConsoleColors.red("[" + enemy.getName() + " - "
+                + enemy.getHp() + "/" + enemy.getMaxHP() + " HP]"));
+        System.out.println("---");
+    }
+
+    /** Handle exactly one player action (loops until a valid one is chosen). */
+    private void playerTurn(Enemy enemy) {
+        System.out.println(ConsoleColors.bold("\nYour Turn:"));
+        System.out.println("1. Light Attack | 2. Heavy Attack " + ConsoleColors.blue("(-" + Player.HEAVY_COST + " Mana)")
+                + " | 3. Defend " + ConsoleColors.blue("(-" + Player.DEFEND_COST + " Mana)")
+                + " | 4. Heal " + ConsoleColors.blue("(-" + Player.HEAL_COST + " Mana)")
+                + " | 5. " + player.getSpecialName() + " " + ConsoleColors.blue("(-" + Player.SPECIAL_COST + " Mana)")
+                + " | 6. Use Item");
+
+        while (true) {
+            int choice = readChoice(1, 6);
+            switch (choice) {
+                case 1 -> {
+                    player.lightAttack(enemy);
+                    return;
+                }
+                case 2 -> {
+                    if (requireMana(Player.HEAVY_COST)) {
+                        player.heavyAttack(enemy);
+                        return;
+                    }
+                }
+                case 3 -> {
+                    if (requireMana(Player.DEFEND_COST)) {
+                        player.defend();
+                        return;
+                    }
+                }
+                case 4 -> {
+                    if (requireMana(Player.HEAL_COST)) {
+                        player.healAction();
+                        return;
+                    }
+                }
+                case 5 -> {
+                    if (requireMana(Player.SPECIAL_COST)) {
+                        player.specialAbility(enemy);
+                        return;
+                    }
+                }
+                case 6 -> {
+                    if (useItemMenu()) {
+                        return;
+                    }
+                }
+            }
+        }
+    }
+
+    private boolean requireMana(int cost) {
+        if (player.canAfford(cost)) {
+            return true;
+        }
+        System.out.println(ConsoleColors.blue("Not enough Mana! Pick another action."));
+        return false;
+    }
+
+    /**
+     * Show the inventory and use a chosen consumable. Returns true if an item was
+     * used (which consumes the turn), false if the player had nothing / cancelled.
+     */
+    private boolean useItemMenu() {
+        List<Consumable> inv = player.getInventory();
+        if (inv.isEmpty()) {
+            System.out.println("Your inventory is empty!");
+            return false;
+        }
+        System.out.println("Choose an item to use (0 to cancel):");
+        for (int i = 0; i < inv.size(); i++) {
+            System.out.println((i + 1) + ". " + inv.get(i).getName());
+        }
+        int choice = readChoice(0, inv.size());
+        if (choice == 0) {
+            return false;
+        }
+        player.useConsumable(choice - 1);
+        return true;
+    }
+
+    private void enemyTurn(Enemy enemy) {
+        System.out.println(ConsoleColors.bold("\n" + enemy.getName() + "'s Turn:"));
+        if (enemy.isStunned()) {
+            enemy.clearStun();
+            System.out.println(ConsoleColors.yellow("😵 " + enemy.getName() + " is stunned and skips its turn!"));
+            return;
+        }
+        enemy.attack(player);
+    }
+
+    // ------------------------------------------------------------------
+    //  Post-combat rewards & progression
+    // ------------------------------------------------------------------
+
+    private void afterVictory(Enemy enemy) {
+        System.out.println(ConsoleColors.bold(ConsoleColors.GREEN
+                + "\n🏆 The " + enemy.getName() + " is defeated!" + ConsoleColors.RESET));
+
+        player.gainXP(enemy.getXpReward());
+
+        int coins = Math.max(0, Dice.between(enemy.getCoinReward() - 4, enemy.getCoinReward() + 4));
+        player.addCoins(coins);
+        System.out.println(ConsoleColors.yellow("💰 Found " + coins + " coins (total: " + player.getCoins() + ")."));
+
+        tryKeyDrop(enemy);
+
+        player.restoreAfterBattle();
+        System.out.println(ConsoleColors.green("You catch your breath — HP and Mana fully restored."));
+    }
+
+    /** Roll for the enemy's unique key, respecting the one-key-per-species rule. */
+    private void tryKeyDrop(Enemy enemy) {
+        KeyType key = enemy.getKeyType();
+        if (key == null || player.hasKey(key)) {
+            return; // Dragon has no key, or we already own this one
+        }
+        if (Dice.chance(enemy.getKeyDropChance())) {
+            player.addKey(key);
+            System.out.println(ConsoleColors.bold(ConsoleColors.PURPLE
+                    + "🗝️  The " + enemy.getName() + " dropped the " + key.getDisplayName() + "!" + ConsoleColors.RESET));
+            printKeyProgress();
+        }
+    }
+
+    private void printKeyProgress() {
+        StringBuilder sb = new StringBuilder("Keys: ");
+        for (KeyType key : KeyType.values()) {
+            sb.append(player.hasKey(key) ? ConsoleColors.green("[" + key.getDisplayName() + "] ")
+                    : ConsoleColors.red("[???] "));
+        }
+        System.out.println(sb.toString().trim());
+    }
+
+    // ------------------------------------------------------------------
+    //  Endgame
+    // ------------------------------------------------------------------
+
+    private void castleFight() {
+        System.out.println(ConsoleColors.bold(ConsoleColors.RED
+                + "\nYou march to the Castle. The ground trembles as the Dragon awakens...\n" + ConsoleColors.RESET));
+        Dragon dragon = new Dragon();
+
+        boolean won = combat(dragon);
+        if (won) {
+            System.out.println(ConsoleColors.bold(ConsoleColors.GREEN
+                    + "\n🎉 VICTORY! The Dragon falls, the curse breaks, and peace returns to Javanest!"
+                    + ConsoleColors.RESET));
+            System.out.println(ConsoleColors.green("You are the Java Knight. 🛡️"));
+        } else {
+            gameOver();
+        }
+        running = false;
+    }
+
+    private void gameOver() {
+        System.out.println(ConsoleColors.bold(ConsoleColors.RED
+                + "\n💀 GAME OVER — " + player.getName() + " has fallen. Darkness consumes Javanest..."
+                + ConsoleColors.RESET));
+        running = false;
+    }
+
+    // ------------------------------------------------------------------
+    //  Input helper
+    // ------------------------------------------------------------------
+
+    /** Read an integer choice in [min, max], re-prompting on bad input. */
+    private int readChoice(int min, int max) {
+        while (true) {
+            System.out.print(ConsoleColors.bold("> "));
+            if (!scanner.hasNextLine()) {
+                return min; // no more input: pick the safe default so we don't loop forever
+            }
+            try {
+                int value = Integer.parseInt(scanner.nextLine().trim());
+                if (value >= min && value <= max) {
+                    return value;
+                }
+            } catch (NumberFormatException ignored) {
+                // fall through to re-prompt
+            }
+            System.out.println("Please enter a number between " + min + " and " + max + ".");
+        }
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/Main.java b/Java-Knight/src/main/java/org/project/Main.java
index 6bde20e..760eb3c 100644
--- a/Java-Knight/src/main/java/org/project/Main.java
+++ b/Java-Knight/src/main/java/org/project/Main.java
@@ -5,11 +5,19 @@ import org.project.location.Location;
 import java.util.ArrayList;
 import java.util.List;
 
+/**
+ * Entry point. Builds the world (a handful of locations) and starts the game.
+ */
 public class Main {
     public static void main(String[] args) {
-        // TODO: ADD LOCATIONS TO YOUR GAME
         List<Location> locations = new ArrayList<>();
+        locations.add(new Location("Whispering Woods"));
+        locations.add(new Location("Forgotten Crypt"));
+        locations.add(new Location("Bleak Marsh"));
+        locations.add(new Location("Ruined Village"));
+        locations.add(new Location("Frostpeak Pass"));
 
-        // TODO: IMPLEMENT GAMEPLAY
+        Game game = new Game(locations);
+        game.start();
     }
-}
\ No newline at end of file
+}
diff --git a/Java-Knight/src/main/java/org/project/Merchant.java b/Java-Knight/src/main/java/org/project/Merchant.java
new file mode 100644
index 0000000..c36ab41
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/Merchant.java
@@ -0,0 +1,100 @@
+package org.project;
+
+import org.project.entity.players.Player;
+import org.project.item.consumables.Flask;
+import org.project.item.consumables.ManaPotion;
+import org.project.item.weapons.GreatAxe;
+import org.project.item.weapons.Weapon;
+import org.project.util.ConsoleColors;
+
+import java.util.Scanner;
+
+/**
+ * Bonus feature: a shop where the player spends coins earned in battle on
+ * consumables, a stronger weapon, or armor repairs.
+ */
+public class Merchant {
+
+    private static final int REPAIR_COST = 15;
+
+    private final Scanner scanner;
+
+    public Merchant(Scanner scanner) {
+        this.scanner = scanner;
+    }
+
+    public void visit(Player player) {
+        System.out.println(ConsoleColors.yellow("\n🧙 Merchant: \"Welcome, traveler. Coin buys survival out here.\""));
+
+        boolean shopping = true;
+        while (shopping) {
+            System.out.println(ConsoleColors.bold("\n--- Merchant's Wares ---"));
+            System.out.println("You have " + ConsoleColors.yellow(player.getCoins() + " coins") + ".");
+            System.out.println("1. Health Flask (heals 25 HP) - 20 coins");
+            System.out.println("2. Mana Potion (restores 20 Mana) - 20 coins");
+            System.out.println("3. Great Axe (12 damage weapon) - 80 coins");
+            System.out.println("4. Repair Armor - " + REPAIR_COST + " coins");
+            System.out.println("5. Leave");
+
+            int choice = readChoice(1, 5);
+            switch (choice) {
+                case 1 -> buyConsumable(player, new Flask(), 20);
+                case 2 -> buyConsumable(player, new ManaPotion(), 20);
+                case 3 -> buyWeapon(player, new GreatAxe());
+                case 4 -> repairArmor(player);
+                case 5 -> shopping = false;
+            }
+        }
+        System.out.println(ConsoleColors.yellow("🧙 Merchant: \"Safe travels, hero.\"\n"));
+    }
+
+    private void buyConsumable(Player player, org.project.item.consumables.Consumable item, int price) {
+        if (player.spendCoins(price)) {
+            player.addConsumable(item);
+            System.out.println(ConsoleColors.green("Bought a " + item.getName() + "! Added to your inventory."));
+        } else {
+            notEnough();
+        }
+    }
+
+    private void buyWeapon(Player player, Weapon weapon) {
+        if (player.spendCoins(weapon.getPrice())) {
+            player.setWeapon(weapon);
+            System.out.println(ConsoleColors.green("You equip the " + weapon.getName()
+                    + " (" + weapon.getDamage() + " damage)!"));
+        } else {
+            notEnough();
+        }
+    }
+
+    private void repairArmor(Player player) {
+        if (player.spendCoins(REPAIR_COST)) {
+            player.getArmor().repair();
+            System.out.println(ConsoleColors.green("Your " + player.getArmor().getName() + " is fully repaired."));
+        } else {
+            notEnough();
+        }
+    }
+
+    private void notEnough() {
+        System.out.println(ConsoleColors.red("Not enough coins!"));
+    }
+
+    private int readChoice(int min, int max) {
+        while (true) {
+            System.out.print("> ");
+            if (!scanner.hasNextLine()) {
+                return max; // treat end-of-input as "Leave"
+            }
+            try {
+                int value = Integer.parseInt(scanner.nextLine().trim());
+                if (value >= min && value <= max) {
+                    return value;
+                }
+            } catch (NumberFormatException ignored) {
+                // fall through and re-prompt
+            }
+            System.out.println("Please enter a number between " + min + " and " + max + ".");
+        }
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/Entity.java b/Java-Knight/src/main/java/org/project/entity/Entity.java
index 2a060f9..9c39fa8 100644
--- a/Java-Knight/src/main/java/org/project/entity/Entity.java
+++ b/Java-Knight/src/main/java/org/project/entity/Entity.java
@@ -1,21 +1,39 @@
 package org.project.entity;
 
+/**
+ * The common contract that everything able to fight in the game must follow.
+ *
+ * Both {@code Player} and {@code Enemy} implement this interface, which is what
+ * lets the combat loop treat a Knight and a Dragon the same way (polymorphism):
+ * it only ever talks to an {@code Entity}.
+ */
 public interface Entity {
+
+    /** Perform this entity's basic attack against a target. */
     void attack(Entity target);
 
+    /** Put the entity into a defensive stance for the next incoming hit. */
     void defend();
 
+    /** Restore some health (capped at the maximum). */
     void heal(int health);
 
+    /** Restore some mana/stamina (capped at the maximum). */
     void fillMana(int mana);
 
+    /** Apply incoming damage to this entity. */
     void takeDamage(int damage);
 
+    String getName();
+
+    int getHp();
+
     int getMaxHP();
 
+    int getMp();
+
     int getMaxMP();
 
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
+    /** @return true while the entity still has health left. */
+    boolean isAlive();
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java b/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
new file mode 100644
index 0000000..0362bdb
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
@@ -0,0 +1,30 @@
+package org.project.entity.enemies;
+
+import org.project.entity.Entity;
+import org.project.entity.players.Player;
+import org.project.util.ConsoleColors;
+
+/**
+ * Dragon 🐉 — the final boss. Enormous HP and damage. Its fiery breath is "true
+ * damage": it bypasses armor and the player's defend stance entirely by calling
+ * the overloaded {@link Player#takeDamage(int, boolean)} with {@code true}.
+ *
+ * Even though it is the boss, it still extends {@link Enemy} so it reuses all
+ * the common combat plumbing — exactly what the assignment asks for.
+ */
+public class Dragon extends Enemy {
+
+    public Dragon() {
+        super("Dragon", 160, 26, 120, 100, null, 0);
+    }
+
+    @Override
+    public void attack(Entity target) {
+        System.out.println(ConsoleColors.red("🐉🔥 The Dragon unleashes a torrent of fire that bypasses all defenses!"));
+        if (target instanceof Player player) {
+            player.takeDamage(damage, true); // true = ignore armor and shields
+        } else {
+            target.takeDamage(damage);
+        }
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java b/Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java
index e019acb..f2a131b 100644
--- a/Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java
@@ -1,34 +1,137 @@
 package org.project.entity.enemies;
 
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.util.ConsoleColors;
 
-// TODO: UPDATE IMPLEMENTATION
-public abstract class Enemy {
-    Weapon weapon;
+/**
+ * Abstract base for every monster, including the Dragon boss.
+ *
+ * It holds the stats and rewards shared by all enemies and provides a plain
+ * default attack. Each subclass overrides {@link #attack(Entity)} (and sometimes
+ * {@link #takeDamage(int)}) to add its signature ability — a crit, a
+ * resurrection, lifesteal, or armor-piercing fire.
+ */
+public abstract class Enemy implements Entity {
+
+    protected String name;
     private int hp;
-    private int mp;
+    private final int maxHP;
+    protected int damage;
 
-    public Enemy(int hp, int mp, Weapon weapon) {
-        this.hp = hp;
-        this.mp = mp;
+    private final int xpReward;
+    private final int coinReward;
+    private final KeyType keyType;      // null for the Dragon (it drops no key)
+    private final int keyDropChance;    // percent chance to drop its key
 
-        this.weapon = weapon;
+    private boolean stunned = false;
+
+    protected Enemy(String name, int maxHP, int damage,
+                    int xpReward, int coinReward, KeyType keyType, int keyDropChance) {
+        this.name = name;
+        this.maxHP = maxHP;
+        this.hp = maxHP;
+        this.damage = damage;
+        this.xpReward = xpReward;
+        this.coinReward = coinReward;
+        this.keyType = keyType;
+        this.keyDropChance = keyDropChance;
+    }
+
+    /** Default attack: hit the target for this enemy's damage. */
+    @Override
+    public void attack(Entity target) {
+        System.out.println(ConsoleColors.red("👾 " + name + " attacks!"));
+        target.takeDamage(damage);
     }
 
     @Override
     public void takeDamage(int damage) {
         hp -= damage;
+        if (hp < 0) {
+            hp = 0;
+        }
+        // Note: the attacker prints the damage/HP lines, so this stays quiet.
     }
 
+    /** Enemies don't have a defensive stance in this game. */
+    @Override
+    public void defend() {
+        // no-op
+    }
+
+    @Override
+    public void heal(int health) {
+        hp += health;
+        if (hp > maxHP) {
+            hp = maxHP;
+        }
+    }
+
+    /** Enemies use no mana, so this does nothing. */
+    @Override
+    public void fillMana(int mana) {
+        // no-op
+    }
+
+    // --- Stun handling (used by the Knight's Shield Bash) ---
+
+    public void stun() {
+        stunned = true;
+    }
+
+    public boolean isStunned() {
+        return stunned;
+    }
+
+    public void clearStun() {
+        stunned = false;
+    }
+
+    // --- Getters ---
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
     public int getHp() {
         return hp;
     }
 
-    public int getMp() {
-        return mp;
+    @Override
+    public int getMaxHP() {
+        return maxHP;
     }
 
-    public Weapon getWeapon() {
-        return weapon;
+    @Override
+    public int getMp() {
+        return 0;
+    }
+
+    @Override
+    public int getMaxMP() {
+        return 0;
+    }
+
+    @Override
+    public boolean isAlive() {
+        return hp > 0;
+    }
+
+    public int getXpReward() {
+        return xpReward;
+    }
+
+    public int getCoinReward() {
+        return coinReward;
+    }
+
+    public KeyType getKeyType() {
+        return keyType;
+    }
+
+    public int getKeyDropChance() {
+        return keyDropChance;
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java b/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
new file mode 100644
index 0000000..d24f63f
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
@@ -0,0 +1,31 @@
+package org.project.entity.enemies;
+
+import org.project.entity.Entity;
+import org.project.util.ConsoleColors;
+import org.project.util.Dice;
+
+/**
+ * Goblin 👹 — low health, but a high chance to land a devastating critical hit.
+ * Drops the Goblin Key.
+ */
+public class Goblin extends Enemy {
+
+    private static final int CRIT_CHANCE = 40; // percent
+
+    public Goblin() {
+        super("Goblin", 30, 8, 20, 12, KeyType.GOBLIN, 25);
+    }
+
+    @Override
+    public void attack(Entity target) {
+        if (Dice.chance(CRIT_CHANCE)) {
+            int critDamage = damage * 2;
+            System.out.println(ConsoleColors.red("👹 Goblin used Critical Strike!"));
+            System.out.println(ConsoleColors.red("💥 Critical hit!"));
+            target.takeDamage(critDamage);
+        } else {
+            System.out.println(ConsoleColors.red("👹 Goblin lunges with a rusty blade!"));
+            target.takeDamage(damage);
+        }
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/KeyType.java b/Java-Knight/src/main/java/org/project/entity/enemies/KeyType.java
new file mode 100644
index 0000000..e953d1a
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/KeyType.java
@@ -0,0 +1,22 @@
+package org.project.entity.enemies;
+
+/**
+ * The three keys that the Dragon scattered among the cursed monsters.
+ * Each standard enemy species is tied to exactly one key type, and the player
+ * needs all three to unlock the castle.
+ */
+public enum KeyType {
+    GOBLIN("Goblin Key"),
+    SKELETON("Skeleton Key"),
+    VAMPIRE("Vampire Key");
+
+    private final String displayName;
+
+    KeyType(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java b/Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java
index 8a6a555..eeecd39 100644
--- a/Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java
@@ -1,6 +1,31 @@
 package org.project.entity.enemies;
 
-// TODO: UPDATE IMPLEMENTATION
-public class Skeleton {
-    // TODO: DESIGN ENEMY AND IMPLEMENT THE CONSTRUCTOR
+import org.project.util.ConsoleColors;
+
+/**
+ * Skeleton ☠️ — a bag of bones that can pull itself back together once per
+ * battle, returning to 50% HP the first time it would die. Drops the Skeleton
+ * Key.
+ */
+public class Skeleton extends Enemy {
+
+    private boolean hasResurrected = false;
+
+    public Skeleton() {
+        super("Skeleton", 40, 10, 25, 14, KeyType.SKELETON, 25);
+    }
+
+    @Override
+    public void takeDamage(int damage) {
+        super.takeDamage(damage);
+
+        // First time it drops to 0, it revives at half health.
+        if (getHp() <= 0 && !hasResurrected) {
+            hasResurrected = true;
+            int revived = getMaxHP() / 2;
+            heal(revived); // hp was 0, so this sets it to 50% of max
+            System.out.println(ConsoleColors.purple(
+                    "☠️ The Skeleton collapses into a pile of bones... then reassembles with " + getHp() + " HP!"));
+        }
+    }
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java b/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
new file mode 100644
index 0000000..fddbde2
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
@@ -0,0 +1,28 @@
+package org.project.entity.enemies;
+
+import org.project.entity.Entity;
+import org.project.util.ConsoleColors;
+
+/**
+ * Vampire 🦇 — heals itself for a portion of the damage it deals (lifesteal),
+ * making it a war of attrition. Drops the Vampire Key.
+ */
+public class Vampire extends Enemy {
+
+    private static final double LIFESTEAL = 0.5; // heals for 50% of damage dealt
+
+    public Vampire() {
+        super("Vampire", 48, 11, 30, 16, KeyType.VAMPIRE, 25);
+    }
+
+    @Override
+    public void attack(Entity target) {
+        System.out.println(ConsoleColors.red("🦇 Vampire sinks its fangs in!"));
+        target.takeDamage(damage);
+
+        int stolen = (int) (damage * LIFESTEAL);
+        heal(stolen);
+        System.out.println(ConsoleColors.green(
+                "🩸 Vampire drains " + stolen + " HP and now has " + getHp() + "/" + getMaxHP() + " HP."));
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/players/Assassin.java b/Java-Knight/src/main/java/org/project/entity/players/Assassin.java
new file mode 100644
index 0000000..f1a2cc9
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/players/Assassin.java
@@ -0,0 +1,42 @@
+package org.project.entity.players;
+
+import org.project.entity.Entity;
+import org.project.item.armors.LeatherArmor;
+import org.project.item.weapons.Dagger;
+import org.project.util.ConsoleColors;
+
+/**
+ * The Assassin 🗡️ — the nimble skirmisher. Highest max mana/stamina so it can
+ * chain abilities, with average damage and low HP.
+ *
+ * Special: Vanish — turns invisible, dodging the enemy's next attack entirely
+ * and guaranteeing a critical hit on the Assassin's next strike.
+ */
+public class Assassin extends Player {
+
+    public Assassin(String name) {
+        // Highest Mana/Stamina (55); low HP (45).
+        super(name, 45, 55, 6, new Dagger(), new LeatherArmor());
+    }
+
+    @Override
+    public String getClassName() {
+        return "Assassin";
+    }
+
+    @Override
+    public String getSpecialName() {
+        return "Vanish";
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        spendMana(SPECIAL_COST);
+        // Flip the two combat-state flags the base class already knows about.
+        dodgeNext = true;
+        guaranteedCrit = true;
+        System.out.println(ConsoleColors.purple("🌫️ " + name + " VANISHES into the shadows! "
+                + ConsoleColors.blue("(-" + SPECIAL_COST + " Mana)")));
+        System.out.println(ConsoleColors.purple("   The next enemy attack will miss, and the next strike is a guaranteed crit!"));
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java b/Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java
new file mode 100644
index 0000000..7dfb9ed
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java
@@ -0,0 +1,24 @@
+package org.project.entity.players;
+
+import org.project.entity.Entity;
+
+/**
+ * "The Rule of Five" – every player class must offer exactly these five actions
+ * on its turn. Declaring them in an interface guarantees each class implements
+ * all of them, and lets the game loop drive any player class the same way.
+ *
+ * Light Attack is free; every other action costs mana/stamina, and the Special
+ * Ability always costs the most.
+ */
+public interface ICombatActions {
+
+    void lightAttack(Entity target);
+
+    void heavyAttack(Entity target);
+
+    void defend();
+
+    void healAction();
+
+    void specialAbility(Entity target);
+}
diff --git a/Java-Knight/src/main/java/org/project/entity/players/Knight.java b/Java-Knight/src/main/java/org/project/entity/players/Knight.java
index 14d8fa2..4831a82 100644
--- a/Java-Knight/src/main/java/org/project/entity/players/Knight.java
+++ b/Java-Knight/src/main/java/org/project/entity/players/Knight.java
@@ -1,6 +1,46 @@
 package org.project.entity.players;
 
-// TODO: UPDATE IMPLEMENTATION
-public class Knight {
-    // TODO: DESIGN KNIGHT'S WEAPON AND ARMOR AND IMPLEMENT THE CONSTRUCTOR
+import org.project.entity.Entity;
+import org.project.entity.enemies.Enemy;
+import org.project.item.armors.KnightArmor;
+import org.project.item.weapons.Sword;
+import org.project.util.ConsoleColors;
+
+/**
+ * The Knight ⚔️ — the front-line bruiser. Highest base damage of the three
+ * classes and sturdy plate armor, but an average health and mana pool.
+ *
+ * Special: Shield Bash — deals heavy damage and stuns the enemy so it skips its
+ * next turn.
+ */
+public class Knight extends Player {
+
+    public Knight(String name) {
+        // Highest base damage (8); average HP/Mana.
+        super(name, 50, 40, 8, new Sword(), new KnightArmor());
+    }
+
+    @Override
+    public String getClassName() {
+        return "Knight";
+    }
+
+    @Override
+    public String getSpecialName() {
+        return "Shield Bash";
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        spendMana(SPECIAL_COST);
+        System.out.println(ConsoleColors.purple("🛡️💥 " + name + " performs a mighty SHIELD BASH! "
+                + ConsoleColors.blue("(-" + SPECIAL_COST + " Mana)")));
+        dealDamage(target, (int) (getAttackPower() * 2.2));
+
+        // Stun only makes sense against an actual enemy.
+        if (target instanceof Enemy enemy) {
+            enemy.stun();
+            System.out.println(ConsoleColors.yellow("😵 " + enemy.getName() + " is stunned and will skip its next turn!"));
+        }
+    }
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/players/Player.java b/Java-Knight/src/main/java/org/project/entity/players/Player.java
index ff5385c..256c91f 100644
--- a/Java-Knight/src/main/java/org/project/entity/players/Player.java
+++ b/Java-Knight/src/main/java/org/project/entity/players/Player.java
@@ -1,42 +1,203 @@
 package org.project.entity.players;
 
 import org.project.entity.Entity;
+import org.project.entity.enemies.KeyType;
 import org.project.item.armors.Armor;
+import org.project.item.consumables.Consumable;
 import org.project.item.weapons.Weapon;
+import org.project.util.ConsoleColors;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Abstract base for all playable heroes (Knight, Wizard, Assassin).
+ *
+ * This class holds everything the three classes share: health/mana bars, the
+ * weapon and armor, the level/XP system, coins, the inventory of consumables,
+ * and the collected keys. It also implements four of the five combat actions,
+ * because Light/Heavy Attack, Defend and Heal work the same for every class.
+ * Only {@link #specialAbility(Entity)} is left abstract so each subclass can
+ * provide its own unique ultimate (polymorphism).
+ */
+public abstract class Player implements Entity, ICombatActions {
+
+    // Mana/stamina cost of each action. Special is deliberately the highest.
+    public static final int HEAVY_COST = 8;
+    public static final int DEFEND_COST = 6;
+    public static final int HEAL_COST = 12;
+    public static final int SPECIAL_COST = 15;
 
-// TODO: UPDATE IMPLEMENTATION
-public abstract class Player {
     protected String name;
-    Weapon weapon;
-    Armor armor;
     private int hp;
     private int maxHP;
     private int mp;
     private int maxMP;
+    private int baseDamage;
 
-    public Player(String name, int hp, int mp, Weapon weapon, Armor armor) {
+    protected Weapon weapon;
+    protected Armor armor;
+
+    // Progression
+    private int level = 1;
+    private int xp = 0;
+    private int xpToNext = 50;
+    private int coins = 0;
+
+    private final List<Consumable> inventory = new ArrayList<>();
+    private final Set<KeyType> keys = EnumSet.noneOf(KeyType.class);
+
+    // Temporary combat states, all triggered by actions and consumed on the
+    // next relevant hit. Kept in the base class so takeDamage/dealDamage stay
+    // generic while subclasses just flip the flags.
+    protected boolean defending = false;
+    protected boolean dodgeNext = false;
+    protected boolean guaranteedCrit = false;
+
+    protected Player(String name, int maxHP, int maxMP, int baseDamage, Weapon weapon, Armor armor) {
         this.name = name;
-        this.hp = hp;
-        this.mp = mp;
-
+        this.maxHP = maxHP;
+        this.hp = maxHP;
+        this.maxMP = maxMP;
+        this.mp = maxMP;
+        this.baseDamage = baseDamage;
         this.weapon = weapon;
         this.armor = armor;
     }
 
+    /** The class name shown in menus, e.g. "Knight". */
+    public abstract String getClassName();
+
+    /** The display name of the special ability, used to build the turn menu. */
+    public abstract String getSpecialName();
+
+    // ------------------------------------------------------------------
+    //  Combat actions (ICombatActions)
+    // ------------------------------------------------------------------
+
+    /** Total raw damage of a basic hit = class base damage + weapon damage. */
+    public int getAttackPower() {
+        return baseDamage + weapon.getDamage();
+    }
+
+    /** The generic Entity attack maps to the free Light Attack. */
     @Override
     public void attack(Entity target) {
-        target.takeDamage(weapon.getDamage());
+        lightAttack(target);
+    }
+
+    @Override
+    public void lightAttack(Entity target) {
+        System.out.println(ConsoleColors.cyan("⚔️ " + name + " (" + getClassName() + ") used Light Attack! (0 Mana)"));
+        dealDamage(target, getAttackPower());
+    }
+
+    @Override
+    public void heavyAttack(Entity target) {
+        spendMana(HEAVY_COST);
+        System.out.println(ConsoleColors.cyan("⚔️ " + name + " used Heavy Attack! " + manaTag(HEAVY_COST)));
+        dealDamage(target, getAttackPower() * 2);
     }
 
     @Override
     public void defend() {
-       // TODO
+        spendMana(DEFEND_COST);
+        defending = true;
+        System.out.println(ConsoleColors.yellow("🛡️ " + name + " braces for the next hit! " + manaTag(DEFEND_COST)));
     }
 
+    @Override
+    public void healAction() {
+        spendMana(HEAL_COST);
+        int amount = (int) (maxHP * 0.4);
+        heal(amount);
+        System.out.println(ConsoleColors.green("✨ " + name + " heals for " + amount + " HP! " + manaTag(HEAL_COST)));
+        System.out.println(ConsoleColors.green(name + " now has " + hp + "/" + maxHP + " HP."));
+    }
+
+    // specialAbility is abstract -> each class supplies its own ultimate.
+
+    /**
+     * Shared damage routine for the player's attacks. Applies a guaranteed crit
+     * if the Assassin set one up, then reports the result.
+     */
+    protected void dealDamage(Entity target, int amount) {
+        if (guaranteedCrit) {
+            amount *= 2;
+            guaranteedCrit = false;
+            System.out.println(ConsoleColors.purple("🌙 Critical hit from the shadows!"));
+        }
+        target.takeDamage(amount);
+        System.out.println(ConsoleColors.red(target.getName() + " took " + amount + " damage!"));
+        System.out.println(target.getName() + " has " + target.getHp() + "/" + target.getMaxHP() + " HP remaining.");
+        System.out.println(ConsoleColors.blue(name + " Mana: " + mp + "/" + maxMP));
+    }
+
+    // ------------------------------------------------------------------
+    //  Taking damage (with overloading for the Dragon's true damage)
+    // ------------------------------------------------------------------
 
     @Override
     public void takeDamage(int damage) {
-        hp -= damage - armor.getDefense();
+        // Normal hit: goes through armor and any defensive stance.
+        takeDamage(damage, false);
+    }
+
+    /**
+     * Overloaded version. When {@code ignoreDefenses} is true the hit ignores
+     * armor and the defend stance – this is how the Dragon's fiery breath
+     * bypasses shields.
+     */
+    public void takeDamage(int damage, boolean ignoreDefenses) {
+        if (dodgeNext) {
+            dodgeNext = false;
+            System.out.println(ConsoleColors.purple("💨 " + name + " was invisible and dodged the attack completely!"));
+            return;
+        }
+
+        int incoming = damage;
+        if (!ignoreDefenses) {
+            if (defending) {
+                defending = false;
+                incoming = incoming / 4; // brace reduces the blow to 25%
+                System.out.println(ConsoleColors.yellow("🛡️ " + name + " blocks most of the blow!"));
+            }
+            incoming -= armor.getDefense();
+            armor.absorbHit();
+        }
+        if (incoming < 1) {
+            incoming = 1; // a hit always stings at least a little
+        }
+
+        hp -= incoming;
+        if (hp < 0) {
+            hp = 0;
+        }
+        System.out.println(ConsoleColors.red(name + " took " + incoming + " damage!"));
+        System.out.println(name + " has " + hp + "/" + maxHP + " HP remaining.");
+    }
+
+    // ------------------------------------------------------------------
+    //  Resource helpers
+    // ------------------------------------------------------------------
+
+    /** Spend mana if affordable. Returns false when there is not enough. */
+    protected boolean spendMana(int cost) {
+        if (mp < cost) {
+            return false;
+        }
+        mp -= cost;
+        return true;
+    }
+
+    public boolean canAfford(int cost) {
+        return mp >= cost;
+    }
+
+    private String manaTag(int cost) {
+        return ConsoleColors.blue("(-" + cost + " Mana)");
     }
 
     @Override
@@ -55,11 +216,100 @@ public abstract class Player {
         }
     }
 
+    /** Refill HP and mana fully after a won battle. */
+    public void restoreAfterBattle() {
+        hp = maxHP;
+        mp = maxMP;
+    }
 
+    // ------------------------------------------------------------------
+    //  Leveling
+    // ------------------------------------------------------------------
+
+    /** Award XP and level up as many times as the total allows. */
+    public void gainXP(int amount) {
+        xp += amount;
+        System.out.println(ConsoleColors.purple("✨ Gained " + amount + " XP! (" + xp + "/" + xpToNext + ")"));
+        while (xp >= xpToNext) {
+            xp -= xpToNext;
+            levelUp();
+        }
+    }
+
+    private void levelUp() {
+        level++;
+        xpToNext = (int) (xpToNext * 1.5);
+        maxHP += 10;
+        maxMP += 5;
+        baseDamage += 2;
+        hp = maxHP;
+        mp = maxMP;
+        System.out.println(ConsoleColors.bold(ConsoleColors.GREEN
+                + "⬆️  LEVEL UP! " + name + " is now level " + level + "!" + ConsoleColors.RESET));
+        System.out.println(ConsoleColors.green(
+                "   Max HP -> " + maxHP + " | Max Mana -> " + maxMP + " | Base Damage -> " + baseDamage));
+    }
+
+    // ------------------------------------------------------------------
+    //  Inventory, coins and keys
+    // ------------------------------------------------------------------
+
+    public void addConsumable(Consumable c) {
+        inventory.add(c);
+    }
+
+    public List<Consumable> getInventory() {
+        return inventory;
+    }
+
+    /** Use (and remove) the consumable at the given index on this player. */
+    public void useConsumable(int index) {
+        Consumable c = inventory.remove(index);
+        c.use(this);
+    }
+
+    public void addCoins(int amount) {
+        coins += amount;
+    }
+
+    public boolean spendCoins(int amount) {
+        if (coins < amount) {
+            return false;
+        }
+        coins -= amount;
+        return true;
+    }
+
+    public int getCoins() {
+        return coins;
+    }
+
+    public void addKey(KeyType key) {
+        keys.add(key);
+    }
+
+    public boolean hasKey(KeyType key) {
+        return keys.contains(key);
+    }
+
+    public boolean hasAllKeys() {
+        return keys.size() == KeyType.values().length;
+    }
+
+    public Set<KeyType> getKeys() {
+        return keys;
+    }
+
+    // ------------------------------------------------------------------
+    //  Simple getters
+    // ------------------------------------------------------------------
+
+    @Override
     public String getName() {
         return name;
     }
 
+    @Override
     public int getHp() {
         return hp;
     }
@@ -69,6 +319,7 @@ public abstract class Player {
         return maxHP;
     }
 
+    @Override
     public int getMp() {
         return mp;
     }
@@ -78,12 +329,24 @@ public abstract class Player {
         return maxMP;
     }
 
+    @Override
+    public boolean isAlive() {
+        return hp > 0;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
     public Weapon getWeapon() {
         return weapon;
     }
 
+    public void setWeapon(Weapon weapon) {
+        this.weapon = weapon;
+    }
+
     public Armor getArmor() {
         return armor;
     }
-
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/players/Wizard.java b/Java-Knight/src/main/java/org/project/entity/players/Wizard.java
new file mode 100644
index 0000000..b39c21d
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/players/Wizard.java
@@ -0,0 +1,44 @@
+package org.project.entity.players;
+
+import org.project.entity.Entity;
+import org.project.item.armors.Robe;
+import org.project.item.weapons.Staff;
+import org.project.util.ConsoleColors;
+
+/**
+ * The Wizard 🧙 — the glass cannon caster. Highest max HP so it can survive long
+ * fights, but weak basic attacks and flimsy armor.
+ *
+ * Special: Arcane Blast — blasts the enemy for heavy damage AND heals the Wizard
+ * at the same time.
+ */
+public class Wizard extends Player {
+
+    public Wizard(String name) {
+        // Highest HP (65); low base damage (5).
+        super(name, 65, 45, 5, new Staff(), new Robe());
+    }
+
+    @Override
+    public String getClassName() {
+        return "Wizard";
+    }
+
+    @Override
+    public String getSpecialName() {
+        return "Arcane Blast";
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        spendMana(SPECIAL_COST);
+        System.out.println(ConsoleColors.purple("🔮 " + name + " channels an ARCANE BLAST! "
+                + ConsoleColors.blue("(-" + SPECIAL_COST + " Mana)")));
+        dealDamage(target, (int) (getAttackPower() * 2.5));
+
+        int lifeReturn = (int) (getMaxHP() * 0.25);
+        heal(lifeReturn);
+        System.out.println(ConsoleColors.green("🌿 The spell's energy restores " + lifeReturn + " HP to " + name
+                + " (" + getHp() + "/" + getMaxHP() + ")."));
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/Item.java b/Java-Knight/src/main/java/org/project/item/Item.java
index 6d6b5ad..d100cdb 100644
--- a/Java-Knight/src/main/java/org/project/item/Item.java
+++ b/Java-Knight/src/main/java/org/project/item/Item.java
@@ -2,10 +2,19 @@ package org.project.item;
 
 import org.project.entity.Entity;
 
+/**
+ * Anything that can live in the player's inventory or be sold by the merchant.
+ *
+ * Weapons, Armor and Consumables are the three families of items; they all
+ * implement this interface so the merchant can list and sell them uniformly.
+ */
 public interface Item {
+
+    /** Use / apply the item on a target (deal damage, heal, equip, ...). */
     void use(Entity target);
 
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
+    String getName();
+
+    /** Cost in coins at the merchant. */
+    int getPrice();
 }
diff --git a/Java-Knight/src/main/java/org/project/item/armors/Armor.java b/Java-Knight/src/main/java/org/project/item/armors/Armor.java
index 7ca8774..3380ff9 100644
--- a/Java-Knight/src/main/java/org/project/item/armors/Armor.java
+++ b/Java-Knight/src/main/java/org/project/item/armors/Armor.java
@@ -1,17 +1,48 @@
 package org.project.item.armors;
 
-// TODO: UPDATE IMPLEMENTATION
-public abstract class Armor {
+import org.project.entity.Entity;
+import org.project.item.Item;
+
+/**
+ * Base class for every piece of armor. Armor lowers the damage the wearer takes
+ * through its {@code defense} value, and slowly wears out through
+ * {@code durability}: once durability hits zero the armor breaks and stops
+ * protecting until it is repaired at the merchant.
+ */
+public abstract class Armor implements Item {
+
+    private final String name;
+    private final int price;
+
     private int defense;
-    private int maxDefense;
+    private final int maxDefense;
     private int durability;
-    private int maxDurability;
+    private final int maxDurability;
 
     private boolean isBroke;
 
-    public Armor(int defense, int durability) {
+    protected Armor(String name, int defense, int durability, int price) {
+        this.name = name;
         this.defense = defense;
+        this.maxDefense = defense;
         this.durability = durability;
+        this.maxDurability = durability;
+        this.price = price;
+    }
+
+    /** Equipping armor has no direct effect on a target, so this is a no-op. */
+    @Override
+    public void use(Entity target) {
+        // Armor is worn, not "used" on someone. Nothing to do here.
+    }
+
+    /** Every hit chips away one point of durability; may break the armor. */
+    public void absorbHit() {
+        if (isBroke) {
+            return;
+        }
+        durability--;
+        checkBreak();
     }
 
     public void checkBreak() {
@@ -21,13 +52,23 @@ public abstract class Armor {
         }
     }
 
-    // TODO: (BONUS) UPDATE THE REPAIR METHOD
+    /** Bonus: merchants can repair worn/broken armor back to full. */
     public void repair() {
         isBroke = false;
         defense = maxDefense;
         durability = maxDurability;
     }
 
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getPrice() {
+        return price;
+    }
+
     public int getDefense() {
         return defense;
     }
diff --git a/Java-Knight/src/main/java/org/project/item/armors/KnightArmor.java b/Java-Knight/src/main/java/org/project/item/armors/KnightArmor.java
index eb59a46..ccdffae 100644
--- a/Java-Knight/src/main/java/org/project/item/armors/KnightArmor.java
+++ b/Java-Knight/src/main/java/org/project/item/armors/KnightArmor.java
@@ -1,6 +1,12 @@
 package org.project.item.armors;
 
-// TODO: UPDATE IMPLEMENTATION
-public class KnightArmor {
-    // TODO: DESIGN ARMOR'S ATTRIBUTES IMPLEMENT THE CONSTRUCTOR
-}
\ No newline at end of file
+/**
+ * Heavy plate armor worn by the Knight. High defense to match the Knight's
+ * front-line, tanky role.
+ */
+public class KnightArmor extends Armor {
+
+    public KnightArmor() {
+        super("Knight Plate", 4, 25, 40);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/armors/LeatherArmor.java b/Java-Knight/src/main/java/org/project/item/armors/LeatherArmor.java
new file mode 100644
index 0000000..c44debc
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/armors/LeatherArmor.java
@@ -0,0 +1,12 @@
+package org.project.item.armors;
+
+/**
+ * Light armor worn by the Assassin. Modest defense, but does not slow the
+ * nimble assassin down.
+ */
+public class LeatherArmor extends Armor {
+
+    public LeatherArmor() {
+        super("Leather Vest", 2, 20, 30);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/armors/Robe.java b/Java-Knight/src/main/java/org/project/item/armors/Robe.java
new file mode 100644
index 0000000..ac265a8
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/armors/Robe.java
@@ -0,0 +1,12 @@
+package org.project.item.armors;
+
+/**
+ * A simple cloth robe worn by the Wizard. Very little protection — the Wizard is
+ * squishy and relies on high HP and spells instead.
+ */
+public class Robe extends Armor {
+
+    public Robe() {
+        super("Mage Robe", 1, 18, 25);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/consumables/Consumable.java b/Java-Knight/src/main/java/org/project/item/consumables/Consumable.java
index 028e13d..e2f7eed 100644
--- a/Java-Knight/src/main/java/org/project/item/consumables/Consumable.java
+++ b/Java-Knight/src/main/java/org/project/item/consumables/Consumable.java
@@ -1,8 +1,37 @@
 package org.project.item.consumables;
 
-// TODO: UPDATE IMPLEMENTATION
-public abstract class Consumable {
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
+import org.project.entity.Entity;
+import org.project.item.Item;
+
+/**
+ * Base class for one-shot items the player can carry and use in battle
+ * (potions, flasks, ...). Each consumable knows its name, its shop price and how
+ * potent its effect is; the actual effect is defined by each subclass in
+ * {@link #use(Entity)}.
+ */
+public abstract class Consumable implements Item {
+
+    private final String name;
+    private final int price;
+    protected final int potency;
+
+    protected Consumable(String name, int potency, int price) {
+        this.name = name;
+        this.potency = potency;
+        this.price = price;
+    }
+
+    /** Subclasses decide what the consumable actually does. */
+    @Override
+    public abstract void use(Entity target);
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getPrice() {
+        return price;
+    }
 }
diff --git a/Java-Knight/src/main/java/org/project/item/consumables/Flask.java b/Java-Knight/src/main/java/org/project/item/consumables/Flask.java
index c0e7a6d..c2caaa2 100644
--- a/Java-Knight/src/main/java/org/project/item/consumables/Flask.java
+++ b/Java-Knight/src/main/java/org/project/item/consumables/Flask.java
@@ -1,16 +1,21 @@
 package org.project.item.consumables;
 
 import org.project.entity.Entity;
+import org.project.util.ConsoleColors;
 
-// TODO: UPDATE IMPLEMENTATION
-public class Flask {
-    /*
-    THIS IS AN EXAMPLE OF A CONSUMABLE DESIGN.
-    */
+/**
+ * A healing flask. Restores a flat amount of HP to whoever drinks it.
+ */
+public class Flask extends Consumable {
+
+    public Flask() {
+        super("Health Flask", 25, 20);
+    }
 
-    // TODO: UPDATE USE METHOD
     @Override
     public void use(Entity target) {
-        target.heal(target.getMaxHP() / 10);
+        target.heal(potency);
+        System.out.println(ConsoleColors.green(
+                "🧪 " + target.getName() + " drinks a Health Flask and recovers " + potency + " HP!"));
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/item/consumables/ManaPotion.java b/Java-Knight/src/main/java/org/project/item/consumables/ManaPotion.java
new file mode 100644
index 0000000..4f7ecd8
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/consumables/ManaPotion.java
@@ -0,0 +1,22 @@
+package org.project.item.consumables;
+
+import org.project.entity.Entity;
+import org.project.util.ConsoleColors;
+
+/**
+ * A mana/stamina potion. Restores a flat amount of the resource the player uses
+ * to power their abilities.
+ */
+public class ManaPotion extends Consumable {
+
+    public ManaPotion() {
+        super("Mana Potion", 20, 20);
+    }
+
+    @Override
+    public void use(Entity target) {
+        target.fillMana(potency);
+        System.out.println(ConsoleColors.blue(
+                "🔷 " + target.getName() + " drinks a Mana Potion and restores " + potency + " Mana!"));
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/Dagger.java b/Java-Knight/src/main/java/org/project/item/weapons/Dagger.java
new file mode 100644
index 0000000..eae55f4
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Dagger.java
@@ -0,0 +1,12 @@
+package org.project.item.weapons;
+
+/**
+ * The Assassin's starting weapon. Lower raw damage than the sword but cheap on
+ * stamina, which fits the Assassin's fast, resource-hungry play style.
+ */
+public class Dagger extends Weapon {
+
+    public Dagger() {
+        super("Twin Dagger", 6, 6, 30);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/GreatAxe.java b/Java-Knight/src/main/java/org/project/item/weapons/GreatAxe.java
new file mode 100644
index 0000000..e05b38b
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/weapons/GreatAxe.java
@@ -0,0 +1,12 @@
+package org.project.item.weapons;
+
+/**
+ * A heavy weapon only available from the merchant. Big damage for players who
+ * have saved up enough coins.
+ */
+public class GreatAxe extends Weapon {
+
+    public GreatAxe() {
+        super("Great Axe", 12, 10, 80);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/Staff.java b/Java-Knight/src/main/java/org/project/item/weapons/Staff.java
new file mode 100644
index 0000000..7a836ad
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Staff.java
@@ -0,0 +1,12 @@
+package org.project.item.weapons;
+
+/**
+ * The Wizard's starting weapon. Weak on basic hits, but the Wizard makes up for
+ * it with a powerful special ability.
+ */
+public class Staff extends Weapon {
+
+    public Staff() {
+        super("Oak Staff", 5, 10, 30);
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/Sword.java b/Java-Knight/src/main/java/org/project/item/weapons/Sword.java
index 96226ee..d53cbe5 100644
--- a/Java-Knight/src/main/java/org/project/item/weapons/Sword.java
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Sword.java
@@ -2,25 +2,32 @@ package org.project.item.weapons;
 
 import org.project.entity.Entity;
 
-import java.util.ArrayList;
+import java.util.List;
 
-// TODO: UPDATE IMPLEMENTATION
-public class Sword {
-    /*
-    THIS IS AN EXAMPLE OF A WEAPON DESIGN.
-    */
+/**
+ * The Knight's starting weapon. A reliable, high-damage blade.
+ *
+ * Also keeps the example "unique ability" idea from the skeleton: a sweeping
+ * slash that can hit several targets at once (useful in the bonus party mode).
+ */
+public class Sword extends Weapon {
 
-    int abilityCharge;
+    private int abilityCharge;
 
     public Sword() {
-        // TODO: DESIGN SWORD'S ATTRIBUTES IMPLEMENT THE CONSTRUCTOR
+        super("Iron Sword", 6, 8, 30);
     }
 
-    // TODO: (BONUS) UPDATE THE UNIQUE ABILITY
-    public void uniqueAbility(ArrayList<Entity> targets) {
+    /** Constructor overloading: lets the merchant sell fancier swords. */
+    public Sword(String name, int damage, int price) {
+        super(name, damage, 8, price);
+    }
+
+    /** Bonus: a charged sweep that damages every target passed in. */
+    public void uniqueAbility(List<Entity> targets) {
         abilityCharge += 2;
         for (Entity target : targets) {
-            target.takeDamage(getDamage());
+            target.takeDamage(getDamage() + abilityCharge);
         }
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/Weapon.java b/Java-Knight/src/main/java/org/project/item/weapons/Weapon.java
index cb9fcf2..2a2f501 100644
--- a/Java-Knight/src/main/java/org/project/item/weapons/Weapon.java
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Weapon.java
@@ -1,26 +1,43 @@
 package org.project.item.weapons;
 
 import org.project.entity.Entity;
+import org.project.item.Item;
 
-// TODO: UPDATE IMPLEMENTATION
-public abstract class Weapon {
-    private int damage;
-    private int manaCost;
+/**
+ * Base class shared by every weapon. It holds the numbers common to all weapons
+ * (damage, the mana it takes to swing hard with it, and its shop price) so the
+ * concrete weapons only have to fill in those values in their constructor.
+ */
+public abstract class Weapon implements Item {
 
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS ATTRIBUTES
-    */
+    private final String name;
+    private final int damage;
+    private final int manaCost;
+    private final int price;
 
-    public Weapon(int damage, int manaCost) {
+    protected Weapon(String name, int damage, int manaCost, int price) {
+        this.name = name;
         this.damage = damage;
         this.manaCost = manaCost;
+        this.price = price;
     }
 
+    /** Default weapon use = strike the target for the weapon's damage. */
     @Override
     public void use(Entity target) {
         target.takeDamage(damage);
     }
 
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public int getPrice() {
+        return price;
+    }
+
     public int getDamage() {
         return damage;
     }
@@ -28,8 +45,4 @@ public abstract class Weapon {
     public int getManaCost() {
         return manaCost;
     }
-
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
 }
diff --git a/Java-Knight/src/main/java/org/project/location/Location.java b/Java-Knight/src/main/java/org/project/location/Location.java
index b0b4b98..cb7c461 100644
--- a/Java-Knight/src/main/java/org/project/location/Location.java
+++ b/Java-Knight/src/main/java/org/project/location/Location.java
@@ -1,28 +1,33 @@
 package org.project.location;
 
 import org.project.entity.enemies.Enemy;
+import org.project.entity.enemies.Goblin;
+import org.project.entity.enemies.Skeleton;
+import org.project.entity.enemies.Vampire;
+import org.project.util.Dice;
 
-import java.util.ArrayList;
-
+/**
+ * A place in Javanest the player can wander into. Each visit to a location
+ * spawns a fresh, random standard enemy (Goblin, Skeleton or Vampire).
+ */
 public class Location {
-    private String name;
 
-    private ArrayList<Enemy> enemies;
+    private final String name;
 
-    public Location(ArrayList<Location> locations, ArrayList<Enemy> enemies) {
-        this.locations = locations;
-        this.enemies = enemies;
+    public Location(String name) {
+        this.name = name;
     }
 
     public String getName() {
         return name;
     }
 
-    public ArrayList<Location> getLocations() {
-        return locations;
-    }
-
-    public ArrayList<Enemy> getEnemies() {
-        return enemies;
+    /** Spawn one of the three standard enemies at random. */
+    public Enemy spawnEnemy() {
+        return switch (Dice.between(1, 3)) {
+            case 1 -> new Goblin();
+            case 2 -> new Skeleton();
+            default -> new Vampire();
+        };
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/util/ConsoleColors.java b/Java-Knight/src/main/java/org/project/util/ConsoleColors.java
new file mode 100644
index 0000000..97e7f0f
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/util/ConsoleColors.java
@@ -0,0 +1,55 @@
+package org.project.util;
+
+/**
+ * Small helper that wraps text in ANSI escape codes so the combat log is
+ * colourful in the terminal. Keeping all the codes in one place means the rest
+ * of the game never has to remember the raw "[..m" strings.
+ *
+ * Colour convention used across the game:
+ *   red   -> damage taken / dealt
+ *   blue  -> mana / stamina usage
+ *   green -> healing and good news
+ */
+public final class ConsoleColors {
+
+    private ConsoleColors() {
+        // utility class, never instantiated
+    }
+
+    public static final String RESET = "";
+    public static final String RED = "";
+    public static final String GREEN = "";
+    public static final String YELLOW = "";
+    public static final String BLUE = "";
+    public static final String PURPLE = "";
+    public static final String CYAN = "";
+    public static final String BOLD = "";
+
+    public static String red(String text) {
+        return RED + text + RESET;
+    }
+
+    public static String green(String text) {
+        return GREEN + text + RESET;
+    }
+
+    public static String blue(String text) {
+        return BLUE + text + RESET;
+    }
+
+    public static String yellow(String text) {
+        return YELLOW + text + RESET;
+    }
+
+    public static String purple(String text) {
+        return PURPLE + text + RESET;
+    }
+
+    public static String cyan(String text) {
+        return CYAN + text + RESET;
+    }
+
+    public static String bold(String text) {
+        return BOLD + text + RESET;
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/util/Dice.java b/Java-Knight/src/main/java/org/project/util/Dice.java
new file mode 100644
index 0000000..96be695
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/util/Dice.java
@@ -0,0 +1,26 @@
+package org.project.util;
+
+import java.util.concurrent.ThreadLocalRandom;
+
+/**
+ * Tiny wrapper around the random number generator so the rest of the code reads
+ * nicely (e.g. {@code Dice.chance(20)} instead of raw Random calls everywhere).
+ */
+public final class Dice {
+
+    private Dice() {
+    }
+
+    /**
+     * @param percent a value from 0 to 100
+     * @return true with the given percentage probability
+     */
+    public static boolean chance(int percent) {
+        return ThreadLocalRandom.current().nextInt(100) < percent;
+    }
+
+    /** @return a random integer in the inclusive range [min, max]. */
+    public static int between(int min, int max) {
+        return ThreadLocalRandom.current().nextInt(min, max + 1);
+    }
+}
diff --git a/Java-Knight/target/classes/org/project/Game.class b/Java-Knight/target/classes/org/project/Game.class
new file mode 100644
index 0000000000000000000000000000000000000000..a1486411fa48da43c30e119fbd50250d414b8b1b
GIT binary patch
literal 10957
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
HM>GEiTK95f

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/Main.class b/Java-Knight/target/classes/org/project/Main.class
new file mode 100644
index 0000000000000000000000000000000000000000..c259ce0fcddbbf6c2c31c050f9761f403a224794
GIT binary patch
literal 1017
zcmZuv?QRl56g^XDcUdUV(qjFnrG8W>wQK!WnkH=%^arT121FB+0am(o*(I}s36JF;
ziIVsLK7fy7ytB|!H{BmIbLZZB?m1`Y_urqt0PN$rff+<JL=%|B97Fnqf90mb-H!RX
zd1AFB!`!az+H#K}k}uRW=nR>ls4s2D+!ulmDz+~TXbLCJu<D79*%O}XHXX0UrR}+9
zWpdClPgCm0w%@aa?RIi?&ujYz45So=G{bVfG9_^&RZ*!>i(?TP4ND0uBg>GSQc%;0
z9B;Qny<-8T!Ur8I45>2l@}#uf+@Tosq>d{L@dL-=UvgD0{9_&02={H@cCB`<W;+h=
zSURrLU0Ha(?5V;x-1jx)NWpoLFL>87u!b8-!A<gKq9AZc(IfsUe>;H<W%8^qxsV$2
zA)G3=U54nP*S3gng^0ZBcbk@Y$D0n_EGiG38W*;TCznx4RtC9qt}CDtA$0@5Z2sd#
zj#8eB4)ta(NHfGve;rk%$Nf`1)Y~D^;kn8Pnw$Nf=%9B>b|-|hTRCsz>A<tMQraUh
z<H+lamQ}Wu1u>;;Tm5^i;|@Jt_051R#T=~#icH!W?X#Ohux~+nlU9`m;waLZ7#Cm*
zcPWZtJ7`kPe-K54_Rk||jUi%{;s{1#F)>8)2Nq^fAIFzM@#Ro_H59L&#UrdWibJed
zx4z?+Vi$p8w?Qm`dFV)D1u5i_##1cdCB6FhSOTY4Zy_77&y5-49(Jfl$0yv!15(7v
Ygok)Uc08tgrE#2lLMKLO%BW}m00JNB7ytkO

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/Merchant.class b/Java-Knight/target/classes/org/project/Merchant.class
new file mode 100644
index 0000000000000000000000000000000000000000..3583e0505084d5e8a1e1af6b3f0ea88c2a7ce3d4
GIT binary patch
literal 4366
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

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/Entity.class b/Java-Knight/target/classes/org/project/entity/Entity.class
new file mode 100644
index 0000000000000000000000000000000000000000..c474beb546b8225ed79e839f04a56273e32cb9eb
GIT binary patch
literal 388
zcmZ{g%}xR_6opR_rpWk%ihmo|!^U|4RwPOwVbp}gg}due#zL7PLnZoZE_?tV%5bMN
zapk68@9F8ez5V(9`UcR)l|)V8x+t@FRTguV+F0dQ+t2vkL830up3{b6LwOcIzE&QA
zfUKo-A#f9o|GnJnKC^SGW-6Zw>_t^se^X=_(Wt7LGi^*lISI5ZEz}(?DN_P6Q}%(D
zyz4~W@n8FiEp?vt1R87@u3YGdW4KD_WB9Z?Ncg}@2}@G1`$lg#jGyqrohHS5nW}*{
zEQPx{Z>t`G0DJgffRM*-AV4*~MALB}EyvLF!1EACPCrK5@x=4g^USk@b50hx;I)R!
EE$=K)DgXcg

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/Dragon.class b/Java-Knight/target/classes/org/project/entity/enemies/Dragon.class
new file mode 100644
index 0000000000000000000000000000000000000000..40a61867234658cb381b3b2dc5247d3177a43a18
GIT binary patch
literal 1149
zcmaJ=TTc^F5dKcPu<dq{QZ5w`-HKvMq3iutBpSe^u_y_o5567RL%XouZFWzM{R1Zc
z1mAcuzN#U3Ni_QEf8j3}XS+3lSlLbH%<P$&@0-j1`u+7gfJb-`Lxf>))#G*7(V$>J
z#h?xqF$Tl+>SoJxcSTj2!jYEj&>@<Z@Xa+kI~2HNIhI^zSk9Jr`3r8^+^L(J(zBd;
zu|!Y#lpIe)XRFf^#Zs;khlYd-UB?j4FeH!V>iAML8KQ1mGK_~PmTPVhgd`xro5dKC
z49|}Cza71Q9ms>X##TcZVNpigu?6=V!Z)}fUC*OR40p%au{>eO2A9Tmr^S6gxVLSi
zCU%5FMn*#lqbkO9jAMe~{P9BC(z4AJ*YRCjthl!8`9#nYHHNu9eaQXW8VzSLsbWgU
zG|n-McI!P^6@%IeYP20HyI<Cdit`Ma<Ggx9YT3LaJm1{to^cq+sJN(O7MJ=5{GDpp
zF&b-)H+fw!u#$!u%;~s-EQ2Qbo>=W&4P;BtbCm?<kyo)0cq}qZ_F=Qu-5drbOM|99
zWdo_KxHZZ@T(%tXwB6hm-WK1s=}W5YR=Hi_o)y@=kBV$q)Z*FGwkhOZB=THJUfrXS
zW&8Pubcz9q!LU*PNqn-4L1M|hx}YtbJ|!>1&}IO?&Rae5+NRs~s^YN~l$Qu;7J`8z
zLz7YHHv}S}aic)eB<mq!qyee<6dS>Qaw_>US!2;ph<@n$UL~nf40&J#qqs(z9!B6g
zZji-r6SsQVULi^^Q22;=YWOoo4w26P#LOFv<$qviePR9p7nDO>eutrapnpLwf&eLs
z0BHgPB-2RH&ZaR*TQrSD+KK?xAfGg0-^QITpF$6x&~O*`h{1jGQV^MqlU^h}f~7x+
CnJ4D}

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/Enemy.class b/Java-Knight/target/classes/org/project/entity/enemies/Enemy.class
new file mode 100644
index 0000000000000000000000000000000000000000..80174d593df38399a6b9936c181a2ca828d97813
GIT binary patch
literal 3183
zcma)8U2_v<6n-{e+ooHfg|yVt&_auC3Pcd_qliEOTWA3ZmM=xN$<i#{?8eO&?0DgY
z7ybn=9LEc1yzxRD;s-PG1HAB`@E07P^KRILbccZ%dfxZ!d(L^D^VR<I-_vIR&R`>p
z1d=*Z2GYoA*zv%8XcisQT`OK$ePERX4Vja+YX_$^B&TOqdeMVk9a#f?Ff@#N{#vo_
zd-Aeqxq%&QQdl+HY81~?ZfejQ!G`Nv6%E>LvEF82J9cPDxn|AMFu2r?SPFdGU7M3v
zg9dhDmxgrB{Bq$cZ5Ks5WMEjdiE3T0BL?1(Yo=n>%r#3?dkl<;s^`o4HS3Y-S46qj
zz_=*0WzTlo>U{?GW0DBht<CG3b%L2(dIg_L;VT92fPpu~V?RyL`Cfg#YPw|tm_b3u
ztbv0#^inQMn~lJ#F@@enpdlA>w!Pw25)Me)GHY{#EJ)G7TR5U&xMr?f^PXEagBx~G
z<*5;vZqU$hV0vr9X11!bcpJxb95--6{N+1&Z3MPc6qlaE7>?)DZPK?YS-gw)bi8k1
z4ktD2RE2pNB$HJa$c{@EaY$DBa0(ylIBl@G&T1Ix4BTpv^Quo+j({Z3snW3>rWa>c
zG@OcYy2yX8QyAqSHSbke$?Z$FYhB)`ty=zdbJbCe=9Nun#q@2tx0I=%YLorGSGiYx
zJjX6GgTO4WGnvzI&qG#oLLw8G{+h)?kG|p|o2MlHmd$z#Or~Ppw_FZNs%n`I-G~UP
zZ07s6<1Cx5$xpRV$WUqMwHu`u)5Yn$O-<RcOkb2N6){{^L$+%=rbRehe6UbggT2To
zye)^*CLfmhp`}{p0P1$*jAK7!BK!F9W^1}gg17l-tXNduTazNqIun<H7aQWmL~&F?
ztM(|-QOVoz%hm;3ikDSII4m8>$7ek+Xav4lU$%m(S84QsNg8<m<KNF8KO5J^!#Xu4
zwrB7li*-0UYBE<$$z*%k*zQAb-71DVCmgj4W;yVD?yT=RyRh{zjJ0686~}6DQF!Yc
z^|`Hs*P(gIP!>$g^E(~y!-YH7S*n(cdDC%9c3`m!jYTd~f8H@04XdH!3k_3SIK@HL
z!9LHw`YBs3<dvG>)=Yroh+d>*UvoDlWcN}I%4Via$?{cqZd@g~WR>JrRgx=`G9kYz
zD0k8#jd^-K$J@Wu_fVcF`~j_yY(g*0Hql?$)5L)M$Q8z#*j>n_niwtQ(oN(GBbg>9
z3OT)rsmIFidHy_1@8HfCG`+}U8}>5NICf)#+I`&c`?-}TQN$FE;{Y!3^|dfEKEeWT
z#Gn{z>LlC}>Ll!v>LmP9>Ld))>LeU9>Le_6vRcH&7PnjUAU?)^!*t;Z`kxXd{>0JW
z@y;yoyZ^!m3A8C}Q(<PA*n`-ELki+h=pcePhD%tYdrj7AE6hFGNtofnttZHhRwQXW
ze2*T<XHEhnAvqdU=#L<aqZr^Xh9NSRJcL1pqaeeoq8gT!r8dMkmq{`#*esQjBCQQv
zJ^?3{FC+Ze@}=QQ1aqwgGatgd*Mdo?13#g!ATkE+X`(%Y9KDROU)pH%5!yViGV>AI
zF&;mTf*vO@$;}qD7dw1ukuQxsA-*(}BErY$K=@?}>_NTFTK-}J`K1|OaD~h>5%cT#
zgm%*7MdcAllcW9%6$w?2Fm0s{<8)-a5))pAqdWW!hQHb2p&kAP^;^UD|JoJ)ZijI@
z{4Ly$G0t^kFUK0+i8UVRHm=4Re;OGdY-KHx?6$0RSSF&BefAobeyru)s8TXgQtN&h
zpdX;8env`#4+ki$*rN_7{jKmaDrqG8PK*8L5t7czk9O1es>4q^_4i_p^WDZ@#~Pbh
vW&G}*o9Hh3H?hX$*vM1ek-v>GPNJgv%EEoh9%8Whe+?dQS)S_f5n$whvwujx

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/Goblin.class b/Java-Knight/target/classes/org/project/entity/enemies/Goblin.class
new file mode 100644
index 0000000000000000000000000000000000000000..951d268c97e74e1d07813eeaccfa0158a6aeebe4
GIT binary patch
literal 1329
zcma)6+foxj5IvJ1n=Gp=5R{v^;bsEpdcQ?b2oa(YEur$@i!~%u$;f7x+Dx?aDZcq)
z`Q(F?<*iCTz<=QvEPIkzLP?>!wUeIS>F#q*_vXjXuipVI;eHGehVIp1%aeW_T{vc-
z+k$}@!$c5P+?_CZE=tN3zLKg*KcXf@-F+aMo6Q}eLmw>{^6Ly!g?}H<m@v^}z_M^0
zCm5U~LUL58N%?O}U#dlh#Z=)rf5Bak`xSRXh0?EN@^t-A*?hWaz-CAuQLin5iGB<i
zNLU!eNru7w0SzTRcSV*o>r$2b+UQE<(@*2*#gK(zjL@4huki}KVfi@5aN5AQg)?v%
z?0xW?btP&H(V(HINSl}p+{eU95jVkWnHVM*Cih-{+k5}TX@hebby0S*p;WTOJx7bM
zEs`dtFl}JQ!davk#{Ytx4g7lGiEQ8nVV#PGqRcRJh@9!a6*e)8IRo<+&fz@6K#Rjc
zqzuN6#_jn;<*=;97%ng*G?m>qf8bZ8O7`FqE*rRF;VP~%4DZL@nYdhQ@EA<Rx5Y|F
zTrE4Ly}^(=sF2t2E28eal&b1*Cv4PJ)7kQPStJ>HvQP4x&$4Sv>)9N`aV?ADzAAFB
zA)@p(ka*Elx=2mU24(7CZ$bKEy;0i|;U?em$kSg4NcbWTrQUa(U8*Wc*2$v=vE9E6
zjR#kXm$s=*sl(2<$!0VNvqXLV&9__eup($yMvsUhP8&M;L%!32W^M$Huq5tD4Zf!h
z;=FDlk~Fd=ab_67O?nt^(Jq1vJ(LHxX<Z=CGGb%_iP?T;kJ~XjVOzV1+QXj^f8UB&
zq}8M-z{UXjaEC0b9fP~{52I@=BiqUMj!tT=b9U-8`d(pn_5)5Gt1j$fv_JV7lOK`R
zrrS2>#=hWU1aC2<o!2`~9n$h^08wZFGl<hVNMKJAu~S572-EaI&XeV0l*o-?1>-Gn
i4#o81H0?)PuyY-l1d8r^1ay^hbs^#=$X+8mg8VPu&`^8;

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/KeyType.class b/Java-Knight/target/classes/org/project/entity/enemies/KeyType.class
new file mode 100644
index 0000000000000000000000000000000000000000..6e9b50b62a24079f1cf5e265c0cae96c2d789954
GIT binary patch
literal 1470
zcma)6YfsZ)6n?s`TUUyX%0&<r5p<ivRPZ`PE>0wjjW}E+e(J{StadHwIupM6lN3~l
zM#E=+l<}N*s6$CyllJVq?>WzNuKWJu^EUwV$i)y+FzWfW%$D!H64f9h+`taDNr<{F
z8krTby}rFA;!qGVpdzXux>Q`qFBcSy<^S)PWlzmOoISPDN-m#UFBbT)%Yea$vGV-t
z+VYbepPevp5(zpRE6?Yj=1L02pLar{!^Ei=5(awFr$DVbo+}jeCR6!W)*CD1SZ*y-
ztZ;%^9RoNW!=Qm7oFU3T206D`C+;_v(-g%Q3T`IbycZp-(a5$Plmg#&YuR=N29Wq?
z4V=SyD%Fhb+QF=X{&uKC&*fB^bG~3;6c?!;n|5Q%v9=3VokBPNWzwK(xTHW|@+yw)
zj!<iK@=r2XisW$=|DvSI8sZwRDlkf~g(Ct_B55!*WGITVRo}9G@eBRBfg70Oj>xh!
z6kJZGI_e2!|H~z^=xtI?C-b%|3e9>&`0G~1p_4nu#GLA+;aniEYB^=gw;AdXFXGDL
zC00f7(%W3Kd{P79Q`C{*rA;DUvTLptG<_oPJC3|e6Hybv!}eYr9izkU(KOFgsSUEd
z;be*&Z?#pMM`5OuOlGsx(URBntKyN(H8BoXZjuLc?mBgNfOb`#8|3W+NYXAzN$W#5
zCXWx07~<6-Jxce}m?FQMq>Yl~N8dsBC-fY^d`B9^O5dowqj8{3xQ&pspC-v3x~Zi1
z(SHDi?L$ZG@6d_Svcg^F#yxsfa(m0BG>r&Lu*W1LY@EI_yocfR#7B(0C%pxCf^I=U
zM=9(s^nhXe>5jp(GBy6i$%Q3BH<@#S{L(W+ZwU7(j#)gQFK3$}$<eFn4;cA7@LtK#
z3S4b5By^tc-_9H>FcAF;Wh1<UaA_m5gIH-p-JupS+|jyen4|yD7V|Ue4nNah$k!YT
zo8x=9yo<0@(-HHERAW+|P|ZoH>if91i*7DS3)z(Aic?W^Dq|NWpiz#kOc$_7b|F0c
E3GO&Er~m)}

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/Skeleton.class b/Java-Knight/target/classes/org/project/entity/enemies/Skeleton.class
new file mode 100644
index 0000000000000000000000000000000000000000..f3f4d953ddf6e6b2a514bd6bf989ce2359cf1081
GIT binary patch
literal 1605
zcma)6>uwWA6#gc5vi5cpn*>TsLfCLg9k<xDg#a~#f=Ox<=K{7;sr@yvr}pCY&T4m@
z)=$A-gaqm<fFMNq(Ff>b@B)1U#2MRBjS{7`<e4*P&-uP{nKOTXJopR1eN<x@VTe^)
z!WBw-aYQj{V9bJn7{f&wG;)3*pNg8w2~RnyOPgprBFwFcZnf(R?Yy>9Ua4+wFkCMG
zw?p29i7yOT7RE8bV4vW!LR?*ju{)0EsAY!bbonXY<vEvoja)?qj@QVS==XnUON-la
zByq~Xq=hM*X1H_$^I<_4CYn5aBEn7(P!U9(f&HR0_|n2zOf#5@x5Pu<<_#)EG)*if
zv7ECogIR{rhEPSHA(CD!Y5kmq3tAr|{W|}nxTTfz7A|V2Xj5=Ej?1`WV8OyyNHZjd
z^6iF7v<XXg6vLT*B^;UCqB1BdhT!e|BsDc-;cI-uaJEg66{J_=>SsqaNeUJBR7k!Q
z=Fvi$$RcOpnuTxi9mCvkbvnv%a~eUq1nJ6vP{#aD;JcLd!ZBSr7XLbK7+A7!6So+q
zdYOG5KZD`xY+O$Vc{Ieu?OrKqjTU5`s1s$!6C0iOjtHuJM+Y-mmNo8f^T5&PfikL^
z4n=(Bq<eDM@jL|)h+Sv5*Xt7HSs!$FyrOumwa)zks#%eppe9xw%{zYRpVfI$;~q$<
zLKSd-U8tt4hcW!b@c6^?KmXZ(W>=fSK6J2a(sj8XiqNLirOj=h5N-LJy(2vlX0usa
zHHBwWgTqj?DXY-_of>L0ySO!<7z5p`M_4mZ){S4MDg5`&INq*oiNUD!@4_mtDH+gI
zJs&Rcz_1@{k$ZJwp=p+_j-Nl;hat^pj`~43#{AbI`^_EwnB<4=#{i<hUAN*WK@G4<
zo+pBWs}l|lY*Fiu<aAu92A<HxJ=v5R+RqE~G<zlu48w?i5J(y!c^tQC{eezvh>--O
zGLtNsPMXP7a^ejl$<%wqGm&>lyzaT=X`MiX)&#*=m?qdebh7%+xQk^v(LB<ZKJY6d
z()KqqGw*RGvxn46T+O^i;sq8mQ358_`BC?7W_Azu8(h*B2UrC5adi*hYuX4j?E>Po
zp2jGFPZ9hyQuMx@qbFnrY0Tmp?Ms;Jg=3S?1+u$`ABmpG2Z3qnKIs@9^l;e{85T$!
Y!9%Rju8UBl|0*`<WRkRr$EYCn2~QWGTmS$7

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/enemies/Vampire.class b/Java-Knight/target/classes/org/project/entity/enemies/Vampire.class
new file mode 100644
index 0000000000000000000000000000000000000000..0a8cc2813e655816e5b39b50fd0319f13c3fd1cb
GIT binary patch
literal 1729
zcma)6>sA|86#fpEObAnnDM&*pP7!LL%6Pv8S|J394J{T-)p|Q5$1u%gCTr%TnkVQ#
z|LRX)!7dll{^$erDf$9^1()BD(WZ;6XtHMJoW1tt+k1a|KmP0CBLM4=Nel@X71?Y#
zff~aIMhzrP7)T1t`$64q1^yjX)wc4qqdWYlrlUgpn(FL#S}L+#-`OqQED9`?|64zw
zLJH#sOcQ7Df`B!^q{vVmfyAogIr@sgm0bCbyen;2dUbnG2aZ?Im-zcXVM|MuF{JUL
zfsBc>m=s9&`09jOH3f$KwicM`Msa+5mmxF*DcQ^?@e&L2^tVS(kM3D<xvbFf8lmOr
z(E5Rxc=9f$a1L1mGbYYsR$#6-zqWQ<yWo4F@2Z0D`a#H;fvO2y>XX{i>1<P&!^;LN
z6BjWraP}mH=Yg^ztq8X3F_V5?S%(EI8n|TQRpbUYInI+ksL7_Rv)iIHj%8dn@S2I&
zu_BP|O)%z2@q{V@DJ>gnGqxPbu?LB(Pe?odQUvjqiMJycBZo@5k>Fhu@8Nxc(Yn&x
zE!HNtREp#un)oP^Cn?{NKW*=3=wa2w8pw+2CWEl3RjF?|`Y<Z5mY!y5r*kAn-zuKN
z$0o_o{*2ZGrC6%5a%ro$w_jW@GsjJVGynLhNVm<r38g}$1;572MA`Aw^>*_>1^e>A
zr6g1KtJ1B=z=`g$a6}(EgfVa|;tJ<kVyU&PHb|LVKSFnFnvYN<v<z4Yf%5|tsTOMT
zjJc)u{B}@PTTX=3j3cf@+~E{#_`VKxAX__1ANsX0iG6{Ui02QE|K)itkd7Bx!rI=o
zq*t>%|3~XkQea1-m5Br@Dcr&r2EL5C@)eVQHeHT)*KeqJV7rall2z>oob6wG85%2g
zfowC5t3npfZ?s$a)3eYcdCoA}N`2IC_vqg^h&Ecjmm0B)f^^+IM=SQjEP0*^3a$)8
z6&m<PVDVH={h%87jy)W#%I0+Q;v6q<765@6Y@opJCT~Nq`H+Pu^1VgL29i7hlgk;A
zej`1eo=d0iV>q4t6Jx)hSbV~FidMh`7hD?KJege^l<+BU0@qNE{r$pCKTO%$eN1Gg
zjxl|N3zwJwz$*{1G=%7IZxVLn=e6b8BfLqa+2td=!{>vC$OFf?N`q&C=LwJCFpeqy
zr(tmmE+WfSF~gD0VwKx40%UcA#()?eJGf3r7B1iha)dvOUFr?tGu-4iO8Rp?d$`S8
Mil?vfExt$gZ`T#a^8f$<

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/players/Assassin.class b/Java-Knight/target/classes/org/project/entity/players/Assassin.class
new file mode 100644
index 0000000000000000000000000000000000000000..d5f25980552f8a22650916279e0e2b689987d89b
GIT binary patch
literal 1941
zcmaJ?U31e$6g?Xo%W*|wobVASpoApYhM-bHp*5v7CTZL{A;qb~N86c=y<;ztC5^Nu
z&3oVb+Q+{4rR}tk0j58I|HAMOI=w5K#=$P0u~xf#@7a6LxqJ2UpJ#sqDB^nqBMfJ~
zplSPo_ej*0EtP27JA(V38``&dvnhfU7~&=lA;FNiAzi6%GQ_gEnt>$4?0`29+FlUa
z6~R?Y1Vued!9YBP_h1@0tf9sjru!X*tEAeseTVM~@?DQchI`q{BmS7%4tJY&RRz**
z7Ru#vrQh{H#G6s%g+YT}P*F66TrG(-L$Vl#JPf6qM21qUaaV?|6ee-hz%diYaf0Do
z|50y6`No}LH1vhrSmiD!s<P$WgHb{`Y2p;#r_F}fXo@xQgJNLO&KVPD_0Cwc!vpRr
zAsVGXs!>d1#=tofvzTK@_ocoYk}kx$*CCLjT~efHuM;DRcoDo^&_|v(kwuPTaCuuW
zWCqzw;sQe|yKwocrNhmouz*VjY!e^gGQ*kvbUR8qc8LnXb41B=NK``Jayo=OKSY?^
z;At5uvnwVRah2hCn{N}0Tjy$1s+Pu8lsjQw9|AUrH3VJ<f6c^o9eKj<1im9u_yh$5
zH%xpAD$|LG!-GsQ7{2Dsaf!+yN9*eNoMF|ntc{kiToTR_u4wOCTq$1PwsxfBSZx`G
z7cK5KEUNOZQAh>4Ei4&Y+}c;xs*|+S#9Ya15Od=d>58>ZdrJfxe9MVc^6K2F@j&W%
zZ!xY~lBk(GP|5#Oe+34!DOAa!VqS}cpUe(nOV^uFRbSL4ce-|CRJVFo+>#F6Khi%t
z?7*eycG9&WniUTSh2hjY45`AZUMHxFWvLT9{N|!u(rQp)-|{>~WO090sFv3VllYn;
z`|6h$uU`E6dhaKTS+(L?xw^7cwMZu~VmNH^hPM+=TWmamY6=_p#z0Ni)+RNf{i`C~
z$KJN+HH&V!E%Una0?O{^ezkjs-4IqtNJoUT70=u5_=Umh>svYCxUuVtA?6SJ?C)&p
z&RXbKqz6&rj#H)nr3Eazt_UItMQGpwNk5R&uuu(rORBxwlvL~HMg3)xny~)Gsi_~r
zO?nn-b{9#E(0DR`A-#~kmQFkeyZ;oi=P+m(eTvlYv^#=Z^h`yT6PO~b63vfwJ#iaL
zG$Rb%f(Vyk8DI497os^3%Z&d<CS9NeEdnPZ5Hos@^*|U_hPWPi+x7HN*D}8Bo%$nU
zQEZF(^!O7@Z06&CVM;$v{{buiC+0KxJzRW-4}m>=^aLN%a^|z{>wdm7#0@Y*U$9x2
zn8OjwQ;z3pWu7w4;tFNE&%@$>JS^fXR49@dR-=^HaEHbut=y&mI_}X-e_HS3A-==Z
Ezu%hs6aWAK

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/players/ICombatActions.class b/Java-Knight/target/classes/org/project/entity/players/ICombatActions.class
new file mode 100644
index 0000000000000000000000000000000000000000..87f0fe84d1590f7ac05591159ca0ba53efedcf23
GIT binary patch
literal 282
zcmZvXO>V+K429qDlkn3bB=)Rf!yJHBgs4;rsSBj;CxZzCLncZFq+E>!2jEZ@9-xa#
z-Pp39{rvg%bGZUYFo@9*n7T5PMd|jWy`<b5U(3R(n#xLkF5EFyKGEK|yo%8h81B_s
zNvrZqex+eYpl?mK^NIIL9|Xpe)jy8Qhw*&+&Eq>#=lXX%+R&ErjX-k}#2$<Gc~4+a
z6{HQ<sj-a3>e`)3O&`XR!00dCEPzD<?8M&zZH8?lLV%86xr6Sb?!9t9^m*frV*~GZ
DaR^4s

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/players/Knight.class b/Java-Knight/target/classes/org/project/entity/players/Knight.class
new file mode 100644
index 0000000000000000000000000000000000000000..d7ecb810f1b07eaa7cd356eb9ccbdb2f3bd2edd9
GIT binary patch
literal 2187
zcmaJ@TUQ%Z6#fo@ObAnm6na%UTunl0TC}#9S_>2;EthBzdhvEhPLpXSGvmxjF~7h!
zeYHO6gYVj<6wA`3ul|=Ve}HSb+-EXsXtKz|oH>WRzrFXjzkP;3{(kl=fO&kXp^IU}
z@yZ$3a~_JK%$QQtGP{Dij_qd(yN*|igP~hT526gwYo=|=>kN@(YD+_mVZ6<mdo{=N
zGq-KCT#@r?6NiTGIQpP#IHr*L8Ae<Ege^_k$ha172y)E_E5n`S>O=mBXDn`)GX?3H
zb~&5N<yKo=59PZZ<ehCd2y+Uu$)>hqNKh@!3}YB%=qprAVU>&p?pNX%!mx%DI!@x$
z(TO$@7<zqI*rhdYbD}DlOWo_m8JyMdvW{0U!jNbwqu~?7M4(fb48zR=O(&D5>Lk@D
zcrDvY85lZ7F-CAUuL*|1b|zw&V2CGYE?qWM<Ww9}cvVAEM+)f|x>}c}m06^gI+j>;
zEb0#-?^tz0p6Wnysy*5u3Ff?x8C+mES>siLv5Q=8o3f&CCATGEUhM$Zj@1EPC4W)J
zC6#&9t$VH|;&=_OYq+fA4P0S39&mV=DF)3|yjeC;*&%dlOEq&&$D7D9^p}O4my#E&
zd1qI6frxX_8|<<AeXT6t)^P*##A-=!>n5-9G7)qxc}P#8R+j?FW^-x`78#6IO@=1I
z7By4&nI&2qaV%g-$FiEDZeP}Ib+Do%hg(zyWwsvlc_`U|oI#qvRmFW;(X_5(BcQ1v
zEX&y?xJ9Q#c@C_awpg#%c7(UdcdS4(PLW$%+%wfaJnWVglR7otsi=Pku&HaJOsB*a
zE$;ix>=c6qR}@Wdg$E>jwVU5DEt+6b-BDzvwitR8D`Ys<DgGhGD120Mk3uq>?PMLc
zfZ<p{HFb@<VTtjAQ}>Eu*;FL-HH*2R<U^CV;5gEk9(UJ-tT-h<h8>34=imJD{NUR^
z_rFvxPrfsl;R^48<JEkF8#Q&2HH^YaZfW(Vu`pj)88ui8C5DU2eE%mhH+@4j)fOd#
z+a+Vyv@FA~nyz6=->}7J(vWq}9vz6{K^$dNG?=QP4;d!@zZ*>Zky91nP1l^SWnPqy
zM|^$ND(}#+S;7hhw1hvg>NwT9n{6MrmXkw{n+;cVFu&hozp<k}3fWdoh7gO~vI=zh
zDv{)<ZZD9D@HNooHrZBFr&KjKB$%U3NdwKg=r$apFNpee(>V0t3O)0*dk-;m(RwC5
zotRA|6R`uZyH620fJRI2Q^bFuzjonWdd36GA)LlA`2i=Io+x0Gc7#Du#t4_;ecTH1
zXM#Nt865bYOqxJZIt0Ne5IuO0gdhxC9b8{}(RHMw>o)F$QGZ4h5dzPr69aoVzWoHJ
z(?8<e;P^f!pJ5u<M`jPR>FM+yu6{m*Yt=9IaDDoBEIh`@^lw;LJHLmU<VDLn&v08g
ztdWD_A`);hg<g6er%&?)5}3p(T1V)5nW4|e9MX7;qHNGkm1vO99I<s5_X5W9|1p-w
seSAPUe@Iq6V1JQI1Rv3+3m@YXTKnlukO2>#MO5ib{YPQJhKtkx03G~7fdBvi

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/players/Player.class b/Java-Knight/target/classes/org/project/entity/players/Player.class
new file mode 100644
index 0000000000000000000000000000000000000000..9c03887297a6f2acdd3297abde235cbc3882fd80
GIT binary patch
literal 8959
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
UPham;M@U<`ucPX2buU)@4AQ9jwg3PC

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/entity/players/Wizard.class b/Java-Knight/target/classes/org/project/entity/players/Wizard.class
new file mode 100644
index 0000000000000000000000000000000000000000..7d75d2299e4f46fe088488ef198f395302256299
GIT binary patch
literal 2171
zcmaJ@+g95~6y3wcGL8x^kXu8D5+K;7;HGIBTIXgQC~koepj?vP#`a(f%aSUMlhPmP
zTb}!vFUV@UvPc$5oA*BTNBD)Vo{`*QVi!NmXh!Gk*=Nt5k^lUA{|^9J)HQT43_D&q
z?Rw6RD9W@cMJ@eUaM!W@^s40B+c7Y7>F7p;A#%gCO?iu<Gm%`^5M>x@N#<V7@%;3P
zQxGv|=!)S4bPew)h+c+^%?ZMmrrb@t7T*<=vmEpcn~8-T{)ne7ZkLIKXWHdVKA&G`
zPCY_&BOsh<4QP<bDo&Z?dK7UgV#EBAd!;D)8T71I<hC$oEbhw~260luDIKSA=6I$d
z1VfMS3cIw(ZB8O3^2rB1cn{|^4Cy$JVTO299lJhhOVT-Y$#62P&~(zvRGy?F1+Qg#
zh=HNwA}$e}&1-_8zg3DTMj2v>$t%|kwQ@3s%NW;?(2+#yt^KS^(@N)PGaXCh9E)~_
zkPB9wkT17UIoY~eKUw8{9g~=1I9=mag0YKSZkV#7a3!}TVNSOJYsG2<ugHI(<BDP)
zaqFIIk!`NxBMsMde2nW11A&G|m159brJH4wlx>zyuB*-bM8~JdF!Yv%%u30N)n(_g
z@B;hhBX_!}GWw~=+dA$bORAOxx9;*9FOxtQ5=RWxFzamK*-SoMBB$f7S|UnIEb<@b
zmm|0TI)t6qk;mtxc!gj?hXlkHbS$c@ZpxZ>`{{(;QwlFLBop~o+4A}S5pG4tsuHfd
z><K|qbmg295${_tZLw6Z6@<6O3s&GFr^u~!?wM-bnCy}jleTW8U6ubH$<XLTRVS)B
zIwk&6V9UWo8%m+ltF9=T+zR7*>42zFwqROx)XAO4iJDv|6G-mSS`6pf@oK0~J7t;M
zVnxWhM|HD2O{_X~uPEkBRqu(A_mr{@ox&N%k-qe}yC`JEDfv-sGmIWQ{r%wiGlLn$
z3b$=x`3AR*>`E@XG;7Q(WLMWN8Z3$m!_|YQuMb|oG1e-=pn5E8+&6?Ryz;K$312$Y
z5X$_rAsy-yEX|TreG%-$P=%$TruLRtjvihHrv1pNipJd*9;i89BqUPk=Vm`Q0z=;O
z+%8$dA6;;qYTeDW8l`FGNaEVAE82uVY>K~EQ1^ePc~=_{Ic{02bloZw<Vhzluz~P3
ze9th}Qd2vs8pvnE$A{9+hjr2QH%Q+M_3NUO(T(fWuF>c|qUfOhY-%E&jZa2jfo;7&
z=PPK`^}ImrS9;ljFR6_Mfde>0Q0p{46((W>n=~Q_b;lAc!xkPi;3tDI(AnSj3x$M0
z5t;<SC=fk(?reZCJZzKt?%S#7+opbnuN$krK?I!yzLkpi?O|Z!H!ANrF7%JQ#MnM2
zfR{+`;ltEKY7f&t4dO=i$sTUeV1@>>)h9PoLwop)vW8R|&3~cZ?PE!0-lxn%QKkY_
zFVRPN1aXW~RU;V27@2b%(@5YZeLv=q!V2}9w6v<(2+92?+!nsUw?uuK1pE%1RO&>5
c;yO@7iTYl8GU>et+A<uPQ~w}bc#t^z54Hp=DgXcg

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/Item.class b/Java-Knight/target/classes/org/project/item/Item.class
new file mode 100644
index 0000000000000000000000000000000000000000..40cee89833796c5cadb2a308be68b9c236a8a8e8
GIT binary patch
literal 219
zcmYk0y$ZrW5QJwFH9sm?XltD`-UFnvPzVGS0`@T+;X;1oya>LUg%99EiJLUq%)rjf
z^1VOL7l1A14lKf|)rGj~wv@RM%E(&8EDlD5MVZ|*QDsdbj+Z_s*xgMM)<N>Wl8sU3
zA$EgB;hEqR(j2mytIHrves5BvRZ~O+mkTGYa&Fi`7!&-o?Q|~ps^XK^BW(KFguo5P
X1#Bi7V}hQ{fjhVdpA*8A)xzux(u*_0

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/armors/Armor.class b/Java-Knight/target/classes/org/project/item/armors/Armor.class
new file mode 100644
index 0000000000000000000000000000000000000000..2e6e7f9e11037af5349a0c2625d905b02c2d7e60
GIT binary patch
literal 1559
zcmaJ=+fEZv6kVsCwos>BYAM%J@3tdQK~SN@2#T>u@e&M)yiLnkhtifz2cy5?n-Bhh
z50Zc;KKKEClyU9T3D?F<GH3Qad#$x^^XKoc-vCyy97hP@7z`5;L=^^h><@Nf*KXDd
zFDpAv)mMlvyG_@Bq!7;KH+#{8-WcL0F2PjDw7gnj&ud9!!S$U+!S)(0uU%M?L&0d;
z4M!naKB3+4J-1ma3Q?blehetYww-rQv&}$N5`WUfW%0)w_Q$84D{&8*NNe}@zGqk5
zUDy94?hzBC;!a5PnVWGF6LJ&T^W3T<v6CjUxI#s@z3R2<qPP{O|C)*GQhvPp-l^7C
zJ;$!ca8qIELVYC`sW6heSW&4|%5SpdC#`Mr_LtqJ^J2eIalAKnWtX00xmC4yH*L=q
zJ8&BQd$+BSEng5i-N+)Fzc2ln%$*5znm(IQSkp&Q)T6%b)f`T3{6B#Ty>_MD@+!|=
zMkY3VyINnj_kxt7p0j7W9A1n>FZBFUx%|a?6?z!(N?NOTqr~>n5e$sHVjRyyhioxq
zqqXl<ooBAJB(B$FMwY|4$}xnXa04+UWxKeaNtqwdknD-Jxfj~zB50eF*EXlhGY*4m
ze2Xl%X?-Rx!t;jp6Uw@CgqSsPgoL~Xt;`Wp@*1{=j3bO4FfN1~-`AK2FhZtL^kNKs
z80R)l(39aa$vw#;&xrXBH!R$tMHQX1(qEEoNPkJ5Vf`hQ7|d)6(?Na<^h=aF5s&f;
zxTyuwoy%hZg&7ohuW%O<Cnau?ToA+7Au?ZJ99VA;kutWWxF5JG#9>`kT4$SQZ!Ok0
z#m-LiXPVJMW``mWn$;N9LnnWUK<71c5uGG;QeW9a_AFzC+07G)B+CP4DKW?4-NPUj
zPSGdN(hrhu?wGzD(5HnmV^L&K2E}ujm7KJvBeBR@mXJUZLs&i~kq#sj#pi>>I}HOO
z<cfV~ew`tA`uzA5IC2bL!2K@Zv2W+VYhA$)x`Gqu!KJR?hh4#`^WgQa;4Buqq@6hr
Me%%$kq>C&519dCvEdT%j

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/armors/KnightArmor.class b/Java-Knight/target/classes/org/project/item/armors/KnightArmor.class
new file mode 100644
index 0000000000000000000000000000000000000000..e00b1d02f653d6dc4988a77eedd39a0a64840ae1
GIT binary patch
literal 375
zcma)1O-sW-5Pg%TO--YX^`Zws5h3;9-mM5l5Q0I3O77dZq+9YK+pYi0li<N0;Exh#
zX%AimXW-4eVR&!m>-*yqz!V34c!cP_(dELPJXX@G5I(vAdJzKj3CFD|#fxc|s<1*^
zRSRkA)~v+T6+-V?H`?A14wGytU!|yIQ;L~2x+y1VnvU}TA>r&VnT_>Utdop$f`8jS
zE5b0-je1zub7h|7yyD3yYYSQB(rCxGL*Fj+ig2F&!(l=QXYJY)>P|bs_?P>oyB??5
z;s0F_XMh1?#Ow-P?ttiGL_vHMC-3OIG54^`7;<$u;M{Xtn_UbMGb8LXdKmoxYLr;Z

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/armors/LeatherArmor.class b/Java-Knight/target/classes/org/project/item/armors/LeatherArmor.class
new file mode 100644
index 0000000000000000000000000000000000000000..589fd51f7df69007128a5ebb416d48df0899d0e9
GIT binary patch
literal 378
zcma)2!AiqG5Ph2_O--YX(SsL7L8SHI-mM5l5CXwVCHHMy(k)3=He3J8li<M*@T0_8
z%)yJ`47`~)4DT`X`Stz*V1a`XJcc-z!mgz`Eo5gS_y|G_V}uwn9BWhYXQMZ=v|L%)
zaA6v4I=*m)VR)ljWp5ddrujy^2wsb};!A5(Tg|g9n-w7<hV#E<dh1?oFr5_){+)i3
z43k{7@?qPoq<IvpnkH$kOHmiXD98JuZ`Z10xXAxwF=vRDdTUB~ubkrkZ~rTI0M4*O
yFL1#qLyQSyV%G?$1LDh+1<7G@@`k}HaSywM5mkp{%00LBvx^B5Vq`?<A^isK&{^pK

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/armors/Robe.class b/Java-Knight/target/classes/org/project/item/armors/Robe.class
new file mode 100644
index 0000000000000000000000000000000000000000..d8fe256b232528c814dd323ff83365b6e815c75d
GIT binary patch
literal 351
zcmaKn!AiqG5QhJ0)22zIjq#$OqPNzAd$%GKK?p<-R&w9OC2mQwvQ2%jo&*m*fDa|k
zqF0@PfA$-Oe|A2<-ah~=us=eN5ZuX1oj#aCh43)&F^u42L^w9K5---QRM`pLsYXcK
z7`qk=R|vx^-Rka|a4^kQ@>Pmjwv||RR=3qWP19NKBP1OCW#d*7`qNoX@NUc#!z9zK
zy5BT~vX8Q;xszn3lyxqxcKqA)x@Wy6oMiu5&k5nuY;37+wQ~yGz6<wJoFU*-T@a^_
sF>Azhi2=WW=sY1WPU6Ei^ta4C?68JhosKzo-PF%4CWx5`d#pVq-$GtarvLx|

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/consumables/Consumable.class b/Java-Knight/target/classes/org/project/item/consumables/Consumable.class
new file mode 100644
index 0000000000000000000000000000000000000000..f1b7d0593240ceff0eb392d74593a93f602ac08d
GIT binary patch
literal 752
zcmZuu?MfR#6g@ZD&6;#InkKPYzb!Obq5A+4L8OI+pn@g;H|r2blHIVG2)>g)T4)gb
z;RE!c#CtbEX%iOae(b&HoH_IN<>?u~DZZ4DL*9Yq!bX9xdK=z_em{(R{zdmzMTSr~
z*0DAxgnXmfDPjpl2PGFD;1a$jY0n>~iA?(1sDU3P@n}2<yL~nC&)#x^6^8>wsI=b+
zu1u=qUP~ZXT$Hg&aE6Idadc0hK>8IIAEj>(QynP>H9~EUGGJc9dSf0s2$~(HK1;5d
zy4=>WIv)?ZD*Y+?L`)Ke{Z5!_sb@{g+~^UZ*`DKBe6<!EGafP8PUD{y6&r2t{qI?5
zi4Lcy%z5TQwb7gxOIYH8OSx#~bwDUxCF3+wKeVVVzuWmuOtkjdpd1KQ<WZ6L;1{ik
zUmUCACr67v8+D#q=c>>1mi+Y|LEg~>j<+?zvbR0K+HdaX@QKelZwQjbSVcx!L5;II
zHn{6e_pyo3TnUfxQkDs0F3Uti-Xd&an`^cPyE6qoN13+0KX86=GNmkJ&7F*53TMwK
V2z%IHu)Oy0-}2$Y<%4YM@D+*0jk5p%

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/consumables/Flask.class b/Java-Knight/target/classes/org/project/item/consumables/Flask.class
new file mode 100644
index 0000000000000000000000000000000000000000..ec677fda0a5c6c43afec13d23895d6598aa1d8c5
GIT binary patch
literal 1414
zcmaJ>T~8B16g>llg=K+KzC;kqcL8O^Z!Mxwsnj5nK=8q*VLNG;Zg-m9DGC3?N1uJu
z7!e-$0sa^Mg7NOQk!{-0q;qF(?w)(@xp(Hz--}BC8+hM^HU?u`a7PuBS%>>29Wiuh
z=ro|Ai(x@}1+(JGV__-NR-$ZL()Fule&h(>%>3UobgtR1t=1VvQ#;4}gqsd`3+BG^
zY`2ik<rWXSp`%BGVW1a%4AVCvhg=x6id4e2P8nFP2XPE&NEjHz5W`sXd*Lcuotj&r
zVTcu}A~LBk?FdFS+%hnR+YIptw^N@AVrZ9D#V}lBZA){HC@Uf^csU&;oiK0*lSHN<
z)GjXzhN0AAbBzg-G-+T8)1*O}mjtO}arMbo#Xu*;UFDOYt<-6OrehX!8s-fwAjL2l
zt+uLcC)8d#l*Ex9;dT@}AzX&}7WggUm$0nio`L&VVHgZmX{<d^KTyIU)ZtdBha_EU
zk=9s7=1G<Q9orSV)$)<>4ubh$NbE?9JBQq}gLB;(Q$?Ey&+bG^Y8tI@0MeA9>J!jp
zsv)|e-RXcrr{W&9hhhANKn8tZRy|8(?SP#g=2!_zr@7daQu)f`l@CG{W!~??D~8pp
zua{S6-;ykuCn-vPk|(2=CCS}<(i4_E5uQ&$+j~>}op`O|4K_4v2E&k{O0P%Gc28tU
z)Ne&?KC;|W(xVCg64kgKSmUxyY3RC<VzN}Nq?<=C;%WHs;ItxIgny32e>@7Vb~-vD
zb%+dioPFvGHNnWauJAJSKKR1dkY$)_s;L!K4cpYan?tF0wYo^G;PDB5ZJ^<UN$UeT
zy&x|m+q0Bl@v->O8QQ;xL94Xt6bu+-d+{*bg`s$a$8=(Nf~R$u0@}mandPOQ=srh(
z8-8GT`5fa6f#(8uf!~<<g~e<55p)pD0Kq5FM-R^g*=Y=gsYYsW^;EzNp5ZwqYbVA*
Z4KI-<+eMyr`mf<Fopjo5;T>`q`v<qzcSisK

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/consumables/ManaPotion.class b/Java-Knight/target/classes/org/project/item/consumables/ManaPotion.class
new file mode 100644
index 0000000000000000000000000000000000000000..7e14e0a0a926db770911e1c198eedf6c5feed6cb
GIT binary patch
literal 1432
zcmah}?M@Rx6g@*rx0Kb^Qa}W;e7B&i;<rT<Do9O15(xhA*R&nW!gi<Gos#rT{OK!b
zhzN;3fbYU981J-=l+a+4&g{(IIp^GS@9ghCr@sI!<6RhC480rN<;g9nZ0SZ2M7M#E
z2?Jq<8R?a+swekFQCYSU6{{#+zgFP|NBCCu-!nsK(ROXM#4wo3@AE@$IovH<+sd=u
zaweBc@Ae>qUIV6yYq<VDWUZ(vh{32zCEQ}2f#rG;!wmy*6MaZ947JM>uCi6#T5U`W
z;ZL^XXdH%Ms=+^iK?65U4B-|-tW9Lyr_2}vvZfgNoAPaGZIO0G83<m<XyOqQw=qhB
z%0g}OieN~j(wCEsleI|`V;CnhD*Ql@O+~Ig*lJH3rnswo%D<CM9nd0}#FT+)6EjFL
zjJ9W7Q?}D6f^>+)ksjd&3r>xcO?QCrh(3!s19wf_!#qP@!<37u>jG#a9GAT5gt|-4
zrP4G8v$90g(Y)=7&03`(ydB*q4Dq}ya%Y!&wqCb3gKEzvz3F^=MweRbyb&@)Q}YRJ
zG<D&~g|cU~j*#LWm55>Zia>_Qwyb$Yv1V(D(Q~4CZ2~pOij>M%9<Oc)wI@q{7%v$X
z&c6ISJ33CXWQj~U@RK~LPquDPlDnm(CwwJopcwsXEE>YA2wr2^z>02*EW_k^^V#m9
zJP@sm((IHqUL*kO_s{Kiw*s4D)`^I2;ACFPgIYCnxe42LE*#vcS4D^Lk8Sbq3;MQa
z+PkF%k>!rFO(mjIm^s%KUe@8hFMI=Q3{#hK>Lk^`I#uxMP^w@vFEUGikMyq#)Q7NW
zyicp=w99DjosF|tB9=Ht;A<o30gVv~27P2AxQ+#SGMk}zh)1+yc#J14m@)#5*onE>
zBlMgg+J$fEpF6=YgWfsC9pDEhz9W4OKY(t6i4%Mu5hO4|^Emn&R0B=878Njor+7wW
d0aC1Uc!3PfVcJ=u|03SdDnd`Ic#9l{{sOgke&qlF

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/weapons/Dagger.class b/Java-Knight/target/classes/org/project/item/weapons/Dagger.class
new file mode 100644
index 0000000000000000000000000000000000000000..985346f9ef9d743a4bfae1878b1b8964f2e9f176
GIT binary patch
literal 364
zcmaJ+!AiqG5Pg%TNlj8)<HeKOTkFAmKtvEl2m~)J@w|;o+>-8=ZEC;Eli<M*@T0_u
z@v1ZMX5M4=?ab%b`v-s<91q|S!o^<c^E**h(gtwR_u)nGF(8~7TO}K7R<djo)yQ?S
zmtte|HhKK11n){|)m#%!ruj;|h@=*}O6HAKx=OPwn-xBS|BSkS3BBp8Ah@^YNfJi6
z((+-qUP`+V%bJxqH>IcxVO7h2MYnlYTf!v&bIr~@B?NP`v!%ROty$Q~m+ius;DC>A
wgE)PJj1jXGeeQtaMNDIl^Yjh9R~8%$83V2@M*QHAyQmw+2xDf1BSr`DH>s9WmH+?%

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/weapons/GreatAxe.class b/Java-Knight/target/classes/org/project/item/weapons/GreatAxe.class
new file mode 100644
index 0000000000000000000000000000000000000000..03082aa3a8188a429cb4498e0813c0af1d1d9f23
GIT binary patch
literal 368
zcmah^!AiqG6r7i)O&b#%<Heg6FRcgn10q5Zlt2)n63^SX#4TyIY*Y2OJP98B06$86
zsd^Om!Mr!a?#$bd&$o8~Q|$NQ5C&IP$>wPKtbDlWdgul4&?g)kTZ)x63sp2iH)<)K
zlw6s5E$+6R&^yz$Zq5k@<7^=xrKn_GidkcIT_$OoPI3=EVf3fbHky+Oo$(|mxEJQ0
z$uQHky5213%HGO(#Y&u+LRPu7y5&Ej+dSws;W+!(KOy)tv$2J`)U93k8+_WXjS&X?
z_4W{#haJX%S%NN4KzI^U6hwY>^NP+33l2g?pL>e|KiK6d_`ZxGB4&g=MhEd1WF1vd

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/weapons/Staff.class b/Java-Knight/target/classes/org/project/item/weapons/Staff.class
new file mode 100644
index 0000000000000000000000000000000000000000..f9f01e9ecca1c0987e61b11627655fe4835c6c6e
GIT binary patch
literal 358
zcmaJ+u};H441G@1CcOq4!opO_)-rHAMMww<DN+POP?)db8m^>Cm8Rvpn2;Fw06q%g
z1Xi%6XFu!d+5Y@`{{V1>Ll+jIf2W?uajg~$0UKQhJr53C!f{z;a$S{6oz~LSdL>`9
zT9?H}KD3q4yD){RF9}DJXsLEe=BmhKTvw*ZW?>jk69<AY`qQXgOXy6d3BkTDA2neZ
znL^)gS94w6t9j0oASzRpC#o_H{~g-(li3i)(f{T%f{4p)mFgSQc!_r9S#vE;(C3ev
vAWjDZMvvJ!y4(TYX+W+o{Lvdaugop%F$%5?4mkH4)sGfK_{<0gj241#&)89<

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/weapons/Sword.class b/Java-Knight/target/classes/org/project/item/weapons/Sword.class
new file mode 100644
index 0000000000000000000000000000000000000000..f923c3945bd274008c4c73e55367b435b8480757
GIT binary patch
literal 1262
zcmaJ>TTc@~6#k}cyX|%hwO|3cv?yv@E{j*xB1%w`CIugAF#5!_Y|28rTenk@pW-jj
zR}(M62jjCp!XILcdS==pMdW4X%$YOa<(zH5{rda`zzSBv2rw80-*eNYJ<s1VpdqLu
zWI{)nA?5j1tKoY)c12i@u<O>I%^RNEw4SP+A++SUj#y?G$rN|^OK#P;TeV8Ucid{e
zP$*<KA}|ouVVa1cpJDR9kV*hUjF+97BlcIfxnH#zSRsly&ge*(7{m}mzv5{Lr)CwM
zreFw@GM@|2XGmtUZ5isi(8=ecNMcyWh>200V@Ui(=$0_(+q}7MzaqT8O!m2aF>Yc4
zlMI@x(nDQrW$|%YHYKkk%`ke@lkEypZ#`6-LFUh!xPWPfNYxe(c%4gAL_xMvxMboo
zGBg6gckS+_mZ7$(8d|kgZ;Kub6dl)IZ`I4T|Ad!olt~o53a@Q&-;w7|QWM)wlObI^
zs;Fmhs>^wX;S=X2c{P{U75+c-q;YR`3<Mj#Q=zI@%XMC~?3MP+7zR7AhvUgh$dHh;
zq}Go02<vGTY0}$eWFUTIigL(wne6qu-{^XtJ65}N3db@5#Y%!#cGq~L)3Zp)sk&UW
ze6q7}T>j}`(wkB8T7JcT<jA2Is=f2FbC{ypYxFZ?2*^*LqCSdsWNFRODUTpUKrEMF
z@lZS*pZtWrca#WVhE{`iAOZQ+&r)Qzi!q0JI!Pd_1GGUvlE}!-jK{+hC!h=?f)Rz1
zYgcwqB+CM>C}aayNu=a7aE&4<_Bw7*Mv8q)XUVacd-fiY;N}NJW)3jGur_;uvkb41
zqF{{SD^lxoxsRC2QQhVNE(Y-C_jhSaQ?`;M78oaz2~1;>s8YCzv=Wyll4%Ukd66O_
rJCwPITewYv?ohVf2${)KW{EOU1b)hYh~y7?ewPvfEYsCJ72W>>oDmyH

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/item/weapons/Weapon.class b/Java-Knight/target/classes/org/project/item/weapons/Weapon.class
new file mode 100644
index 0000000000000000000000000000000000000000..6f2a19c55353b01b6c0a704694c484b37e9f810c
GIT binary patch
literal 1102
zcmaJ=U2hUm5Iq-m*}^XUK%k|it@u%4QC1V*FeU~y*`&56HTZm?8{7)JWLY%6`Gb7W
zL}K*8AK;HN&Ro!zkN7nA&OPVMnVH>RzkmD$@B|MsNFZrIv!Ej-uz4ZhNvAJ^o^#r{
z@Vc=;>X9G#@neBxwbo8!4QT@z3nnaq!!YVO!zg5=<Hz2>dGE<#7>u0PDhg<U9C!k`
z<4fVQIP!yDlcm-zY+#dWoXdgi5l*<A&RMv|>9v6jWGfuSoGe%<a#9~ge%CXxgOY(=
z3wtOFl&%`_g4mBgIL}lN$i(uk_jFc3tGczefdhfURf_WNQUd}z)n%`)ODt-p6`qsH
zjblIXPR4_d7rm05zG^S*%6?l$KHq0aEq>#V1S-c%h31FUq|uH?q;gQ5gU+?l<oc;t
zMm>*qviBdLfI*lOHTHb9w%iQOl>je!ifXB@K$;SNCuGw3#cb|0yt8l|b-m|4w`oqd
z+TdMk71~Jx0{hUA<IjOUs2s0TMcSW=v@(h*!ss|8^mV#@B%V%j*Zu}!*C#OS@&s9X
ze}XN$piPkfLazx_7(-mv)#!^zBad|y=u|`r+qgk552s4FiCc7IJUbEU#9k8W#BP%6
z#C|k-zm21rn-*ahW!CMl$bQFm0+;3a_W;VsP@7z?IEDTzXW|a3BqUISJri`)9neY7
z_)Mf}Cn-vUdSaQWLwzPAP{-XB<ou@v^3h82y_MwbBH3O^ZmcA4Es`56$&T`O{|_Yf
By6XS{

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/location/Location.class b/Java-Knight/target/classes/org/project/location/Location.class
new file mode 100644
index 0000000000000000000000000000000000000000..d88d58f6ca0ddab3be03956661af92790c202b8b
GIT binary patch
literal 921
zcmah{(QXn^5Iq+b)?J~kEk$dsrL9$<iTmOk#Kfo=608px5+4`5!P_poWVzV%1N@dg
z_@arXMiM{3k20RStdU4kH`(2pxo6JInL9s!eg6UA365N3khNhIkV9Tz?ZkiYdx0Mg
zy;uDcInV<6rV5pQERe0%dJe9^vEdeQ9R-1%C?0y_I5J2thz7n^QRsD2L%<6CkrY_(
z{H5*cScSueixsTeSS#QL)&({fiKbcw-ZM2|rrnqNOv+FoS8cazZ5t(ly+yDLwbJLF
z4CP44iT5Jv2P$;2VN~4|IJg4aJ(Ypf5z%FXzAdnS1-j>t#wwOBwvc7R)n!e!9u+^0
z-m>r2jtb@RbkvveYrh{PGvHK$o*ygYr$I}<Qxk#R&SKrAIW{<lq14C8EKAkea%BN`
zGWO5H=bXa1z&&CX8ULA4f+A_LtNp?0OMjenW1}ii`Cl3<b)#uKkS%3Y7607zLvzE}
z<9cMcSiEwxAhfcybGXCr4!ssn&AD5@gs2~Vh5eac26y>gAr{;Qi@6T(Z<k(qjz)#d
z=5Z5NLAHGyq?{iAf@it<7ucU@%<1w;u$<5o=75xj^T8n_rlAi+o8+dI|Ayj6T7buQ
zE&|w2?ZX*1-dtky0;L(sv~FF%onedCwyBv-B$O%D<WwlQPX0%XHs~8E^B$UM5BC{y
RU{xHaW#a)`s4<X1{WoOH#-jiL

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/util/ConsoleColors.class b/Java-Knight/target/classes/org/project/util/ConsoleColors.class
new file mode 100644
index 0000000000000000000000000000000000000000..6c7c80fe50f3b122ab56d307911931c3b75a79d4
GIT binary patch
literal 1732
zcmaJ>*;3R%6g>^I#BmfDSHukk1w=<gaKR16VbKUU!%`GaVd#QLNKa)lDu3c<=#y1G
z_yK;D<>@pQp_1a|cFxT`ckll5_t$R#(^xN{1D$zfipU}-(EZ8z?36vn-zhI`eUgn(
zAos%c-SCw_=g{z4i7cy#Qz!^r+IRM3MfnXUTzA7=ezii!4_g9vhU_Ch^)PV#ovGoZ
zsssV6!~`fhwa93Z)glKgkCMQ373`Fofzqjz+o9`~br|I_uBQTq%GRp&>WV-q>0aQ>
z|D4twuPrTH63FyzKHO(5wdz|7SIF<%93P`1J6Ee#7cE>fsz+4iHmbJ0v~J<1(T!7=
znXy-^7H%8OV{Ns(T3fcMyJK_{+N!cKO<%)CGa2!gYz7>S643E76}2q|x@^~%i|zd_
z8LT*49yKLfH5_lv30#d2m6>qYWwAHyliM-H!UDNX@1gw4(Pei6DSg5%md{iVr01zG
z{Ajj=rVf^A95~T`<&jmWt9H<kvu>2fu|_}8^W=KWC>6HCz-fMv;jY?lS>R$6Ob>Nu
zExa+94K#ShV7AKOw+6GB2G1JIwi!HcFq>xZJAqSun{1heT{+kVe86HJOL_~J1qO~b
z&GkR4Jy|vj$Mm_FvrZ#a!GXZH_(~ocni}REf7_F-0b8lPc5^DZM={MY;>tl&rkHQW
z?9ClIw)=-JDvsyX-B5C5#RcD&LB(@gE!oPWE-;v=DJ|7JR(U~AHs!2MT^K_TZyIke
zdT|ctdG#(3b>JfL<rwZI?u+58#Mfi^262B3-y$A};X&fNF+4;(62teHL5F^9n8AH!
zFwRr(%#Qqo_z|V_fKtCpKo_5c9+df2G)8#HLcqyCqJ?oVcIY5K@(X$3JAZdTyU-DU
zYcYDB(auNo$EozwNqT=OeIk`!OwtEa>65ASGfDbzD*Z_+{cMtcKb8J8mEM)4kEPO|
zrP8~T^obODC!R<1nZgU6qa4_KPU&SNUq^B}l9fnSBRLnz1$-n!550yJtfBWGk^VB~

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/classes/org/project/util/Dice.class b/Java-Knight/target/classes/org/project/util/Dice.class
new file mode 100644
index 0000000000000000000000000000000000000000..a56517f7ca66b153e8e9aeb9497f936c886662ff
GIT binary patch
literal 659
zcma)(yH3L}6o!8{DWN4mDfe=}s%0QTj36!ofg%-<pkiRcO)Y9@ohqcj^RTe6umED<
z0eC3Hv73Q`fk^Q=K9}F0eZIawJ^}1vDT@>=2eykex)^fT{EmAKuCBb3>a_@BhOSMi
zWW2>-6-(z?bR**+>!JrP!?G!F$FkuCp$ghjBvkBG>XG2Jav1Q&DOa_y$>1b8hLvKe
z{J*XZeORB1e&k3%iHF!%#A6rzlCM*Fof>3F7k!F27-kp_qbsi!g__(mSo<;%)Uy}X
z$n=+`636XkRYVnDZBQg{D9?E$^*#yOab4arjF$gY+n^^2>RcIJV!0r=mWTqnIRo<<
zde34W+#K;%BIi^^d@qEe7i>zi@&|_OS=gqg1F11G8go@Y3)V11BhjBlmWBd`5!$Vj
zWn|MUZ(uLvq%caWo*!r!He8I6=XQ!Pjsop6n80Kra7dL}ApZ_0S9?Wo;SrAg1lxM1
zsAbgjVZh)or97rEO|cpJ(@5oZ2o|$c(xKX>gAD+Q7AEY=R}5&i4qHcU%&3hdoO4D^
O6VH>Uue4z57k>aa9D9ra

literal 0
HcmV?d00001

diff --git a/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
new file mode 100644
index 0000000..725bebc
--- /dev/null
+++ b/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
@@ -0,0 +1,31 @@
+org/project/Game.class
+org/project/entity/enemies/Enemy.class
+org/project/entity/enemies/Vampire.class
+org/project/item/armors/Robe.class
+org/project/entity/players/ICombatActions.class
+org/project/item/consumables/Flask.class
+org/project/item/weapons/Dagger.class
+org/project/Main.class
+org/project/entity/players/Wizard.class
+org/project/Merchant.class
+org/project/entity/players/Player.class
+org/project/location/Location.class
+org/project/entity/enemies/Dragon.class
+org/project/entity/enemies/Goblin.class
+org/project/util/ConsoleColors.class
+org/project/item/weapons/Staff.class
+org/project/entity/enemies/Skeleton.class
+org/project/entity/Entity.class
+org/project/item/armors/LeatherArmor.class
+org/project/item/weapons/Sword.class
+org/project/entity/players/Assassin.class
+org/project/util/Dice.class
+org/project/item/armors/KnightArmor.class
+org/project/entity/enemies/KeyType.class
+org/project/item/weapons/Weapon.class
+org/project/item/weapons/GreatAxe.class
+org/project/item/armors/Armor.class
+org/project/entity/players/Knight.class
+org/project/item/consumables/Consumable.class
+org/project/item/consumables/ManaPotion.class
+org/project/item/Item.class
diff --git a/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
new file mode 100644
index 0000000..cd759f9
--- /dev/null
+++ b/Java-Knight/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
@@ -0,0 +1,31 @@
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/Game.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/Main.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/Merchant.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/Entity.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/Enemy.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/KeyType.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/Skeleton.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/players/Assassin.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/players/Knight.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/players/Player.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/entity/players/Wizard.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/Item.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/armors/Armor.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/armors/KnightArmor.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/armors/LeatherArmor.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/armors/Robe.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/consumables/Consumable.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/consumables/Flask.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/consumables/ManaPotion.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/weapons/Dagger.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/weapons/GreatAxe.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/weapons/Staff.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/weapons/Sword.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/item/weapons/Weapon.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/location/Location.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/util/ConsoleColors.java
+/Users/faraz/Documents/SBU/Term 6/AP/HW-04-JAVA-KNIGHT/Java-Knight/src/main/java/org/project/util/Dice.java
diff --git a/README.md b/README.md
index 1e2c975..a430304 100644
--- a/README.md
+++ b/README.md
@@ -1,175 +1,195 @@
-# Fourth Assignment - Java Knight ⚔️
-A turn-based RPG with Roguelike elements which can be run in the terminal.
+# Java Knight ⚔️
 
-### **Prologue: The Legend of Javanest**
-*For centuries, the land of Javanest lived in peace, until a magical Dragon attacked, plunging the realm into absolute darkness. With a wicked curse, the Dragon transformed the innocent people into horrific monsters: Goblins, Skeletons, and Vampires. Retreating to its impenetrable Castle, the Dragon divided the three keys to its lair and hid them among these cursed creatures. Now, it is your duty to step up and save the land. You must battle these monsters, recover the unique key from each monster type, and finally slay the Dragon to break the curse and restore peace to Javanest!*
+A turn-based, roguelike-inspired RPG that runs entirely in the terminal, written
+in Java for the fourth Advanced Programming assignment.
 
-### **Introduction**
-Welcome to **Java knight**, a turn-based RPG inspired by Roguelike games! In this assignment, you will develop a **text-based role-playing game (RPG)**. This project is designed to rigorously test your understanding of **Object-Oriented Programming (OOP) principles**.
-
-⚠️ **REQUIREMENT:** You **must** utilize all the OOP concepts you have learned so far—including *Inheritance, Interfaces, Abstract Classes, Encapsulation, Polymorphism, Overloading, and Overriding*. It is extremely important that you use everything in its right place. Your design and architecture will be graded based on how well you apply these principles to avoid code duplication and maintain a clean structure.
-
-🎯 **Your goal is not just to complete the assignment but to learn and apply OOP effectively!**
-
-### **What is a Turn-Based Game?**
-In this combat system, two sides - which are usually the player's side and the enemy's side - attack each other in turns. The side which is not attacking can perform actions to avoid or deflect the enemy's attack.
-
-### **Core Mechanics:**
-- **Turn-based combat** – Players and monsters take turns attacking each other.
-- **Character classes with Unique Traits** – Players can choose from archetypes like **Knight, Assassin, or Wizard**, each starting with distinctly different base stats.
-- **Unified Mana/Stamina System** – All player classes use a unified resource (Mana/Stamina) to perform actions.
-- **Standardized Action Set** – Every player character has exactly 5 specific actions available during their turn.
-- **Experience & Leveling System** – Earn XP based on enemy strength to automatically level up and increase your base stats.
-- **Progression System** – You cannot fight the Dragon immediately. You must farm enemies for a chance to drop their specific key, collect all three, and grow stronger first.
+> *For centuries, the land of Javanest lived in peace, until a magical Dragon
+> plunged it into darkness, cursing its people into monsters and scattering the
+> three keys to its lair among them. Battle the cursed creatures, recover the
+> Goblin, Skeleton and Vampire keys, grow strong, and slay the Dragon to break
+> the curse and restore peace to Javanest!*
 
 ---
 
-## Tasks 📝
-
-### 1️⃣ Step 1: Fork & Setup 🍴
-1. **Fork** this repository and clone it to your local machine.
-```bash
-git clone https://git.meshcomp.ir/AdvancedProgramming1404/HW-04-JAVA-KNIGHT.git
-```
-2. Create a new branch named `develop` and switch to it.
-```bash
-git checkout -b develop
-```
-### 2️⃣ Step 2: Implement the Class Hierarchy 🌲
-
-A well-structured OOP hierarchy is crucial. Avoid duplicating code by placing shared logic in abstract classes.
-
-- **Entities & Locations:** You have `Entity`, `Item`(Bonus) , and `Location`.
-- **Players:** `Player` is an abstract class implementing `Entity`. Subclasses: `Wizard`, `Knight`, `Assassin`.
-    - **Base Stat Differences:** Each class must have distinct starting stats. For example:
-        - **Knight:** Highest Base Damage.
-        - **Wizard:** Highest Max Health (HP).
-        - **Assassin:** Highest Max Stamina/Mana.
-- **Enemies:** `Enemy` is an abstract class implementing `Entity`. Subclasses: `Skeleton`, `Goblin`, `Vampire`, and **`Dragon`**.
-    - **The Boss:** Even though `Dragon` is the final boss, it **must** be a subclass of `Enemy` to inherit common combat properties, while possessing extremely high stats and unique mechanics.
-- **Item (Bonus):** `Consumable`, `Armor`, `Weapon` are abstract classes implementing `Item`. example :
-    - KnightArmor extends Armor - you can add more subclasses of Armor for extra score
-    - Sword extends Weapon - you can add more subclasses of Weapon for extra score
-    - Flask extends Consumable - you can add more subclasses of Consumable for extra score
-
-![structure](Readme_Pictures/structure.png)
-
-### 3️⃣ Step 3: Implement Player & Monster Methods 🏹
-
-**Player Actions (The Rule of Five):**
-Every player class **must** implement exactly the following 5 actions (You can use an interface like `ICombatActions`). Every action (except Light Attack) consumes a specific amount of Mana/Stamina. The **Special Ability** must consume the *highest* amount of Mana compared to the others.
-1. **Light Attack:** Deals moderate damage and costs **NO Mana**. (Note: If the player runs out of Mana/Stamina, this is the ONLY action they can perform.)
-2. **Heavy Attack:** Deals high damage, medium Mana cost.
-3. **Defend:** Completely blocks or significantly reduces the damage of the enemy's *next* strike. Medium Mana cost.
-4. **Heal:** Restores a portion of the player's HP. Medium-high Mana cost.
-5. **Special Ability:** A unique class-based ultimate move (Highest Mana cost):
-    - **Wizard** 🧙‍♂️: Casts a devastating spell that damages the enemy while simultaneously replenishing some HP.
-    - **Assassin** 🗡️: Turns invisible, dodging the next incoming attack completely and guaranteeing a *Critical Hit* on their next turn.
-    - **Knight** ⚔️: Performs a shield bash that stuns the enemy, forcing them to skip their next turn while dealing heavy damage.
-
-**Monster Abilities:**
-- **Goblin** 👹: High critical hit chance but low health.
-- **Skeleton** ☠️: Can resurrect once per battle with 50% HP.
-- **Vampire** 🦇: Lifesteal ability – a portion of the damage it deals to the player is added back to its own health.
-- **Dragon (Final Boss)** 🐉: Immune to normal defense. Its fiery breath bypasses shields and deals massive damage.
-
-🔹 Make sure each entity **prints messages** when performing actions. example output (while in combat) :
-
-```bash
-You chose to FIGHT!
-
-[Ser Duncan - 45/45 HP | 40/40 Mana]
-[Goblin - 30/30 HP]
+## Table of Contents
+1. [How to Compile & Run](#how-to-compile--run)
+2. [How to Play](#how-to-play)
+3. [Classes, Enemies & Stats](#classes-enemies--stats)
+4. [Project Structure](#project-structure)
+5. [OOP Principles Used](#oop-principles-used)
+6. [Bonus Features](#bonus-features)
 
 ---
 
-Your Turn:
-1. Light Attack | 2. Heavy Attack (-8 Mana) | 3. Defend (-6 Mana) | 4. Heal (-12 Mana) | 5. Shield Bash (-15 Mana)
-```
+## How to Compile & Run
 
+The project is a standard Maven project. You need **JDK 21+** installed.
+
+### Using Maven (recommended)
 ```bash
-→ Chose: Light Attack
-⚔️ Ser Duncan (Knight) used Light Attack! (0 Mana)
-Goblin took 10 damage!
-Goblin has 20/30 HP remaining.
-Ser Duncan Mana: 40/40
-```
-```
-Goblin's Turn :
-👹 Goblin used Critical Strike!
-💥 Critical hit! Ser Duncan took 20 damage!
-Ser Duncan has 25/45 HP remaining.
-```
-🔹 *Narrative Console:* Use ANSI escape codes to print colorful narrative logs (e.g., Red for damage, Blue for Mana usage, Green for healing).
-
-
-### 4️⃣ Step 4: Implement the Game Loop & Progression 🎮
-
-1. **The Core Loop:** The game starts with the player entering a location. A random standard enemy (`Goblin`, `Skeleton`, or `Vampire`) spawns immediately.
-2. **Player Choices:** Before engaging, the player is presented with the following options:
-    - **1. Fight the enemy:** Enter the turn-based combat sequence.
-    - **2. Move to another location:** Skip the current enemy and spawn a new random one.
-    - **3. Go to the Castle to fight the Dragon:** *(Note: This option must remain strictly hidden or locked until the player has successfully collected all 3 keys).*
-3. **The Key Drop Logic (RNG Gatekeeping):**
-    - When the player defeats an enemy, there is a **specific percentage chance (e.g., 20%)** that it will drop the unique key associated with its species (Goblin Key, Skeleton Key, Vampire Key).
-    - **One Key Per Species:** Once a player obtains a specific key (e.g., Goblin Key), subsequent enemies of that same type (other Goblins) will **never** drop a key again.
-    - The player **must collect all 3 distinct keys** to unlock Option 3 and enter the Castle.
-4. **Post-Combat Recovery:** After each successful battle, the player's HP and Mana bars must automatically replenish (either fully or partially) to their base amounts so they are ready for the next encounter.
-5. **Experience & Leveling System:**
-    - Defeating an enemy grants **XP**. The amount of XP must scale proportionally to the enemy's power level.
-    - Upon reaching an XP threshold, the player levels up. **Leveling up must automatically increase the player's Max HP and Max Stamina/Mana**, making them strong enough to eventually face the Dragon.
-6. **Final Boss Fight:** Once the 3 Keys are obtained and the player chooses to go to the Castle, they will face the Dragon. Defeating the Dragon breaks the curse, resulting in **Victory**. Dying at any point results in **Game Over**.
-
-🔹 Example game loop structure:
-
-```java
-while (player.isAlive() && enemy.isAlive())
-    player.attack(enemy);
-    if (enemy.isAlive()) {
-        enemy.attack(player);
-    }
-}
+cd Java-Knight
+mvn compile
+mvn exec:java -Dexec.mainClass=org.project.Main
 ```
 
+### Using plain `javac` / `java`
+```bash
+cd Java-Knight
+# compile every source file into the target/classes folder
+find src/main/java -name "*.java" > sources.txt
+javac -d target/classes @sources.txt
 
-### 5️⃣ Step 5: Extra Features & Bonus Tasks ⭐
-*(Optional for extra credit)*
+# run it
+java -cp target/classes org.project.Main
+```
 
-✅ **Dynamic Economy & Merchant System:** Implement coins that drop from enemies. Add a "Visit Merchant" option to the main loop where players can spend coins to buy specific weapons, armors, or consumables.  
-✅ **Multiple Weapons & Inventory:** Players can buy, store, and swap between multiple weapons  or use consumables mid-combat.  
-✅ **Multiplayer/Party Mode:** Allow multiple players to team up and fight multiple enemies together. The Dragon's breath attack will damage the entire party simultaneously.  
-✅ **PvP Mode:** Implement a **Player vs. Player** combat system.
-
-### 6️⃣ Step 6: Write a Comprehensive README 📄
-As the final mandatory step of your development, you must replace the default `README.md` with your own comprehensive documentation. Your README should include:
-- A brief introduction to the game.
-- How to compile and run your project from the terminal.
-- An explanation of the classes, design patterns, and OOP principles you used.
-- A brief guide on how to play (controls, stats, classes).
+> The game uses ANSI colour codes, so run it in a real terminal (macOS Terminal,
+> Linux shell, Windows Terminal) for the intended colourful output.
 
 ---
 
-## Evaluation Criteria ⚖
+## How to Play
 
-| **Criteria**                                                | **Points** |
-|-------------------------------------------------------------|------------|
-| Proper use of OOP principles                                | **50**     |
-| Working combat mechanics, Leveling System & Enemy abilities | **20**     |
-| Clear and Comprehensive `README.md`                         | **20**     |
-| Code readability, documentation, and comments               | **10**     |
-| Meaningful, interactive, & colored console outputs          | **10**     |
-| Inventory (item) and Merchant System (bonus)                | **20**     |
-| Other Extra features (bonus tasks)                          | **20**     |
-| **Total Score**                                             | **150**    |
+1. **Name your hero** and **pick a class** (Knight, Wizard, or Assassin).
+2. You wander into a random **location** and a random standard enemy appears.
+   For each encounter you choose:
+   - **1. Fight** – enter turn-based combat.
+   - **2. Move** – skip this enemy and travel somewhere new.
+   - **3. Visit the Merchant** – spend coins on potions, a weapon, or repairs.
+   - **4. Go to the Castle** – *only appears once you hold all 3 keys* – fight
+     the Dragon.
+3. **Combat is turn-based.** On your turn you pick one of five actions. Only
+   **Light Attack** is free; the rest cost Mana/Stamina, and the class
+   **Special** costs the most. If you run out of Mana, you can still Light
+   Attack.
 
-## Tips 🚀
-- **Follow OOP principles**: Avoid redundant code by using inheritance properly. Think carefully about what belongs in an abstract class vs. a specific subclass. Make sure you use overriding and overloading correctly.
-- **Test your code**: Run different scenarios (fighting, running out of mana, leveling up, dying) to ensure everything works as expected.
-- **Ask for help**: If you're stuck, reach out to your classmates or mentors.
+   | # | Action        | Cost      | Effect |
+   |---|---------------|-----------|--------|
+   | 1 | Light Attack  | 0         | Moderate damage |
+   | 2 | Heavy Attack  | 8         | Double damage |
+   | 3 | Defend        | 6         | Blocks ~75% of the next hit |
+   | 4 | Heal          | 12        | Restores 40% of max HP |
+   | 5 | Special       | 15        | Unique class ultimate |
+   | 6 | Use Item      | –         | Drink a potion from your inventory |
 
-## Submission ⌛
-- **Deadline**: Submit your assignment before **21 Ordibehesht (May 11th, 2026)**.
-- **Submission Format**: Push your code to your forked repository, create a PR, and ensure your comprehensive `README.md` is included in the root directory.
+4. **Winning a fight** grants **XP** (scaled to the enemy's power), **coins**,
+   and a chance to drop that species' **key**. Your HP and Mana are then fully
+   restored.
+5. **Leveling up** automatically raises your Max HP, Max Mana and base damage.
+6. Collect **all 3 keys**, go to the Castle, and defeat the **Dragon** to win.
+   Dying at any point is **Game Over**.
 
-![cover](Readme_Pictures/image.png)
-###### - Born of God and Void. You shall seal the blinding light that plagues their dreams. You are the Vessel. You are the Java Knight.
\ No newline at end of file
+---
+
+## Classes, Enemies & Stats
+
+### Player Classes
+Each class has deliberately different starting stats, so they play differently.
+
+| Class      | HP | Mana | Base Dmg | Weapon      | Special ability |
+|------------|----|------|----------|-------------|-----------------|
+| **Knight** ⚔️  | 50 | 40 | **8 (highest)** | Iron Sword | **Shield Bash** – heavy damage + stuns the enemy (skips its next turn) |
+| **Wizard** 🧙  | **65 (highest)** | 45 | 5 | Oak Staff | **Arcane Blast** – heavy damage AND heals the caster |
+| **Assassin** 🗡️ | 45 | **55 (highest)** | 6 | Twin Dagger | **Vanish** – dodges the next attack + guarantees a crit on the next strike |
+
+### Enemies
+| Enemy      | HP  | Ability | Key |
+|------------|-----|---------|-----|
+| **Goblin** 👹   | 30  | 40% chance to land a **critical hit** (double damage) | Goblin Key |
+| **Skeleton** ☠️ | 40  | **Resurrects once** per battle at 50% HP | Skeleton Key |
+| **Vampire** 🦇  | 48  | **Lifesteal** – heals for 50% of the damage it deals | Vampire Key |
+| **Dragon** 🐉   | 160 | **True damage** – fiery breath ignores armor *and* the Defend stance | — |
+
+Standard enemies each have a **25% chance** to drop their key, and only **one key
+per species** can ever drop (once you have the Goblin Key, no other Goblin will
+drop one).
+
+---
+
+## Project Structure
+
+```
+org.project
+├── Main.java                 // entry point – builds the world, starts the game
+├── Game.java                 // the game controller / main loop
+├── Merchant.java             // bonus shop system
+├── entity
+│   ├── Entity.java           // interface every combatant implements
+│   ├── players
+│   │   ├── ICombatActions.java   // interface: the 5 required actions
+│   │   ├── Player.java           // abstract base for all heroes
+│   │   ├── Knight.java / Wizard.java / Assassin.java
+│   └── enemies
+│       ├── Enemy.java            // abstract base for all monsters
+│       ├── KeyType.java          // enum of the three keys
+│       ├── Goblin.java / Skeleton.java / Vampire.java / Dragon.java
+├── item
+│   ├── Item.java             // interface for anything ownable/sellable
+│   ├── weapons  (Weapon abstract → Sword, Dagger, Staff, GreatAxe)
+│   ├── armors   (Armor abstract  → KnightArmor, LeatherArmor, Robe)
+│   └── consumables (Consumable abstract → Flask, ManaPotion)
+├── location
+│   └── Location.java         // a place that spawns random enemies
+└── util
+    ├── ConsoleColors.java    // ANSI colour helpers
+    └── Dice.java             // random-number helpers
+```
+
+---
+
+## OOP Principles Used
+
+This project was designed around the seven principles the assignment asks for:
+
+- **Encapsulation** – all fields are `private`/`protected` with getters. HP, Mana
+  and XP can only be changed through methods like `takeDamage`, `heal` and
+  `gainXP`, which enforce their own rules (clamping to max, capping at zero,
+  leveling up).
+
+- **Inheritance** – shared logic lives in abstract base classes so it isn't
+  duplicated. `Player` holds the HP/Mana bars, leveling, inventory and four of
+  the five actions; `Knight`, `Wizard` and `Assassin` only add what's unique.
+  Same idea for `Enemy` → its four monster subclasses, and for
+  `Weapon`/`Armor`/`Consumable` → their concrete items.
+
+- **Interfaces** – `Entity` is the contract every combatant obeys, which is what
+  lets the combat loop treat a Knight and a Dragon identically. `ICombatActions`
+  guarantees every player class implements exactly the five required actions.
+  `Item` unifies weapons, armor and consumables so the merchant can sell any of
+  them.
+
+- **Abstract classes** – `Player`, `Enemy`, `Weapon`, `Armor` and `Consumable`
+  are all abstract: they provide shared state/behaviour but can't be instantiated
+  on their own, forcing subclasses to fill in the specifics (e.g.
+  `Player.specialAbility` is abstract).
+
+- **Polymorphism** – the whole game loop is polymorphic. `Game` only ever calls
+  `Player`/`Enemy`/`Entity` methods; the correct `specialAbility`, `attack` or
+  `takeDamage` runs depending on the real object. Each enemy overrides `attack`
+  to add its signature move.
+
+- **Overriding** – subclasses override base behaviour, e.g. `Skeleton` overrides
+  `takeDamage` to resurrect, `Vampire`/`Goblin`/`Dragon` override `attack`, and
+  every player class overrides `specialAbility`.
+
+- **Overloading** – `takeDamage(int)` vs `takeDamage(int, boolean)` in `Player`.
+  The second, overloaded version ignores defenses and is how the Dragon's breath
+  bypasses armor and shields. The `Sword` also overloads its constructor.
+
+---
+
+## Bonus Features
+
+- **Coins & Merchant system** – enemies drop coins; the Merchant sells Health
+  Flasks, Mana Potions, a stronger **Great Axe**, and can **repair** armor.
+- **Inventory & consumables** – potions can be bought, stored and used mid-combat
+  (action 6).
+- **Durable armor** – armor loses durability as it absorbs hits and eventually
+  breaks, until repaired at the merchant.
+- **Colourful narrative console** – ANSI colours (red for damage, blue for mana,
+  green for healing) make the combat log easy to read.
+
+---
+
+*Born of God and Void. You shall seal the blinding light that plagues their
+dreams. You are the Vessel. You are the Java Knight.*