global.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_HEADER__
#define __GLOBAL_HEADER__

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

#include "global_objects.h"
#include "global_actors.h"
#include "global_skills.h"

namespace hoa_global {

extern GameGlobal* GlobalManager;

extern bool GLOBAL_DEBUG;

const int32 GLOBAL_BAD_EVENT = -5555555;

class GlobalEventGroup {
  friend class GameGlobal;

public:
  ~GlobalEventGroup() {}

  bool DoesEventExist(const std::string& event_name)
    { if (_events.find(event_name) != _events.end()) return true; else return false; }

  void AddNewEvent(const std::string& event_name, int32 event_value = 0);

  int32 GetEvent(const std::string& event_name);

  void SetEvent(const std::string& event_name, int32 event_value);

  uint32 GetNumberEvents() const
    { return _events.size(); }

  std::string GetGroupName() const
    { return _group_name; }

private:
  std::string _group_name;

  std::map<std::string, int32> _events;

  GlobalEventGroup(const std::string& group_name) :
    _group_name(group_name) {}


  GlobalEventGroup(const GlobalEventGroup& geg);
  GlobalEventGroup& operator=(const GlobalEventGroup& geg);
}; // class GlobalEventGroup


class GameGlobal : public hoa_utils::Singleton<GameGlobal> {
  friend class hoa_utils::Singleton<GameGlobal>;
  friend class GlobalItem;
  friend class GlobalWeapon;
  friend class GlobalArmor;
  friend class GlobalSkill;

public:
  ~GameGlobal();

  bool SingletonInitialize();

  void ClearAllData();



  void AddCharacter(uint32 id);

  void AddCharacter(GlobalCharacter* ch);

  void RemoveCharacter(uint32 id);

  GlobalCharacter* GetCharacter(uint32 id);

  bool IsCharacterInParty(uint32 id)
    { if (_characters.find(id) != _characters.end()) return true; else return false; }



  void AddToInventory(uint32 obj_id, uint32 obj_count = 1);

  void AddToInventory(GlobalObject* object);

  void RemoveFromInventory(uint32 obj_id);

  GlobalObject* RetrieveFromInventory(uint32 obj_id, bool all_counts = false);

  void IncrementObjectCount(uint32 obj_id, uint32 obj_count = 1);

  void DecrementObjectCount(uint32 obj_id, uint32 obj_count = 1);

  bool IsObjectInInventory(uint32 id)
    { if (_inventory.find(id) != _inventory.end()) return true; else return false; }



  bool DoesEventGroupExist(const std::string& group_name) const
    { if (_event_groups.find(group_name) != _event_groups.end()) return true; else return false; }

  bool DoesEventExist(const std::string& group_name, const std::string& event_name) const;

  void AddNewEventGroup(const std::string& group_name);

  GlobalEventGroup* GetEventGroup(const std::string& group_name) const;

  int32 GetEventValue(const std::string& group_name, const std::string& event_name) const;

  uint32 GetNumberEventGroups() const
    { return _event_groups.size(); }

  uint32 GetNumberEvents(const std::string& group_name) const;

  void AddDrunes(uint32 amount)
    { _drunes += amount; }

  void SubtractDrunes(uint32 amount)
    { if (_drunes >= amount) _drunes -= amount; }

  uint32 AverageActivePartyExperienceLevel() const
    { return static_cast<uint32>(_active_party.AverageExperienceLevel()); }

  void SetLocation(const hoa_utils::ustring& location_name, const std::string& location_graphic_filename);

  bool SaveGame(std::string& filename);

  bool LoadGame(const std::string& filename);


  void SetDrunes(uint32 amount)
    { _drunes = amount; }

  uint32 GetDrunes() const
    { return _drunes; }

  hoa_utils::ustring& GetLocationName()
    { return _location_name; }

  hoa_video::StillImage& GetLocationGraphic()
    { return _location_graphic; }

  std::vector<GlobalCharacter*>* GetCharacterOrder()
    { return &_character_order; };

  GlobalParty* GetActiveParty()
    { return &_active_party; }

  std::map<uint32, GlobalObject*>* GetInventory()
    { return &_inventory; }

  std::vector<GlobalItem*>* GetInventoryItems()
    { return &_inventory_items; }

  std::vector<GlobalWeapon*>* GetInventoryWeapons()
    { return &_inventory_weapons; }

  std::vector<GlobalArmor*>* GetInventoryHeadArmor()
    { return &_inventory_head_armor; }

  std::vector<GlobalArmor*>* GetInventoryTorsoArmor()
    { return &_inventory_torso_armor; }

  std::vector<GlobalArmor*>* GetInventoryArmArmor()
    { return &_inventory_arm_armor; }

  std::vector<GlobalArmor*>* GetInventoryLegArmor()
    { return &_inventory_leg_armor; }

  std::vector<GlobalShard*>* GetInventoryShards()
    { return &_inventory_shards; }

  std::vector<GlobalKeyItem*>* GetInventoryKeyItems()
    { return &_inventory_key_items; }

private:
  GameGlobal();

  uint32 _drunes;

