ucsched.cc

Go to the documentation of this file.

/*
 *  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 "ucinternal.h"
#include "useval.h"
#include "ucsched.h"
#include "Audio.h"
#include "barge.h"
#include "game.h"
#include "frameseq.h"
#include "gamewin.h"
#include "gameclk.h"
#include "egg.h"
#include "actors.h"
#include "ucscriptop.h"

#include <iostream>
#include <iomanip>

using std::cout;
using std::endl;
using std::hex;
using std::setfill;
using std::setw;

using namespace Ucscript;

int Usecode_script::count = 0;
Usecode_script *Usecode_script::first = 0;

/*
 *  Create for a 'restore'.
 */

Usecode_script::Usecode_script
  (
  Game_object *item, 
  Usecode_value *cd, 
  int findex,
  int nhalt, 
  int del
  ) : obj(item), code(cd), i(0), frame_index(findex), 
      no_halt(nhalt != 0), must_finish(false), delay(del)
  {
  cnt = code->get_array_size();
  }

/*
 *  Create.
 */

Usecode_script::Usecode_script
  (
  Game_object *o,
  Usecode_value *cd   // May be NULL for empty script.
  ) : obj(o), code(cd), cnt(0), i(0), frame_index(0), no_halt(false),
      must_finish(false), delay(0)
  {
  if (!code)      // Empty?
    code = new Usecode_value(0, 0);
  else
    {
    cnt = code->get_array_size();
    if (!cnt)   // Not an array??  (This happens.)
      {   // Create with single element.
      code = new Usecode_value(1, code);
      cnt = 1;
      }
    }
  }

/*
 *  Delete.
 */

Usecode_script::~Usecode_script()
  {
  delete code;
  count--;
  if (next)
    next->prev = prev;
  if (prev)
    prev->next = next;
  else
    first = next;
  }

/*
 *  Enter into the time-queue and our own chain.  Terminate existing
 *  scripts for this object unless 'dont_halt' is set.
 */

void Usecode_script::start
  (
  long d      // Start after this many msecs.
  )
  {
  Game_window *gwin = Game_window::get_instance();
  int cnt = code->get_array_size();// Check initial elems.
  for (int i = 0; i < cnt; i++)
    {
    int opval0 = code->get_elem(i).get_int_value();
    if (opval0 == Ucscript::dont_halt)
      no_halt = true;
    else if (opval0 == Ucscript::finish)
      must_finish = true;
    else
      break;
    }
  if (!is_no_halt())    // If flag not set,
          // Remove other entries that aren't
          //   'no_halt'.
    Usecode_script::terminate(obj);
  count++;      // Keep track of total.
  next = first;     // Put in chain.
  prev = 0;
  if (first)
    first->prev = this;
  first = this;
//++++ Messes up Moonshade Trial.
//  gwin->get_tqueue()->add(d + Game::get_ticks(), this,
  gwin->get_tqueue()->add(d + SDL_GetTicks(), this,
          (long) gwin->get_usecode());
  }

/*
 *  Set this script to halt.
 */

void Usecode_script::halt
  (
  )
  {
  if (!no_halt)
    i = cnt;
  }

/*
 *  Append instructions.
 */
void Usecode_script::add(int v1)
  {
  code->append(&v1, 1);
  cnt++;
  }
void Usecode_script::add(int v1, int v2)
  {
  int vals[2];
  vals[0] = v1;
  vals[1] = v2;
  code->append(vals, 2);
  cnt += 2;
  }
void Usecode_script::add(int v1, const char *str)
  {
  int sz = code->get_array_size();
  code->resize(sz + 2);
  (*code)[sz] = v1;
  (*code)[sz + 1] = str;
  cnt += 2;
  }
void Usecode_script::add(int *vals, int c)
  {
  code->append(vals, cnt);
  cnt += c;
  }

/*
 *  Search list for one for a given item.
 *
 *  Output: ->Usecode_script if found, else 0.
 */

Usecode_script *Usecode_script::find
  (
  Game_object *srch,
  Usecode_script *last_found  // Find next after this.
  )
  {
  Usecode_script *start = last_found ? last_found->next : first;
  for (Usecode_script *each = start; each; each = each->next)
    if (each->obj == srch)
      return each;  // Found it.
  return (0);
  }

/*
 *  Terminate all scripts for a given object.
 */

void Usecode_script::terminate
  (
  Game_object *obj
  )
  {
  Usecode_script *next = 0;
  for (Usecode_script *each = first; each; each = next)
    {
    next = each->next;  // Get next in case we delete 'each'.
    if (each->obj == obj)
      each->halt();
    }
  }     

/*
 *  Remove all from global list (assuming they've already been cleared
 *  from the time queue).
 */

void Usecode_script::clear
  (
  )
  {
  while (first)
    delete first;
  }

