barge.cc

Go to the documentation of this file.

/*
Copyright (C) 2000  Jeffrey S. Freedman

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 "barge.h"
#include "gamewin.h"
#include "gamemap.h"
#include "actors.h"
#include "Zombie.h"
#include "citerate.h"
#include "dir.h"
#include "chunks.h"
#include "objiter.h"
#include "game.h"
#include "databuf.h"
#include "ucsched.h"

using std::ostream;

/*
 *  Rotate a point 90 degrees to the right around a point.
 *
 *  In cartesian coords with 'c' as center, the rule is:
 *    (newx, newy) = (oldy, -oldx)
 */

inline Tile_coord Rotate90r
  (
  Tile_coord t,     // Tile to move.
  Tile_coord c      // Center to rotate around.
  )
  {
          // Get cart. coords. rel. to center.
  int rx = t.tx - c.tx, ry = c.ty - t.ty;
  return Tile_coord(c.tx + ry, c.ty + rx, t.tz);
  }

/*
 *  Rotate a point 90 degrees to the left around a point.
 *
 *  In cartesian coords with 'c' as center, the rule is:
 *    (newx, newy) = (-oldy, oldx)
 */

inline Tile_coord Rotate90l
  (
  Tile_coord t,     // Tile to move.
  Tile_coord c      // Center to rotate around.
  )
  {
          // Get cart. coords. rel. to center.
  int rx = t.tx - c.tx, ry = c.ty - t.ty;
  return Tile_coord(c.tx - ry, c.ty - rx, t.tz);
  }

/*
 *  Rotate a point 180 degrees around a point.
 *
 *  In cartesian coords with 'c' as center, the rule is:
 *    (newx, newy) = (-oldx, -oldy)
 */

inline Tile_coord Rotate180
  (
  Tile_coord t,     // Tile to move.
  Tile_coord c      // Center to rotate around.
  )
  {
          // Get cart. coords. rel. to center.
  int rx = t.tx - c.tx, ry = c.ty - t.ty;
  return Tile_coord(c.tx - rx, c.ty + ry, t.tz);
  }

/*
 *  Figure tile where an object will be if it's rotated 90 degrees around
 *  a point counterclockwise, assuming its 'hot spot' 
 *  is at its lower-right corner.
 */

inline Tile_coord Rotate90r
  (
  Game_window *gwin,
  Game_object *obj,
  int xtiles, int ytiles,   // Object dimensions.
  Tile_coord c      // Rotate around this.
  )
  {
          // Rotate hot spot.
  Tile_coord r = Rotate90r(obj->get_tile(), c);
          // New hotspot is what used to be the
          //   upper-right corner.
  r.tx = (r.tx + ytiles + c_num_tiles)%c_num_tiles;
  r.ty = (r.ty + c_num_tiles)%c_num_tiles;
  return r;
  }

/*
 *  Figure tile where an object will be if it's rotated 90 degrees around
 *  a point, assuming its 'hot spot' is at its lower-right corner.
 */

inline Tile_coord Rotate90l
  (
  Game_window *gwin,
  Game_object *obj,
  int xtiles, int ytiles,   // Object dimensions.
  Tile_coord c      // Rotate around this.
  )
  {
          // Rotate hot spot.
  Tile_coord r = Rotate90l(obj->get_tile(), c);
          // New hot-spot is old lower-left.
  r.ty = (r.ty + xtiles + c_num_tiles)%c_num_tiles;
  r.tx = (r.tx + c_num_tiles)%c_num_tiles;
  return r;
  }

/*
 *  Figure tile where an object will be if it's rotated 180 degrees around
 *  a point, assuming its 'hot spot' is at its lower-right corner.
 */

inline Tile_coord Rotate180
  (
  Game_window *gwin,
  Game_object *obj,
  int xtiles, int ytiles,   // Object dimensions.
  Tile_coord c      // Rotate around this.
  )
  {
          // Rotate hot spot.
  Tile_coord r = Rotate180(obj->get_tile(), c);
          // New hotspot is what used to be the
          //   upper-left corner.
  r.tx = (r.tx + xtiles + c_num_tiles)%c_num_tiles;
  r.ty = (r.ty + ytiles + c_num_tiles)%c_num_tiles;
  return r;
  }

