add BurnEffect.java FreezeEffect.java PoisonEffect.java StatusEffect.java

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

@@ -0,0 +1,312 @@
+package org.project;
+
+import org.project.combat.*;
+import org.project.entity.enemies.*;
+import org.project.entity.players.*;
+import org.project.location.Location;
+import org.project.managers.*;
+
+import java.util.*;
+
+public class GameLoop {
+
+    private final Scanner scanner = new Scanner(System.in);
+
+    private final ActionDecisionManager actionManager = new ActionDecisionManager();
+    private final StatusEffectManager statusManager = new StatusEffectManager();
+    private final SpecialAbilityManager abilityManager = new SpecialAbilityManager();
+    private final ManaCostManager manaManager = new ManaCostManager();
+
+    private final TotalAttackCalculator attackCalculator =
+            new TotalAttackCalculator(statusManager, abilityManager, manaManager);
+
+    private Player player;
+    private Enemy currentEnemy;
+
+    private boolean gameRunning = true;
+
+    private boolean hasGoblinKey;
+    private boolean hasSkeletonKey;
+    private boolean hasVampireKey;
+
+    private Location currentLocation;
+    private final List<Location> locations = new ArrayList<>();
+
+
+    public GameLoop() {
+        initializeLocations();
+    }
+
+    private void initializeLocations() {
+
+        Location valhalla = new Location("Valhalla");
+        Location elysium = new Location("Elysium");
+        Location niflheim = new Location("Niflheim");
+        Location castle = new Location("Castle");
+
+        valhalla.connect(elysium);
+        valhalla.connect(niflheim);
+        elysium.connect(niflheim);
+        niflheim.connect(castle);
+
+        locations.add(valhalla);
+        locations.add(elysium);
+        locations.add(niflheim);
+        locations.add(castle);
+
+        currentLocation = valhalla;
+    }
+
+    public void start() {
+
+        System.out.println("====== JAVA KNIGHT ======");
+
+        chooseClass();
+        spawnEnemy();
+
+        while (gameRunning) {
+            showMenu();
+        }
+
+        System.out.println("Game Ended.");
+    }
+
+    private void chooseClass() {
+
+        System.out.println("""
+                Choose class:
+                1. Knight   (HP:150 MP:80 DMG:12)
+                2. Wizard   (HP:80 MP:200 DMG:10)
+                3. Assassin (HP:90 MP:120 DMG:15)
+                """);
+
+        int choice = scanner.nextInt();
+
+        switch (choice) {
+            case 2 -> player = new Wizard("Merlin");
+            case 3 -> player = new Assassin("Shadow");
+            default -> player = new Knight("Sir Duncan");
+        }
+    }
+
+    private void showMenu() {
+
+        System.out.println("====" + Colors.YELLOW +  " GAME MENU " + Colors.RESET + "====");
+        System.out.println("Location: " + currentLocation.getName());
+
+        if (currentEnemy != null)
+            System.out.println("Enemy: " + currentEnemy);
+
+        System.out.println("""
+                \n1. Fight
+                2. Inventory
+                3. Move
+                0. Exit
+                """);
+
+        if (hasAllKeys())
+            System.out.println("4. Fight Dragon");
+
+        int choice = scanner.nextInt();
+
+        switch (choice) {
+            case 1 -> startCombat();
+            case 2 -> new InventoryManager().displayInventory(player);
+            case 3 -> move();
+            case 4 -> {
+                if (hasAllKeys())
+                    fightDragon();
+            }
+            case 0 -> gameRunning = false;
+        }
+    }
+
+    private void move() {
+
+        List<Location> connected = currentLocation.getConnectedLocations();
+
+        if (connected.isEmpty()) {
+            System.out.println("No paths from here.");
+            return;
+        }
+
+        System.out.println("Choose destination:");
+
+        for (int i = 0; i < connected.size(); i++)
+            System.out.println((i + 1) + ". " + connected.get(i).getName());
+
+        int choice = scanner.nextInt();
+
+        if (choice < 1 || choice > connected.size())
+            return;
+
+        currentLocation = connected.get(choice - 1);
+
+        spawnEnemy();
+    }
+
+    private void spawnEnemy() {
+
+        Enemy[] enemies = {
+                new Goblin(),
+                new Skeleton(),
+                new Vampire()
+        };
+
+        currentEnemy = enemies[(int) (Math.random() * enemies.length)];
+    }
+
+    private void startCombat() {
+
+        if (currentEnemy == null) {
+            System.out.println("No enemy here.");
+            return;
+        }
+
+        System.out.println(Colors.RED_BRIGHT + "⚔ COMBAT STARTED! ⚔" + Colors.RESET);
+
+
+        while (player.isLive() && currentEnemy.isLive()) {
+
+            statusManager.tick(player);
+            statusManager.tick(currentEnemy);
+
+            abilityManager.tick(currentEnemy, player);
+            abilityManager.tick(player, currentEnemy);
+
+            if (!player.isLive() || !currentEnemy.isLive())
+                break;
+
+            playerTurn();
+            currentEnemy.resetTurnState();
+
+            if (currentEnemy.isLive())
+                enemyTurn();
+            player.resetTurnState();
+        }
+
+        if (player.isLive())
+            victory();
+        else
+            gameRunning = false;
+    }
+
+
+    private void playerTurn() {
+        System.out.println("====" + Colors.YELLOW +  " YOUR TURN " + Colors.RESET + "====");
+        System.out.println(player.getName() + "-> HP: " + player.getHp() + " | MP: " + player.getMp() + " | level: " + player.getLevel() + " | XP: " + player.getXp());
+        System.out.println(currentEnemy.getName() + "-> HP: "  + currentEnemy.getHp() + " | MP: " + currentEnemy.getMp());
+        System.out.println("\n");
+        var action = actionManager.userChooseAction();
+
+        AttackResult result = attackCalculator.calculate(player, currentEnemy, action);
+
+        int totalDamage = result.getDamageToTarget();
+        int healAmount = result.getHealSelf();
+        boolean isDefend = result.isDefended();
+
+        if (totalDamage > 0) {
+            System.out.println(currentEnemy.getName() + " got " + totalDamage + " damage");
+            currentEnemy.takeDamage(totalDamage);
+        }
+
+        if (healAmount > 0) {
+            player.heal(healAmount);
+            if (player.getHp() < player.getMaxHP())
+                System.out.println(player.getName() + "healed " + healAmount + " HP");
+        }
+
+        if (isDefend) {
+            player.defend();
+            System.out.println(player.getName() + " will defend (50% damage)");
+        }
+        System.out.println("\n");
+    }
+
+    private void enemyTurn() {
+        System.out.println("====" + Colors.YELLOW +  " ENEMY TURN " + Colors.RESET + "====\n");
+        var action = actionManager.botChooseAction();
+
+        System.out.println("enemy random choose action: " + Colors.RED + action + Colors.RESET);
+
+        AttackResult result = attackCalculator.calculate(currentEnemy, player, action);
+
+        int totalDamage = result.getDamageToTarget();
+        int healAmount = result.getHealSelf();
+        boolean isDefend = result.isDefended();
+
+
+        if (totalDamage > 0) {
+            System.out.println(player.getName() + " got " + totalDamage + " damage");
+            player.takeDamage(totalDamage);
+        }
+
+        if (healAmount > 0) {
+            currentEnemy.heal(healAmount);
+            if (currentEnemy.getHp() < currentEnemy.getMaxHP())
+                System.out.println(currentEnemy.getName() + " healed " + healAmount + " HP");
+
+        }
+
+        if (isDefend) {
+            currentEnemy.defend();
+            System.out.println(currentEnemy.getName() + " will defend (50% damage)");
+        }
+
+
+        System.out.println("\n");
+
+    }
+
+    private void victory() {
+
+        System.out.println(Colors.GREEN + "Victory!" + Colors.RESET);
+
+        currentEnemy.rewardXp(player);
+
+        checkKeyDrop();
+
+        player.restore();
+
+        currentEnemy = null;
+    }
+
+    private void checkKeyDrop() {
+
+        if (Math.random() * 100 > 20)
+            return;
+
+        if (currentEnemy instanceof Goblin && !hasGoblinKey) {
+            hasGoblinKey = true;
+            System.out.println("Goblin Key obtained!");
+        }
+
+        else if (currentEnemy instanceof Skeleton && ! hasSkeletonKey) {
+            hasSkeletonKey = true;
+            System.out.println("Skeleton Key obtained!");
+        }
+
+        else if (currentEnemy instanceof Vampire && !hasVampireKey) {
+            hasVampireKey = true;
+            System.out.println("Vampire Key obtained!");
+        }
+    }
+
+    private boolean hasAllKeys() {
+        return hasGoblinKey && hasSkeletonKey && hasVampireKey;
+    }
+
+    private void fightDragon() {
+
+        currentEnemy = new Dragon();
+
+        System.out.println("The Dragon Appears!");
+
+        startCombat();
+
+        if (player.isLive())
+            System.out.println("YOU SAVED JAVANEST!");
+        else
+            System.out.println("The Dragon has defeated you...");
+    }
+}

