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 MM1_DATA_CHAR_H
#define MM1_DATA_CHAR_H
 
#include "common/array.h"
#include "common/serializer.h"
#include "mm/mm1/data/items.h"
#include "mm/shared/xeen/sprites.h"
 
namespace MM {
namespace MM1 {
 
#define INVENTORY_COUNT 6
#define MAX_LEVEL 200
#define NUM_PORTRAITS 12
 
enum CharacterClass {
    KNIGHT = 1, PALADIN = 2, ARCHER = 3, CLERIC = 4,
    SORCERER = 5, ROBBER = 6, NONE = 0
};
 
enum Race {
    HUMAN = 1, ELF = 2, DWARF = 3, GNOME = 4, HALF_ORC = 5
};
 
enum Alignment {
    GOOD = 1, NEUTRAL = 2, EVIL = 3
};
 
enum Sex {
    MALE = 1, FEMALE = 2, YES_PLEASE = 3
};
 
enum Condition {
    FINE = 0, BAD_CONDITION = 0x80, ERADICATED = 0xff,
    DEAD = 0x40, STONE = 0x20,
    UNCONSCIOUS = 0x40, PARALYZED = 0x20, POISONED = 0x10,
    DISEASED = 8,  SILENCED = 4, BLINDED = 2, ASLEEP = 1
};
 
enum ConditionEnum {
    HEART_BROKEN = 1,
    C_BLINDED = 2,          // WEAK condition in Xeen
    C_POISONED = 3,
    C_DISEASED = 4,
    C_ASLEEP = 8,
    DEPRESSED = 9,
    C_SILENCED = 10,        // CONFUSED condition in Xeen
    C_PARALYZED = 11,
    C_UNCONSCIOUS = 12,
    C_DEAD = 13,
    C_STONE = 14,
    C_ERADICATED = 15,
    C_GOOD = 16
};
 
enum Resistance {
    RESISTANCE_MAGIC = 0, RESISTANCE_FIRE = 1, RESISTANCE_COLD = 2,
    RESISTANCE_ELECTRICITY = 3, RESISTANCE_ACID = 4,
    RESISTANCE_FEAR = 5, RESISTANCE_POISON = 6,
    RESISTANCE_PSYCHIC = 7, RESISTANCE_15 = 15
};
 
enum CharFlags0 {
    CHARFLAG0_COURIER1 = 1,
    CHARFLAG0_COURIER2 = 2,
    CHARFLAG0_COURIER3 = 4,
    CHARFLAG0_ZOM_CLUE = 8,
    CHARFLAG0_ZAM_CLUE = 0x10,
    CHARFLAG0_FOUND_CHEST = 0x20,
    CHARFLAG0_40 = 0x40,
    CHARFLAG0_DOG_STATUE = 0x80
};
 
enum CharFlags1 {
     CHARFLAG1_1 = 1,
     CHARFLAG1_2 = 2,
     CHARFLAG1_4 = 4,
     CHARFLAG1_8 = 8,
     CHARFLAG1_10 = 0x10,
     CHARFLAG1_20 = 0x20,
     CHARFLAG1_40 = 0x40,
     CHARFLAG1_WORTHY = 0x80
};
 
enum CharFlags2 {
    CHARFLAG2_1 = 1,
    CHARFLAG2_2 = 2,
    CHARFLAG2_4 = 4,
    CHARFLAG2_8 = 8,
    CHARFLAG2_10 = 0x10,
    CHARFLAG2_20 = 0x20,
    CHARFLAG2_40 = 0x40,
    CHARFLAG2_80 = 0x80
};
 
enum CharFlags4 {
    CHARFLAG4_ASSIGNED = 8,
    CHARFLAG4_SIGN = 7,
    CHARFLAG4_COLOR = 0xf,
    CHARFLAG4_80 = 0x80
};
 
enum CharFlags5 {
    CHARFLAG5_1 = 1,
    CHARFLAG5_2 = 2,
    CHARFLAG5_4 = 4,
    CHARFLAG5_8 = 8,
    CHARFLAG5_10 = 0x10,
    CHARFLAG5_20 = 0x20,
    CHARFLAG5_40 = 0x40,
    CHARFLAG5_80 = 0x80
};
 
enum CharFlags6 {
    CHARFLAG6_1 = 1,
    CHARFLAG6_2 = 2,
    CHARFLAG6_4 = 4,
    CHARFLAG6_8 = 8,
    CHARFLAG6_10 = 0x10,
    CHARFLAG6_20 = 0x20,
    CHARFLAG6_40 = 0x40,
    CHARFLAG6_80 = 0x80
};
 
enum CharFlags7 {
    CHARFLAG7_1 = 1,
    CHARFLAG7_2 = 2,
    CHARFLAG7_4 = 4,
    CHARFLAG7_8 = 8,
    CHARFLAG7_10 = 0x10,
    CHARFLAG7_20 = 0x20,
    CHARFLAG7_40 = 0x40,
    CHARFLAG7_80 = 0x80
};
 
enum CharFlags8 {
    CHARFLAG8_1 = 1,
    CHARFLAG8_2 = 2,
    CHARFLAG8_4 = 4,
    CHARFLAG8_8 = 8,
    CHARFLAG8_10 = 0x10,
    CHARFLAG8_20 = 0x20,
    CHARFLAG8_40 = 0x40,
    CHARFLAG8_80 = 0x80
};
 
enum CharFlags9 {
    CHARFLAG9_1 = 1,
    CHARFLAG9_2 = 2,
    CHARFLAG9_4 = 4,
    CHARFLAG9_8 = 8,
    CHARFLAG9_10 = 0x10,
    CHARFLAG9_20 = 0x20,
    CHARFLAG9_40 = 0x40,
    CHARFLAG9_80 = 0x80
};
 
enum CharFlags10 {
    CHARFLAG10_1 = 1,
    CHARFLAG10_2 = 2,
    CHARFLAG10_4 = 4,
    CHARFLAG10_8 = 8,
    CHARFLAG10_10 = 0x10,
    CHARFLAG10_20 = 0x20,
    CHARFLAG10_40 = 0x40,
    CHARFLAG10_80 = 0x80
};
 
enum CharFlags11 {
    CHARFLAG11_GOT_ENDURANCE = 1,
    CHARFLAG11_PERSONALITY = 2,
    CHARFLAG11_GOT_INTELLIGENCE = 4,
    CHARFLAG11_GOT_MIGHT = 8,
    CHARFLAG11_GOT_ACCURACY = 0x10,
    CHARFLAG11_GOT_SPEED = 0x20,
    CHARFLAG11_GOT_LUCK = 0x40,
    CHARFLAG11_CLERICS = 0x80
};
 
enum CharFlags12 {
    CHARFLAG12_1 = 1,
    CHARFLAG12_2 = 2,
    CHARFLAG12_4 = 4,
    CHARFLAG12_8 = 8,
    CHARFLAG12_10 = 0x10,
    CHARFLAG12_20 = 0x20,
    CHARFLAG12_40 = 0x40,
    CHARFLAG12_80 = 0x80
};
 
enum CharFlags13 {
    CHARFLAG13_1 = 1,
    CHARFLAG13_2 = 2,
    CHARFLAG13_4 = 4,
    CHARFLAG13_8 = 8,
    CHARFLAG13_10 = 0x10,
    CHARFLAG13_20 = 0x20,
    CHARFLAG13_ALAMAR = 0x40,
    CHARFLAG13_80 = 0x80
};
 
class Inventory {
public:
    struct Entry {
        byte _id = 0;
        byte _charges = 0;
        operator bool() const { return _id != 0; }
//      bool operator!() const { return !_id; }
//      operator byte() const { return _id; }
    };
private:
    Common::Array<Entry> _items;
 
