global_skills.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_SKILLS_HEADER__
#define __GLOBAL_SKILLS_HEADER__

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

#include "global_actors.h"

namespace hoa_global {

namespace private_global {

const uint32 MAX_ATTACK_ID   = 10000;
const uint32 MAX_DEFEND_ID   = 20000;
const uint32 MAX_SUPPORT_ID  = 30000;

} // namespace private_global

enum GLOBAL_ELEMENTAL {
  GLOBAL_ELEMENTAL_INVALID    = 0,
  GLOBAL_ELEMENTAL_FIRE       = 1,
  GLOBAL_ELEMENTAL_WATER      = 2,
  GLOBAL_ELEMENTAL_VOLT       = 3,
  GLOBAL_ELEMENTAL_EARTH      = 4,
  GLOBAL_ELEMENTAL_SLICING    = 5,
  GLOBAL_ELEMENTAL_SMASHING   = 6,
  GLOBAL_ELEMENTAL_MAULING    = 7,
  GLOBAL_ELEMENTAL_PIERCING   = 8,
  GLOBAL_ELEMENTAL_TOTAL      = 9
};

enum GLOBAL_STATUS {
  GLOBAL_STATUS_INVALID    = -1,
  GLOBAL_STATUS_POISON     = 0,
  GLOBAL_STATUS_SLOW       = 1,
  GLOBAL_STATUS_TOTAL      = 2
};

enum GLOBAL_INTENSITY {
  GLOBAL_INTENSITY_INVALID       = -5,
  GLOBAL_INTENSITY_NEG_EXTREME   = -4,
  GLOBAL_INTENSITY_NEG_GREATER   = -3,
  GLOBAL_INTENSITY_NEG_MODERATE  = -2,
  GLOBAL_INTENSITY_NEG_LESSER    = -1,
  GLOBAL_INTENSITY_NEUTRAL       = 0,
  GLOBAL_INTENSITY_POS_LESSER    = 1,
  GLOBAL_INTENSITY_POS_MODERATE  = 2,
  GLOBAL_INTENSITY_POS_GREATER   = 3,
  GLOBAL_INTENSITY_POS_EXTREME   = 4,
  GLOBAL_INTENSITY_TOTAL         = 5
};

enum GLOBAL_SKILL {
  GLOBAL_SKILL_INVALID  = -1,
  GLOBAL_SKILL_ATTACK   =  0,
  GLOBAL_SKILL_DEFEND   =  1,
  GLOBAL_SKILL_SUPPORT  =  2,
  GLOBAL_SKILL_TOTAL    =  3
};


class GlobalElementalEffect {
public:
  GlobalElementalEffect() :
    _type(GLOBAL_ELEMENTAL_INVALID), _intensity(GLOBAL_INTENSITY_NEUTRAL) {}

  ~GlobalElementalEffect()
    {}

  GLOBAL_ELEMENTAL GetType() const
    { return _type; }

  GLOBAL_INTENSITY GetIntensity() const
    { return _intensity; }

  void SetIntensity(GLOBAL_INTENSITY intensity)
    { _intensity = intensity; }

  void IncrementIntensity(uint8 amount = 1);
  
  void DecrementIntensity(uint8 amount = 1);

private:
  GLOBAL_ELEMENTAL _type;

  GLOBAL_INTENSITY _intensity;
}; // class GlobalElementalEffect



class GlobalStatusEffect {
public:
  GlobalStatusEffect(GLOBAL_STATUS type, GLOBAL_INTENSITY intensity = GLOBAL_INTENSITY_NEUTRAL) :
    _type(type), _intensity(intensity) {}

  ~GlobalStatusEffect()
    {}

  // TODO: Return a pointer from image stored in GameGlobal
  // hoa_video::StillImage* GetIconImage();


  GLOBAL_STATUS GetType() const
    { return _type; }

  GLOBAL_INTENSITY GetIntensity() const
    { return _intensity; }

  void SetIntensity(GLOBAL_INTENSITY intensity)
    { _intensity = intensity; }

  bool IncrementIntensity(uint8 amount);
  
  bool DecrementIntensity(uint8 amount);

private:
  GLOBAL_STATUS _type;

  GLOBAL_INTENSITY _intensity;
}; // class GlobalStatusEffect


class GlobalSkill {
public:
  GlobalSkill(uint32 id);

  ~GlobalSkill();

  bool IsExecutableInBattle() const
    { return ((_usage == GLOBAL_USE_BATTLE) || (_usage == GLOBAL_USE_ALL)); }

  bool IsExecutableInMenu() const
    { return ((_usage == GLOBAL_USE_MENU) || (_usage == GLOBAL_USE_ALL)); }
  //@

  void BattleExecute(hoa_battle::private_battle::BattleActor* target, hoa_battle::private_battle::BattleActor* instigator);

  void MenuExecute(GlobalCharacter* target, GlobalCharacter* instigator);

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

  hoa_utils::ustring GetDescription() const
    { return _description; }

  uint32 GetID() const
    { return _id; }

  uint8 GetType() const
    { return _type; }

  uint32 GetSPRequired() const
    { return _sp_required; }

  uint32 GetWarmupTime() const
    { return _warmup_time; }

  uint32 GetCooldownTime() const
    { return _cooldown_time; }

  GLOBAL_USE GetUsage() const
    { return _usage; }

  GLOBAL_TARGET GetTargetType() const
    { return _target_type; }

  bool IsTargetAlly() const
    { return _target_ally; }
    
//  std::vector<GlobalElementalEffect*>& GetElementalEffects() const
//    { return _elemental_effects; }

//  std::vector<std::pair<float, GlobalStatusEffect*> >& GetStatusEffects() const
//    { return _status_effects; }

private:
  hoa_utils::ustring _name;

  hoa_utils::ustring _description;

  uint32 _id;

  GLOBAL_SKILL _type;

  uint32 _sp_required;

  uint32 _warmup_time;

  uint32 _cooldown_time;

  GLOBAL_USE _usage;

  GLOBAL_TARGET _target_type;

  bool _target_ally;

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

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

  ScriptObject* _battle_execute_function;

  ScriptObject* _menu_execute_function;
}; // class GlobalSkill

} // namespace hoa_global

#endif // __GLOBAL_SKILLS_HEADER__

---