From 2d2f969fc9e324bebb7037b714e3db7e92db9b2a Mon Sep 17 00:00:00 2001 From: mohammadreza Date: Sun, 17 May 2026 08:53:37 -0700 Subject: [PATCH] add all managers --- .../managers/ActionDecisionManager.java | 74 ++++++ .../project/managers/InventoryManager.java | 234 +++++++++++++++++ .../org/project/managers/ManaCostManager.java | 248 ++++++++++++++++++ .../managers/SpecialAbilityManager.java | 77 ++++++ .../project/managers/StatusEffectManager.java | 81 ++++++ 5 files changed, 714 insertions(+) create mode 100644 Java-Knight/src/main/java/org/project/managers/ActionDecisionManager.java create mode 100644 Java-Knight/src/main/java/org/project/managers/InventoryManager.java create mode 100644 Java-Knight/src/main/java/org/project/managers/ManaCostManager.java create mode 100644 Java-Knight/src/main/java/org/project/managers/SpecialAbilityManager.java create mode 100644 Java-Knight/src/main/java/org/project/managers/StatusEffectManager.java diff --git a/Java-Knight/src/main/java/org/project/managers/ActionDecisionManager.java b/Java-Knight/src/main/java/org/project/managers/ActionDecisionManager.java new file mode 100644 index 0000000..7a969ee --- /dev/null +++ b/Java-Knight/src/main/java/org/project/managers/ActionDecisionManager.java @@ -0,0 +1,74 @@ +package org.project.managers; + + + +import java.util.Random; +import java.util.Scanner; + + +public class ActionDecisionManager { + + public enum actionsType { + lightAttack, + heavyAttack, + defend, + heal, + ability, + shiedbash, + inventory + } + + + private Random random = new Random(); + + + public actionsType userChooseAction() { + actionsType res = null; + while (true) { + System.out.println("Choose attack type:\n"); + System.out.println("1.lightAttack"); + System.out.println("2.heavyAttack"); + System.out.println("3.heal"); + System.out.println("4.defend"); + System.out.println("5.ability"); + System.out.println("6.shielBash"); + System.out.println("7.inventory"); + + int choice = new Scanner(System.in).nextInt(); + switch (choice) { + case 1: + return actionsType.lightAttack; + case 2: + return actionsType.heavyAttack; + case 3: + return actionsType.heal; + case 4: + return actionsType.defend; + case 5: + return actionsType.ability; + case 6: + return actionsType.shiedbash; + case 7: + return actionsType.inventory; + default: + return actionsType.lightAttack; + } + + } + + } + + public actionsType botChooseAction() { + + actionsType[] possibleActions = { + actionsType.lightAttack, + actionsType.heavyAttack, + actionsType.defend, + actionsType.heal + }; + + return possibleActions[random.nextInt(possibleActions.length)]; + } + + +} diff --git a/Java-Knight/src/main/java/org/project/managers/InventoryManager.java b/Java-Knight/src/main/java/org/project/managers/InventoryManager.java new file mode 100644 index 0000000..73510da --- /dev/null +++ b/Java-Knight/src/main/java/org/project/managers/InventoryManager.java @@ -0,0 +1,234 @@ +package org.project.managers; + +import org.project.Colors; +import org.project.entity.players.Player; +import org.project.item.consumables.HealFlask; +import org.project.item.consumables.ManaFlask; +import org.project.item.weapons.Dagger; +import org.project.item.weapons.Sword; +import org.project.weaponEffects.BurnEffect; +import org.project.weaponEffects.FreezeEffect; +import org.project.weaponEffects.PoisonEffect; + +import java.awt.*; +import java.util.Scanner; + +public class InventoryManager { + + private final HealFlask healFlask = new HealFlask("Heal Flask", 30, 3); + private final ManaFlask manaFlask = new ManaFlask("Mana Flask", 20, 2); + + + private final Scanner scanner = new Scanner(System.in); + private final ManaCostManager manager = new ManaCostManager(); + + public void displayInventory(Player player) { + + while (true) { + + System.out.println("\n========" + Colors.YELLOW + " INVENTORY " + Colors.RESET + "========"); + System.out.println(""" + 1. Equip Armor + 2. Equip / Change Weapon + 3. Equip / Change Weapon Effect + 4. Use Flask + 0. Exit + """); + + + int input = scanner.nextInt(); + + if (input < 0 || input > 4) { + System.out.println("Enter a number between [0 - 3]"); + continue; + } + + switch (input) { + + // ========================= + // Exit + // ========================= + + case 0: + System.out.println("Closing inventory..."); + return; + + // ========================= + // Armor + // ========================= + + case 1: + + if (player.getArmor() != null) { + + System.out.println( + player.getName() + + Color.GREEN+ + " already has armor: " + + Colors.RESET + + player.getArmor().getName() + ); + + } else { + + manager.equipArmor(player, player.getPersonalArmor()); + + } + + break; + + // ========================= + // Weapon + // ========================= + + case 2: + + System.out.println("\n---" + Colors.YELLOW + " Weapons " + Colors.RESET + "---"); + System.out.println(""" + 1. Sword + 2. Dagger + 0. Back + """); + + int choice = scanner.nextInt(); + + if (choice < 0 || choice > 2) { + System.out.println("Enter a number between [0 - 2]"); + continue; + } + + switch (choice) { + + case 0: + System.out.println("Coming back..."); + break; + + case 1: + manager.equipWeapon( + player, + new Sword(null) + ); + break; + + case 2: + manager.equipWeapon(player, new Dagger(null)); + break; + } + + break; + + // ========================= + // Weapon Effects + // ========================= + + case 3: + + if (player.getWeapon() == null) { + System.out.println(Colors.RED + "Equip a weapon first!" + Colors.RESET); + break; + } + + System.out.println("\n---" + Colors.YELLOW + " Weapon Effects " + Colors.RESET + "---"); + System.out.println(""" + 1. Poison Effect + 2. Freeze Effect + 3. Burn Effect + 0. Back + """); + + int choice2 = scanner.nextInt(); + + if (choice2 < 0 || choice2 > 3) { + System.out.println("Enter a number between [0 - 4]"); + continue; + } + + switch (choice2) { + + case 0: + System.out.println("Coming back..."); + break; + + case 1: + + manager.equipStatusEffect(player, new PoisonEffect()); + + break; + + case 2: + + manager.equipStatusEffect(player, new FreezeEffect()); + + break; + + case 3: + + manager.equipStatusEffect(player, new BurnEffect()); + + break; + } + + break; + case 4: + + System.out.println("\n---" + Colors.YELLOW + " Flasks " + Colors.RESET + "---"); + + System.out.println("1. Heal Flask (" + healFlask.getCharges() + ")"); + System.out.println("2. Mana Flask (" + manaFlask.getCharges() + ")"); + System.out.println("0. Back"); + + int flaskChoice = scanner.nextInt(); + + if (flaskChoice < 0 || flaskChoice > 2) { + System.out.println("Enter a number between [0 - 2]"); + continue; + } + + switch (flaskChoice) { + + case 0: + System.out.println("Coming back..."); + break; + + case 1: + + if (healFlask.getCharges() <= 0) { + System.out.println(Colors.RED + "No Heal Flask charges left!" + Colors.RESET); + break; + } + + healFlask.use(player); + + System.out.println( + Colors.GREEN + + "Heal Flask used! Charges left: " + + healFlask.getCharges() + + Colors.RESET + ); + + break; + + case 2: + + if (manaFlask.getCharges() <= 0) { + System.out.println(Colors.RED + "No Mana Flask charges left!" + Colors.RESET); + break; + } + + manaFlask.use(player); + + System.out.println( + Colors.CYAN + + "Mana Flask used! Charges left: " + + manaFlask.getCharges() + + Colors.RESET + ); + + break; + } + + break; + } + } + } +} diff --git a/Java-Knight/src/main/java/org/project/managers/ManaCostManager.java b/Java-Knight/src/main/java/org/project/managers/ManaCostManager.java new file mode 100644 index 0000000..18e4867 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/managers/ManaCostManager.java @@ -0,0 +1,248 @@ +package org.project.managers; + +import org.project.Colors; +import org.project.abilities.SpecialAbility; +import org.project.entity.Entity; +import org.project.entity.players.Player; +import org.project.item.armors.Armor; +import org.project.item.weapons.Weapon; +import org.project.weaponEffects.StatusEffect; + +public class ManaCostManager { + + private final int heavyAttackManaCost = 8; + private final int defendManaCost = 9; + private final int healManaCost = 12; + private final int shieldBashManaCost = 15; + + // ========================= + // Weapon + // ========================= + + public void equipWeapon(Player player, Weapon weapon) { + + int manaCost = getWeaponEquipCost(weapon); + + if (player.getMp() < manaCost) { + + System.out.println("Not enough mana to equip weapon!"); + return; + } + + player.useMana(manaCost); + + player.setWeapon(weapon); + + System.out.println( + player.getName() + + " equipped weapon: " + + weapon.getName() + ); + + } + + // ========================= + // Armor + // ========================= + + public void equipArmor(Player player, Armor armor) { + + int manaCost = getArmorEquipCost(armor); + + if (player.getMp() < manaCost) { + + System.out.println(Colors.RED + "Not enough mana to equip armor!" + Colors.RESET); + return; + } + + player.useMana(manaCost); + + player.setArmor(armor); + + System.out.println( + player.getName() + + Colors.GREEN + + " equipped armor: " + + Colors.RESET + + armor.getName() + ); + + } + + // ========================= + // Status Effect + // ========================= + + public void equipStatusEffect(Player player, + StatusEffect equippedEffect) { + + Weapon weapon = player.getWeapon(); + + if (weapon == null) { + + System.out.println(Colors.RED + "Equip a weapon first!" + Colors.RESET); + return; + } + + int manaCost = equippedEffect.getEquipManaCost(); + + if (player.getMp() < manaCost) { + + System.out.println(Colors.RED + "Not enough mana to equip this effect!" + Colors.RESET); + return; + } + + player.useMana(manaCost); + + weapon.setEffect(equippedEffect); + + System.out.println( + player.getName() + + Colors.GREEN + + " equipped effect: " + + Colors.RESET + + equippedEffect.getName() + ); + + } + + // ========================= + // Special Ability + // ========================= + + public boolean useSpecialAbility(Entity entity) { + + SpecialAbility ability = entity.getSpacialAbility(); + + if (ability == null) { + + System.out.println(Colors.RED + "No special ability equipped!" + Colors.RESET); + return false; + } + + int manaCost = ability.getManaCost(); + + if (entity.getMp() < manaCost) { + + System.out.println(Colors.RED + "Not enough mana to use special ability!" + Colors.RESET); + return false; + } + + entity.useMana(manaCost); + + return true; + } + + // ========================= + // Heavy Attack + // ========================= + + public boolean useHeavyAttack(Entity entity) { + + if (entity.getMp() < heavyAttackManaCost) { + + System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET); + return false; + } + + entity.useMana(heavyAttackManaCost); + + return true; + } + + // ========================= + // Defend + // ========================= + + public boolean useDefend(Entity entity) { + + if (entity.getMp() < defendManaCost) { + + System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET); + return false; + } + + entity.useMana(defendManaCost); + + return true; + } + + // ========================= + // Heal + // ========================= + + public boolean useHeal(Entity entity) { + + if (entity.getMp() < healManaCost) { + + System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET); + return false; + } + + entity.useMana(healManaCost); + + return true; + } + + // ========================= + // Shield Bash + // ========================= + + public boolean useShieldBash(Player player) { + + Armor armor = player.getArmor(); + + if (armor == null) { + + System.out.println(Colors.RED + "You need armor to use Shield Bash!" + Colors.RESET); + return false; + } + + if (armor.getType() != Armor.ArmorType.HEAVY) { + + System.out.println(Colors.RED + "Shield Bash requires HEAVY armor!" + Colors.RESET); + return false; + } + + if (player.getMp() < shieldBashManaCost) { + + System.out.println(Colors.RED + "Not enough mana!" + Colors.RESET); + return false; + } + + player.useMana(shieldBashManaCost); + + return true; + } + + // ========================= + // Mana Costs + // ========================= + + private int getArmorEquipCost(Armor armor) { + + return switch (armor.getType()) { + + case LIGHT -> 3; + + case MEDIUM -> 6; + + case HEAVY -> 10; + }; + } + + private int getWeaponEquipCost(Weapon weapon) { + + int damage = weapon.getLightAttackDamage(); + + if (damage <= 10) { + return 3; + } + + if (damage <= 20) { + return 6; + } + + return 10; + } +} diff --git a/Java-Knight/src/main/java/org/project/managers/SpecialAbilityManager.java b/Java-Knight/src/main/java/org/project/managers/SpecialAbilityManager.java new file mode 100644 index 0000000..d5770a2 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/managers/SpecialAbilityManager.java @@ -0,0 +1,77 @@ +package org.project.managers; + +import org.project.abilities.*; +import org.project.entity.Entity; +import org.project.item.armors.GoblinArmor; + +import javax.swing.text.Position; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; + +public class SpecialAbilityManager { + + private final Map> activeAbilities = + new HashMap<>(); + + // ========================= + // Add Ability + // ========================= + + public void addAbility(SpecialAbility ability, Entity target) { + + if (ability == null || target == null) { + return; + } + + activeAbilities.putIfAbsent(target, new ArrayList<>()); + + ability.onApply(target); + + activeAbilities.get(target).add(ability); + } + + // ========================= + // Update Ability Effects + // ========================= + + public void tick(Entity abilityUser, Entity target) { + + List abilities = activeAbilities.get(abilityUser); + + if (abilities == null || abilities.isEmpty()) { + return; + } + + Iterator iterator = abilities.iterator(); + + while (iterator.hasNext()) { + + SpecialAbility ability = iterator.next(); + + if (ability instanceof GuardianOath || ability instanceof PoisonDagger || ability instanceof LifeSteal) + ability.onTick(abilityUser); + + if (ability instanceof InfernoBreath || ability instanceof BoneStrike || ability instanceof ArcaneStorm) + ability.onTick(target); + + + ability.reduceDuration(); + + if (ability.getDuration() <= 0) { + + ability.onExpire(abilityUser); + + iterator.remove(); + } + } + + // Cleanup empty list + if (abilities.isEmpty()) { + activeAbilities.remove(target); + } + } + +} diff --git a/Java-Knight/src/main/java/org/project/managers/StatusEffectManager.java b/Java-Knight/src/main/java/org/project/managers/StatusEffectManager.java new file mode 100644 index 0000000..b2e6558 --- /dev/null +++ b/Java-Knight/src/main/java/org/project/managers/StatusEffectManager.java @@ -0,0 +1,81 @@ +package org.project.managers; + +import org.project.entity.Entity; +import org.project.weaponEffects.StatusEffect; + +import java.util.*; + +public class StatusEffectManager { + + private Map> activeEffects = new HashMap<>(); + + public void addEffect(StatusEffect newEffect, Entity target) { + if (newEffect == null) return; + + activeEffects.putIfAbsent(target, new ArrayList<>()); + List effects = activeEffects.get(target); + + for (StatusEffect existing : effects) { + + if (existing.getName().equals(newEffect.getName())) { + + + if (existing.getStackType() == null) { + return; + } else if (existing.getStackType() == StatusEffect.StackType.duration) { + + existing.setDuration(existing.getDuration() + newEffect.getDuration()); + + } else if (existing.getStackType() == StatusEffect.StackType.damage) { + + existing.setDamage(existing.getDamage()+ newEffect.getDamage()); + + } else if (existing.getStackType() == StatusEffect.StackType.both) { + + existing.setDamage(existing.getDamage()+ newEffect.getDamage()); + existing.setDuration(existing.getDuration() + newEffect.getDuration()); + } + + return; + } + } + + effects.add(newEffect); + newEffect.onApply(target); + } + + + public void tick(Entity target) { + + List effects = activeEffects.get(target); + if (effects == null) return; + + Iterator iterator = effects.iterator(); + + while (iterator.hasNext()) { + + StatusEffect effect = iterator.next(); + + effect.onTick(target); + effect.reduceDuration(); + + if (effect.getDuration() <= 0) { + effect.onExpire(target); + iterator.remove(); + } + } + } + + public boolean hasEffect(Entity target, String name) { + + List effects = activeEffects.get(target); + if (effects == null) return false; + + for (StatusEffect effect : effects) { + if (effect.getName().equals(name)) + return true; + } + + return false; + } +}