Java-Knight/src/main/java/org/project/combat/AttackResult.java

@@ -0,0 +1,18 @@
+package org.project.combat;
+
+public class AttackResult {
+
+    private int damageToTarget;
+    private int healSelf;
+    private boolean defended;
+
+    public AttackResult(int damageToTarget, int healSelf, boolean defended) {
+        this.damageToTarget = damageToTarget;
+        this.healSelf = healSelf;
+        this.defended = defended;
+    }
+
+    public int getDamageToTarget() { return damageToTarget; }
+    public int getHealSelf() { return healSelf; }
+    public boolean isDefended() { return defended; }
+}

Java-Knight/src/main/java/org/project/combat/TotalAttackCalculator.java

@@ -0,0 +1,198 @@
+package org.project.combat;
+
+import org.project.abilities.SpecialAbility;
+import org.project.entity.Entity;
+import org.project.entity.players.Player;
+import org.project.item.armors.Armor;
+import org.project.item.weapons.Weapon;
+import org.project.managers.ActionDecisionManager;
+import org.project.managers.ManaCostManager;
+import org.project.managers.SpecialAbilityManager;
+import org.project.managers.StatusEffectManager;
+
+public class TotalAttackCalculator {
+
+    private final StatusEffectManager statusEffectManager;
+    private final SpecialAbilityManager specialAbilityManager;
+    private final ManaCostManager manaCostManager;
+
+    private static final int HEAL_AMOUNT = 25;
+    private static final int SHIELD_BASH_BASE_DAMAGE = 15;
+    private static final int SHIELD_BASH_STUN_CHANCE = 30;
+
+    public TotalAttackCalculator(
+            StatusEffectManager statusEffectManager,
+            SpecialAbilityManager specialAbilityManager,
+            ManaCostManager manaCostManager
+    ) {
+        this.statusEffectManager = statusEffectManager;
+        this.specialAbilityManager = specialAbilityManager;
+        this.manaCostManager = manaCostManager;
+    }
+
+    public AttackResult calculate(
+            Entity attacker,
+            Entity defender,
+            ActionDecisionManager.actionsType action
+    ) {
+
+        switch (action) {
+
+            case lightAttack:
+                return lightAttack(attacker, defender);
+
+            case heavyAttack:
+                return heavyAttack(attacker, defender);
+
+            case defend:
+                return defend(attacker);
+
+            case heal:
+                return heal(attacker);
+
+            case ability:
+                return ability(attacker, defender);
+
+            case shiedbash:
+                return shieldBash(attacker, defender);
+        }
+
+        return new AttackResult(0,0,false);
+    }
+
+    // --------------------------------
+    // LIGHT ATTACK
+    // --------------------------------
+    private AttackResult lightAttack(Entity attacker, Entity defender) {
+
+        int damage = attacker.getBaseDamage();
+
+        Weapon weapon = attacker.getWeapon();
+
+        if (weapon != null) {
+            damage += weapon.getLightAttackDamage();
+
+            if (weapon.getEffect() != null)
+                statusEffectManager.addEffect(weapon.getEffect(), defender);
+        }
+
+        damage = applyArmor(defender, damage);
+
+        if (defender.isDefending())
+            damage /= 2;
+
+        return new AttackResult(damage,0,false);
+    }
+
+    // --------------------------------
+    // HEAVY ATTACK
+    // --------------------------------
+    private AttackResult heavyAttack(Entity attacker, Entity defender) {
+
+        if (!manaCostManager.useHeavyAttack( attacker))
+            return new AttackResult(0,0,false);
+
+        int damage = attacker.getBaseDamage() * 2;
+
+        Weapon weapon = attacker.getWeapon();
+
+        if (weapon != null) {
+
+            damage += weapon.getHeavyAttackDamage();
+
+            if (weapon.getEffect() != null)
+                statusEffectManager.addEffect(weapon.getEffect(), defender);
+        }
+
+        damage = applyArmor(defender, damage);
+
+        if (defender.isDefending())
+            damage /= 2;
+
+        return new AttackResult(damage,0,false);
+    }
+
+    // --------------------------------
+    // DEFEND
+    // --------------------------------
+    private AttackResult defend(Entity attacker) {
+
+        if (!manaCostManager.useHeavyAttack( attacker))
+            return new AttackResult(0,0,false);
+
+        return new AttackResult(0,0,true);
+    }
+
+    // --------------------------------
+    // HEAL
+    // --------------------------------
+    private AttackResult heal(Entity attacker) {
+
+        if (!manaCostManager.useHeavyAttack( attacker))
+            return new AttackResult(0,0,false);
+
+        return new AttackResult(0,HEAL_AMOUNT,false);
+    }
+
+    // --------------------------------
+    // SPECIAL ABILITY
+    // --------------------------------
+    private AttackResult ability(Entity attacker, Entity defender) {
+
+        SpecialAbility ability = attacker.getSpacialAbility();
+
+        if (ability == null)
+            return new AttackResult(0,0,false);
+
+        if (attacker instanceof Player && !manaCostManager.useSpecialAbility((Player) attacker))
+            return new AttackResult(0,0,false);
+
+        Entity target =
+                ability.getTarget() == SpecialAbility.AbilityTarget.SELF
+                        ? attacker
+                        : defender;
+
+        specialAbilityManager.addAbility(ability, target);
+
+        return new AttackResult(0,0,false);
+    }
+
+    // --------------------------------
+    // SHIELD BASH
+    // --------------------------------
+    private AttackResult shieldBash(Entity attacker, Entity defender) {
+
+        if (!manaCostManager.useHeavyAttack( attacker))
+            return new AttackResult(0,0,false);
+
+        Armor armor = attacker.getArmor();
+
+        if (armor == null)
+            return new AttackResult(0,0,false);
+
+        if (armor.getType() != Armor.ArmorType.HEAVY)
+            return new AttackResult(0,0,false);
+
+        int damage = SHIELD_BASH_BASE_DAMAGE + armor.getDefense() / 2;
+
+        damage = applyArmor(defender, damage);
+
+        if (Math.random() * 100 < SHIELD_BASH_STUN_CHANCE)
+            defender.stun();
+
+        return new AttackResult(damage,0,false);
+    }
+
+    // --------------------------------
+    // ARMOR REDUCTION
+    // --------------------------------
+    private int applyArmor(Entity defender, int rawDamage) {
+
+        Armor armor = defender.getArmor();
+
+        if (armor == null)
+            return rawDamage;
+
+        return armor.reduceDamage(rawDamage);
+    }
+}

