gamemap.cc

Go to the documentation of this file.

/*
 *
 *  Copyright (C) 1998-1999  Jeffrey S. Freedman
 *  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

#ifndef ALPHA_LINUX_CXX
#  include <cstdlib>
#  include <cstring>
#  include <cstdarg>
#  include <cstdio>
#endif

#include "gamemap.h"
#include "objs.h"
#include "chunks.h"
#include "mappatch.h"
#include "fnames.h"
#include "utils.h"
#include "shapeinf.h"
#include "objiter.h"
#include "Flex.h"
#include "exceptions.h"
#include "animate.h"
#include "barge.h"
#include "spellbook.h"
#include "virstone.h"
#include "egg.h"
#include "jawbone.h"
#include "actors.h" /* For Dead_body, which should be moved. */
#include "ucsched.h"
#include "gamewin.h"  /* With some work, could get rid of this. */
#include "bodies.h"
#include "game.h"
#include "effects.h"
#include "objiter.cc" /* Yes we #include the .cc here on purpose! Please don't "fix" this */
#include "databuf.h"
#include <fstream>

#ifndef UNDER_CE
using std::cerr;
using std::cout;
using std::endl;
using std::istream;
using std::ifstream;
using std::ios;
using std::memcpy;
using std::memset;
using std::ofstream;
using std::rand;
using std::strcmp;
using std::strcpy;
using std::string;
using std::strlen;
using std::srand;
using std::vector;
#endif

/*
 *  Create a chunk.
 */

Map_chunk *Game_map::create_chunk
  (
  int cx, int cy
  )
  {
  return (objects[cx][cy] = new Map_chunk(cx, cy));
  }

/*
 *  Read in a terrain chunk.
 */

Chunk_terrain *Game_map::read_terrain
  (
  int chunk_num     // Want this one from u7chunks.
  )
  {
  assert(chunk_num >= 0 && chunk_num < chunk_terrains.size());
  unsigned char buf[16*16*2]; 
  chunks->seekg(chunk_num * 512);
  chunks->read(reinterpret_cast<char*>(buf), sizeof(buf));
  Chunk_terrain *ter = new Chunk_terrain(&buf[0]);
  chunk_terrains.put(chunk_num, ter);
  return ter;
  }

/*
 *  Create game window.
 */

Game_map::Game_map
  (
  ) : 
            chunk_terrains(0), read_all_terrain(false), 
      map_modified(false),
      map_patches(new Map_patch_collection), chunks(0)
  {
  }

/*
 *  Deleting map.
 */

Game_map::~Game_map
  (
  )
  {
  clear();      // Delete all objects, chunks.
  delete chunks;
  delete map_patches;
  }

/*
 *  Initialize for new/restored game.
 */

void Game_map::init
  (
  )
  {
  if (chunks)
    delete chunks;
  chunks = new ifstream;
  int num_chunk_terrains;
  bool patch_exists = is_system_path_defined("<PATCH>");
  if (patch_exists && U7exists(PATCH_U7CHUNKS))
    U7open(*chunks, PATCH_U7CHUNKS);
  else try
    {
    U7open(*chunks, U7CHUNKS);
    }
  catch(const file_exception & f)
    {
    if (!Game::is_editing() ||  // Ok if map-editing.
        !patch_exists)  // But only if patch exists.
      throw f;
    ofstream ochunks; // Create one in 'patch'.
    U7open(ochunks, PATCH_U7CHUNKS);
    unsigned char buf[16*16*2]; 
    memset(&buf[0], 0, sizeof(buf));
    ochunks.write((char *) buf, sizeof(buf));
    ochunks.close();
    U7open(*chunks, PATCH_U7CHUNKS);
    }
          // Get to end so we can get length.
  chunks->seekg(0, ios::end);
          // 2 bytes/tile.
  num_chunk_terrains = chunks->tellg()/
        (c_tiles_per_chunk*c_tiles_per_chunk*2);
          // Resize list to hold all.
  chunk_terrains.resize(num_chunk_terrains);
  read_all_terrain = map_modified = false;
  std::ifstream u7map;    // Read in map.
  bool nomap = false;
  if (is_system_path_defined("<PATCH>") && U7exists(PATCH_U7MAP))
    U7open(u7map, PATCH_U7MAP);
  else try 
    {
    U7open(u7map, U7MAP);
    }
  catch(const file_exception & f)
    {
    if (!Game::is_editing())  // Ok if map-editing.
      throw f;
    nomap = true;
    }
  for (int schunk = 0; schunk < c_num_schunks*c_num_schunks; schunk++)
  {     // Read in the chunk #'s.
    unsigned char buf[16*16*2];
    if (nomap)
      memset(&buf[0], 0, sizeof(buf));
    else
      u7map.read(reinterpret_cast<char *>(buf), sizeof(buf));
    int scy = 16*(schunk/12);// Get abs. chunk coords.
    int scx = 16*(schunk%12);
    uint8 *mapdata = buf;
          // Go through chunks.
    for (int cy = 0; cy < 16; cy++)
      for (int cx = 0; cx < 16; cx++)
        terrain_map[scx+cx][scy+cy] = Read2(mapdata);
  }
  u7map.close();
          // Clear object lists, flags.
  // No casting _should_ be necessary at this point.
  // Who needs this?
  memset(reinterpret_cast<char*>(objects), 0, sizeof(objects));
  memset(reinterpret_cast<char*>(schunk_read), 0, sizeof(schunk_read));
  memset(reinterpret_cast<char*>(schunk_modified), 0, 
            sizeof(schunk_modified));

  memset(schunk_cache, 0, sizeof (schunk_cache));
  memset(schunk_cache_sizes, -1, sizeof(schunk_cache_sizes));
  }

/*
 *  Clear out world's contents.  Should be used during a 'restore'.
 */

void Game_map::clear
  (
  )
  {
          // Delete all chunks (& their objs).
  for (int y = 0; y < c_num_chunks; y++)
    for (int x = 0; x < c_num_chunks; x++)
      {
      delete objects[x][y];
      objects[x][y] = 0;
      }
  int cnt = chunk_terrains.size();
  int i;
  for (i = 0; i < cnt; i++)
    delete chunk_terrains[i];
  chunk_terrains.resize(0);
  delete chunks;      // Close 'u7chunks'.
  chunks = 0;
  map_modified = false;
          // Clear 'read' flags.
  memset(reinterpret_cast<char*>(schunk_read), 0, sizeof(schunk_read));
  memset(reinterpret_cast<char*>(schunk_modified), 0, 
            sizeof(schunk_modified));

  for (i = 0; i < 144; i++) delete [] schunk_cache[i];
  memset(schunk_cache, 0, sizeof (schunk_cache));
  memset(schunk_cache_sizes, -1, sizeof(schunk_cache_sizes));

  }

