Feature 9 polymorphism

Pokemon/BattleManager.cpp

@@ -0,0 +1,59 @@
+#include "BattleManager.h"
+#include <iostream>
+#include "Pokemon.h"
+#include "PokemonType.h"
+#include "player.h"
+#include "utility.h"
+#include "BattleState.h"
+using namespace std;
+
+BattleState BattleManager::battleState;
+
+void BattleManager::startBattle(Player* player, Pokemon* wildPokemon) {
+    battleState.playerPokemon = player->chosenPokemon;
+    battleState.wildPokemon = wildPokemon;
+    battleState.playerTurn = true;
+    battleState.battleOngoing = true;
+
+    cout << "A wild " << wildPokemon->name << " appeared!\n";
+    Utility::waitForEnter();
+
+    battle();
+}
+
+void BattleManager::stopBattle() { battleState.battleOngoing = false; }
+
+void BattleManager::battle() {
+    while (battleState.battleOngoing)
+    {
+        if (battleState.playerTurn)
+            battleState.playerPokemon->selectAndUseMove(battleState.wildPokemon);
+        else
+            battleState.wildPokemon->selectAndUseMove(battleState.playerPokemon);
+
+        updateBattleState();
+        battleState.playerTurn = !battleState.playerTurn;
+        Utility::waitForEnter();
+    }
+
+    handleBattleOutcome();
+}
+
+void BattleManager::updateBattleState() {
+    if (battleState.playerPokemon->isFainted()) {
+        battleState.battleOngoing = false;
+    }
+    else if (battleState.wildPokemon->isFainted()) {
+        battleState.battleOngoing = false;
+    }
+}
+
+void BattleManager::handleBattleOutcome() {
+    if (battleState.playerPokemon->isFainted()) {
+        cout << battleState.playerPokemon->name
+            << " has fainted! You lose the battle.\n";
+    }
+    else {
+        cout << "You defeated the wild " << battleState.wildPokemon->name << "!\n";
+    }
+}

Pokemon/BattleManager.h

@@ -0,0 +1,18 @@
+#pragma once
+#include "BattleState.h"
+#include "Player.h"
+
+
+class Pokemon;
+
+class BattleManager {
+public:
+    void startBattle(Player* player, Pokemon* wildPokemon);
+    static void stopBattle();
+private:
+    static BattleState battleState;
+
+    void battle();
+    void handleBattleOutcome();
+    void updateBattleState();
+};

Pokemon/BattleState.cpp

@@ -0,0 +1 @@
+#include "BattleState.h"

Pokemon/BattleState.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Pokemon.h"
+
+struct BattleState {
+    Pokemon* playerPokemon;
+    Pokemon* wildPokemon;
+    bool playerTurn;
+    bool battleOngoing;
+};

Pokemon/Bulbasaur.cpp

@@ -0,0 +1,30 @@
+#include "Bulbasaur.h"
+#include<iostream>
+#include "PokemonType.h"
+using namespace std;
+
+Bulbasaur::Bulbasaur()
+    : Pokemon("Bulbasaur", PokemonType::GRASS, 110, {
+        Move("VINE WHIP", 25),
+        Move("TACKLE", 10)
+        }) {
+}
+
+void Bulbasaur::attack(Move selectedMove, Pokemon* target)
+{
+    Pokemon::attack(selectedMove, target);
+
+    if (selectedMove.name == "VINE WHIP")
+    {
+        // Chance for a second hit (50% chance)
+        int secondHitChance = rand() % 2;
+
+        if (secondHitChance == 1)
+        {
+            Pokemon::attack(selectedMove, target);
+            std::cout << name << " hits again with a second " << selectedMove.name << "!\n";
+        }
+        else
+            std::cout << target->name << " dodged the second hit!\n";
+    }
+}

Pokemon/Bulbasaur.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "Pokemon.h"
+
+class Bulbasaur : public Pokemon {
+public:
+    Bulbasaur();
+    void attack(Move selectedMove, Pokemon* target) override;
+};
+

Pokemon/Caterpie.cpp

