map_sprites.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 __MAP_SPRITES_HEADER__
#define __MAP_SPRITES_HEADER__

#include "utils.h"
#include "defs.h"
#include "video.h"
#include "map_actions.h"
#include "map_dialogue.h"
#include "map_objects.h"
#include "map_zones.h"

namespace hoa_map {

namespace private_map {

// *********************** SPRITE CONSTANTS **************************

const float VERY_SLOW_SPEED = 200.0f;
const float SLOW_SPEED      = 175.0f;
const float NORMAL_SPEED    = 150.0f;
const float FAST_SPEED      = 125.0f;
const float VERY_FAST_SPEED = 100.0f;

const uint16 NORTH     = 0x0001;
const uint16 SOUTH     = 0x0002;
const uint16 WEST      = 0x0004;
const uint16 EAST      = 0x0008;
const uint16 NW_NORTH  = 0x0010;
const uint16 NW_WEST   = 0x0020;
const uint16 NE_NORTH  = 0x0040;
const uint16 NE_EAST   = 0x0080;
const uint16 SW_SOUTH  = 0x0100;
const uint16 SW_WEST   = 0x0200;
const uint16 SE_SOUTH  = 0x0400;
const uint16 SE_EAST   = 0x0800;

const uint16 NORTHWEST = NW_NORTH | NW_WEST;
const uint16 NORTHEAST = NE_NORTH | NE_EAST;
const uint16 SOUTHWEST = SW_SOUTH | SW_WEST;
const uint16 SOUTHEAST = SE_SOUTH | SE_EAST;

const uint16 FACING_NORTH = NORTH | NW_NORTH | NE_NORTH;
const uint16 FACING_SOUTH = SOUTH | SW_SOUTH | SE_SOUTH;
const uint16 FACING_WEST = WEST | NW_WEST | SW_WEST;
const uint16 FACING_EAST = EAST | NE_EAST | SE_EAST;

const uint32 ANIM_STANDING_SOUTH = 0;
const uint32 ANIM_STANDING_NORTH = 1;
const uint32 ANIM_STANDING_WEST  = 2;
const uint32 ANIM_STANDING_EAST  = 3;
const uint32 ANIM_WALKING_SOUTH  = 4;
const uint32 ANIM_WALKING_NORTH  = 5;
const uint32 ANIM_WALKING_WEST   = 6;
const uint32 ANIM_WALKING_EAST   = 7;

extern hoa_video::AnimatedImage new_dialogue_icon;

class VirtualSprite : public MapObject {
public:
  uint16 direction;

  float movement_speed;

  bool moving;

  bool sky_object;

  hoa_utils::ustring name;

  hoa_video::StillImage* face_portrait;

  bool seen_all_dialogue;

  int8 current_action;

  // TODO: change how forced action work
  int8 forced_action;

  std::vector<SpriteAction*> actions;


  bool _saved;
  uint16 _saved_direction;
  float _saved_movement_speed;
  bool _saved_moving;
  hoa_utils::ustring _saved_name;
  int8 _saved_current_action;

  std::vector<MapDialogue*> dialogues;

  int16 _current_dialogue;

  bool _show_dialogue_icon;

  hoa_video::Color _dialogue_icon_color;

  // -------------------- Public methods

  VirtualSprite();

  ~VirtualSprite();

  virtual void Update();

  virtual void Draw();

  void SetDirection(uint16 dir);

  void SetMovementSpeed(float speed)
    { movement_speed = speed; }

  uint16 GetDirection() const
    { return direction; }

  float GetMovementSpeed() const
    { return movement_speed; }

  void SetFacePortrait(std::string pn);

  virtual void SaveState();

  virtual bool LoadState();

  void UpdateSeenDialogue();

  void AddAction(SpriteAction* act)
    { act->SetSprite(this); actions.push_back(act); }

  void AddDialogue(MapDialogue* md)
    { dialogues.push_back(md); md->SetOwner(this); if (md->HasAlreadySeen() == false) seen_all_dialogue = false; }

  bool HasDialogue() const
    { return (dialogues.size() > 0); }

  MapDialogue* GetCurrentDialogue() const
    { return dialogues[_current_dialogue]; }

