#include "AMateria.h"
#include "ICharacter.h"
#include <string>
+#include <iostream>
AMateria::AMateria()
{
AMateria &AMateria::operator=(const AMateria &other)
{
+ if (this == &other)
+ return (*this);
+ return (*this);
}
AMateria::AMateria(const std::string &type)
{
}
-const std::string &getType() const
+const std::string &AMateria::getType() const
{
return (m_type);
}
-void use(ICharacter &target);
+void AMateria::use(ICharacter &target)
{
std::cout << "* AMATERIA AFFECTS " << target.getName() << " *\n";
}
+
+bool AMateria::operator==(const std::string &type)
+{
+ return (m_type == type);
+}
# include "ICharacter.h"
# include <string>
+class ICharacter;
+
class AMateria
{
private:
virtual AMateria *clone() const = 0;
virtual void use(ICharacter &target);
+
+ bool operator==(const std::string &type);
};
#endif // AMATERIA_H
: m_name(name)
{
for (size_t i(0); i < INVENTORY_SIZE; ++i)
- inventory[i] = NULL;
+ m_inventory[i] = NULL;
}
Character::Character(const Character &other)
{
for (size_t i(0); i < INVENTORY_SIZE; ++i)
{
- if (other.inventor[i] == NULL)
- inventory[i] = NULL;
+ if (other.m_inventory[i] == NULL)
+ m_inventory[i] = NULL;
else
- inventory[i] = other.inventory[i]->clone();
+ m_inventory[i] = other.m_inventory[i]->clone();
}
}
Character::~Character()
{
for (size_t i(0); i < INVENTORY_SIZE; ++i)
- delete inventory[i];
+ delete m_inventory[i];
}
Character &Character::operator=(const Character &other)
{
+ if (this == &other)
+ return (*this);
+ return (*this);
}
void Character::equip(AMateria *materia)
for (size_t i(0); i < INVENTORY_SIZE; ++i)
if (m_inventory[i] == NULL)
{
- m_inventory[i] = materia
+ m_inventory[i] = materia;
return ;
}
}
void Character::unequip(int idx)
{
- if (idx < 0 || idx >= INVENTORY_SIZE)
+ if (idx < 0 || (size_t)idx >= INVENTORY_SIZE)
return ;
m_inventory[idx] = NULL;
}
void Character::use(int idx, ICharacter &target)
{
- if (idx < 0 || idx >= INVENTORY_SIZE)
+ if (idx < 0 || (size_t)idx >= INVENTORY_SIZE)
return ;
- if (m_inventory[i] == NULL)
+ if (m_inventory[idx] == NULL)
return ;
- m_inventory[i]->use(target);
+ m_inventory[idx]->use(target);
}
const std::string &Character::getName() const
AMateria *m_inventory[INVENTORY_SIZE];
public:
- Character(std::string name);
+ Character(const std::string &name);
~Character();
+ const std::string &getName() const;
void equip(AMateria *materia);
void unequip(int idx);
void use(int idx, ICharacter &target);
Cure &Cure::operator=(const Cure &other)
{
+ if (this == &other)
+ return (*this);
+ return (*this);
}
-AMateria *clone() const
+AMateria *Cure::clone() const
{
- return (new Ice(*this));
+ return (new Cure(*this));
}
-void use(ICharacter& target)
+void Cure::use(ICharacter& target)
{
- std::cout << "* heals " << target.getName << "'s wounds *\n";
+ std::cout << "* heals " << target.getName() << "'s wounds *\n";
}
#ifndef CURE_H
# define CURE_H
+# include "AMateria.h"
+# include "ICharacter.h"
+
class Cure : public AMateria
{
private:
Cure();
Cure(const Cure &other);
~Cure();
+
+ AMateria *clone() const;
+ void use(ICharacter &target);
};
#endif // CURE_H
#ifndef ICHARACTER_H
# define ICHARACTER_H
+# include "AMateria.h"
+# include <string>
+
+class AMateria;
+
class ICharacter
{
public:
public:
virtual ~IMateriaSource() {}
- virtual void leanMateria(AMateria *) = 0;
+ virtual void learnMateria(AMateria *) = 0;
virtual AMateria *createMateria(const std::string &type) = 0;
};
}
Ice::Ice(const Ice &other)
- : AMateria(other);
+ : AMateria(other)
{
}
Ice &Ice::operator=(const Ice &other)
{
+ if (this == &other)
+ return (*this);
+ return (*this);
}
-AMateria *clone() const
+AMateria *Ice::clone() const
{
return (new Ice(*this));
}
-void use(ICharacter& target)
+void Ice::use(ICharacter& target)
{
- std::cout << "* shoots an ice bolt at " << target.getName << " *\n";
+ std::cout << "* shoots an ice bolt at " << target.getName() << " *\n";
}
#ifndef ICE_H
# define ICE_H
+# include "AMateria.h"
+# include "ICharacter.h"
+
class Ice : public AMateria
{
private:
Ice();
Ice(const Ice &other);
~Ice();
+
+ AMateria *clone() const;
+ void use(ICharacter &target);
};
#endif // ICE_H
#include "MateriaSource.h"
+#include "AMateria.h"
MateriaSource::MateriaSource()
: m_num_known(0)
void MateriaSource::deleteKnown()
{
- for (; m_num_know > 0;)
+ for (; m_num_known > 0;)
delete m_known_materia[--m_num_known];
}
deleteKnown();
for (; m_num_known < other.m_num_known; ++m_num_known)
m_known_materia[m_num_known] = other.m_known_materia[m_num_known]->clone();
+ return (*this);
}
void MateriaSource::learnMateria(AMateria *materia)
AMateria *MateriaSource::createMateria(const std::string &type)
{
for (size_t i(0); i < m_num_known; ++i)
- if (m_known_materia[i] == type)
+ if (*m_known_materia[i] == type)
return (m_known_materia[i]->clone());
return (NULL);
}
# include "AMateria.h"
# include "IMateriaSource.h"
-class MateriaSource : IMateriaSource
+class MateriaSource : public IMateriaSource
{
private:
MateriaSource &operator=(const MateriaSource &other);
+ void deleteKnown();
static const size_t max_known = 4;