Battle_Implementation.cpp

//
// Battle_Implementation.cpp
//
//  Created by MAQ on 07/08/25.
#include "pokemon_game.hpp"


// function to calculate type effectiveness multiplier
double BattleTurn::calculateTypeEffectiveness(Type moveType, const Pokemon& defender)
{
    double effectiveness = 1.0;
    vector<Type> weaknesses = defender.getWeakness(); // Pokemons weakness
    
    for (Type weak : weaknesses)
    {
        if (moveType == weak)
        {
            effectiveness *= 2.0;
        }
    }
    
    return effectiveness;
    // Say if a pokemon is water and flying, then it's (2*2) weak to electric
}

// function to calculate damage using standard Pokemon formula ( basically the move selected by attacking pokemon will damage the defender)

int BattleTurn::calculateDamage(const Pokemon& attacker, const Pokemon& defender, const Moves& move)
{
    double effectiveness = calculateTypeEffectiveness(move.getType(), defender);
    double stab = (move.getType() == attacker.getType()) ? 1.5 : 1.0;
    double random = (rand() % (100 - 80 + 1) + 80)/100.0; // Random number from 0.80 to 1.00

    // This formula is actually a modification (simplification) of the offical damage formula
    int damage = ((2 * attacker.getLevel() / 5 + 2) *
                move.getDamage() *
                attacker.getAttack() /
                defender.getDefence() /
                50 + 2) * stab * effectiveness * random;
    /*
     the formula:
     <[((2 x level / 5) + 2) x (damage x attack / defence) / 50 + 2] x stab x effective x rand>
    */
    
    return damage;
}

// function to check if move hits based on accuracy
bool BattleTurn::checkAccuracy(const Moves& move)
{
    return ((rand() % 100) < move.getAccuracy());
}

// function to execute player's turn
void BattleTurn::playerTurn(Player& player, AI& ai)
{
    Pokemon& playerPokemon = player.getFirstUsablePokemon();
    Pokemon& aiPokemon = ai.getFirstUsablePokemon();
    
    int moveIndex = player.selectMove(playerPokemon);
    vector<Moves>& playerMoves = playerPokemon.getMoves(); // Reference to original vector
    Moves& move = playerMoves[moveIndex]; // Reference to original move
    
    if (!checkAccuracy(move))
    {
        cout << playerPokemon.getNickname() << "'s attack missed!\n";
        return;
    }
    
    move.decrementUses(); //reduce the PP
    TextForBattle::displayMoveUsed(playerPokemon, move.getName());
    
    int damage = calculateDamage(playerPokemon, aiPokemon, move);
    TextForBattle::displayTypeEffectiveness(calculateTypeEffectiveness(move.getType(), aiPokemon));
    
    aiPokemon.takeDamage(damage); // since its player's turn so the AI's pokemon gets damaged
    TextForBattle::displayDamageDealt(aiPokemon, damage);
    
    if (aiPokemon.isFainted())
    {
        TextForBattle::displayPokemonFainted(aiPokemon);
    }
}

// function to execute AI's turn
void BattleTurn::aiTurn(Player& player, AI& ai)
{
    Pokemon& playerPokemon = player.getFirstUsablePokemon();
    Pokemon& aiPokemon = ai.getFirstUsablePokemon();
    
    int moveIndex = ai.selectMove(aiPokemon);
    vector<Moves>& aiMoves = aiPokemon.getMoves();
    Moves& move = aiMoves[moveIndex];
    
    if (!checkAccuracy(move))
    {
        cout << aiPokemon.getNickname() << "'s attack missed!\n";
        return;
    }
    
    move.decrementUses();
    TextForBattle::displayMoveUsed(aiPokemon, move.getName());
    
    int damage = calculateDamage(aiPokemon, playerPokemon, move);
    TextForBattle::displayTypeEffectiveness(calculateTypeEffectiveness(move.getType(), playerPokemon));
    
    playerPokemon.takeDamage(damage);
    TextForBattle::displayDamageDealt(playerPokemon, damage);
    
    if (playerPokemon.isFainted())
    {
        TextForBattle::displayPokemonFainted(playerPokemon);
    }
}