/*
 *  Read in superchunk data to cover the screen.
 */

void Game_map::read_map_data
  (
  )
  {
  Game_window *gwin = Game_window::get_instance();
  int scrolltx = gwin->get_scrolltx(), scrollty = gwin->get_scrollty();
  int w = gwin->get_width(), h = gwin->get_height();
          // Start one tile to left.
  int firstsx = (scrolltx - 1)/c_tiles_per_schunk, 
      firstsy = (scrollty - 1)/c_tiles_per_schunk;
          // End 8 tiles to right.
  int lastsx = (scrolltx + (w + c_tilesize - 2)/c_tilesize + 
        c_tiles_per_chunk/2)/c_tiles_per_schunk;
  int lastsy = (scrollty + (h + c_tilesize - 2)/c_tilesize + 
        c_tiles_per_chunk/2)/c_tiles_per_schunk;
          // Watch for wrapping.
  int stopsx = (lastsx + 1)%c_num_schunks,
      stopsy = (lastsy + 1)%c_num_schunks;
          // Read in "map", "ifix" objects for
          //  all visible superchunks.
  for (int sy = firstsy; sy != stopsy; sy = (sy + 1)%c_num_schunks)
    for (int sx = firstsx; sx != stopsx; 
            sx = (sx + 1)%c_num_schunks)
      {
          // Figure superchunk #.
      int schunk = 12*sy + sx;
          // Read it if necessary.
      if (!schunk_read[schunk])
        get_superchunk_objects(schunk);
      }
  } 

/*
 *  Get the map objects and scenery for a superchunk.
 */

void Game_map::get_map_objects
  (
  int schunk      // Superchunk # (0-143).
  )
  {
  int scy = 16*(schunk/12); // Get abs. chunk coords.
  int scx = 16*(schunk%12);
          // Go through chunks.
  for (int cy = 0; cy < 16; cy++)
    for (int cx = 0; cx < 16; cx++)
      get_chunk_objects(scx + cx, scy + cy);
  }

/*
 *  Read in terrain graphics data into window's image.  (May also be
 *  called during map-editing if the chunknum changes.)
 */

void Game_map::get_chunk_objects
  (
  int cx, int cy      // Chunk index within map.
  )
  {
          // Get list we'll store into.
  Map_chunk *chunk = get_chunk(cx, cy);
  int chunk_num = terrain_map[cx][cy];
  Chunk_terrain *ter = get_terrain(chunk_num);
  chunk->set_terrain(ter);
  }

/*
 *  Read in all terrain chunks (for editing).
 */

void Game_map::get_all_terrain
  (
  )
  {
  if (read_all_terrain)
    return;     // Already done.
  int num_chunk_terrains = chunk_terrains.size();
  for (int i = 0; i < num_chunk_terrains; i++)
    if (!chunk_terrains[i])
      read_terrain(i);
  read_all_terrain = true;
  }

/*
 *  Set a chunk to a new terrain (during map-editing).
 */

void Game_map::set_chunk_terrain
  (
  int cx, int cy,     // Coords. of chunk to change.
  int chunknum      // New chunk #.
  )
  {
  terrain_map[cx][cy] = chunknum; // Set map.
  get_chunk_objects(cx, cy);  // Set chunk to it.
  }

/*
 *  Get the name of an ireg or ifix file.
 *
 *  Output: ->fname, where name is stored.
 */

char *Game_map::get_schunk_file_name
  (
  char *prefix,     // "ireg" or "ifix".
  int schunk,     // Superchunk # (0-143).
  char *fname     // Name is stored here.
  )
  {
  strcpy(fname, prefix);
  int len = strlen(fname);
  fname[len] = '0' + schunk/16;
  int lb = schunk%16;
  fname[len + 1] = lb < 10 ? ('0' + lb) : ('a' + (lb - 10));
  fname[len + 2] = 0;
  return (fname);
  }

/*
 *  Write out the 'static' map files.
 */

void Game_map::write_static
  (
  )
  {
  U7mkdir("<PATCH>", 0755);   // Create dir if not already there. Don't
                  // use PATCHDAT define cause it has a
                  // trailing slash

  int schunk;     // Write each superchunk to 'static'.
  for (schunk = 0; schunk < c_num_schunks*c_num_schunks; schunk++)
          // Only write what we've modified.
    if (schunk_modified[schunk])
      write_ifix_objects(schunk);
  int cnt = chunk_terrains.size();
  int i;        // Any terrains modified?
  for (i = 0; i < cnt; i++)
    if (chunk_terrains[i] && chunk_terrains[i]->is_modified())
      break;
  if (i < cnt)      // Got to update.
    {
    get_all_terrain();  // IMPORTANT:  Get all in memory.
    ofstream ochunks; // Open file for chunks data.
          // This truncates the file.
    U7open(ochunks, PATCH_U7CHUNKS);
    for (i = 0; i < cnt; i++)
      {
      Chunk_terrain *ter = chunk_terrains[i];
      unsigned char data[512];
      if (ter)
        {
        ter->write_flats(data);
        ter->set_modified(false);
        }
      else
        {
        memset(&data[0], 0, 512);
        cerr << "NULL terrain.  U7chunks may be bad."
                << endl;
        }
      ochunks.write(reinterpret_cast<char*>(data), 512);
      }
    if (!ochunks.good())
      throw file_write_exception(U7CHUNKS);
    ochunks.close();
    }
  std::ofstream u7map;    // Write out map.
  U7open(u7map, PATCH_U7MAP);
  for (schunk = 0; schunk < c_num_schunks*c_num_schunks; schunk++)
    {
    int scy = 16*(schunk/12);// Get abs. chunk coords.
    int scx = 16*(schunk%12);
    uint8 buf[16*16*2];
    uint8 *mapdata = buf;
          // Go through chunks.
    for (int cy = 0; cy < 16; cy++)
      for (int cx = 0; cx < 16; cx++)
        Write2(mapdata, terrain_map[scx+cx][scy+cy]);
    u7map.write(reinterpret_cast<char*>(buf), sizeof(buf));
    }
  if (!u7map.good())
    throw file_write_exception(U7MAP);
  u7map.close();
  map_modified = false;
  }

