battle.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 __BATTLE_HEADER__
#define __BATTLE_HEADER__

#include <string>
#include <vector>
#include <deque>
#include <map>

#include "utils.h"
#include "defs.h"
#include "video.h"
#include "audio.h"
#include "global.h"
#include "global_actors.h"
#include "mode_manager.h"
#include "system.h"

#include "battle_windows.h"

namespace hoa_battle {

extern bool BATTLE_DEBUG;

namespace private_battle {

extern BattleMode* current_battle;



const uint32 TILE_SIZE     = 64;
const uint32 SCREEN_LENGTH = 16;
const uint32 SCREEN_HEIGHT = 12; 

const float MONSTER_LOCATIONS[][2] =
{
  { 515.0f, 768.0f - 360.0f }, // 768 - because of reverse Y-coordinate system 
  { 494.0f, 768.0f - 450.0f },
  { 510.0f, 768.0f - 550.0f },
  { 580.0f, 768.0f - 630.0f },
  { 675.0f, 768.0f - 390.0f },
  { 655.0f, 768.0f - 494.0f },
  { 793.0f, 768.0f - 505.0f },
  { 730.0f, 768.0f - 600.0f }
};


const uint32 ACTION_TYPE_ATTACK    = 0;
const uint32 ACTION_TYPE_DEFEND    = 1;
const uint32 ACTION_TYPE_SUPPORT   = 2;
const uint32 ACTION_TYPE_ITEM      = 3;

enum CURSOR_STATE {
  CURSOR_IDLE = 0,
  CURSOR_WAIT = 1,
  CURSOR_SELECT_ATTACK_POINT = 2,
  CURSOR_SELECT_TARGET = 3,
  CURSOR_SELECT_PARTY = 4
};

const uint32 INVALID_BATTLE_ACTOR_INDEX = 999;

const uint32 MAX_INIT_WAIT_TIME = 8000;

// of item used
const uint32 ITEM_WARM_UP_TIME = 1000;

//FIX ME should be handled via the options menu
const bool ACTIVE_BATTLE_MODE = false;

float ComputeAveragePartyLevel();

class ScriptEvent {
public:
  //ScriptEvent(BattleActor* source, std::deque<BattleActor*> targets, const std::string & script_name, uint32 warm_up_time);
  ScriptEvent(BattleActor* source, BattleActor* target, hoa_global::GlobalItem* item, hoa_global::GlobalAttackPoint* attack_point = NULL, uint32 warm_up_time = ITEM_WARM_UP_TIME);
  ScriptEvent(BattleActor* source, BattleActor* target, hoa_global::GlobalSkill* skill, hoa_global::GlobalAttackPoint* attack_point = NULL);
  //ScriptEvent(BattleActor* source, std::deque<BattleActor*> targets, hoa_global::GlobalSkill* skill);

  ~ScriptEvent();

  void RunScript();


  BattleActor * GetSource()
    { return _source; }

  inline hoa_system::SystemTimer* GetWarmUpTime()
    { return &_warm_up_time; }

  inline BattleActor* GetTarget()
    { return _target; }

  inline hoa_global::GlobalItem* GetItem()
    { return _item; }

  inline hoa_global::GlobalSkill* GetSkill()
    { return _skill; }



  //hoa_global::GlobalActor * GetSource() { return _source; }

  void Update();

  // \brief Returns the amount of time left in warm up
  // \return warm up time left
  //inline hoa_system::SystemTimer GetWarmUpTime() const { return _warm_up_time; }

  //inline IBattleActor* GetActor() { return _actor_source; }

private:
  std::string _script_name;

  BattleActor* _source;

  hoa_global::GlobalSkill* _skill;

  hoa_global::GlobalItem* _item;

  hoa_global::GlobalAttackPoint* _attack_point;

  //hoa_global::GlobalActor * _source;

  BattleActor* _target;

  //std::deque<BattleActor *> _targets;

  hoa_system::SystemTimer _warm_up_time;
};

} // namespace private_battle

class BattleMode : public hoa_mode_manager::GameMode {
  friend class private_battle::BattleActor;
  friend class private_battle::BattleCharacterActor;
  friend class private_battle::BattleEnemyActor;
  friend class private_battle::ScriptEvent;
  friend class private_battle::ActionWindow;
  friend class private_battle::FinishWindow;
public:
  BattleMode();

  ~BattleMode();


  void Reset();
  
  void Update();

  void Draw();

  void AddEnemy(hoa_global::GlobalEnemy new_enemy);

  void AddEnemy(uint32 new_enemy_id)
    { AddEnemy(hoa_global::GlobalEnemy(new_enemy_id)); }

  void AddMusic(std::string music_filename);

