actions.h

Go to the documentation of this file.

/*
 *  actions.h - Action controllers for actors.
 *
 *  Copyright (C) 2000-2001  The Exult Team
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#ifndef ACTIONS_H
#define ACTIONS_H 1

#include "tiles.h"

class Actor;
class Game_object;
class Tile_coord;
class PathFinder;
class Pathfinder_client;
class If_else_path_actor_action;

/*
 *  This class controls the current actions of an actor:
 */
class Actor_action
  {
  static long seqcnt;   // Sequence # to check for deletion.
protected:
  bool get_party;     // At each step (of the Avatar), have
          //   the party follow.
  long seq;     // 'unique' sequence #.
public:
  Actor_action() : get_party(false)
    { seq = ++seqcnt; }
  virtual ~Actor_action() { }
  void set_get_party(bool tf = true)
    { get_party = true; }
  int handle_event_safely(Actor *actor, bool& deleted);
          // Handle time event.
  virtual int handle_event(Actor *actor) = 0;
  virtual void stop(Actor *actor) // Stop moving.
    {  }
          // Set simple path to destination.
  virtual Actor_action *walk_to_tile(Actor *npc, Tile_coord src, 
      Tile_coord dest, int dist = 0);
          // Set action to walk to dest, then
          //   exec. another action when there.
  static Actor_action *create_action_sequence(Actor *actor, 
      Tile_coord dest, Actor_action *when_there, 
          bool from_off_screen = false);
          // Get destination, or ret. 0.
  virtual int get_dest(Tile_coord& dest)
    { return 0; }
          // Check for Astar.
  virtual int following_smart_path()
    { return 0; }
  virtual If_else_path_actor_action *as_usecode_path()
    { return 0; }
  };

/*
 *  A null action just returns 0 the first time.
 */
class Null_action : public Actor_action
  {
public:
  Null_action() {  }
  virtual int handle_event(Actor *actor);
  };

/*
 *  Follow a path.
 */
class Path_walking_actor_action : public Actor_action
  {
protected:
  bool reached_end;   // Reached end of path.
  PathFinder *path;   // Allocated pathfinder.
private:
  int original_dir;   // From src. to dest. (0-7).
  int speed;      // Time between frames.
  bool from_offscreen;    // Walking from offscreen.
  Actor_action *subseq;   // For opening doors.
  unsigned char blocked;    // Blocked-tile retries.
  unsigned char max_blocked;  // Try this many times.
  unsigned char blocked_frame;  // Frame for blocked tile.
  Tile_coord blocked_tile;  // Tile to retry.
  void set_subseq(Actor_action *sub)
    {
    delete subseq;
    subseq = sub;
    }
public:
  Path_walking_actor_action(PathFinder *p = 0, int maxblk = 3);
  virtual ~Path_walking_actor_action();
  static Path_walking_actor_action *create_path(Tile_coord src,
      Tile_coord dest, Pathfinder_client& cost);
          // Handle time event.
  virtual int handle_event(Actor *actor);
  int open_door(Actor *actor, Game_object *door);
  virtual void stop(Actor *actor);// Stop moving.
          // Set simple path to destination.
  virtual Actor_action *walk_to_tile(Actor *npc, Tile_coord src, 
        Tile_coord dest, int dist = 0);
          // Get destination, or ret. 0.
  virtual int get_dest(Tile_coord& dest);
          // Check for Astar.
  virtual int following_smart_path();
  };

/*
 *  Follow a path to approach a given object, and stop half-way if it
 *  moved.
 */