Java-Knight/src/main/java/org/project/item/consumables/Flask.java

@@ -1,16 +0,0 @@
-package org.project.item.consumables;
-
-import org.project.entity.Entity;
-
-// TODO: UPDATE IMPLEMENTATION
-public class Flask {
-    /*
-    THIS IS AN EXAMPLE OF A CONSUMABLE DESIGN.
-    */
-
-    // TODO: UPDATE USE METHOD
-    @Override
-    public void use(Entity target) {
-        target.heal(target.getMaxHP() / 10);
-    }
-}

Java-Knight/src/main/java/org/project/item/consumables/HealFlask.java

@@ -0,0 +1,24 @@
+package org.project.item.consumables;
+
+import org.project.entity.Entity;
+import org.project.entity.players.Player;
+import org.project.item.Item;
+
+public class HealFlask extends Consumable {
+
+    private int healAmount;
+
+    public HealFlask(String name, int healAmount, int charges) {
+        super(name, healAmount, charges);
+    }
+
+
+
+    public void use(Player target) {
+
+        super.use(target);
+        System.out.println(target.getName() + " healed for " + healAmount);
+    }
+
+
+}

Java-Knight/src/main/java/org/project/item/consumables/ManaFlask.java

@@ -0,0 +1,23 @@
+package org.project.item.consumables;
+
+import org.project.entity.Entity;
+import org.project.entity.players.Player;
+import org.project.item.Item;
+
+public class ManaFlask extends Consumable {
+
+    private int manaAmount;
+
+    public ManaFlask(String name, int manaAmount, int charges) {
+
+        super(name, manaAmount, charges);
+    }
+
+
+    public void use(Player target) {
+        super.use(target);
+
+        System.out.println(target.getName() + " got " + manaAmount + " mana");
+    }
+
+}

