actions.cc

Go to the documentation of this file.

/*
 *  actions.cc - 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.
 */

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "gamewin.h"
#include "actions.h"
#include "actors.h"
#include "Zombie.h"
#include "Astar.h"
#include "paths.h"
#include "dir.h"
#include "ucmachine.h"
#include "frameseq.h"
#include "ucmachine.h"
#include "cheat.h"
#include "party.h"

using std::cout;
using std::endl;

long Actor_action::seqcnt = 0;

/*
 *  Handle an event and check to see if we were deleted.
 *
 *  Output: Delay value from handle_event (0 if we've been deleted).
 */

int Actor_action::handle_event_safely
  (
  Actor *actor,
  bool& deleted     // True returned if we're gone!
  )
  {
  Actor_action *old_action = actor->get_action();
  long old_seq = old_action->seq;
          // Do current action.
  int delay = handle_event(actor);
  if (actor->get_action() != old_action ||
      old_action->seq != old_seq)
    {
    deleted = true;   // We've been deleted.
    return 0;
    }
  deleted = false;
  return delay;
  }

/*
 *  Set to walk from one point to another the dumb way.
 *
 *  Output: ->this, or 0 if unsuccessful.
 */

Actor_action *Actor_action::walk_to_tile
  (
  Actor * /* npc */,
  Tile_coord src,
  Tile_coord dest,
  int /* dist */      // Ignored.
  )
  {
  Zombie *path = new Zombie();
  get_party = false;
          // Set up new path.
  if (path->NewPath(src, dest, 0))
    return (new Path_walking_actor_action(path));
  else
    {
    delete path;
    return (0);
    }
  }

/*
 *  Set up an action to get an actor to a location (via pathfinding), and
 *  then execute another action when he gets there.
 *
 *  Output: ->action.  
 */

Actor_action *Actor_action::create_action_sequence
  (
  Actor *actor,     // Whom to activate.
  Tile_coord dest,    // Where to walk to.
  Actor_action *when_there, // What to do when he gets there.
  bool from_off_screen    // Have actor walk from off-screen.
  )
  {
  Actor_action *act = when_there;
  Tile_coord actloc = actor->get_tile();
  if (from_off_screen)
    actloc.tx = actloc.ty = -1;
  if (dest != actloc)   // Get to destination.
    {
    Actor_action *w = new Path_walking_actor_action(new Astar());
    Actor_action *w2 = w->walk_to_tile(actor, actloc, dest);
    if (w2 != w)
      delete w;
    if (!w2)    // Failed?  Teleport.
      w2 = new Move_actor_action(dest);
          // And teleport if blocked walking.
    Actor_action *tel = new Move_actor_action(dest);
          // Walk there, then do whatever.
    Sequence_actor_action *seq;
    act = seq = new Sequence_actor_action(w2, tel, act);
    seq->set_speed(0);  // No delay between actions.
    }
  return act;
  }

/*
 *  Null action.
 */

int Null_action::handle_event
  (
  Actor *actor
  )
  {
  return 0;
  }

/*
 *  Create action to follow a path.
 */

Path_walking_actor_action::Path_walking_actor_action
  (
  PathFinder *p,      // Pathfinder, or 0 for Astar.
  int maxblk      // Max. retries when blocked.
  ) : reached_end(false), path(p), from_offscreen(false),
      subseq(0), blocked(0), max_blocked(maxblk)
  {
  if (!path)
    path = new Astar();
  Tile_coord src = path->get_src(), dest = path->get_dest();
  original_dir = static_cast<int>(Get_direction4(
        src.ty - dest.ty, dest.tx - src.tx));
  }

/*
 *  Delete.
 */

Path_walking_actor_action::~Path_walking_actor_action
  (
  )
  {
  delete path;
  delete subseq;
  subseq = 0;     // (Debugging).
  original_dir = -1;
  }

/*
 *  Create action for walking to given destination using Astar.
 *  Note:  This is a static method.
 *
 *  Output: Action if successful, else 0.
 */