@@ -0,0 +1,25 @@
+#include "Caterpie.h"
+#include "PokemonType.h"
+#include <iostream>
+using namespace std;
+
+Caterpie::Caterpie()
+    : Pokemon("Caterpie", PokemonType::BUG, 75, {
+        Move("TACKLE", 10),
+        Move("STRING SHOT", 5),
+        Move("STICKY WEB", 10)
+        }) {
+}
+
+void Caterpie::attack(Move selectedMove, Pokemon* target)
+{
+    Pokemon::attack(selectedMove, target);
+
+    if (selectedMove.name == "STICKY WEB")
+    {
+        // Reduce the target's next attack damage (for simplicity, reducing by a fixed value)
+        int reducedDamage = 5;
+        target->reduceAttackPower(reducedDamage);
+        std::cout << target->name << "'s next attack will be reduced by " << reducedDamage << " damage!\n";
+    }
+}

Pokemon/Caterpie.h

@@ -0,0 +1,8 @@
+#include"Pokemon.h"
+#pragma once
+
+class Caterpie : public Pokemon {
+public:
+    Caterpie();
+    void attack(Move selectedMove, Pokemon* target) override;
+};

Pokemon/Charmander.cpp

@@ -0,0 +1,27 @@
+#include "Charmander.h"
+#include "PokemonType.h"
+#include "Move.h"
+#include "Utility.h"
+#include <iostream>
+using namespace std;
+
+Charmander::Charmander()
+    : Pokemon("Charmander", PokemonType::FIRE, 95, {
+        Move("EMBER", 20),
+        Move("SCRATCH", 15),
+        Move("BLAZING CHARGE", 70)
+        }) {
+}
+
+void Charmander::attack(Move selectedMove, Pokemon* target)
+{
+    Pokemon::attack(selectedMove, target);
+
+    if (selectedMove.name == "BLAZING CHARGE")
+    {
+        // Recoil effect: Charmander takes recoil damage
+        this->takeDamage(10); // Fixed recoil damage
+        std::cout << name << " takes 10 recoil damage from the Blazing Charge!\n";
+        Utility::Utility::waitForEnter();
+    }
+}

Pokemon/Charmander.h

@@ -0,0 +1,8 @@
+#include"Pokemon.h"
+#pragma once
+
+class Charmander : public Pokemon {
+public:
+    Charmander();
+    void attack(Move selectedMove, Pokemon* target) override;
+};

Pokemon/Game.cpp

@@ -0,0 +1,109 @@
+#include "Game.h"
+#include "Player.h"
+#include "PokemonType.h"
+#include "utility.h"
+#include "WildEncounterManager.h"
+#include <iostream>
+#include"BattleManager.h"
+#include "Caterpie.h"
+#include "Pidgey.h"
+#include "Zubat.h"
+#include "Utility.h"
+#include <iostream>
+using namespace std;
+
+Game::Game() {
+    // Create a sample grass environment with actual Pokemon objects
+    forestGrass = { "Forest", {new Pidgey(), new Caterpie(), new Zubat()}, 70 };
+}
+
+void Game::gameLoop(Player* player) {
+
+    int choice;
+    bool keepPlaying = true;
+    BattleManager* battleManager = new BattleManager();
+    WildEncounterManager* encounterManager = new WildEncounterManager();
+
+    while (keepPlaying) {
+        // Clear console before showing options
+        Utility::clearConsole();
+
+        // Display options to the player
+        cout << "\nWhat would you like to do next, " << player->name << "?\n";
+        cout << "1. Battle Wild Pok�mon\n";
+        cout << "2. Visit PokeCenter\n";
+        cout << "3. Challenge Gyms\n";
+        cout << "4. Enter Pok�mon League\n";
+        cout << "5. Quit\n";
+        cout << "Enter your choice: ";
+        cin >> choice;
+
+        Utility::clearInputBuffer(); // Clear the input buffer
+
+        // Process the player's choice and display the corresponding message
+        switch (choice) {
+        case 1: {
+            wildPokemon = encounterManager->getRandomPokemonFromGrass(forestGrass);
+            battleManager->startBattle(player, wildPokemon);
+            break;
+        }
+        case 2: {
+            visitPokeCenter(player);
+            break;
+        }
+        case 3: {
+            cout << "You march up to the Gym, but it's closed for renovations. Seems "
+                "like even Gym Leaders need a break!\n";
+            break;
+        }
+        case 4: {
+            cout << "You boldly step towards the Pok�mon League... but the "
+                "gatekeeper laughs and says, 'Maybe next time, champ!'\n";
+            break;
+        }
+        case 5: {
+            cout << "You try to quit, but Professor Oak's voice echoes: 'There's no "
+                "quitting in Pok�mon training!'\n";
+            cout << "Are you sure you want to quit? (y/n): ";
+            char quitChoice;
+            cin >> quitChoice;
+            if (quitChoice == 'y' || quitChoice == 'Y') {
+                keepPlaying = false;
+            }
+            break;
+        }
+        default: {
+            cout << "That's not a valid choice. Try again!\n";
+            break;
+        }
+        }
+
+        // Wait for Enter key before the screen is cleared and the menu is shown
+        // again
+        Utility::waitForEnter();
+    }
+
+    cout << "Goodbye, " << player->name << "! Thanks for playing!\n";
+
+    delete(encounterManager);
+    delete(battleManager);
+}
+
+void Game::visitPokeCenter(Player* player) {
+    if (player->chosenPokemon->health == player->chosenPokemon->maxHealth) {
+        std::cout << "Your Pok�mon is already at full health!\n";
+    }
+    else {
+        std::cout << "You head to the PokeCenter.\n";
+        std::cout << "Healing your Pok�mon...\n";
+        Utility::waitForEnter(); // Simulate a short pause for the
+        // healing process
+        player->chosenPokemon->heal();        // Heal the player's Pok�mon
+        std::cout << player->chosenPokemon->name << "'s health is fully restored!\n";
+    }
+}
+
+Game::~Game()
+{
+    delete(wildPokemon);
+}

