schedule.cc

Go to the documentation of this file.

/*
 *  Schedule.cc - Schedules for characters.
 *
 *  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 "SDL_timer.h"
#include "schedule.h"
#include "actors.h"
#include "Zombie.h"
#include "gamewin.h"
#include "gameclk.h"
#include "gamemap.h"
#include "actions.h"
#include "dir.h"
#include "items.h"
#include "game.h"
#include "paths.h"
#include "ucmachine.h"
#include "ucsched.h"
#include "ucscriptop.h"
#include "monstinf.h"

#ifndef UNDER_CE
using std::cout;
using std::endl;
using std::rand;
#endif

/*
 *  Create. 
 */
Schedule::Schedule
  (
  Actor *n
  ) : npc(n), blocked(-1, -1, -1), street_maintenance_failures(0),
      street_maintenance_time(0)
  {
  prev_type = npc ? npc->get_schedule_type() : -1;
  }


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

void Schedule::set_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.
  int delay     // Msecs. to delay.
  )
  {
  actor->set_action(Actor_action::create_action_sequence(
      actor, dest, when_there, from_off_screen));
  actor->start(250, delay); // Get into time queue.
  }

/*
 *  Look for lamps to light/unlight and shutters to open/close.
 *
 *  Output: 1 if successful, which means npc's schedule has changed!
 */

int Schedule::try_street_maintenance
  (
  )
  {
          // What to look for:
  static int night[] = {322, 372, 889};
  static int sinight[] = {290, 291, 889};
  static int day[] = {290, 291, 526};

  long curtime = Game::get_ticks();
  if (curtime < street_maintenance_time)
    return 0;   // Not time yet.
  if (npc->Actor::get_npc_num() <= 0 ||
      npc == gwin->get_camera_actor())
    return 0;   // Only want normal NPC's.
          // At least 30secs. before next one.
  street_maintenance_time = curtime + 30000 + 
        street_maintenance_failures*5000;
  int *shapes;
  int hour = gclock->get_hour();
  bool bg = (Game::get_game_type() == BLACK_GATE);
  if (hour >= 9 && hour < 18)
    shapes = &day[0];
  else if (hour >= 18 || hour < 6)
    shapes = bg ? &night[0] : &sinight[0];
  else
    return 0;   // Dusk or dawn.
  Tile_coord npcpos = npc->get_tile();
          // Look at screen + 1/2.
  Rectangle winrect = gwin->get_win_tile_rect();
  winrect.enlarge(winrect.w/4);
  if (!winrect.has_point(npcpos.tx, npcpos.ty))
    return 0;
          // Get to within 1 tile.
  Actor_pathfinder_client cost(npc, 1);
  Game_object *found = 0;   // Find one we can get to.
  Actor_action *pact;   // Gets ->action to walk there.
  for (int i = 0; !found && i < sizeof(night)/sizeof(night[0]); i++)
    {
    Game_object_vector objs;// Find nearby.
    int cnt = npc->find_nearby(objs, shapes[i], 20, 0);
    int j;
    for (j = 0; j < cnt; j++)
      {
      Game_object *obj = objs[j];
      int shnum = obj->get_shapenum();
      if (!bg &&  // Serpent isle?  Shutters?
          (shnum == 290 || shnum == 291))
          // Want closed during day.
        if ((shapes == day) !=
          (obj->get_framenum() <= 3))
          continue;
      if ((pact = Path_walking_actor_action::create_path(
          npcpos, obj->get_tile(), cost)) != 0)
        {
        found = obj;
        break;
        }
      street_maintenance_failures++;
      }
    }
  if (!found)
    return 0;   // Failed.
          // Set actor to walk there.
  npc->set_schedule_type(Schedule::street_maintenance,
      new Street_maintenance_schedule(npc, pact, found));
  street_maintenance_failures = 0;// We did it, so clear failures.
  return 1;
  }

/*
 *  Get actual schedule (for Usecode intrinsic).
 */

int Schedule::get_actual_type
  (
  Actor *npc
  )
  {
  return npc->get_schedule_type();
  }

/*
 *  Create schedule to turn lamps on/off, open/close shutters.
 */

Street_maintenance_schedule::Street_maintenance_schedule
  (
  Actor *n, 
  Actor_action *p, 
  Game_object *o
  ) : Schedule(n), obj(o), shapenum(o->get_shapenum()),
        framenum(o->get_framenum()), paction(p)
  {
  }

/*
 *  Street-maintenance schedule.
 */

void Street_maintenance_schedule::now_what
  (
  )
  {
  if (paction)      // First time?
    {     // Set to follow given path.
    cout << npc->get_name() << 
      " walking for street maintenance" << endl;
    npc->set_action(paction);
    npc->start(250);
    paction = 0;
    return;
    }
  if (npc->distance(obj) == 1 &&  // We're there.
      obj->get_shapenum() == shapenum && obj->get_framenum() == framenum)
    {
    cout << npc->get_name() << 
      " about to perform street maintenance" << endl;
    int dir = npc->get_direction(obj);
    signed char frames[2];
    frames[0] = npc->get_dir_framenum(dir, Actor::standing);
    frames[1] = npc->get_dir_framenum(dir, 3);
    signed char standframe = frames[0];
    npc->set_action(new Sequence_actor_action(
      new Frames_actor_action(frames, sizeof(frames)),
      new Activate_actor_action(obj),
      new Frames_actor_action(&standframe, 1)));
    npc->start(250);
    switch (shapenum)
      {
    case 322:   // Closing shutters.
    case 372:
      npc->say(first_close_shutters, last_close_shutters);
      break;
    case 290:   // Open shutters (or both for SI).
    case 291:
      if (Game::get_game_type() == BLACK_GATE)
        npc->say(first_open_shutters, 
              last_open_shutters);
      else    // SI.
        if (framenum <= 3)
          npc->say(first_open_shutters, 
              last_open_shutters);
        else
          npc->say(first_close_shutters, 
              last_close_shutters);
      break;
    case 889:   // Turn on lamp.
      npc->say(first_lamp_on, last_lamp_on);
      break;
    case 526:   // Turn off lamp.
      npc->say(lamp_off, lamp_off);
      break;
      }
    shapenum = 0;   // Don't want to repeat.
    return;
    }
  cout << npc->get_name() << 
      " done with street maintenance" << endl;
        // Set back to old schedule.
  int period = gclock->get_hour()/3;
  npc->update_schedule(period, 7, 0);
  }

/*
 *  Get actual schedule (for Usecode intrinsic).
 */

int Street_maintenance_schedule::get_actual_type
  (
  Actor * /* npc */
  )
  {
  return prev_type;
  }

/*
 *  What do we do now?
 */

void Follow_avatar_schedule::now_what
  (
  )
  {
  bool is_blocked = blocked.tx != -1;
  blocked = Tile_coord(-1, -1, -1);
  if (npc->get_flag(Obj_flags::asleep) || npc->is_dead() ||
      npc->get_flag(Obj_flags::paralyzed) ||
      gwin->main_actor_dont_move()) // Under Usecode control.
    return;     // Disabled.
  Actor *av = gwin->get_main_actor();
  Tile_coord leaderpos = av->get_tile();
  Tile_coord pos = npc->get_tile();
  int dist2lead = leaderpos.distance(pos);
  if (!av->is_moving() &&   // Avatar stopped.
      dist2lead <= 6)   // And we're already close enough.
    return;
  uint32 curtime = SDL_GetTicks();// Want the REAL time here.
  if (!is_blocked)    // Not blocked?
    {
    npc->follow(av);  // Then continue following.
    return;
    }
  if (curtime < next_path_time) // Failed pathfinding recently?
    {     // Wait a bit.
    npc->start(gwin->get_std_delay(), next_path_time - curtime);
    return;
    }
          // Find a free spot within 3 tiles.
  Map_chunk::Find_spot_where where = Map_chunk::anywhere;
          // And try to be inside/outside.
  where = gwin->is_main_actor_inside() ?
          Map_chunk::inside : Map_chunk::outside;
  Tile_coord goal = Map_chunk::find_spot(leaderpos, 3, npc, 0, where);
  if (goal.tx == -1)    // No free spot?  Give up.
    {
    cout << npc->get_name() << " can't find free spot" << endl;
    next_path_time = SDL_GetTicks() + 1000;
    return;
    }
          // Get his speed.
  int speed = av->get_frame_time();
  if (!speed)     // Avatar stopped?
    speed = gwin->get_std_delay();
  if (pos.distance(goal) <= 3)
    return;     // Already close enough!
#if 0
#ifdef DEBUG
  cout << npc->get_name() << " at distance " << dist2lead 
        << " trying to catch up." << endl;
#endif
#endif
          // Succeed if within 3 tiles of goal.
  if (npc->walk_path_to_tile(goal, speed - speed/4, 0, 3, 1))
    return;     // Success.
  cout << "... but failed to find path." << endl;
          // On screen (roughly)?
  int ok;
          // Get window rect. in tiles.
  Rectangle wrect = gwin->get_win_tile_rect();
  if (wrect.has_point(pos.tx - pos.tz/2, pos.ty - pos.tz/2))
          // Try walking off-screen.
    ok = npc->walk_path_to_tile(Tile_coord(-1, -1, -1),
              speed - speed/4, 0);
  else        // Off screen already?
    ok = npc->approach_another(av);
  if (!ok)      // Failed? Don't try again for a bit.
    next_path_time = SDL_GetTicks() + 1000;
  }

/*
 *  Waiting...
 */

void Wait_schedule::now_what
  (
  )
  {
  }

/*
 *  Create a horizontal pace schedule.
 */

Pace_schedule *Pace_schedule::create_horiz
  (
  Actor *n
  )
  {
  Tile_coord t = n->get_tile(); // Get his position.
  return (new Pace_schedule(n, Tile_coord(t.tx - 4, t.ty, t.tz),
          Tile_coord(t.tx + 4, t.ty, t.tz)));
  }

/*
 *  Create a vertical pace schedule.
 */

Pace_schedule *Pace_schedule::create_vert
  (
  Actor *n
  )
  {
  Tile_coord t = n->get_tile(); // Get his position.
  return (new Pace_schedule(n, Tile_coord(t.tx, t.ty - 4, t.tz),
          Tile_coord(t.tx, t.ty + 4, t.tz)));
  }

/*
 *  Schedule change for pacing:
 */

void Pace_schedule::now_what
  (
  )
  {
  if (rand() % 6 == 0)    // Check for lamps, etc.
    if (try_street_maintenance())
      return;   // We no longer exist.
  which = !which;     // Flip direction.
  int delay = 750;    // Delay .75 secs.
  if (blocked.tx != -1)   // Blocked?
    {
    Game_object *obj = Game_object::find_blocking(blocked);
    blocked.tx = -1;
    Monster_info *minfo = npc->get_info().get_monster_info();
    if (obj && obj->as_actor() != 0 &&
        (!minfo || !minfo->cant_yell()))
      {
      npc->say(first_move_aside, last_move_aside);
      delay = 1200; // Wait longer.
      }
    }
          // Wait 1 sec. before moving.
  npc->walk_to_tile(which ? p1 : p0, gwin->get_std_delay(), delay);
  }

/*
 *  Eat at inn.
 */

