gamemap.h

Go to the documentation of this file.

/*
 *  gamemap.h - Game map data.
 *
 *  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.
 */

#ifndef GAMEMAP_H
#define GAMEMAP_H

#include "exult_constants.h"
#include "vec.h"
#include "flags.h"
#ifndef ALPHA_LINUX_CXX
#  include <cassert>
#endif
#include <string> // STL string
#include <iostream>
#include <fstream>

class Map_chunk;
class Chunk_terrain;
class Map_patch_collection;
class Ireg_game_object;
class Ifix_game_object;
class Egg_object;
class Shape_info;
class Shapes_vga_file;
class DataSource;

/*
 *  The game map:
 */
class Game_map
  {
          // Flat chunk areas:
  Exult_vector<Chunk_terrain *> chunk_terrains;
  bool read_all_terrain;    // True if we've read them all.
  bool map_modified;    // True if any map changes from
          //   map-editing.
          // Chunk_terrain index for each chunk:
  short terrain_map[c_num_chunks][c_num_chunks];
          // A list of objects in each chunk:
  Map_chunk *objects[c_num_chunks][c_num_chunks];
  bool schunk_read[144];    // Flag for reading in each "ifix".
  bool schunk_modified[144];  // Flag for modified "ifix".
  char *schunk_cache[144];
  int  schunk_cache_sizes[144];
  std::ifstream *chunks;    // "u7chunks" file.
  Map_patch_collection *map_patches;

  Map_chunk *create_chunk(int cx, int cy);
  Chunk_terrain *read_terrain(int chunk_num);

  void cache_out_schunk(int schunk);
public:
  Game_map();
  ~Game_map();
  void init();      // Set up map.
  void clear();     // Clear out old map.
  void read_map_data();   // Read in 'ifix', 'ireg', etc.
  inline short get_terrain_num(int cx, int cy) const
    { return terrain_map[cx][cy]; }
  inline Map_patch_collection *get_map_patches()
    { return map_patches; }
  void set_map_modified()
    { map_modified = true; }
  bool was_map_modified() const
    { return map_modified; }
  bool is_chunk_read(int cx, int cy)
    { return cx < c_num_chunks && cy < c_num_chunks &&
      schunk_read[12*(cy/c_chunks_per_schunk) +
            cx/c_chunks_per_schunk]; }
  void set_ifix_modified(int cx, int cy)
    { 
    map_modified = true;
    schunk_modified[12*(cy/c_chunks_per_schunk) +
          cx/c_chunks_per_schunk] = true;
    }
          // Get/create objs. list for a chunk.
  Map_chunk *get_chunk(int cx, int cy)
    {
    assert((cx >= 0) && (cx < c_num_chunks) && 
            (cy >= 0) && (cy < c_num_chunks));
    Map_chunk *list = objects[cx][cy];
    return list ? list : create_chunk(cx, cy);
    }
  Map_chunk *get_chunk_safely(int cx, int cy)
    {
    Map_chunk *list;
    return (cx >= 0 && cx < c_num_chunks && 
      cy >= 0 && cy < c_num_chunks ? 
      ((list = objects[cx][cy]) != 0 ? list : 
            create_chunk(cx, cy)) : 0);
    }
          // Get "map" superchunk objs/scenery.
  void get_map_objects(int schunk);
          // Get "chunk" objects/scenery.
  void get_chunk_objects(int cx, int cy);
  void get_all_terrain();   // Read in all terrains.
          // Get desired terrain.
  Chunk_terrain *get_terrain(int tnum)
    {
    Chunk_terrain *ter = chunk_terrains[tnum];
    return ter ? ter : read_terrain(tnum);
    }
  inline int get_num_chunk_terrains() const
    { return chunk_terrains.size(); }
          // Set new terrain chunk.
  void set_chunk_terrain(int cx, int cy, int chunknum);
          // Get ifixxxx/iregxx name.
  static char *get_schunk_file_name(char *prefix,
            int schunk, char *fname);
  void write_static();    // Write to 'static' directory.
          // Write (static) map objects.
  void write_ifix_objects(int schunk);
          // Get "ifix" objects for a superchunk.
  void get_ifix_objects(int schunk);
          // Get "ifix" objs. for given chunk.
  void get_ifix_chunk_objects(DataSource* ifix, long filepos, int cnt,
              int cx, int cy);
          // Write scheduled script for obj.
  static void write_scheduled(DataSource* ireg, Game_object *obj,
            bool write_mark = false);
  void write_ireg();    // Write modified ireg files.
          // Write moveable objects to file.
  void write_ireg_objects(int schunk);
          // Write moveable objects to datasource.
  void write_ireg_objects(int schunk, DataSource *ireg);
          // Get moveable objects.
  void get_ireg_objects(int schunk);
          // Read scheduled script(s) for obj.
  void read_special_ireg(DataSource* ireg, Game_object *obj);
  void read_ireg_objects(DataSource* ireg, int scx, int scy,
          Game_object *container = 0,
      unsigned long flags = (1<<Obj_flags::okay_to_take));
  Ireg_game_object *create_ireg_object(Shape_info& info, int shnum, 
      int frnum, int tilex, int tiley, int lift);
  Ireg_game_object *create_ireg_object(int shnum, int frnum);
  Ifix_game_object *create_ifix_object(int shnum, int frnum);
          // Get all superchunk objects.
  void get_superchunk_objects(int schunk);
          // Locate chunk with desired terrain.
  bool locate_terrain(int tnum, int& cx, int& cy, bool upwards = false);
  bool swap_terrains(int tnum); // Swap adjacent terrain #'s.
          // Insert new terrain after 'tnum'.
  bool insert_terrain(int tnum, bool dup = false);
  bool delete_terrain(int tnum);
  void commit_terrain_edits();  // End terrain-editing mode.
  void abort_terrain_edits();
          // Search entire game for unused.
  void find_unused_shapes(unsigned char *found, int foundlen);
          // Locate shape (for EStudio).
  Game_object *locate_shape(int shapenum, bool upwards, 
              Game_object *start);
          // Do a cache out. (cx, cy) is the center
  void cache_out(int cx, int cy);
  };

#endif

---