/*
 *  Swap dimensions.
 */

inline void Barge_object::swap_dims
  (
  )
  {
  int tmp = xtiles;   // Swap dims.
  xtiles = ytiles;
  ytiles = tmp;
  }

/*
 *  Get footprint in tiles.
 */

Rectangle Barge_object::get_tile_footprint
  (
  )
  {
  Tile_coord pos = get_tile();
  int xts = get_xtiles(), yts = get_ytiles();
  Rectangle foot((pos.tx - xts + 1 + c_num_tiles)%c_num_tiles, 
    (pos.ty - yts + 1 + c_num_tiles)%c_num_tiles, xts, yts);
  return foot;
  }

/*
 *  Set center.
 */

inline void Barge_object::set_center
  (
  )
  {
  center = get_tile();
  center.tx = (center.tx - xtiles/2 + c_num_tiles)%c_num_tiles;
  center.ty = (center.ty - ytiles/2 + c_num_tiles)%c_num_tiles;
  }

/*
 *  See if okay to rotate.
 +++++++++++Handle wrapping here+++++++++++
 */

int Barge_object::okay_to_rotate
  (
  Tile_coord pos      // New position (bottom-right).
  )
  {
  int lift = get_lift();
          // Special case for carpet.
  int move_type = (lift >= 10) ? (MOVE_LEVITATE) : MOVE_ALL_TERRAIN;
          // Get footprint in tiles.
  Rectangle foot = get_tile_footprint();
  int xts = get_xtiles(), yts = get_ytiles();
          // Get where new footprint will be.
  Rectangle newfoot(pos.tx - yts + 1, pos.ty - xts + 1, yts, xts);
  int new_lift;
  if (newfoot.y < foot.y)   // Got a piece above the old one?
          // Check area.  (No dropping allowed.)
    if (Map_chunk::is_blocked(4, lift,
      newfoot.x, newfoot.y, newfoot.w, foot.y - newfoot.y,
        new_lift, move_type, 0) || new_lift != lift)
      return 0;
  if (foot.y + foot.h < newfoot.y + newfoot.h)
          // A piece below old one.
    if (Map_chunk::is_blocked(4, lift,
      newfoot.x, foot.y + foot.h, newfoot.w, 
      newfoot.y + newfoot.h - (foot.y + foot.h),
        new_lift, move_type, 0) || new_lift != lift)
      return 0;
  if (newfoot.x < foot.x)   // Piece to the left?
    if (Map_chunk::is_blocked(4, lift,
      newfoot.x, newfoot.y, foot.x - newfoot.x, newfoot.h,
        new_lift, move_type, 0) || new_lift != lift)
      return 0;
  if (foot.x + foot.w < newfoot.x + newfoot.w)
          // Piece to the right.
    if (Map_chunk::is_blocked(4, lift,
      foot.x + foot.w, newfoot.y,
      newfoot.x + newfoot.w - (foot.x + foot.w), newfoot.h,
        new_lift, move_type, 0) || new_lift != lift)
      return 0;
  return 1;
  }

/*
 *  Delete.
 */

Barge_object::~Barge_object
  (
  )
  {
  delete path;
  }

/*
 *  Gather up all objects that appear to be on this barge.
 *  Also inits. 'center'.
 */

