Commit

Java-Ring/src/main/java/org/project/GameEngine.java

@@ -0,0 +1,271 @@
+package org.project;
+
+import org.project.entity.enemies.Enemy;
+import org.project.entity.players.*;
+import org.project.location.Location;
+import org.project.object.consumables.Consumable;
+import java.util.Scanner;
+
+/**
+ * Main game engine class that controls the game flow and manages player interactions.
+ * Handles initialization, game loop, combat, and menu systems.
+ */
+public class GameEngine {
+    // Game state variables
+    private Player player;          // Current player character
+    private Location currentLocation; // Active game location
+    private Scanner scanner = new Scanner(System.in); // Input handler
+    private boolean gameRunning = true; // Main game loop flag
+
+    /**
+     * Starts the main game loop and manages the game lifecycle
+     */
+    public void startGame() {
+        initializePlayer();     // Set up player character
+        initializeLocations();  // Initialize game world
+
+        // Main game loop - runs while game is active and player is alive
+        while (gameRunning && player.isAlive()) {
+            displayMainMenu();      // Show player options
+            handleMainMenuInput();   // Process player choice
+        }
+
+        endGame(); // Handle game conclusion
+    }
+
+    /**
+     * Initializes player character with name and class selection
+     */
+    private void initializePlayer() {
+        System.out.println("=== CHARACTER CREATION ===");
+        System.out.print("Enter your name: ");
+        String name = scanner.nextLine();
+
+        // Class selection menu
+        System.out.println("Choose your class:");
+        System.out.println("1. Knight\n2. Wizard\n3. Assassin");
+
+        int classChoice = Integer.parseInt(scanner.nextLine());
+
+        // Create player based on class choice
+        player = switch (classChoice) {
+            case 1 -> new Knight(name);  // Tank class
+            case 2 -> new Wizard(name);  // Mage class
+            default -> new Knight(name); // Default to Knight
+        };
+
+        System.out.printf("%s the %s enters the Java Ring!%n",
+                player.getName(), player.getClass().getSimpleName());
+    }
+
+    /**
+     * Initializes game locations and starting area
+     */
+    private void initializeLocations() {
+        // Create starting location with description
+        currentLocation = new Location("Forgotten Forest",
+                "A dense woodland shrouded in mist");
+    }
+
+    /**
+     * Displays the main game menu options
+     */
+    private void displayMainMenu() {
+        System.out.println("\n=== MAIN MENU ===");
+        System.out.println("Location: " + currentLocation.getName());
+        System.out.println("1. Explore");       // Risk encounter
+        System.out.println("2. Character Info"); // View stats
+        System.out.println("3. Quit");          // Exit game
+        System.out.print("Choose an action: ");
+    }
+
+    /**
+     * Handles player input from main menu
+     */
+    private void handleMainMenuInput() {
+        int choice = getValidInput(1, 3); // Get validated input
+
+        switch (choice) {
+            case 1 -> explore();            // Enter exploration
+            case 2 -> displayCharacterInfo(); // Show character sheet
+            case 3 -> gameRunning = false;   // Quit game
+            default -> System.out.println("Invalid choice!");
+        }
+    }
+
+    /**
+     * Handles exploration logic and random encounters
+     */
+    private void explore() {
+        System.out.println("\nYou venture deeper into " + currentLocation.getName());
+
+        // 70% chance of enemy encounter
+        if (Math.random() < 0.7) {
+            Enemy enemy = currentLocation.generateEnemy();
+            if (enemy != null) {
+                System.out.println("Encountered: " + enemy.getDescription());
+                startCombat(enemy); // Begin combat if enemy exists
+            } else {
+                System.out.println("The enemy mysteriously vanished...");
+            }
+        } else {
+            System.out.println("The path is clear for now...");
+        }
+        currentLocation.increaseDanger(); // Scale difficulty
+    }
+
+    /**
+     * Manages combat between player and enemy
+     * @param enemy The enemy to fight
+     */
+    private void startCombat(Enemy enemy) {
+        System.out.printf("%nA wild %s appears!%n", enemy.getName());
+
+        // Combat continues until one combatant is defeated
+        while (player.isAlive() && enemy.isAlive()) {
+            playerTurn(enemy); // Player action phase
+
+            if (!enemy.isAlive()) break; // Check if enemy defeated
+
+            enemyTurn(enemy); // Enemy action phase
+        }
+
+        // Combat resolution
+        if (player.isAlive()) {
+            System.out.printf("You defeated the %s!%n", enemy.getName());
+            player.gainExperience(enemy.getExpReward()); // Award XP
+        } else {
+            System.out.println("You have been defeated...");
+        }
+    }
+
+    /**
+     * Handles player's turn during combat
+     * @param enemy The current combat target
+     */
+    private void playerTurn(Enemy enemy) {
+        System.out.println("\n=== YOUR TURN ===");
+        // Display combat status
+        System.out.printf("HP: %d/%d | Enemy HP: %d%n",
+                player.getHealth(), player.getMaxHealth(), enemy.getHealth());
+
+        // Combat action menu
+        System.out.println("1. Attack");
+        System.out.println("2. Defend");
+        System.out.println("3. Special Ability");
+        System.out.println("4. Use Item");
+        System.out.print("Choose action: ");
+
+        int choice = getValidInput(1, 4); // Validate input
+
+        // Process player choice
+        switch (choice) {
+            case 1 -> { // Standard attack
+                player.attack(enemy);
+                System.out.printf("%s attacks %s!%n",
+                        player.getName(), enemy.getName());
+            }
+            case 2 -> { // Defensive stance
+                player.defend();
+                System.out.println(player.getName() + " defends!");
+            }
+            case 3 -> { // Class-specific ability
+                if (player instanceof Knight) {
+                    ((Knight)player).useSpecialAbility(enemy);
+                } else {
+                    player.useSpecialAbility(enemy);
+                }
+                System.out.printf("%s uses special ability on %s!%n",
+                        player.getName(), enemy.getName());
+            }
+            case 4 -> useItemInCombat(); // Inventory usage
+            default -> System.out.println("Invalid choice! Lost your turn...");
+        }
+    }
+
+    /**
+     * Validates player input within a specified range
+     * @param min Minimum valid value
+     * @param max Maximum valid value
+     * @return Validated user input
+     */
+    private int getValidInput(int min, int max) {
+        while (true) {
+            try {
+                int choice = Integer.parseInt(scanner.nextLine());
+                if (choice >= min && choice <= max) return choice;
+                System.out.printf("Enter %d-%d: ", min, max);
+            } catch (NumberFormatException e) {
+                System.out.print("(Numbers only) ");
+            }
+        }
+    }
+
+    /**
+     * Handles enemy's turn during combat
+     * @param enemy The attacking enemy
+     */
+    private void enemyTurn(Enemy enemy) {
+        System.out.printf("%n=== %s's TURN ===%n", enemy.getName());
+        enemy.attack(player); // Enemy performs attack
+    }
+
+    /**
+     * Manages item usage during combat
+     */
+    private void useItemInCombat() {
+        if (player.getInventory().isEmpty()) {
+            System.out.println("Your inventory is empty!");
+            return;
+        }
+
+        // Display inventory
+        System.out.println("\nAvailable items:");
+        for (int i = 0; i < player.getInventory().size(); i++) {
+            Consumable item = player.getInventory().get(i);
+            System.out.printf("%d. %s (%d uses)%n",
+                    i + 1, item.getName(), item.getRemainingUses());
+        }
+
+        System.out.print("Select item (0 to cancel): ");
+        int choice = getValidInput(0, player.getInventory().size()) - 1;
+
+        if (choice >= 0) {
+            player.useItem(choice); // Use selected item
+        }
+    }
+
+    /**
+     * Displays character statistics and equipment
+     */
+    private void displayCharacterInfo() {
+        System.out.println("\n=== CHARACTER SHEET ===");
+        System.out.printf("Name: %s%n", player.getName());
+        System.out.printf("Class: %s%n", player.getClass().getSimpleName());
+        System.out.printf("Level: %d%n", player.getLevel());
+        System.out.printf("HP: %d/%d%n", player.getHealth(), player.getMaxHealth());
+        System.out.printf("XP: %d/%d%n",
+                player.getExperience(), player.getLevel() * 100);
+        System.out.printf("Weapon: %s%n", player.getWeapon().getDescription());
+        System.out.printf("Armor: %s%n", player.getArmor().getDescription());
+    }
+
+    /**
+     * Handles game conclusion with appropriate message
+     */
+    private void endGame() {
+        if (player.isAlive()) {
+            System.out.println("You leave the Java Ring... for now.");
+        } else {
+            System.out.println("GAME OVER");
+        }
+    }
+
+    /**
+     * Entry point for the game
+     * @param args Command line arguments (unused)
+     */
+    public static void main(String[] args) {
+        new GameEngine().startGame(); // Launch game
+    }
+}

Java-Ring/src/main/java/org/project/entity/Entity.java

@@ -1,21 +1,33 @@
 package org.project.entity;
 
 public interface Entity {
+    // Combat Core
     void attack(Entity target);
-
-    void defend();
-
+    void takeDamage(int damage);
     void heal(int health);
 
-    void fillMana(int mana);
 
-    void takeDamage(int damage);
 
-    int getMaxHP();
+    // Status methods
+    boolean isAlive();
+
+    int getHealth();
+    int getMaxHealth();
 
-    int getMaxMP();
 
-    /*
-    TODO: ADD OTHER REQUIRED AND BONUS METHODS
-    */
+    // Magic/Ability system
+    void useSpecialAbility(Entity target);
+    void defend();
+
+    String getName();  
+
+    // Resource management
+    void gainExperience(int amount);
+    default boolean isDefending() { return false; }
+    void healMana(int amount);
+    default int getMana() { return 0; }
+    default int getMaxMana() { return 0; }
+
+
+    String getDescription();
 }