void Eat_at_inn_schedule::now_what
  (
  )
  {
  int frnum = npc->get_framenum();
  if ((frnum&0xf) != Actor::sit_frame)
    {     // First have to sit down.
    if (!Sit_schedule::set_action(npc))
      {   // Try again in a while.
      npc->start(250, 5000);
      return;
      }
    }
  Game_object_vector foods;     // Food nearby?
  int cnt = npc->find_nearby(foods, 377, 2, 0);
  if (cnt)      // Found?
    {     // Find closest.
    Game_object *food = 0;
    int dist = 500;
    for (Game_object_vector::const_iterator it = foods.begin();
          it != foods.end(); ++it)
      {
      Game_object *obj = *it;
      int odist = obj->distance(npc);
      if (odist < dist)
        {
        dist = odist;
        food = obj;
        }
      }
    if (rand()%5 == 0)
      {
      gwin->add_dirty(food);
      food->remove_this();
      }
    if (rand()%4)
      npc->say(first_munch, last_munch);
    }
  else if (rand()%4)
    npc->say(first_more_food, last_more_food);
          // Wake up in a little while.
  npc->start(250, 5000 + rand()%12000);
  }

/*
 *  Find someone listening to the preacher.
 */

Actor *Find_congregant
  (
  Actor *npc
  )
  {
  Actor_vector vec, vec2;
  if (!npc->find_nearby_actors(vec, c_any_shapenum, 16))
    return 0;
  vec2.reserve(vec.size()); // Get list of ones to consider.
  for (Actor_vector::const_iterator it = vec.begin();
            it != vec.end(); ++it)
    {
    Actor *act = *it;
    if (act->get_schedule_type() == Schedule::sit &&
              !act->is_in_party())
      vec2.push_back(act);
    }
  return vec2.size() ? vec2[rand()%vec2.size()] : 0;
  }

/*
 *  Preach:
 */

void Preach_schedule::now_what
  (
  )
  {
  switch (state)
    {
  case find_podium:
    {
    Game_object_vector vec;
    if (!npc->find_nearby(vec, 697, 17, 0))
      {
      npc->set_schedule_type(loiter);
      return;
      }
    Game_object *podium = vec[0];
    Tile_coord pos = podium->get_tile();
    static int deltas[4][2] = {{-1, 0},{1, 0},{0, -2},{0, 1}};
    int frnum = podium->get_framenum()%4;
    pos.tx += deltas[frnum][0];
    pos.ty += deltas[frnum][1];
    Actor_pathfinder_client cost(npc, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
      npc->get_tile(), pos, cost);
    if (pact)
      {
      state = at_podium;
      npc->set_action(new Sequence_actor_action(pact,
        new Face_pos_actor_action(podium, 200)));
      npc->start(gwin->get_std_delay());
      return;
      }
    npc->start(250, 5000 + rand()%5000);  // Try again later.
    return;
    }
  case at_podium:
    if (rand()%2)   // Just wait a little.
      npc->start(gwin->get_std_delay(), rand()%3000);
    else 
      {
      if (rand()%3)
        state = exhort;
      else if ((GAME_SI) || rand()%3)
        state = visit;
      else
        state = find_icon;
      npc->start(gwin->get_std_delay(), 2000 + rand()%2000);
      }
    return;
  case exhort:
    {
    signed char frames[8];    // Frames.
    int cnt = 1 + rand()%(sizeof(frames) - 1);
          // Frames to choose from:
    static char choices[3] = {0, 8, 9};
    for (int i = 0; i < cnt - 1; i++)
      frames[i] = npc->get_dir_framenum(
          choices[rand()%(sizeof(choices))]);
          // Make last one standing.
    frames[cnt - 1] = npc->get_dir_framenum(Actor::standing);
    npc->set_action(new Frames_actor_action(frames, cnt, 250));
    npc->start(gwin->get_std_delay());
    npc->say(first_preach, last_preach);
    state = at_podium;
    Actor *member = Find_congregant(npc);
    if (member)
      {
      Usecode_script *scr = new Usecode_script(member);
      scr->add(Ucscript::delay_ticks, 3);
      scr->add(Ucscript::face_dir, member->get_dir_facing());
      scr->add(Ucscript::npc_frame + Actor::standing);
      scr->add(Ucscript::say, item_names[first_amen +
          rand()%(last_amen - first_amen + 1)]);
      scr->add(Ucscript::delay_ticks, 2);
      scr->add(Ucscript::npc_frame + Actor::sit_frame);
      scr->start(); // Start next tick.
      }
    return;
    }
  case visit:
    {
    state = find_podium;
    npc->start(gwin->get_std_delay(), 1000 + rand()%2000);
    Actor *member = Find_congregant(npc);
    if (!member)
      return;
    Tile_coord pos = member->get_tile();
    Actor_pathfinder_client cost(npc, 1);
    Actor_action *pact = Path_walking_actor_action::create_path(
      npc->get_tile(), pos, cost);
    if (!pact)
      return;
    npc->set_action(new Sequence_actor_action(pact,
        new Face_pos_actor_action(member, 200)));
    state = talk_member;
    return;
    }
  case talk_member:
    state = find_podium;
    npc->say(first_preach2, last_preach2);
    npc->start(250, 2000);
    return;
  case find_icon:
    {
    state = find_podium;    // In case we fail.
    npc->start(2*gwin->get_std_delay());
    Game_object *icon = npc->find_closest(724);
    if (!icon)
      return;
    Tile_coord pos = icon->get_tile();
    pos.tx += 2;
    pos.ty -= 1;
    Actor_pathfinder_client cost(npc, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
      npc->get_tile(), pos, cost);
    if (pact)
      {
      static char f[] = {Actor::standing, Actor::bow_frame, 
        Actor::kneel_frame, Actor::kneel_frame,
        Actor::kneel_frame, Actor::kneel_frame,
        Actor::bow_frame, Actor::standing};
      npc->set_action(pact);
      state = pray;
      }
    return;
    }
  case pray:
    {
    Usecode_script *scr = new Usecode_script(npc);
    (*scr) << Ucscript::face_dir << 6 // Face west.
      << (Ucscript::npc_frame + Actor::standing)
      << (Ucscript::npc_frame + Actor::bow_frame)
      << Ucscript::delay_ticks << 3
      << (Ucscript::npc_frame + Actor::kneel_frame);
    scr->add(Ucscript::say, item_names[first_amen + rand()%2]);
    (*scr)  << Ucscript::delay_ticks << 5
      << (Ucscript::npc_frame + Actor::bow_frame)
      << Ucscript::delay_ticks << 3
      << (Ucscript::npc_frame + Actor::standing);
      scr->start(); // Start next tick.
    state = find_podium;
    npc->start(2*gwin->get_std_delay(), 4000);
    return;
    }
  default:
    state = find_podium;
    npc->start(250);
    return;
    }
  }

/*
 *  Schedule change for patroling:
 */

void Patrol_schedule::now_what
  (
  )
  {
  if (sitting)      // Sitting?
    {
          // Stay 5-15 secs.
    if ((npc->get_framenum()&0xf) == Actor::sit_frame)
      npc->start(250, 5000 + rand()%10000);
    else      // Not sitting.
      npc->start(250, rand()%1000);
    sitting = false;  // Continue on afterward.
    find_next = true;
    return;
    }
  if (rand() % 8 == 0)    // Check for lamps, etc.
    if (try_street_maintenance())
      return;   // We no longer exist.
  const int PATH_SHAPE = 607;
  Game_object *path;
  if (!find_next &&
      pathnum >= 0 &&   // Arrived at path?
      pathnum < paths.size() && (path = paths[pathnum]) != 0 &&
      npc->distance(path) < 2)
          // Quality = type.  (I think high bits
          //   are flags.
    switch (path->get_quality()&31)
      {
    case 0:     // None.
      break;
    case 1:     // Wrap to 0.
      pathnum = -1;
      dir = 1;
      break;
    case 2:     // Pause.
      break;    //++++++++
    case 3:     // Sit.
      if (Sit_schedule::set_action(npc))
        {
        sitting = true;
        return;
        }
      break;
    case 4:     // Kneel at tombstone.+++++++
    case 5:     // Kneel+++++++++++
    case 6:     // Loiter.++++++
      break;
    case 7:     // Left about-face.
    case 8:     // Right about-face.
      if (pathnum == 0 && dir == -1)
        dir = 1;
      else if (pathnum > 0 && dir == 1)
        dir = -1;
          // ++++Turn animations.
      break;
    case 9:     // Horiz. pace.+++++++
    case 10:    // Vert. pace+++++++
    case 11:    // 50% reverse.
    case 12:    // 50% skip next.
    case 13:    // Hammer.++++++
    case 14:    // Check area.
      break;    //++++++Implement above.
    case 15:    // Usecode.
      {   // Schedule so we don't get deleted.
      Usecode_script *scr = new Usecode_script(npc);
          // Don't let this script halt others,
          //   as it messes up automaton in
          //   SI-Freedom.
      (*scr) << Ucscript::dont_halt <<
        Ucscript::usecode2 << npc->get_usecode() <<
            static_cast<int>(Usecode_machine::npc_proximity);
      scr->start(); // Start next tick.
      find_next = true; // THEN, find next path.
      npc->start(250, 500);
      return;
      }
    case 16:    // Bow to ground.  ++++Implement.
    case 17:    // Bow from ground.+++++
    case 18:    // Wait for semaphore+++++
    case 19:    // Release semaphore+++++
    case 20:    // Ready weapon++++++++
    case 21:    // Unready weapon+++++++
    case 22:    // One-handed swing.+++++
    case 23:    // Two-handed swing.
    case 24:    // Read++++++
    case 25:    // 50% wrap to 0.++++++
    case 26:    // Combat near??
    case 27:    // Repeat forever??
    default:
      break;
      }
  pathnum += dir;     // Find next path.
  find_next = false;    // We're doing it.
          // Already know its location?
  path =  pathnum >= 0 && pathnum < paths.size() ? paths[pathnum] : 0;
  if (!path)      // No, so look around.
    {
    Game_object_vector nearby;
    npc->find_nearby(nearby, PATH_SHAPE, 25, 0);
    int best_dist = 1000; // Find closest.
    for (Game_object_vector::const_iterator it = nearby.begin();
            it != nearby.end(); ++it)
      {
      Game_object *obj = *it;
      int framenum = obj->get_framenum();
      int dist;
      if (framenum == pathnum && 
          (dist = obj->distance(npc)) < best_dist)
        { // Found it.
        path = obj;
        best_dist = dist;
        }
      }
    if (path)   // Save it.
      {
      failures = 0;
      paths.put(pathnum, path);
      }
    else      // Turn back if at end.
      {
      failures++;
      dir = 1;
      if (pathnum == 0) // At start?  Retry.
        {
        if (failures < 4)
          {
          pathnum = -1;
          npc->start(200, 500);
          return;
          }
          // After 4, fall through.
        }
      else    // At end, go back to start.
        {
        pathnum = 0;
        path = paths.size() ? paths[0] : 0;
        }
      }
    if (!path)    // Still failed?
      {
          // Wiggle a bit.
      Tile_coord pos = npc->get_tile();
      int dist = failures + 2;
      Tile_coord delta = Tile_coord(rand()%dist - dist/2,
          rand()%dist - dist, 0);
      npc->walk_to_tile(pos + delta, gwin->get_std_delay(), 
                failures*300);
      int pathcnt = paths.size();
      pathnum = rand()%(pathcnt < 4 ? 4 : pathcnt);
      return;
      }
    }
  Tile_coord d = path->get_tile();
      if (!npc->walk_path_to_tile(d, gwin->get_std_delay(), rand()%1000))
    {   
          // Look for free tile within 1 square.
    d = Map_chunk::find_spot(d, 1, npc->get_shapenum(),
            npc->get_framenum(), 1);
    if (d.tx == -1 || !npc->walk_path_to_tile(d,
          gwin->get_std_delay(), rand()%1000))
      {   // Failed.  Later.
      npc->start(200, 2000);
      return;
      }
    }
  }

/*
 *  Schedule change for 'talk':
 */

