Subversion Repositories Kolibri OS

/*

------------------------------------------------------------

	Fixed Rate Pig - a fixed logic frame rate demo

------------------------------------------------------------

 * Copyright (C) 2004 David Olofson 

 *

 * This software is released under the terms of the GPL.

 *

 * Contact author for permission if you want to use this

 * software, or work derived from it, under other terms.

 */

#ifndef	PIG_ENGINE_H

#define	PIG_ENGINE_H

#include "SDL.h"

#include 

#ifndef M_PI

#	define M_PI 3.14159265358979323846	/* pi */

#endif

#include "dirty.h"

/*----------------------------------------------------------

	Game Engine

----------------------------------------------------------*/

typedef struct PIG_object PIG_object;

typedef struct PIG_engine PIG_engine;

/* Interpolated point */

typedef struct PIG_ipoint

{

	/* From the last logic frame: */

	float	ox, oy;		/* Position */

	/* From the last/current rendered frame: */

	int	gimage;		/* Sprite frame index */

	float	gx, gy;		/* Interpolated position */

} PIG_ipoint;

/*

 * Game logic events

 *

 * PREFRAME:

 *	Occurs once per logic frame, before collision and

 *	off-screen detection, and before timer handlers.

 *

 * TIMERx:

 *	Occurs whenever timer x expires. Timers are one-

 *	shot, but can be reloaded by the handler for

 *	periodic action. Timer events are handled before

 *	before collision and off-screen detection.

 *

 * HIT_TILE:

 *	Occurs when the hot-spot of an object hits a

 *	marked side of a tile, and the corresponding bit

 *	in 'tilemask' is set.

 *

 * HIT_OBJECT:

 *	Occurs when the collision circle of an object

 *	intersects the collision circle of another object,

 *	provided one or more bits in 'hitgroup' of the

 *	other object matches bits in 'hitmask'.

 *

 * OFFSCREEN:

 *	Occurs when an object is off-screen. This takes

 *	in account the hot-spot and bounding rectangle of

 *	the current sprite frame.

 *

 * POSTFRAME:

 *	Occurs once per logic frame, after collision

 *	detection, off-screen detection and all other

 *	events.

 *

 */

#define	PIG_TIMERS	3

typedef enum

{

	PIG_PREFRAME,

	PIG_TIMER0,

	PIG_TIMER1,

	PIG_TIMER2,

	PIG_HIT_TILE,

	PIG_HIT_OBJECT,

	PIG_OFFSCREEN,

	PIG_POSTFRAME

} PIG_events;

typedef enum

{

	PIG_NONE =	0,

	/* Bit positions */

	PIG_TOP_B =	0,

	PIG_BOTTOM_B =	1,

	PIG_LEFT_B =	2,

	PIG_RIGHT_B =	3,

	/* Masks */

	PIG_TOP =	1 << PIG_TOP_B,

	PIG_BOTTOM =	1 << PIG_BOTTOM_B,

	PIG_LEFT =	1 << PIG_LEFT_B,

	PIG_RIGHT =	1 << PIG_RIGHT_B,

	/* Combined masks */

	PIG_TL =	PIG_TOP | PIG_LEFT,

	PIG_TR =	PIG_TOP | PIG_RIGHT,

	PIG_BL =	PIG_BOTTOM | PIG_LEFT,

	PIG_BR =	PIG_BOTTOM | PIG_RIGHT,

	PIG_ALL =	0xf,

} PIG_sides;

typedef enum

{

	PIG_UNCHANGED =	-10000000,

	PIG_MIN =	-10000001,

	PIG_CENTER =	-10000002,

	PIG_MAX =	-10000003

} PIG_values;

/* Collision info */

typedef struct

{

	float		ff;	/* Fractional frame */

	int		x, y;	/* Exact position */

	PIG_sides	sides;	/* Side of tile hit */

} PIG_cinfo;

typedef struct PIG_event

{

	PIG_events	type;

	/* For HIT_TILE, HIT_OBJECT and OFFSCREEN: */

	PIG_cinfo	cinfo;	/* Detailed collision info */

	/* For HIT_OBJECT: */

	PIG_object	*obj;	/* Which object? */

}  PIG_event;

