player.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 ULTIMA4_GAME_PLAYER_H
#define ULTIMA4_GAME_PLAYER_H

#include "ultima/ultima4/game/creature.h"
#include "ultima/ultima4/map/direction.h"
#include "ultima/ultima4/core/observable.h"
#include "ultima/ultima4/filesys/savegame.h"
#include "ultima/ultima4/game/script.h"
#include "ultima/ultima4/map/tile.h"
#include "ultima/ultima4/core/types.h"

namespace Ultima {
namespace Ultima4 {

class Armor;
class Party;
class Weapon;

typedef Std::vector<class PartyMember *> PartyMemberVector;

#define ALL_PLAYERS -1

enum KarmaAction {
    KA_FOUND_ITEM,
    KA_STOLE_CHEST,
    KA_GAVE_TO_BEGGAR,
    KA_GAVE_ALL_TO_BEGGAR,
    KA_BRAGGED,
    KA_HUMBLE,
    KA_HAWKWIND,
    KA_MEDITATION,
    KA_BAD_MANTRA,
    KA_ATTACKED_GOOD,
    KA_FLED_EVIL,
    KA_FLED_GOOD,
    KA_HEALTHY_FLED_EVIL,
    KA_KILLED_EVIL,
    KA_SPARED_GOOD,
    KA_DONATED_BLOOD,
    KA_DIDNT_DONATE_BLOOD,
    KA_CHEAT_REAGENTS,
    KA_DIDNT_CHEAT_REAGENTS,
    KA_USED_SKULL,
    KA_DESTROYED_SKULL
};

enum HealType {
    HT_NONE,
    HT_CURE,
    HT_FULLHEAL,
    HT_RESURRECT,
    HT_HEAL,
    HT_CAMPHEAL,
    HT_INNHEAL
};

enum InventoryItem {
    INV_NONE,
    INV_WEAPON,
    INV_ARMOR,
    INV_FOOD,
    INV_REAGENT,
    INV_GUILDITEM,
    INV_HORSE
};

enum CannotJoinError {
    JOIN_SUCCEEDED,
    JOIN_NOT_EXPERIENCED,
    JOIN_NOT_VIRTUOUS
};

enum EquipError {
    EQUIP_SUCCEEDED,
    EQUIP_NONE_LEFT,
    EQUIP_CLASS_RESTRICTED
};

class PartyMember : public Creature, public Script::Provider {
public:
    PartyMember(Party *p, SaveGamePlayerRecord *pr);
    virtual ~PartyMember();

    void notifyOfChange();

    Common::String translate(Std::vector<Common::String> &parts) override;

    // Accessor methods
    int getHp() const override;
    int getMaxHp() const {
        return _player->_hpMax;
    }
    int getExp() const {
        return _player->_xp;
    }
    int getStr() const {
        return _player->_str;
    }
    int getDex() const {
        return _player->_dex;
    }
    int getInt() const {
        return _player->_intel;
    }
    int getMp() const {
        return _player->_mp;
    }

    int getMaxMp() const;

    const Weapon *getWeapon() const;
    const Armor *getArmor() const;
    Common::String getName() const override;
    SexType getSex() const;
    ClassType getClass() const;
    CreatureStatus getState() const override;

    int getRealLevel() const;

    int getMaxLevel() const;

    void addStatus(StatusType status) override;

    void adjustMp(int pts);

    void advanceLevel();

    void applyEffect(TileEffect effect);

    void awardXp(int xp);

    bool heal(HealType type);

    void removeStatus(StatusType status) override;

    void setHp(int hp) override;
    void setMp(int mp);
    EquipError setArmor(const Armor *a);
    EquipError setWeapon(const Weapon *w);

    bool applyDamage(int damage, bool byplayer = false) override;
    int getAttackBonus() const override;
    int getDefense() const override;
    bool dealDamage(Creature *m, int damage) override;

    int getDamage();

    const Common::String &getHitTile() const override;

    const Common::String &getMissTile() const override;
    bool isDead();
    bool isDisabled();

    int  loseWeapon();

    void putToSleep() override;

    void wakeUp() override;

protected:
    static MapTile tileForClass(int klass);

    SaveGamePlayerRecord *_player;
    class Party *_party;
};

class PartyEvent {
public:
    enum Type {
        GENERIC,
        LOST_EIGHTH,
        ADVANCED_LEVEL,
        STARVING,
        TRANSPORT_CHANGED,
        PLAYER_KILLED,
        ACTIVE_PLAYER_CHANGED,
        MEMBER_JOINED,
        PARTY_REVIVED,
        INVENTORY_ADDED
    };

    PartyEvent(Type type, PartyMember *partyMember) : _type(type), _player(partyMember) { }

    Type _type;
    PartyMember *_player;
};

typedef Std::vector<PartyMember *> PartyMemberVector;

class Party : public Observable<Party *, PartyEvent &>, public Script::Provider {
    friend class PartyMember;
public:
    Party(SaveGame *saveGame);
    virtual ~Party();

    void notifyOfChange(PartyMember *partyMember = 0, PartyEvent::Type = PartyEvent::GENERIC);

    // Used to translate script values into something useful
    Common::String translate(Std::vector<Common::String> &parts) override;

    void adjustFood(int food);
    void adjustGold(int gold);

    void adjustKarma(KarmaAction action);

    void applyEffect(TileEffect effect);

    bool attemptElevation(Virtue virtue);

    void burnTorch(int turns = 1);

    bool canEnterShrine(Virtue virtue);

    bool canPersonJoin(Common::String name, Virtue *v);

    void damageShip(uint pts);

    bool donate(int quantity);

    void endTurn();

    int  getChest();

    int  getTorchDuration() const;

    void healShip(uint pts);

    bool isFlying() const;

    bool isImmobilized();

    bool isDead();

    bool isPersonJoined(Common::String name);

    CannotJoinError join(Common::String name);

    bool lightTorch(int duration = 100, bool loseTorch = true);

    void quenchTorch();

    void reviveParty();
    MapTile getTransport() const;
    void setTransport(MapTile transport);
    void setShipHull(int str);

    Direction getDirection() const;
    void setDirection(Direction dir);

    void adjustReagent(int reagent, int amt);
    int getReagent(int reagent) const;
    short *getReagentPtr(int reagent) const;

    void setActivePlayer(int p);
    int getActivePlayer() const;

    void swapPlayers(int p1, int p2);

    int size() const;

    PartyMember *member(int index) const;

private:
    void syncMembers();
    PartyMemberVector _members;
    SaveGame *_saveGame;
    MapTile _transport;
    int _torchDuration;
    int _activePlayer;
#ifdef IOS_ULTIMA4
    friend void U4IOS::syncPartyMembersWithSaveGame();
#endif
};

bool isPartyMember(Object *punknown);

} // End of namespace Ultima4
} // End of namespace Ultima

#endif