void Talk_schedule::now_what
  (
  )
  {

  // Switch to phase 3 if we are reasonable close
  if (phase != 0 && phase != 4 &&
      npc->distance(gwin->get_main_actor()) < 8)
    phase = 3;

  switch (phase)
    {
  case 0:       // Start by approaching Avatar.
    {
    if (npc->distance(gwin->get_main_actor()) > 50)
      {   // Too far?  
          // Try a little later.
      npc->start(250, 5000);
      return;
      }
          // Aim for within 5 tiles.
    Actor_pathfinder_client cost(npc, 5);
    Actor_action *pact = Path_walking_actor_action::create_path(
      npc->get_tile(),
      gwin->get_main_actor()->get_tile(), cost);
    if (!pact)
      {
#ifdef DEBUG
      cout << "Talk: Failed to find path for " << 
            npc->get_name() << endl;
#endif
      npc->follow(gwin->get_main_actor());
      }
    else
      {
          // Walk there, and retry if
          //   blocked.
      npc->set_action(pact);
      npc->start(400, 250); // Start walking.
      }
    phase++;
    return;
    }
  case 1:       // Wait a second.
  case 2:
    {
    int dx = 1 - 2*(rand()%2);
    npc->walk_to_tile(npc->get_tile() +
      Tile_coord(dx, -dx, 0), 300, 500);
          // Wait til conversation is over.
//    if (ucmachine->get_num_faces_on_screen() == 0)
//      phase++;
      phase = 3;
    return;
    }
  case 3:       // Talk.
          // Got to be reachable.
    if (!Fast_pathfinder_client::is_grabable(
      npc->get_tile(),
      gwin->get_main_actor()->get_tile()))
      {
      phase = 0;
      npc->start(250, 1000);
      return;
      }
          // But first face Avatar.
    npc->change_frame(npc->get_dir_framenum(npc->get_direction(
        gwin->get_main_actor()), Actor::standing));
    phase++;
    npc->start(250, 250); // Wait another 1/4 sec.
    break;
  case 4:
    npc->stop();    // Stop moving.
          // NOTE:  This could DESTROY us!
    if (Game::get_game_type() == SERPENT_ISLE)
      npc->activate(9);
    else
      npc->activate(1);
          // SO don't refer to any instance
          //   variables from here on.
    gwin->paint();
    return;
  default:
    break;
    }
  }

/*
 *  Create a loiter schedule.
 */

Loiter_schedule::Loiter_schedule
  (
  Actor *n,
  int d       // Distance in tiles to roam.
  ) : Schedule(n), center(n->get_tile()), dist(d)
  {
  }

/*
 *  Schedule change for 'loiter':
 */

void Loiter_schedule::now_what
  (
  )
  {
  if (rand() % 3 == 0)    // Check for lamps, etc.
    if (try_street_maintenance())
      return;   // We no longer exist.
  int newx = center.tx - dist + rand()%(2*dist);
  int newy = center.ty - dist + rand()%(2*dist);
          // Wait a bit.
  npc->walk_to_tile(newx, newy, center.tz, 2*gwin->get_std_delay(), 
                rand()%2000);
  }

/*
 *  Schedule change for kid games.
 */

void Kid_games_schedule::now_what
  (
  )
  {
  Tile_coord pos = npc->get_tile();
  Actor *kid = 0;     // Get a kid to chase.
          // But don't run too far.
  while (!kids.empty())
  {
    kid = kids.pop();
    if (npc->distance(kid) < 16)
      break;
    kid = 0;
  }

  if (kid)
  {
    Fast_pathfinder_client cost(1);
    Actor_action *pact = Path_walking_actor_action::create_path(
        pos, kid->get_tile(), cost);
    if (pact)
    {
      npc->set_action(pact);
      npc->start(100, 250); // Run.
      return;
    }
  }
  else        // No more kids?  Search.
  {
    Actor_vector vec;
    npc->find_nearby_actors(vec, c_any_shapenum, 16);
    for (Actor_vector::const_iterator it = vec.begin();
            it != vec.end(); ++it)
    {
      Actor *act = *it;
      if (act->get_schedule_type() == kid_games)
        kids.push(act);
    }
  }
  Loiter_schedule::now_what();  // Wander around the start.
}

/*
 *  Schedule change for 'dance':
 */

void Dance_schedule::now_what
  (
  )
  {
  Tile_coord dest = center; // Pick new spot to walk to.
  dest.tx += -dist + rand()%(2*dist);
  dest.ty += -dist + rand()%(2*dist);
  Tile_coord cur = npc->get_tile();
  int dir = static_cast<int>(Get_direction4(cur.ty - dest.ty, dest.tx - cur.tx));
  signed char frames[4];
  for (int i = 0; i < 4; i++)
          // Spin with 'hands outstretched'.
    frames[i] = npc->get_dir_framenum((2*(dir + i))%8, 
                      npc->get_shapenum() == 846 ? 15 : 9);
          // Create action to walk.
  Actor_action *walk = new Path_walking_actor_action(new Zombie());
  walk->walk_to_tile(npc, cur, dest);
          // Walk, then spin.
  npc->set_action(new Sequence_actor_action(walk,
    new Frames_actor_action(frames, sizeof(frames), 100)));
  npc->start(gwin->get_std_delay(), 500);   // Start in 1/2 sec.
  }

/*
 *  Schedule change for mining/farming:
 */

void Tool_schedule::now_what
  (
  )
  {
  if (!tool)      // First time?
    {
    tool = new Ireg_game_object(toolshape, 0, 0, 0, 0);
          // Free up both hands.
    Game_object *obj = npc->get_readied(Actor::rhand);
    if (obj)
      obj->remove_this();
    if ((obj = npc->get_readied(Actor::lhand)) != 0)
      obj->remove_this();
    if (!npc->add_readied(tool, Actor::lrhand))
      npc->add_readied(tool, Actor::lhand);
    }
  if (rand()%4 == 0)    // 1/4 time, walk somewhere.
    {
    Loiter_schedule::now_what();
    return;
    }
  if (rand()%10 == 0)
    {
    Schedule_types ty = (Schedule_types) npc->get_schedule_type();
    if (ty == Schedule::miner)
      npc->say(first_miner, last_miner);
    else if (ty == Schedule::farm)
      npc->say(first_farmer, last_farmer);
    }
  signed char frames[12];   // Use pick.
  int cnt = npc->get_attack_frames(toolshape, false, rand()%8, frames);
  npc->set_action(new Frames_actor_action(frames, cnt));
  npc->start();     // Get back into time queue.
  }

/*
 *  End of mining/farming:
 */

void Tool_schedule::ending
  (
  int
  )
  {
  if (tool)
    tool->remove_this();  // Should safely remove from NPC.
  }

/*
 *  Schedule change for hounding the Avatar.
 */

void Hound_schedule::now_what
  (
  )
  {
  Actor *av = gwin->get_main_actor();
  Tile_coord avpos = av->get_tile(),
       npcpos = npc->get_tile();
          // How far away is Avatar?
  int dist = npcpos.distance(avpos);
  if (dist > 20 || dist < 3)  // Too far, or close enough?
    {     // Check again in a few seconds.
    npc->start(gwin->get_std_delay(), 500 + rand()%1000);
    return;
    }
  int newdist = 1 + rand()%2; // Aim for about 3 tiles from Avatar.
  Fast_pathfinder_client cost(newdist);
  avpos.tx += rand()%3 - 1; // Vary a bit randomly.
  avpos.ty += rand()%3 - 1;
  Actor_action *pact = Path_walking_actor_action::create_path(npcpos,
              avpos, cost);
  if (pact)
    {
    npc->set_action(pact);
    npc->start(gwin->get_std_delay(), 50);
    }
  else        // Try again.
    npc->start(gwin->get_std_delay(), 2000 + rand()%3000);
  }

/*
 *  Schedule change for 'wander':
 */

void Wander_schedule::now_what
  (
  )
  {
  if (rand() % 2)     // 1/2 time, check for lamps, etc.
    if (try_street_maintenance())
      return;   // We no longer exist.
  Tile_coord pos = npc->get_tile();
  const int legdist = 32;
          // Go a ways from current pos.
  pos.tx += -legdist + rand()%(2*legdist);
  pos.ty += -legdist + rand()%(2*legdist);
          // Don't go too far from center.
  if (pos.tx - center.tx > dist)
    pos.tx = center.tx + dist;
  else if (center.tx - pos.tx > dist)
    pos.tx = center.tx - dist;
  if (pos.ty - center.ty > dist)
    pos.ty = center.ty + dist;
  else if (center.ty - pos.ty > dist)
    pos.ty = center.ty - dist;
          // Find a free spot.
  Tile_coord dest = Map_chunk::find_spot(pos, 4, npc->get_shapenum(), 0,
                  1);
  if (dest.tx == -1 || !npc->walk_path_to_tile(dest,
          gwin->get_std_delay(), rand()%2000))
          // Failed?  Try again a little later.
    npc->start(250, rand()%3000);
  }

/*
 *  Stand up if not already.
 */

static void Stand_up
  (
  Actor *npc
  )
  {
  if ((npc->get_framenum()&0xf) != Actor::standing)
          // Stand.
    npc->change_frame(Actor::standing);
  }

/*
 *  Create a sleep schedule.
 */

Sleep_schedule::Sleep_schedule
  (
  Actor *n
  ) : Schedule(n), bed(0), state(0)
  {
  floorloc.tx = -1;   // Set to invalid loc.
  if (Game::get_game_type() == BLACK_GATE)
    {
    spread0 = 3;
    spread1 = 16;
    }
  else        // Serpent Isle.
    {
    spread0 = 7;
    spread1 = 20;
    }
  }

/*
 *  Schedule change for 'sleep':
 */

void Sleep_schedule::now_what
  (
  )
  {
  if (!bed && state == 0)   // Always find bed.
    {     // Find closest EW or NS bed.
    static int bedshapes[2] = {696, 1011};
    Stand_up(npc);
    bed = npc->find_closest(bedshapes, 2);
    if (!bed && GAME_BG)  // Check for Gargoyle beds.
      {
      static int gbeds[2] = {363, 312};
      bed = npc->find_closest(gbeds, 2);
      }
    }
  int frnum = npc->get_framenum();
  if ((frnum&0xf) == Actor::sleep_frame)
    return;     // Already sleeping.

  switch (state)
    {
  case 0:       // Find path to bed.
    {
    if (!bed)
      {   // Just lie down at current spot.
      int dirbits = npc->get_framenum()&(0x30);
      npc->change_frame(Actor::sleep_frame|dirbits);
      return;
      }
    state = 1;
    Game_object_vector tops;  // Want to find top of bed.
    bed->find_nearby(tops, bed->get_shapenum(), 1, 0);
    for (Game_object_vector::const_iterator it = tops.begin(); 
            it != tops.end(); ++it)
      {
      Game_object *top = *it;
      int frnum = top->get_framenum();
      if (frnum >= spread0 && frnum <= spread1)
        {
        bed = top;
        break;
        }
      }
    Tile_coord bloc = bed->get_tile();
    bloc.tz -= bloc.tz%5; // Round down to floor level.
    Shape_info& info = bed->get_info();
    bloc.tx -= info.get_3d_xtiles(bed->get_framenum())/2;
    bloc.ty -= info.get_3d_ytiles(bed->get_framenum())/2;
          // Get within 3 tiles.
    Actor_pathfinder_client cost(npc, 3);
    Actor_action *pact = Path_walking_actor_action::create_path(
        npc->get_tile(), bloc, cost);
    if (pact)
      npc->set_action(pact);
    npc->start(200);  // Start walking.
    break;
    }
  case 1:       // Go to bed.
    {
    npc->stop();    // Just to be sure.
    int bedshape = bed->get_shapenum();
    int dir = (bedshape == 696 || bedshape == 363) ? west : north;
    npc->set_frame(npc->get_dir_framenum(dir, Actor::sleep_frame));
          // Get bed info.
    Shape_info& info = bed->get_info();
    Tile_coord bedloc = bed->get_tile();
    floorloc = npc->get_tile();
    int bedframe = bed->get_framenum();// Unmake bed.
    if (bedframe >= spread0 && bedframe < spread1 && (bedframe%2))
      {
      bedframe++;
      bed->change_frame(bedframe);
      }
    int bedspread = (bedframe >= spread0 && !(bedframe%2));
          // Put NPC on top of bed.
    npc->move(bedloc.tx, bedloc.ty, bedloc.tz + 
        (bedspread ? 0 : info.get_3d_height()));
    state = 2;
    break;
    }
  default:
    break;
    }
  }