    typedef bool (*CategoryFn)(byte id);
    bool hasCategory(CategoryFn fn) const;
 
    int getFreeSlot() const;
 
public:
    Inventory() {
        clear();
    }
    Entry &operator[](uint idx) {
        assert(idx < INVENTORY_COUNT);
        return _items[idx];
    }
    const Entry &operator[](uint idx) const {
        assert(idx < INVENTORY_COUNT);
        return _items[idx];
    }
 
    void synchronize(Common::Serializer &s, bool ids);
 
    void clear();
 
    bool empty() const;
 
    bool full() const;
 
    uint size() const;
 
    uint add(byte id, byte charges);
 
    void removeAt(uint idx);
 
    void remove(Entry *e);
 
    int indexOf(Entry *e) const;
 
    int indexOf(byte itemId) const;
 
    void removeCharge(Entry *e);
 
    bool hasWeapon() const { return hasCategory(isWeapon); }
    bool hasMissile() const { return hasCategory(isMissile); }
    bool hasTwoHanded() const { return hasCategory(isTwoHanded); }
    bool hasArmor() const { return hasCategory(isArmor); }
    bool hasShield() const { return hasCategory(isShield); }
 
    size_t getPerformanceTotal() const;
};
 
struct AttributePair {
    uint8 _current = 0;
    uint8 _base = 0;
 
    operator uint8() const { return _current; }
    AttributePair &operator=(byte v) {
        _base = _current = v;
        return *this;
    }
    AttributePair &operator++() {
        if (_base < 255)
            _current = ++_base;
        return *this;
    }
    AttributePair &operator--() {
        if (_base > 0)
            _current = --_base;
        return *this;
    }
    void clear() { _current = _base = 0; }
    void reset() { _current = _base; }
    void synchronize(Common::Serializer &s) {
        s.syncAsByte(_base);
        s.syncAsByte(_current);
    }
 