  // TODO: Some of the public methods below should probably not be public...

  bool _IsPerformingScript() const
    { return _performing_script; }

  void SetPerformingScript(bool is_performing, private_battle::ScriptEvent* se);

  void AddScriptEventToQueue(private_battle::ScriptEvent* event)
    { _script_queue.push_back(event); }

  void RemoveScriptedEventsForActor(hoa_battle::private_battle::BattleActor * actor);

  std::deque<private_battle::BattleCharacterActor*> GetCharacters() const
    { return _character_actors; }

  void FreezeTimers();

  void UnFreezeTimers();

  bool IsBattleOver() const
    { return _battle_over; }

  bool IsVictorious() const
    { return _victorious_battle; }

  void PlayerVictory();
  
  void PlayerDefeat();

  uint32 GetNumberOfCharacters() const
    { return _character_actors.size(); }

  uint32 GetNumberOfEnemies() const
    { return _enemy_actors.size(); }

  uint32 GetIndexOfFirstAliveEnemy() const;

  uint32 GetIndexOfLastAliveEnemy() const;

  uint32 GetIndexOfFirstIdleCharacter() const;

  uint32 GetIndexOfNextAliveEnemy(bool move_upward) const;

  private_battle::BattleCharacterActor * GetPlayerCharacterAt(uint32 index) const
    { return _character_actors.at(index); }

  private_battle::BattleEnemyActor * GetEnemyActorAt(uint32 index) const
    { return _enemy_actors.at(index); }

  uint32 GetIndexOfCharacter(private_battle::BattleCharacterActor * const Actor) const;

  // This may become more complicated if it is done in a wierd graphical manner
  void SwapCharacters(private_battle::BattleCharacterActor * ActorToRemove, private_battle::BattleCharacterActor * ActorToAdd);

  // \brief Gets the active ScriptEvent
  // \param se the ScriptEvent to designate as active
  inline private_battle::ScriptEvent* GetActiveScript()
    { return _active_se; }

private:
  bool _initialized;

  bool _performing_script;

  private_battle::ScriptEvent* _active_se;

  bool _battle_over;

  bool _victorious_battle;
  
  uint32 _victory_xp;

  uint32 _victory_sp;

  uint32 _victory_money;

  bool _victory_level;

  bool _victory_skill;

  std::map<std::string, uint32> _victory_items;

  std::vector<hoa_audio::MusicDescriptor> _battle_music;



  hoa_video::StillImage _battle_background;

  std::vector<hoa_video::ImageDescriptor*> _background_images;



  std::deque<hoa_global::GlobalEnemy> _original_enemies;

  std::deque<hoa_global::GlobalCharacter> _original_characters;

  std::map<uint8, private_battle::BattleActor*> _battle_actors;

  std::deque<private_battle::BattleCharacterActor*> _character_actors;

  std::deque<private_battle::BattleEnemyActor*> _enemy_actors;

  std::deque<private_battle::BattleCharacterActor*> _reserve_characters;



  private_battle::CURSOR_STATE _cursor_state;

  // NOTE: Are _selected_character_index and _selected_target_index really necessary in addition to _selected_character
  // and _selected target? They essentially represent the same thing...

  int32 _selected_character_index;

  uint32 _selected_target_index;

  private_battle::BattleCharacterActor* _selected_character;

  private_battle::BattleActor* _selected_target;

  uint32 _selected_attack_point;



  private_battle::ActionWindow* _action_window;

  private_battle::FinishWindow* _finish_window;



  hoa_video::StillImage _bottom_menu_image;

  hoa_video::StillImage _actor_selection_image;

  hoa_video::AnimatedImage _attack_point_indicator;

  hoa_video::StillImage _universal_time_meter;

  hoa_video::StillImage _swap_icon;

  hoa_video::StillImage _swap_card;



  uint8 _current_number_swaps;

  int32 _swap_countdown_timer;

  uint32 _min_agility;



  std::list<private_battle::ScriptEvent*> _script_queue;

  int32 _next_monster_location_index;


  void _TEMP_LoadTestData();

  void _CreateCharacterActors();

  void _CreateEnemyActors();

  void _Initialize();

  void _ShutDown();

  void _TallyRewards();

  uint32 _NumberEnemiesAlive() const;

  uint32 _NumberCharactersAlive() const;


  void _UpdateCharacterSelection();

  void _UpdateTargetSelection();

  void _UpdateAttackPointSelection();

  void _DrawBackgroundVisuals();

  void _DrawBottomMenu();

  void _DrawSprites();

  void _DrawTimeMeter();
}; // class BattleMode : public hoa_mode_manager::GameMode

} // namespace hoa_battle

#endif // __BATTLE_HEADER__

---