actor.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 WORLD_ACTORS_ACTOR_H
#define WORLD_ACTORS_ACTOR_H
 
#include "ultima/ultima8/world/container.h"
#include "ultima/ultima8/usecode/intrinsics.h"
#include "ultima/ultima8/world/actors/animation.h"
 
namespace Ultima {
namespace Ultima8 {
 
class ActorAnimProcess;
struct PathfindingState;
class CombatProcess;
class AttackProcess;
 
class Actor : public Container {
    friend class ActorAnimProcess;
    friend class AnimationTracker;
public:
    Actor();
    ~Actor() override;
 
    int16 getStr() const {
        return _strength;
    }
    void setStr(int16 str) {
        _strength = str;
    }
    int16 getDex() const {
        return _dexterity;
    }
    void setDex(int16 dex) {
        _dexterity = dex;
    }
    int16 getInt() const {
        return _intelligence;
    }
    void setInt(int16 intl) {
        _intelligence = intl;
    }
    uint16 getHP() const {
        return _hitPoints;
    }
    void setHP(uint16 hp) {
        _hitPoints = hp;
    }
    int16 getMana() const {
        return _mana;
    }
    void setMana(int16 mp) {
        _mana = mp;
    }
 
    int16 getMaxMana() const;
    uint16 getMaxHP() const;
 
    bool isDead() const {
        return (_actorFlags & ACT_DEAD) != 0;
    }
 
    bool isInCombat() const {
        return (_actorFlags & ACT_INCOMBAT) != 0;
    }
 
    bool isKneeling() const {
        return (_actorFlags & ACT_KNEELING) != 0;
    }
 
    bool isFalling() const;
 
    CombatProcess *getCombatProcess() const;    // in U8
    AttackProcess *getAttackProcess() const;    // in Crusader
    virtual void setInCombat(int activity);
    virtual void clearInCombat();
 
    uint16 getAlignment() const {
        return _alignment;
    }
    void setAlignment(uint16 a) {
        _alignment = a;
    }
    uint16 getEnemyAlignment() const {
        return _enemyAlignment;
    }
    void setEnemyAlignment(uint16 a) {
        _enemyAlignment = a;
    }
 
    Animation::Sequence getLastAnim() const {
        return _lastAnim;
    }
    void setLastAnim(Animation::Sequence anim) {
        _lastAnim = anim;
    }
    Direction getDir() const {
        return _direction;
    }
    void setDir(Direction dir) {
        _direction = dir;
    }
    int32 getFallStart() const {
        return _fallStart;
    }
    void setFallStart(int32 zp) {
        _fallStart = zp;
    }
    void setUnkByte(uint8 b) {
        _unkByte = b;
    }
    uint8 getUnkByte() const {
        return _unkByte;
    }
 
    bool hasActorFlags(uint32 flags) const {
        return (_actorFlags & flags) != 0;
    }
    void setActorFlag(uint32 mask) {
        _actorFlags |= mask;
        if (mask & ACT_KNEELING)
            _cachedShapeInfo = nullptr;
    }
    void clearActorFlag(uint32 mask) {
        _actorFlags &= ~mask;
        if (mask & ACT_KNEELING)
            _cachedShapeInfo = nullptr;
    }
 
    void setCombatTactic(int no) {
        _combatTactic = no;
    }
 
    bool loadMonsterStats();
 
    bool giveTreasure();
 
    virtual void teleport(int mapnum, int32 x, int32 y, int32 z);
 
    bool removeItem(Item *item) override;
 
    uint16 schedule(uint32 time);
 
    bool setEquip(Item *item, bool checkwghtvol = false);
    uint16 getEquip(uint32 type) const;
 
    virtual uint32 getArmourClass() const;
    virtual uint16 getDefenseType() const;
    virtual int16 getAttackingDex() const;
    virtual int16 getDefendingDex() const;
 
    uint16 getDamageType() const override;
    virtual int getDamageAmount() const;
 
    void setDefaultActivity(int no, uint16 activity);
    uint16 getDefaultActivity(int no) const;
 
    void setHomePosition(int32 x, int32 y, int32 z);
    void getHomePosition(int32 &x, int32 &y, int32 &z) const;
 
    int calculateAttackDamage(uint16 other, int damage, uint16 type);
 
    void receiveHit(uint16 other, Direction dir, int damage, uint16 type) override;
 