    size_t getPerformanceTotal() const {
        return (size_t)_base + (size_t)_current;
    }
};
 
struct AttributePair16 {
    uint16 _current = 0;
    uint16 _base = 0;
 
    void clear() { _current = _base = 0; }
    AttributePair16 &operator=(byte v) {
        _base = _current = v;
        return *this;
    }
    operator uint16() const {
        return _current;
    }
    void synchronize(Common::Serializer &s) {
        s.syncAsUint16LE(_base);
        s.syncAsUint16LE(_current);
    }
 
    size_t getPerformanceTotal() const {
        return (_base & 0xff) + (_base >> 8) +
            (_current & 0xff) + (_current >> 8);
    }
};
 
struct ResistanceFields {
    AttributePair _magic;
    AttributePair _fire;
    AttributePair _cold;
    AttributePair _electricity;
    AttributePair _acid;
    AttributePair _fear;
    AttributePair _poison;
    AttributePair _psychic;
};
 
union Resistances {
    ResistanceFields _s;
    AttributePair _arr[8];
 
    Resistances();
 
    void synchronize(Common::Serializer &s);
 
    size_t getPerformanceTotal() const;
};
 
struct PrimaryAttributes {
public:
    AttributePair _intelligence;
    AttributePair _might;
    AttributePair _personality;
    AttributePair _endurance;
    AttributePair _speed;
    AttributePair _accuracy;
    AttributePair _luck;
    AttributePair _level;
 
    AttributePair &getAttribute(uint i) {
        return *_attributes[i];
    }
private:
    AttributePair *_attributes[8] = {
        &_intelligence, &_might, &_personality, &_endurance,
        &_speed, &_accuracy, &_luck, &_level
    };
};
 
struct Character : public PrimaryAttributes {
    char _name[16] = { 0 };
    Sex _sex = MALE;
    Alignment _alignmentInitial = GOOD;
    Alignment _alignment = GOOD;
    Race _race = HUMAN;
    CharacterClass _class = NONE;
 
    byte _age = 18;
    int _ageDayCtr = 0;
    AttributePair16 _sp;
    AttributePair _spellLevel;
    AttributePair _ac;
 
    uint32 _exp = 0;
    uint16 _gems = 0;
    uint16 _hpCurrent = 0, _hp = 0, _hpMax = 0;
    uint32 _gold = 0;
    uint8 _food = 0;
    uint8 _condition = 0;
    Inventory _equipped;
    Inventory _backpack;
    Resistances _resistances;
 
    AttributePair _physicalAttr, _missileAttr;
    byte _trapCtr = 0;
    byte _quest = 0;
    byte _worthiness = 0;
    byte _alignmentCtr = 0;
    byte _flags[14];
 
    byte _portrait = 0;
    Shared::Xeen::SpriteResource _faceSprites;
 
    // Non persistent fields
    byte _numDrinks = 0;
    // Combat fields
    bool _checked = false;
    bool _canAttack = false;
    int _nonCombatSpell = -1;
    int _combatSpell = -1;
 
    int spellNumber() const;
 
    void setSpellNumber(int spellNum);
 
    Character();
 
    void synchronize(Common::Serializer &s, int portraitNum = -1);
 
    bool operator==(const Character &rhs) const {
        return !strcmp(_name, rhs._name);
    }
 
    void clear();
 
    void gatherGold();
 
    void gatherResources();
 
    enum TradeResult { TRADE_SUCCESS, TRADE_NO_ITEM, TRADE_FULL };
    TradeResult trade(int whoTo, int itemIndex);
 
    struct LevelIncrease {
        int _numHP;
        int _numSpells;
    };
    LevelIncrease increaseLevel();
 
    enum BuyResult { BUY_SUCCESS, BUY_NOT_ENOUGH_GOLD, BUY_BACKPACK_FULL };
    BuyResult buyItem(byte itemId);
 
    void updateAttributes();
 
    void updateAC();
 
    void updateSP();
 
    void updateResistances();
 
    Common::String getConditionString() const;
 
    void rest();
 
    bool hasItem(byte itemId) const;
 
    size_t getPerformanceTotal() const;
 
    void loadFaceSprites();
 
    uint32 experienceForNextLevel() const;
 
    bool canLevelUp() const;
 
    byte statColor(int amount, int threshold) const;
 
    byte conditionColor() const;
 
    ConditionEnum worstCondition() const;
 
    static Common::String getConditionString(ConditionEnum cond);
 
    bool hasBadCondition() const {
        return (_condition & BAD_CONDITION) != 0;
    }
};
 
struct SuggestedName {
    CharacterClass _class;
    Sex _sex;
    Common::String _name;
};
 
} // namespace MM1
} // namespace MM
 
#endif