shapeid.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2000-2003  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 SHAPEID_H
#define SHAPEID_H 1

#include "exult_constants.h"
#include "shapevga.h"
#include "singles.h"

class Shape_frame;
class Shape_info;
class Fonts_vga_file;
class Font;
class Image_buffer8;

enum ShapeFile {
  SF_SHAPES_VGA = 0,  // <STATIC>/shapes.vga.  MUST be first.
  SF_GUMPS_VGA,   // <STATIC>/gumps.vga
  SF_PAPERDOL_VGA,  // <STATIC>/paperdol.vga
  SF_SPRITES_VGA,   // <STATIC>/sprites.vga
  SF_FACES_VGA,   // <STATIC>/faces.vga
  SF_EXULT_FLX,   // <DATA>/exult.flx
  SF_GAME_FLX,    // <DATA>/bg_data.flx or <DATA>/si_data.flx
  SF_BG_SIGUMP_FLX, // BG only for Paperdolls
  SF_BG_SISHAPES_VGA, // BG only for Multiracial
  // Not yet
  //SF_FONTS_VGA,   // <STATIC>/fonts.vga

  SF_OTHER,   // Other unknown FLX
  SF_COUNT    // # of preceding entries.
};

          // Special pixels.
enum Pixel_colors {POISON_PIXEL = 0, PROTECT_PIXEL, CURSED_PIXEL, HIT_PIXEL,
      NPIXCOLORS};

/*
 *  Manage the set of shape files.
 */
class Shape_manager : public Game_singletons
  {
  static Shape_manager *instance; // There shall be only one.
  Shapes_vga_file shapes;   // Main 'shapes.vga' file.
  Vga_file files[(int) SF_COUNT]; // The files we manage.
  Fonts_vga_file *fonts;    // "fonts.vga" file.
  Xform_palette xforms[11]; // Transforms translucent colors
          //   0xf4 through 0xfe.
  Xform_palette *invis_xform; // For showing invisible NPC's.
  unsigned char special_pixels[NPIXCOLORS]; // Special colors.
  bool bg_paperdolls_allowed; // Set true if the SI paperdoll file 
          //   is found when playing BG
  bool bg_paperdolls;   // True if paperdolls are wanted in BG
  bool bg_multiracial_allowed;  // Set true if the SI shapes file 
          //   is found when playing BG
public:
  friend class ShapeID;
  Shape_manager();
  ~Shape_manager();
  static Shape_manager *get_instance()
    { return instance; }
  void load();      // Read in files.
  void reload_shapes(int dragtype); // Reload a shape file.
  Vga_file& get_file(enum ShapeFile f)
    { return files[(int) f]; };
  Shapes_vga_file& get_shapes()
    { return shapes; }
  inline Xform_palette& get_xform(int i)
    { return xforms[i]; }
  // BG Only
  inline bool can_use_paperdolls() const
  { return bg_paperdolls_allowed; }

  inline bool get_bg_paperdolls() const
  { return bg_paperdolls; }

  inline void set_bg_paperdolls(bool p)
  { bg_paperdolls = p; }

  inline bool can_use_multiracial() const
  { return bg_multiracial_allowed; }

          // Paint shape in window.
  void paint_shape(int xoff, int yoff, Shape_frame *shape,
            int translucent = 0)
    {
    if (!shape || !shape->data)
      CERR("NULL SHAPE!!!");
    else if (!shape->rle)
      shape->paint(xoff, yoff);
    else if (!translucent)
      shape->paint_rle(xoff, yoff);
    else
      shape->paint_rle_translucent(xoff, yoff, xforms, 
          sizeof(xforms)/sizeof(xforms[0]));
    }

  inline void paint_invisible(int xoff, int yoff, Shape_frame *shape)
    {
    if (shape) shape->paint_rle_transformed(
            xoff, yoff, *invis_xform);
    }
          // Paint outline around a shape.
  inline void paint_outline(int xoff, int yoff, Shape_frame *shape, 
              Pixel_colors pix)
    {
    if (shape) shape->paint_rle_outline(
          xoff, yoff, special_pixels[(int) pix]);
    }
  unsigned char get_special_pixel(Pixel_colors pix)
    { return special_pixels[(int) pix]; }

          // Paint text using "fonts.vga".
  int paint_text_box(int fontnum, const char *text, int x, int y, int w, 
    int h, int vert_lead = 0, int pbreak = 0, int shading = -1);
  int paint_text(int fontnum, const char *text, int xoff, int yoff);
  int paint_text(int fontnum, const char *text, int textlen, 
              int xoff, int yoff);
          // Get text width.
  int get_text_width(int fontnum, const char *text);
  int get_text_width(int fontnum, const char *text, int textlen);
          // Get text height, baseline.
  int get_text_height(int fontnum);
  int get_text_baseline(int fontnum);
  Font *get_font(int fontnum);
  };