/*
 *  Wakeup time.
 */

void Sleep_schedule::ending
  (
  int new_type      // New schedule.
  )
  {
          // Needed for Skara Brae.
  if (new_type == static_cast<int>(wait) || 
          // Not time to get up, Penumbra!
      new_type == static_cast<int>(sleep))
    return;     // ++++Does this leave NPC's stuck?++++
  if (bed &&      // Still in bed?
      (npc->get_framenum()&0xf) == Actor::sleep_frame &&
      npc->distance(bed) < 8)
    {     // Locate free spot.
    if (floorloc.tx == -1)
          // Want spot on floor.
      floorloc = npc->get_tile();
    floorloc.tz -= floorloc.tz%5;
    Tile_coord pos = Map_chunk::find_spot(floorloc, 
        6, npc->get_shapenum(), 
        static_cast<int>(Actor::standing), 0);
    if (pos.tx == -1) // Failed?  Allow change in lift.
      pos = Map_chunk::find_spot(floorloc,
        6, npc->get_shapenum(), 
        static_cast<int>(Actor::standing), 1);
    floorloc = pos;
          // Make bed.
    int frnum = bed->get_framenum();
    Actor_vector occ; // Unless there's another occupant.
    if (frnum >= spread0 && frnum <= spread1 && !(frnum%2) &&
        bed->find_nearby_actors(occ, c_any_shapenum, 0) < 2)
      bed->set_frame(frnum - 1);
    }
  if (floorloc.tx >= 0)   // Get back on floor.
    npc->move(floorloc);
  npc->set_frame(Actor::standing);
  gwin->set_all_dirty();    // Update all, since Av. stands up.
  state = 0;      // In case we go back to sleep.
  }

/*
 *  Create a 'sit' schedule.
 */

Sit_schedule::Sit_schedule
  (
  Actor *n,
  Game_object *ch     // Chair, or null to find one.
  ) : Schedule(n), chair(ch), sat(false), did_barge_usecode(false)
  {
  }

/*
 *  Schedule change for 'sit':
 */

void Sit_schedule::now_what
  (
  )
  {
  int frnum = npc->get_framenum();
  if (chair && (frnum&0xf) == Actor::sit_frame && 
      npc->distance(chair) <= 1)
    {     // Already sitting.
          // Seat on barge?
    if (!chair || chair->get_shapenum() != 292)
      return;
    if (did_barge_usecode)
      return;   // But NOT more than once for party.
    did_barge_usecode = true;
    if (gwin->get_moving_barge())
      return;   // Already moving.
    if (!npc->is_in_party())
      return;   // Not a party member.
    Actor *party[9];  // See if all sitting.
    int cnt = gwin->get_party(&party[0], 1);
    for (int i = 0; i < cnt; i++)
      if ((party[i]->get_framenum()&0xf) != Actor::sit_frame)
        return; // Nope.
          // Find barge.
    Game_object *barge = chair->find_closest(961);
    if (!barge)
      return;
    int usefun = 0x634; // I hate using constants like this.
    did_barge_usecode = true;
          // Special usecode for barge pieces:
          // (Call with item=Avatar to avoid
          //   running nearby barges.)
    ucmachine->call_usecode(usefun, gwin->get_main_actor(),
          Usecode_machine::double_click);
    return;
    }
          // Wait a while if we got up.
  if (!set_action(npc, chair, sat ? (2000 + rand()%3000) : 0, &chair))
    npc->start(200, 5000);  // Failed?  Try again later.
  else
    sat = true;
  }

/*
 *  Action to sit in the chair NPC is in front of.
 */

class Sit_actor_action : public Frames_actor_action, public Game_singletons
  {
  Game_object *chair;   // Chair.
  Tile_coord chairloc;    // Original chair location.
  Tile_coord sitloc;    // Actually where NPC sits.
  signed char frames[2];
  static short offsets[8];  // Offsets where NPC should sit.
  signed char *init(Game_object *chairobj, Actor *actor)
    {
          // Frame 0 faces N, 1 E, etc.
    int dir = 2*(chairobj->get_framenum()%4);
    frames[0] = actor->get_dir_framenum(dir, Actor::bow_frame);
    frames[1] = actor->get_dir_framenum(dir, Actor::sit_frame);
    return frames;
    }
  static bool is_occupied(Tile_coord sitloc, Actor *actor)
    {
    Game_object_vector occ; // See if occupied.
    if (Game_object::find_nearby(occ, sitloc,c_any_shapenum, 0, 8))
      for (Game_object_vector::const_iterator it = 
          occ.begin(); it != occ.end(); ++it)
        {
        Game_object *npc = *it;
        if (npc == actor)
          continue;
        int frnum = npc->get_framenum() & 15;
        if (frnum == Actor::sit_frame ||
            frnum == Actor::bow_frame)
          return true;
        }
#if 1 /* Seems to work.  Added Nov. 2, 2001 */
    if (actor->get_tile() == sitloc)
      return false; // We're standing there.
          // See if spot is blocked.
    Tile_coord pos = sitloc;// Careful, .tz gets updated.
    if (Map_chunk::is_blocked(pos, 
          actor->get_info().get_3d_height(), MOVE_WALK, 0))
      return true;
#endif
    return false;
    }
public:
  Sit_actor_action(Game_object *o, Actor *actor) : chair(o),
      Frames_actor_action(init(o, actor), 2)
    {
    sitloc = chairloc = o->get_tile();
          // Frame 0 faces N, 1 E, etc.
    int nsew = o->get_framenum()%4;
    sitloc.tx += offsets[2*nsew];
    sitloc.ty += offsets[2*nsew + 1];
    }
  Tile_coord get_sitloc() const
    { return sitloc; }
  static bool is_occupied(Game_object *chair, Actor *actor)
    {
    int dir = 2*(chair->get_framenum()%4);
    return is_occupied(chair->get_tile() +
      Tile_coord(offsets[dir], offsets[dir + 1], 0), actor);
    }
          // Handle time event.
  virtual int handle_event(Actor *actor);
  };

          // Offsets where NPC should sit:
short Sit_actor_action::offsets[8] = {0,-1, 1,0, 0,1, -1,0};

/*
 *  Show frame for sitting down.
 */

int Sit_actor_action::handle_event
  (
  Actor *actor
  )
  {
  if (get_index() == 0)   // First time?
    {
    if (is_occupied(sitloc, actor))
      return 0; // Abort.
    if (chair->get_tile() != chairloc)
      {   // Chair was moved!
      actor->say(first_chair_thief, last_chair_thief);
      return 0;
      }
    }
  return Frames_actor_action::handle_event(actor);
  }

/*
 *  Is chair occupied, other than by 'actor'?
 */

bool Sit_schedule::is_occupied
  (
  Game_object *chairobj,
  Actor *actor
  )
  {
  return Sit_actor_action::is_occupied(chairobj, actor);
  }

/*
 *  Set up action.
 *
 *  Output: false if couldn't find a free chair.
 */

bool Sit_schedule::set_action
  (
  Actor *actor,
  Game_object *chairobj,    // May be 0 to find it.
  int delay,      // Msecs. to delay.
  Game_object **chair_found // ->chair ret'd if not NULL.
  )
  {
  static int chairshapes[] = {873,292};
  Game_object_vector chairs;
  if (chair_found)
    *chair_found = 0; // Init. in case we fail.
  if (!chairobj)      // Find chair if not given.
    {
    actor->find_closest(chairs, chairshapes,
          sizeof(chairs)/sizeof(chairs[0]));
    for (Game_object_vector::const_iterator it = chairs.begin();
            it != chairs.end(); ++it)
      if (!Sit_actor_action::is_occupied((*it), actor))
        { // Found an unused one.
        chairobj = *it;
        break;
        }
    if (!chairobj)
      return false;
    }
  else if (Sit_actor_action::is_occupied(chairobj, actor))
    return false;   // Given chair is occupied.
  Sit_actor_action *act = new Sit_actor_action(chairobj, actor);
          // Walk there, then sit.
  set_action_sequence(actor, act->get_sitloc(), act, false, delay);
  if (chair_found)
    *chair_found = chairobj;
  return true;
  }

/*
 *  Desk work.
 */

Desk_schedule::Desk_schedule
  (
  Actor *n
  ) : Schedule(n), chair(0)
  {
  }

/*
 *  Schedule change for 'desk work':
 */

void Desk_schedule::now_what
  (
  )
  {
  if (!chair)     // No chair found yet.
    {
    static int desks[2] = {283, 407};
    static int chairs[2] = {873,292};
    Stand_up(npc);
    Game_object *desk = npc->find_closest(desks, 2);
    if (desk)
      chair = desk->find_closest(chairs, 2);
    if (!chair)   // Failed.
      {   // Try again in a few seconds.
      npc->start(200, 5000);
      return; 
      }
    }
  int frnum = npc->get_framenum();
  if ((frnum&0xf) != Actor::sit_frame)
    {
    if (!Sit_schedule::set_action(npc, chair, 0))
      {
      chair = 0;  // Look for any nearby chair.
      npc->start(200, 5000);  // Failed?  Try again later.
      }
    else
      npc->start(250, 0);
    }
  else        // Stand up a second.
    {
    signed char frames[3];
    frames[0] = npc->get_dir_framenum(Actor::standing);
    frames[1] = npc->get_dir_framenum(Actor::bow_frame);
    frames[2] = npc->get_dir_framenum(Actor::sit_frame);
    npc->set_action(new Frames_actor_action(frames,
          sizeof(frames)/sizeof(frames[0])));
    npc->start(250, 10000 + rand()%5000);
    }
  }

/*
 *  A class for indexing the perimeter of a rectangle.
 */
class Perimeter
  {
  Rectangle perim;    // Outside given rect.
  int sz;       // # squares.
public:
  Perimeter(Rectangle &r) : sz(2*r.w + 2*r.h + 4)
    {
    perim = r;
    perim.enlarge(1);
    }
  int size() { return sz; }
          // Get i'th tile.
  void get(int i, Tile_coord& ptile, Tile_coord& atile);
#if 0
  static void test()
    {
    Rectangle r(10, 10, 3, 4);
    Perimeter p(r);
    int cnt = p.size();
    for (int i = 0; i < cnt; i++)
      {
      Tile_coord pt, at;
      p.get(i, pt, at);
      cout << "pt.tx = " << pt.tx << ", pt.ty = " << pt.ty
        << ", at.tx = " << at.tx << ", at.ty = " <<
        at.ty << endl;
      }
    }
#endif
  };

/*
 *  Get the i'th perimeter tile and the tile in the original rect.
 *  that's adjacent.
 */