  hoa_utils::ustring _location_name;

  hoa_video::StillImage _location_graphic;

  std::map<uint32, GlobalCharacter*> _characters;

  std::vector<GlobalCharacter*> _character_order;

  GlobalParty _active_party;

  std::map<uint32, GlobalObject*> _inventory;

  std::vector<GlobalItem*>    _inventory_items;
  std::vector<GlobalWeapon*>  _inventory_weapons;
  std::vector<GlobalArmor*>   _inventory_head_armor;
  std::vector<GlobalArmor*>   _inventory_torso_armor;
  std::vector<GlobalArmor*>   _inventory_arm_armor;
  std::vector<GlobalArmor*>   _inventory_leg_armor;
  std::vector<GlobalShard*>   _inventory_shards;
  std::vector<GlobalKeyItem*> _inventory_key_items;


  hoa_script::ReadScriptDescriptor _items_script;
  hoa_script::ReadScriptDescriptor _weapons_script;
  hoa_script::ReadScriptDescriptor _head_armor_script;
  hoa_script::ReadScriptDescriptor _torso_armor_script;
  hoa_script::ReadScriptDescriptor _arm_armor_script;
  hoa_script::ReadScriptDescriptor _leg_armor_script;
  // hoa_script::ReadScriptDescriptor _shard_script;
  // hoa_script::ReadScriptDescriptor _key_items_script;
  hoa_script::ReadScriptDescriptor _attack_skills_script;
  hoa_script::ReadScriptDescriptor _defend_skills_script;
  hoa_script::ReadScriptDescriptor _support_skills_script;

  std::map<std::string, GlobalEventGroup*> _event_groups;

  // ----- Private methods

  template <class T> bool _RemoveFromInventory(uint32 obj_id, std::vector<T*>& inv);

  template <class T> T* _RetrieveFromInventory(uint32 obj_id, std::vector<T*>& inv, bool all_counts);

  template <class T> void _SaveInventory(hoa_script::WriteScriptDescriptor& file, std::string name, std::vector<T*>& inv);

  void _SaveCharacter(hoa_script::WriteScriptDescriptor& file, GlobalCharacter* character, bool last);

  void _SaveEvents(hoa_script::WriteScriptDescriptor& file, GlobalEventGroup* event_group);

  void _LoadInventory(hoa_script::ReadScriptDescriptor& file, std::string category_name);

  void _LoadCharacter(hoa_script::ReadScriptDescriptor& file, uint32 id);

  void _LoadEvents(hoa_script::ReadScriptDescriptor& file, const std::string& group_name);
}; // class GameGlobal : public hoa_utils::Singleton<GameGlobal>

//-----------------------------------------------------------------------------
// Template Function Definitions
//-----------------------------------------------------------------------------

template <class T> bool GameGlobal::_RemoveFromInventory(uint32 obj_id, std::vector<T*>& inv) {
  for (typename std::vector<T*>::iterator i = inv.begin(); i != inv.end(); i++) {
    if ((*i)->GetID() == obj_id) {
      delete _inventory[obj_id];
      _inventory.erase(obj_id);
      inv.erase(i);
      return true;
    }
  }

  return false;
} // template <class T> bool GameGlobal::_RemoveFromInventory(uint32 obj_id, std::vector<T*>& inv)



template <class T> T* GameGlobal::_RetrieveFromInventory(uint32 obj_id, std::vector<T*>& inv, bool all_counts) {
  for (typename std::vector<T*>::iterator i = inv.begin(); i != inv.end(); i++) {
    if ((*i)->GetID() == obj_id) {
      T* return_object;
      if (all_counts == true || _inventory[obj_id]->GetCount() == 1) {
        return_object = *i;
        _inventory.erase(obj_id);
        inv.erase(i);
      }
      else {
        return_object = new T(**i);
        return_object->SetCount(1);
        _inventory[obj_id]->DecrementCount();
      }
      return return_object;
    }
  }

  return NULL;
} // template <class T> T* GameGlobal::_RetrieveFromInventory(uint32 obj_id, std::vector<T*>& inv, bool all_counts)



template <class T> void GameGlobal::_SaveInventory(hoa_script::WriteScriptDescriptor& file, std::string name, std::vector<T*>& inv) {
  if (file.IsFileOpen() == false) {
    if (GLOBAL_DEBUG)
      std::cerr << "GLOBAL WARNING: GameGlobal::_SaveInventory() failed because the file passed to it was not open" << std::endl;
    return;
  }

  file.InsertNewLine();
  file.WriteLine(name + " = {");
  for (uint32 i = 0; i < inv.size(); i++) {
    if (i == 0)
      file.WriteLine("\t", false);
    else
      file.WriteLine(", ", false);
    file.WriteLine("[" + NumberToString(inv[i]->GetID()) + "] = "
      + NumberToString(inv[i]->GetCount()), false);
  }
  file.InsertNewLine();
  file.WriteLine("}");
} // template <class T> void GameGlobal::_SaveInventory(hoa_script::WriteScriptDescriptor& file, std::string name, std::vector<T*>& inv)

} // namespace hoa_global

#endif

---