Path_walking_actor_action *Path_walking_actor_action::create_path
  (
  Tile_coord src,     // Starting position.
  Tile_coord dest,    // Destination.
  Pathfinder_client& cost   // Cost for Astar.
  )
  {
  Astar *path = new Astar();
          // Get to within 1 tile.
  if (path->NewPath(src, dest, &cost))
    return new Path_walking_actor_action(path);
  else
    {
    delete path;
    return 0;
    }
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Path_walking_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (subseq)     // Going through a door?
    {
    int delay = subseq->handle_event(actor);
    if (delay)
      return delay; // Still going.
    set_subseq(0);
          // He was stopped, so restore speed.
    actor->set_frame_time(speed);
    return speed;   // Come back in a moment.
    }
  Tile_coord tile;
  if (blocked)
    {
#if 0
std::cout << "Actor " << actor->get_name() << " blocked.  Retrying." << std::endl;
#endif
    if (actor->step(blocked_tile, blocked_frame))
      {   // Successful?
      blocked = 0;
          // He was stopped, so restore speed.
      actor->set_frame_time(speed);
      return speed;
      }
          // Wait up to 1.6 secs.
    return (blocked++ > max_blocked ? 0 
          : 100 + blocked*(std::rand()%500));
    }
  speed = actor->get_frame_time();// Get time between frames.
  if (!speed)
    return 0;   // Not moving.
  bool done;      // So we'll know if this is the last.
  if (!path->GetNextStep(tile, done))
    {
    reached_end = true; // Did it.
    return (0);
    }
  if (done)     // In case we're deleted.
    reached_end = true;
  Tile_coord cur = actor->get_tile();
  int newdir = static_cast<int>(Get_direction4(cur.ty - tile.ty, 
              tile.tx - cur.tx));
  Frames_sequence *frames = actor->get_frames(newdir);
  int& step_index = actor->get_step_index();
  if (!step_index)    // First time?  Init.
    step_index = frames->find_unrotated(actor->get_framenum());
          // Get next (updates step_index).
  int frame = frames->get_next(step_index);
  int cur_speed = speed;    // Step() might delete us!
  if (from_offscreen)   // Teleport to 1st spot.
    {
    from_offscreen = false;
    actor->move(tile.tx, tile.ty, tile.tz);
    return cur_speed;
    }
  else if (actor->step(tile, frame))  // Successful.
    {
    if (get_party)    // MUST be the Avatar.
      Game_window::get_instance()->get_party_man()->
            get_followers(newdir);
    if (done)   // Was this the last step?
      return (0);
    return cur_speed;
    }
  reached_end = false;
  frames->decrement(step_index);  // We didn't take the step.
          // Blocked by a door?
  if (actor->get_tile().distance(tile) == 1 &&
      !cheat.in_map_editor()) // And NOT map-editing?
          // +++++Check for intelligence?
    {
    Game_object *door = Game_object::find_door(tile);
    if (door != 0 && door->is_closed_door() &&
          // Make sure it's not locked!
        door->get_framenum()%4 < 2)

          // Try to open it.
      {
      if (open_door(actor, door))
        return speed;
      }
    }
  if (!max_blocked ||   // No retries allowed?
      actor->is_dormant())  // Or actor off-screen?
    return 0;
  blocked = 1;
  blocked_tile = tile;
  blocked_frame = frame;
  return (100 + std::rand()%500); // Wait .1 to .6 seconds.
  }

/*
 *  Open door that's blocking the NPC, and set action to walk past and
 *  close it.
 *
 *  Output: 1 if successful.
 */

int Path_walking_actor_action::open_door
  (
  Actor *actor,
  Game_object *door
  )
  {
  Game_window *gwin = Game_window::get_instance();
  Tile_coord cur = actor->get_tile();
          // Get door's footprint in tiles.
  Rectangle foot = door->get_footprint();
          // Open it, but kludge quality to
          //   avoid unwanted usecode.
  int savequal = door->get_quality();
  door->set_quality(0);
  door->activate();
  door->set_quality(savequal);
  Tile_coord past;    // Tile on other side of door.
  past.tz = cur.tz;
  int dir;      // Get dir to face door afterwards.
  if (foot.w > foot.h)    // Horizontal?
    {
    past.tx = foot.x + foot.w/2;
    if (cur.ty <= foot.y) // N. of door?
      {
      past.ty = foot.y + foot.h;
      dir = 0;
      }
    else      // S. of door?
      {
      past.ty = foot.y - 1;
      dir = 4;
      }
    }
  else        // Vertical.
    {
    past.ty = foot.y + foot.h/2;
    if (cur.tx <= foot.x) // W. of door?
      {
      past.tx = foot.x + foot.w;
      dir = 6;
      }
    else      // E. of door?
      {
      past.tx = foot.x - 1;
      dir = 2;
      }
    }
  Tile_coord tmp = Map_chunk::find_spot(past, 1, actor, 1);
  if (past.tx != -1)    // Succeeded.  Walk past and close it.
    {
#ifdef DEBUG
    cout << "Path_walking_actor_action::open_door()" << endl;
#endif
    signed char frames[2];
    frames[0] = actor->get_dir_framenum(dir, Actor::standing);
    frames[1] = actor->get_dir_framenum(dir, 3);
    signed char standframe = frames[0];
    set_subseq(create_action_sequence(actor, past,
      new Sequence_actor_action(
        new Frames_actor_action(frames, 
              sizeof(frames)),
        new Activate_actor_action(door),
        new Frames_actor_action(&standframe, 1))));
    return 1;
    }
  return 0;
  }