/*
 *  Write out one of the "u7ifix" files.
 *
 *  Output: Errors reported.
 */

void Game_map::write_ifix_objects
  (
  int schunk      // Superchunk # (0-143).
  )
  {
  char fname[128];    // Set up name.
  ofstream ifix_stream; // There it is.
  U7open(ifix_stream, get_schunk_file_name(PATCH_U7IFIX, schunk, fname));
  StreamDataSource ifix(&ifix_stream);
          // +++++Use game title.
  const int count = c_chunks_per_schunk*c_chunks_per_schunk;
  Flex::write_header(&ifix, "Exult",  count);
  uint8 table[2*count*4];
  uint8 *tptr = &table[0];
  int scy = 16*(schunk/12); // Get abs. chunk coords.
  int scx = 16*(schunk%12);
          // Go through chunks.
  for (int cy = 0; cy < 16; cy++)
    for (int cx = 0; cx < 16; cx++)
      {
          // Store file position in table.
      long start = ifix.getPos();
      Write4(tptr, start);
      Map_chunk *chunk = get_chunk(scx + cx,
                     scy + cy);
          // Restore original order (sort of).
      Object_iterator_backwards next(chunk);
      Game_object *obj;
      while ((obj = next.get_next()) != 0)
        obj->write_ifix(&ifix);
          // Store IFIX data length.
      Write4(tptr, ifix.getPos() - start);
      }
  ifix.seek(0x80);  // Write table.
  ifix.write(reinterpret_cast<char *>(&table[0]), sizeof(table));
  ifix_stream.flush();
  int result = ifix_stream.good();
  if (!result)
    throw file_write_exception(fname);
  schunk_modified[schunk] = false;
  return;
  }

/*
 *  Read in the objects for a superchunk from one of the "u7ifix" files.
 */

void Game_map::get_ifix_objects
  (
  int schunk      // Superchunk # (0-143).
  )
  {
  char fname[128];    // Set up name.
  ifstream ifix_stream; // There it is.
  if (is_system_path_defined("<PATCH>") &&
          // First check for patch.
      U7exists(get_schunk_file_name(PATCH_U7IFIX, schunk, fname)))
    U7open(ifix_stream, fname);
  else try
    {
    U7open(ifix_stream, get_schunk_file_name(U7IFIX, schunk, fname));
    }
    catch(const file_exception & f)
    {
    if (!Game::is_editing())  // Ok if map-editing.
      throw f;
    return;
    }
  StreamDataSource ifix(&ifix_stream);
  int scy = 16*(schunk/12); // Get abs. chunk coords.
  int scx = 16*(schunk%12);
          // Go through chunks.
  for (int cy = 0; cy < 16; cy++)
    for (int cx = 0; cx < 16; cx++)
      {
          // Get to index entry for chunk.
      int chunk_num = cy*16 + cx;
      ifix.seek(0x80 + chunk_num*8);
          // Get location, length.
      long shapesoff = ifix.read4();
      if (!shapesoff) // Nothing there?
        continue;
      unsigned long shapeslen = ifix.read4();
      get_ifix_chunk_objects(&ifix, shapesoff, shapeslen/4,
        scx + cx, scy + cy);
      }
  }

/*
 *  Get the objects from one ifix chunk entry onto the screen.
 */

void Game_map::get_ifix_chunk_objects
  (
  DataSource* ifix,
  long filepos,     // Where chunk's data lies.
  int cnt,      // # entries (objects).
  int cx, int cy      // Absolute chunk #'s.
  )
  {
  Game_window *gwin = Game_window::get_instance();
  ifix->seek(filepos);    // Get to actual shape.
          // Get buffer to hold entries' indices.
  unsigned char *entries = new unsigned char[4*cnt];
  unsigned char *ent = entries; // Read them in.
  ifix->read(reinterpret_cast<char*>(entries), 4*cnt);
          // Get object list for chunk.
  Map_chunk *olist = get_chunk(cx, cy);
  for (int i = 0; i < cnt; i++, ent += 4)
    {
    Ifix_game_object *obj;
    int shnum = ent[2]+256*(ent[3]&3);
    Shape_info& info = ShapeID::get_info(shnum);
    if (info.is_animated() || info.has_sfx())
      obj = new Animated_ifix_object(ent);
    else
      obj = new Ifix_game_object(ent);

    olist->add(obj);
    }
  delete[] entries;   // Done with buffer.
  olist->setup_dungeon_levels();  // Should have all dungeon pieces now.
  }

/*
 *  Constants for IREG files:
 */
#define IREG_SPECIAL  255   // Precedes special entries.
#define IREG_UCSCRIPT 1   // Saved Usecode_script for object.
#define IREG_ENDMARK  2   // Just an 'end' mark.

/*
 *  Write out scheduled usecode for an object.
 */

void Game_map::write_scheduled
  (
  DataSource* ireg,
  Game_object *obj,
  bool write_mark     // Write an IREG_ENDMARK if true.
  )
  {
  for (Usecode_script *scr = Usecode_script::find(obj); scr;
          scr = Usecode_script::find(obj, scr))
    {
    unsigned char buf[256];
    int len = scr->save(buf, sizeof(buf));
    if (len < 0)
      cerr << "Error saving Usecode script" << endl;
    else if (len > 0)
      {
      ireg->write1(IREG_SPECIAL);
      ireg->write1(IREG_UCSCRIPT);
      ireg->write2(len);  // Store length.
      ireg->write(reinterpret_cast<char*>(buf), len);
      }
    }
  if (write_mark)
    {
    ireg->write1(IREG_SPECIAL);
    ireg->write1(IREG_ENDMARK);
    }
  }

/*
 *  Write modified 'u7ireg' files.
 */

void Game_map::write_ireg
  (
  )
  {

          // Write each superchunk to Iregxx.
  for (int schunk = 0; schunk < c_num_schunks*c_num_schunks; schunk++)
          // Only write what we've read.
    if (schunk_cache[schunk] && schunk_cache_sizes[schunk] >= 0) {
      // It's loaded in a memory buffer
      char fname[128];    // Set up name.
      ofstream ireg_stream;
      U7open(ireg_stream, get_schunk_file_name(U7IREG, schunk, fname));
      ireg_stream.write(schunk_cache[schunk], schunk_cache_sizes[schunk]);
    }
    else if (schunk_read[schunk]) {
      // It's active
      write_ireg_objects(schunk);
    }
  }