    virtual ProcId die(uint16 damageType, uint16 damagePts, Direction srcDir);
 
    void killAllButCombatProcesses();
 
    ProcId killAllButFallAnims(bool death);
 
    bool areEnemiesNear();
 
    uint16 setActivity(int activity);
 
    uint16 getCurrentActivityNo() const {
        return _currentActivityNo;
    }
 
    uint16 getLastActivityNo() const {
        return _lastActivityNo;
    }
 
    void clearLastActivityNo() {
        _lastActivityNo = 0;
    }
 
    int32 getLastTickWasHit() const {
        return _lastTickWasHit;
    }
 
    uint16 doAnim(Animation::Sequence anim, Direction dir, unsigned int steps = 0);
 
    uint16 doAnimAfter(Animation::Sequence anim, Direction dir, ProcId waitfor);
 
    bool hasAnim(Animation::Sequence anim);
 
    void setToStartOfAnim(Animation::Sequence anim);
 
    Animation::Result tryAnim(Animation::Sequence anim, Direction dir, unsigned int steps = 0, PathfindingState *state = 0);
 
    DirectionMode animDirMode(Animation::Sequence anim) const;
 
    bool isBusy() const;
 
    int32 collideMove(int32 x, int32 y, int32 z, bool teleport, bool force,
                      ObjId *hititem = 0, uint8 *dirs = 0) override;
 
    uint16 turnTowardDir(Direction dir, ProcId prevpid = 0);
 
    static Actor *createActor(uint32 shape, uint32 frame);
 
    uint16 assignObjId() override; // assign an NPC objid
 
    Common::String dumpInfo() const override;
 
    bool loadData(Common::ReadStream *rs, uint32 version);
    void saveData(Common::WriteStream *ws) override;
 
    virtual int receiveShieldHit(int damage, uint16 damage_type) {
        return damage;
    }
 
    uint16 getActiveWeapon() const {
        return _activeWeapon;
    }
 
    uint16 getCombatTactic() const {
        return _combatTactic;
    }
 
    bool activeWeaponIsSmall() const;
 
    void tookHitCru();
 
    bool canSeeControlledActor(bool forcombat);
 
    void addFireAnimOffsets(int32 &x, int32 &y, int32 &z);
 
    uint32 getAttackMoveTimeoutFinishFrame() const {
        return _attackMoveStartFrame + _attackMoveTimeout;
    }
 
    uint16 getAttackMoveDodgeFactor() const {
        return _attackMoveDodgeFactor;
    }
 
    bool getAttackAimFlag() const {
        return _attackAimFlag;
    }
 
    void setAttackAimFlag(bool val) {
        _attackAimFlag = val;
    }
 
    ENABLE_RUNTIME_CLASSTYPE()
 
    INTRINSIC(I_isNPC);
    INTRINSIC(I_getDir);
    INTRINSIC(I_getLastAnimSet);
    INTRINSIC(I_pathfindToItem);
    INTRINSIC(I_pathfindToPoint);
    INTRINSIC(I_getStr);
    INTRINSIC(I_getDex);
    INTRINSIC(I_getInt);
    INTRINSIC(I_getHp);
    INTRINSIC(I_getMaxHp);
    INTRINSIC(I_getMana);
    INTRINSIC(I_getAlignment);
    INTRINSIC(I_getEnemyAlignment);
    INTRINSIC(I_setStr);
    INTRINSIC(I_setDex);
    INTRINSIC(I_setInt);
    INTRINSIC(I_setHp);
    INTRINSIC(I_setMana);
    INTRINSIC(I_setAlignment);
    INTRINSIC(I_setEnemyAlignment);
    INTRINSIC(I_getMap);
    INTRINSIC(I_addHp);
    INTRINSIC(I_teleport);
    INTRINSIC(I_doAnim);
    INTRINSIC(I_isInCombat);
    INTRINSIC(I_setInCombat);
    INTRINSIC(I_clrInCombat);
    INTRINSIC(I_setTarget);
    INTRINSIC(I_getTarget);
    INTRINSIC(I_isEnemy);
    INTRINSIC(I_isDead);
    INTRINSIC(I_setDead);
    INTRINSIC(I_clrDead);
    INTRINSIC(I_isImmortal);
    INTRINSIC(I_setImmortal);
    INTRINSIC(I_clrImmortal);
    INTRINSIC(I_isWithstandDeath);
    INTRINSIC(I_setWithstandDeath);
    INTRINSIC(I_clrWithstandDeath);
    INTRINSIC(I_isFeignDeath);
    INTRINSIC(I_setFeignDeath);
    INTRINSIC(I_clrFeignDeath);
    INTRINSIC(I_areEnemiesNear);
    INTRINSIC(I_isBusy);
    INTRINSIC(I_createActor);
    INTRINSIC(I_createActorCru);
    INTRINSIC(I_setActivity);
    INTRINSIC(I_setAirWalkEnabled);
    INTRINSIC(I_getAirWalkEnabled);
    INTRINSIC(I_schedule);
    INTRINSIC(I_getEquip);
    INTRINSIC(I_setEquip);
    INTRINSIC(I_setDefaultActivity0);
    INTRINSIC(I_setDefaultActivity1);
    INTRINSIC(I_setDefaultActivity2);
    INTRINSIC(I_getDefaultActivity0);
    INTRINSIC(I_getDefaultActivity1);
    INTRINSIC(I_getDefaultActivity2);
    INTRINSIC(I_setCombatTactic);
    INTRINSIC(I_setUnkByte);
    INTRINSIC(I_getUnkByte);
    INTRINSIC(I_getLastActivityNo);
    INTRINSIC(I_getCurrentActivityNo);
    INTRINSIC(I_turnToward);
    INTRINSIC(I_isKneeling);
    INTRINSIC(I_isFalling);
 
