Character.cpp

[詳解]

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   Character.cpp                                      :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: kamitsui <kamitsui@student.42tokyo.jp>     +#+  +:+       +#+        */
/*                                                +#+#+#+#+#+   +#+           */
/*   Created: 2025/05/30 00:01:26 by kamitsui          #+#    #+#             */
/*   Updated: 2025/06/02 05:46:35 by kamitsui         ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#include "Character.hpp"
#include "AMateria.hpp" // Included for AMateria definitions
#include "Logger.hpp"
#include <sstream>
 
Character::Character(std::string const &name) : name(name) {
    LOG_INFO("Character constructor called for " + this->name);
    for (int i = 0; i < 4; ++i)
        this->inventory[i] = NULL;
}
 
Character::Character(const Character &other) : name(other.name) {
    LOG_INFO("Character copy constructor called for " + this->name);
    for (int i = 0; i < 4; ++i)
        this->inventory[i] = NULL; // Ensure all slots are NULL before equipping
    for (int i = 0; i < 4; ++i) {
        if (other.inventory[i])
            this->equip(other.inventory[i]->clone()); // Deep copy: clone and equip
    }
}
 
Character &Character::operator=(const Character &other) {
    LOG_INFO("Character copy assignment operator called for " + other.name);
    if (this != &other) {
        this->name = other.name;
        // Delete current materias before copying new ones to prevent leaks
        for (int i = 0; i < 4; ++i) {
            if (this->inventory[i])
                delete this->inventory[i];
            this->inventory[i] = NULL;
        }
        // Equip cloned materias from the 'other' character
        for (int i = 0; i < 4; ++i) {
            if (other.inventory[i])
                this->equip(other.inventory[i]->clone()); // Deep copy: clone and equip
        }
    }
    return *this;
}
 
Character::~Character() {
    LOG_INFO("Character destructor called for " + this->name);
    for (int i = 0; i < 4; ++i) {
        if (this->inventory[i])
            delete this->inventory[i];
    }
}
 
std::string const &Character::getName() const { return this->name; }
 
void Character::equip(AMateria *m) {
    if (!m) // Do nothing if materia is NULL
        return;
    std::ostringstream oss;
    for (int i = 0; i < 4; ++i) {
        if (!this->inventory[i]) { // Find the first empty slot
            this->inventory[i] = m;
            oss << this->name << " equipped " << m->getType() << " at slot " << i;
            LOG_INFO(oss.str());
            return;
        }
    }
    // If loop finishes, inventory is full
    oss << this->name << "'s inventory is full, cannot equip " << m->getType();
    LOG_INFO(oss.str());
    delete m; // Delete the passed materia if it couldn't be equipped to prevent leak ( as per tip ? )
}
 
void Character::unequip(int idx) {
    std::ostringstream oss;
    if (idx >= 0 && idx < 4 && this->inventory[idx]) {
        oss << this->name << " unequips " << this->inventory[idx]->getType() << " from slot " << idx;
        this->inventory[idx] = NULL; // Set slot to NULL, but don't delete the Materia
    } else {
        oss << this->name << " tried to unequip from invalid slot " << idx;
    }
    LOG_INFO(oss.str());
}
 
void Character::use(int idx, ICharacter &target) {
    std::ostringstream oss;
    if (idx >= 0 && idx < 4 && this->inventory[idx]) {
        this->inventory[idx]->use(target);
    } else {
        oss << this->name << " tried to use invalid slot " << idx;
        LOG_INFO(oss.str());
    }
}
 
bool Character::isMateriaEquipped(int idx) const { return (idx >= 0 && idx < 4 && inventory[idx] != NULL); }
 
AMateria *Character::getMateriaAtSlot(int idx) const {
    if (idx >= 0 && idx < 4) {
        return this->inventory[idx];
    }
    return NULL; // Return NULL for invalid indices
}