/*
 *  Write out one of the "u7ireg" files.
 *
 *  Output: 0 if error, which is reported.
 */

void Game_map::write_ireg_objects
  (
  int schunk      // Superchunk # (0-143).
  )
  {
  char fname[128];    // Set up name.
  ofstream ireg_stream;     // There it is.
  U7open(ireg_stream, get_schunk_file_name(U7IREG, schunk, fname));
  StreamDataSource ireg(&ireg_stream);
  write_ireg_objects (schunk, &ireg);
  ireg_stream.flush();
  int result = ireg_stream.good();
  if (!result) throw file_write_exception(fname);
  return;
  }


/*
 *  Write out one of the "u7ireg" files.
 *
 *  Output: 0 if error, which is reported.
 */

void Game_map::write_ireg_objects
  (
  int schunk,     // Superchunk # (0-143).
  DataSource *ireg
  )
  {
  int scy = 16*(schunk/12); // Get abs. chunk coords.
  int scx = 16*(schunk%12);
          // Go through chunks.
  for (int cy = 0; cy < 16; cy++)
    for (int cx = 0; cx < 16; cx++)
      {
      Map_chunk *chunk = get_chunk(scx + cx,
                     scy + cy);
      Game_object *obj;
          // Restore original order (sort of).
      Object_iterator_backwards next(chunk);
      while ((obj = next.get_next()) != 0)
        obj->write_ireg(ireg);
      ireg->write2(0);// End with 2 0's.
      }
  }

/*
 *  Read in the objects for a superchunk from one of the "u7ireg" files.
 *  (These are the moveable objects.)
 */

void Game_map::get_ireg_objects
  (
  int schunk      // Superchunk # (0-143).
  )
  {
  char fname[128];    // Set up name.
  ifstream ireg_stream;     // There it is.
  DataSource *ireg = 0;

  if (schunk_cache[schunk] && schunk_cache_sizes[schunk] >= 0) {
    // No items
    if (schunk_cache_sizes[schunk] == 0) return;
    ireg = new BufferDataSource (schunk_cache[schunk], schunk_cache_sizes[schunk]);
#ifdef DEBUG
    std::cout << "Reading " << get_schunk_file_name(U7IREG, schunk, fname) << " from memory" << std::endl;
#endif
  }
  else {
    try
    {
      U7open(ireg_stream, get_schunk_file_name(U7IREG, schunk, fname));
    }
    catch(const file_exception & f)
    {
      return;     // Just don't show them.
    }
    ireg = new StreamDataSource (&ireg_stream);
  }
  int scy = 16*(schunk/12); // Get abs. chunk coords.
  int scx = 16*(schunk%12);
  read_ireg_objects(ireg, scx, scy);
          // A fixup:
  if (schunk == 10*12 + 11 && Game::get_game_type() == SERPENT_ISLE)
    {     // Lever in SilverSeed:
    Game_object_vector vec;
    if (Game_object::find_nearby(vec, Tile_coord(2936, 2726, 0),
          787, 0, 0, c_any_qual, 5))
      vec[0]->move(2937, 2727, 2);
    }
  delete ireg;
  if (schunk_cache[schunk]) {
    delete [] schunk_cache[schunk];
    schunk_cache[schunk] = 0;
    schunk_cache_sizes[schunk] = -1;
  }

  }

/*
 *  Read in a 'special' IREG entry (one starting with 255).
 */

void Read_special_ireg
  (
  DataSource *ireg,
  Game_object *obj    // Last object read.
  )
  {
  int type = ireg->read1();   // Get type.
  int len = ireg->read2();    // Length of rest.
  unsigned char *buf = new unsigned char[len];
  ireg->read(reinterpret_cast<char*>(buf), len);
  if (type == IREG_UCSCRIPT)  // Usecode script?
    {
    Usecode_script *scr = Usecode_script::restore(obj, buf, len);
    if (scr)
      {
      scr->start(scr->get_delay());
#if 0
      COUT("Restored script for '" << 
        item_names[obj->get_shapenum()]
              << "'" << endl);
      scr->print(cout); cout << endl;
#endif
      }
    }
  else
    cerr << "Unknown special IREG entry: " << type << endl;
  delete [] buf;
  }

/*
 *  Read in a 'special' IREG entry (one starting with 255).
 */

void Game_map::read_special_ireg
  (
  DataSource *ireg,
  Game_object *obj    // Last object read.
  )
  {
  unsigned char entlen;
  while ((entlen = ireg->peek()) == IREG_SPECIAL && !ireg->eof())
    {
    ireg->read1();    // Eat the IREG_SPECIAL.
    unsigned char type = ireg->peek();
    if (type == IREG_ENDMARK)
      {   // End of list.
      ireg->read1();
      return;
      }
    Read_special_ireg(ireg, obj);
    }
  }

/*
 *  Create an "egg".
 */

static Egg_object *Create_egg
  (
  unsigned char *entry,   // 1-byte ireg entry.
  bool animated
  )
  {
  int shnum = entry[2]+256*(entry[3]&3);
  int frnum = entry[3] >> 2;
  unsigned short type = entry[4] + 256*entry[5];
  int prob = entry[6];    // Probability (1-100).
  int data1 = entry[7] + 256*entry[8];
  int lift = entry[9] >> 4;
  int data2 = entry[10] + 256*entry[11];
  Egg_object *obj = animated ?
    new Animated_egg_object(shnum, frnum,
      entry[0]&0xf, entry[1]&0xf, lift, type, prob,
            data1, data2)
    : new Egg_object(shnum, frnum,
      entry[0]&0xf, entry[1]&0xf, lift, type, prob,
            data1, data2);
  return (obj);
  }

/*
 *  Containers and items classed as 'quality_flags' have a byte of flags.
 *  This routine returns them converted into Object_flags.
 */
inline unsigned long Get_quality_flags
  (
  unsigned char qualbyte    // Quality byte containing flags.
  )
  {
  return  ((qualbyte&1) << Obj_flags::invisible) |
    (((qualbyte>>3)&1) << Obj_flags::okay_to_take);
  }

/*
 *  Read a list of ireg objects.  They are either placed in the desired
 *  game chunk, or added to their container.
 */