void Barge_object::gather
  (
  )
  {
  if (!gmap->get_chunk_safely(get_cx(), get_cy()))
    return;     // Not set in world yet.
  ice_raft = false;   // We'll just detect it each time.
  objects.resize(perm_count); // Start fresh.
          // Get footprint in tiles.
  Rectangle foot = get_tile_footprint();
  int lift = get_lift();    // How high we are.
          // Go through intersected chunks.
  Chunk_intersect_iterator next_chunk(foot);
  Rectangle tiles;
  int cx, cy;
  bool si = Game::get_game_type() == SERPENT_ISLE;
  while (next_chunk.get_next(tiles, cx, cy))
    {
    Map_chunk *chunk = gmap->get_chunk(cx, cy);
    tiles.x += cx*c_tiles_per_chunk;
    tiles.y += cy*c_tiles_per_chunk;
    Game_object *obj;
    Object_iterator next(chunk->get_objects());
    while ((obj = next.get_next()) != 0)
      {   // Look at each object.
      if (obj == this)
        continue;
      if (obj->is_egg()) // don't pick up eggs
        continue;
      Tile_coord t = obj->get_tile();
      Shape_info& info = obj->get_info();
          // Above barge, within 5-tiles up?
      if (tiles.has_point(t.tx, t.ty) &&
          t.tz >= lift - 1 &&
          t.tz + info.get_3d_height() > lift && 
          (info.is_barge_part() || t.tz < lift + 5) &&
          obj->get_owner() != this)
        {
        objects.append(obj);
        if (si)
          {
          if (obj->get_shapenum() == 0x1f8)
            ice_raft = true;
          // Kludge for SI turtle.
          else if (obj->get_shapenum() == 0xd7)
            xtiles = 20;
          }
        }
      }
    }
  set_center();
          // Test for boat.
  Map_chunk *chunk = gmap->get_chunk_safely(
    center.tx/c_tiles_per_chunk, center.ty/c_tiles_per_chunk);
  if (boat == -1 && chunk != 0)
    {
    ShapeID flat = chunk->get_flat(center.tx%c_tiles_per_chunk,
            center.ty%c_tiles_per_chunk);
    if (flat.is_invalid())
      boat = 0;
    else
      {
      Shape_info& info = flat.get_info();
      boat = info.is_water();
      }
    }
  gathered = true;
  }

/*
 *  Add a dirty rectangle for our current position.
 */

void Barge_object::add_dirty
  (
  )
  {
  int x, y;     // Get lower-right corner.
  gwin->get_shape_location(this, x, y);
  int w = xtiles*c_tilesize, h = ytiles*c_tilesize;
  Rectangle box(x - w, y - h, w, h);
  box.enlarge(10);    // Make it a bit bigger.
  if (dir%2)      // Horizontal?  Stretch.
    { box.x -= 18; box.w += 36; }
  else
    { box.y -= 18; box.h += 36; }
  box = gwin->clip_to_win(box); // Intersect with screen.
  gwin->add_dirty(box);
  }

/*
 *  Finish up moving all the objects by adding them back and deleting the
 *  saved list of positions.
 */

void Barge_object::finish_move
  (
  Tile_coord *positions   // New positions.  Deleted when done.
  )
  {
  set_center();     // Update center.
  int cnt = objects.size(); // We'll move each object.
  for (int i = 0; i < cnt; i++) // Now add them back in new location.
    {
    Game_object *obj = get_object(i);
    if (i < perm_count) // Restore us as owner.
      obj->set_owner(this);
    obj->move(positions[i]);
    }
  delete [] positions;
          // Check for scrolling.
  gwin->scroll_if_needed(center);
  }

/*
 *  Turn to face a given direction.
 */

void Barge_object::face_direction
  (
  int ndir      // 0-7 0==North.
  )
  {
  ndir /= 2;      // Convert to 0-3.
  switch ((4 + ndir - dir)%4)
    {
  case 1:       // Rotate 90 degrees right.
    turn_right();
    break;
  case 2:
    turn_around();    // 180 degrees.
    break;
  case 3:
    turn_left();
    break;
  default:
    break;
    }
  }

/*
 *  Travel towards a given tile.
 */

void Barge_object::travel_to_tile
  (
  Tile_coord dest,    // Destination.
  int speed     // Time between frames (msecs).
  )
  {
  if (!path)
    path = new Zombie();
          // Set up new path.
  if (path->NewPath(get_tile(), dest, 0))
    {
    frame_time = speed;
          // Figure new direction.
    Tile_coord cur = get_tile();
    int dy = Tile_coord::delta(cur.ty, dest.ty),
        dx = Tile_coord::delta(cur.tx, dest.tx);
    int ndir = Get_direction4(-dy, dx);
    if (!ice_raft)    // Ice-raft doesn't rotate.
      face_direction(ndir);
    if (!in_queue())  // Not already in queue?
      gwin->get_tqueue()->add(Game::get_ticks(), this, 0L);
    }
  else
    frame_time = 0;   // Not moving.
  }