void Perimeter::get
  (
  int i,
  Tile_coord& ptile,    // Perim. tile returned.
  Tile_coord& atile   // Adjacent tile returned.
  )
  {
  if (i < perim.w - 1)    // Spiral around from top-left.
    {
    ptile = Tile_coord(perim.x + i, perim.y, 0);
    atile = ptile + Tile_coord(!i ? 1 : 0, 1, 0);
    return;
    }
  i -= perim.w - 1;
  if (i < perim.h - 1)
    {
    ptile = Tile_coord(perim.x + perim.w - 1, perim.y + i, 0);
    atile = ptile + Tile_coord(-1, !i ? 1 : 0, 0);
    return;
    }
  i -= perim.h - 1;
  if (i < perim.w - 1)
    {
    ptile = Tile_coord(perim.x + perim.w - 1 - i,
          perim.y + perim.h - 1, 0);
    atile = ptile + Tile_coord(!i ? -1 : 0, -1, 0);
    return;
    }
  i -= perim.w - 1;
    {
    ptile = Tile_coord(perim.x, perim.y + perim.h - 1 - i, 0);
    atile = ptile + Tile_coord(1, !i ? -1 : 0, 0);
    return;
    }
          // Bad index if here.
  get(i%sz, ptile, atile);
  }

/*
 *  Initialize.
 */

void Lab_schedule::init
  (
  )
  {
  chair = book = 0;
  cauldron = npc->find_closest(995, 20);
          // Find 'lab' tables.
  npc->find_nearby(tables, 1003, 20, 0);
  npc->find_nearby(tables, 1018, 20, 0);
  int cnt = tables.size();  // Look for book, chair.
  for (int i = 0; (!book || !chair) && i < cnt; i++)
    {
    static int chairs[2] = {873,292};
    Game_object *table = tables[i];
    Rectangle foot = table->get_footprint();
          // Book on table?
    if (!book && (book = table->find_closest(642, 4)) != 0)
      {
      Tile_coord p = book->get_tile();
      if (!foot.has_point(p.tx, p.ty))
        book = 0;
      }
    if (!chair)
      chair = table->find_closest(chairs, 2, 4);
    }
  }

/*
 *  Create lab schedule.
 */

Lab_schedule::Lab_schedule
  (
  Actor *n
  ) : Schedule(n), state(start)
  {
  init();
  }

/*
 *  Lab work.
 */

void Lab_schedule::now_what
  (
  )
  {
  Tile_coord npcpos = npc->get_tile();
  int delay = 100;    // 1/10 sec. to next action.
          // Often want to get within 1 tile.
  Actor_pathfinder_client cost(npc, 1);
  switch (state)
    {
  case start:
  default:
    {
    if (!cauldron)
      {   // Try looking again.
      init();
      if (!cauldron)  // Again a little later.
        delay = 6000;
      break;
      }
    int r = rand()%5; // Pick a state.
    if (!r)     // Sit less often.
      state = sit_down;
    else
      state = r <= 2 ? walk_to_cauldron : walk_to_table;
    break;
    }
  case walk_to_cauldron:
    {
    state = start;    // In case we fail.
    if (!cauldron)
      break;
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, cauldron->get_tile(), cost);
    if (pact)
      {
      npc->set_action(new Sequence_actor_action(pact,
        new Face_pos_actor_action(cauldron, 200)));
      state = use_cauldron;
      }
    break;
    }
  case use_cauldron:
    {
    int dir = npc->get_direction(cauldron);
          // Set random frame (skip last frame).
    cauldron->change_frame(rand()%(cauldron->get_num_frames() -1));
    npc->change_frame(
      npc->get_dir_framenum(dir, Actor::bow_frame));
    int r = rand()%5;
    state = !r ? use_cauldron : (r <= 2 ? sit_down
            : walk_to_table);
    break;
    }
  case sit_down:
    if (!chair || !Sit_schedule::set_action(npc, chair, 200))
      state = start;
    else
      state = read_book;
    break;
  case read_book:
    {
    state = stand_up;
    if (!book || npc->distance(book) > 4)
      break;
          // Read a little while.
    delay = 1000 + 1000*(rand()%5);
          // Open book.
    int frnum = book->get_framenum();
    book->change_frame(frnum - frnum%3);
    break;
    }
  case stand_up:
    {
    if (book && npc->distance(book) < 4)
      {   // Close book.
      int frnum = book->get_framenum();
      book->change_frame(frnum - frnum%3 + 1);
      }
    state = start;
    break;
    }
  case walk_to_table:
    {
    state = start;    // In case we fail.
    int ntables = tables.size();
    if (!ntables)
      break;
    Game_object *table = tables[rand()%ntables];
    Rectangle r = table->get_footprint();
    Perimeter p(r);   // Find spot adjacent to table.
    Tile_coord spot;  // Also get closest spot on table.
    p.get(rand()%p.size(), spot, spot_on_table);
    Actor_pathfinder_client cost0(npc, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
              npcpos, spot, cost0);
    if (!pact)
      break;    // Failed.
    Shape_info& info = table->get_info();
    spot_on_table.tz += info.get_3d_height();
    npc->set_action(new Sequence_actor_action(pact,
      new Face_pos_actor_action(spot_on_table, 200)));
    state = use_potion;
    break;
    }
  case use_potion:
    {
    state = start;
    Exult_vector<Game_object *> potions;
    Game_object::find_nearby(potions, spot_on_table, 340, 0, 0);
    if (potions.size()) // Found a potion.  Remove it.
      {
      gwin->add_dirty(potions[0]);
      potions[0]->remove_this();
      }
    else      // Create potion if spot is empty.
      {
      Tile_coord t = Map_chunk::find_spot(spot_on_table, 0,
              340, 0, 0);
      if (t.tx != -1 && t.tz == spot_on_table.tz)
        {
        // create a potion randomly, but don't use the last frame
        int nframes = ShapeID(340, 0).get_num_frames() - 1;
        Game_object *p = gmap->create_ireg_object(
          ShapeID::get_info(340), 340,
          rand()%nframes, 0, 0, 0);
        p->move(t);
        }
      }
    signed char frames[2];
    int dir = npc->get_direction(spot_on_table);
          // Reach out hand:
    frames[0] = npc->get_dir_framenum(dir, 1);
    frames[1] = npc->get_dir_framenum(dir, Actor::standing);
    npc->set_action(new Frames_actor_action(frames, 2));
    break;
    }
    }
  npc->start(gwin->get_std_delay(), delay); // Back in queue.
  }

/*
 *  Schedule change for 'shy':
 */

void Shy_schedule::now_what
  (
  )
  {
  Actor *av = gwin->get_main_actor();
  Tile_coord avpos = av->get_tile(),
       npcpos = npc->get_tile();
          // How far away is Avatar?
  int dist = npcpos.distance(avpos);
  if (dist > 10)      // Far enough?
    {     // Check again in a few seconds.
    if (rand()%3)   // Just wait.
      npc->start(250, 1000 + rand()%1000);
    else      // Sometimes wander.
      npc->walk_to_tile(
        Tile_coord(npcpos.tx + rand()%6 - 3,
          npcpos.ty + rand()%6 - 3, npcpos.tz));
    return;
    }
          // Get deltas.
  int dx = npcpos.tx - avpos.tx, dy = npcpos.ty - avpos.ty;
  int adx = dx < 0 ? -dx : dx;
  int ady = dy < 0 ? -dy : dy;
          // Which is farthest?
  int farthest = adx < ady ? ady : adx;
  int factor = farthest < 2 ? 9 : farthest < 4 ? 4 
        : farthest < 7 ? 2 : 1;
          // Walk away.
  Tile_coord dest = npcpos + Tile_coord(dx*factor, dy*factor, 0);
  Tile_coord delta = Tile_coord(rand()%3, rand()%3, 0);
  dest = dest + delta;
  Monster_pathfinder_client cost(npc, dest, 4);
  Actor_action *pact = Path_walking_actor_action::create_path(
              npcpos, dest, cost);
  if (pact)     // Found path?
    {
    npc->set_action(pact);
    npc->start(200, 100 + rand()%200);  // Start walking.
    }
  else          // Try again in a couple secs.
    npc->start(250, 500 + rand()%1000);
  }


/*
 *  Create a 'waiter' schedule.
 */

Waiter_schedule::Waiter_schedule
  (
  Actor *n
  ) : Schedule(n), first(1), startpos(n->get_tile()), customer(0)
    
  {
  }

/*
 *  Get a new customer & walk to a prep. table.
 */

void Waiter_schedule::get_customer
  (
  )
{
  if (customers.empty())      // Got to search?
  {
    Actor_vector vec;   // Look within 32 tiles;
    npc->find_nearby_actors(vec, c_any_shapenum, 32);
    for (Actor_vector::const_iterator it = vec.begin();
              it != vec.end(); ++it)
    {   // Filter them.
      Actor *each = (Actor *) *it;
      if (each->get_schedule_type() == Schedule::eat_at_inn)
        customers.push(each);
    }
  }

  if (!customers.empty())
    customer = customers.pop();
  npc->say(first_waiter_ask, last_waiter_ask);  
  if (prep_tables.size()) // Walk to a 'prep' table.
  {
    Game_object *table = prep_tables[rand()%prep_tables.size()];
    Tile_coord pos = Map_chunk::find_spot(
      table->get_tile(), 1, npc);
    if (pos.tx != -1 &&
        npc->walk_path_to_tile(pos, gwin->get_std_delay(), 
              1000 + rand()%1000))
      return;
  }
  const int dist = 8;   // Bad luck?  Walk randomly.
  int newx = startpos.tx - dist + rand()%(2*dist);
  int newy = startpos.ty - dist + rand()%(2*dist);
  npc->walk_to_tile(newx, newy, startpos.tz, 2*gwin->get_std_delay(), 
                rand()%2000);
}

/*
 *  Find tables and categorize them.
 */

void Waiter_schedule::find_tables
  (
  int shapenum
  )
  {
  Game_object_vector vec;
  npc->find_nearby(vec, shapenum, 32, 0);
  int floor = npc->get_lift()/5;  // Make sure it's on same floor.
  for (Game_object_vector::const_iterator it = vec.begin(); it != vec.end();
                ++it)
    {
    Game_object *table = *it;
    if (table->get_lift()/5 != floor)
      continue;
    Game_object_vector chairs;    // No chairs by it?
    if (!table->find_nearby(chairs, 873, 3, 0) &&
        !table->find_nearby(chairs, 292, 3, 0))
      prep_tables.append(table);
    else
      eating_tables.append(table);
    }
  }

/*
 *  Find serving spot for a customer.
 *
 *  Output: Plate if found, with spot set.  Plate is created if needed.
 */

Game_object *Waiter_schedule::find_serving_spot
  (
  Tile_coord& spot
  )
  {
  Game_object_vector plates;  // First look for a nearby plate.
  Game_object *plate = 0;
  int cnt = npc->find_nearby(plates, 717, 1, 0);
  if (!cnt)
    cnt = npc->find_nearby(plates, 717, 2, 0);
  int floor = npc->get_lift()/5;  // Make sure it's on same floor.
  for (Game_object_vector::const_iterator it = plates.begin();
          it != plates.end(); ++it)
    {
    plate = *it;
    if (plate->get_lift()/5 == floor)
      {
      spot = plate->get_tile();
      spot.tz++;  // Just above plate.
      return plate;
      }
    }
  Tile_coord cpos = customer->get_tile();
  
  // Blame MSVC
  {
    // Go through tables.

  for (Game_object_vector::const_iterator it = eating_tables.begin();
          it != eating_tables.end(); ++it)
    {
    Game_object *table = *it;
    Rectangle foot = table->get_footprint();
    if (foot.distance(cpos.tx, cpos.ty) > 2)
      continue;
          // Found it.
    spot = cpos;    // Start here.
          // East/West of table?
    if (cpos.ty >= foot.y && cpos.ty < foot.y + foot.h)
      spot.tx = cpos.tx <= foot.x ? foot.x
              : foot.x + foot.w - 1;
    else      // North/south.
      spot.ty = cpos.ty <= foot.y ? foot.y
            : foot.y + foot.h - 1;
    if (foot.has_point(spot.tx, spot.ty))
      {   // Passes test.
      Shape_info& info = table->get_info();
      spot.tz = table->get_lift() + info.get_3d_height();
      plate = gmap->create_ireg_object(717, 0);
      plate->move(spot);
      spot.tz++;  // Food goes above plate.
      return plate;
      }
    }
  }
  return 0;     // Failed.
  }

