global_actors.h

Go to the documentation of this file.

//            Copyright (C) 2004-2007 by The Allacrost Project
//                         All Rights Reserved
//
// This code is licensed under the GNU GPL version 2. It is free software
// and you may modify it and/or redistribute it under the terms of this license.
// See http://www.gnu.org/copyleft/gpl.html for details.

#ifndef __GLOBAL_ACTORS_HEADER__
#define __GLOBAL_ACTORS_HEADER__

#include <utility>

#include "defs.h"
#include "utils.h"

namespace hoa_global {

enum GLOBAL_TARGET {
  GLOBAL_TARGET_INVALID      = -1,
  GLOBAL_TARGET_ATTACK_POINT =  0,
  GLOBAL_TARGET_ACTOR        =  1,
  GLOBAL_TARGET_PARTY        =  2,
  GLOBAL_TARGET_TOTAL        =  3
};

enum GLOBAL_USE {
  GLOBAL_USE_INVALID = -1,
  GLOBAL_USE_MENU    =  0,
  GLOBAL_USE_BATTLE  =  1,
  GLOBAL_USE_ALL     =  2,
  GLOBAL_USE_TOTAL   =  3
};

const uint32 GLOBAL_POSITION_HEAD  = 0;
const uint32 GLOBAL_POSITION_TORSO = 1;
const uint32 GLOBAL_POSITION_ARMS  = 2;
const uint32 GLOBAL_POSITION_LEGS  = 3;

const uint32 GLOBAL_CHARACTER_INVALID     = 0x00000000;
const uint32 GLOBAL_CHARACTER_CLAUDIUS    = 0x00000001;
const uint32 GLOBAL_CHARACTER_LAILA       = 0x00000002;
const uint32 GLOBAL_CHARACTER_ALL         = 0xFFFFFFFF;


class GlobalTarget {
public:
  GlobalTarget()
    {}

  virtual ~GlobalTarget()
    {}

  virtual GLOBAL_TARGET GetTargetType() = 0;
}; // class GlobalTarget


class GlobalAttackPoint : public GlobalTarget {
  friend class GlobalActor;
  friend class GlobalCharacter;
  friend class GlobalEnemy;

public:
  GlobalAttackPoint(GlobalActor* actor_owner) :
    _actor_owner(actor_owner) {}

  ~GlobalAttackPoint()
    {}

  GLOBAL_TARGET GetTargetType()
    { return GLOBAL_TARGET_ATTACK_POINT; }


  hoa_utils::ustring& GetName()
    { return _name; }

  uint16 GetXPosition() const
    { return _x_position; }

  uint16 GetYPosition() const
    { return _y_position; }

  float GetFortitudeModifier() const
    { return _fortitude_modifier; }

  float GetProtectionModifier() const
    { return _protection_modifier; }

  float GetEvadeModifier() const
    { return _evade_modifier; }

  GlobalActor* GetActorOwner() const
    { return _actor_owner; }

  uint16 GetTotalPhysicalDefense() const
    { return _total_physical_defense; }

  uint16 GetTotalMetaphysicalDefense() const
    { return _total_metaphysical_defense; }

  float GetTotalEvadeRating() const
    { return _total_evade_rating; }

private:
  hoa_utils::ustring _name;

  uint16 _x_position, _y_position;

  float _fortitude_modifier;
  float _protection_modifier;
  float _evade_modifier;

  GlobalActor* _actor_owner;

  uint16 _total_physical_defense;
  uint16 _total_metaphysical_defense;
  float _total_evade_rating;

  // TODO: Add status and elemental effects to attack points
  // std::vector<std::pair<float, GlobalStatusEffect*> > _status_weaknesses;

  bool _LoadData(hoa_script::ReadScriptDescriptor& script);
}; // class GlobalAttackPoint : public GlobalTarget


class GlobalActor : public GlobalTarget {
public:
  GlobalActor()
    {}

  virtual ~GlobalActor();

  GLOBAL_TARGET GetTargetType()
    { return GLOBAL_TARGET_ACTOR; }

  virtual bool IsCharacter() = 0;

  bool IsAlive() const
    { return (_hit_points != 0); }

  uint32 GetID() const
    { return _id; }

  hoa_utils::ustring& GetName()
    { return _name; }

  std::string& GetFilename()
    { return _filename; }

  uint32 GetHitPoints() const
    { return _hit_points; }

  uint32 GetMaxHitPoints() const
    { return _max_hit_points; }

  uint32 GetSkillPoints() const
    { return _skill_points; }

  uint32 GetMaxSkillPoints() const
    { return _max_skill_points; }

  uint32 GetExperienceLevel() const
    { return _experience_level; }

  uint32 GetExperiencePoints() const
    { return _experience_points; }

  uint32 GetStrength() const
    { return _strength; }