Pokemon/Game.h

@@ -0,0 +1,17 @@
+#pragma once
+#include "Player.h"
+#include "Grass.h"
+
+// class Player;
+
+class Game {
+private:
+    Grass forestGrass;
+    Pokemon* wildPokemon;
+
+public:
+    Game();
+    ~Game();
+    void gameLoop(Player* player);
+    void visitPokeCenter(Player* player);
+};

Pokemon/Grass.cpp

@@ -0,0 +1,21 @@
+#include "Grass.h"
+#include "PokemonType.h"
+#include "Move.h"
+
+Grass forestGrass = {
+    "Forest",
+    {
+        new Pokemon("Pidgey", PokemonType::NORMAL, 40, {Move("GUST", 15), Move("TACKLE", 10)}),
+        new Pokemon("Caterpie", PokemonType::BUG, 35, {Move("TACKLE", 10), Move("STRING SHOT", 5)})
+    },
+    70
+};
+
+Grass caveGrass = {
+    "Cave",
+    {
+        new Pokemon("Zubat", PokemonType::POISON, 30, {Move("BITE", 12), Move("WING ATTACK", 10)}),
+        new Pokemon("Geodude", PokemonType::ROCK, 50, {Move("TACKLE", 10), Move("DEFENSE CURL", 5)})
+    },
+    80
+};

Pokemon/Grass.h

@@ -0,0 +1,13 @@
+#include<string>
+#include<vector>
+#include"Pokemon.h"
+#include <iostream>
+using namespace std;
+class Pokemon;
+
+struct Grass {
+    std::string environmentType;  // Example: "Forest", "Cave", "Riverbank"
+    std::vector<Pokemon*> wildPokemonList;  // List of wild Pok�mon in this grass
+    int encounterRate;  // Likelihood of encountering a wild Pok�mon, out of 100
+};
+

Pokemon/Move.cpp

@@ -0,0 +1 @@
+#include "Move.h"

Pokemon/Move.h

@@ -0,0 +1,16 @@
+#pragma once
+#include <string>
+using namespace std;
+
+
+struct Move
+{
+    string name;
+    int power;
+
+    Move(const string& moveName, int movePower)
+    {
+        name = moveName;
+        power = movePower;
+    }
+};

Pokemon/MoveName.cpp

@@ -0,0 +1 @@
+#include "MoveName.h"