/*
 *  Schedule change for 'waiter':
 */

void Waiter_schedule::now_what
  (
  )
  {
  if (rand() % 4 == 0)    // Check for lamps, etc.
    if (try_street_maintenance())
      return;   // We no longer exist.
  if (first)      // First time?
    {
    first = 0;    // Find tables.
    find_tables(971);
    find_tables(633);
    find_tables(847);
    find_tables(1003);
    find_tables(1018);
    find_tables(890);
    find_tables(964);
    find_tables(333);
    }
  int dist = customer ? npc->distance(customer) : 5000;
  if (dist > 32)      // Need a new customer?
    {
    get_customer();   // Find one, and walk to a prep. table.
    return;
    }
  if (dist < 3)     // Close enough to customer?
    {
    Game_object_vector foods;
    if (customer->find_nearby(foods, 377, 2, 0) > 0)
      {
      if (rand()%4)
        npc->say(first_waiter_banter, 
              last_waiter_banter);
      }
    else      // Needs food.
      {
      Game_object *food = npc->get_readied(Actor::lhand);
      Tile_coord spot;
      if (food && food->get_shapenum() == 377 &&
          find_serving_spot(spot))
        {
        npc->change_frame(npc->get_dir_framenum(
          npc->get_direction(customer),
              Actor::standing));
        npc->remove(food);
        food->set_invalid();
        food->move(spot);
        if (rand()%3)
          npc->say(first_waiter_serve,
             last_waiter_serve);
        }
      }
    customer = 0;   // Done with this one.
    npc->start(250, rand()%3000);
    return;
    }
          // Walk to customer with food.
  if (!npc->get_readied(Actor::lhand))
    {     // Acquire some food.
    int nfoods = ShapeID(377, 0).get_num_frames();
    int frame = rand()%nfoods;
    Game_object *food = new Ireg_game_object(377, frame, 0, 0, 0);
    npc->add_readied(food, Actor::lhand);
    }
  Tile_coord dest = Map_chunk::find_spot(customer->get_tile(),
          3, npc);
  if (dest.tx != -1 && npc->walk_path_to_tile(dest,
          gwin->get_std_delay(), rand()%1000))
    return;       // Walking there.

  npc->start(200, 2000 + rand()%4000);  // Failed so try again later.
  }

/*
 *  Waiter schedule is done.
 */

void Waiter_schedule::ending
  (
  int new_type      // New schedule.
  )
  {
          // Remove what he/she is carrying.
  Game_object *obj = npc->get_readied(Actor::lhand);
  if (obj)
    obj->remove_this();
  obj = npc->get_readied(Actor::rhand);
  if (obj)
    obj->remove_this();
  }

/*
 *  Sew/weave schedule.
 */

Sew_schedule::Sew_schedule
  (
  Actor *n
  ) : Schedule(n), state(get_wool), bale(0), spinwheel(0),
        chair(0), spindle(0), loom(0), cloth(0), work_table(0),
        wares_table(0), sew_clothes_cnt(0)
  {
  }

/*
 *  Sew/weave.
 */

void Sew_schedule::now_what
  (
  )
  {
  Tile_coord npcpos = npc->get_tile();
          // Often want to get within 1 tile.
  Actor_pathfinder_client cost(npc, 1);
  switch (state)
    {
  case get_wool:
    {
    if (spindle)    // Clean up any remainders.
      spindle->remove_this();
    if (cloth)
      cloth->remove_this();
    cloth = spindle = 0;
    npc->remove_quantity(2, 654, c_any_qual, c_any_framenum);
    npc->remove_quantity(2, 851, c_any_qual, c_any_framenum);

    bale = npc->find_closest(653);
    if (!bale)    // Just skip this step.
      {
      state = sit_at_wheel;
      break;
      }
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, bale->get_tile(), cost);
    if (pact)
      npc->set_action(new Sequence_actor_action(pact,
        new Pickup_actor_action(bale, 250),
        new Pickup_actor_action(bale,
          bale->get_tile(), 250)));
    state = sit_at_wheel;
    break;
    }
  case sit_at_wheel:
    chair = npc->find_closest(873);
    if (!chair || !Sit_schedule::set_action(npc, chair, 200)) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      return;
    }
    state = spin_wool;
    break;
  case spin_wool:     // Cycle spinning wheel 8 times.
    spinwheel = npc->find_closest(651);
    if (!spinwheel) {
      // uh-oh... try again in a few seconds?
      npc->start(250, 2500);
      return;
    }
    npc->set_action(new Object_animate_actor_action(spinwheel,
                8, 200));
    state = get_thread;
    break;
  case get_thread:
    {
    Tile_coord t = Map_chunk::find_spot(
        spinwheel->get_tile(), 1, 654, 0);
    if (t.tx != -1)   // Space to create thread?
      {
      spindle = new Ireg_game_object(654, 0, 0, 0);
      spindle->move(t);
      gwin->add_dirty(spindle);
      npc->set_action(
        new Pickup_actor_action(spindle, 250));
      }
    state = weave_cloth;
    break;
    }
  case weave_cloth:
    {
    if (spindle)    // Should be held by NPC.
      spindle->remove_this();
    spindle = 0;
    loom = npc->find_closest(261);
    if (!loom)    // No loom found?
      {
      state = get_wool;
      break;
      }
    Tile_coord lpos = loom->get_tile() +
            Tile_coord(-1, 0, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, lpos, cost);
    if (pact)
      npc->set_action(new Sequence_actor_action(pact,
        new Face_pos_actor_action(loom, 250),
        new Object_animate_actor_action(loom,
                4, 200)));
    state = get_cloth;
    break;
    }
  case get_cloth:
    {
    Tile_coord t = Map_chunk::find_spot(loom->get_tile(),
              1, 851, 0);
    if (t.tx != -1)   // Space to create it?
      {
      cloth = new Ireg_game_object(851, rand()%2, 0, 0);
      cloth->move(t);
      gwin->add_dirty(cloth);
      npc->set_action(
        new Pickup_actor_action(cloth, 250));
      }
    state = to_work_table;
    break;
    }
  case to_work_table:
    {
    work_table = npc->find_closest(971);
    if (!work_table || !cloth)
      {
      state = get_wool;
      break;
      }
    Tile_coord tpos = work_table->get_tile() +
            Tile_coord(1, -2, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
          // Find where to put cloth.
    Rectangle foot = work_table->get_footprint();
    Shape_info& info = work_table->get_info();
    Tile_coord cpos(foot.x + foot.w/2, foot.y + foot.h/2,
      work_table->get_lift() + info.get_3d_height());
    if (pact)
      npc->set_action(new Sequence_actor_action(pact,
        new Face_pos_actor_action(
            work_table, 250),
        new Pickup_actor_action(cloth, cpos, 250)));
    state = set_to_sew;
    break;
    }
  case set_to_sew:
    {
    Game_object *shears = npc->get_readied(Actor::lhand);
    if (shears && shears->get_shapenum() != 698)
      {   // Something's not right.
      shears->remove_this();
      shears = 0;
      }
    if (!shears)
      {   // Shears on table?
      Game_object_vector vec;
      if (npc->find_nearby(vec, 698, 3, 0))
        {
        shears = vec[0];
        gwin->add_dirty(shears);
        shears->remove_this(1);
        }
      else
        shears = new Ireg_game_object(698, 0, 0, 0);
      npc->add_readied(shears, Actor::lhand);
      }
    state = sew_clothes;
    sew_clothes_cnt = 0;
    break;
    }
  case sew_clothes:
    {
    int dir = npc->get_direction(cloth);
    signed char frames[5];
    int nframes = npc->get_attack_frames(698, false, 
                dir, frames);
    npc->set_action(new Frames_actor_action(frames, nframes));
    sew_clothes_cnt++;
    if (sew_clothes_cnt > 1 && sew_clothes_cnt < 5)
      {
      int num_cloth_frames = ShapeID(851, 0).get_num_frames();
      cloth->change_frame(rand()%num_cloth_frames);
      }
    else if (sew_clothes_cnt == 5)
      {
      gwin->add_dirty(cloth);
      Tile_coord pos = cloth->get_tile();
      cloth->remove_this(1);
          // Top or pants.
      int shnum = GAME_SI ? 403 : (rand()%2 ? 738 : 249);
      cloth->set_shape(shnum);
      int nframes = ShapeID(shnum, 0).get_num_frames();
      cloth->set_frame(rand()%nframes);
      cloth->move(pos);
      state = get_clothes;
      }
    break;
    }
  case get_clothes:
    {
    Game_object *shears = npc->get_readied(Actor::lhand);
    if (shears) {
      Tile_coord pos = cloth->get_tile();
      npc->set_action(new Sequence_actor_action(
                  new Pickup_actor_action(cloth, 250),
                  new Pickup_actor_action(shears, pos, 250)));
    } else {
      // ++++ maybe create shears? anyway, leaving this till after
      // possible/probable schedule system rewrite
      npc->set_action(new Pickup_actor_action(cloth, 250));
    }
    state = display_clothes;
    break;
    }
  case display_clothes:
    {
    state = done;
    wares_table = npc->find_closest(890);
    if (!wares_table)
      {
      cloth->remove_this();
      cloth = 0;
      break;
      }
    Tile_coord tpos = wares_table->get_tile() +
            Tile_coord(1, -2, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
          // Find where to put cloth.
    Rectangle foot = wares_table->get_footprint();
    Shape_info& info = wares_table->get_info();
    Tile_coord cpos(foot.x + rand()%foot.w, foot.y + rand()%foot.h,
      wares_table->get_lift() + info.get_3d_height());
    if (pact)
      npc->set_action(new Sequence_actor_action(pact,
        new Pickup_actor_action(cloth, cpos, 250)));
    cloth = 0;      // Leave it be.
    break;
    }
  case done:        // Just put down clothing.
    {
    state = get_wool;
    Game_object_vector vec;   // Don't create too many.
    int cnt = 0;
    if (GAME_SI)
      cnt += npc->find_nearby(vec, 403, 4, 0);
    else        // BG shapes.
      {
      cnt += npc->find_nearby(vec, 738, 4, 0);
      cnt += npc->find_nearby(vec, 249, 4, 0);
      }
    if (cnt > 5)
      {
      Game_object *obj = vec[rand()%cnt];
      gwin->add_dirty(obj);
      obj->remove_this();
      }
    break;
    }
  default:      // Back to start.
    state = get_wool;
    break;
    }
  npc->start(250, 100);   // Back in queue.
  }

/*
 *  Sewing schedule is done.
 */

void Sew_schedule::ending
  (
  int new_type      // New schedule.
  )
  {
          // Remove shears.
  Game_object *obj = npc->get_readied(Actor::lhand);
  if (obj)
    obj->remove_this();
  if (cloth)      // Don't leave cloth lying around.
    {
    if (!cloth->get_owner())
      gwin->add_dirty(cloth);
    cloth->remove_this();
    cloth = 0;
    }
  }


/*
 *  Bake bread/pastries
 *
 * TODO: fix for SI tables... (specifically in Moonglow)
 */

Bake_schedule::Bake_schedule(Actor *n) : Schedule(n),
  state(to_flour), oven(0), worktable(0), displaytable(0),
  flourbag(0), dough(0), dough_in_oven(0), baked_count(0)
  { }

