From fa56a58cea7639ba20595d108cf3dea358ce5971 Mon Sep 17 00:00:00 2001 From: Saba_frm Date: Tue, 19 May 2026 11:48:51 +0330 Subject: [PATCH] develop --- .idea/misc.xml | 4 +- .idea/modules.xml | 8 - .../src/main/java/org/project/GameState.java | 25 ++ .../src/main/java/org/project/Main.java | 298 +++++++++++++++++- .../java/org/project/combat/CombatSystem.java | 166 ++++++++++ .../main/java/org/project/entity/Entity.java | 18 +- .../org/project/entity/enemies/Dragon.java | 38 +++ .../org/project/entity/enemies/Enemy.java | 132 +++++++- .../org/project/entity/enemies/Goblin.java | 37 +++ .../org/project/entity/enemies/Skeleton.java | 48 ++- .../org/project/entity/enemies/Vampire.java | 30 ++ .../org/project/entity/players/Assassin.java | 99 ++++++ .../entity/players/ICombatActions.java | 22 ++ .../org/project/entity/players/Knight.java | 103 +++++- .../org/project/entity/players/Player.java | 182 +++++++---- .../org/project/entity/players/Wizard.java | 96 ++++++ .../src/main/java/org/project/item/Item.java | 12 +- .../java/org/project/item/armors/Armor.java | 49 ++- .../org/project/item/armors/KnightArmor.java | 18 +- .../project/item/consumables/Consumable.java | 52 ++- .../org/project/item/consumables/Flask.java | 45 ++- .../org/project/item/weapons/BasicWeapon.java | 20 ++ .../java/org/project/item/weapons/Sword.java | 68 +++- .../java/org/project/item/weapons/Weapon.java | 84 ++++- .../java/org/project/location/Location.java | 62 +++- .../org/project/utils/SaveLoadManager.java | 27 ++ .../classes/org/project/GameState.class | Bin 0 -> 848 bytes .../target/classes/org/project/Main.class | Bin 0 -> 9114 bytes .../org/project/combat/CombatSystem.class | Bin 0 -> 4424 bytes .../classes/org/project/entity/Entity.class | Bin 0 -> 517 bytes .../org/project/entity/enemies/Dragon.class | Bin 0 -> 1801 bytes .../org/project/entity/enemies/Enemy.class | Bin 0 -> 3103 bytes .../org/project/entity/enemies/Goblin.class | Bin 0 -> 1868 bytes .../org/project/entity/enemies/Skeleton.class | Bin 0 -> 1924 bytes .../org/project/entity/enemies/Vampire.class | Bin 0 -> 1617 bytes .../org/project/entity/players/Assassin.class | Bin 0 -> 3141 bytes .../entity/players/ICombatActions.class | Bin 0 -> 288 bytes .../org/project/entity/players/Knight.class | Bin 0 -> 3100 bytes .../org/project/entity/players/Player.class | Bin 0 -> 4873 bytes .../org/project/entity/players/Wizard.class | Bin 0 -> 3020 bytes .../classes/org/project/item/Item.class | Bin 0 -> 244 bytes .../org/project/item/armors/Armor.class | Bin 0 -> 1331 bytes .../org/project/item/armors/KnightArmor.class | Bin 0 -> 458 bytes .../project/item/consumables/Consumable.class | Bin 0 -> 1536 bytes .../org/project/item/consumables/Flask.class | Bin 0 -> 1627 bytes .../project/item/weapons/BasicWeapon.class | Bin 0 -> 844 bytes .../org/project/item/weapons/Sword.class | Bin 0 -> 2604 bytes .../org/project/item/weapons/Weapon.class | Bin 0 -> 2600 bytes .../org/project/location/Location.class | Bin 0 -> 2914 bytes .../org/project/utils/SaveLoadManager.class | Bin 0 -> 2564 bytes README1.md | 162 ++++++++++ 51 files changed, 1735 insertions(+), 170 deletions(-) delete mode 100644 .idea/modules.xml create mode 100644 Java-Knight/src/main/java/org/project/GameState.java create mode 100644 Java-Knight/src/main/java/org/project/combat/CombatSystem.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/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/weapons/BasicWeapon.java create mode 100644 Java-Knight/src/main/java/org/project/utils/SaveLoadManager.java create mode 100644 Java-Knight/target/classes/org/project/GameState.class create mode 100644 Java-Knight/target/classes/org/project/Main.class create mode 100644 Java-Knight/target/classes/org/project/combat/CombatSystem.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/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/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/weapons/BasicWeapon.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/utils/SaveLoadManager.class create mode 100644 README1.md diff --git a/.idea/misc.xml b/.idea/misc.xml index be3fc8d..46d8359 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -8,7 +8,5 @@ - - - + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100644 index 00e0d01..0000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/Java-Knight/src/main/java/org/project/GameState.java b/Java-Knight/src/main/java/org/project/GameState.java new file mode 100644 index 0000000..9e016a2 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/GameState.java @@ -0,0 +1,25 @@ +package org.project; + +import org.project.entity.players.Player; +import org.project.location.Location; +import java.io.Serializable; + +public class GameState implements Serializable { + private static final long serialVersionUID = 1L; + + private Player player; + private Location currentLocation; + + public GameState(Player player, Location currentLocation) { + this.player = player; + this.currentLocation = currentLocation; + } + + public Player getPlayer() { + return player; + } + + public Location getCurrentLocation() { + return currentLocation; + } +} \ No newline at end of file diff --git a/Java-Knight/src/main/java/org/project/Main.java b/Java-Knight/src/main/java/org/project/Main.java index 6bde20e..e8e4180 100644 --- a/Java-Knight/src/main/java/org/project/Main.java +++ b/Java-Knight/src/main/java/org/project/Main.java @@ -1,15 +1,301 @@ package org.project; +import org.project.combat.CombatSystem; +import org.project.entity.Entity; +import org.project.entity.enemies.Dragon; +import org.project.entity.enemies.Goblin; +import org.project.entity.enemies.Skeleton; +import org.project.entity.enemies.Vampire; +import org.project.entity.players.*; import org.project.location.Location; -import java.util.ArrayList; -import java.util.List; +import java.util.Random; +import java.util.Scanner; public class Main { - public static void main(String[] args) { - // TODO: ADD LOCATIONS TO YOUR GAME - List locations = new ArrayList<>(); - // TODO: IMPLEMENT GAMEPLAY + private static final Scanner scanner = new Scanner(System.in); + private static Location currentLocation; + + public static final String RESET = "\u001B[0m"; + public static final String RED = "\u001B[31m"; + public static final String GREEN = "\u001B[32m"; + public static final String YELLOW = "\u001B[33m"; + public static final String BLUE = "\u001B[34m"; + public static final String PURPLE = "\u001B[35m"; + public static final String CYAN = "\u001B[36m"; + + public static void main(String[] args) { + + initializeMap(); + + while (true) { + + System.out.println(CYAN + "\n===============================" + RESET); + System.out.println(YELLOW + " โš” JAVA KNIGHT โš”" + RESET); + System.out.println(CYAN + "===============================" + RESET); + + System.out.println("1. Start Game"); + System.out.println("2. How To Play"); + System.out.println("3. Exit"); + + System.out.print("> "); + int option = scanner.nextInt(); + + switch (option) { + case 1 -> startGame(); + case 2 -> showHelpMenu(); + case 3 -> { + System.out.println(GREEN + "Farewell hero!" + RESET); + System.exit(0); + } + default -> System.out.println(RED + "Invalid option!" + RESET); + } + } + } + + + private static void startGame() + { + + showIntro(); + + System.out.print("Enter your name: "); + String name = scanner.next(); + + System.out.println("\nChoose your class:"); + System.out.println(BLUE + "1. Knight ๐Ÿ›ก" + RESET); + System.out.println(PURPLE + "2. Wizard ๐Ÿ”ฎ" + RESET); + System.out.println(YELLOW + "3. Assassin ๐Ÿ—ก" + RESET); + + int choice = scanner.nextInt(); + Player player; + + switch (choice) { + case 1 -> player = new Knight(name); + case 2 -> player = new Wizard(name); + case 3 -> player = new Assassin(name); + default -> player = new Knight(name); + } + + player.resetKeys(); + System.out.println(GREEN + "\nWelcome " + name + " to Javanest!" + RESET); + + currentLocation.enter(); + gameLoop(player); + } + + private static void gameLoop(Player player) + { + + Random random = new Random(); + + + while (player.isAlive()) + { + + showPlayerStatus(player); + + System.out.println(CYAN + "\n===== LOCATION: " + currentLocation.getName() + " =====" + RESET); + System.out.println("1. Fight Enemy"); + System.out.println("2. Move Location"); + + if (player.hasAllKeys() && currentLocation.getName().equals("Vampire Crypt")) + { + System.out.println(RED + "3. Enter Dragon Castle ๐Ÿ‰" + RESET); + } + + System.out.print("> "); + int option = scanner.nextInt(); + + if (option == 1) { + Entity enemy = currentLocation.spawnEnemy(); + + System.out.println(RED + "\nA wild " + enemy.getName() + " appears!" + RESET); + + CombatSystem combat = new CombatSystem(); + combat.startBattle(player, enemy); + + if (!player.isAlive()) { + System.out.println(RED + "\nYou have fallen..." + RESET); + break; + } + + tryToDropKey(player, enemy, random); + recoverPlayer(player); + + } else if (option == 2) { + + moveLocation(); + + } else if (option == 3 && + player.hasAllKeys() && + currentLocation.getName().equals("Vampire Crypt")) { + + System.out.println(RED + "\nYou enter the Dragon Castle..." + RESET); + + CombatSystem combat = new CombatSystem(); + combat.startBattle(player, new Dragon()); + + if (player.isAlive()) { + System.out.println(GREEN + "\n๐Ÿ† YOU SAVED JAVANEST!" + RESET); + } else { + System.out.println(RED + "\nThe Dragon has defeated you..." + RESET); + } + + showProjectFeatures(); + break; + + } else { + System.out.println(RED + "Invalid option!" + RESET); + } + } + } + + private static void showPlayerStatus(Player player) { + + System.out.println(YELLOW + "\n===== PLAYER STATUS =====" + RESET); + + printBar("HP ", player.getHP(), player.getMaxHP(), RED); + printBar("MP ", player.getMP(), player.getMaxMP(), BLUE); + System.out.println("XP: " + player.getXP()); + } + + private static void printBar(String label, int value, int max, String color) + { + + int totalBars = 20; + int filled = (int)((double)value / max * totalBars); + + StringBuilder bar = new StringBuilder(); + + for (int i = 0; i < filled; i++) bar.append("โ–ˆ"); + for (int i = filled; i < totalBars; i++) bar.append("โ–‘"); + + System.out.println(label + " " + color + bar + RESET + " " + value + "/" + max); + } + + private static void moveLocation() + { + + System.out.println(YELLOW + "\nWhere do you want to go?" + RESET); + + int index = 1; + for (Location loc : currentLocation.getConnectedLocations()) + { + System.out.println(index + ". " + loc.getName()); + index++; + } + + System.out.print("> "); + int choice = scanner.nextInt(); + + if (choice < 1 || choice > currentLocation.getConnectedLocations().size()) + { + System.out.println(RED + "Invalid location!" + RESET); + return; + } + + currentLocation = currentLocation.getConnectedLocations().get(choice - 1); + currentLocation.enter(); + } + + private static void tryToDropKey(Player player, Entity enemy, Random random) + { + + int chance = random.nextInt(100) + 1; + + if (chance <= 20) + { + + if (enemy instanceof Goblin && !player.hasGoblinKey()) + { + player.obtainGoblinKey(); + System.out.println(YELLOW + "You obtained the Goblin Key!" + RESET); + } else if (enemy instanceof Skeleton && !player.hasSkeletonKey()) { + player.obtainSkeletonKey(); + System.out.println(YELLOW + "You obtained the Skeleton Key!" + RESET); + } else if (enemy instanceof Vampire && !player.hasVampireKey()) { + player.obtainVampireKey(); + System.out.println(YELLOW + "You obtained the Vampire Key!" + RESET); + } + } + } + + private static void recoverPlayer(Player player) + { + player.setHealth(player.getMaxHP()); + player.setMana(player.getMaxMP()); + System.out.println(GREEN + "You recovered your HP and Mana." + RESET); + } + + private static void showIntro() + { + System.out.println(PURPLE + "\n====================================" + RESET); + System.out.println(YELLOW + " LEGEND OF JAVANEST" + RESET); + System.out.println(PURPLE + "====================================" + RESET); + System.out.println("Defeat enemies, collect keys,"); + System.out.println("and face the mighty Dragon!"); + } + + private static void showHelpMenu() + { + System.out.println(YELLOW + "\nHOW TO PLAY:" + RESET); + System.out.println("- Fight enemies to gain XP."); + System.out.println("- Collect 3 keys."); + System.out.println("- Unlock Dragon Castle."); + System.out.println("- Defeat the Dragon to win."); + } + + private static void showProjectFeatures() + { + + System.out.println(CYAN + "\n====================================" + RESET); + System.out.println(YELLOW + " PROJECT FEATURES" + RESET); + System.out.println(CYAN + "====================================" + RESET); + + System.out.println(GREEN + "โœ” Multiple Player Classes" + RESET); + System.out.println(GREEN + "โœ” Location System" + RESET); + System.out.println(GREEN + "โœ” Key Collection System" + RESET); + System.out.println(GREEN + "โœ” Combat System" + RESET); + System.out.println(GREEN + "โœ” Final Boss Battle" + RESET); + } + + private static void initializeMap() + { + + Location forest = new Location( + "Forest", + "A dark forest full of goblins.", + 1 + ); + + Location graveyard = new Location( + "Graveyard", + "An abandoned graveyard with skeletons.", + 2 + ); + + Location vampireCrypt = new Location( + "Vampire Crypt", + "A cursed crypt where vampires sleep.", + 3 + ); + + Location dragonCastle = new Location( + "Dragon Castle", + "The castle of the ancient dragon.", + 4 + ); + + forest.connectLocation(graveyard); + graveyard.connectLocation(forest); + + graveyard.connectLocation(vampireCrypt); + vampireCrypt.connectLocation(graveyard); + + vampireCrypt.connectLocation(dragonCastle); + + currentLocation = forest; } } \ No newline at end of file diff --git a/Java-Knight/src/main/java/org/project/combat/CombatSystem.java b/Java-Knight/src/main/java/org/project/combat/CombatSystem.java new file mode 100644 index 0000000..705ddc1 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/combat/CombatSystem.java @@ -0,0 +1,166 @@ +package org.project.combat; + +import org.project.entity.players.Player; +import org.project.entity.Entity; +import org.project.entity.enemies.Goblin; +import org.project.entity.enemies.Skeleton; +import org.project.entity.enemies.Vampire; + +import java.util.Scanner; + +public class CombatSystem +{ + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String GREEN = "\u001B[32m"; + private static final String YELLOW = "\u001B[33m"; + private static final String BLUE = "\u001B[34m"; + + private Scanner scanner = new Scanner(System.in); + + public void startBattle(Player player, Entity enemy) + { + + System.out.println(RED + "\nโš”๏ธ A battle has started!" + RESET); + System.out.println(YELLOW + "Enemy: " + enemy.getName() + RESET); + + while (player.isAlive() && enemy.isAlive()) + { + + System.out.println("\n" + BLUE + "----- YOUR TURN -----" + RESET); + System.out.println("1. Light Attack"); + System.out.println("2. Heavy Attack"); + System.out.println("3. Defend"); + System.out.println("4. Heal"); + System.out.println("5. Special Ability"); + System.out.println("6. Exit Game"); + + while (!scanner.hasNextInt()) + { + scanner.next(); + System.out.println("โŒ Please enter a number between 1-6"); + } + + int choice = scanner.nextInt(); + + switch (choice) + { + + case 1: + player.lightAttack(enemy); + break; + + case 2: + player.heavyAttack(enemy); + break; + + case 3: + player.defend(); + break; + + case 4: + player.specialAbility(enemy); + break; + + case 5: + if (player.getMP() >= 6) + { + player.heal(10); + player.fillMana(-6); + System.out.println("๐Ÿ’š You restored 10 HP at the cost of 6 MP!"); + } else { + System.out.println("โŒ Not enough MP to heal!"); + } + break; + + case 6: + if (player.getXP() >= 10) + { + player.gainXP(-10); + player.fillMana(20); + System.out.println("๐Ÿ”ฎ +20 MP restored (Cost: 10 XP)"); + } else { + System.out.println("โŒ Not enough XP to restore mana!"); + } + break; + + case 7: + if (player.getXP() >= 50) + { + player.gainXP(-50); + player.heal(30); + System.out.println("โค๏ธ +30 HP restored (Cost: 50 XP)"); + } else { + System.out.println("โŒ Not enough XP to restore HP!"); + } + break; + + case 8: + System.out.println("๐Ÿ‘‹ Exiting game..."); + System.exit(0); + + default: + System.out.println("โŒ Invalid choice!"); + } + + if (!enemy.isAlive()) + { + + System.out.println(GREEN + "\nโœ… Enemy defeated!" + RESET); + + player.gainXP(50); + + dropKey(player, enemy); + + recoverPlayer(player); + + break; + } + + System.out.println(RED + "\n๐Ÿ‘น ENEMY TURN!" + RESET); + + enemy.attack(player); + + if (!player.isAlive()) + { + System.out.println(RED + "\n๐Ÿ’€ You were defeated..." + RESET); + } + } + } + + private void dropKey(Player player, Entity enemy) + { + + double chance = Math.random(); + + if (chance > 0.20) return; + + if (enemy instanceof Goblin && !player.hasGoblinKey()) + { + System.out.println(YELLOW + "๐Ÿ—๏ธ Goblin Key obtained!" + RESET); + player.obtainGoblinKey(); + } + + else if (enemy instanceof Skeleton && !player.hasSkeletonKey()) + { + System.out.println(YELLOW + "๐Ÿ—๏ธ Skeleton Key obtained!" + RESET); + player.obtainSkeletonKey(); + } + + else if (enemy instanceof Vampire && !player.hasVampireKey()) + { + System.out.println(YELLOW + "๐Ÿ—๏ธ Vampire Key obtained!" + RESET); + player.obtainVampireKey(); + } + } + + private void recoverPlayer(Player player) + { + + player.setHealth(player.getMaxHP()); + player.setMana(player.getMaxMP()); + + System.out.println("\u001B[32mโœจ Your HP and Mana have been fully restored!\u001B[0m"); + } +} \ No newline at end of file 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..4146ce7 100644 --- a/Java-Knight/src/main/java/org/project/entity/Entity.java +++ b/Java-Knight/src/main/java/org/project/entity/Entity.java @@ -1,6 +1,7 @@ package org.project.entity; -public interface Entity { +public interface Entity +{ void attack(Entity target); void defend(); @@ -11,9 +12,22 @@ public interface Entity { void takeDamage(int damage); + int getHP(); + int getMP(); int getMaxHP(); - int getMaxMP(); + int getLevel(); + String getName(); + + void setStunned(boolean value); + boolean isStunned(); + + void setInvisible(boolean value); + boolean isInvisible(); + + boolean isAlive(); + + void gainXP(int xp); /* TODO: ADD OTHER REQUIRED AND BONUS METHODS 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..dbc1e57 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/enemies/Dragon.java @@ -0,0 +1,38 @@ +package org.project.entity.enemies; + +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +import java.util.Random; + +public class Dragon extends Enemy +{ + + private Random random = new Random(); + + public Dragon() + { + super("Dragon", 200, 50, new BasicWeapon("Flame Breath", 25)); + } + + @Override + public void attack(Entity target) + { + + int damage; + + if (random.nextBoolean()) + { + damage = weapon.getDamage() + 20; + System.out.println(RED + "๐Ÿ”ฅ Dragon uses FIRE BREATH!" + RESET); + } else { + damage = weapon.getDamage(); + System.out.println(YELLOW + "๐Ÿ‰ Dragon claws viciously!" + RESET); + } + + target.takeDamage(damage); + + System.out.println(RED + "๐Ÿ’ฅ Dragon deals " + + damage + " damage!" + RESET); + } +} \ No newline at end of file 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..a10e2fe 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,140 @@ package org.project.entity.enemies; +import org.project.entity.Entity; import org.project.item.weapons.Weapon; -// TODO: UPDATE IMPLEMENTATION -public abstract class Enemy { - Weapon weapon; - private int hp; - private int mp; +public abstract class Enemy implements Entity +{ - public Enemy(int hp, int mp, Weapon weapon) { + protected String name; + protected int hp; + protected int mp; + protected int maxHp; + protected int maxMp; + protected int level; + protected boolean stunned; + protected boolean invisible; + protected Weapon weapon; + + protected static final String RESET = "\u001B[0m"; + protected static final String RED = "\u001B[31m"; + protected static final String YELLOW = "\u001B[33m"; + protected static final String PURPLE = "\u001B[35m"; + + public Enemy(String name, int hp, int mp, Weapon weapon) + { + this.name = name; this.hp = hp; this.mp = mp; - + this.maxHp = hp; + this.maxMp = mp; + this.level = 1; + this.stunned = false; + this.invisible = false; this.weapon = weapon; } @Override - public void takeDamage(int damage) { - hp -= damage; + public void defend() + { + System.out.println(name + " defends."); } - public int getHp() { + @Override + public void heal(int health) + { + if (health <= 0) return; + hp += health; + if (hp > maxHp) hp = maxHp; + } + + @Override + public void fillMana(int mana) + { + if (mana <= 0) return; + mp += mana; + if (mp > maxMp) mp = maxMp; + } + + @Override + public void takeDamage(int damage) + { + if (damage <= 0) return; + hp -= damage; + if (hp < 0) hp = 0; + } + + @Override + public int getHP() + { return hp; } - public int getMp() { + @Override + public int getMP() + { return mp; } - public Weapon getWeapon() { - return weapon; + @Override + public int getMaxHP() + { + return maxHp; } + + @Override + public int getMaxMP() + { + return maxMp; + } + + @Override + public int getLevel() + { + return level; + } + + @Override + public String getName() + { + return name; + } + + @Override + public void setStunned(boolean value) + { + this.stunned = value; + } + + @Override + public boolean isStunned() + { + return stunned; + } + + @Override + public void setInvisible(boolean value) + { + this.invisible = value; + } + + @Override + public boolean isInvisible() + { + return invisible; + } + + @Override + public boolean isAlive() + { + return hp > 0; + } + + @Override + public void gainXP(int xp) + { + } + + @Override + public abstract void attack(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 new file mode 100644 index 0000000..af0fc86 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/enemies/Goblin.java @@ -0,0 +1,37 @@ +package org.project.entity.enemies; + +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +import java.util.Random; + +public class Goblin extends Enemy +{ + + private Random random = new Random(); + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String PURPLE = "\u001B[35m"; + + public Goblin() { + super("Goblin", 60, 20, new BasicWeapon("Rusty Dagger", 12)); + } + + @Override + public void attack(Entity target) + { + + int damage = weapon.getDamage(); + + if (random.nextInt(100) < 25) + { + damage *= 2; + System.out.println(PURPLE + "๐Ÿ’€ Goblin CRITICAL strike!" + RESET); + } + + target.takeDamage(damage); + + System.out.println(RED + "๐Ÿ‘น Goblin attacks for " + damage + " damage!" + RESET); + } +} \ No newline at end of file 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..600faa5 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,46 @@ package org.project.entity.enemies; -// TODO: UPDATE IMPLEMENTATION -public class Skeleton { - // TODO: DESIGN ENEMY AND IMPLEMENT THE CONSTRUCTOR -} +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +public class Skeleton extends Enemy +{ + + private boolean revived = false; + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String YELLOW = "\u001B[33m"; + + public Skeleton() + { + super("Skeleton", 70, 10, new BasicWeapon("Bone Sword", 15)); + } + + @Override + public void attack(Entity target) + { + + int damage = weapon.getDamage(); + + target.takeDamage(damage); + + System.out.println(RED + "โ˜  Skeleton slashes for " + damage + " damage!" + RESET); + } + + @Override + public void takeDamage(int damage) + { + + super.takeDamage(damage); + + if (!isAlive() && !revived) + { + + revived = true; + this.hp = 40; + + System.out.println(YELLOW + "โš  Skeleton reassembles itself!" + RESET); + } + } +} \ No newline at end of file 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..b9c01e0 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/enemies/Vampire.java @@ -0,0 +1,30 @@ +package org.project.entity.enemies; + +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +public class Vampire extends Enemy +{ + + public Vampire() + { + super("Vampire", 90, 30, new BasicWeapon("Dark Claws", 18)); + } + + @Override + public void attack(Entity target) + { + + int damage = weapon.getDamage(); + target.takeDamage(damage); + + int healAmount = damage / 2; + this.hp += healAmount; + + System.out.println(RED + "๐Ÿง› Vampire drains " + + damage + " HP!" + RESET); + + System.out.println(YELLOW + "๐Ÿฉธ Vampire heals " + + healAmount + " HP!" + RESET); + } +} \ No newline at end of file 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..9fef985 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/players/Assassin.java @@ -0,0 +1,99 @@ +package org.project.entity.players; + +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +import java.util.Random; + +public class Assassin extends Player +{ + + private static final int HEAVY_COST = 15; + private static final int SPECIAL_COST = 25; + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String GREEN = "\u001B[32m"; + private static final String YELLOW = "\u001B[33m"; + private static final String BLUE = "\u001B[34m"; + private static final String PURPLE = "\u001B[35m"; + + private Random random = new Random(); + + public Assassin(String name) { + super(name, 90, 80, new BasicWeapon("Dagger", 18)); + } + + @Override + public void lightAttack(Entity target) + { + + int dmg = weapon.getDamage() + 12; + + // 25% critical chance + if (random.nextInt(100) < 25) + { + dmg *= 2; + System.out.println(PURPLE + "๐Ÿ’€ CRITICAL HIT!" + RESET); + } + + target.takeDamage(dmg); + + System.out.println(YELLOW + "๐Ÿ—ก๏ธ " + name + + " strikes for " + dmg + " damage!" + RESET); + } + + @Override + public void heavyAttack(Entity target) + { + if (mp < HEAVY_COST) { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= HEAVY_COST; + int dmg = weapon.getDamage() + 30; + target.takeDamage(dmg); + + System.out.println(PURPLE + "โšก Shadow Slash deals " + + dmg + " damage!" + RESET); + } + + @Override + public void defendAction() + { + defend(); + System.out.println(BLUE + "๐Ÿ›ก๏ธ Quick dodge stance!" + RESET); + } + + @Override + public void healAction() + { + heal(20); + System.out.println(GREEN + "๐Ÿ’– " + name + + " uses bandage restoring 20 HP!" + RESET); + } + + @Override + public void specialAbility(Entity target) + { + if (mp < SPECIAL_COST) + { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= SPECIAL_COST; + + setInvisible(true); + + int dmg = weapon.getDamage() + 50; + target.takeDamage(dmg); + + System.out.println(BLUE + "๐ŸŒ‘ SHADOW STRIKE deals " + + dmg + " damage!" + RESET); + + System.out.println(YELLOW + "๐Ÿ‘ค " + name + + " becomes INVISIBLE!" + RESET); + } +} \ No newline at end of file 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..d06a014 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/players/ICombatActions.java @@ -0,0 +1,22 @@ +package org.project.entity.players; + +import org.project.entity.Entity; + +public interface ICombatActions +{ + + // 1. Light Attack + void lightAttack(Entity target); + + // 2. Heavy Attack + void heavyAttack(Entity target); + + // 3. Defend + void defendAction(); + + // 4. Heal + void healAction(); + + // 5. Special Ability + 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..fe46714 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,101 @@ 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.item.armors.KnightArmor; +import org.project.item.weapons.Sword; + +public class Knight extends Player { + + private static final int LIGHT_BONUS = 15; + private static final int HEAVY_COST = 10; + private static final int SPECIAL_COST = 25; + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String GREEN = "\u001B[32m"; + private static final String YELLOW = "\u001B[33m"; + private static final String BLUE = "\u001B[34m"; + private static final String PURPLE = "\u001B[35m"; + + public Knight(String name) + { + super(name, 150, 40, new Sword()); + new KnightArmor(); + } + + @Override + public void lightAttack(Entity target) + { + int dmg = weapon.getDamage() + LIGHT_BONUS; + target.takeDamage(dmg); + + ((Sword) weapon).addCharge(1); + + System.out.println( + YELLOW + "โš”๏ธ " + name + + " slashes the enemy for " + dmg + " damage!" + + RESET + ); + } + + @Override + public void heavyAttack(Entity target) + { + if (mp < HEAVY_COST) + { + System.out.println(RED + "โŒ Not enough MP for heavy attack!" + RESET); + return; + } + + mp -= HEAVY_COST; + int dmg = weapon.getDamage() + 30; + target.takeDamage(dmg); + + ((Sword) weapon).addCharge(2); + + System.out.println(PURPLE + "๐Ÿ’ฅ " + name + + " performs a HEAVY STRIKE for " + dmg + " damage!" + RESET); + } + + @Override + public void defendAction() + { + defend(); + System.out.println(BLUE + "๐Ÿ›ก๏ธ " + name + + " raises his shield!" + RESET); + } + + @Override + public void healAction() + { + heal(30); + System.out.println(GREEN + "๐Ÿ’– " + name + + " heals for 30 HP!" + RESET); + } + + @Override + public void specialAbility(Entity target) + { + if (mp < SPECIAL_COST) + { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= SPECIAL_COST; + + int dmg = weapon.getDamage() + 45; + target.takeDamage(dmg); + target.setStunned(true); + + ((Sword) weapon).addCharge(3); + + System.out.println( + BLUE + "๐ŸŒ‹ " + name + + " uses EARTH SHATTERING STRIKE dealing " + dmg + " damage!" + + RESET + ); + + System.out.println(YELLOW + "โš ๏ธ The enemy is STUNNED!" + RESET); + } +} \ No newline at end of file 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..f5ec8e0 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,89 +1,159 @@ package org.project.entity.players; import org.project.entity.Entity; -import org.project.item.armors.Armor; import org.project.item.weapons.Weapon; -// TODO: UPDATE IMPLEMENTATION -public abstract class Player { +import java.io.Serializable; + +public abstract class Player implements Entity, ICombatActions, Serializable +{ + private static final long serialVersionUID = 1L; + protected String name; - Weapon weapon; - Armor armor; - private int hp; - private int maxHP; - private int mp; - private int maxMP; + protected int hp, maxHP; + protected int mp, maxMP; + protected int level = 1; + protected int xp = 0; - public Player(String name, int hp, int mp, Weapon weapon, Armor armor) { + protected boolean stunned = false; + protected boolean invisible = false; + protected boolean defending = false; + + private boolean goblinKey = false; + private boolean skeletonKey = false; + private boolean vampireKey = false; + + protected Weapon weapon; + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String GREEN = "\u001B[32m"; + private static final String YELLOW = "\u001B[33m"; + private static final String BLUE = "\u001B[34m"; + private static final String PURPLE = "\u001B[35m"; + + public Player(String name, int maxHP, int maxMP, Weapon weapon) + { this.name = name; - this.hp = hp; - this.mp = mp; - + this.maxHP = maxHP; + this.hp = maxHP; + this.maxMP = maxMP; + this.mp = maxMP; this.weapon = weapon; - this.armor = armor; } @Override - public void attack(Entity target) { - target.takeDamage(weapon.getDamage()); + public void attack(Entity target) + { + lightAttack(target); } @Override - public void defend() { - // TODO - } - - - @Override - public void takeDamage(int damage) { - hp -= damage - armor.getDefense(); + public void defend() + { + defending = true; + System.out.println(BLUE + "๐Ÿ›ก๏ธ " + name + " is defending!" + RESET); } @Override - public void heal(int health) { - hp += health; - if (hp > maxHP) { + public void heal(int amount) + { + hp = Math.min(maxHP, hp + amount); + } + + @Override + public void fillMana(int amount) + { + mp = Math.min(maxMP, mp + amount); + } + + @Override + public void takeDamage(int damage) + { + if (defending) + { + damage /= 2; + defending = false; + } + hp = Math.max(0, hp - damage); + System.out.println(RED + "๐Ÿ’ฅ " + name + " took " + damage + " damage!" + RESET); + } + + @Override + public int getHP() { return hp; } + @Override + public int getMP() { return mp; } + @Override + public int getMaxHP() { return maxHP; } + @Override + public int getMaxMP() { return maxMP; } + @Override + public int getLevel() { return level; } + @Override + public String getName() { return name; } + + @Override + public void setStunned(boolean v) { stunned = v; } + @Override + public boolean isStunned() { return stunned; } + + @Override + public void setInvisible(boolean v) { invisible = v; } + @Override + public boolean isInvisible() { return invisible; } + + @Override + public boolean isAlive() { return hp > 0; } + + @Override + public void gainXP(int xp) + { + this.xp += xp; + if (this.xp >= level * 100) + { + level++; + this.xp = 0; + maxHP += 10; + maxMP += 5; hp = maxHP; - } - } - - @Override - public void fillMana(int mana) { - mp += mana; - if (mp > maxMP) { mp = maxMP; + + System.out.println(GREEN + "โญ " + name + " leveled up to level " + level + "!" + RESET); } } + public boolean hasGoblinKey() { return goblinKey; } + public boolean hasSkeletonKey() { return skeletonKey; } + public boolean hasVampireKey() { return vampireKey; } - public String getName() { - return name; + public void obtainGoblinKey() { goblinKey = true; } + public void obtainSkeletonKey() { skeletonKey = true; } + public void obtainVampireKey() { vampireKey = true; } + + public boolean hasAllKeys() + { + return goblinKey && skeletonKey && vampireKey; } - public int getHp() { - return hp; + public void resetKeys() + { + goblinKey = false; + skeletonKey = false; + vampireKey = false; } - @Override - public int getMaxHP() { - return maxHP; + public void setHealth(int hp) + { + this.hp = Math.min(hp, maxHP); } - public int getMp() { - return mp; + public void setMana(int mp) + { + this.mp = Math.min(mp, maxMP); } - @Override - public int getMaxMP() { - return maxMP; + public int getXP() + { + return xp; } - - public Weapon getWeapon() { - return weapon; - } - - public Armor getArmor() { - return armor; - } - -} +} \ No newline at end of file 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..d3decf5 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/entity/players/Wizard.java @@ -0,0 +1,96 @@ +package org.project.entity.players; + +import org.project.entity.Entity; +import org.project.item.weapons.BasicWeapon; + +public class Wizard extends Player +{ + + private static final int LIGHT_COST = 5; + private static final int HEAVY_COST = 15; + private static final int SPECIAL_COST = 30; + + private static final String RESET = "\u001B[0m"; + private static final String RED = "\u001B[31m"; + private static final String GREEN = "\u001B[32m"; + private static final String YELLOW = "\u001B[33m"; + private static final String BLUE = "\u001B[34m"; + private static final String PURPLE = "\u001B[35m"; + + public Wizard(String name) { + super(name, 100, 120, new BasicWeapon("Magic Staff", 20)); + } + + @Override + public void lightAttack(Entity target) + { + if (mp < LIGHT_COST) + { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= LIGHT_COST; + int dmg = weapon.getDamage() + 10; + target.takeDamage(dmg); + + System.out.println(YELLOW + "โœจ " + name + " casts Magic Bolt for " + dmg + " damage!" + RESET); + } + + @Override + public void heavyAttack(Entity target) + { + if (mp < HEAVY_COST) + { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= HEAVY_COST; + int dmg = weapon.getDamage() + 35; + target.takeDamage(dmg); + + System.out.println(PURPLE + "๐Ÿ”ฅ " + name + + " casts FIREBALL for " + dmg + " damage!" + RESET); + } + + @Override + public void defendAction() + { + defend(); + System.out.println(BLUE + "๐Ÿ”ฎ Magical barrier activated!" + RESET); + } + + @Override + public void healAction() + { + if (mp < 20) + { + System.out.println(RED + "โŒ Not enough MP to heal!" + RESET); + return; + } + + mp -= 20; + heal(40); + System.out.println(GREEN + "๐Ÿ’– " + name + + " casts HEAL restoring 40 HP!" + RESET); + } + + @Override + public void specialAbility(Entity target) + { + if (mp < SPECIAL_COST) + { + System.out.println(RED + "โŒ Not enough MP!" + RESET); + return; + } + + mp -= SPECIAL_COST; + + int dmg = weapon.getDamage() + 60; + target.takeDamage(dmg); + + System.out.println(BLUE + "๐ŸŒช๏ธ ARCANE BURST hits for " + + dmg + " damage!" + RESET); + } +} \ No newline at end of file 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..13d746e 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,14 @@ package org.project.item; import org.project.entity.Entity; -public interface Item { +public interface Item +{ void use(Entity target); - /* - TODO: ADD OTHER REQUIRED AND BONUS METHODS - */ + String getName(); + + String getDescription(); + + int getValue(); + } 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..640d60d 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 @@ -7,36 +7,67 @@ public abstract class Armor { private int durability; private int maxDurability; - private boolean isBroke; + private boolean isBroken; public Armor(int defense, int durability) { this.defense = defense; + this.maxDefense = defense; this.durability = durability; + this.maxDurability = durability; + this.isBroken = false; } - public void checkBreak() { + public void takeHit(int damage) + { + durability -= damage; + + if (durability < 0) + { + durability = 0; + } + + checkBroken(); + } + + public void checkBroken() { if (durability <= 0) { - isBroke = true; + isBroken = true; defense = 0; } } // TODO: (BONUS) UPDATE THE REPAIR METHOD - public void repair() { - isBroke = false; + public void repair() + { + isBroken = false; defense = maxDefense; durability = maxDurability; } - public int getDefense() { + public int getDefense() + { return defense; } - public int getDurability() { + public int getDurability() + { return durability; } - public boolean isBroke() { - return isBroke; + public int getMaxDefense() + { + return maxDefense; } + + public int getMaxDurability() + { + return maxDurability; + } + + public boolean isBroken() + { + return isBroken; + } + + public abstract String getArmorName(); } 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..5601b45 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,16 @@ 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 +public class KnightArmor extends Armor +{ + + public KnightArmor() + { + super(30, 100); + } + + @Override + public String getArmorName() + { + return "Knight's Plate Armor"; + } +} 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..c5b964b 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,50 @@ package org.project.item.consumables; -// TODO: UPDATE IMPLEMENTATION -public abstract class Consumable { - /* - TODO: ADD OTHER REQUIRED AND BONUS METHODS - */ +import org.project.entity.Entity; + +public abstract class Consumable +{ + + protected String name; + protected String description; + protected int restoreAmount; + protected boolean percentageBased; + + public Consumable(String name, String description, int restoreAmount, boolean percentageBased) + { + this.name = name; + this.description = description; + this.restoreAmount = restoreAmount; + this.percentageBased = percentageBased; + } + + + public abstract void use(Entity target); + + + public String getName() + { + return name; + } + + public int getRestoreAmount() + { + return restoreAmount; + } + + public String getDescription() + { + return description; + } + + public boolean isPercentageBased() + { + return percentageBased; + } + + @Override + public String toString() + { + return name + " (" + description + ")"; + } } 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..75cbc48 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 @@ -2,15 +2,44 @@ package org.project.item.consumables; import org.project.entity.Entity; -// TODO: UPDATE IMPLEMENTATION -public class Flask { - /* - THIS IS AN EXAMPLE OF A CONSUMABLE DESIGN. - */ +public class Flask extends Consumable +{ + + private static final int HEAL_AMOUNT = 30; + + public Flask() + { + super( + "Health Flask", + "A small flask that restores health.", + HEAL_AMOUNT, + false + ); + } - // TODO: UPDATE USE METHOD @Override - public void use(Entity target) { - target.heal(target.getMaxHP() / 10); + public void use(Entity target) + { + + int healValue; + + if (percentageBased) + { + healValue = target.getMaxHP() * restoreAmount / 100; + } else + { + healValue = restoreAmount; + } + + target.heal(healValue); + + System.out.println( + target.getName() + + " used " + + name + + " and restored " + + healValue + + " HP!" + ); } } 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 new file mode 100644 index 0000000..5d66de1 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/item/weapons/BasicWeapon.java @@ -0,0 +1,20 @@ +package org.project.item.weapons; + +import org.project.entity.Entity; +import java.util.ArrayList; +import java.io.Serializable; + +public class BasicWeapon extends Weapon implements Serializable +{ + + private static final long serialVersionUID = 1L; + + public BasicWeapon(String name, int damage) + { + super(name, damage, 0); + } + + @Override + public void uniqueAbility(ArrayList targets) { + } +} \ No newline at end of file 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..57602f7 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 @@ -1,26 +1,64 @@ package org.project.item.weapons; import org.project.entity.Entity; - import java.util.ArrayList; +import java.io.Serializable; -// TODO: UPDATE IMPLEMENTATION -public class Sword { - /* - THIS IS AN EXAMPLE OF A WEAPON DESIGN. - */ +public class Sword extends Weapon implements Serializable +{ - int abilityCharge; + private static final long serialVersionUID = 1L; - public Sword() { - // TODO: DESIGN SWORD'S ATTRIBUTES IMPLEMENT THE CONSTRUCTOR + private int abilityCharge; + private static final int MAX_CHARGE = 10; + private static final int REQUIRED_CHARGE = 5; + + public Sword() + { + super("Knight Sword", 20, 0); + this.abilityCharge = 0; } - // TODO: (BONUS) UPDATE THE UNIQUE ABILITY - public void uniqueAbility(ArrayList targets) { - abilityCharge += 2; - for (Entity target : targets) { - target.takeDamage(getDamage()); + @Override + public void uniqueAbility(ArrayList targets) + { + if (abilityCharge < REQUIRED_CHARGE) + { + System.out.println("โš ๏ธ Not enough charge for special ability! (" + abilityCharge + "/" + REQUIRED_CHARGE + ")"); + return; } + + if (isBroken) + { + System.out.println("โš ๏ธ " + name + " is broken and can't use its special ability!"); + return; + } + + System.out.println("โš”๏ธ " + name + " special ability: Cleave!"); + for (Entity target : targets) + { + if (target != null && target.isAlive()) + { + target.takeDamage((int) (getDamage() * 1.5)); + } + } + + abilityCharge = 0; + reduceDurability(5); } -} + + public void addCharge(int amount) + { + this.abilityCharge = Math.min(this.abilityCharge + amount, MAX_CHARGE); + } + + public int getAbilityCharge() + { + return abilityCharge; + } + + public int getMaxCharge() + { + return MAX_CHARGE; + } +} \ No newline at end of file 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..e84d5c2 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,35 +1,87 @@ package org.project.item.weapons; import org.project.entity.Entity; +import java.util.ArrayList; +import java.io.Serializable; -// TODO: UPDATE IMPLEMENTATION -public abstract class Weapon { - private int damage; - private int manaCost; +public abstract class Weapon implements Serializable +{ - /* - TODO: ADD OTHER REQUIRED AND BONUS ATTRIBUTES - */ + private static final long serialVersionUID = 1L; - public Weapon(int damage, int manaCost) { + protected String name; + protected int damage; + protected int manaCost; + protected int level; + protected int durability; + protected boolean isBroken; + + public Weapon(String name, int damage, int manaCost) + { + this.name = name; this.damage = damage; this.manaCost = manaCost; + this.level = 1; + this.durability = 100; + this.isBroken = false; } - @Override - public void use(Entity target) { + public void use(Entity target) + { + if (isBroken) + { + System.out.println("โš ๏ธ " + name + " is broken and can't be used!"); + return; + } + target.takeDamage(damage); + reduceDurability(1); } - public int getDamage() { + public abstract void uniqueAbility(ArrayList targets); + + protected void reduceDurability(int amount) + { + durability = Math.max(0, durability - amount); + if (durability == 0) + { + isBroken = true; + } + } + + public void upgrade() + { + level++; + damage += 5; + System.out.println("๐Ÿ› ๏ธ " + name + " upgraded to level " + level + "!"); + } + + public String getName() { + return name; + } + + public int getDamage() + { return damage; } - public int getManaCost() { + public int getManaCost() + { return manaCost; } - /* - TODO: ADD OTHER REQUIRED AND BONUS METHODS - */ -} + public int getLevel() + { + return level; + } + + public int getDurability() + { + return durability; + } + + public boolean isBroken() + { + return isBroken; + } +} \ No newline at end of file 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..d55781f 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,64 @@ package org.project.location; -import org.project.entity.enemies.Enemy; - +import org.project.entity.enemies.*; +import java.io.Serializable; import java.util.ArrayList; -public class Location { +public class Location implements Serializable +{ + private static final long serialVersionUID = 1L; + private String name; + private String description; + private int difficulty; // 1 = easy, 2 = medium, 3 = hard + private ArrayList connectedLocations; - private ArrayList enemies; - - public Location(ArrayList locations, ArrayList enemies) { - this.locations = locations; - this.enemies = enemies; + public Location(String name, String description, int difficulty) + { + this.name = name; + this.description = description; + this.difficulty = difficulty; + this.connectedLocations = new ArrayList<>(); } - public String getName() { + public void connectLocation(Location location) + { + connectedLocations.add(location); + } + + public ArrayList getConnectedLocations() + { + return connectedLocations; + } + + public String getName() + { return name; } - public ArrayList getLocations() { - return locations; + public int getDifficulty() + { + return difficulty; } - public ArrayList getEnemies() { - return enemies; + public void enter() + { + System.out.println("\n=============================="); + System.out.println("๐Ÿ“ You arrived at: " + name); + System.out.println(description); + System.out.println("Difficulty: " + difficulty); + System.out.println("==============================\n"); + } + + public Enemy spawnEnemy() + { + return switch (name) + { + case "Forest" -> new Goblin(); + case "Graveyard" -> new Skeleton(); + case "Vampire Crypt" -> new Vampire(); + case "Dragon Castle" -> new Dragon(); + default -> new Goblin(); + }; } } diff --git a/Java-Knight/src/main/java/org/project/utils/SaveLoadManager.java b/Java-Knight/src/main/java/org/project/utils/SaveLoadManager.java new file mode 100644 index 0000000..491d61d --- /dev/null +++ b/Java-Knight/src/main/java/org/project/utils/SaveLoadManager.java @@ -0,0 +1,27 @@ +package org.project.utils; + +import org.project.GameState; +import java.io.*; + +public class SaveLoadManager { + + public static void saveGame(GameState gameState, String filename) { + try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filename))) { + oos.writeObject(gameState); + System.out.println("\u001B[34m\u2714\u001B[0m Game saved successfully."); + } catch (IOException e) { + System.out.println("\u001B[31m\u2716\u001B[0m Error saving game: " + e.getMessage()); + } + } + + public static GameState loadGame(String filename) { + try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filename))) { + GameState loadedState = (GameState) ois.readObject(); + System.out.println("\u001B[32m\u2714\u001B[0m Game loaded successfully."); + return loadedState; + } catch (IOException | ClassNotFoundException e) { + System.out.println("\u001B[31m\u2716\u001B[0m Error loading game: " + e.getMessage()); + return null; + } + } +} \ No newline at end of file diff --git a/Java-Knight/target/classes/org/project/GameState.class b/Java-Knight/target/classes/org/project/GameState.class new file mode 100644 index 0000000000000000000000000000000000000000..c62b3ec011bdc659ca4a0db40262fd80403aed5f GIT binary patch literal 848 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 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..ff525396a390372742a988f72ca9e1b8b9c8a3bf GIT binary patch literal 1924 zcmah}+fo}x5IrLac3Ce*76AtYwlFtI#Fia$aU$D^0TC+^#z8~`liMH-(wfz-YInfl zPh33Z7m|vh;#Bzq{2Bg`RC+Ipm!LQgnw_5NKBv1+t6%-~;w69*3>7g3wYo1%A#F=R zf?>vXnuU&IKM{3VFr;V~o(kTvEw`}5U8BC`8!Gx4v?bdTnd(#9X=sQ;)iD5#q5qCy z8S);(Xtwf%AM%39t!AMr9m8rC%ek5c9fJxkdhSCEnJAyIq#=(A!V+ymxP=mZj~H(E z0xDOcfoBp8axCU*1Gt2gf?*x+V1!{h8u2fxZVwm~M;sc5qQSr(djOYpyo)iaE9e8m z)c-PTNMl05q>d}N%5XKx+aptkfu@ivyv>_}A)d{ZFJKDS6in-w!7RgA6d+8z#{xq#BEpeNf)a&&AQ?sic?`Soh_sQUkl^iNiYDW_jvFX2 zTy7KgvTfD5+%jZ~Zm#5(bSajI&a1287T#B|sN(~C$S~|PpT(#Cc04xI@<7f*1oLrC zqsHIX@d-Yq0K>g+k|KUpZ5@7pLlWekZthenGb{T4@ZYlO2mSoMI{cqdFutJ()nU91{j>Vw_J z-tcs#!CJCy=}L!p)`V=?4Ohi?3=4j5UO$WI;F{cRkp_FVlVO>F%U5EkA3tdL5kD#5 z-pK9J`gt?0hIMG~i*R!UQ@G0O(spPiJd2J_=on=2fLjd`e5PXC`v;xkd4(e{X972m zI--aBPQ-tG*V~H4=;VhG%iJ`p^w%bJ^s;3MXPIhtg{y!XH+!z8Ua2Z*lA>>SC8>hC zXg^${Jqjcc^OhUk#&I7@U|6Pm3@c=>M(i)hE=TMyX=BsgL50pWidch6Hz1u)vE*t} z`xEi)R9|xF6v`OTraPtjzib?`)T$PZAFhQGi(#OvP7$H8PVH4jFgG%Ms zaE~}>crY7s{!Dg^aOU&rQ+$*^!NvK0QR3W=6!O8EsCO!&e8ELU1QkBWBPhc{hoe1sFS79t${tX GF!nbK>D_w( 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..73dcc22135de6e1b6197673179b1905f75ab69b5 GIT binary patch literal 1617 zcmah}?QYXZ6g`uMI&lpR2`zNfmh=mfuwbAI%MvI{)0PGT6k3AV{$ZMo5)*$!_5{=y zSt0RfUjYOZio^r#yYLE#>)3!xBTyvg&gk5G&fIfn{{OuD5x_EP3B(wb8n-%zD-^^T zW*xVwcUJ$Ey>n69G`nq%tyIHCfYAQ4wRB*_L4>RPVe8QH7+}4FHEJJwuGW~BeT3QwMp{8e!x4-yOh+?*pbA?+@`K|tO#PBT#ZeqnFs9)*WEqY}%l8q) zkZcOM#4X+w3We5|PRB&8F4pR(c(E_2qU1T;NMMZN=xgMPByR+_N@*I2(;Ch|XEhg zTs|~piy}{QTY8jB-1~i1aSrDd%xm}q7Z@@<=Dqc4&N@DuY5PU?mnhWIU^w0DOpPI4 zb{f>C;i_SaJ6&r_xEp-Sq@8rtsdKZ&UBh38n{nAPNZjlm&-zDBQ(;VHP!Ft_ha{iG_` zAisYOB_o4#VTvx7M)v`T(NHGwCw(u`Y6%I7fYD-_rT$4xe!#$^^np}*2g(kHUiR>R z(O0EBU2l#E1VeL#qYpdoTYeT7Z-c+cg9I5R3%ONG8iV_3`Xg7IfeqVxImGwq8KoRDu@%; x@Hgp5&~RMG9BIyA28$F8(63AxF*@-w{U4&}CLvdP-&L&9o=WR`SjPj5eF2fTt7QNH 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..7b7d492cc97825ee50be016b2d771fab8c254f14 GIT binary patch literal 3141 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 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..5663e67ae62d0177a39c47b8b9eb637d87828909 GIT binary patch literal 4873 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 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..fbe477ec1cb580a8f490bd08ff382e1e78b3f90b GIT binary patch literal 1331 zcmaJ=*>2NN5Ir|>;?{NAEG3ktD{JDGhVsBm5n?MMQd)$HD$zG5F{zuaa$E%e0)M~@ z5(S9|K7fxxoVhV+2oZ{O=iZq)b7sysKYxAy0bmz*EyNHvVc19@sgOQ#-@4_t+ijL# z)K0v5sF1wxcm42zLcCZyoW>NUO;|Q&U@I*5f@b+N=t*YT54}#=4LZG`Uw$M;!EAVM zyl&r9P!)mB+L#lZ)p6fF9fZW4v60p8##!Lj{I(yy7x%o4OX5yR_Fs|9HWqM2Vao46 z4tg!GOM)Ydkb;dRnPaAY?A2R;Vu@mJxgV3$F_T1B`WHRthU7x~O zO)rcD(85-jE3V;`gZJK0Ca#8Yd5@%UBS#8016uEWw?oePVySwu#e*>LyG=G}9rVtE zy7$bNc`cp4C27VwWsC7+NbuxRd5g)CwB=T`@SH${KcL8LD>mvs?IHnMq7i3vZ36?WChs};NEGR^SS+WsPR6fJP zw}$1bQF&c5?~o)V($eNQ(}kP^3Wrl|P|!{OV{VU7eK@1wgG 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..5c0336c527a2827c7a8fbcb336f7722928c8dff9 GIT binary patch literal 458 zcma)2%SyvQ6g|_lOld0dOE5U^y;75sf z(jwgm&f>l}kKufMe|!SC!(In9ST^bo8fY@?7b*#!Rk0AU4x|=Yz*SbLGPp5~p?M{9 zsjnFt{%ACeT4*u!A99(@^+`E+Ot}_=3TmUnaP*hjim}$T{9(jUzb$5hp%=EeY&%+rV~Y4-K8uII93I1c~eaLM2#LRW5Mo{?nVABGG5!h@9ONifk$<_V!X zlVYi2aW9RnyYa_!1I8iR6qb24PypDX>dK?eWcd)k#vQ5>b3s6c#?b76| kfat-cjbR7gTI7tn5wSe`m0Ask-mFgD4XX7^-K|jlA5CXs3IG5A 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..dcbf7199c84209c01d67a1e9ac1761c632c24496 GIT binary patch literal 1536 zcma)5TTc@~6#j-@wv_FK3L+o~3epy2QBl#NiByP9DjFe};M34f%0j!_>`qB|^Jn-Y ze9*+kga?0sKgxJ!x1puo7_!+pXU?349b0J{rW6gMVq0#j!H?>~HHw!! zL)hXC!H_9;1MEr1v}y(AGN~h_{EbwFTXD>$G;K@CM|EUygCXGvSK5wv-LP90VPYlq zIX^bb!$gCh3IbE%@{=i#6)edu=`w6&2k{I_ za)Tm<+_g+ghq(hvzGzn|`Bd4o#BQr`B%FO!Ayp2$!s`dzG1a{z49jDau;t3vEN+2X z({jn%Z1#!?Rm7C%#yrn=*>s)m4uZOgW$D;?f^C*-kRbz@j#h_JaV%cY`t6vtz% zYj~pC_>^IxJ36LyW}gbfkK=cChgWDq&KbV;Hm0NK`+v)=D$V6W*|twx&B9<;dn8v3 z_s^RmK>c%%zP~Mn-l}$76nVYAN4r67(o2>loMN53u5dLxXILD_DF~_tGM@dvDlMv? zS9qRQV~EB-OdoBj$I*6ql(xyEv^PXGP`PoN&KbIWA*%?{sr)an{Bj#wex;2>ex{9d zemva9*bjOg!mQFkl+GkYNMRUh;zr4H29tE&p_g^v6Xq~aH>IzTFppDM6uv37+X#7_ z!V?ZN+{Hb*Q?IeuL1hqCc9Hx~Xy1wP0Yp9Fv=_{G9O(pOxR0d( zf8@nL;~eqbDrn9mp}i0@dto?JWe7eV3(Eb>5g;I zlVLZBguv~h6ZU1V=X`6H9Nm%H2~?%=ZFvv^^fr*meVnpVvuBQ%%{Zkd3 zn8FiCSN*2!HDutL`FJs*J1*s|S0}SRy=DvaFbruZlRbw%S0e>OVb)|jV#b2iGGLkn zZeDVTg6di}yEQo&^GenIAuIL3HOy1do!K^#W4-M8z7BOD2Q{TTek)Akb6OV;xwRbO zNU!zsTAFG3cy)dT)f8$tv~Xk+&FWqMujpLwncr38D>Taefo$?tp9y?FnT#=TZ8-yII7+`NfGJ9qHpY@nvVzn;J!otl@UFj-4u6D2-Bb!LaDuq&RYf)byiP=yxi z0vi`JO`~ez5i@u>lvx|;!YZ#&lGP=!jF0#U+~X{U`}|mwc)+&6l?TKL_V#94q~i;j z`0ucOj*vTSQ$%x*_%wE-QG~@qe9W1^Cn%2X{DcHdHScWxiYq^0aqBr=6X4`VXQ9>G z{Siqs-rZVxj+-(3f?EV^M1b7N3%mvVhIfqLIE>%5i2E`utniV#g$!3Vu#Oztd+ZCi z8}Zqs*Xum9M}>yz&X}1QmGCLKW%wKI?sMNlZ0Rramk`GRr!jnnGW#TfU+}BoOU_ap KeT5S=u=EekX`lxH literal 0 HcmV?d00001 diff --git a/Java-Knight/target/classes/org/project/item/weapons/BasicWeapon.class b/Java-Knight/target/classes/org/project/item/weapons/BasicWeapon.class new file mode 100644 index 0000000000000000000000000000000000000000..5a42d708cf5b1e19273f4e5aa0f3925eb164c24f GIT binary patch literal 844 zcma))-%b=U6vn^qzrhs*7FZBbP>2ytoW#VdB_xPwmQ1`^9k07fGnUMD)=o#WzLi%d zUibh$l<}Jm8qw7_N#~rNp7ZN>+J61^`3ry(?6pxtJwRg~O|%5IGn<4Ho1LqX3$;_@ z@V%0g%;e!~Zv|Qh+GuwuuzoK(m+xelN|S^GXSGRs{r-L&U`}A~ubd|`*P{v+pe?ZK zAvy~O%4(VF4|13)fu-C}V`X!lnOFU%0^(F);h0*SG%l8Dp_=TW{DeSvmYV%opmCg? zk+&FWqh1u_p|UTl9Xe4ql4&ftD|fsIHryMX3*3$VM}LoWBgdq7{yYkv)R`R1gsY-Y z;f2v}3w1QqsdiI=jSIbn(`k5Qt(->RkQH{Mo@sw~zufV|@_KO_0pA(7;@HGh z%+oIL;%d0&<4r6vvdqXS8mQCG-G8uE{{->TXLa~5Un-a%U=b_ycB(wAVvRFapo?`< zN^b+#J$Dl~XiM&MjnMROpS-D>eCOkfK)xqgdzrC1g+vd#Yv{Tdq*xZ}Ou E@8a#s=l}o! 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..69b40117f7612047769c1dd333cc883ecd622667 GIT binary patch literal 2604 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 VF?B&W&fo*`Os+q~$GD3v{{bw|zJ>q* literal 0 HcmV?d00001 diff --git a/Java-Knight/target/classes/org/project/utils/SaveLoadManager.class b/Java-Knight/target/classes/org/project/utils/SaveLoadManager.class new file mode 100644 index 0000000000000000000000000000000000000000..a9b5a359c7f36ceeccceeda1c097f165512503b4 GIT binary patch literal 2564 zcmai0T~pge6g>+DVWR|MLIWWm4gqSw;Czwrk)};3Bv2dDnvzo5w8B=5f-Jd`Ov3-@ zbo$Wuye55s88XxKxj&=-qA#UqC4b0)wlK51+P!=4J?Ea?^&fv9{sv$Hdoi@2RY62W z8`=fBpKH5X+SIIKdUfl$p7#XW?;4ij-4kd{j;<@{5IFA}8FtlVwc?d4Ue0rLt)w6( z&{tbuG)z6b8bcJSjC4w%H<@X~;%37t&W*0eprA`ybPM!XEo7ijh^kdwMGwvjbiQy5 zPp>80!ppo~_6(bW$1$lQjcWq2qV8qsNh|6CXOpAHixQ_$Zm774TLR}w+KxVNTY1fU zVtCsext?ZuuE0n*i&{C4J5z9*g{{#N6llo`$!D5DYRghSp~V>PK#gGvb5bC88^|TP zh7VsKQ@E$%V|+q@lx3kNk7j^XeJFUq(%VikU3P4#`Lrx=&eJ@-1D_HaOMj!e^ro#9 zj@Nz)R~0-INHl~!Z)&c)Vtb2r#VUjfu!Knk%eC_O#jdZ$A#g)MR^UoFsfuTqZaPQN zWf(oHSuB|&5Sh0NEL~T|u=JHmX-jw3q+$f(89T3;>zZT8@9Jd4+csFOtC|1xJSWg0 z6)w3DNF|$g)Crn9UgFVpd7NxUxllh&0n<&VSU}KkoYyJNpZt4i!EtOy zUQE1A6OzK&gy?`NFnEHQ%syn-)ehbaHp&WqkjI_c8fpmHuy*YoJsq6v;09RK@}BMN z3H%&pt!fzL_(-z~rtS`9Y;U2o z2Q64-E0<;an5`NZ;B$PzuPAa@;|w>82pzR?Zuu>gjkkzyj31!$0H?F5v3;ER6}|C+ zeOyfKWAGJvSAxECHZsv4*~f