/*
 *  Terminate all scripts for objects that are more than a given distance
 *  from a particular spot.
 */

void Usecode_script::purge
  (
  Tile_coord spot,
  int dist      // In tiles.
  )
  {
  Usecode_script *next = 0;
  Game_window *gwin = Game_window::get_instance();
  Usecode_internal *usecode = static_cast<Usecode_internal*>(
          gwin->get_usecode());
  for (Usecode_script *each = first; each; each = next)
    {
    next = each->next;  // Get next in case we delete 'each'.
          // Only purge if not yet started.
    if (each->obj && !each->i &&
        each->obj->get_outermost()->get_tile().distance(
                spot) > dist)
      {   // Force it to halt.
      each->no_halt = false;
      if (each->must_finish)
        {
        cout << "MUST finish this script" << endl;
        each->exec(usecode, true);
        }
      each->halt();
      }
    }
  }     

inline void Usecode_script::activate_egg(Usecode_internal *usecode,
             Game_object *e)
{
  if (!e || !e->is_egg())
    return;
  int type = ((Egg_object *) e)->get_type();
          // Guess:  Only certain types:
  if (type == Egg_object::monster || type == Egg_object::button ||
      type == Egg_object::missile)
    ((Egg_object *) e)->activate(
      usecode->gwin->get_main_actor(), true);
}


/*
 *  Execute an array of usecode, generally one instruction per tick.
 */

void Usecode_script::handle_event
  (
  unsigned long curtime,    // Current time of day.
  long udata      // ->usecode machine.
  )
  {
  Usecode_internal *usecode = (Usecode_internal *) udata;
  int delay = exec(usecode, false);
  if (i < cnt)      // More to do?
    {
    usecode->gwin->get_tqueue()->add(curtime + delay, this, udata);
    return;
    }
#if 0 /* ++++Might need this for Test of Love!! */
  if (count == 1 &&   // Last one?  GUESSING:
      objpos.tx != -1)    // And valid pos.
  {
    usecode->activate_cached(objpos);
  }
#endif
  delete this;      // Hope this is safe.
  }

/*
 *  Execute an array of usecode, generally one instruction per tick.
 *
 *  Output: Delay for next execution.
 */