    enum ActorFlags {
        ACT_INVINCIBLE     = 0x000001, // flags from npcdata byte 0x1B
        ACT_ASCENDING      = 0x000002,
        ACT_DESCENDING     = 0x000004,
        ACT_ANIMLOCK       = 0x000008,
 
        ACT_KNEELING       = 0x000100, // not the same bit used in Crusader, but use this because it's empty.
        ACT_FIRSTSTEP      = 0x000400, // flags from npcdata byte 0x2F
        ACT_INCOMBAT       = 0x000800,
        ACT_DEAD           = 0x001000,
        ACT_SURRENDERED    = 0x002000, // not the same bit used in Crusader, but use this because it's empty.
        ACT_WEAPONREADY    = 0x004000, // not the same bit used in Crusader, but use this because it's empty.
        ACT_COMBATRUN      = 0x008000,
 
        ACT_AIRWALK        = 0x010000, // flags from npcdata byte 0x30
        ACT_IMMORTAL       = 0x040000,
        ACT_WITHSTANDDEATH = 0x080000,
        ACT_FEIGNDEATH     = 0x100000,
        ACT_STUNNED        = 0x200000,
        ACT_POISONED       = 0x400000,
        ACT_PATHFINDING    = 0x800000
    };
 
protected:
    int16 _strength;
    int16 _dexterity;
    int16 _intelligence;
    uint16 _hitPoints;
    int16 _mana;
 
    uint16 _alignment, _enemyAlignment;
 
    Animation::Sequence _lastAnim;
    uint16 _animFrame;
    Direction _direction;
 
    int32 _fallStart;
 
    uint8 _unkByte;
 
    uint16 _combatTactic;
 
    uint32 _actorFlags;
 
    uint16 _defaultActivity[3];
 
    int32 _homeX;
    int32 _homeY;
    int32 _homeZ;
 
    uint16 _currentActivityNo;
    uint16 _lastActivityNo;
 
    uint16 _activeWeapon;
 
    int32 _lastTickWasHit;
 
    uint32 _attackMoveStartFrame;
    uint32 _attackMoveTimeout;
    uint16 _attackMoveDodgeFactor;
 
    bool _attackAimFlag;
 
    uint16 setActivityU8(int activity);
 
    uint16 setActivityCru(int activity);
 
    bool loadMonsterStatsU8();
    bool loadMonsterStatsCru();
 
    void receiveHitU8(uint16 other, Direction dir, int damage, uint16 type);
    void receiveHitCru(uint16 other, Direction dir, int damage, uint16 type);
 
    void setInCombatU8();
    void setInCombatCru(int activity);
 
    ProcId dieU8(uint16 damageType);
    ProcId dieCru(uint16 damageType, uint16 damagePts, Direction srcDir);
};
 
} // End of namespace Ultima8
} // End of namespace Ultima
 
#endif