void Bake_schedule::now_what()
{
  Tile_coord npcpos = npc->get_tile();
  Actor_pathfinder_client cost(npc, 1);
  int delay = 100;

  switch (state) {
  case to_flour:
  {
    Game_object_vector items;
    npc->find_nearby(items, npcpos, 863, -1, 0, c_any_qual, 0);
    npc->find_nearby(items, npcpos, 863, -1, 0, c_any_qual, 13);
    npc->find_nearby(items, npcpos, 863, -1, 0, c_any_qual, 14);

    if (items.empty()) {
      state = to_table;
      break;
    }

    int nr = rand()%items.size();
    flourbag = items[nr];

    Tile_coord tpos = flourbag->get_tile();
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
    if (pact) {
      npc->set_action(pact);
    } else {
      // just ignore it
      state = to_table;
      break;
    }

    state = get_flour;
    break;
  }
  case get_flour:
  {
    if (!flourbag) {
      // what are we doing here then? back to start
      state = to_flour;
      break;
    }

    int dir = npc->get_direction(flourbag);
    npc->change_frame(
      npc->get_dir_framenum(dir,Actor::bow_frame));

    if (flourbag->get_framenum() != 0)
      flourbag->change_frame(0);

    delay = 750;
    state = to_table;
    break;
  }
  case to_table:
  {
    Game_object *table1 = npc->find_closest(1003);
    Game_object *table2 = npc->find_closest(1018);

    if (!table1)
      worktable = table2;
    else if (!table2)
      worktable = table1;
    else if (table1->distance(npc) < table2->distance(npc))
      worktable = table1;
    else
      worktable = table2;

    if (!worktable)
      worktable = npc->find_closest(1018);
    if (!worktable) {
      // problem... try again in a few seconds
      delay = 2500;
      state = to_flour;
      break;
    }

          // Find where to put dough.
    Rectangle foot = worktable->get_footprint();
    Shape_info& info = worktable->get_info();
    Tile_coord cpos(foot.x + rand()%foot.w, foot.y + rand()%foot.h,
      worktable->get_lift() + info.get_3d_height());
    Tile_coord tablepos = cpos;
    cpos.tz = 0;

    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, cpos, cost);
    if (pact) {
      if (dough) {
        dough->remove_this();
        dough = 0;
      }
      if (Game::get_game_type() == SERPENT_ISLE)
        dough = new Ireg_game_object(863, 16, 0, 0);
      else
        dough = new Ireg_game_object(658, 0, 0, 0);
      npc->set_action(new Sequence_actor_action(pact,
        new Pickup_actor_action(dough,tablepos,250)));
    } else {
      // not good... try again
      delay = 2500;
      state = to_flour;
      break;
    }

    state = make_dough;
    break;
  }
  case make_dough:
  {
    if (!dough) {
      // better try again...
      delay = 2500;
      state = to_table;
      break;
    }

    int dir = npc->get_direction(dough);
    signed char fr[2];
    fr[0] = npc->get_dir_framenum(dir, 3);
    fr[1] = npc->get_dir_framenum(dir, 0);

    npc->set_action(new Sequence_actor_action(
        new Frames_actor_action(fr, 2, 500),
    ((Game::get_game_type() == SERPENT_ISLE) ?
        new Frames_actor_action((signed char *)"\x11",1,250,dough) :
        new Frames_actor_action((signed char *)"\x01",1,250,dough)),
        new Frames_actor_action(fr, 2, 500),
    ((Game::get_game_type() == SERPENT_ISLE) ?
        new Frames_actor_action((signed char *)"\x12",1,250,dough) :
        new Frames_actor_action((signed char *)"\x02",1,250,dough))
        ));
    
    state = remove_from_oven;
    break;
  }
  case remove_from_oven:
  {
    if (!dough_in_oven) {
      // nothing in oven yet
      state = get_dough;
      break;
    }

    oven = npc->find_closest(831);
    if (!oven) {
      // this really shouldn't happen...
      dough_in_oven->remove_this();
      dough_in_oven = 0;

      delay = 2500;
      state = to_table;
      break;
    }

    gwin->add_dirty(dough_in_oven);
    dough_in_oven->set_shape(377);
    dough_in_oven->set_frame(rand()%7);
    gwin->add_dirty(dough_in_oven);

    Tile_coord tpos = oven->get_tile() + 
            Tile_coord(1, 1, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
    if (pact) {
      npc->set_action(new Sequence_actor_action(
        pact,
        new Pickup_actor_action(dough_in_oven, 250)));
    } else {
      // just pick it up
      npc->set_action(
        new Pickup_actor_action(dough_in_oven, 250));
    }

    state = display_wares;
    break;
  }
  case display_wares:
  {
    if (!dough_in_oven) {
      // try again
      delay = 2500;
      state = to_flour;
      break;
    }
    displaytable = npc->find_closest(633);
    if (!displaytable) {
      // uh-oh...
      dough_in_oven->remove_this();
      dough_in_oven = 0;

      delay = 2500;
      state = to_flour;
      break;
    }

    baked_count++;

    Tile_coord tpos = displaytable->get_tile();
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
          // Find where to put cloth.
    Rectangle foot = displaytable->get_footprint();
    Shape_info& info = displaytable->get_info();
    Tile_coord cpos(foot.x + rand()%foot.w, foot.y + rand()%foot.h,
      displaytable->get_lift() + info.get_3d_height());
    if (pact) {
      if (baked_count <= 5) {
        npc->set_action(new Sequence_actor_action(pact,
          new Pickup_actor_action(dough_in_oven,
               cpos, 250)));
      } else {
        npc->set_action(pact);
        dough_in_oven->remove_this();
      }
      dough_in_oven = 0;
    } else {
      // just make it vanish
      dough_in_oven->remove_this();
      dough_in_oven = 0;
    }

    state = get_dough;
    break;
  }
  case get_dough:
  {
    if (!dough) {
      // try again
      delay = 2500;
      state = to_flour;
      break;
    }

    oven = npc->find_closest(831);
    if (!oven) {
      // wait a while
      delay = 2500;
      state = to_flour;
      break;
    }

    Tile_coord tpos = dough->get_tile();
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);
    if (pact) {
      npc->set_action(new Sequence_actor_action(
        pact,
        new Pickup_actor_action(dough, 250)));
    } else {
      // just pick it up
      npc->set_action(new Pickup_actor_action(dough, 250));
    }

    state = put_in_oven;
    break;
  }
  case put_in_oven:
  {
    if (!dough) {
      // try again
      delay = 2500;
      state = to_flour;
      break;
    }

    oven = npc->find_closest(831);
    if (!oven) {
      // oops... retry
      dough->remove_this();
      dough = 0;

      delay = 2500;
      state = to_table;
      break;
    }

    Tile_coord tpos = oven->get_tile() + 
            Tile_coord(1, 1, 0);
    Actor_action *pact = Path_walking_actor_action::create_path(
          npcpos, tpos, cost);

    Rectangle foot = oven->get_footprint();
    Shape_info& info = oven->get_info();
    Tile_coord cpos(foot.x + 1, foot.y,
        oven->get_lift() + info.get_3d_height());

    if (pact) {
      npc->set_action(new Sequence_actor_action(
        pact,
        new Pickup_actor_action(dough, cpos, 250)));

      dough_in_oven = dough;
      dough = 0;
    } else {
      dough->remove_this();
      dough = 0;
    }

    state = to_flour;
    break;
  }
  }
  npc->start(250, delay);   // Back in queue.
}

void Bake_schedule::ending(int new_type)
{
  if (dough) {
    dough->remove_this();
    dough = 0;
  }

  if (dough_in_oven) {
    dough_in_oven->remove_this();
    dough_in_oven = 0;
  }
}

/*
 *  Notify that an object is no longer present.
 */
void Bake_schedule::notify_object_gone(Game_object *obj)
{
  if (obj == dough)   // Someone stole the dough!
    dough = 0;
  if (obj == dough_in_oven)
    dough_in_oven = 0;
}


/*
 *  Blacksmith.
 *
 * Note: the original kept the tongs & hammer, and put them on a nearby table
 */

Forge_schedule::Forge_schedule(Actor *n) : Schedule(n), 
  state(put_sword_on_firepit), tongs(0), hammer(0), blank(0),
  firepit(0), anvil(0), trough(0), bellows(0)
  { }

