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/>.
 *
 *
 * Based on the original sources
 *   Faery Tale II -- The Halls of the Dead
 *   (c) 1993-1996 The Wyrmkeep Entertainment Co.
 */

#ifndef SAGA2_PLAYER_H
#define SAGA2_PLAYER_H

#include "saga2/actor.h"

namespace Saga2 {

#define FTA_JULIAN  (PlayerActorID)0
#define FTA_PHILIP  (PlayerActorID)1
#define FTA_KEVIN   (PlayerActorID)2

/* ======================================================================= *
   PlayerActor -- data specific to possible center actors
 * ======================================================================= */

class ContainerNode;

class PlayerActor {
    friend class Actor;

    friend void initPlayerActors();
    friend void cleanupPlayerActors();

    ObjectID        _actorID;            // ID of player's actor

public:
    int16           _portraitType;       // Integer representing portrait state
    // for this player actor
    uint16          _flags;              // various flags

    ActorAttributes _baseStats;          // Base stats for this actor
    enum PlayerActorFlags {
        kPlayerAggressive        = (1 << 0), // Player is in aggressive mode
        kPlayerBanded            = (1 << 1), // Player is banded
        kPlayerHasCartography    = (1 << 2)  // Player has ability to map
    };

    // recovery information
    enum Recovery {
        kBaseManaRec             = 1,
        kAttribPointsPerUpdate   = 1,
        kAttribPointsPerValue    = 10
    };

    enum {
        kVitalityLevelBump       = 50
    };

    //  Container node for ready containers
    ContainerNode           *_readyNode;

    // mana 'experience' pool
    int16   _manaMemory[kNumManas];

    // attrib recovery pools
    uint8   _attribRecPools[kNumSkills];

    // skills 'expericene' pool
    uint8   _attribMemPools[kNumSkills];

    // vitality pool
    uint8 _vitalityMemory;

    //  Flag indicating whether the user has been notified that this player
    //  actor has been attacked since the last combat
    bool _notifiedOfAttack;

    //  Constructor
    PlayerActor(ObjectID a) :  _actorID(a), _portraitType(0), _flags(0), _readyNode(NULL),
            _vitalityMemory(0), _notifiedOfAttack(false) {

        assert(ActorAttributes::kSkillFracPointsPerLevel > 0);    // this is used in a divide

        memset(&_baseStats, 0, sizeof(_baseStats));

        for (int i = 0; i < kNumManas; i++)
            _manaMemory[i] = 0;

        for (int i = 0; i < kNumSkills; i++) {
            _attribRecPools[i] = 0;
            _attribMemPools[i] = 0;
        }
    }

    // gets level of skill
    int8 getSkillLevel(SkillProto *, bool base = false);

    // get the actorAttributes allskills index from proto
    uint8 getStatIndex(SkillProto *);

    // get the effective stats of this player actor
    ActorAttributes *getEffStats();

    // these update a players baseStat skills
    void skillAdvance(uint8 stat,
                      uint8 advanceChance,
                      uint8 points,
                      uint8 useMult = 1);

    void skillAdvance(SkillProto *proto,
                      uint8 points,
                      uint8 useMult = 1);

    void skillAdvance(ActorSkillID stat,
                      uint8 points,
                      uint8 useMult = 1);

    void vitalityAdvance(uint8 points);

    //  Return Actor structure pointer
    Actor *getActor() {
        return (Actor *)GameObject::objectAddress(_actorID);
    }

    //  Return Actor's object ID
    ObjectID getActorID() {
        return _actorID;
    }

    //  Set player to be aggressive
    void setAggression() {
        _flags |= kPlayerAggressive;
    }

    //  Set player to not aggressive
    void clearAggression() {
        _flags &= ~kPlayerAggressive;
    }

    //  Determine if actor is in aggressive state
    bool isAggressive() {
        return (_flags & kPlayerAggressive) != 0;
    }

    //  Set the player to be banded
    void setBanded() {
        _flags |= kPlayerBanded;
    }

    //  Set the player to not be banded
    void clearBanded() {
        _flags &= ~kPlayerBanded;
    }

    //  Determine if this player actor is banded
    bool isBanded() {
        return (_flags & kPlayerBanded) != 0;
    }

    //  Resolve the banding state of this actor
    void resolveBanding();

