/* Copyright (C) 1994-2003 Revolution Software Ltd
 *
 * 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.
 *
 * $Header: /cvsroot/scummvm/scummvm/bs2/header.h,v 1.1 2003/07/28 01:44:37 khalek Exp $
 */

#ifndef	_HEADER
#define	_HEADER

#include "common/scummsys.h"
//#include "src\driver96.h"

//----------------------------------------------------------
// SYSTEM FILE & FRAME HEADERS	(23sep96 JEL)
//----------------------------------------------------------

//#pragma pack( push )
//#pragma pack( 1 )

#if !defined(__GNUC__)
	#pragma START_PACK_STRUCTS
#endif



//----------------------------------------------------------
// ALL FILES
//----------------------------------------------------------
// Standard File Header
#define	NAME_LEN	34

typedef struct
{
	uint8	fileType;	// byte to define file type (see below)
	uint8	compType;	// type of file compression used ie. on whole file (see below)
	uint32	compSize;	// length of compressed file (ie. length on disk)
	uint32	decompSize;	// length of decompressed file held in memory (NB. frames still held compressed)
	uint8	name[NAME_LEN];	//name of object
} GCC_PACK _standardHeader;

//----------------------------------------------------------
// fileType

// 0 something's wrong!
#define ANIMATION_FILE		1	// all normal animations & sprites including mega-sets & font files which are the same format (but all frames always uncompressed)
#define	SCREEN_FILE			2	// each contains background, palette, layer sprites, parallax layers & shading mask
#define	GAME_OBJECT			3	// each contains object hub + structures + script data
#define	WALK_GRID_FILE		4	// walk-grid data
#define	GLOBAL_VAR_FILE		5	// all the global script variables in one file; "there can be only one"
#define PARALLAX_FILE_null	6	// NOT USED
#define	RUN_LIST			7	// each contains a list of object resource id's
#define	TEXT_FILE			8	// each contains all the lines of text for a location or a character's conversation script
#define	SCREEN_MANAGER		9	// one for each location; this contains special startup scripts
#define MOUSE_FILE			10	// mouse pointers and luggage icons (sprites in General \ Mouse pointers & Luggage icons)
#define WAV_FILE			11	// wav file
#define	ICON_FILE			12	// menu icon (sprites in General \ Menu icons
#define PALETTE_FILE		13	// separate palette file (see also _paletteHeader)
//----------------------------------------------------------
// compType

#define NO_COMPRESSION		0
#define FILE_COMPRESSION	1	// standard whole-file compression (not yet devised!)

//----------------------------------------------------------



//----------------------------------------------------------
// (1) ANIMATION FILES
//----------------------------------------------------------
// an animation file consists of:

// standard file header
// animation header
// a string of CDT entries (one per frame of the anim)
// a 16-byte colour table ONLY if (runTimeComp==RLE16)
// a string of groups of (frame header + frame data)

//----------------------------------------------------------
// Animation Header

typedef	struct
{
	uint8	runTimeComp;	// type of runtime compression used for the frame data (see below)
	uint16	noAnimFrames;	// number of frames in the anim (ie. no. of CDT entries)
	uint16	feetStartX;		// start coords for mega to walk to, before running anim
	uint16	feetStartY;
	uint8	feetStartDir;	// direction to start in before running anim
	uint16	feetEndX;		// end coords for mega to stand at after running anim (vital if anim starts from an off-screen position, or ends in a different place from the start)
	uint16	feetEndY;
	uint8	feetEndDir;		// direction to start in after running anim
	uint16	blend;
} GCC_PACK _animHeader;

//----------------------------------------------------------
// runtimeComp - compression used on each frame of the anim

#define NONE	0	// No frame compression
#define RLE256	1	// James's RLE for 256-colour sprites
#define RLE16	2	// James's RLE for 16- or 17-colour sprites
					// (raw blocks have max 16 colours for 2 pixels per byte,
					// so '0's are encoded only as FLAT for 17-colour sprites eg. George's mega-set)
//----------------------------------------------------------
// CDT Entry

typedef struct
{
	int16	x;				// sprite x-coord OR offset to add to mega's feet x-coord to calc sprite y-coord
	int16	y;				// sprite y-coord OR offset to add to mega's feet y-coord to calc sprite y-coord
	uint32	frameOffset;	// points to start of frame header (from start of file header)
	uint8	frameType;		// 0=print sprite normally with top-left corner at (x,y), otherwise see below...
} GCC_PACK _cdtEntry;

// 'frameType' bit values
#define FRAME_OFFSET	1	// print at (feetX+x,feetY+y), with scaling according to feetY
#define FRAME_FLIPPED	2	// print the frame flipped Left->Right
#define FRAME_256_FAST	4	// Frame has been compressed using Pauls fast RLE 256 compression.

//----------------------------------------------------------
//Frame Header