void Forge_schedule::now_what
  (
  )
  {
  Tile_coord npcpos = npc->get_tile();
          // Often want to get within 1 tile.
  Actor_pathfinder_client cost(npc, 1);

  switch (state) {
  case put_sword_on_firepit:
  {
    if (!blank) {
      blank = npc->find_closest(668);
      //TODO: go and get it...

    }
    if (!blank)
      blank = new Ireg_game_object(668, 0, 0, 0);

    firepit = npc->find_closest(739);
    if (!firepit) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      return;
    }

    Tile_coord tpos = firepit->get_tile();
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, tpos, cost);

    Rectangle foot = firepit->get_footprint();
    Shape_info& info = firepit->get_info();
    Tile_coord bpos(foot.x + foot.w/2 + 1, foot.y + foot.h/2,
      firepit->get_lift() + info.get_3d_height());
    if (pact) {
      npc->set_action(new Sequence_actor_action(pact,
        new Pickup_actor_action(blank, bpos, 250)));
    } else {
      npc->set_action(
        new Pickup_actor_action(blank, bpos, 250));
    }

    state = use_bellows;
    break;
  }
  case use_bellows:
  {
    bellows = npc->find_closest(431);
    firepit = npc->find_closest(739);
    if (!bellows || !firepit || !blank) {
      // uh-oh... try again in a few second
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }

    Tile_coord tpos = bellows->get_tile() +
          Tile_coord(3,0,0);
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, tpos, cost);

    Actor_action **a = new Actor_action*[35];
    a[0] = pact;
    a[1] = new Face_pos_actor_action(bellows, 250);
    a[2] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[3] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[4] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[5] = new Frames_actor_action((signed char *)"\x01", 1, 0, firepit);
    a[6] = new Frames_actor_action((signed char *)"\x01", 1, 0, blank);
    a[7] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[8] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[9] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[10] = new Frames_actor_action((signed char *)"\x02", 1, 0, blank);
    a[11] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[12] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[13] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[14] = new Frames_actor_action((signed char *)"\x02", 1, 0, firepit);
    a[15] = new Frames_actor_action((signed char *)"\x03", 1, 0, blank);
    a[16] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[17] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[18] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[19] = new Frames_actor_action((signed char *)"\x03", 1, 0, firepit);
    a[20] = new Frames_actor_action((signed char *)"\x04", 1, 0, blank);
    a[21] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[22] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[23] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[24] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[25] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[26] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[27] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[28] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[29] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[30] = new Frames_actor_action((signed char *)"\x2b", 1, 0);
    a[31] = new Object_animate_actor_action(bellows, 3, 1, 300);
    a[32] = new Frames_actor_action((signed char *)"\x20", 1, 0);
    a[33] = new Frames_actor_action((signed char *)"\x00", 1, 0, bellows);
    a[34] = 0;


    npc->set_action(new Sequence_actor_action(a));
    state = get_tongs;
    break;
  }
  case get_tongs:
  {
#if 0
    if (!tongs) {
      tongs = npc->find_closest(994);
      //TODO: go and get it...
    }
#endif
    if (!tongs)
      tongs = new Ireg_game_object(994, 0, 0, 0);

    npc->add_dirty();
    npc->add_readied(tongs, Actor::rhand);
    npc->add_dirty();

    state = sword_on_anvil;
    break;
  }
  case sword_on_anvil:
  {
    anvil = npc->find_closest(991);
    firepit = npc->find_closest(739);
    if (!anvil || !firepit || !blank) {
      // uh-oh... try again in a few second
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }

    Tile_coord tpos = firepit->get_tile();
    Actor_action *pact = Path_walking_actor_action::create_path(
        npcpos, tpos, cost);
    Tile_coord tpos2 = anvil->get_tile() + 
          Tile_coord(0,1,0);
    Actor_action *pact2 = Path_walking_actor_action::create_path(
        tpos, tpos2, cost);

    Rectangle foot = anvil->get_footprint();
    Shape_info& info = anvil->get_info();
    Tile_coord bpos(foot.x + 2, foot.y,
      anvil->get_lift() + info.get_3d_height());
    if (pact && pact2) {
      npc->set_action(new Sequence_actor_action(pact,
        new Pickup_actor_action(blank, 250),
        pact2,
        new Pickup_actor_action(blank, bpos, 250)));
    } else {
      npc->set_action(new Sequence_actor_action(
        new Pickup_actor_action(blank, 250),
        new Pickup_actor_action(blank, bpos, 250)));
    }
    state = get_hammer;
    break;
  }
  case get_hammer:
  {
#if 0
    if (!hammer) {
      hammer = npc->find_closest(623);
      //TODO: go and get it...
    }
#endif

    if (!hammer)
      hammer = new Ireg_game_object(623, 0, 0, 0);

    npc->add_dirty();
    if (tongs) {
      tongs->remove_this();
      tongs = 0;
    }
    npc->add_readied(hammer, Actor::rhand);
    npc->add_dirty();

    state = use_hammer;
    break;
  }
  case use_hammer:
  {
    anvil = npc->find_closest(991);
    firepit = npc->find_closest(739);
    if (!anvil || !firepit || !blank) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }

    signed char frames[12];
    int cnt = npc->get_attack_frames(623, false, 0, frames);
    npc->set_action(new Frames_actor_action(frames, cnt));
    
    Actor_action **a = new Actor_action*[10];
    a[0] = new Frames_actor_action(frames, cnt);
    a[1] = new Frames_actor_action((signed char *)"\x03", 1, 0, blank);
    a[2] = new Frames_actor_action((signed char *)"\x02", 1, 0, firepit);
    a[3] = new Frames_actor_action(frames, cnt);
    a[4] = new Frames_actor_action((signed char *)"\x02", 1, 0, blank);
    a[5] = new Frames_actor_action((signed char *)"\x01", 1, 0, firepit);
    a[6] = new Frames_actor_action(frames, cnt);
    a[7] = new Frames_actor_action((signed char *)"\x01", 1, 0, blank);
    a[8] = new Frames_actor_action((signed char *)"\x00", 1, 0, firepit);
    a[9] = 0;
    npc->set_action(new Sequence_actor_action(a));

    state = walk_to_trough;
    break;
  }
  case walk_to_trough:
  {
    npc->add_dirty();
    if (hammer) {
      hammer->remove_this();
      hammer = 0;
    }
    npc->add_dirty();

    trough = npc->find_closest(719);
    if (!trough) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }

    if (trough->get_framenum() == 0) {
      Tile_coord tpos = trough->get_tile() +
            Tile_coord(0,2,0);
      Actor_action *pact = Path_walking_actor_action::
					create_path(npcpos, tpos, cost);
      npc->set_action(pact);
      state = fill_trough;
      break;
    }
    
    state = get_tongs2;
    break;
  }
  case fill_trough:
  {
    trough = npc->find_closest(719);
    if (!trough) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }

    int dir = npc->get_direction(trough);
    trough->change_frame(3);
    npc->change_frame(
      npc->get_dir_framenum(dir, Actor::bow_frame));

    state = get_tongs2;
    break;
  }
  case get_tongs2:
  {
#if 0
    if (!tongs) {
      tongs = npc->find_closest(994);
      //TODO: go and get it...
    }
#endif
    if (!tongs)
      tongs = new Ireg_game_object(994, 0, 0, 0);

    npc->add_dirty();
    npc->add_readied(tongs, Actor::rhand);
    npc->add_dirty();

    state = use_trough;
    break;
  }
  case use_trough:
  {
    trough = npc->find_closest(719);
    anvil = npc->find_closest(991);
    if (!trough || !anvil || !blank) {
      // uh-oh... try again in a few seconds
      npc->start(250, 2500);
      state = put_sword_on_firepit;
      return;
    }
    
    Tile_coord tpos = anvil->get_tile() +
        Tile_coord(0,1,0);
    Actor_action *pact = Path_walking_actor_action::
				create_path(npcpos, tpos, cost);

    Tile_coord tpos2 = trough->get_tile() +
        Tile_coord(0,2,0);
    Actor_action *pact2 = Path_walking_actor_action::
				create_path(tpos, tpos2, cost);

    if (pact && pact2) {
      signed char troughframe = trough->get_framenum() - 1;
      if (troughframe < 0) troughframe = 0;

      int dir = npc->get_direction(trough);
      signed char npcframe = npc->get_dir_framenum(dir, Actor::bow_frame);

      Actor_action **a = new Actor_action*[7];
      a[0] = pact;
      a[1] = new Pickup_actor_action(blank, 250);
      a[2] = pact2;
      a[3] = new Frames_actor_action(&npcframe, 1, 250);
      a[4] = new Frames_actor_action(&troughframe, 1, 0, trough);
      a[5] = new Frames_actor_action((signed char *)"\x00", 1, 0, blank);
      a[6] = 0;
      npc->set_action(new Sequence_actor_action(a));
    } else {
      // no path found, just pick up sword blank
      npc->set_action(new Sequence_actor_action(
        new Pickup_actor_action(blank, 250),
        new Frames_actor_action((signed char *)"\0", 1, 0, blank)));
    } 

    state = done;
    break;
  }
  case done:
  {
    npc->add_dirty();
    if (tongs) {
      tongs->remove_this();
      tongs = 0;
    }
    npc->add_dirty();
    

    state = put_sword_on_firepit;
  }
  }

  npc->start(250, 100);   // Back in queue.
  }

/*
 *  Forge schedule is done.
 */

void Forge_schedule::ending
  (
  int new_type      // New schedule.
  )
  {
          // Remove any tools.
  if (tongs) {
    tongs->remove_this();
    tongs = 0;
  }
  if (hammer) {
    hammer->remove_this();
    hammer = 0;
  }

  firepit = npc->find_closest(739);
  bellows = npc->find_closest(431);

  if (firepit && firepit->get_framenum() != 0)
    firepit->change_frame(0);
  if (bellows && bellows->get_framenum() != 0)
    bellows->change_frame(0);
  if (blank && blank->get_framenum() != 0)
    blank->change_frame(0);

  }


/*
 *  Modify goal to walk off the screen.
 */

void Walk_to_schedule::walk_off_screen
  (
  Rectangle& screen,    // In tiles, area slightly larger than
          //   actual screen.
  Tile_coord& goal    // Modified for path offscreen.
  )
  {
          // Destination.
  if (goal.tx >= screen.x + screen.w)
    {
    goal.tx = screen.x + screen.w - 1;
    goal.ty = -1;
    }
  else if (goal.tx < screen.x)
    {
    goal.tx = screen.x;
    goal.ty = -1;
    }
  else if (goal.ty >= screen.y + screen.h)
    {
    goal.ty = screen.y + screen.h - 1;
    goal.tx = -1;
    }
  else if (goal.ty < screen.y)
    {
    goal.ty = screen.y;
    goal.tx = -1;
    }
  }

/*
 *  Create schedule for walking to the next schedule's destination.
 */

Walk_to_schedule::Walk_to_schedule
  (
  Actor *n,
  Tile_coord d,     // Destination.
  int new_sched,      // Schedule when we get there.
  int delay     // Msecs, or -1 for random delay.
  ) : Schedule(n), dest(d), new_schedule(new_sched), retries(0), legs(0)
  {
          // Delay 0-20 secs.
  first_delay = delay >= 0 ? delay : 2*(rand()%10000);
  }

/*
 *  Schedule change for walking to another schedule destination.
 */

void Walk_to_schedule::now_what
  (
  )
  {
  if (npc->get_tile().distance(dest) <= 3)
    {     // Close enough!
    npc->set_schedule_type(new_schedule);
    return;
    }
  if (legs >= 40 || retries >= 2) // Trying too hard?  (Following
            //   Patterson takes about 30.)
    {     // Going to jump there.
    npc->move(dest.tx, dest.ty, dest.tz);
    npc->set_schedule_type(new_schedule);
    return;
    }
          // Get screen rect. in tiles.
  Rectangle screen = gwin->get_win_tile_rect();
  screen.enlarge(6);    // Enlarge in all dirs.
          // Might do part of it first.
  Tile_coord from = npc->get_tile(),
       to = dest;
          // Destination off the screen?
  if (!screen.has_point(to.tx, to.ty))
    {
    if (!screen.has_point(from.tx, from.ty))
      {   // Force teleport on next tick.
      retries = 100;
      npc->start(200, 100);
      return;
      }
          // Don't walk off screen if close, or
          //   if lots of legs, indicating that
          //   Avatar is following this NPC.
    if (from.distance(to) > 80 || legs < 10)
          // Modify 'dest'. to walk off.
      walk_off_screen(screen, to);
    }
  else if (!screen.has_point(from.tx, from.ty))
          // Modify src. to walk from off-screen.
    walk_off_screen(screen, from);
  blocked = Tile_coord(-1, -1, -1);
  cout << "Finding path to schedule for " << npc->get_name() << endl;
          // Create path to dest., delaying
          //   0 to 1 seconds.
  if (!npc->walk_path_to_tile(from, to, gwin->get_std_delay(),
            first_delay + rand()%1000))
    {     // Wait 1 sec., then try again.
#ifdef DEBUG
    cout << "Failed to find path for " << npc->get_name() << endl;
#endif
    npc->walk_to_tile(dest, gwin->get_std_delay(), 1000);
    retries++;    // Failed.  Try again next tick.
    }
  else        // Okay.  He's walking there.
    {
    legs++;
    retries = 0;
    }
  first_delay = 0;
  }

/*
 *  Don't go dormant when walking to a schedule.
 */

void Walk_to_schedule::im_dormant
  (
  )
  {
  Walk_to_schedule::now_what(); // Get there by any means.
  }

/*
 *  Get actual schedule (for Usecode intrinsic).
 */

int Walk_to_schedule::get_actual_type
  (
  Actor * /* npc */
  )
  {
  return new_schedule;
  }

/*
 *  Set a schedule.
 */

void Schedule_change::set
  (
  unsigned char *entry    // 4 bytes read from schedule.dat.
  )
  {
  time = entry[0]&7;
  type = entry[0]>>3;
  x = entry[1];
  y = entry[2];
  superchunk = entry[3];
  }

/*
 *  Get a schedule.
 */

void Schedule_change::get
  (
  unsigned char *entry    // 4 bytes to write to schedule.dat.
  )
  {
  entry[0] = time&7;
  entry[0] |= (type&31) << 3;
  entry[1] = x;
  entry[2] = y;
  entry[3] = superchunk;
  }

/*
 *  Set a schedule.
 */

void Schedule_change::set
  (
  int ax,
  int ay,
  unsigned char stype,
  unsigned char stime
  )
  {
  time = stime;
  type = stype;
  x = static_cast<unsigned char>(ax%c_tiles_per_schunk);
  y = static_cast<unsigned char>(ay%c_tiles_per_schunk);
  superchunk = static_cast<unsigned char>((ay/c_tiles_per_schunk)*12 + (ax/c_tiles_per_schunk));
  }

/*
 *  Get position.
 */

Tile_coord Schedule_change::get_pos() const
  {
  int cx = 16*(superchunk%12) + x/16,
      cy = 16*(superchunk/12) + y/16,
      tx = x%16,
      ty = y%16;
  return Tile_coord(cx*c_tiles_per_chunk + tx, cy*c_tiles_per_chunk + ty, 0);
  }

---