  void SetDialogue(const int16 dialogue)
    { if (static_cast<uint16>(dialogue) >= dialogues.size()) return; else _current_dialogue = dialogue; }

  void NextDialogue()
    { _current_dialogue++; if (static_cast<uint16>(_current_dialogue) >= dialogues.size()) _current_dialogue = 0; }

  int16 GetNumDialogues() const
    { return dialogues.size(); }

  void ShowDialogueIcon(bool state)
    { _show_dialogue_icon = state; }

  bool IsShowingDialogueIcon() const
    { return _show_dialogue_icon; }

  static uint16 CalculateOppositeDirection(const uint16 direction);

  void SetRandomDirection();
}; // class VirtualSprite : public MapObject


class MapSprite : public VirtualSprite {
public:
  bool was_moving;

  int8 walk_sound;

  uint8 current_animation;

  std::vector<hoa_video::AnimatedImage> animations;

  bool _saved_was_moving;
  int8 _saved_walk_sound;
  uint8 _saved_current_animation;

  // -------------------------------- Methods --------------------------------

  MapSprite();

  ~MapSprite();

  bool LoadStandardAnimations(std::string filename);

  virtual void Update();

  virtual void Draw();

  void SetName(std::string na)
    { name = hoa_utils::MakeUnicodeString(na); }

  void SetWalkSound(int8 sound)
    { walk_sound = sound; }

  void SetCurrentAnimation(uint8 anim)
    { current_animation = anim; }

  int8 GetWalkSound() const
    { return walk_sound; }

  uint8 GetCurrentAnimation() const
    { return current_animation; }

  virtual void SaveState();

  virtual bool LoadState();
}; // class MapSprite : public VirtualSprite


class EnemySprite : public MapSprite {
private:
  enum STATE {
    SPAWNING,
    HOSTILE,
    DEAD
  };

public:
  EnemySprite();
  
  EnemySprite(std::string file);

  bool Load();

  void Reset();

  virtual void Update();

  virtual void Draw();

  // TODO: eventually I would like the ability for Lua to pass in a table of ints to the AddEnemyParty function, but because I'm not quite
  // sure how to do that yet, I'm writing several smaller functions so we can just get this demo released.

  // void AddEnemyParty(std::vector<uint32>& party);

  void NewEnemyParty()
    { _enemy_parties.push_back(std::vector<uint32>()); }

  void AddEnemy(uint32 enemy_id);

  const std::vector<uint32>& RetrieveRandomParty();


  float GetAggroRange() const
    { return _aggro_range; }

  uint32 GetTimeToChange() const
    { return _time_dir_change; }

  uint32 GetTimeToSpawn() const
    { return _time_to_spawn; }

  std::string GetBattleMusicTheme() const
    { return _music_theme; }

  bool IsDead() const
    { return _state == DEAD; }

  bool IsSpawning() const
    { return _state == SPAWNING; }

  bool IsHostile() const
    { return _state == HOSTILE; }

  void SetZone(EnemyZone* zone)
    { _zone = zone; }

  void SetAggroRange(float range)
    { _aggro_range = range; }

  void SetTimeToChange(uint32 time)
    { _time_dir_change = time; }

  void SetTimeToSpawn(uint32 time)
    { _time_to_spawn = time; }

  void SetBattleMusicTheme(const std::string & music_theme)
    { _music_theme = music_theme; }

  void ChangeStateDead() { 
    Reset(); 
    if( _zone ) 
      _zone->EnemyDead(); 
  }

  void ChangeStateSpawning()
    { updatable = true; _state = SPAWNING; no_collision = false; }

  void ChangeStateHostile()
    { updatable = true; _state = HOSTILE; no_collision = false; _color.SetAlpha(1.0); }

private:
  private_map::EnemyZone* _zone;

  hoa_video::Color _color;

  uint32 _time_elapsed;

  STATE _state;

  float _aggro_range;

  uint32 _time_dir_change;

  uint32 _time_to_spawn;

  bool _out_of_zone;

  std::string _music_theme;

  std::vector<std::vector<uint32> > _enemy_parties;
}; // class EnemySprite : public MapSprite

} // namespace private_map

} // namespace hoa_map

#endif // __MAP_SPRITES_HEADER__

---