typedef	struct
{
	uint32	compSize;	// compressed size of frame - NB. compression type is now in Anim Header
	uint16	width;		// dimensions of frame
	uint16	height;
} GCC_PACK _frameHeader;

//----------------------------------------------------------
// Frame Data

// uint8 spriteData[width*height];	// one byte per pixel
//----------------------------------------------------------





//----------------------------------------------------------
// (2) SCREEN FILES
//----------------------------------------------------------
// a screen file consists of:

// standard file header
// multi screen header
// 4*256 bytes of palette data
// 256k palette match table
// 2 background parallax layers
// 1 background layer with screen header
// 2 foreground parallax layers
// a string of layer headers
// a string of layer masks

//----------------------------------------------------------
// Multi screen header
// Goes at the beginning of a screen file after the standard
// header.
// Gives offsets from start of table of each of the components

typedef struct
{
	uint32 palette;
	uint32 bg_parallax[2];
	uint32 screen;
	uint32 fg_parallax[2];
	uint32 layers;
	uint32 paletteTable;
	uint32 maskOffset;
} GCC_PACK _multiScreenHeader;

//------------------------------------------------------------
// Palette Data

typedef struct
{
	uint8	red;
	uint8	green;
	uint8	blue;
	uint8	alpha;
} GCC_PACK _palEntry;

#define	NO_COLOURS	256
// _palEntry palette[NO_COLOURS]

//------------------------------------------------------------
// Screen Header

typedef struct
{
	uint16	width;		// dimensions of the background screen
	uint16	height;
	uint16	noLayers;	// number of layer areas
} GCC_PACK _screenHeader;

//------------------------------------------------------------
// Background Raw Bitmap

// uint8 backgroundData[width*height];	// one byte per pixel

//------------------------------------------------------------
// Layer Header

// Note that all the layer headers are kept together,
// rather than being placed before each layer mask,
// in order to simplify the sort routine.

typedef struct
{
	uint16	x;			// coordinates of top-left pixel of area
	uint16	y;
	uint16	width;
	uint16	height;
	uint32  maskSize;
	uint32	offset;		// where to find mask data (from start of standard file header)
} GCC_PACK _layerHeader;

//------------------------------------------------------------
// Layer Mask

// uint8 layerData[width*height/8];	// 8 pixels to a byte

//------------------------------------------------------------



//----------------------------------------------------------
// (3) SCRIPT OBJECT FILES
//----------------------------------------------------------
// a script object file consists of:

// standard file header
// script object header
// script object data

//----------------------------------------------------------
// Script Object Header

// ???????
// ???????
// ???????

//----------------------------------------------------------
// Script Object Data

//----------------------------------------------------------



//----------------------------------------------------------
// (4) WALK-GRID FILES
//----------------------------------------------------------
// a walk-grid file consists of:

// standard file header
// walk-grid file header
// walk-grid data

//----------------------------------------------------------
// Walk-Grid Header - taken directly from old "header.h" in STD_INC

typedef struct
{
	int32	numBars;	// number of bars on the floor
	int32	numNodes;	// number of nodes
} GCC_PACK _walkGridHeader;

//----------------------------------------------------------
// Walk-Grid Data

// ???????

//----------------------------------------------------------



//----------------------------------------------------------
// (5) PALETTE FILES
//----------------------------------------------------------
// a palette file consists of:

// standard file header
// 4*256 bytes of palette data
// 256k palette match table

//----------------------------------------------------------

//--------------------------------------------------------------------------------------------------
// PCX file header
//--------------------------------------------------------------------------------------------------
typedef	struct
{	uint8	manufacturer;
	uint8	version;
	uint8	encoding;
	uint8	bitsPerPixel;
	int16	xmin,ymin;
	int16	xmax,ymax;
	int16	hres;
	int16	vres;
	char	palette[48];
	char	reserved;
	uint8	colourPlanes;
	int16	bytesPerLine;
	int16	paletteType;
	char	filler[58];
} GCC_PACK _PCXHEAD;
//----------------------------------------------------------
#define	TREE_SIZE	3

typedef	struct	// an object hub - which represents all that remains of the compact concept
{
	int32	type;					// type of object
	uint32	logic_level;			// what level?
	uint32	logic[TREE_SIZE];		// NOT USED
	uint32	script_id[TREE_SIZE];	// need this if script
	uint32	script_pc[TREE_SIZE];	// need this also
} GCC_PACK _object_hub;
//----------------------------------------------------------
//----------------------------------------------------------
// (6) text module header	TW

typedef	struct
{
	uint32	noOfLines;	//how many lines of text are there in this module
} GCC_PACK _textHeader;

//a text file has:

//	_standardHeader
//	_textHeader
//	look up table, to
//	line of text,0
//	line of text,0

//----------------------------------------------------------

// #pragma pack( pop )

#if !defined(__GNUC__)
	#pragma END_PACK_STRUCTS
#endif

#endif
