diff --git a/Java-Knight/src/main/java/org/project/GameEngine.java b/Java-Knight/src/main/java/org/project/GameEngine.java
new file mode 100644
index 0000000..0638f59
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/GameEngine.java
@@ -0,0 +1,157 @@
+package org.project.game;
+
+import org.project.entity.enemies.Enemy;
+import org.project.entity.enemies.Goblin;
+import org.project.entity.players.Knight;
+import org.project.entity.players.Player;
+import org.project.entity.players.Warrior;
+import org.project.location.Location;
+
+import java.util.Scanner;
+
+public class setupGame {
+
+    private Player player;
+
+    private Location currentLocation;
+
+    private Scanner scanner;
+
+    public setupGame() {
+
+        scanner = new Scanner(System.in);
+
+        setupGame();
+    }
+
+    private void setupGame() {
+
+
+        player = new Knight("Hero");
+
+        // Create Locations
+        Location village = new Location("Village");
+        Location forest = new Location("Forest");
+        Location dungeon = new Location("Dungeon");
+
+        // Connect Locations
+        village.connectLocation(forest);
+        forest.connectLocation(village);
+
+        forest.connectLocation(dungeon);
+        dungeon.connectLocation(forest);
+
+        // Add Enemies
+        forest.addEnemy(new Goblin());
+
+        // Starting Location
+        currentLocation = village;
+    }
+
+    public void startGame() {
+
+        boolean running = true;
+
+        System.out.println("=== RPG Game Started ===");
+
+        while (running) {
+
+            System.out.println("\nCurrent Location: " + currentLocation.getName());
+
+            System.out.println("1. Move");
+            System.out.println("2. Fight");
+            System.out.println("3. Show Inventory");
+            System.out.println("4. Exit");
+
+            int choice = scanner.nextInt();
+
+            switch (choice) {
+
+                case 1:
+                    move();
+                    break;
+
+                case 2:
+                    fight();
+                    break;
+
+                case 3:
+                    player.getInventory().showInventory();
+                    break;
+
+                case 4:
+                    running = false;
+                    System.out.println("Game Over.");
+                    break;
+
+                default:
+                    System.out.println("Invalid choice.");
+            }
+        }
+    }
+
+    private void move() {
+
+        if (currentLocation.getConnectedLocations().isEmpty()) {
+            System.out.println("No connected locations.");
+            return;
+        }
+
+        System.out.println("Where do you want to go?");
+
+        for (int i = 0; i < currentLocation.getConnectedLocations().size(); i++) {
+
+            System.out.println(
+                    (i + 1) + ". " +
+                            currentLocation.getConnectedLocations().get(i).getName()
+            );
+        }
+
+        int choice = scanner.nextInt();
+
+        if (choice < 1 || choice > currentLocation.getConnectedLocations().size()) {
+
+            System.out.println("Invalid location.");
+            return;
+        }
+
+        currentLocation =
+                currentLocation.getConnectedLocations().get(choice - 1);
+
+        System.out.println("You moved to " + currentLocation.getName());
+    }
+
+    private void fight() {
+
+        if (currentLocation.getEnemies().isEmpty()) {
+
+            System.out.println("No enemies here.");
+            return;
+        }
+
+        Enemy enemy = currentLocation.getEnemies().get(0);
+
+        System.out.println("A wild " + enemy.getName() + " appeared!");
+
+        while (player.isAlive() && enemy.isAlive()) {
+
+            player.lightAttack(enemy);
+
+            if (enemy.isAlive()) {
+                enemy.attack(player);
+            }
+        }
+
+        if (!enemy.isAlive()) {
+
+            System.out.println(enemy.getName() + " defeated!");
+
+            currentLocation.removeEnemy(enemy);
+        }
+
+        if (!player.isAlive()) {
+
+            System.out.println("You died.");
+        }
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/Inventory.java b/Java-Knight/src/main/java/org/project/Inventory.java
new file mode 100644
index 0000000..ac8a4dd
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/Inventory.java
@@ -0,0 +1,4 @@
+package org.project;
+
+public class Inventory {
+}
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 a73480b..9ba31fa 100644
--- a/Java-Knight/src/main/java/org/project/entity/Entity.java
+++ b/Java-Knight/src/main/java/org/project/entity/Entity.java
@@ -1,70 +1,128 @@
 package org.project.entity;
 
+import org.project.item.weapons.Weapon;
+
 public abstract class Entity {
 
     protected String name;
     protected int hp;
-    protected int maxHP;
-    protected int mp;
-    protected int maxMP;
-    protected boolean alive = true;
+    protected int maxHp;
+
+    protected int mana;
+    protected int maxMana;
+
+    protected Weapon weapon;
+
+    protected boolean isDefending;
+
+    public Entity(String name, int hp, int mana, Weapon weapon) {
 
-    public Entity(String name , int maxHP , int maxMP){
         this.name = name;
-        this.maxHP = maxHP;
-        this.hp = maxHP;
-        this.maxMP = maxMP;
-        this.mp = maxMP;
+
+        this.hp = hp;
+        this.maxHp = hp;
+
+        this.mana = mana;
+        this.maxMana = mana;
+
+        this.weapon = weapon;
+
+        this.isDefending = false;
     }
 
-    public abstract  void attack(Entity target);
+    public boolean useMana(int amount) {
 
-    public  abstract void defend();
+        if (mana >= amount) {
 
-    public void heal(int amount){
-        hp += amount;
-        if(hp > maxHP) hp=maxHP;
-    }
-
-    public void consumeMana(int amount){
-        mp -= amount;
-        if(mp < 0 ) mp=0;
-    }
-
-    public void fillMana(int amount){
-        mp += amount;
-        if(mp > maxMP) mp=maxMP;
-    }
-
-    public void takeDamage(int damage){
-        hp -= damage;
-        if(hp <= 0 ){
-            hp=0;
-            alive = false;
-            System.out.println(name + " failed! ");
+            mana -= amount;
+            return true;
         }
+
+        return false;
     }
 
-    public boolean isAlive(){
-        return alive;
+    public void takeDamage(int damage) {
+
+        if (isDefending) {
+            damage /= 2;
+        }
+
+        hp -= damage;
+
+        if (hp < 0) {
+            hp = 0;
+        }
+
+        System.out.println(name + " took " + damage + " damage.");
     }
 
-    public int getHp(){
-        return hp;
+    public void heal(int amount) {
+
+        hp += amount;
+
+        if (hp > maxHp) {
+            hp = maxHp;
+        }
+
+        System.out.println(name + " healed for " + amount + " HP.");
     }
 
-    public int getMp(){
-        return mp;
-    }
-    public int getMaxHP(){
-        return maxHP;
+    public boolean isAlive() {
+        return hp > 0;
     }
 
-    public int getMaxMP(){
-        return maxMP;
+    public void defend() {
+
+        isDefending = true;
+
+        System.out.println(name + " is defending.");
+    }
+
+    public void resetDefending() {
+        isDefending = false;
     }
 
     public String getName() {
         return name;
     }
+
+    public int getHp() {
+        return hp;
+    }
+
+    public void setHp(int hp) {
+        this.hp = hp;
+    }
+
+    public int getMaxHp() {
+        return maxHp;
+    }
+
+    public int getMana() {
+        return mana;
+    }
+
+    public void setMana(int mana) {
+        this.mana = mana;
+    }
+
+    public int getMaxMana() {
+        return maxMana;
+    }
+
+    public Weapon getWeapon() {
+        return weapon;
+    }
+
+    public void setWeapon(Weapon weapon) {
+        this.weapon = weapon;
+    }
+
+    public boolean isDefending() {
+        return isDefending;
+    }
+
+    public void setDefending(boolean defending) {
+        isDefending = defending;
+    }
 }
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
index 1747ce1..bbd59d8 100644
--- a/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java
@@ -1,10 +1,24 @@
 package org.project.entity.enemies;
 
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.weapons.Staff;
 
 public class Dragon extends Enemy {
 
-    public Dragon(Weapon weapon) {
-        super("Dragon", 100, 50, weapon);
+    public Dragon() {
+        super("Dragon", 300, 100, new Staff() , 150);
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        int damage = getWeapon().getDamage() * 3;
+
+
+
+        target.takeDamage(damage);
+
+
+        System.out.println(getName() + " uses Breath Fire!");
+        System.out.println(target.getName() + " takes " + damage + " fire 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 b14ab10..b9f5a45 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,71 +1,69 @@
 package org.project.entity.enemies;
 
 import org.project.entity.Entity;
+import org.project.item.Item;
+import org.project.item.Key;
+import org.project.item.consumables.Flask;
 import org.project.item.weapons.Weapon;
 
+import java.util.Random;
+
 public abstract class Enemy extends Entity {
 
-    protected Weapon weapon;
-    protected boolean isDefending;
+    protected int xpReward;
 
-    public Enemy(String name, int maxHP, int maxMP, Weapon weapon) {
-        super(name, maxHP, maxMP);
+    public Enemy(String name, int hp, int mana, Weapon weapon, int xpReward) {
 
-        this.weapon = weapon;
-        this.isDefending = false;
+        super(name, hp, mana, weapon);
+
+        this.xpReward = xpReward;
+    }
+
+    public int getXpReward() {
+        return xpReward;
     }
 
-    @Override
     public void attack(Entity target) {
 
+        int damage = 0;
 
-        int manaCost = weapon.getManaCost();
-
-        if (mp < manaCost) {
-            System.out.println(name + " tried to attack but does not have enough MP!");
-            return;
+        if (weapon != null) {
+            damage = weapon.getDamage();
         }
 
+        target.takeDamage(damage);
 
-        mp -= manaCost;
+        System.out.println(name + " attacks " + target.getName());
 
-        System.out.println(
-                name + " attacks " + target.getName() +
-                        " with " + weapon.getClass().getSimpleName() + "!"
-        );
-
-
-        weapon.use(target);
+        target.resetDefending();
     }
 
-    @Override
     public void defend() {
-        isDefending = true;
-        System.out.println(name + " is defending!");
+
+        setDefending(true);
+
+        System.out.println(name + " is defending.");
     }
 
-    @Override
-    public void takeDamage(int damage) {
 
-        if (damage <= 0) return;
+    public Item dropLoot() {
 
+        Random random = new Random();
 
-        if (isDefending) {
-            damage /= 2;
-            isDefending = false;
-            System.out.println(name + " defended and reduced the damage!");
+        int chance = random.nextInt(100);
+
+        if (chance < 30) {
+            return new Flask();
         }
 
-        hp -= damage;
-        if (hp < 0) hp = 0;
+        if (chance >= 30 && chance < 40) {
+            return new Key("Castle Key");
+        }
 
-        System.out.println(
-                name + " took " + damage + " damage. (" + hp + "/" + maxHP + ")"
-        );
+        return null;
     }
 
 
-    public Weapon getWeapon() {
-        return weapon;
-    }
+
+    public abstract void specialAbility(Entity target);
 }
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
index b343d71..c3d4add 100644
--- a/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java
@@ -1,11 +1,22 @@
 package org.project.entity.enemies;
 
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.weapons.Dagger;
 
 public class Goblin extends Enemy {
 
-    public Goblin(Weapon weapon) {
-        super("Goblin", 30, 10, weapon);
+    public Goblin() {
+        super("Goblin", 80, 0, new Dagger() , 20);
     }
 
+    @Override
+    public void specialAbility(Entity target) {
+        int damage = getWeapon().getDamage() + 5;
+
+        target.takeDamage(damage);
+
+
+        System.out.println("Goblin uses Sneak Attack!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
+    }
 }
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 2da43c8..f01f90e 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,10 +1,18 @@
 package org.project.entity.enemies;
 
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.weapons.Sword;
 
 public class Skeleton extends Enemy {
 
-    public Skeleton(Weapon weapon) {
-        super("Skeleton", 35, 10, weapon);
+    public Skeleton() {
+        super("Skeleton", 100, 0, new Sword() , 30);
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        defend();
+
+        System.out.println("Skeleton raises its shield.");
     }
 }
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
index 88241a3..8b81622 100644
--- a/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
+++ b/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java
@@ -1,10 +1,24 @@
 package org.project.entity.enemies;
 
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.weapons.Dagger;
 
 public class Vampire extends Enemy {
 
-    public Vampire(Weapon weapon) {
-        super("Vampire", 45, 20, weapon);
+    public Vampire() {
+        super("Vampire", 120, 50, new Dagger() , 50);
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+        int damage = getWeapon().getDamage() * 2;
+
+        target.takeDamage(damage);
+
+
+        setHp(getHp() + damage / 2);
+
+        System.out.println("Vampire uses Life Drain!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
     }
 }
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
index 8d6ccfa..0383499 100644
--- a/Java-Knight/src/main/java/org/project/entity/players/Assassin.java
+++ b/Java-Knight/src/main/java/org/project/entity/players/Assassin.java
@@ -1,10 +1,76 @@
 package org.project.entity.players;
 
-import org.project.item.armors.Armor;
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.armors.AssassinArmor;
+import org.project.item.weapons.Dagger;
 
-public class Assassin extends Player{
-    public Assassin(String name , Weapon weapon , Armor armor){
-        super(name , 75 , 50 , weapon , armor);
+public class Assassin extends Player {
+
+    public Assassin(String name) {
+        super(name, 120, 80, new Dagger());
+    }
+
+    @Override
+    public void heavyAttack(Entity target) {
+
+        int manaCost = 15;
+
+        if (getMana() < manaCost) {
+            System.out.println("Not enough mana!");
+            return;
+        }
+
+        useMana(manaCost);
+
+        int damage = weapon.getDamage() * 2;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " performs a deadly strike!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
+    }
+
+    @Override
+    public void heal() {
+
+        int healAmount = 20;
+        int manaGain = 20;
+
+        setHp(Math.min(getHp() + healAmount, getMaxHp()));
+
+        setMana(Math.min(getMana() + manaGain, getMaxMana()));
+
+
+        System.out.println(name + " regains " + healAmount + " HP and " + manaGain + " mana.");
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+
+        int manaCost = 30;
+
+        if (getMana() < manaCost) {
+            System.out.println("Not enough mana!");
+            return;
+        }
+
+        useMana(manaCost);
+
+        int damage = weapon.getDamage() * 3;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " uses Shadow Strike!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/players/CombatActions.java b/Java-Knight/src/main/java/org/project/entity/players/CombatActions.java
new file mode 100644
index 0000000..ed83b40
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/players/CombatActions.java
@@ -0,0 +1,4 @@
+package org.project.entity.players;
+
+public class CombatActions {
+}
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 2a5b6d1..08f43af 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,11 +1,54 @@
 package org.project.entity.players;
 
-import org.project.item.armors.Armor;
-import org.project.item.weapons.Weapon;
+import org.project.entity.Entity;
+import org.project.item.armors.KnightArmor;
+import org.project.item.weapons.Sword;
 
 public class Knight extends Player {
 
-    public Knight(String name, Weapon weapon , Armor armor) {
-        super(name, 100, 30, weapon , armor);
+    public Knight(String name) {
+        super(name, 150, 50, new Sword());
+    }
+
+    @Override
+    public void heavyAttack(Entity target) {
+
+        int damage = weapon.getDamage() * 2;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " performs a heavy sword strike!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
+    }
+
+    @Override
+    public void heal() {
+
+        int healAmount = 30;
+        setHp(Math.min(getHp() + healAmount, getMaxHp()));
+
+
+        System.out.println(name + " recovers " + healAmount + " HP.");
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+
+        int damage = weapon.getDamage() + 20;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " uses Shield Bash!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
     }
 }
diff --git a/Java-Knight/src/main/java/org/project/entity/players/Mage.java b/Java-Knight/src/main/java/org/project/entity/players/Mage.java
deleted file mode 100644
index cd66d92..0000000
--- a/Java-Knight/src/main/java/org/project/entity/players/Mage.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package org.project.entity.players;
-
-import org.project.item.armors.Armor;
-import org.project.item.weapons.Weapon;
-
-public class Mage extends Player{
-    public Mage(String name , Weapon weapon , Armor armor){
-        super(name , 60 , 100 , weapon , armor);
-    }
-}
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 e62803c..bb21db8 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,70 +1,138 @@
 package org.project.entity.players;
 
-import org.project.Main;
 import org.project.entity.Entity;
+import org.project.inventory.Inventory;
 import org.project.item.weapons.Weapon;
-import org.project.item.armors.Armor;
 
-public abstract class Player extends Entity {
+public abstract class Player extends Entity implements CombatActions {
 
-    protected Weapon weapon;
-    protected Armor armor;
-    boolean isDefending = false;
+    protected Inventory inventory;
 
-    public Player(String name, int maxHP, int maxMP, Weapon weapon, Armor armor) {
-        super(name, maxHP, maxMP);
-        this.weapon = weapon;
-        this.armor = armor;
+    protected int level;
+    protected int xp;
+    protected int xpToNextLevel;
+
+    protected int baseDamage;
+
+    public Player(String name,
+                  int hp,
+                  int mana,
+                  Weapon weapon) {
+
+        super(name, hp, mana, weapon);
+
+        this.inventory = new Inventory();
+
+        this.level = 1;
+        this.xp = 0;
+        this.xpToNextLevel = 100;
+
+        this.baseDamage = 10;
+    }
+
+    public Inventory getInventory() {
+        return inventory;
+    }
+
+    public int getLevel() {
+        return level;
+    }
+
+    public int getXp() {
+        return xp;
+    }
+
+    public int getBaseDamage() {
+        return baseDamage;
+    }
+
+    public void gainXP(int amount) {
+
+        xp += amount;
+
+        System.out.println(name + " gained " + amount + " XP!");
+
+        while (xp >= xpToNextLevel) {
+            levelUp();
+        }
+    }
+
+    private void levelUp() {
+
+        level++;
+
+        xp -= xpToNextLevel;
+
+        xpToNextLevel += 50;
+
+        maxHp += 20;
+        hp = maxHp;
+
+        maxMana += 10;
+        mana = maxMana;
+
+        baseDamage += 5;
+
+        System.out.println("\n=== LEVEL UP ===");
+        System.out.println(name + " reached level " + level);
+        System.out.println("HP increased!");
+        System.out.println("Mana increased!");
+        System.out.println("Damage increased!");
     }
 
     @Override
-    public void attack(Entity target) {
-        if (weapon == null) {
-            System.out.println(name + " has no weapon!");
-            return;
+    public void lightAttack(Entity target) {
+
+        System.out.println(
+                this.name +
+                        " uses a light attack on " +
+                        target.getName()
+        );
+
+        if (weapon != null) {
+
+            weapon.use(target);
+
+        } else {
+
+            target.takeDamage(baseDamage);
+
+            System.out.println("Basic attack dealt " +
+                    baseDamage +
+                    " damage.");
         }
 
-        if (mp < weapon.getManaCost()) {
-            System.out.println(name + " doesn't have enough mana!");
-            return;
-        }
-
-        mp -= weapon.getManaCost();
-        weapon.use(target);
-
-        System.out.println(name + " attacked " + target.getName() +
-                " with " + weapon.getClass().getSimpleName());
+        target.resetDefending();
     }
 
     @Override
     public void defend() {
+
         isDefending = true;
-        System.out.println(name + " is defending! ");
+
+        System.out.println(name + " is defending!");
     }
+    public int getKeyCount() {
+
+        int count = 0;
+
+        for (var item : inventory.getItems()) {
+
+            if (item.getName().equals("Castle Key")) {
+                count++;
+            }
+        }
+
+        return count;
+    }
+
 
     @Override
-    public void takeDamage(int damage) {
-        if (damage <= 0) return;
+    public abstract void heavyAttack(Entity target);
 
+    @Override
+    public abstract void heal();
 
-        if (armor != null) {
-            damage -= armor.getDefense();
-            System.out.println(name + "'s armor reduced damage by " + armor.getDefense());
-        }
-
-
-        if (isDefending) {
-            damage /= 2;
-            isDefending = false;
-            System.out.println(name + " defended and reduced damage!");
-        }
-
-
-        damage = Math.max(0, damage);
-
-        hp -= damage;
-        if (hp < 0) hp = 0;
-
-        System.out.println(name + " took " + damage + " damage. (" + hp + "/" + maxHP + ")");
-    }
+    @Override
+    public abstract void specialAbility(Entity target);
 }
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..e29f310
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/entity/players/Wizard.java
@@ -0,0 +1,80 @@
+package org.project.entity.players;
+
+import org.project.entity.Entity;
+import org.project.item.weapons.Staff;
+
+public class Wizard extends Player {
+
+    public Wizard(String name) {
+        super(name, 100, 150, new Staff());
+    }
+
+    @Override
+    public void heavyAttack(Entity target) {
+
+        int manaCost = 20;
+
+        if (getMana() < manaCost) {
+            System.out.println("Not enough mana!");
+            return;
+        }
+
+        useMana(manaCost);
+
+        int damage = weapon.getDamage() * 2;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " casts a powerful fire spell!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
+    }
+
+    @Override
+    public void heal() {
+
+        int manaCost = 15;
+
+        if (getMana() < manaCost) {
+            System.out.println("Not enough mana!");
+            return;
+        }
+
+        useMana(manaCost);
+
+        int healAmount = 40;
+        setHp(Math.min(getHp() + healAmount, getMaxHp()));
+
+
+        System.out.println(name + " casts a healing spell and restores " + healAmount + " HP.");
+    }
+
+    @Override
+    public void specialAbility(Entity target) {
+
+        int manaCost = 40;
+
+        if (getMana() < manaCost) {
+            System.out.println("Not enough mana!");
+            return;
+        }
+
+        useMana(manaCost);
+
+        int damage = weapon.getDamage() * 3;
+
+        if (target.isDefending()) {
+            damage /= 2;
+        }
+
+        target.takeDamage(damage);
+
+
+        System.out.println(name + " unleashes Lightning Storm!");
+        System.out.println(target.getName() + " takes " + damage + " damage.");
+    }
+}
diff --git a/Java-Knight/src/main/java/org/project/item/Key.java b/Java-Knight/src/main/java/org/project/item/Key.java
new file mode 100644
index 0000000..c6baee0
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/Key.java
@@ -0,0 +1,4 @@
+package org.project.item;
+
+public class Key {
+}
diff --git a/Java-Knight/src/main/java/org/project/item/armors/AssassinArmor.java b/Java-Knight/src/main/java/org/project/item/armors/AssassinArmor.java
new file mode 100644
index 0000000..f65e9f4
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/armors/AssassinArmor.java
@@ -0,0 +1,4 @@
+package org.project.item.armors;
+
+public class AssassinArmor {
+}
diff --git a/Java-Knight/src/main/java/org/project/item/armors/MageArmor.java b/Java-Knight/src/main/java/org/project/item/armors/MageArmor.java
new file mode 100644
index 0000000..c3836b6
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/armors/MageArmor.java
@@ -0,0 +1,4 @@
+package org.project.item.armors;
+
+public class MageArmor {
+}
diff --git a/Java-Knight/src/main/java/org/project/item/weapons/BasicWeapon.java b/Java-Knight/src/main/java/org/project/item/weapons/BasicWeapon.java
deleted file mode 100644
index d7a5db9..0000000
--- a/Java-Knight/src/main/java/org/project/item/weapons/BasicWeapon.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.project.item.weapons;
-
-import org.project.entity.Entity;
-
-public class BasicWeapon extends Weapon {
-
-    public BasicWeapon() {
-        super(5, 2);
-    }
-
-    @Override
-    public void use(Entity target) {
-        target.takeDamage(damage);
-    }
-}
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..cf828d1
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Dagger.java
@@ -0,0 +1,4 @@
+package org.project.item.weapons;
+
+public class Dragger {
+}
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..65b42b9
--- /dev/null
+++ b/Java-Knight/src/main/java/org/project/item/weapons/Staff.java
@@ -0,0 +1,4 @@
+package org.project.item.weapons;
+
+public class Staff {
+}