481 lines
14 KiB
C++
481 lines
14 KiB
C++
/*
|
||
* Copyright (C) 2003 Daniel Heck
|
||
*
|
||
* 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.,
|
||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
||
*
|
||
*/
|
||
#ifndef D_ENGINE_HH
|
||
#define D_ENGINE_HH
|
||
|
||
#include "ecl_geom.hh"
|
||
#include "ecl_array2.hh"
|
||
#include "ecl_alist.hh"
|
||
#include "ecl_fwd.hh"
|
||
|
||
namespace display
|
||
{
|
||
|
||
/* -------------------- DisplayEngine -------------------- */
|
||
|
||
class DisplayEngine {
|
||
public:
|
||
DisplayEngine (int tilew=32, int tileh=32);
|
||
~DisplayEngine();
|
||
|
||
/* ---------- Class configuration ---------- */
|
||
void add_layer (DisplayLayer *l);
|
||
void set_screen_area (const ecl::Rect & r);
|
||
void set_tilesize (int w, int h);
|
||
|
||
int get_tilew () const { return m_tilew; }
|
||
int get_tileh () const { return m_tileh; }
|
||
int get_width() const { return m_width; }
|
||
int get_height() const { return m_height; }
|
||
const ecl::Rect &get_area() const { return m_area; }
|
||
|
||
/* ---------- Scrolling / page flipping ---------- */
|
||
void set_offset (const ecl::V2 &off);
|
||
void move_offset (const ecl::V2 &off);
|
||
ecl::V2 get_offset () const { return m_offset; }
|
||
|
||
/* ---------- Game-related stuff ---------- */
|
||
void new_world (int w, int h);
|
||
void tick (double dtime);
|
||
|
||
/* ---------- Coordinate conversion ---------- */
|
||
void world_to_screen (const ecl::V2 & pos, int *x, int *y);
|
||
WorldArea screen_to_world (const ScreenArea &a);
|
||
ScreenArea world_to_screen (const WorldArea &a);
|
||
|
||
/* "Video" coordinates are like screen coordinates, except the
|
||
origin coincides with the world origin, not the current
|
||
scrolling position. */
|
||
void world_to_video (const ecl::V2 &pos, int *x, int *y);
|
||
void video_to_screen (int x, int y, int *xx, int *yy);
|
||
void video_to_world (const ecl::Rect &r, ecl::Rect &s);
|
||
|
||
V2 to_world (const V2 &pos);
|
||
|
||
/* ---------- Screen upates ---------- */
|
||
|
||
void mark_redraw_screen();
|
||
void mark_redraw_area (const WorldArea &wa, int delay=0);
|
||
|
||
void redraw_screen_area (const ScreenArea &a);
|
||
void redraw_world_area (const WorldArea &a);
|
||
|
||
void update_screen();
|
||
void draw_all (ecl::GC &gc);
|
||
void update_offset();
|
||
|
||
private:
|
||
void update_layer (DisplayLayer *l, WorldArea wa);
|
||
|
||
/* ---------- Variables ---------- */
|
||
|
||
std::vector<DisplayLayer *> m_layers;
|
||
int m_tilew, m_tileh;
|
||
|
||
// Offset of screen
|
||
ecl::V2 m_offset; // Offset in world units
|
||
ecl::V2 m_new_offset; // New offset in world units
|
||
int m_screenoffset[2]; // Offset in screen units
|
||
|
||
|
||
// Screen area occupied by level display
|
||
ecl::Rect m_area;
|
||
|
||
// Width and height of the world in tiles
|
||
int m_width, m_height;
|
||
|
||
ecl::Array2<char> m_redrawp;
|
||
};
|
||
|
||
|
||
/* -------------------- DisplayLayer -------------------- */
|
||
|
||
class DisplayLayer {
|
||
public:
|
||
DisplayLayer() {}
|
||
virtual ~DisplayLayer() {}
|
||
|
||
/* ---------- Class configuration ---------- */
|
||
void set_engine (DisplayEngine *e) { m_engine = e; }
|
||
DisplayEngine *get_engine() const { return m_engine; }
|
||
|
||
/* ---------- DisplayLayer interface ---------- */
|
||
virtual void prepare_draw (const WorldArea &) {}
|
||
virtual void draw (ecl::GC &gc, const WorldArea &a, int x, int y) = 0;
|
||
virtual void draw_onepass (ecl::GC &/*gc*/) {}
|
||
virtual void tick (double /*dtime*/) {}
|
||
virtual void new_world (int /*w*/, int /*h*/) {}
|
||
|
||
// Functions.
|
||
void mark_redraw_area (const ecl::Rect &r)
|
||
{
|
||
get_engine()->mark_redraw_area(r);
|
||
}
|
||
private:
|
||
DisplayEngine *m_engine;
|
||
};
|
||
|
||
|
||
/* -------------------- ModelLayer -------------------- */
|
||
|
||
/*! The base class for all layers that contains Models. */
|
||
class ModelLayer : public DisplayLayer {
|
||
public:
|
||
ModelLayer() {}
|
||
|
||
// DisplayLayer interface
|
||
void tick (double dtime);
|
||
void new_world (int, int);
|
||
|
||
// Member functions
|
||
void activate (Model *m);
|
||
void deactivate (Model *m);
|
||
void maybe_redraw_model(Model *m, bool immediately=false);
|
||
|
||
virtual int redraw_size () const { return 2; }
|
||
private:
|
||
|
||
// Variables
|
||
ModelList m_active_models;
|
||
ModelList m_active_models_new;
|
||
};
|
||
|
||
|
||
/* -------------------- DL_Grid -------------------- */
|
||
|
||
/*! Layer for grid-aligned models (stones, floor tiles, items). */
|
||
|
||
class DL_Grid : public ModelLayer {
|
||
public:
|
||
DL_Grid(int redrawsize = 1);
|
||
~DL_Grid();
|
||
|
||
void set_model (int x, int y, Model *m);
|
||
Model *get_model (int x, int y);
|
||
Model *yield_model (int x, int y);
|
||
|
||
private:
|
||
// DL_Grid interface.
|
||
void mark_redraw (int x, int y);
|
||
|
||
// DisplayLayer interface.
|
||
void new_world (int w, int h);
|
||
void draw (ecl::GC &gc, const WorldArea &a, int x, int y);
|
||
|
||
// ModelLayer interface
|
||
virtual int redraw_size () const { return m_redrawsize; }
|
||
|
||
// Variables.
|
||
typedef ecl::Array2<Model*> ModelArray;
|
||
ModelArray m_models;
|
||
int m_redrawsize;
|
||
};
|
||
|
||
|
||
/* -------------------- Sprites -------------------- */
|
||
|
||
class Sprite : public ecl::Nocopy {
|
||
public:
|
||
Model *model;
|
||
V2 pos;
|
||
int screenpos[2];
|
||
SpriteLayer layer;
|
||
bool visible;
|
||
bool mayNeedRedraw;
|
||
|
||
Sprite (const V2 & p, SpriteLayer l, Model *m)
|
||
: model(m), pos(p), layer(l), visible(true), mayNeedRedraw(false)
|
||
{
|
||
screenpos[0] = screenpos[1] = 0;
|
||
}
|
||
~Sprite() { delete model; }
|
||
};
|
||
|
||
typedef std::vector<Sprite*> SpriteList;
|
||
|
||
class DL_Sprites : public ModelLayer {
|
||
public:
|
||
DL_Sprites();
|
||
~DL_Sprites();
|
||
|
||
/* ---------- DisplayLayer interface ---------- */
|
||
void draw (ecl::GC &gc, const WorldArea &a, int x, int y);
|
||
void draw_onepass (ecl::GC &gc);
|
||
void new_world (int, int);
|
||
|
||
/* ---------- Member functions ---------- */
|
||
SpriteId add_sprite (Sprite *sprite);
|
||
void kill_sprite (SpriteId id);
|
||
void move_sprite (SpriteId, const ecl::V2& newpos);
|
||
void replace_sprite (SpriteId id, Model *m);
|
||
|
||
void redraw_sprite_region (SpriteId id);
|
||
void draw_sprites (bool shades, ecl::GC &gc);
|
||
|
||
Model *get_model (SpriteId id) { return sprites[id]->model; }
|
||
|
||
void set_maxsprites (unsigned m) { maxsprites = m; }
|
||
|
||
Sprite *get_sprite(SpriteId id);
|
||
|
||
static const SpriteId MAGIC_SPRITEID = 1000000;
|
||
SpriteList sprites;
|
||
|
||
private:
|
||
// ModelLayer interface
|
||
virtual void tick (double /*dtime*/);
|
||
|
||
// Variables.
|
||
unsigned numsprites; // Current number of sprites
|
||
unsigned maxsprites; // Maximum number of sprites
|
||
};
|
||
|
||
|
||
/* -------------------- Shadows -------------------- */
|
||
|
||
struct StoneShadowCache;
|
||
|
||
class DL_Shadows : public DisplayLayer {
|
||
public:
|
||
DL_Shadows(DL_Grid *grid, DL_Sprites *sprites);
|
||
~DL_Shadows();
|
||
|
||
void new_world(int w, int h);
|
||
void draw (ecl::GC &gc, int xpos, int ypos, int x, int y);
|
||
|
||
void draw (ecl::GC &gc, const WorldArea &a, int x, int y);
|
||
private:
|
||
/* ---------- Private functions ---------- */
|
||
void shadow_blit (ecl::Surface *scr, int x, int y,
|
||
ecl::Surface *shadows, ecl::Rect r);
|
||
|
||
bool has_actor (int x, int y);
|
||
virtual void prepare_draw (const WorldArea &);
|
||
|
||
Model * get_shadow_model(int x, int y);
|
||
|
||
/* ---------- Variables ---------- */
|
||
DL_Grid *m_grid; // Stone models
|
||
DL_Sprites *m_sprites; // Sprite models
|
||
|
||
StoneShadowCache *m_cache;
|
||
|
||
Uint32 shadow_ckey; // Color key
|
||
ecl::Surface *buffer;
|
||
|
||
ecl::Array2<bool> m_hasactor;
|
||
};
|
||
|
||
|
||
/* -------------------- Lines -------------------- */
|
||
|
||
struct Line {
|
||
V2 start,end;
|
||
V2 oldstart, oldend;
|
||
|
||
Line(const V2 &s, const V2 &e) :start(s), end(e) {}
|
||
Line() {}
|
||
};
|
||
|
||
|
||
typedef ecl::AssocList<unsigned, Line> LineMap;
|
||
|
||
class DL_Lines : public DisplayLayer {
|
||
public:
|
||
DL_Lines() : m_id(1)
|
||
{
|
||
}
|
||
|
||
void draw (ecl::GC &/*gc*/, const WorldArea &/*a*/, int /*x*/, int /*y*/)
|
||
{}
|
||
void draw_onepass (ecl::GC &gc);
|
||
|
||
RubberHandle add_line (const V2 &p1, const V2 &p2);
|
||
void set_startpoint (unsigned id, const V2 &p1);
|
||
void set_endpoint (unsigned id, const V2 &p2);
|
||
void kill_line (unsigned id);
|
||
|
||
private:
|
||
// Private methods.
|
||
void mark_redraw_line (const Line &r);
|
||
|
||
// Variables.
|
||
unsigned m_id;
|
||
LineMap m_rubbers;
|
||
};
|
||
|
||
|
||
/* -------------------- CommonDisplay -------------------- */
|
||
|
||
/*! Parts of the display engine that are common to the game and
|
||
the editor. */
|
||
class CommonDisplay {
|
||
public:
|
||
CommonDisplay (const ScreenArea &a = ScreenArea (0, 0, 10, 10));
|
||
~CommonDisplay();
|
||
|
||
Model *set_model (const GridLoc &l, Model *m);
|
||
Model *get_model (const GridLoc &l);
|
||
Model *yield_model (const GridLoc &l);
|
||
|
||
void set_floor (int x, int y, Model *m);
|
||
void set_item (int x, int y, Model *m);
|
||
void set_stone (int x, int y, Model *m);
|
||
|
||
DisplayEngine *get_engine() const { return m_engine; }
|
||
|
||
SpriteHandle add_effect (const V2& pos, Model *m);
|
||
SpriteHandle add_sprite (const V2 &pos, Model *m);
|
||
|
||
RubberHandle add_line (V2 p1, V2 p2);
|
||
|
||
void new_world (int w, int h);
|
||
void redraw();
|
||
|
||
protected:
|
||
DL_Grid *floor_layer;
|
||
DL_Grid *item_layer;
|
||
DL_Grid *stone_layer;
|
||
|
||
DL_Sprites *effects_layer;
|
||
|
||
DL_Lines *line_layer;
|
||
DL_Sprites *sprite_layer;
|
||
DL_Shadows *shadow_layer;
|
||
|
||
private:
|
||
|
||
DisplayEngine *m_engine;
|
||
};
|
||
|
||
|
||
/* -------------------- Scrolling -------------------- */
|
||
|
||
|
||
class Follower {
|
||
public:
|
||
Follower (DisplayEngine *e);
|
||
virtual ~Follower() {}
|
||
virtual void tick(double dtime, const ecl::V2 &point) = 0;
|
||
virtual void center(const ecl::V2 &point);
|
||
|
||
void set_boundary (double b) { m_boundary = b; }
|
||
|
||
protected:
|
||
DisplayEngine *get_engine() const { return m_engine; }
|
||
bool set_offset (V2 offs);
|
||
double get_hoff() const;
|
||
double get_voff() const;
|
||
ecl::V2 get_scrollpos(const ecl::V2 &point);
|
||
|
||
double m_boundary;
|
||
|
||
private:
|
||
DisplayEngine *m_engine;
|
||
};
|
||
|
||
/*! Follows a sprite by flipping to the next screen as soon as the
|
||
sprite reaches the border of the current screen. */
|
||
class Follower_Screen : public Follower {
|
||
public:
|
||
Follower_Screen(DisplayEngine *e);
|
||
void tick(double dtime, const ecl::V2 &point);
|
||
};
|
||
|
||
/*! Follows a sprite by softly scrolling the visible area of the
|
||
screen as soon as the sprite reaches the border of the current
|
||
screen. */
|
||
class Follower_Scrolling : public Follower {
|
||
public:
|
||
Follower_Scrolling (DisplayEngine *e, bool screenwise_);
|
||
void tick(double dtime, const ecl::V2 &point);
|
||
void center(const ecl::V2 &point);
|
||
private:
|
||
bool currently_scrolling;
|
||
V2 curpos, destpos;
|
||
V2 dir;
|
||
double scrollspeed;
|
||
double resttime;
|
||
bool screenwise;
|
||
};
|
||
|
||
class Follower_Smooth : public Follower {
|
||
public:
|
||
Follower_Smooth (DisplayEngine *e);
|
||
void tick (double time, const ecl::V2 &point);
|
||
void center (const ecl::V2 &point);
|
||
virtual void set_boundary (double b) {}
|
||
|
||
ecl::V2 calc_offset (const ecl::V2 &point);
|
||
};
|
||
|
||
|
||
/* -------------------- GameDisplay -------------------- */
|
||
|
||
class GameDisplay : public CommonDisplay {
|
||
public:
|
||
GameDisplay (const ScreenArea &gamearea,
|
||
const ScreenArea &inventoryarea);
|
||
~GameDisplay();
|
||
|
||
StatusBar * get_status_bar() const;
|
||
|
||
void tick(double dtime);
|
||
void new_world (int w, int h);
|
||
|
||
void resize_game_area (int w, int h);
|
||
|
||
/* ---------- Scrolling ---------- */
|
||
void set_follow_mode (FollowMode m);
|
||
void follow_center();
|
||
void set_follow_sprite(SpriteId id);
|
||
void set_reference_point (const ecl::V2 &point);
|
||
void set_scroll_boundary (double d);
|
||
|
||
// current screen coordinates of reference point
|
||
void get_reference_point_coordinates(int *x, int *y);
|
||
|
||
/* ---------- Screen updates ---------- */
|
||
void redraw (ecl::Screen *scr);
|
||
void redraw_all (ecl::Screen *scr);
|
||
void draw_all (ecl::GC &gc);
|
||
|
||
private:
|
||
void set_follower (Follower *f);
|
||
void draw_borders (ecl::GC &gc);
|
||
|
||
/* ---------- Variables ---------- */
|
||
Uint32 last_frame_time;
|
||
bool redraw_everything;
|
||
StatusBarImpl *status_bar;
|
||
|
||
V2 m_reference_point;
|
||
Follower *m_follower;
|
||
|
||
ScreenArea inventoryarea;
|
||
};
|
||
|
||
class ModelHandle {
|
||
public:
|
||
ModelHandle ();
|
||
};
|
||
}
|
||
|
||
#endif
|