map_actions.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_ACTIONS_HEADER__
#define __MAP_ACTIONS_HEADER__

#include <string>
#include <vector>

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

namespace hoa_map {

namespace private_map {

class SpriteAction {
public:
  SpriteAction(VirtualSprite *sprite) :
    _sprite(sprite), _finished(false), _forced(false) {}

  virtual ~SpriteAction()
    {}

  virtual void Execute() = 0;

  const bool IsFinished()
    { return _finished; }

  bool IsFinishedReset()
    { if (!_finished) return false; else _finished = false; return true; }

  bool IsForced() const
    { return _forced; }

  void SetFinished(bool fin)
    { _finished = fin; }

  void SetForced(bool forc)
    { _forced = forc; }

  void SetSprite(VirtualSprite* sp)
    { _sprite = sp; }

protected:
  VirtualSprite *_sprite;

  bool _finished;

  bool _forced;
}; // class SpriteAction


class ActionPathMove : public SpriteAction {
public:
  // ----- Members -----

  PathNode destination;

  std::vector<PathNode> path;

  uint32 current_node;

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

  ActionPathMove(VirtualSprite* sprite) :
    SpriteAction(sprite), current_node(0) {}

  ~ActionPathMove()
    {}

  void Execute();

  void SetDestination(int16 x, int16 y)
    { destination.col = x; destination.row = y; }
}; // class ActionPathMove : public SpriteAction


class ActionRandomMove : public SpriteAction {
public:
  // ----- Members -----
  uint32 total_movement_time;

  uint32 movement_timer;

  uint32 total_direction_time;

  uint32 direction_timer;

  MapZone* zone;

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

  ActionRandomMove(VirtualSprite* sprite) :
    SpriteAction(sprite), total_movement_time(10000), movement_timer(0), total_direction_time(2000), direction_timer(0) {}

  ~ActionRandomMove()
    {}

  void Execute();
}; // class ActionPathMove : public SpriteAction


class ActionAnimate : public SpriteAction {
public:
  std::vector<uint16> frames;

  std::vector<uint32> display_times;

  uint32 current_frame;

  uint32 timer;

  int8 loop_count;

  int8 loops;

  ActionAnimate(VirtualSprite* sprite) :
    SpriteAction(sprite), current_frame(0), timer(0), loops(0) {}

  ~ActionAnimate()
    {}

  void Execute();

  void AddFrame(uint16 frame, uint32 time)
    { frames.push_back(frame); display_times.push_back(time); }

  void SetLoops(int8 count)
    { loops = count; }
}; // class ActionAnimate : public SpriteAction


// class ActionScriptFunction : public SpriteAction {
// public:
//  ActionScriptFunction()
//    {}
//  ~ActionScriptFunction()
//    {}
//
//  void Load(uint32 table_key)
//    {}
//  void Execute()
//    {}
// };

} // namespace private_map

} // namespace hoa_map

#endif

---