  uint32 GetVigor() const
    { return _vigor; }

  uint32 GetFortitude() const
    { return _fortitude; }

  uint32 GetProtection() const
    { return _protection; }

  uint32 GetAgility() const
    { return _agility; }

  float GetEvade() const
    { return _evade; }

  uint32 GetTotalPhysicalAttack() const
    { return _total_physical_attack; }

  uint32 GetTotalMetaphysicalAttack() const
    { return _total_metaphysical_attack; }

  uint32 GetTotalPhysicalDefense(uint32 index) const;

  uint32 GetTotalMetaphysicalDefense(uint32 index) const;

  float GetTotalEvadeRating(uint32 index) const;

  GlobalWeapon* GetWeaponEquipped() const
    { return _weapon_equipped; }

  std::vector<GlobalArmor*>* GetArmorEquipped()
    { return &_armor_equipped; }

  GlobalArmor* GetArmorEquipped(uint32 index) const;

  std::vector<GlobalAttackPoint*>* GetAttackPoints()
    { return &_attack_points; }

  GlobalAttackPoint* GetAttackPoint(uint32 index) const;

  std::map<uint32, GlobalSkill*>* GetSkills()
    { return &_skills; }

  GlobalSkill* GetSkill(uint32 skill_id) const;

  GlobalSkill* GetSkill(const GlobalSkill* skill) const;

  // TODO: elemental and status effects not yet available in game
//  std::vector<GlobalElementalEffect*>& GetElementalAttackBonuses()
//    { return _elemental_attack_bonuses; }
// 
//  std::vector<std::pair<float, GlobalStatusEffect*> >& GetStatusAttackBonuses()
//    { return _status_attack_bonuses; }
// 
//  std::vector<GlobalElementalEffect*>& GetElementalDefenseBonuses()
//    { return _elemental_defense_bonuses; }
// 
//  std::vector<std::pair<float, GlobalStatusEffect*> >& GetStatusDefenseBonuses()
//    { return _status_defense_bonuses; }

  void SetExperienceLevel(uint32 xp_level)
    { _experience_level = xp_level; }

  void SetExperiencePoints(uint32 xp_points)
    { _experience_points = xp_points; }

  void SetHitPoints(uint32 hp)
    { if (hp > _max_hit_points) _hit_points = _max_hit_points; else _hit_points = hp; }

  void SetMaxHitPoints(uint32 hp)
    { _max_hit_points = hp; if (_hit_points > _max_hit_points) _hit_points = _max_hit_points; }

  void SetSkillPoints(uint32 sp)
    { if (sp > _max_skill_points) _skill_points = _max_skill_points; else _skill_points = sp; }

  void SetMaxSkillPoints(uint32 sp)
    { _max_skill_points = sp; if (_skill_points > _max_skill_points) _skill_points = _max_skill_points; }

  void SetStrength(uint32 st)
    { _strength = st; _CalculateAttackRatings(); }

  void SetVigor(uint32 vi)
    { _vigor = vi; _CalculateAttackRatings(); }

  void SetFortitude(uint32 fo)
    { _fortitude = fo; _CalculateDefenseRatings(); }

  void SetProtection(uint32 pr)
    { _protection = pr; _CalculateDefenseRatings(); }

  void SetAgility(uint32 ag)
    { _agility = ag; }

  void SetEvade(float ev)
    { _evade = ev; _CalculateEvadeRatings(); }


  void AddHitPoints(uint32 hp)
    { _hit_points += hp; if (_hit_points > _max_hit_points) _hit_points = _max_hit_points; }

  void SubHitPoints(uint32 hp)
    { if (hp < _hit_points) _hit_points -= hp; else _hit_points = 0; }

  void AddMaxHitPoints(uint32 hp)
    { _max_hit_points += hp; _hit_points += hp; }

  void AddSkillPoints(uint32 sp)
    { _skill_points += sp; if (_skill_points > _max_skill_points) _skill_points = _max_skill_points; }

  void SubSkillPoints(uint32 sp)
    { if (sp < _skill_points) _skill_points -= sp; else _skill_points = 0; }

  void AddMaxSkillPoints(uint32 sp)
    { _max_skill_points += sp; _skill_points += sp; }

  void AddStrength(uint32 st)
    { _strength += st; _CalculateAttackRatings(); }

  void AddVigor(uint32 vi)
    { _vigor += vi; _CalculateAttackRatings(); }

  void AddFortitude(uint32 fo)
    { _fortitude += fo; _CalculateDefenseRatings(); }

  void AddProtection(uint32 pr)
    { _protection += pr; _CalculateDefenseRatings(); }

  void AddAgility(uint32 ag)
    { _agility += ag; }

  void AddEvade(float ev)
    { _evade += ev; _CalculateEvadeRatings(); }

