global_objects.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_OBJECTS_HEADER__
#define __GLOBAL_OBJECTS_HEADER__

#include "defs.h"
#include "utils.h"
#include "image.h"
#include "script.h"

#include "global_actors.h"

namespace hoa_global {

namespace private_global {

const uint32 MAX_ITEM_ID         = 10000;
const uint32 MAX_WEAPON_ID       = 20000;
const uint32 MAX_HEAD_ARMOR_ID   = 30000;
const uint32 MAX_TORSO_ARMOR_ID  = 40000;
const uint32 MAX_ARM_ARMOR_ID    = 50000;
const uint32 MAX_LEG_ARMOR_ID    = 60000;
const uint32 MAX_SHARD_ID        = 70000;
const uint32 MAX_KEY_ITEM_ID     = 80000;

} // namespace private_global

enum GLOBAL_OBJECT {
  GLOBAL_OBJECT_INVALID     = -1,
  GLOBAL_OBJECT_ITEM        =  0,
  GLOBAL_OBJECT_WEAPON      =  1,
  GLOBAL_OBJECT_HEAD_ARMOR  =  2,
  GLOBAL_OBJECT_TORSO_ARMOR =  3,
  GLOBAL_OBJECT_ARM_ARMOR   =  4,
  GLOBAL_OBJECT_LEG_ARMOR   =  5,
  GLOBAL_OBJECT_SHARD       =  6,
  GLOBAL_OBJECT_KEY_ITEM    =  7,
  GLOBAL_OBJECT_TOTAL       =  8
};

GlobalObject* GlobalCreateNewObject(uint32 id, uint32 count = 1);


class GlobalObject {
public:
  GlobalObject() :
    _id(0), _count(0) {}

  GlobalObject(uint32 id, uint32 count) :
    _id(id), _count(count) {}

  virtual ~GlobalObject()
    {}

  virtual GLOBAL_OBJECT GetObjectType() const = 0;

  void IncrementCount(uint32 count = 1)
    { _count += count; }

  void DecrementCount(uint32 count = 1)
    { if (count > _count) _count = 0; else _count -= count; }


  uint32 GetID() const
    { return _id; }

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

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

  uint32 GetCount() const
    { return _count; }

  void SetCount(uint32 count)
    { _count = count; }

  uint32 GetPrice() const
    { return _price; }

  const hoa_video::StillImage& GetIconImage() const
    { return _icon_image; }

protected:
  uint32 _id;

  hoa_utils::ustring _name;

  hoa_utils::ustring _description;

  uint32 _count;

  uint32 _price;

  hoa_video::StillImage _icon_image;
}; // class GlobalObject


class GlobalItem : public GlobalObject {
public:
  GlobalItem(uint32 id, uint32 count = 1);

  ~GlobalItem();

  GLOBAL_OBJECT GetObjectType() const
    { return GLOBAL_OBJECT_ITEM; }

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

  bool IsUsableInMenu()
    { return ((_usage == GLOBAL_USE_MENU) || (_usage == GLOBAL_USE_ALL)); }

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

  void MenuUse(GlobalCharacter* target);


  GLOBAL_USE GetUsage() const
    { return _usage; }

  GLOBAL_TARGET GetTargetType() const
    { return _target_type; }

  bool IsTargetAlly() const
    { return _target_ally; }

private:
  GLOBAL_USE _usage;

  GLOBAL_TARGET _target_type;

  bool _target_ally;

  ScriptObject* _battle_use_function;

  ScriptObject* _menu_use_function;
}; // class GlobalItem : public GlobalObject


class GlobalWeapon : public GlobalObject {
public:
  GlobalWeapon(uint32 id, uint32 count = 1);

  ~GlobalWeapon()
    {}

  GLOBAL_OBJECT GetObjectType() const
    { return GLOBAL_OBJECT_WEAPON; }

  uint32 GetPhysicalAttack() const
    { return _physical_attack; }

  uint32 GetMetaphysicalAttack() const
    { return _metaphysical_attack; }

  uint32 GetUsableBy() const
    { return _usable_by; }

private:
  uint32 _physical_attack;

  uint32 _metaphysical_attack;

  uint32 _usable_by;

  // TODO: Add elementals, status, and shard sockets to weapons
  // std::map<GLOBAL_ELEMENTAL, uint32> _elemental_bonuses;
  // std::map<GLOBAL_STATUS, uint32> _status_bonuses;
  // std::vector<GlobalShard*> _sockets;
}; // class GlobalWeapon : public GlobalObject


class GlobalArmor : public GlobalObject {
public:
  GlobalArmor(uint32 id, uint32 count = 1);

  ~GlobalArmor()
    {}

  GLOBAL_OBJECT GetObjectType() const;

  uint32 GetPhysicalDefense() const
    { return _physical_defense; }

  uint32 GetMetaphysicalDefense() const
    { return _metaphysical_defense; }

  uint32 GetUsableBy() const
    { return _usable_by; }

private:
  uint32 _physical_defense;

  uint32 _metaphysical_defense;

  uint32 _usable_by;

  // TODO: Add elementals, status, and shard sockets to armor
  // std::map<GLOBAL_ELEMENTAL, uint32> _elemental_bonuses;
  // std::map<GLOBAL_STATUS, uint32> _status_bonuses;
  // std::vector<GlobalShard*> _sockets;
}; // class GlobalArmor : public GlobalObject


class GlobalShard : public GlobalObject {
public:
  GlobalShard(uint32 id, uint32 count = 1) :
    GlobalObject(id, count) {}

  GLOBAL_OBJECT GetObjectType() const
    { return GLOBAL_OBJECT_SHARD; }
}; // class GlobalShard : public GlobalObject


class GlobalKeyItem : public GlobalObject {
public:
  GlobalKeyItem(uint32 id, uint32 count = 1) :
    GlobalObject(id, count) {}

  GLOBAL_OBJECT GetObjectType() const
    { return GLOBAL_OBJECT_KEY_ITEM; }
}; // class GlobalKeyItem : public GlobalObject

} // namespace hoa_global

#endif // __GLOBAL_OBJECTS_HEADER__

---