Java-Knight/src/main/java/org/project/item/weapons/Dagger.java

@@ -0,0 +1,26 @@
+package org.project.item.weapons;
+
+import org.project.weaponEffects.StatusEffect;
+
+public class Dagger extends Weapon {
+
+    private static final String NAME = "Sword";
+    private static final int LIGHT_DAMAGE = 10;
+    private static final int HEAVY_DAMAGE = 5;
+    private static final int DURABILITY = 4;
+
+    public Dagger() {
+        this(null);
+    }
+
+    public Dagger(StatusEffect weaponEffect) {
+
+        super(
+                NAME,
+                LIGHT_DAMAGE,
+                HEAVY_DAMAGE,
+                weaponEffect,
+                DURABILITY
+        );
+    }
+}

Java-Knight/src/main/java/org/project/item/weapons/Sword.java

@@ -1,26 +1,26 @@
 package org.project.item.weapons;
 
-import org.project.entity.Entity;
+import org.project.weaponEffects.StatusEffect;
 
-import java.util.ArrayList;
+public class Sword extends Weapon {
 
-// TODO: UPDATE IMPLEMENTATION
-public class Sword {
-    /*
-    THIS IS AN EXAMPLE OF A WEAPON DESIGN.
-    */
-
-    int abilityCharge;
+    private static final String NAME = "Sword";
+    private static final int LIGHT_DAMAGE = 10;
+    private static final int HEAVY_DAMAGE = 5;
+    private static final int DURABILITY = 4;
 
     public Sword() {
-        // TODO: DESIGN SWORD'S ATTRIBUTES IMPLEMENT THE CONSTRUCTOR
+        this(null);
     }
 
-    // TODO: (BONUS) UPDATE THE UNIQUE ABILITY
-    public void uniqueAbility(ArrayList<Entity> targets) {
-        abilityCharge += 2;
-        for (Entity target : targets) {
-            target.takeDamage(getDamage());
-        }
+    public Sword(StatusEffect weaponEffect) {
+
+        super(
+                NAME,
+                LIGHT_DAMAGE,
+                HEAVY_DAMAGE,
+                weaponEffect,
+                DURABILITY
+        );
     }
 }

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

@@ -1,35 +1,48 @@
 package org.project.item.weapons;
 
-import org.project.entity.Entity;
+import org.project.weaponEffects.StatusEffect;
+
+import org.project.item.Item;
+
 
 // TODO: UPDATE IMPLEMENTATION
-public abstract class Weapon {
-    private int damage;
-    private int manaCost;
+public abstract class Weapon implements Item {
 
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS ATTRIBUTES
-    */
+    private String name;
+    private StatusEffect effect;
+    private int lightAttackDamage;
+    private int heavyAttackDamage;
+    private int equipManaCost;
 
-    public Weapon(int damage, int manaCost) {
-        this.damage = damage;
-        this.manaCost = manaCost;
+
+    public Weapon(String name,int heavyAttackDamage,int lightAttackDamage, StatusEffect statusEffect, int equipManaCost) {
+        this.name = name;
+        this.lightAttackDamage = lightAttackDamage;
+        this.heavyAttackDamage = heavyAttackDamage;
+        this.effect = statusEffect;
+        this.equipManaCost = equipManaCost;
     }
 
+    public int getHeavyAttackDamage() {
+        return heavyAttackDamage;
+    }
+
+    public int getLightAttackDamage() {
+        return lightAttackDamage;
+    }
+
+    public StatusEffect getEffect() {
+        return effect;
+    }
+
+    public void setEffect(StatusEffect effect) {
+        this.effect = effect;
+    }
+
+
     @Override
-    public void use(Entity target) {
-        target.takeDamage(damage);
+    public String getName() {
+        return name;
     }
 
-    public int getDamage() {
-        return damage;
-    }
-
-    public int getManaCost() {
-        return manaCost;
-    }
-
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
 }

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

@@ -3,26 +3,75 @@ package org.project.location;
 import org.project.entity.enemies.Enemy;
 
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 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;
+    private final List<Location> connectedLocations;
+    private final List<Enemy> enemies;
+
+    public Location(String name) {
+        this.name = name;
+        this.connectedLocations = new ArrayList<>();
+        this.enemies = new ArrayList<>();
+    }
+
+    public Location(String name, List<Location> connectedLocations, List<Enemy> enemies) {
+        this.name = name;
+
+        this.connectedLocations =
+                connectedLocations != null ? new ArrayList<>(connectedLocations) : new ArrayList<>();
+
+        this.enemies =
+                enemies != null ? new ArrayList<>(enemies) : new ArrayList<>();
     }
 
     public String getName() {
         return name;
     }
 
-    public ArrayList<Location> getLocations() {
-        return locations;
+    public List<Location> getConnectedLocations() {
+        return Collections.unmodifiableList(connectedLocations);
     }
 
-    public ArrayList<Enemy> getEnemies() {
-        return enemies;
+    public List<Enemy> getEnemies() {
+        return Collections.unmodifiableList(enemies);
+    }
+
+    // ------------------------------------
+    // ADD / REMOVE LOCATIONS
+    // ------------------------------------location
+
+    public void connect(Location other) {
+        if (other == null || other == this) return;
+
+        if (!connectedLocations.contains(other)) {
+            connectedLocations.add(other);
+        }
+
+        if (!other.connectedLocations.contains(this)) {
+            other.connectedLocations.add(this);
+        }
+    }
+
+
+    public void removeLocation(Location location) {
+        connectedLocations.remove(location);
+    }
+
+    // ------------------------------------
+    // ADD / REMOVE ENEMIES
+    // ------------------------------------
+    public void addEnemy(Enemy enemy) {
+        if (enemy != null) {
+            enemies.add(enemy);
+        }
+    }
+
+    public void removeEnemy(Enemy enemy) {
+        enemies.remove(enemy);
     }
 }

Java-Knight/src/main/java/org/project/managers/ActionDecisionManager.java

@@ -0,0 +1,74 @@
+package org.project.managers;
+
+
+
+import java.util.Random;
+import java.util.Scanner;
+
+
+public class ActionDecisionManager {
+
+    public enum actionsType {
+        lightAttack,
+        heavyAttack,
+        defend,
+        heal,
+        ability,
+        shiedbash,
+        inventory
+    }
+
+
+    private Random random = new Random();
+
+
+    public actionsType userChooseAction() {
+        actionsType res = null;
+        while (true) {
+            System.out.println("Choose attack type:\n");
+            System.out.println("1.lightAttack");
+            System.out.println("2.heavyAttack");
+            System.out.println("3.heal");
+            System.out.println("4.defend");
+            System.out.println("5.ability");
+            System.out.println("6.shielBash");
+            System.out.println("7.inventory");
+
+            int choice = new Scanner(System.in).nextInt();
+            switch (choice) {
+                case 1:
+                    return actionsType.lightAttack;
+                case 2:
+                    return actionsType.heavyAttack;
+                case 3:
+                    return actionsType.heal;
+                case 4:
+                    return actionsType.defend;
+                case 5:
+                    return actionsType.ability;
+                case 6:
+                    return actionsType.shiedbash;
+                case 7:
+                    return actionsType.inventory;
+                default:
+                    return actionsType.lightAttack;
+            }
+
+        }
+
+    }
+
+    public actionsType botChooseAction() {
+
+        actionsType[] possibleActions = {
+                actionsType.lightAttack,
+                actionsType.heavyAttack,
+                actionsType.defend,
+                actionsType.heal
+        };
+
+        return possibleActions[random.nextInt(possibleActions.length)];
+    }
+
+
+}

Java-Knight/src/main/java/org/project/managers/InventoryManager.java

@@ -0,0 +1,234 @@
+package org.project.managers;
+
+import org.project.Colors;
+import org.project.entity.players.Player;
+import org.project.item.consumables.HealFlask;
+import org.project.item.consumables.ManaFlask;
+import org.project.item.weapons.Dagger;
+import org.project.item.weapons.Sword;
+import org.project.weaponEffects.BurnEffect;
+import org.project.weaponEffects.FreezeEffect;
+import org.project.weaponEffects.PoisonEffect;
+
+import java.awt.*;
+import java.util.Scanner;
+
+public class InventoryManager {
+
+    private final HealFlask healFlask = new HealFlask("Heal Flask", 30, 3);
+    private final ManaFlask manaFlask = new ManaFlask("Mana Flask", 20, 2);
+
+
+    private final Scanner scanner = new Scanner(System.in);
+    private final ManaCostManager manager = new ManaCostManager();
+
+    public void displayInventory(Player player) {
+
+        while (true) {
+
+            System.out.println("\n========" + Colors.YELLOW + " INVENTORY " + Colors.RESET + "========");
+            System.out.println("""
+                        1. Equip Armor
+                        2. Equip / Change Weapon
+                        3. Equip / Change Weapon Effect
+                        4. Use Flask
+                        0. Exit
+                        """);
+
+
+            int input = scanner.nextInt();
+
+            if (input < 0 || input > 4) {
+                System.out.println("Enter a number between [0 - 3]");
+                continue;
+            }
+
+            switch (input) {
+
+                // =========================
+                // Exit
+                // =========================
+
+                case 0:
+                    System.out.println("Closing inventory...");
+                    return;
+
+                // =========================
+                // Armor
+                // =========================
+
+                case 1:
+
+                    if (player.getArmor() != null) {
+
+                        System.out.println(
+                                player.getName() +
+                                        Color.GREEN+
+                                        " already has armor: " +
+                                        Colors.RESET +
+                                        player.getArmor().getName()
+                        );
+
+                    } else {
+
+                        manager.equipArmor(player, player.getPersonalArmor());
+
+                    }
+
+                    break;
+
+                // =========================
+                // Weapon
+                // =========================
+
+                case 2:
+
+                    System.out.println("\n---" + Colors.YELLOW + " Weapons " + Colors.RESET + "---");
+                    System.out.println("""
+                            1. Sword
+                            2. Dagger
+                            0. Back
+                            """);
+
+                    int choice = scanner.nextInt();
+
+                    if (choice < 0 || choice > 2) {
+                        System.out.println("Enter a number between [0 - 2]");
+                        continue;
+                    }
+
+                    switch (choice) {
+
+                        case 0:
+                            System.out.println("Coming back...");
+                            break;
+
+                        case 1:
+                            manager.equipWeapon(
+                                    player,
+                                    new Sword(null)
+                            );
+                            break;
+
+                        case 2:
+                            manager.equipWeapon(player, new Dagger(null));
+                            break;
+                    }
+
+                    break;
+
+                // =========================
+                // Weapon Effects
+                // =========================
+
+                case 3:
+
+                    if (player.getWeapon() == null) {
+                        System.out.println(Colors.RED + "Equip a weapon first!" + Colors.RESET);
+                        break;
+                    }
+
+                    System.out.println("\n---" + Colors.YELLOW + " Weapon Effects " + Colors.RESET + "---");
+                    System.out.println("""
+                            1. Poison Effect
+                            2. Freeze Effect
+                            3. Burn Effect
+                            0. Back
+                            """);
+
+                    int choice2 = scanner.nextInt();
+
+                    if (choice2 < 0 || choice2 > 3) {
+                        System.out.println("Enter a number between [0 - 4]");
+                        continue;
+                    }
+
+                    switch (choice2) {
+
+                        case 0:
+                            System.out.println("Coming back...");
+                            break;
+
+                        case 1:
+
+                            manager.equipStatusEffect(player, new PoisonEffect());
+
+                            break;
+
+                        case 2:
+
+                            manager.equipStatusEffect(player, new FreezeEffect());
+
+                            break;
+
+                        case 3:
+
+                            manager.equipStatusEffect(player, new BurnEffect());
+
+                            break;
+                    }
+
+                    break;
+                case 4:
+
+                    System.out.println("\n---" + Colors.YELLOW + " Flasks " + Colors.RESET + "---");
+
+                    System.out.println("1. Heal Flask (" + healFlask.getCharges() + ")");
+                    System.out.println("2. Mana Flask (" + manaFlask.getCharges() + ")");
+                    System.out.println("0. Back");
+
+                    int flaskChoice = scanner.nextInt();
+
+                    if (flaskChoice < 0 || flaskChoice > 2) {
+                        System.out.println("Enter a number between [0 - 2]");
+                        continue;
+                    }
+
+                    switch (flaskChoice) {
+
+                        case 0:
+                            System.out.println("Coming back...");
+                            break;
+
+                        case 1:
+
+                            if (healFlask.getCharges() <= 0) {
+                                System.out.println(Colors.RED + "No Heal Flask charges left!" + Colors.RESET);
+                                break;
+                            }
+
+                            healFlask.use(player);
+
+                            System.out.println(
+                                    Colors.GREEN +
+                                            "Heal Flask used! Charges left: " +
+                                            healFlask.getCharges() +
+                                            Colors.RESET
+                            );
+
+                            break;
+
+                        case 2:
+
+                            if (manaFlask.getCharges() <= 0) {
+                                System.out.println(Colors.RED + "No Mana Flask charges left!" + Colors.RESET);
+                                break;
+                            }
+
+                            manaFlask.use(player);
+
+                            System.out.println(
+                                    Colors.CYAN +
+                                            "Mana Flask used! Charges left: " +
+                                            manaFlask.getCharges() +
+                                            Colors.RESET
+                            );
+
+                            break;
+                    }
+
+                break;
+            }
+        }
+    }
+}

Java-Knight/src/main/java/org/project/managers/ManaCostManager.java

@@ -0,0 +1,248 @@
+package org.project.managers;
+
+import org.project.Colors;
+import org.project.abilities.SpecialAbility;
+import org.project.entity.Entity;
+import org.project.entity.players.Player;
+import org.project.item.armors.Armor;
+import org.project.item.weapons.Weapon;
+import org.project.weaponEffects.StatusEffect;
+
+public class ManaCostManager {
+
+    private final int heavyAttackManaCost = 8;
+    private final int defendManaCost = 9;
+    private final int healManaCost = 12;
+    private final int shieldBashManaCost = 15;
+
+    // =========================
+    // Weapon
+    // =========================
+
+    public void equipWeapon(Player player, Weapon weapon) {
+
+        int manaCost = getWeaponEquipCost(weapon);
+
+        if (player.getMp() < manaCost) {
+
+            System.out.println("Not enough mana to equip weapon!");
+            return;
+        }
+
+        player.useMana(manaCost);
+
+        player.setWeapon(weapon);
+
+        System.out.println(
+                player.getName() +
+                        " equipped weapon: " +
+                        weapon.getName()
+        );
+
+    }
+
+    // =========================
+    // Armor
+    // =========================
+
+    public void equipArmor(Player player, Armor armor) {
+
+        int manaCost = getArmorEquipCost(armor);
+
+        if (player.getMp() < manaCost) {
+
+            System.out.println(Colors.RED +  "Not enough mana to equip armor!" + Colors.RESET);
+            return;
+        }
+
+        player.useMana(manaCost);
+
+        player.setArmor(armor);
+
+        System.out.println(
+                player.getName() +
+                        Colors.GREEN +
+                        " equipped armor: " +
+                        Colors.RESET +
+                        armor.getName()
+        );
+
+    }
+
+    // =========================
+    // Status Effect
+    // =========================
+
+    public void equipStatusEffect(Player player,
+                                  StatusEffect equippedEffect) {
+
+        Weapon weapon = player.getWeapon();
+
+        if (weapon == null) {
+
+            System.out.println(Colors.RED + "Equip a weapon first!" + Colors.RESET);
+            return;
+        }
+
+        int manaCost = equippedEffect.getEquipManaCost();
+
+        if (player.getMp() < manaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana to equip this effect!" + Colors.RESET);
+            return;
+        }
+
+        player.useMana(manaCost);
+
+        weapon.setEffect(equippedEffect);
+
+        System.out.println(
+                player.getName() +
+                        Colors.GREEN +
+                        " equipped effect: " +
+                        Colors.RESET +
+                        equippedEffect.getName()
+        );
+
+    }
+
+    // =========================
+    // Special Ability
+    // =========================
+
+    public boolean useSpecialAbility(Entity entity) {
+
+        SpecialAbility ability = entity.getSpacialAbility();
+
+        if (ability == null) {
+
+            System.out.println(Colors.RED + "No special ability equipped!" +  Colors.RESET);
+            return false;
+        }
+
+        int manaCost = ability.getManaCost();
+
+        if (entity.getMp() < manaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana to use special ability!" + Colors.RESET);
+            return false;
+        }
+
+        entity.useMana(manaCost);
+
+        return true;
+    }
+
+    // =========================
+    // Heavy Attack
+    // =========================
+
+    public boolean useHeavyAttack(Entity entity) {
+
+        if (entity.getMp() < heavyAttackManaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET);
+            return false;
+        }
+
+        entity.useMana(heavyAttackManaCost);
+
+        return true;
+    }
+
+    // =========================
+    // Defend
+    // =========================
+
+    public boolean useDefend(Entity entity) {
+
+        if (entity.getMp() < defendManaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET);
+            return false;
+        }
+
+        entity.useMana(defendManaCost);
+
+        return true;
+    }
+
+    // =========================
+    // Heal
+    // =========================
+
+    public boolean useHeal(Entity entity) {
+
+        if (entity.getMp() < healManaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET);
+            return false;
+        }
+
+        entity.useMana(healManaCost);
+
+        return true;
+    }
+
+    // =========================
+    // Shield Bash
+    // =========================
+
+    public boolean useShieldBash(Player player) {
+
+        Armor armor = player.getArmor();
+
+        if (armor == null) {
+
+            System.out.println(Colors.RED + "You need armor to use Shield Bash!" + Colors.RESET);
+            return false;
+        }
+
+        if (armor.getType() != Armor.ArmorType.HEAVY) {
+
+            System.out.println(Colors.RED + "Shield Bash requires HEAVY armor!" + Colors.RESET);
+            return false;
+        }
+
+        if (player.getMp() < shieldBashManaCost) {
+
+            System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET);
+            return false;
+        }
+
+        player.useMana(shieldBashManaCost);
+
+        return true;
+    }
+
+    // =========================
+    // Mana Costs
+    // =========================
+
+    private int getArmorEquipCost(Armor armor) {
+
+        return switch (armor.getType()) {
+
+            case LIGHT -> 3;
+
+            case MEDIUM -> 6;
+
+            case HEAVY -> 10;
+        };
+    }
+
+    private int getWeaponEquipCost(Weapon weapon) {
+
+        int damage = weapon.getLightAttackDamage();
+
+        if (damage <= 10) {
+            return 3;
+        }
+
+        if (damage <= 20) {
+            return 6;
+        }
+
+        return 10;
+    }
+}

Java-Knight/src/main/java/org/project/managers/SpecialAbilityManager.java

@@ -0,0 +1,77 @@
+package org.project.managers;
+
+import org.project.abilities.*;
+import org.project.entity.Entity;
+import org.project.item.armors.GoblinArmor;
+
+import javax.swing.text.Position;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class SpecialAbilityManager {
+
+    private final Map<Entity, List<SpecialAbility>> activeAbilities =
+            new HashMap<>();
+
+    // =========================
+    // Add Ability
+    // =========================
+
+    public void addAbility(SpecialAbility ability, Entity target) {
+
+        if (ability == null || target == null) {
+            return;
+        }
+
+        activeAbilities.putIfAbsent(target, new ArrayList<>());
+
+        ability.onApply(target);
+
+        activeAbilities.get(target).add(ability);
+    }
+
+    // =========================
+    // Update Ability Effects
+    // =========================
+
+    public void tick(Entity abilityUser, Entity target) {
+
+        List<SpecialAbility> abilities = activeAbilities.get(abilityUser);
+
+        if (abilities == null || abilities.isEmpty()) {
+            return;
+        }
+
+        Iterator<SpecialAbility> iterator = abilities.iterator();
+
+        while (iterator.hasNext()) {
+
+            SpecialAbility ability = iterator.next();
+
+            if (ability instanceof GuardianOath || ability instanceof PoisonDagger || ability instanceof LifeSteal)
+                ability.onTick(abilityUser);
+
+            if (ability instanceof InfernoBreath || ability instanceof BoneStrike || ability instanceof ArcaneStorm)
+                ability.onTick(target);
+
+
+            ability.reduceDuration();
+
+            if (ability.getDuration() <= 0) {
+
+                ability.onExpire(abilityUser);
+
+                iterator.remove();
+            }
+        }
+
+        // Cleanup empty list
+        if (abilities.isEmpty()) {
+            activeAbilities.remove(target);
+        }
+    }
+
+}

Java-Knight/src/main/java/org/project/managers/StatusEffectManager.java

@@ -0,0 +1,81 @@
+package org.project.managers;
+
+import org.project.entity.Entity;
+import org.project.weaponEffects.StatusEffect;
+
+import java.util.*;
+
+public class StatusEffectManager {
+
+    private Map<Entity, List<StatusEffect>> activeEffects = new HashMap<>();
+
+    public void addEffect(StatusEffect newEffect, Entity target) {
+        if (newEffect == null) return;
+
+        activeEffects.putIfAbsent(target, new ArrayList<>());
+        List<StatusEffect> effects = activeEffects.get(target);
+
+        for (StatusEffect existing : effects) {
+
+            if (existing.getName().equals(newEffect.getName())) {
+
+
+                if (existing.getStackType() == null) {
+                    return;
+                } else if (existing.getStackType() == StatusEffect.StackType.duration) {
+
+                    existing.setDuration(existing.getDuration() + newEffect.getDuration());
+
+                } else if (existing.getStackType() == StatusEffect.StackType.damage) {
+
+                    existing.setDamage(existing.getDamage()+ newEffect.getDamage());
+
+                } else if (existing.getStackType() == StatusEffect.StackType.both) {
+
+                    existing.setDamage(existing.getDamage()+ newEffect.getDamage());
+                    existing.setDuration(existing.getDuration() + newEffect.getDuration());
+                }
+
+                return;
+            }
+        }
+
+        effects.add(newEffect);
+        newEffect.onApply(target);
+    }
+
+
+    public void tick(Entity target) {
+
+        List<StatusEffect> effects = activeEffects.get(target);
+        if (effects == null) return;
+
+        Iterator<StatusEffect> iterator = effects.iterator();
+
+        while (iterator.hasNext()) {
+
+            StatusEffect effect = iterator.next();
+
+            effect.onTick(target);
+            effect.reduceDuration();
+
+            if (effect.getDuration() <= 0) {
+                effect.onExpire(target);
+                iterator.remove();
+            }
+        }
+    }
+
+    public boolean hasEffect(Entity target, String name) {
+
+        List<StatusEffect> effects = activeEffects.get(target);
+        if (effects == null) return false;
+
+        for (StatusEffect effect : effects) {
+            if (effect.getName().equals(name))
+                return true;
+        }
+
+        return false;
+    }
+}

Java-Knight/src/main/java/org/project/weaponEffects/BurnEffect.java

@@ -0,0 +1,16 @@
+package org.project.weaponEffects;
+
+import org.project.entity.Entity;
+
+public class BurnEffect extends StatusEffect{
+
+
+    public BurnEffect() {
+        super("Burn", 10,5 , 3, StackType.damage);
+    }
+
+    @Override
+    public void onApply(Entity target) {
+        System.out.println(target.getName() + " is burned!");
+    }
+}

Java-Knight/src/main/java/org/project/weaponEffects/FreezeEffect.java

@@ -0,0 +1,22 @@
+package org.project.weaponEffects;
+
+import org.project.entity.Entity;
+
+public class FreezeEffect extends StatusEffect{
+
+    public FreezeEffect() {
+        super("Freeze",1,5 , 1, StatusEffect.StackType.damage);
+    }
+
+
+    @Override
+    public void onTick(Entity target) {
+        target.freeze();
+        super.onTick(target);
+    }
+
+    @Override
+    public void onExpire(Entity target) {
+        System.out.println(target.getName() + " is Frozen!");
+    }
+}

Java-Knight/src/main/java/org/project/weaponEffects/PoisonEffect.java

@@ -0,0 +1,17 @@
+package org.project.weaponEffects;
+
+import org.project.entity.Entity;
+
+public class PoisonEffect extends StatusEffect{
+
+
+    public PoisonEffect() {
+        super("Poison",10,5 , 3, StackType.damage);
+    }
+
+    @Override
+    public void onApply(Entity target) {
+        System.out.println(target.getName() + " is poisoned!");
+    }
+
+}

Java-Knight/src/main/java/org/project/weaponEffects/StatusEffect.java

@@ -0,0 +1,65 @@
+package org.project.weaponEffects;
+
+import org.project.entity.Entity;
+
+public abstract class StatusEffect {
+
+    public enum StackType {
+
+        none, // this effect is not stackable
+        duration, // in duplication, just duration increases
+        damage,// in duplication, just damage increases
+        both // increases duration and damage
+    }
+
+    protected String name;
+    private int duration;
+    private int equipManaCost;
+    protected int damage;
+    protected StackType stackType;
+
+
+    public StatusEffect(String name, int damage, int equipManaCost, int duration, StackType stackType) {
+        this.name = name;
+        this.damage = damage;
+        this.equipManaCost = equipManaCost;
+        this.duration = duration;
+        this.stackType = stackType;
+    }
+
+    public String getName() { return name; }
+
+    public int getDamage() {
+        return damage;
+    }
+
+    public void setDamage(int damage) {
+        this.damage = damage;
+    }
+
+    public int getDuration() { return duration; }
+
+    public void setDuration(int duration) {
+        this.duration = duration;
+    }
+
+    public StackType getStackType() { return stackType; }
+
+    public int getEquipManaCost() {
+        return equipManaCost;
+    }
+
+    public void reduceDuration() {
+        duration--;
+    }
+
+    public void onApply(Entity target) {}
+
+    public  void onTick(Entity target) {
+        target.takeDamage(damage);
+        System.out.println(target.getName() + " suffers " + damage + " damage form " + name);
+        reduceDuration();
+    }
+
+    public void onExpire(Entity target) {System.out.println(target.getName() + " is no longer suffering form " + name);}
+}