    //  Re-evaluate the portrait type for this player actor
    void recalcPortraitType();

    //  Return the integer representing the portrait type for this
    //  player actor
    int16 getPortraitType() {
        return _portraitType;
    }

    // figures out what what ( if any ) changes are required to
    // the charaters vitality
    void recoveryUpdate();
    void manaUpdate();
    void AttribUpdate();
    void stdAttribUpdate(uint8 &stat, uint8 baseStat, int16 index);

    // get this player actor's base stats
    ActorAttributes &getBaseStats() {
        return _baseStats;
    }

    //  Notify the user of attack if necessary
    void handleAttacked();

    //  Simply reset the attack notification flag
    void resetAttackNotification() {
        _notifiedOfAttack = false;
    }
};

//  Return a pointer to a PlayerActor given it's ID
PlayerActor *getPlayerActorAddress(PlayerActorID id);

//  Return a PlayerActor ID given it's address
PlayerActorID getPlayerActorID(PlayerActor *p);

//  Return a pointer to the center actor
Actor *getCenterActor();
//  Return the center actor's object ID
ObjectID getCenterActorID();
//  Return the center actor's player actor ID
PlayerActorID getCenterActorPlayerID();

//  Set a new center actor based upon the PlayerActor ID
void setCenterActor(PlayerActorID newCenter);

//  Set a new center actor based upon the address of the actor's struct
void setCenterActor(Actor *newCenter);

//  Set a new center actor based upon the address of the PlayerActor
//  struct
void setCenterActor(PlayerActor *newCenter);

//  Get the coordinates of the center actor
TilePoint centerActorCoords();

//  Set a player actor's aggression
void setAggression(PlayerActorID player, bool aggression);

//  Set the center actor's aggression
inline void setCenterActorAggression(bool aggression) {
    setAggression(getCenterActorPlayerID(), aggression);
}

//  Determine the state of a player actor's aggression
bool isAggressive(PlayerActorID player);

//  Determine if center actor is aggressive
inline bool isCenterActorAggressive() {
    return isAggressive(getCenterActorPlayerID());
}

//  Set a player actor's banding
void setBanded(PlayerActorID player, bool banded);

//  Determine if a player actor is banded
bool isBanded(PlayerActorID player);

//  Globally enable or disable player actor banding
void setBrotherBanding(bool enabled);

//  Adjust the player actors aggression setting based upon their
//  proximity to enemies
void autoAdjustAggression();

//  Calculate the portrait for this brother's current state.
void recalcPortraitType(PlayerActorID id);

//  Returns an integer value representing this player actor's portrait
//  state
int16 getPortraitType(PlayerActorID id);

bool actorToPlayerID(Actor *a, PlayerActorID &result);
bool actorIDToPlayerID(ObjectID id, PlayerActorID &result);

void handlePlayerActorDeath(PlayerActorID id);

//  Transport the center actor and the banded brothers who have a path
//  the center actor
void transportCenterBand(const Location &loc);

void handlePlayerActorAttacked(PlayerActorID id);

void handleEndOfCombat();

/* ======================================================================= *
   PlayerActor list management function prototypes
 * ======================================================================= */


//  Initialize the player actor list
void initPlayerActors();

void savePlayerActors(Common::OutSaveFile *out);
void loadPlayerActors(Common::InSaveFile *in);

//  Cleanup the player actor list
void cleanupPlayerActors();

/* ======================================================================= *
   CenterActor management function prototypes
 * ======================================================================= */

//  Initialize the center actor ID and view object ID
void initCenterActor();

void saveCenterActor(Common::OutSaveFile *outS);
void loadCenterActor(Common::InSaveFile *in);

//  Do nothing
inline void cleanupCenterActor() {}

/* ======================================================================= *
   PlayerActor iteration class
 * ======================================================================= */

class PlayerActorIterator {
protected:
    int16               _index;

public:
    PlayerActorIterator() {
        _index = 0;
    }

    PlayerActor *first();
    PlayerActor *next();
};

//  Iterates through all player actors that are not dead.

class LivingPlayerActorIterator : public PlayerActorIterator {

public:
    LivingPlayerActorIterator() {}

    PlayerActor *first();
    PlayerActor *next();
};

} // end of namespace Saga2

#endif