int Usecode_script::exec
  (
  Usecode_internal *usecode,
  bool finish     // If set, keep going to end.
  )
  {
  Game_window *gwin = usecode->gwin;
  int delay = gwin->get_std_delay();  // Start with default delay.
  bool do_another = true;     // Flag to keep going.
  int opcode;
          // If a 1 follows, keep going.
  for (; i < cnt && ((opcode = code->get_elem(i).get_int_value()) 
            == 0x1 || do_another); i++)
    {
    do_another = finish;
    switch (opcode)
      {
    case cont:    // Means keep going without painting.
      do_another = true;
      gwin->set_painted();  // Want to paint when done.
      break;
    case repeat:    // ?? 2 parms, 1st one < 0.
      {   // Loop(offset, cnt).
      Usecode_value& cntval = code->get_elem(i + 2);
      int cnt = cntval.get_int_value();
      if (cnt <= 0)
          // Done.
        i += 2;
      else
        { // Decr. and loop.
        cntval = Usecode_value(cnt - 1);
        Usecode_value& offval = code->get_elem(i + 1);
        i += offval.get_int_value() - 1;
        if (i < -1) // Before start?
          i = -1;
        do_another = true;
        }
      break;
      }
    case repeat2:   // Loop with 3 parms.???
      {   // Loop(offset, cnt1, cnt2?).
        //Guessing: loop cnt1 each round. use cnt2 as loop var.
        //This is necessary for loop nesting.
        //(used in mining machine, orb of the moons)

        // maybe cnt1 and cnt2 should be swapped... not sure

      do_another = true;
      Usecode_value& cntval = code->get_elem(i + 3);
      Usecode_value& origval = code->get_elem(i + 2);
      int cnt = cntval.get_int_value();
      int orig = origval.get_int_value();
      if (cnt > orig) { // ++++ First pass? Set to orig or not?
        cntval = origval;
        cnt = orig;
      }
      if (cnt <= 0) {
          // Done.
        i += 3;
        cntval = origval; // restore counter
      } else
        { // Decr. and loop.
        cntval = Usecode_value(cnt - 1);
        Usecode_value& offval = code->get_elem(i + 1);
        i += offval.get_int_value() - 1;
        }
      break;
      }
    case nop:   // Just a nop.
      break;
    case Ucscript::finish:  // Flag to finish if deleted.
      must_finish = true;
      do_another = true;
      break;
    case dont_halt:   // ?? Always appears first.
          // Maybe means "don't let
          //    intrinsic 5c stop it".
      no_halt = true; // PURE GUESS.
      do_another = true;
      break;
    case delay_ticks: // 1 parm.
      {   //   delay before next instruction.
      Usecode_value& delayval = code->get_elem(++i);
          // It's # of ticks.
      delay = gwin->get_std_delay()*delayval.get_int_value();
      break;    
      }
    case delay_hours: // 1 parm., game hours.
      {
      Usecode_value& delayval = code->get_elem(++i);
      delay = delayval.get_int_value();
          // Convert to real seconds.
      delay = (delay*3600)/time_factor;
      delay *= 1000;  // Then to msecs.
      break;
      }
#if 0
    case finish:    // Quit if there's already scheduled
          //   code for item?
          // Or supercede the existing one?
      break;
#endif
    case Ucscript::remove:  // Remove obj.
      usecode->remove_item(obj);
      break;
    case rise:    // (For flying carpet.
      {
      Tile_coord t = obj->get_tile();
      if (t.tz < 10)
        t.tz++;
      obj->move(t);
      break;
      }
    case descend:
      {
      Tile_coord t = obj->get_tile();
      if (t.tz > 0)
        t.tz--;
      obj->move(t);
      break;
      }
    case frame:   // Set frame.
      usecode->set_item_frame(obj, 
          code->get_elem(++i).get_int_value());
      break;
    case egg:   // Guessing:  activate egg.
      activate_egg(usecode, obj);
      break;
    case next_frame_max:  // Stop at last frame.
      {
      int nframes = obj->get_num_frames();
      if (obj->get_framenum() < nframes - 1)
        usecode->set_item_frame(obj,
              1+obj->get_framenum());
      break;
      }
    case next_frame:
      {
      int nframes = obj->get_num_frames();
      usecode->set_item_frame(obj, 
          (1 + obj->get_framenum())%nframes);
      break;
      }
    case prev_frame_min:
      if (obj->get_framenum() > 0)
        usecode->set_item_frame(obj, 
            obj->get_framenum() - 1);
      break;
    case prev_frame:
      {
      int nframes = obj->get_num_frames();
      int pframe = obj->get_framenum() - 1;
      usecode->set_item_frame(obj, 
            (pframe + nframes)%nframes);
      break;
      }
    case say:   // Say string.
      {
      Usecode_value& strval = code->get_elem(++i);
      Usecode_value objval(obj);
      usecode->item_say(objval, strval);
      break;
      }
    case Ucscript::step:  // Parm. is dir. (0-7).  0=north.
      {
          // Get dir.
      Usecode_value& val = code->get_elem(++i);
          // It may be 0x3x.
      step(usecode, val.get_int_value()&7);
      //+++++Might be a 2nd parm, diff in altitude.
      // ++++++++++Investigate.
      break;
      }
    case music:   // Unknown.
      {
      Usecode_value& val = code->get_elem(++i);
      Audio::get_ptr()->start_music(val.get_int_value(),
                  false);
      break;
      }
    case Ucscript::usecode: // Call?
      {
      Usecode_value& val = code->get_elem(++i);
      int fun = val.get_int_value();
          // Watch for eggs:
      Usecode_internal::Usecode_events ev = 
          Usecode_internal::internal_exec;
      if (obj && obj->is_egg() 
#if 0
        //removed 20011226, breaks serpent gates in SI without SS -wjp
        && ((Egg_object *)obj)->get_type() == Egg_object::usecode
#endif
        )
        ev = Usecode_internal::egg_proximity;
          // And for telekenesis spell fun:
      else if (fun == usecode->telekenesis_fun)
          {
          ev = Usecode_internal::double_click;
          usecode->telekenesis_fun = -1;
          }
      usecode->call_usecode(fun, obj, ev);
      break;
      }
    case Ucscript::usecode2:// Call(fun, eventid).
      {
      Usecode_value& val = code->get_elem(++i);
      int evid = code->get_elem(++i).get_int_value();
      usecode->call_usecode(val.get_int_value(), obj, 
        (Usecode_internal::Usecode_events) evid);
      break;
      }
    case speech:    // Play speech track.
      {
      Usecode_value& val = code->get_elem(++i);
      int track = val.get_int_value();
      if (track >= 0)
        Audio::get_ptr()->start_speech(track);
      }
    case sfx:   // Play sound effect!
      {
      Usecode_value& val = code->get_elem(++i);
      Audio::get_ptr()->play_sound_effect(
              val.get_int_value());
      break;
      }
    case face_dir:    // Parm. is dir. (0-7).  0=north.
      {
          // Look in that dir.
      Usecode_value& val = code->get_elem(++i);
          // It may be 0x3x.  Face dir?
      int dir = val.get_int_value()&7;
      Actor *npc = obj->as_actor();
      if (npc)
        npc->set_usecode_dir(dir);
      usecode->set_item_frame(obj, obj->get_dir_framenum(
        dir, obj->get_framenum()), 1, 1);
      frame_index = 0;// Reset walking frame index.
      break;
      }
    case hit:   // Hit(hps, ??).
      {
      Usecode_value hps = code->get_elem(++i);
      Usecode_value unk = code->get_elem(++i);
      Actor *act = usecode->as_actor(obj);
      if (act)  // ++++Should apply to any object.
        act->reduce_health(hps.get_int_value());
      break;
      }
    case resurrect:
      {
      Dead_body *body = (Dead_body *) obj;
      Actor *act = gwin->get_npc(body->get_live_npc_num());
      if (act)
        act->resurrect(body);
      break;
      }
    default:
          // Frames with dir.  U7-verified!
      if (opcode >= 0x61 && opcode <= 0x70)
        { // But don't show empty frames.
        Actor *npc = obj->as_actor();
        npc->clear_rest_time();
        int v = obj->get_dir_framenum(
          npc ? npc->get_usecode_dir() : 0, 
          opcode - 0x61);
        usecode->set_item_frame(obj, v, 1, 1);
        }
      else if (opcode >= 0x30 && opcode < 0x38)
        { // Step in dir. opcode&7.
        step(usecode, opcode&7);
        do_another = true;  // Guessing.
        }
      else
        {
              cout << "Und sched. opcode " << hex << 
          "0x" << setfill((char)0x30) << setw(2) 
          << opcode << std::dec << endl;
        do_another = true; // Don't let it delay us.
        }
      break;
      }
    }
  return delay;
  }