class Approach_actor_action : public Path_walking_actor_action
  {
  Game_object *dest_obj;    // Destination object.
  Tile_coord orig_dest_pos; // Dest_obj's pos. when we start.
  int cur_step;     // Count steps.
  int check_step;     // Check at this step.
public:
  Approach_actor_action(PathFinder *p, Game_object *d);
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

/*
 *  Follow a path and execute one action if successful, another if
 *  failed.
 */
class If_else_path_actor_action : public Path_walking_actor_action
  {
  bool succeeded, failed, done;
  Actor_action *success, *failure;
public:
  If_else_path_actor_action(Actor *actor, Tile_coord dest, 
        Actor_action *s, Actor_action *f = 0);
  ~If_else_path_actor_action();
  void set_failure(Actor_action *f);
  bool done_and_failed()    // Happens if no path found in ctor.
    { return done && failed; }
          // Handle time event.
  virtual int handle_event(Actor *actor);
  virtual If_else_path_actor_action *as_usecode_path()
    { return this; }
  };

/*
 *  Just move (i.e. teleport) to a desired location.
 */
class Move_actor_action : public Actor_action
  {
  Tile_coord dest;    // Where to go.
public:
  Move_actor_action(Tile_coord d) : dest(d)
    {  }
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

#if 0 /* +++Maybe not needed. */
/*
 *  Approach an enemy during combat.
 */
class Combat_path_actor_action : public Actor_action
  {
  PathFinder *path;   // Allocated pathfinder.
  int frame_index;    // Index within frame sequence.
public:
  Combat_path_walking_actor_action(PathFinder *p);
  virtual ~Combat_path_walking_actor_action();
          // Handle time event.
  virtual int handle_event(Actor *actor);
          // Get destination, or ret. 0.
  virtual int get_dest(Tile_coord& dest);
  };
#endif

/*
 *  Activate an object.
 */
class Activate_actor_action : public Actor_action
  {
  Game_object *obj;
public:
  Activate_actor_action(Game_object *o) : obj(o)
    {  }
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

/*
 *  Go through a series of frames.
 */
class Frames_actor_action : public Actor_action
  {
  signed char *frames;    // List to go through (a -1 means to
          //   leave frame alone.)
  int cnt;      // Size of list.
  int index;      // Index for next.
  int speed;      // Frame delay in 1/1000 secs.
  Game_object *obj;   // Object to animate
public:
  Frames_actor_action(signed char *f, int c, int spd = 200, Game_object *o = 0);
  virtual ~Frames_actor_action()
    { delete [] frames; }
          // Handle time event.
  virtual int handle_event(Actor *actor);
  int get_index()
    { return index; }
  };

/*
 *  Call a usecode function.
 */
class Usecode_actor_action : public Actor_action
  {
  int fun;      // Fun. #.
  Game_object *item;    // Call it on this item.  
  int eventid;
public:
  Usecode_actor_action(int f, Game_object *i, int ev)
    : fun(f), item(i), eventid(ev)
    {  }  
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

/*
 *  Do a sequence of actions.
 */
class Sequence_actor_action : public Actor_action
  {
  Actor_action **actions;   // List of actions, ending with null.
  int index;      // Index into list.
  int speed;      // Frame delay in 1/1000 secs. between
          //   actions.
public:
          // Create with allocated list.
  Sequence_actor_action(Actor_action **act, int spd = 100) 
          : actions(act), index(0), speed(spd)
    {  }
          // Create with up to 4.
  Sequence_actor_action(Actor_action *a0, Actor_action *a1,
        Actor_action *a2 = 0, Actor_action *a3 = 0);
  void set_speed(int spd)
    { speed = spd; }
  virtual ~Sequence_actor_action();
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

//
//  The below could perhaps go into a highact.h file.
//

/*
 *  Rotate through an object's frames.
 */
class Object_animate_actor_action : public Actor_action
  {
  Game_object *obj;
  int nframes;      // # of frames.
  int cycles;     // # of cycles to do.
  int speed;      // Time between frames.
public:
  Object_animate_actor_action(Game_object *o, int cy, int spd);
  Object_animate_actor_action(Game_object *o, int nframes, int cy, int spd);
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

/*
 *  Action to pick up an item or put it down.
 */

class Pickup_actor_action : public Actor_action
  {
  Game_object *obj;   // What to pick up/put down.
  int pickup;     // 1 to pick up, 0 to put down.
  int speed;      // Time between frames.
  int cnt;      // 0, 1, 2.
  Tile_coord objpos;    // Where to put it.
  int dir;      // Direction to face.
public:
          // To pick up an object:
  Pickup_actor_action(Game_object *o, int spd);
          // To put down an object:
  Pickup_actor_action(Game_object *o, Tile_coord opos, int spd);
  virtual int handle_event(Actor *actor);
  };
  

/*
 *  Action to turn towards an object or spot.
 */

class Face_pos_actor_action : public Actor_action
  {
  int speed;      // Time between frames.
  Tile_coord pos;     // Where to put it.
public:
  Face_pos_actor_action(Tile_coord p, int spd);
          // To pick up an object:
  Face_pos_actor_action(Game_object *o, int spd);
  virtual int handle_event(Actor *actor);
  };
  

#endif  /* INCL_ACTIONS */

---