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 Common::Array<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(Common::Array<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 Common::Array<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(Common::Array<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