/*
 *  Turn 90 degrees to the right.
 */

void Barge_object::turn_right
  (
  )
  {
  add_dirty();      // Want to repaint old position.
          // Move the barge itself.
  Tile_coord rot = Rotate90r(gwin, this, xtiles, ytiles, center);
  if (!okay_to_rotate(rot)) // Check for blockage.
    return;
  Container_game_object::move(rot.tx, rot.ty, rot.tz);
  swap_dims();      // Exchange xtiles, ytiles.
  dir = (dir + 1)%4;    // Increment direction.
  int cnt = objects.size(); // We'll move each object.
          // But 1st, remove & save new pos.
  Tile_coord *positions = new Tile_coord[cnt];
  for (int i = 0; i < cnt; i++)
    {
    Game_object *obj = get_object(i);
    int frame = obj->get_framenum();
    Shape_info& info = obj->get_info();
    positions[i] = Rotate90r(gwin, obj, info.get_3d_xtiles(frame),
          info.get_3d_ytiles(frame), center);
    obj->remove_this(1);  // Remove object from world.
          // Set to rotated frame.
    obj->set_frame(obj->get_rotated_frame(1));
    obj->set_invalid(); // So it gets added back right.
    }
  finish_move(positions);   // Add back & del. positions.
  }

/*
 *  Turn 90 degrees to the left.
 */

void Barge_object::turn_left
  (
  )
  {
  add_dirty();      // Want to repaint old position.
          // Move the barge itself.
  Tile_coord rot = Rotate90l(gwin, this, xtiles, ytiles, center);
  if (!okay_to_rotate(rot)) // Check for blockage.
    return;
  Container_game_object::move(rot.tx, rot.ty, rot.tz);
  swap_dims();      // Exchange xtiles, ytiles.
  dir = (dir + 3)%4;    // Increment direction.
  int cnt = objects.size(); // We'll move each object.
          // But 1st, remove & save new pos.
  Tile_coord *positions = new Tile_coord[cnt];
  for (int i = 0; i < cnt; i++)
    {
    Game_object *obj = get_object(i);
    int frame = obj->get_framenum();
    Shape_info& info = obj->get_info();
    positions[i] = Rotate90l(gwin, obj, info.get_3d_xtiles(frame),
          info.get_3d_ytiles(frame), center);
    obj->remove_this(1);  // Remove object from world.
          // Set to rotated frame.
    obj->set_frame(obj->get_rotated_frame(3));
    obj->set_invalid(); // So it gets added back right.
    }
  finish_move(positions);   // Add back & del. positions.
  }

/*
 *  Turn 180 degrees.
 */

void Barge_object::turn_around
  (
  )
  {
  add_dirty();      // Want to repaint old position.
          // Move the barge itself.
  Tile_coord rot = Rotate180(gwin, this, xtiles, ytiles, center);
  Container_game_object::move(rot.tx, rot.ty, rot.tz);
  dir = (dir + 2)%4;    // Increment direction.
  int cnt = objects.size(); // We'll move each object.
          // But 1st, remove & save new pos.
  Tile_coord *positions = new Tile_coord[cnt];
  for (int i = 0; i < cnt; i++)
    {
    Game_object *obj = get_object(i);
    int frame = obj->get_framenum();
    Shape_info& info = obj->get_info();
    positions[i] = Rotate180(gwin, obj, info.get_3d_xtiles(frame),
          info.get_3d_ytiles(frame), center);
    obj->remove_this(1);  // Remove object from world.
          // Set to rotated frame.
    obj->set_frame(obj->get_rotated_frame(2));
    obj->set_invalid(); // So it gets added back right.
    }
  finish_move(positions);   // Add back & del. positions.
  }

/*
 *  Ending 'barge mode'.
 */

