character.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#ifndef ULTIMA_SHARED_CORE_CHARACTER_H
#define ULTIMA_SHARED_CORE_CHARACTER_H
 
#include "common/array.h"
#include "common/str.h"
#include "common/serializer.h"
#include "ultima/shared/core/named_item.h"
 
namespace Ultima {
namespace Shared {
 
enum Sex { SEX_MALE = 0, SEX_FEMALE = 1, SEX_OTHER = 2, SEX_YES_PLEASE = 2 };
 
class Itemized {
public:
    uint _quantity;
public:
    Itemized() : _quantity(0) {}
 
    virtual ~Itemized() {}
 
    void synchronize(Common::Serializer &s) {
        s.syncAsUint16LE(_quantity);
    }
 
    virtual void changeQuantity(int delta) {
        _quantity = (uint)CLIP((int)_quantity + delta, 0, 9999);
    }
 
    void incrQuantity() { changeQuantity(1); }
 
    bool empty() const { return _quantity == 0; }
 
    bool decrQuantity() {
        changeQuantity(-1);
        return empty();
    }
};
 
class Weapon : public Itemized {
public:
    Common::String _shortName, _longName;
    uint _distance;
public:
    Weapon() : Itemized(), _distance(0) {}
};
 
class Armour : public Itemized {
public:
    Common::String _name;
};
 
class Spell : public Itemized, public NamedItem {
};
 
template<class T>
class ItemArray : public Common::Array<T> {
public:
    size_t itemsCount() const {
        uint total = 0;
        for (uint idx = 1; idx < this->size(); ++idx) {
            if (!(*this)[idx]->empty())
                ++total;
        }
 
        return total;
    }
 
    bool hasNothing() const {
        return itemsCount() == 0;
    }
};
 
class Character {
public:
    Common::String _name;
    uint _race;
    Sex _sex;
    uint _class;
 
    uint _strength;
    uint _agility;
    uint _stamina;
    uint _charisma;
    uint _wisdom;
    uint _intelligence;
    uint _hitPoints;
    uint _experience;
    uint _food;
    uint _coins;
    int _equippedWeapon;
    int _equippedArmour;
    int _equippedSpell;
    ItemArray<Weapon *> _weapons;
    ItemArray<Armour *> _armour;
    ItemArray<Spell *> _spells;
public:
    Character() : _strength(0), _agility(0), _stamina(0), _charisma(0), _wisdom(0), _intelligence(0),
        _hitPoints(0), _experience(0), _food(0), _coins(0), _equippedWeapon(0), _equippedArmour(0), _equippedSpell(0),
        _race(0), _sex(SEX_MALE), _class(0) {}
 
    void synchronize(Common::Serializer &s);
 
    bool isWeaponEquipped() const { return _equippedWeapon != 0; }
 
    bool isArmourEquipped() const { return _equippedArmour != 0; }
 
    bool isSpellEquipped() const { return _equippedSpell != 0; }
 
    Weapon *equippedWeapon() const { return _weapons[_equippedWeapon]; }
 
    Armour *equippedArmour() const { return _armour[_equippedArmour]; }
 
    Spell *equippedSpell() const { return _spells[_equippedSpell]; }
 
    void removeWeapon() { _equippedWeapon = 0; }
 
    void removeArmour() { _equippedArmour = 0; }
 
    void removeSpell() { _equippedSpell = 0; }
 
    uint getLevel() const { return (_experience / 1000) + 1; }
};
 
} // End of namespace Shared
} // End of namespace Ultima
 
#endif