objs.h

Go to the documentation of this file.

/*
 *  objs.h - Game objects.
 *
 *  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 OBJS_H
#define OBJS_H

#include <string> // STL string
#include "exult_constants.h"
#include "exult_types.h"
#include "flags.h"
#include "rect.h"
#include "shapeid.h"
#include "tqueue.h"
#include "tiles.h"
#include "vec.h"

#include "objlist.h"

class Actor;
class Map_chunk;
class Container_game_object;
class Terrain_game_object;
class Egg_object;
class Barge_object;
class Game_window;
class Npc_actor;
class PathFinder;
class Rectangle;
class Schedule;
class Usecode_machine;
class Vga_file;
class DataSource;

template<class T>
class T_Object_list;

/*
 *  A game object is a shape from shapes.vga along with info. about its
 *  position within its chunk.
 */
class Game_object : public ShapeID
  {
protected:
  static Game_object *editing;  // Obj. being edited by ExultStudio.
  unsigned char shape_pos;  // (X,Y) of shape within chunk.
  unsigned char lift;   // Raise by 4* this number.
  short quality;      // Some sort of game attribute.
private:
  Game_object *next, *prev; // ->next in chunk list or container.
  Game_object_vector dependencies;// Objects which must be painted before
          //   this can be rendered.
  Game_object_vector dependors; // Objects which must be painted after.
  static unsigned char rotate[8]; // For getting rotated frame #.
public:
  uint32 render_seq;    // Render sequence #.
protected:
  unsigned char cx, cy;   // (Absolute) chunk coords., or if this
          //   is in a container, coords. within
          //   gump's rectangle.
          // Handle attack on an object.
  int attack_object(Actor *attacker, int weapon_shape, int ammo_shape);
          // Create from ifix record.
  Game_object(unsigned char *ifix)
      : ShapeID(ifix[2], ifix[3]), shape_pos(ifix[0]),
        lift(ifix[1] & 0xf), quality(0), cx(255), cy(255)
    {  }
public:
  friend class T_Object_list<Game_object *>;
  friend class T_Object_iterator<Game_object *>;
  friend class T_Flat_object_iterator<Game_object *,Map_chunk *>;
  friend class T_Object_iterator_backwards<Game_object *, 
              Map_chunk *>;
  friend class Map_chunk;
  Game_object(int shapenum, int framenum, unsigned int tilex, 
        unsigned int tiley, unsigned int lft = 0)
    : ShapeID(shapenum, framenum),
        shape_pos((tilex << 4) + tiley),
      lift(lft), quality(0), cx(255), cy(255)
    {  }
          // Copy constructor.
  Game_object(const Game_object& obj2)
    : ShapeID(obj2), shape_pos(obj2.shape_pos), lift(obj2.lift),
      quality(obj2.quality), cx(obj2.cx), cy(obj2.cy)
    {  }
  Game_object() : ShapeID() // Create fake entry.
    {  }
  virtual ~Game_object()
    {  }
  int get_tx() const    // Get tile (0-15) within chunk.
    { return (shape_pos >> 4) & 0xf; }
  int get_ty() const
    { return shape_pos & 0xf; }
  int get_lift() const
    { return lift; }
  Tile_coord get_tile() const // Get location in abs. tiles.
    {
    return Tile_coord(cx*c_tiles_per_chunk + get_tx(),
        cy*c_tiles_per_chunk + get_ty(), lift);
    }
          // Get distance to another object.
  int distance(Game_object *o2) const
    { return get_tile().distance(
          o2->get_tile()); }
          // Get direction to another object.
  int get_direction(Game_object *o2) const;
  int get_direction(Tile_coord t2) const;
  Map_chunk *get_chunk();   // Get chunk this is in.
  int get_quality() const
    { return quality; }
  void set_quality(int q)
    { quality = q; }
  int get_quantity() const; // Like # of coins.
  virtual int get_obj_hp() const;     // hitpoints for non-NPCs
  virtual void set_obj_hp(int hp);
  int get_volume() const;   // Get space taken.
          // Add/remove to/from quantity.
  int modify_quantity(int delta, bool *del = 0);
          // Set shape coord. within chunk.
  void set_shape_pos(unsigned int shapex, unsigned int shapey)
    { shape_pos = (shapex << 4) + shapey; }
  void set_lift(int l)
    { lift = l; }
  Game_object *get_next()
    { return next; }
  Game_object *get_prev()
    { return prev; }
          // Compare for render order.
  static int compare(class Ordering_info& inf1, Game_object *obj2);
  int lt(Game_object& obj2);  // Is this less than another in pos.?
          // Return chunk coords.
  int get_cx() const
    { return cx; }
  int get_cy() const
    { return cy; }
  void set_invalid()    // Set to invalid position.
    { cx = cy = 255; }
  bool is_pos_invalid() const
    { return cx >= c_num_chunks || cy >= c_num_chunks; }
  void set_chunk(int newcx, int newcy)
    { cx = newcx; cy = newcy; }
          // Get frame for desired direction.
  int get_dir_framenum(int dir, int frnum) const
    { return (frnum&0xf) + rotate[dir]; }
          // Get it using current dir.
  int get_dir_framenum(int frnum) const
    { return (frnum&0xf) + (get_framenum()&(16 | 32)); }
          // Get direction (NPC) is facing.
  int get_dir_facing() const;
          // Move to new abs. location.
  virtual void move(int newtx, int newty, int newlift);
  void move(Tile_coord t)
    { move(t.tx, t.ty, t.tz); }
  void change_frame(int frnum); // Change frame & set to repaint.
          // Swap positions.
  int swap_positions(Game_object *obj2);
  int get_dependency_count()  // Get objs. to paint first.
    { return dependencies.size(); }
  Game_object *get_dependency(int i)
    { return dependencies[i]; }
  void clear_dependencies();  // Remove all dependencies.

          // Find nearby objects.
#define HDR_DECLARE_FIND_NEARBY(decl_type) \
  static int find_nearby(decl_type vec, Tile_coord pos, \
      int shapenum, int delta, int mask,  \
      int qual = c_any_qual, int framenum = c_any_framenum)

  HDR_DECLARE_FIND_NEARBY(Egg_vector&);
  HDR_DECLARE_FIND_NEARBY(Actor_vector&);
  HDR_DECLARE_FIND_NEARBY(Game_object_vector&);

#undef HDR_DECLARE_FIND_NEARBY

  int find_nearby_actors(Actor_vector& vec, int shapenum, int delta) 
                  const;
  int find_nearby_eggs(Egg_vector& vec, int shapenum, int delta,
    int qual = c_any_qual, int frnum = c_any_framenum) const;
  int find_nearby(Game_object_vector& vec, int shapenum, int delta, 
    int mask, int qual = c_any_qual, 
          int framenum = c_any_framenum) const;

  Game_object *find_closest(Game_object_vector& vec,
        int *shapenums, int num_shapes, int dist = 24);
  Game_object *find_closest(int *shapenums, int num_shapes, 
              int dist = 24);
  Game_object *find_closest(int shapenum, int dist = 24)
    { return find_closest(&shapenum, 1, dist); }
  Rectangle get_footprint();  // Get tile footprint.
  bool blocks(Tile_coord tile); // Do we block a given tile?
          // Find object blocking given tile.
  static Game_object *find_blocking(Tile_coord tile);
  static Game_object *find_door(Tile_coord tile);
  int is_closed_door() const; // Checking for a closed door.
  Game_object *get_outermost(); // Get top 'owner' of this object.
  void say(const char *text);   // Put text up by item.
  void say(int from, int to); // Show random msg. from 'text.flx'.
          // Render.
  virtual void paint();
  void paint_outline(Pixel_colors pix);
          // Make this class abstract.
  virtual void paint_terrain() = 0;
          // Can this be clicked on?
  virtual int is_findable()
    { return 1; }
          // Run usecode function.
  virtual void activate(int event = 1);
  virtual bool edit();    // Edit in ExultStudio.
          // Saved from ExultStudio.
  static void update_from_studio(unsigned char *data, int datalen);
  virtual std::string get_name() const;
          // Remove/delete this object.
  virtual void remove_this(int nodel = 0);
  virtual Container_game_object *get_owner()
    { return 0; }
  virtual void set_owner(Container_game_object *o)
    {  }
  static int get_weight(int shnum, int quant = 1);
  virtual int get_weight();
  virtual int get_max_weight(); // Get max. weight allowed.
  virtual int is_dragable() const;// Can this be dragged?
          // Drop another onto this.
  virtual int drop(Game_object *obj);
          // Set/clear/get actor flag.
  virtual void set_flag(int flag) {  }
  virtual void set_siflag(int flag) { }
  virtual void clear_siflag(int flag) { }
  virtual void clear_flag(int flag) { }
  virtual int get_flag(int flag) const  { return 0; }
  virtual void set_flag_recursively(int flag) { }
  virtual int get_siflag(int flag) const { return 0; }
  virtual int get_type_flag(int flag) const { return 0; }

  virtual Actor *as_actor() { return 0; }
  virtual Npc_actor *as_npc() { return 0; }
  virtual Barge_object *as_barge() { return 0; }
  virtual Terrain_game_object *as_terrain() { return 0; }
  virtual Container_game_object *as_container() { return 0; }
  virtual Egg_object *as_egg() { return 0; }
  virtual int is_egg() const  // An egg?
    { return 0; }
          // Count contained objs.
  virtual int count_objects(int shapenum, int qual = c_any_qual,
              int framenum = c_any_framenum)
    { return 0; }
          // Get contained objs.
  virtual int get_objects(Game_object_vector& vec, int shapenum, int qual,
            int framenum)
    { return 0; }
          // Add an object.
  virtual bool add(Game_object *obj, bool dont_check = false,
              bool combine = false);
          // Add to NPC 'ready' spot.
  virtual int add_readied(Game_object *obj, int index, int dont_check = 0, int force_pos = 0)
    { return add(obj, dont_check!=0); }
  virtual int add_quantity(int delta, int shapenum, int qual = c_any_qual,
        int framenum = c_any_framenum, int dontcreate = 0)
    { return delta; }
  virtual int create_quantity(int delta, int shapenum, int qual,
            int framenum, bool temporary = false)
    { return delta; }
  virtual int remove_quantity(int delta, int shapenum, int qual,
                int framenum)
    { return delta; }
  virtual Game_object *find_item(int shapenum, int qual, int framenum)
    { return 0; }
          // Get coord. where this was placed.
  virtual Tile_coord get_original_tile_coord() const
    { return get_tile(); }
          // Move out of the way.
  virtual int move_aside(Actor *for_actor, int dir)
    { return 0; }   // For now.
          // Get frame if rotated clockwise.
  virtual int get_rotated_frame(int quads);
          // Step onto an (adjacent) tile.
  virtual int step(Tile_coord t, int frame)
    { return 0; }
  virtual int is_monster()
    { return 0; }
          // Under attack.
  virtual Game_object *attacked(Actor *attacker, int weapon_shape = 0,
          int ammo_shape = 0);
          // Write out to IREG file.
  virtual void write_ireg(DataSource* out)
    {  }
        // Get size of IREG. Returns -1 if can't write to buffer
  virtual int get_ireg_size()
    { return 0; }
          // Write out IFIX, CHUNKS.
  virtual void write_ifix(DataSource* ifix)
    {  }
  virtual void elements_read()  // Called when all member items read.
    {  }
          // Write common IREG data.
  void write_common_ireg(unsigned char *buf);
  virtual int get_live_npc_num()
    { return -1; }

  virtual void delete_contents() { }

  };

/*
 *  Object from U7chunks.
 */
class Terrain_game_object : public Game_object
  {
public:
  Terrain_game_object(int shapenum, int framenum, unsigned int tilex, 
        unsigned int tiley, unsigned int lft = 0)
    : Game_object(shapenum, framenum, tilex, tiley, lft)
    {  }
  virtual Terrain_game_object *as_terrain() { return this; }
  virtual void paint_terrain();
  };

/*
 *  Object from an IFIXxx file.
 */
class Ifix_game_object : public Game_object
  {
public:
          // Create from ifix record.
  Ifix_game_object(unsigned char *ifix) : Game_object(ifix)
    {  }
  Ifix_game_object(int shapenum, int framenum, unsigned int tilex, 
        unsigned int tiley, unsigned int lft = 0)
    : Game_object(shapenum, framenum, tilex, tiley, lft)
    {  }
          // Move to new abs. location.
  virtual void move(int newtx, int newty, int newlift);
          // Remove/delete this object.
  virtual void remove_this(int nodel = 0);
  virtual void paint_terrain() {  }
  virtual void write_ifix(DataSource* ifix);
  };

#endif

---