void Barge_object::done
  (
  )
  {
  gathered = false;   // Clear for next time.
  static int norecurse = 0; // Don't recurse on the code below.
  if (norecurse > 0)
    return;
  norecurse++;
  if (boat == 1)      // Look for sails on boat.
    {     // Pretend they were clicked on.
    int cnt = objects.size(); // Look for open sail.
    for (int i = 0; i < cnt; i++)
      {
      Game_object *obj = objects[i];
      if (obj->get_shapenum() == 251 &&
          (obj->get_framenum()&7) < 4)
        {
        obj->activate();
        break;
        }
      }
    }
  norecurse--;
  }

/*
 *  Is it okay to land?
 */

int Barge_object::okay_to_land
  (
  )
  {
  Rectangle foot = get_tile_footprint();
  int lift = get_lift();    // How high we are.
          // Go through intersected chunks.
  Chunk_intersect_iterator next_chunk(foot);
  Rectangle tiles;
  int cx, cy;
  while (next_chunk.get_next(tiles, cx, cy))
    {     // Check each tile.
    Map_chunk *chunk = gmap->get_chunk(cx, cy);
    for (int ty = tiles.y; ty < tiles.y + tiles.h; ty++)
      for (int tx = tiles.x; tx < tiles.x + tiles.w; tx++)
        if (chunk->get_highest_blocked(lift, tx, ty)
                != -1)
          return (0);
    }
  return (1);
  }

/*
 *  Handle a time event (for animation).
 */

void Barge_object::handle_event
  (
  unsigned long curtime,    // Current time of day.
  long udata      // Ignored.
  )
  {
  if (!path || !frame_time || gwin->get_moving_barge() != this)
    return;     // We shouldn't be doing anything.
  Tile_coord tile;    // Get spot & walk there. 
          // Take two steps for speed.
  if (!path->GetNextStep(tile) || !step(tile))
    frame_time = 0;
          // But not when just starting.
  else if (!first_step && (!path->GetNextStep(tile) || !step(tile)))
    frame_time = 0;
  else
    gwin->get_tqueue()->add(curtime + frame_time, this, udata);
  first_step = false;   // After 1st, move 2 at a time.
  }

/*
 *  Move to a new absolute location.
 */

void Barge_object::move
  (
  int newtx, 
  int newty, 
  int newlift
  )
  {
  if (!gathered)      // Happens in SI with turtle.
    gather();
          // Want to repaint old position.
  add_dirty();
          // Get current location.
  Tile_coord old = get_tile();
          // Move the barge itself.
  Container_game_object::move(newtx, newty, newlift);
          // Get deltas.
  int dx = newtx - old.tx, dy = newty - old.ty, dz = newlift - old.tz;
  int cnt = objects.size(); // We'll move each object.
          // But 1st, remove & save new pos.
  Tile_coord *positions = new Tile_coord[cnt];
  int i;
  for (i = 0; i < cnt; i++)
    {
    Game_object *obj = get_object(i);
    Tile_coord ot = obj->get_tile();
          // Watch for world-wrapping.
    positions[i] = Tile_coord(
        (ot.tx + dx + c_num_tiles)%c_num_tiles,
        (ot.ty + dy + c_num_tiles)%c_num_tiles, 
        ot.tz + dz);
    obj->remove_this(1);  // Remove object from world.
    obj->set_invalid(); // So it gets added back right.
          // Animate a few shapes.
    int frame = obj->get_framenum();
    switch (obj->get_shapenum())
      {
    case 774:   // Cart wheel.
      obj->set_frame(((frame + 1)&3)|(frame&32));
      break;
    case 796:   // Draft horse.
      obj->set_frame(((frame + 4)&15)|(frame&32));
      break;
      }
    }
  finish_move(positions);   // Add back & del. positions.
  }

/*
 *  Remove an object.
 */

void Barge_object::remove
  (
  Game_object *obj
  )
  {
  obj->set_owner(0);
  obj->remove_this(1);    // Now remove from outside world.
  }

/*
 *  Add an object.
 *
 *  Output: 0, meaning object should also be added to chunk.
 */

bool Barge_object::add
  (
  Game_object *obj,
  bool dont_check,
  bool combine      // True to try to combine obj.  MAY
          //   cause obj to be deleted.
  )
  {
  objects.append(obj);    // Add to list.
  return (false);     // We want it added to the chunk.
  }