/*
 *  Stopped moving.
 */

void Path_walking_actor_action::stop
  (
  Actor *actor
  )
  {
          // Don't set slimes.
  if (!actor->get_info().has_strange_movement())
    {     // ++++For now, just use original dir.
    Frames_sequence *frames = actor->get_frames(original_dir);
    actor->change_frame(frames->get_resting());
    }
  }

/*
 *  Set to walk from one point to another, using the same pathfinder.
 *
 *  Output: ->this, or 0 if unsuccessful.
 */

Actor_action *Path_walking_actor_action::walk_to_tile
  (
  Actor *npc,
  Tile_coord src,     // tx=-1 or ty=-1 means don't care.
  Tile_coord dest,    // Same here.
  int dist      // Distance to get to within dest.
  )
  {
  Game_window *gwin = Game_window::get_instance();
  blocked = 0;      // Clear 'blocked' count.
  reached_end = false;    // Starting new path.
  get_party = false;
  from_offscreen = false;
        //+++++Should dist be used below??:
          // Set up new path.
          // Don't care about 1 coord.?
  if (dest.tx == -1 || dest.ty == -1)
    {
    if (dest.tx == dest.ty) // Completely off-screen?
      {
      Offscreen_pathfinder_client cost(npc);
      if (!path->NewPath(src, dest, &cost))
        return (0);
      }
    else
      {
      Onecoord_pathfinder_client cost(npc);
      if (!path->NewPath(src, dest, &cost))
        return (0);
      }
    }
          // How about from source?
  else if (src.tx == -1 || src.ty == -1)
    {     // Figure path in opposite dir.
    if (src.tx == src.ty) // Both -1?
      {   // Aim from NPC's current pos.
      Offscreen_pathfinder_client cost(npc, npc->get_tile());
      if (!path->NewPath(dest, src, &cost))
        return (0);
      }
    else
      {
      Onecoord_pathfinder_client cost(npc);
      if (!path->NewPath(dest, src, &cost))
        return (0);
      }
    from_offscreen = true;
          // Set to go backwards.
    if (!path->set_backwards())
      return (0);
    }
  else
    {
    Actor_pathfinder_client cost(npc, dist);
    if (!path->NewPath(src, dest, &cost))
      return (0);
    }
          // Reset direction (but not index).
  original_dir = static_cast<int>(Get_direction4(
        src.ty - dest.ty, dest.tx - src.tx));
  return (this);
  }

/*
 *  Return current destination.
 *
 *  Output: 0 if none.
 */

int Path_walking_actor_action::get_dest
  (
  Tile_coord& dest    // Returned here.
  )
  {
  dest = path->get_dest();
  return (1);
  }

/*
 *  Following an Astar path?
 */

int Path_walking_actor_action::following_smart_path
  (
  )
  {
  return path != 0 && path->following_smart_path();
  }

/*
 *  Create action to follow a path towards another object.
 */