void Game_map::read_ireg_objects
  (
  DataSource *ireg,     // File to read from.
  int scx, int scy,   // Abs. chunk coords. of superchunk.
  Game_object *container,   // Container, or null.
  unsigned long flags   // Usecode item flags.
  )
  {
  int entlen;     // Gets entry length.
  sint8 index_id = -1;
  Game_object *last_obj = 0;  // Last one read in this call.
  Game_window *gwin = Game_window::get_instance();
          // Go through entries.
  while (((entlen = ireg->read1(), !ireg->eof())))
    {

    // Skip 0's & ends of containers.

    if (!entlen || entlen == 1)
    {
      if (container)
        return; // Skip 0's & ends of containers.
      else
        continue;
    }
    // Detect the 2 byte index id
    else if (entlen == 2)
    {
      index_id = (sint8) ireg->read2();
      continue;
    }
    else if (entlen == IREG_SPECIAL)
      {
      Read_special_ireg(ireg, last_obj);
      continue;
      }
          // Get copy of flags.
    unsigned long oflags = flags & ~(1<<Obj_flags::is_temporary);
    if (entlen != 6 && entlen != 10 && entlen != 12 && 
                entlen != 18)
      {
      long pos = ireg->getPos();
      cout << "Unknown entlen " << entlen << " at pos. " <<
          pos << endl;
      ireg->seek(pos + entlen);
      continue; // Only know these two types.
      }
    unsigned char entry[18];// Get entry.
    ireg->read(reinterpret_cast<char*>(entry), entlen);
    int cx = entry[0] >> 4; // Get chunk indices within schunk.
    int cy = entry[1] >> 4;
          // Get coord. #'s where shape goes.
    int tilex = entry[0] & 0xf;
    int tiley = entry[1] & 0xf;
          // Get shape #, frame #.
    int shnum = entry[2]+256*(entry[3]&3);
    int frnum = entry[3] >> 2;

    Shape_info& info = ShapeID::get_info(shnum);
    unsigned int lift, quality, type;
    Ireg_game_object *obj;
    int is_egg = 0;   // Fields are eggs.
          // An "egg"?

    // Has flag byte(s)
    if (entlen == 10)
    {
      // Temporary
      if (entry[6] & 1) oflags |= 1<<Obj_flags::is_temporary;
    }
    
    if (info.get_shape_class() == Shape_info::hatchable)
      {
      bool anim = info.is_animated() || info.has_sfx();
      Egg_object *egg = Create_egg(entry, anim);
      get_chunk(scx + cx, scy + cy)->add_egg(egg);
      last_obj = egg;
      continue;
      }
    else if (entlen == 6 || entlen == 10) // Simple entry?
      {
      type = 0;
      lift = entry[4] >> 4;
      quality = entry[5];
      obj = create_ireg_object(info, shnum, frnum,
              tilex, tiley, lift);
      is_egg = obj->is_egg();

          // Wierd use of flag:
      if (info.has_quantity())
        {
        if (!(quality&0x80))
          oflags &= 
            ~(1<<Obj_flags::okay_to_take);
        else
          quality &= 0x7f;
        }
      else if (info.has_quality_flags())
        { // Use those flags instead of deflt.
        oflags = Get_quality_flags(quality);
        quality = 0;
        }
      }
    else if (entlen == 12)  // Container?
      {
      type = entry[4] + 256*entry[5];
      lift = entry[9] >> 4;
      quality = entry[7];
      oflags =  // Override flags (I think).
        Get_quality_flags(entry[11]);
      if (shnum == 330)// Virtue stone?
        {
        Virtue_stone_object *v = 
           new Virtue_stone_object(shnum, frnum, tilex,
            tiley, lift);
        v->set_pos(entry[4], entry[5], entry[6],
                entry[7]);
        obj = v;
        type = 0;
        }
      else if (shnum == 961)
        {
        Barge_object *b = new Barge_object(
            shnum, frnum, tilex, tiley, lift,
          entry[4], entry[5],
          (quality>>1)&3);
        obj = b;
        if (!gwin->get_moving_barge() && 
              (quality&(1<<3)))
          gwin->set_moving_barge(b);
        }
      else if (Game::get_game_type() == SERPENT_ISLE &&
        shnum == 555) // serpent jawbone
        {
        obj = new Jawbone_object(shnum, frnum,
          tilex, tiley, lift, entry[10]);
        }
      else if (Game::get_game_type() == SERPENT_ISLE && 
         shnum == 400 && frnum == 8 && quality == 1)
        // Gwenno. Ugly hack to fix bug without having to start
        // a new game. Remove someday... (added 20010820)
        {
        Dead_body *b = new Dead_body(400, 8, 
            tilex, tiley, lift, 149);
        obj = b;
        gwin->set_body(149, b);
        }
      else if (quality == 1 && 
           (entry[8] >= 0x80 || 
          Game::get_game_type() == SERPENT_ISLE)) 
        {   // NPC's body.
        int npc_num = (entry[8] - 0x80) & 0xFF;
        Dead_body *b = new Dead_body(shnum, frnum, 
            tilex, tiley, lift, npc_num);
        obj = b;
        gwin->set_body(npc_num, b);
        }
      else if (Is_body(shnum)) {
        obj = new Dead_body(
            shnum, frnum, tilex, tiley, lift, -1);
      }
      else
        obj = new Container_game_object(
            shnum, frnum, tilex, tiley, lift,
              entry[10]);
          // Read container's objects.
      if (type) // (0 if empty.)
        { // Don't pass along invisibility!
        read_ireg_objects(ireg, scx, scy, obj, 
          oflags & ~(1<<Obj_flags::invisible));
        obj->elements_read();
        }
      }
    else      // Length 18 means it's a spellbook.
      {   // Get all 9 spell bytes.
      quality = 0;
      unsigned char circles[9];
      memcpy(&circles[0], &entry[4], 5);
      lift = entry[9] >> 4;
      memcpy(&circles[5], &entry[10], 4);
      uint8 *ptr = &entry[14];
          // 3 unknowns, then bookmark.
      unsigned char bmark = ptr[3];
      obj = new Spellbook_object(
        shnum, frnum, tilex, tiley, lift,
        &circles[0], bmark);
      }
    obj->set_quality(quality);
    obj->set_flags(oflags);
    last_obj = obj;   // Save as last read.
          // Add, but skip volume check.
    if (container)
      {
      if (index_id != -1 && 
          container->add_readied(obj, index_id, 1, 1))
        continue;
      else if (container->add(obj, 1))
        continue;
      }
    Map_chunk *chunk = get_chunk(scx + cx, scy + cy);
    if (is_egg)
      chunk->add_egg((Egg_object *) obj);
    else
      chunk->add(obj);
    }
  }