  GlobalWeapon* EquipWeapon(GlobalWeapon* weapon);

  GlobalArmor* EquipArmor(GlobalArmor* armor, uint32 index);

  virtual void AddSkill(uint32 skill_id) = 0;

protected:
  uint32 _id;

  hoa_utils::ustring _name;

  std::string _filename;



  uint32 _experience_level;

  uint32 _experience_points;

  uint32 _hit_points;

  uint32 _max_hit_points;

  uint32 _skill_points;

  uint32 _max_skill_points;

  uint32 _strength;

  uint32 _vigor;

  uint32 _fortitude;

  uint32 _protection;

  uint32 _agility;

  float _evade;

  uint32 _total_physical_attack;

  uint32 _total_metaphysical_attack;

  std::vector<GlobalAttackPoint*> _attack_points;

  GlobalWeapon* _weapon_equipped;

  std::vector<GlobalArmor*> _armor_equipped;

  std::map<uint32, GlobalSkill*> _skills;

//  std::vector<GlobalElementalEffect*> _elemental_attack_bonuses;

//  std::vector<std::pair<float, GlobalStatusEffect*> > _status_attack_bonuses;

//  std::vector<GlobalElementalEffect*> _elemental_defense_bonuses;

//  std::vector<std::pair<float, GlobalStatusEffect*> > _status_defense_bonuses;

  void _CalculateAttackRatings();

  void _CalculateDefenseRatings();

  void _CalculateEvadeRatings();
}; // class GlobalActor : public GlobalTarget


class GlobalCharacterGrowth {
  friend class GlobalCharacter;
  friend void hoa_defs::BindEngineToLua();

public:
  GlobalCharacterGrowth(GlobalCharacter* owner) :
    _character_owner(owner) {}

  ~GlobalCharacterGrowth();

  void AcknowledgeGrowth();


  bool IsExperienceLevelGained() const
    { return _experience_level_gained; }

  bool IsGrowthDetected() const
    { return _growth_detected; }

  uint32 GetHitPointsGrowth() const
    { return _hit_points_growth; }

  uint32 GetSkillPointsGrowth() const
    { return _skill_points_growth; }

  uint32 GetStrengthGrowth() const
    { return _strength_growth; }

  uint32 GetVigorGrowth() const
    { return _vigor_growth; }

  uint32 GetFortitudeGrowth() const
    { return _fortitude_growth; }

  uint32 GetProtectionGrowth() const
    { return _protection_growth; }

  float GetEvadeGrowth() const
    { return _evade_growth; }

  std::list<GlobalSkill*>* GetSkillsLearned()
    { return &_skills_learned; }

private:
  GlobalCharacter* _character_owner;

  bool _experience_level_gained;

  bool _growth_detected;

  uint32 _experience_for_next_level;

  uint32 _experience_for_last_level;

  uint32 _hit_points_growth;
  uint32 _skill_points_growth;
  uint32 _strength_growth;
  uint32 _vigor_growth;
  uint32 _fortitude_growth;
  uint32 _protection_growth;
  uint32 _agility_growth;
  float _evade_growth;

  std::deque<std::pair<uint32, uint32> > _hit_points_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _skill_points_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _strength_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _vigor_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _fortitude_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _protection_periodic_growth;
  std::deque<std::pair<uint32, uint32> > _agility_periodic_growth;
  std::deque<std::pair<uint32, float> > _evade_periodic_growth;

  std::list<GlobalSkill*> _skills_learned;

  void _AddSkill(uint32 skill_id);

  void _CheckForGrowth();

  void _ConstructPeriodicGrowth();

  void _DetermineNextLevelExperience();
}; // class GlobalCharacterGrowth


class GlobalCharacter : public GlobalActor {
  friend class GlobalCharacterGrowth;

public:
  GlobalCharacter(uint32 id, bool initial = true);

  virtual ~GlobalCharacter();

  bool IsCharacter()
    { return true; }


  uint32 GetExperienceForNextLevel() const
    { return _growth._experience_for_next_level; }

  GlobalCharacterGrowth* GetGrowth()
    { return &_growth; }

  GlobalArmor* GetHeadArmorEquipped()
    { return _armor_equipped[0]; }

  GlobalArmor* GetTorsoArmorEquipped()
    { return _armor_equipped[1]; }

  GlobalArmor* GetArmArmorEquipped()
    { return _armor_equipped[2]; }

  GlobalArmor* GetLegArmorEquipped()
    { return _armor_equipped[3]; }

  std::vector<GlobalSkill*>* GetAttackSkills()
    { return &_attack_skills; }

  std::vector<GlobalSkill*>* GetDefenseSkills()
    { return &_defense_skills; }

  std::vector<GlobalSkill*>* GetSupportSkills()
    { return &_support_skills; }