/* Logic object */

struct PIG_object

{

	PIG_engine	*owner;

	PIG_object	*next, *prev;

	int		id;		/* Unique ID. 0 means "free". */

	int		ibase;		/* Sprite frame base index */

	int		image;		/* Sprite frame offset */

	float		x, y;		/* Position */

	float		vx, vy;		/* Speed */

	float		ax, ay;		/* Acceleration */

	PIG_ipoint	ip;

	int		tilemask;	/* Sprite/tile mask [PIG_ALL] */

	int		hitmask;	/* Sprite/sprite mask [0] */

	int		hitgroup;	/* Sprite/sprite group [0] */

	int		timer[PIG_TIMERS];	/* Down-counting timers */

	int		age;		/* Age timer (logic frames) */

	int		score;

	int		power;

	int		target;

	int		state;

	void (*handler)(PIG_object *po, const PIG_event *ev);

	void		*userdata;

};

/* Level map */

typedef struct PIG_map

{

	PIG_engine	*owner;

	int		w, h;		/* Size of map (tiles) */

	unsigned char	*map;		/* 2D aray of tile indices */

	unsigned char	*hit;		/* 2D aray of collision flags */

	int		tw, th;		/* Size of one tile (pixels) */

	SDL_Surface	*tiles;		/* Tile palette image */

	unsigned char	hitinfo[256];	/* Collision info for the tiles */

} PIG_map;

/* Sprite frame */

typedef struct PIG_sprite

{

	int		w, h;		/* Size of sprite (pixels) */

	int		hotx, hoty;	/* Hot-spot offset (pixels) */

	int		radius;		/* Collision zone radius (pixels) */

	SDL_Surface	*surface;

} PIG_sprite;

/* Engine */

struct PIG_engine

{

	/* Video stuff */

	SDL_Surface	*screen;

	SDL_Surface	*buffer;	/* For h/w surface displays */

	SDL_Surface	*surface;	/* Where to render to */

	int		pages;		/* # of display VRAM buffers */

	SDL_Rect	view;		/* Viewport pos & size (pixels) */

	int		page;		/* Current page (double buffer) */

	PIG_dirtytable	*pagedirty[2];	/* One table for each page */

	PIG_dirtytable	*workdirty;	/* The work dirtytable */

	/* "Live" switches */

	int		interpolation;

	int		direct;		/* 1 ==> render directly to screen */

	int		show_dirtyrects;

	/* Time */

	double		time;		/* Logic time (frames) */

	int		frame;		/* Logic time; integer part */

	/* Background graphics */

	PIG_map		*map;

	/* Sprites and stuff */

	PIG_object	*objects;

	PIG_object	*object_pool;

	int		object_id_counter;

	int		nsprites;

	PIG_sprite	**sprites;

	/* Logic frame global handlers */

	void (*before_objects)(PIG_engine *pe);

	void (*after_objects)(PIG_engine *pe);

	/* Space for user data */

	void		*userdata;

};

/*

 * Engine

 */

PIG_engine *pig_open(SDL_Surface *screen);

void pig_close(PIG_engine *pe);

/* Set viewport size and position */

void pig_viewport(PIG_engine *pe, int x, int y, int w, int h);

/* Start engine at logic time 'frame' */

void pig_start(PIG_engine *pe, int frame);

/*

 * Load a sprite palette image. The image is chopped up into

 * sprites, based on 'sw' and 'sh', and added as new frames

 * in the sprite bank. Default values:

 *	Hot-spot:		(sw/2, sh/2)

 *	Collision radius:	0.2 * (sw + sh)

 *

 * Passing 0 for 'sw' and/or 'sh' makes pig_sprites() take

 * the respective value from the image width and/or height.

 *

 * Returns the index of the first frame loaded.

 */

int pig_sprites(PIG_engine *pe, const char *filename, int sw, int sh);

/* Set hot-spot of sprite 'frame' to (hotx, hoty) */