/*
 *  Create non-container IREG objects.
 */

Ireg_game_object *Game_map::create_ireg_object
  (
  Shape_info& info,   // Info. about shape.
  int shnum, int frnum,   // Shape, frame.
  int tilex, int tiley,   // Tile within chunk.
  int lift      // Desired lift.
  )
  {
  if (info.is_field())    // (These are all animated.)
    {     // Check shapes.
    if (shnum == 895 || // Fire.
        shnum == 561) // SI - blue flame.
      return new Field_object(shnum, frnum, tilex, tiley,
          lift, Egg_object::fire_field);
    else if (shnum == 900)  // Poison.
      return new Field_object(shnum, frnum, tilex, tiley,
          lift, Egg_object::poison_field);
    else if (shnum == 902)  // Sleep.
      return new Field_object(shnum, frnum, tilex, tiley,
          lift, Egg_object::sleep_field);
    else if (shnum == 756)  // Caltrops.
      return new Field_object(shnum, frnum, tilex, tiley,
          lift, Egg_object::caltrops_field);
    }
  if (info.is_animated() || info.has_sfx())
    return new Animated_ireg_object(
           shnum, frnum, tilex, tiley, lift);
  if (shnum == 607)   // Path.
    return new Egglike_game_object(
          shnum, frnum, tilex, tiley, lift);
  if (shnum == 848 || shnum == 268) // Mirror
    return new Mirror_object(shnum, frnum, tilex, tiley, lift);
  else if (shnum == 761)    // Spellbook.
    {
    static unsigned char circles[9] = {0};
    return new Spellbook_object(
        shnum, frnum, tilex, tiley, lift,
        &circles[0], 0);
    }
  else if (info.get_shape_class() == Shape_info::container)
    {
    if (shnum == 555 && GAME_SI)
      return new Jawbone_object(shnum, frnum, tilex, tiley,
                  lift);
    else
      return new Container_game_object(shnum, frnum, 
              tilex, tiley, lift);
    }
  else
    return new Ireg_game_object(shnum, frnum, tilex, tiley, lift);
  }

/*
 *  Create non-container IREG objects.
 */

Ireg_game_object *Game_map::create_ireg_object
  (
  int shnum, int frnum    // Shape, frame.
  )
  {
  return create_ireg_object(ShapeID::get_info(shnum), 
            shnum, frnum, 0, 0, 0);
  }

/*
 *  Create 'fixed' (landscape, building) objects.
 */

Ifix_game_object *Game_map::create_ifix_object
  (
  int shnum, int frnum    // Shape, frame.
  )
  {
  Shape_info& info = ShapeID::get_info(shnum);
  return (info.is_animated() || info.has_sfx())
      ? new Animated_ifix_object(shnum, frnum, 0, 0, 0)
      : new Ifix_game_object(shnum, frnum, 0, 0, 0);
  }

/*
 *  Read in the objects in a superchunk.
 */

void Game_map::get_superchunk_objects
  (
  int schunk      // Superchunk #.
  )
  {
//  CYCLE_RED_PLASMA();
  get_map_objects(schunk);  // Get map objects/scenery.
//  CYCLE_RED_PLASMA();
  get_ifix_objects(schunk); // Get objects from ifix.
//  CYCLE_RED_PLASMA();
  get_ireg_objects(schunk); // Get moveable objects.
//  CYCLE_RED_PLASMA();
  schunk_read[schunk] = 1;  // Done this one now.
  map_patches->apply(schunk); // Move/delete objects.
  }

/*
 *  Locate a chunk with a given terrain # and center the view on it.
 *
 *  Output: true if found, else 0.
 */

bool Game_map::locate_terrain
  (
  int tnum,     // # in u7chunks.
  int& cx, int& cy,   // Chunk to start at, or (-1,-1).
          //   Updated with chunk found.
  bool upwards      // If true, search upwards.
  )
  {
  int cnum;     // Chunk #, counting L-R, T-B.
  int cstop;      // Stop when cnum == cstop.
  int dir;
  if (upwards)
    {
    cstop = -1;
    dir = -1;
    if (cx == -1)   // Start at end?
      cnum = c_num_chunks*c_num_chunks - 1;
    else
      cnum = cy*c_num_chunks + cx - 1;
    }
  else
    {
    cstop = c_num_chunks*c_num_chunks;
    dir = 1;
    cnum = (cx == -1) ? 0 : cy*c_num_chunks + cx + 1;
    }
  while (cnum != cstop)
    {
    int chunky = cnum/c_num_chunks;
    int chunkx = cnum%c_num_chunks;
    if (terrain_map[chunkx][chunky] == tnum)
      {   // Return chunk # found.
      cx = chunkx;
      cy = chunky;
          // Center window over chunk found.
      Game_window::get_instance()->center_view(Tile_coord(
        cx*c_tiles_per_chunk + c_tiles_per_chunk/2,
        cy*c_tiles_per_chunk + c_tiles_per_chunk/2, 
                  0));
      return true;
      }
    cnum += dir;
    }
  return false;     // Failed.
  }

/*
 *  Swap two adjacent terrain #'s, keeping the map looking the same.
 *
 *  Output: false if unsuccessful.
 */

bool Game_map::swap_terrains
  (
  int tnum      // Swap tnum and tnum + 1.
  )
  {
  if (tnum < 0 || tnum >= chunk_terrains.size() - 1)
    return false;   // Out of bounds.
  map_modified = true;
          // Swap in list.
  Chunk_terrain *tmp = get_terrain(tnum);
  tmp->set_modified();
  chunk_terrains[tnum] = get_terrain(tnum + 1);
  chunk_terrains[tnum]->set_modified();
  chunk_terrains[tnum + 1] = tmp;
          // Update terrain map.
  for (int cy = 0; cy < c_num_chunks; cy++)
    for (int cx = 0; cx < c_num_chunks; cx++)
      {
      if (terrain_map[cx][cy] == tnum)
        terrain_map[cx][cy]++;
      else if (terrain_map[cx][cy] == tnum + 1)
        terrain_map[cx][cy]--;
      }
  Game_window::get_instance()->set_all_dirty();
  return true;
  }