Approach_actor_action::Approach_actor_action
  (
  PathFinder *p,      // Path to follow.
  Game_object *d      // Destination object.
  ) : Path_walking_actor_action(p, 0),  // (Stop if blocked.)
      dest_obj(d), orig_dest_pos(d->get_tile()), cur_step(0)
  {
          // Get length of path.
  int nsteps = path->get_num_steps();
  if (nsteps >= 6)    // (May have to play with this).
    check_step = nsteps > 18 ? 9 : nsteps/2;
  else
    check_step = 10000;
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Approach_actor_action::handle_event
  (
  Actor *actor
  )
  {
  int delay = Path_walking_actor_action::handle_event(actor);
  if (!delay)     // Done or blocked.
    return 0;
  if (++cur_step == check_step) // Time to check.
    {
    if (dest_obj->get_tile().distance(orig_dest_pos) > 2)
      return 0; // Moved too much, so stop.
          // Figure next check.
    int nsteps = path->get_num_steps();
    if (nsteps >= 6)
      check_step += nsteps/2;
    }
  return delay;
  }

/*
 *  Create if-then-else path.
 */

If_else_path_actor_action::If_else_path_actor_action
  (
  Actor *actor,
  Tile_coord dest,
  Actor_action *s,
  Actor_action *f
  ) : Path_walking_actor_action(0, 6),  // Maxblk = 6.
    succeeded(false), failed(false), done(false),
    success(s), failure(f)
  {
  if (!walk_to_tile(actor, actor->get_tile(), dest))
    {
    done = failed = true;
    }
  }

/*
 *  Delete.
 */

If_else_path_actor_action::~If_else_path_actor_action
  (
  )
  {
  delete success;
  delete failure;
  }

/*
 *  Set failure action.
 */

void If_else_path_actor_action::set_failure
  (
  Actor_action *f
  )
  {
  delete failure;
  failure = f;
  done = false;     // So it gets executed.
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int If_else_path_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (done)
    return 0;   // Shouldn't really get here.
  bool del;
  int delay;
  if (succeeded)      // Doing the success action?
    {
    if ((delay = success->handle_event_safely(actor, del)) == 0 &&
        !del)
      done = true;
    return delay;
    }
  else if (failed)
    {
    if ((delay = failure->handle_event_safely(actor, del)) == 0 &&
        !del)
      done = true;
    return delay;
    }
  delay = Path_walking_actor_action::handle_event(actor);
  if (delay)
    return delay;
  if (!reached_end)
    {     // Didn't get there.
    if (failure)
      {
      failed = true;
#if DEBUG
      cout << "Executing 'failure' path usecode" << endl;
#endif
      delay = failure->handle_event_safely(actor, del);
      if (del)  // Are we gone?
        return 0;
      }
    }
  else        // Success.
    {
    if (success)
      {
      succeeded = true;
      delay = success->handle_event_safely(actor, del);
      if (del)  // Are we gone?
        return 0;
      }
    }
  if (!delay)
    done = true;    // All done now.
  return delay;
  }     

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Move_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (dest.tx < 0 || actor->get_tile() == dest)
    return (0);   // Done.
  actor->move(dest);    // Zip right there.
  Game_window *gwin = Game_window::get_instance();
  if (actor == gwin->get_main_actor())
          // Teleported Avatar?
    gwin->center_view(dest);
  dest.tx = -1;     // Set to stop.
  return (100);     // Wait 1/10 sec.
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Activate_actor_action::handle_event
  (
  Actor *actor
  )
  {
  obj->activate();
  return 0;     // That's all.
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Usecode_actor_action::handle_event
  (
  Actor *actor
  )
  {
  Game_window *gwin = Game_window::get_instance();
  gwin->get_usecode()->call_usecode(fun, item, 
      (Usecode_machine::Usecode_events) eventid);
  gwin->set_all_dirty();    // Clean up screen.
  return 0;     // That's all.
  }

/*
 *  Create sequence of frames.
 */

Frames_actor_action::Frames_actor_action
  (
  signed char *f,     // Frames.  -1 means don't change.
  int c,        // Count.
  int spd,      // Frame delay in 1/1000 secs.
  Game_object *o
  ) : cnt(c), index(0), speed(spd), obj(o)
  {
  frames = new signed char[cnt];
  std::memcpy(frames, f, cnt);
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Frames_actor_action::handle_event
  (
  Actor *actor
  )
  {
  Game_object *o = obj;
  if (index == cnt)
    return (0);   // Done.
  int frnum = frames[index++];  // Get frame.
  if (frnum >= 0)
    {
    Game_window *gwin = Game_window::get_instance();
    if (o)
      o->change_frame(frnum);
    else
      actor->change_frame(frnum);
    }
  return (speed);
  }

/*
 *  Create a sequence with up to 4 actions.
 */

Sequence_actor_action::Sequence_actor_action
  (
  Actor_action *a0,   // (These will be deleted when done.)
  Actor_action *a1,
  Actor_action *a2,
  Actor_action *a3
  ) : index(0), speed(100)
  {
  actions = new Actor_action *[5];// Create list.
  actions[0] = a0;
  actions[1] = a1;
  actions[2] = a2;
  actions[3] = a3;
  actions[4] = 0;     // 0-delimit.
  }

/*
 *  Delete.
 */

Sequence_actor_action::~Sequence_actor_action
  (
  )
  {
  for (int i = 0; actions[i]; i++)
    delete actions[i];
  delete [] actions;
  }

/*
 *  Handle a time event.
 *
 *  Output: 0 if done with this action, else delay for next frame.
 */

int Sequence_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (!actions[index])    // Done?
    return (0);
          // Do current action.
  bool deleted;
  int delay = actions[index]->handle_event_safely(actor, deleted);
  if (deleted)
    return 0;   // We've been deleted!
  if (!delay)
    {
    index++;    // That one's done now.
    if (!speed)   // Immediately?  Run with next.
      return handle_event(actor);
    delay = speed;
    }
  return (delay);
  }

/*
 *  Create object animator.
 */
Object_animate_actor_action::Object_animate_actor_action
  (
  Game_object *o,
  int cy,       // # of cycles.
  int spd       // Time between frames.
  ) : obj(o), cycles(cy), speed(spd)
  {
  Game_window *gwin = Game_window::get_instance();
  nframes = obj->get_num_frames();
  }

Object_animate_actor_action::Object_animate_actor_action
  (
  Game_object *o,
  int nfr,
  int cy,
  int spd
  ) : obj(o), nframes(nfr), cycles(cy), speed(spd) 
  { }
  

/*
 *  Handle tick of the clock.
 */

int Object_animate_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (!cycles) return 0;
  int frnum = (obj->get_framenum() + 1) % nframes;
  if (!frnum)     // New cycle?
    --cycles;
  obj->change_frame(frnum);
  return (cycles ? speed : 0);
  }

/*
 *  Pick up/put down an object.
 */
Pickup_actor_action::Pickup_actor_action(Game_object *o, int spd)
  : obj(o), pickup(1), speed(spd), cnt(0), 
    objpos(obj->get_tile()), dir(0)
  {
  }
          // To put down an object:
Pickup_actor_action::Pickup_actor_action(Game_object *o, Tile_coord opos, 
                int spd)
  : obj(o), pickup(0), speed(spd), cnt(0), objpos(opos), dir(0)
  {
  }

/*
 *  Pick up an item (or put it down).
 */

int Pickup_actor_action::handle_event
  (
  Actor *actor
  )
  {
  Game_window *gwin = Game_window::get_instance();
  int frnum = -1;
  switch (cnt)
    {
  case 0:       // Face object.
    dir = actor->get_direction(objpos);
    frnum = actor->get_dir_framenum(dir, Actor::standing);
    cnt++;
    break;
  case 1:       // Bend down.
    frnum = actor->get_dir_framenum(dir, Actor::bow_frame);
    cnt++;
    if (pickup)
      {
      if (actor->distance(obj) > 8)
        { // No longer nearby.
        actor->notify_object_gone(obj);
        break;
        }
      gwin->add_dirty(obj);
      obj->remove_this(1);
      actor->add(obj, 1);
      }
    else
      {
      obj->remove_this(1);
      obj->move(objpos);
      gwin->add_dirty(obj);
      }
    break;
  default:
    return 0;   // Done.
    }
  actor->change_frame(frnum);
  return speed;
  }

/*
 *  Action to turn towards a position or an object.
 */

Face_pos_actor_action::Face_pos_actor_action(Tile_coord p, int spd)
  : speed(spd), pos(p)
  {
  }
Face_pos_actor_action::Face_pos_actor_action(Game_object *o, int spd)
  : speed(spd),
    pos(o->get_tile())
  {
  }

/*
 *  Just turn to face a tile.
 */

int Face_pos_actor_action::handle_event
  (
  Actor *actor
  )
  {
  Game_window *gwin = Game_window::get_instance();
  int dir = actor->get_direction(pos);
  int frnum = actor->get_dir_framenum(dir, Actor::standing);
  if (actor->get_framenum() == frnum)
    return 0;   // There.
  actor->change_frame(frnum);
  return speed;
  }

---