int pig_hotspot(PIG_engine *pe, int frame, int hotx, int hoty);

/* Set sprite/sprite collision zone radius of 'frame' */

int pig_radius(PIG_engine *pe, int frame, int radius);

/* Advance logic time by 'frames' logic frames */

void pig_animate(PIG_engine *pe, float frames);

/*

 * Manually add a dirtyrect for pig_refresh().

 * 'dr' can be outside the engine viewport.

 */

void pig_dirty(PIG_engine *pe, SDL_Rect *dr);

/*

 * Do what's needed to deal with the dirtyrects

 * and then make the new frame visible.

 */

void pig_flip(PIG_engine *pe);

/*

 * Refresh the viewport and any additional dirtyrects.

 *

 * Note that this does not refresh the entire viewport;

 * only the areas that have actually changed!

 */

void pig_refresh(PIG_engine *pe);

/*

 * Refresh the whole viewport, including sprites.

 */

void pig_refresh_all(PIG_engine *pe);

/* Render a sprite "manually", bypassing the engine */

void pig_draw_sprite(PIG_engine *pe, int frame, int x, int y);

/*

 * Get the collision flags for the tile at (x, y),

 * where the unit of x and y is pixels. The return

 * is the PIG_sides flags for the tile, or PIG_NONE

 * if (x, y) is outside the map.

 */

int pig_test_map(PIG_engine *pe, int x, int y);

/*

 * Find the first "collidable" tile side when going from

 * (x1, y1) to (x2, y2). 'mask' determines which tile sides

 * are considered for collisions.

 *

 * Returns the side(s) hit, if any tile was hit. If the return

 * is non-zero, the PIG_cinfo struct at 'ci' contains detailed

 * information about the collision.

 */

int pig_test_map_vector(PIG_engine *pe, int x1, int y1, int x2, int y2,

		int mask, PIG_cinfo *ci);

/*

 * Map

 */

PIG_map *pig_map_open(PIG_engine *pe, int w, int h);

void pig_map_close(PIG_map *pm);

/* Load a tile palette image */

int pig_map_tiles(PIG_map *pm, const char *filename, int tw, int th);

/*

 * Set tile collision info for 'count' tiles, starting at

 * 'first'. Each tile in the tile palette has a set of

 * PIG_sides flags that determine which sides the tile are

 * considered for sprite/map collisions.

 */

void pig_map_collisions(PIG_map *pm, unsigned first, unsigned count,

		PIG_sides sides);

/*

 * Load a map from a string (one byte/tile). 'trans'

 * is a string used for translating 'data' into integer

 * tile indices. Each position in 'trans' corresponds

 * to one tile in the tile palette.

 */

int pig_map_from_string(PIG_map *pm, const char *trans, const char *data);

/*

 * Object

 */

/*

 * Create an object with the initial position (x, y). If

 * 'last' is 1, the object will end up last in the

 * processing and rendering order, otherwise, first.

 *

 * Note that relative processing order is very important

 * to objects that chase each other and stuff like that!

 * If they're placed in the "wrong" order, the tracking

 * objects get an extra frame of reaction time, which is

 * annoying if it's not what you intend.

 */

PIG_object *pig_object_open(PIG_engine *pe, int x, int y, int last);

/*

 * Delete an object.

 *

 * Note that objects are never actually deleted. Instead,

 * they are placed in a free pool, where pig_object_open()

 * looks for objects to recycle.

 *

 * In fact, they are not even freed when you ask for it,

 * but rather kept around until the next rendered frame,

 * so they can be removed from the screen correctly.

 */

void pig_object_close(PIG_object *po);

/*

 * Close all objects.

 */

void pig_object_close_all(PIG_engine *pe);

/*

 * Find object by 'id', starting at object 'start'.

 *

 * The search starts at 'start' and is done in both

 * directions in parallel, assuming that the matching

 * object is near 'start' in the list. (It usually is

 * when dealing with linked objects.)

 *

 * Returns NULL if the object was not found.

 */

PIG_object *pig_object_find(PIG_object *start, int id);

#endif	/* PIG_ENGINE_H */