/*
 *  A shape ID contains a shape # and a frame # within the shape encoded
 *  as a 2-byte quantity.
 */
class ShapeID : public Game_singletons
  {
  short shapenum;     // Shape #.
  signed char framenum;   // Frame # within shape.
  char has_trans;
  ShapeFile shapefile;
  Shape_frame *shape;

  Shape_frame* cache_shape();

public:
          // Create from map data.
  ShapeID(unsigned char l, unsigned char h) 
    : shapenum(l + 256*(h&0x3)), framenum(h >> 2), has_trans(0),
      shapefile(SF_SHAPES_VGA), shape(0)
    {  }
          // Read from buffer & incr. ptr.
  ShapeID(unsigned char *& data)
    : has_trans(0), shapefile(SF_SHAPES_VGA), shape(0)
    {
    unsigned char l = *data++;
    unsigned char h = *data++;
    shapenum = l + 256*(h&0x3);
    framenum = h >> 2;
    }
          // Create "end-of-list"/invalid entry.
  ShapeID() : shapenum(-1), framenum(-1), has_trans(0), shapefile(SF_SHAPES_VGA), shape(0)
    {  }

    virtual ~ShapeID()
        {  }
          // End-of-list or invalid?
  int is_invalid() const
    { return shapenum == -1; }
  int is_eol() const
    { return is_invalid(); }

  inline int get_shapenum() const
    { return shapenum; }
  inline int get_framenum() const
    { return framenum; }
  inline ShapeFile get_shapefile() const
    { return shapefile; }
  inline Shape_frame *get_shape()
    { return (shape!=0)?shape:cache_shape(); }
  inline void set_translucent(int trans)
    { has_trans=trans; }
  inline bool is_translucent()
    { if (shape==0) cache_shape(); return has_trans!=0; }
          // Set to given shape.
  void set_shape(int shnum, int frnum)
    {
    shapenum = shnum;
    framenum = frnum;
    shape = 0;
    }
  ShapeID(int shnum, int frnum, ShapeFile shfile = SF_SHAPES_VGA) :
    shapenum(shnum), framenum(frnum), shapefile(shfile),
    shape(0), has_trans(0)
    {  }

  void set_shape(int shnum) // Set shape, but keep old frame #.
    { shapenum = shnum; shape = 0; }
  void set_frame(int frnum) // Set to new frame.
    { framenum = frnum; shape = 0; }
  void set_file(ShapeFile shfile) // Set to new flex
    { shapefile = shfile; shape = 0; }

  void paint_shape(int xoff, int yoff, bool force_trans = false)
    {
    sman->paint_shape(xoff, yoff, get_shape(), 
            has_trans || force_trans);
    }
  void paint_invisible(int xoff, int yoff)
    { sman->paint_invisible(xoff, yoff, get_shape()); }
          // Paint outline around a shape.
  inline void paint_outline(int xoff, int yoff, Pixel_colors pix)
    { sman->paint_outline(xoff, yoff, get_shape(), pix); }
  int get_num_frames() const;
  Shape_info& get_info() const  // Get info. about shape.
    { return Shape_manager::instance->shapes.get_info(shapenum); }
  static Shape_info& get_info(int shnum)  // Get info. about shape.
    { return Shape_manager::instance->shapes.get_info(shnum); }
  };

/*
 *  An interface used in Get_click():
 */
class Paintable
  {
public:
  virtual void paint() = 0;
  };

#endif

---