  void AddSkill(uint32 skill_id);

  bool AddExperiencePoints(uint32 xp);

  GlobalArmor* EquipHeadArmor(GlobalArmor* armor)
    { return EquipArmor(armor, GLOBAL_POSITION_HEAD); }

  GlobalArmor* EquipTorsoArmor(GlobalArmor* armor)
    { return EquipArmor(armor, GLOBAL_POSITION_TORSO); }

  GlobalArmor* EquipArmArmor(GlobalArmor* armor)
    { return EquipArmor(armor, GLOBAL_POSITION_ARMS); }

  GlobalArmor* EquipLegArmor(GlobalArmor* armor)
    { return EquipArmor(armor, GLOBAL_POSITION_LEGS); }

  // TEMP: image accessor functions
  void AddBattleAnimation(const std::string & name, hoa_video::AnimatedImage anim)
    { _battle_animation[name] = anim; }

  hoa_video::AnimatedImage* RetrieveBattleAnimation(const std::string & name)
    { return &_battle_animation[name]; }

  std::vector<hoa_video::StillImage>* GetBattlePortraits()
    { return &_battle_portraits; }

protected:
  std::vector<GlobalSkill*> _attack_skills;
  std::vector<GlobalSkill*> _defense_skills;
  std::vector<GlobalSkill*> _support_skills;

  GlobalCharacterGrowth _growth;

  std::vector<hoa_video::StillImage> _map_frames_standard;

  hoa_video::StillImage _map_portrait_standard;

  std::map<std::string, hoa_video::AnimatedImage> _battle_animation;

  std::vector<hoa_video::StillImage> _battle_portraits;

  hoa_video::StillImage _menu_portrait;
}; // class GlobalCharacter : public GlobalActor


class GlobalEnemy : public GlobalActor {
public:
  GlobalEnemy(uint32 id);

  ~GlobalEnemy();

  bool IsCharacter()
    { return false; }

  void AddSkill(uint32 skill_id);

  void Initialize(uint32 xp_level);

  void DetermineDroppedObjects(std::vector<GlobalObject*>& objects);


  uint32 GetSpriteHeight() const
    { return _sprite_height; }

  uint32 GetSpriteWidth() const
    { return _sprite_width; }

  uint32 GetDrunesDropped() const
    { return _drunes_dropped; }

  std::vector<hoa_video::StillImage>* GetBattleSpriteFrames()
    { return &_battle_sprite_frames; }

protected:
  uint32 _sprite_width, _sprite_height;

  float _growth_hit_points;
  float _growth_skill_points;
  float _growth_experience_points;
  float _growth_strength;
  float _growth_vigor;
  float _growth_fortitude;
  float _growth_protection;
  float _growth_agility;
  float _growth_evade;
  float _growth_drunes;

  uint32 _drunes_dropped;

  std::vector<uint32> _dropped_objects;
  std::vector<float> _dropped_chance;
  std::vector<uint32> _dropped_level_required;

  std::map<uint32, uint32> _skill_set;

  std::vector<hoa_video::StillImage> _battle_sprite_frames;
}; // class GlobalEnemy : public GlobalActor


class GlobalParty : public GlobalTarget {
public:
  GlobalParty(bool allow_duplicates = false) :
    _allow_duplicates(allow_duplicates) {}

  ~GlobalParty()
    {}

  void AddActor(GlobalActor* actor, int32 index = -1);

  GlobalActor* RemoveActorAtIndex(uint32 index);

  GlobalActor* RemoveActorByID(uint32 id);

  void RemoveAllActors()
    { _actors.clear(); }

  void SwapActorsByIndex(uint32 first_index, uint32 second_index);

  void SwapActorsByID(uint32 first_id, uint32 second_id);

  GlobalActor* ReplaceActorByIndex(uint32 index, GlobalActor* new_actor);

  GlobalActor* ReplaceActorByID(uint32 id, GlobalActor* new_actor);

  float AverageExperienceLevel() const;

  GlobalActor* GetActorAtIndex(uint32 index) const
    { if (index >= _actors.size()) return NULL; else return _actors[index]; }

  GlobalActor* GetActorByID(uint32 id) const;

  GLOBAL_TARGET GetTargetType()
    { return GLOBAL_TARGET_PARTY; }

  bool IsPartyEmpty() const
    { return (_actors.size() == 0); }

  bool IsAllowDuplicates() const
    { return _allow_duplicates; }

  uint32 GetPartySize() const
    { return _actors.size(); }

  std::vector<GlobalActor*>* GetAllActors()
    { return &_actors; }

private:
  std::vector<GlobalActor*> _actors;

  bool _allow_duplicates;
}; // class GlobalActorParty : public GlobalTarget

} // namespace hoa_global

#endif // __GLOBAL_ACTORS_HEADER__

---