/*
 *  Step in given direction.
 */

void Usecode_script::step
  (
  Usecode_internal *usecode,
  int dir       // 0-7.
  )
  {
  int frame = obj->get_framenum();
  Barge_object *barge;
  Actor *act = usecode->as_actor(obj);
  if (act)
    {
    Frames_sequence *frames = act->get_frames(dir);
          // Get frame (updates frame_index).
    frame = frames->get_next(frame_index);
    Tile_coord tile = obj->get_tile().get_neighbor(dir);
    obj->step(tile, frame);
    }
  else if ((barge = obj->as_barge()) != 0)
    {
    for (int i = 0; i < 4; i++)
      {
      Tile_coord t = obj->get_tile().get_neighbor(
                  dir);
      obj->step(t, 0);
      }
    }
  }

/*
 *  Save (serialize).
 *
 *  Output: Length written, or -1 if error.
 */

int Usecode_script::save
  (
  unsigned char *buf,
  int buflen
  )
  {
          // Get delay to when due.
  long when = Game_window::get_instance()->get_tqueue()->find_delay(
              this, SDL_GetTicks());
  if (when < 0)
    return -1;
  uint8 *ptr = buf;
  Write2(ptr, cnt);   // # of values we'll store.
  Write2(ptr, i);     // Current spot.
  for (int j = 0; j < cnt; j++)
    {
    Usecode_value& val = code->get_elem(j);
    int len = val.save(ptr, buflen - (ptr - buf));
    if (len < 0)
      return -1;
    ptr += len;
    }
  if (buflen - (ptr - buf) < 8) // Enough room left?
    return -1;
  Write2(ptr, frame_index);
  Write2(ptr, no_halt ? 1 : 0);
  Write4(ptr, when);
  return (ptr - buf);
  }

/*
 *  Restore (serialize).
 *
 *  Output: ->entry, which is also stored in our global chain, but is NOT
 *    added to the time queue yet.
 */

Usecode_script *Usecode_script::restore
  (
  Game_object *item,    // Object this is executed for.
  unsigned char *buf,
  int buflen
  )
  {
  uint8 *ptr = buf;
  int cnt = Read2(ptr);   // Get # instructions.
  int curindex = Read2(ptr);  // Where it is.
          // Create empty array.
  Usecode_value *code = new Usecode_value(cnt, 0);
  for (int i = 0; i < cnt; i++)
    {
    Usecode_value& val = code->get_elem(i);
    if (!val.restore(ptr, buflen - (ptr - buf)))
      {
      delete code;
      return 0;
      }
    }
  if (buflen - (ptr - buf) < 8) // Enough room left?
    {
    delete code;
    return 0;
    }
  int frame_index = Read2(ptr);
  int no_halt = Read2(ptr);
  int delay = Read4(ptr);
  Usecode_script *scr =
    new Usecode_script(item, code, frame_index, no_halt, delay);
  scr->i = curindex;    // Set index.
  return scr;
  }

/*
 *  Print for debugging.
 */

void Usecode_script::print
  (
  std::ostream& out
  )
  {
  out << hex << "Obj = 0x" << setfill((char)0x30) << setw(2)
    << (void *) obj << ": " "(";
  for (int i = 0; i < cnt; i++)
    {
    if (i > 0)
      out << ", ";
    code->get_elem(i).print(out);
    }
  out <<") = ";
  out << std::dec;
  }

---