/*
 *  Drop another onto this.
 *
 *  Output: 0 to reject, 1 to accept.
 */

int Barge_object::drop
  (
  Game_object *obj
  )
  {
  return 0;     //++++++Later.
  }

/*
 *  Paint at given spot in world.
 */

void Barge_object::paint
  (
  )
  {
          // DON'T paint barge shape itself.
          // The objects are in the chunk too.
  if(gwin->paint_eggs)
    Container_game_object::paint();
  }

/*
 *  Step onto an adjacent tile.
 *
 *  Output: 0 if blocked.
 *    Dormant is set if off screen.
 */

int Barge_object::step
  (
  Tile_coord t,     // Tile to step onto.
  int       // Frame (ignored).
  )
  {
  if (!gathered)      // Happens in SI with turtle.
    gather();
  Tile_coord cur = get_tile();
          // Blocked? (Assume ht.=4, for now.)
  int move_type;
  if (cur.tz >= 10)
    {     // Definitely a carpet.
    move_type = MOVE_LEVITATE;
    boat = 0;
    }
  else if (boat) 
    {
    move_type = MOVE_SWIM;
          // Hawk's boat gets grounded in SI.
    if (Game::get_game_type() == SERPENT_ISLE)
      {
      int sx = cur.tx/c_tiles_per_schunk,
          sy = cur.ty/c_tiles_per_schunk;
      if (sx == 8 && sy == 9) // Hawk's ship.
        move_type |= MOVE_WALK;
      }
    }
  else move_type = MOVE_WALK;
          // No rising/dropping.
        if (Map_chunk::is_blocked(get_xtiles(), get_ytiles(), 
            4, cur, t, move_type, 0, 0))
    return (0);   // Done.
  move(t.tx, t.ty, t.tz);   // Move it & its objects.
          // Near an egg?
  Map_chunk *nlist = gmap->get_chunk(get_cx(), get_cy());
  nlist->activate_eggs(gwin->get_main_actor(), t.tx, t.ty, t.tz, 
            cur.tx, cur.ty);
  return (1);     // Add back to queue for next time.
  }

/*
 *  Write out.
 */

void Barge_object::write_ireg
  (
  DataSource *out
  )
  {
  unsigned char buf[13];    // 13-byte entry + length-byte.
  buf[0] = 12;
  unsigned char *ptr = &buf[1]; // To avoid confusion about offsets.
  write_common_ireg(ptr);   // Fill in bytes 1-4.
  ptr += 4;
          // Write size.
  *ptr++ = xtiles;
  *ptr++ = ytiles;
  *ptr++ = 0;     // Unknown.
          // Flags (quality).  Taking B3 to in-
          //   dicate barge mode.
  *ptr++ = (dir<<1) | ((gwin->get_moving_barge() == this)<<3);
  *ptr++ = 0;     // (Quantity).
  *ptr++ = (get_lift()&15)<<4;
  *ptr++ = 0;     // Data2.
  *ptr++ = 0;     // 
  out->write((char*)buf, sizeof(buf));
          // Write permanent objects.
  for (int i = 0; i < perm_count; i++)
    {
    Game_object *obj = get_object(i);
    obj->write_ireg(out);
    }
  out->write1(0x01);      // A 01 terminates the list.
          // Write scheduled usecode.
  Game_map::write_scheduled(out, this); 
  }

// Get size of IREG. Returns -1 if can't write to buffer
int Barge_object::get_ireg_size()
{
  // These shouldn't ever happen, but you never know
  if (gwin->get_moving_barge() == this || Usecode_script::find(this))
    return -1;

  int total_size = 13;

  for (int i = 0; i < perm_count; i++)
  {
    Game_object *obj = get_object(i);
    int size = obj->get_ireg_size();

    if (size < 0) return -1;

    total_size += size;
  }

  total_size += 1;

  return total_size;
}

/*
 *  This is called after all elements have been read in and added.
 */

void Barge_object::elements_read
  (
  )
  {
  perm_count = 0;     // So we don't get haystack!
  complete = true;
  }

---