/*
 *  Insert a new terrain after a given one, and push all the others up
 *  so the map looks the same.  The new terrain is filled with
 *  (shape, frame) == (0, 0) unless 'dup' is passed 'true'.
 *
 *  Output: False if unsuccessful.
 */

bool Game_map::insert_terrain
  (
  int tnum,     // Insert after this one (may be -1).
  bool dup      // If true, duplicate #tnum.
  )
  {
  if (tnum < -1 || tnum >= chunk_terrains.size())
    return false;   // Invalid #.
  get_all_terrain();    // Need all of 'u7chunks' read in.
  map_modified = true;
  unsigned char buf[16*16*2]; // Set up buffer with shape #'s.
  if (dup && tnum >= 0)
    {     // Want to duplicate given terrain.
    Chunk_terrain *ter = chunk_terrains[tnum];
    unsigned char *data = &buf[0];
    for (int ty = 0; ty < c_tiles_per_chunk; ty++)
      for (int tx = 0; tx < c_tiles_per_chunk; tx++)
      {
      ShapeID id = ter->get_flat(tx, ty);
      *data++ = id.get_shapenum()&0xff;
      *data++ = ((id.get_shapenum()>>8)&3) | 
            (id.get_framenum()<<2);
      }
    }
  else
    memset(reinterpret_cast<char*>(buf), 0, sizeof(buf));
  Chunk_terrain *new_terrain = new Chunk_terrain(&buf[0]);
          // Insert in list.
  chunk_terrains.insert(chunk_terrains.begin() + tnum + 1, new_terrain);
          // Indicate terrains are modified.
  int num_chunk_terrains = chunk_terrains.size();
  for (int i = tnum + 1; i < num_chunk_terrains; i++)
    chunk_terrains[i]->set_modified();
  if (tnum + 1 == num_chunk_terrains - 1)
    return true;    // Inserted at end of list.
          // Update terrain map.
  for (int cy = 0; cy < c_num_chunks; cy++)
    for (int cx = 0; cx < c_num_chunks; cx++)
      {
      if (terrain_map[cx][cy] > tnum)
        terrain_map[cx][cy]++;
      }
  Game_window::get_instance()->set_all_dirty();
  return true;
  }

/*
 *  Remove a terrain, updating the map.
 *
 *  Output: false if unsuccessful.
 */

bool Game_map::delete_terrain
  (
  int tnum
  )
  {
  if (tnum < 0 || tnum >= chunk_terrains.size())
    return false;   // Out of bounds.
  map_modified = true;
  int sz = chunk_terrains.size();
  delete chunk_terrains[tnum];
  for (int i = tnum + 1; i < sz; i++)
    {     // Move the rest downwards.
    Chunk_terrain *tmp = get_terrain(i);
    tmp->set_modified();
    chunk_terrains[i - 1] = tmp;
    }
  chunk_terrains.resize(sz - 1);
          // Update terrain map.
  for (int cy = 0; cy < c_num_chunks; cy++)
    for (int cx = 0; cx < c_num_chunks; cx++)
      {
      if (terrain_map[cx][cy] >= tnum)
        terrain_map[cx][cy]--;
      }
  Game_window::get_instance()->set_all_dirty();
  return true;
  }

/*
 *  Commit edits made to terrain chunks.
 */

void Game_map::commit_terrain_edits
  (
  )
  {
  int num_terrains = chunk_terrains.size();
          // Create list of flags.
  unsigned char *ters = new unsigned char[num_terrains];
  memset(ters, 0, num_terrains);
          // Commit edits.
  for (int i = 0; i < num_terrains; i++)
    if (chunk_terrains[i] && chunk_terrains[i]->commit_edits())
      ters[i] = 1;
          // Update terrain map.
  for (int cy = 0; cy < c_num_chunks; cy++)
    for (int cx = 0; cx < c_num_chunks; cx++)
      {
      Map_chunk *chunk = objects[cx][cy];
      if (chunk && ters[terrain_map[cx][cy]] != 0 &&
          chunk->get_terrain())
          // Reload objects.
        chunk->set_terrain(chunk->get_terrain());
      }
  delete [] ters;
  }

/*
 *  Abort edits made to terrain chunks.
 */

void Game_map::abort_terrain_edits
  (
  )
  {
  int num_terrains = chunk_terrains.size();
          // Abort edits.
  for (int i = 0; i < num_terrains; i++)
    if (chunk_terrains[i])
      chunk_terrains[i]->abort_edits();
  }

/*
 *  Find all unused shapes in game.  This can take a while!!
 */

void Game_map::find_unused_shapes
  (
  unsigned char *found,   // Bits set for shapes found.
  int foundlen      // # bytes.
  )
  {
  memset(found, 0, foundlen);
  Game_window *gwin = Game_window::get_instance();
  Shape_manager *sman = Shape_manager::get_instance();
  cout << "Reading all chunks";
          // Read in EVERYTHING!
  for (int sc = 0; sc < c_num_schunks*c_num_schunks; sc++)
    {
    cout << '.';
    cout.flush();
    char msg[80];
    snprintf(msg, sizeof(msg), "Scanning superchunk %d", sc);
    gwin->get_effects()->center_text(msg);
    gwin->paint();
    gwin->show();
    if (!schunk_read[sc])
      get_superchunk_objects(sc);
    }
  cout << endl;
  int maxbits = foundlen*8; // Total #bits in 'found'.
  int nshapes = sman->get_shapes().get_num_shapes();
  if (maxbits > nshapes)
    maxbits = nshapes;
          // Go through chunks.
  for (int cy = 0; cy < c_num_chunks; cy++)
    for (int cx = 0; cx < c_num_chunks; cx++)
      {
      Map_chunk *chunk = get_chunk(cx, cy);
      Recursive_object_iterator all(chunk->get_objects());
      Game_object *obj;
      while ((obj = all.get_next()) != 0)
        {
        int shnum = obj->get_shapenum();
        if (shnum >= 0 && shnum < maxbits)
          found[shnum/8] |= (1<<(shnum%8));
        }
      }
  int i;
  for (i = 0; i < maxbits; i++) // Add all possible monsters.
    {
    Shape_info& info = ShapeID::get_info(i);
    Monster_info *minf = info.get_monster_info();
    if (minf)
      found[i/8] |= (1<<(i%8));
    Weapon_info *winf = info.get_weapon_info();
    if (winf)   // Get projectiles for weapons.
      {
      int proj = winf->get_projectile();
      if (proj > 0 && proj < maxbits)
        found[proj/8] |= (1<<(proj%8));
      }
    }
  for (i = 0x96; i < maxbits; i++)  // Ignore flats (<0x96).
    if (!(found[i/8]&(1<<(i%8))))
      cout << "Shape " << i << " not found in game" << endl;
  }

/*
 *  Look throughout the map for a given shape.  The search starts at
 *  the first currently-selected shape, if possible.
 *
 *  Output: ->object if found, else 0.
 */

Game_object *Game_map::locate_shape
  (
  int shapenum,     // Desired shape.
  bool upwards,     // If true, search upwards.
  Game_object *start    // Start here if !0.
  )
  {
  int cx = -1, cy = 0;    // Before chunk to search.
  int dir = 1;      // Direction to increment.
  int stop = c_num_chunks;
  if (upwards)
    {
    dir = -1;
    stop = -1;
    cx = c_num_chunks;  // Past last chunk.
    cy = c_num_chunks - 1;
    }
  Game_object *obj = 0;
  if (start)      // Start here.
    {
    Game_object *owner = start->get_outermost();
    cx = owner->get_cx();
    cy = owner->get_cy();
    if (upwards)
      {
      Recursive_object_iterator_backwards next(start);
      while ((obj = next.get_next()) != 0)
        if (obj->get_shapenum() == shapenum)
          break;
      }
    else
      {
      Recursive_object_iterator next(start);
      while ((obj = next.get_next()) != 0)
        if (obj->get_shapenum() == shapenum)
          break;
      }
    }
  while (!obj)      // Not found yet?
    {
    cx += dir;    // Next chunk.
    if (cx == stop)   // Past (either) end?
      {
      cy += dir;
      if (cy == stop)
        break;  // All done.
      cx -= dir*c_num_chunks;
      }
    Map_chunk *chunk = get_chunk(cx, cy);
          // Make sure objs. are read.
    int sx = cx/c_chunks_per_schunk, sy = cy/c_chunks_per_schunk;
    int schunk = sy*c_num_schunks + sx;
    if (!schunk_read[schunk])
      get_superchunk_objects(schunk);
    if (upwards)
      {
      Recursive_object_iterator_backwards next(
              chunk->get_objects());
      while ((obj = next.get_next()) != 0)
        if (obj->get_shapenum() == shapenum)
          break;
      }
    else
      {
      Recursive_object_iterator next(chunk->get_objects());
      while ((obj = next.get_next()) != 0)
        if (obj->get_shapenum() == shapenum)
          break;
      }
    }
  return obj;
  }

/*
 *  Do a cache out. (x, y) is the center
 */

void Game_map::cache_out(int cx, int cy)
{
  int sx = cx / c_chunks_per_schunk;
  int sy = cy / c_chunks_per_schunk;
  bool chunk_flags[12][12];

#ifdef DEBUG
  std::cout << "Want to cache out around super chunk: " << (sy*12 + sx) << " = "  << sx << ", " << sy << std::endl;
#endif

  std::memset(chunk_flags, 0, sizeof(chunk_flags));

  // We cache out all but the 9 directly around the pov

  chunk_flags[(sy+11)%12][(sx+11)%12] = true;
  chunk_flags[(sy+11)%12][sx] = true;
  chunk_flags[(sy+11)%12][(sx+1)%12] = true;

  chunk_flags[sy][(sx+11)%12] = true;
  chunk_flags[sy][sx] = true;
  chunk_flags[sy][(sx+1)%12] = true;

  chunk_flags[(sy+1)%12][(sx+11)%12] = true;
  chunk_flags[(sy+1)%12][sx] = true;
  chunk_flags[(sy+1)%12][(sx+1)%12] = true;

  for (sy = 0; sy < 12; sy++) for (sx = 0; sx < 12; sx++) {
    if (chunk_flags[sy][sx]) continue;

    int schunk = sy*12 + sx;
    if (schunk_read[schunk] && !schunk_modified[schunk]) cache_out_schunk(schunk);
  }
}

void Game_map::cache_out_schunk(int schunk)
{
  // Get abs. chunk coords.
  const int scy = 16*(schunk/12);
  const int scx = 16*(schunk%12);
  int cy, cx;
  bool save_map_modified = map_modified;

  if (schunk_modified[schunk])
    return;     // NEVER cache out modified chunks.
  // Our vectors
  Game_object_vector removes;
  Actor_vector actors;

  int buf_size = 0;

#ifdef DEBUG
  std::cout << "Killing superchunk: " << schunk << std::endl;
#endif
  // Go through chunks and get all the items
  for (cy = 0; cy < 16; cy++) for (cx = 0; cx < 16; cx++) {

    int size = objects[scx + cx][scy + cy]->get_obj_actors(removes, actors);

    if (size < 0) {
#ifdef DEBUG
      std::cerr << "Failed attempting to kill superchunk" << std::endl;
#endif
      return;
    }

    buf_size += size + 2;
  }

  schunk_read[schunk] = false;

#ifdef DEBUG
  std::cout << "Buffer size of " << buf_size << " bytes required to store super chunk" << std::endl;
#endif

  // Clear old (this shouldn't happen)
  if (schunk_cache[schunk]) {
    delete [] schunk_cache[schunk];
    schunk_cache[schunk] = 0;
    schunk_cache_sizes[schunk] = -1;
  }

  // Create new
  schunk_cache[schunk] = new char[buf_size];
  schunk_cache_sizes[schunk] = buf_size;

  BufferDataSource ds(schunk_cache[schunk], schunk_cache_sizes[schunk]);

  write_ireg_objects(schunk, &ds);

#ifdef DEBUG
  std::cout << "Wrote " << ds.getPos() << " bytes" << std::endl;
#endif

  // Now remove the objects
  for (Game_object_vector::const_iterator it=removes.begin(); it!=removes.end(); ++it) {
    (*it)->delete_contents();
    (*it)->remove_this();
  }

  // Now disable the actors
  for (Actor_vector::const_iterator act=actors.begin(); act!=actors.end(); ++act) {
    (*act)->cache_out();
  }

  // Go through chunks and finish up
  for (cy = 0; cy < 16; cy++) for (cx = 0; cx < 16; cx++) {

    objects[scx + cx][scy + cy]->kill_cache();
  }
          // Removing objs. sets these flags.
  schunk_modified[schunk] = false;
  map_modified = save_map_modified;
}

---