pgestd.h

来自「pocket pc小游戏源码」· C头文件 代码 · 共 425 行

#pragma once

#include <windows.h>

#if defined(_WIN32)
#include "win32gx.h"
#include "stdio.h"
#include <assert.h>

#else defined(_WIN32_WCE)
#include "gx.h"
#endif

#include <list>
#include <vector>
using namespace std;

#include <mmsystem.h>

extern "C"
{
#include "Lua/lauxlib.h"
#include "Lua/lua.h"
#include "Lua/lualib.h"
}

#include "lzo/lzo.h"

typedef struct tagWRECT
{
	tagWRECT(short l, short t, short r, short b)
	{
		left = l;
		right = r;
		top = t; 
		bottom = b;
	}

	tagWRECT(tagRECT& r)
	{
		left = r.left;
		right = r.right;
		top = r.top; 
		bottom = r.bottom;
	}

	tagWRECT(void)
	{
		left = 0;
		right = 0;
		top = 0; 
		bottom = 0;
	}

	inline bool operator == (const tagWRECT& r) const
	{
		return r.bottom == bottom && r.left == left
			&& r.right == right && r.top == top;
	}
	inline bool operator == (const tagRECT& r) const
	{
		return r.bottom == bottom && r.left == left
			&& r.right == right && r.top == top;
	}
	inline bool operator == (const int v) const
	{
		return v == bottom && v == left
			&& v == right && v == top;
	}

	inline tagWRECT operator & (const tagWRECT& r)
	{
		left = r.left > left ? r.left : left;
		top =	r.top > top ? r.top : top;
		right =	r.right > right ? right : r.right;
		bottom = r.bottom > bottom ? bottom : r.bottom;
		return *this;
	}

	inline tagWRECT operator & (const tagRECT& r)
	{
		left = r.left > left ? r.left : left;
		top =	r.top > top ? r.top : top;
		right =	r.right > right ? right : r.right;
		bottom = r.bottom > bottom ? bottom : r.bottom;
		return *this;
	}

	inline bool inThisRect (const tagWRECT& r) const
	{
		return r.left > left && r.right < right && r.top > top && r.bottom < bottom;
	}

	inline bool inRect (const tagWRECT& r) const
	{
		return r.left < left && r.right > right && r.top < top && r.bottom > bottom;
	}

	inline int hit (const tagWRECT& r)
	{
		tagWRECT ra = (*this);
		tagWRECT rh = ra & r;
		if (rh.w()>0 && rh.h()>0) return 1; // 小于零表示不相交，等于零相接，大于零相交
		else if (rh.w()<0 || rh.h()<0) return 0;
		else if (rh.w()==0 || rh.h()==0) return 2;
	}

	inline short w() const { return right - left; }
	inline short h() const { return bottom - top; }
	short left, right, top, bottom;
}wrect, *lpwrect;

#define RECT wrect

#define PGE_RESULT int									// PGE返回类型
#define PGEDisplayProperties GXDisplayProperties		// PGE屏幕信息
#define PGEKeyList GXKeyList

#define SRESULT \
	int iRet = PGE_FAIL; \

#define OKRESULT \
	iRet = PGE_OK; \

#define RET \
	return iRet; \

#define PGEFAILED(RESULT) \
		(RESULT == PGE_FAIL ? TRUE : FALSE) \

//#define fopen PGEFileOpen

// PGE翻译GX返回信息宏
#define GXRETURN(n) \
	if (n > 0) \
	{ \
		return PGE_OK; \
	} \
	else \
	{ \
		return PGE_FAIL; \
	} \

#define SAFE_DELETE(p) \
	if (p) \
	{ \
		delete (p); \
		(p) = NULL; \
	} \

#define SAFE_DELETE_ARY(p) \
	if (p) \
	{ \
	delete[] (p); \
	(p) = NULL; \
	} \

#define SAFE_RELEASE(p) \
	if (NULL != p) \
	{ \
		p->Release(); \
		p = NULL; \
	} \

#define COMP2VAL(v1, v2, sgn) \
	v1 sgn v2 ? v1 : v2; \

#define ADD_STR(a, b) \
	a##b \

#define AnyToStr(a, b) \
	ADD_STR(#a, #b) \

struct WPOINT
{
	short int wx;
	short int wy;
	char bz;
};

#define USE_LUA extern lua_State* L_stat;

#define OPEN_LUA \
	L_stat = lua_open(); \
	luaopen_base(L_stat); \
	luaopen_table(L_stat); \
	luaopen_io(L_stat); \
	luaopen_string(L_stat); \
	luaopen_math(L_stat); \

#define CLOSE_LUA lua_close(L_stat);

// 定义输出到lua的类的创建函数
#define DECLEAR_CREATE_CLASS(tClass)\
	static int new##tClass(lua_State *L) \

// 创建函数的函数体
#define CREATE_CLASS(tClass)\
	static int new##tClass(lua_State *L) \
{ \
	tClass* pT = new tClass; \
	lua_pushnumber(L, (DWORD)pT); \
	return 1; \
} \

// 注册创建函数
#define REGIST_CREATE(tClass) \
	lua_register(L_stat, AnyToStr(new, tClass), new##tClass); \

// 定义输出到lua的类的删除函数
#define DECLEAR_DELETE_CLASS(tClass) \
	static int del##tClass(lua_State* L) \

// 删除函数的实体
#define DELETE_CLASS(tClass) \
	static int del##tClass(lua_State* L) \
{ \
	DWORD dwCl = (DWORD)lua_tonumber(L, 1); \
	if (dwCl) \
	delete ((tClass*)dwCl); \
	return 0; \
} \

// 注册删除函数
#define REGIST_DELETE(tClass) \
	lua_register(L_stat, AnyToStr(del, tClass), del##tClass); \

// 定义输出到lua的类的成员函数
#define DECLEAR_DEFINE_CLASS_FUNC(tClass, tFunc) \
	static int tClass##tFunc(lua_State* L) \

// 实现成员函数的函数体
#define BEGIN_DEFINE_CLASS_FUNC(tClass, tFunc) \
	static int tClass##tFunc(lua_State* L) \
{ \

#define END_DEFINE_CLASS_FUNC \
}\

// 定义注册函数
#define DECLEAR_REGIST_FUNC(tClass) \
	void regist##tClass() \

// 实现注册函数
#define BEGIN_REGIST_FUNC(tClass) \
	void regist##tClass() \
{ \

// 注册一个函数 
#define REGIST_FUNC(tClass, tFunc) \
	lua_register(L_stat, AnyToStr(tClass, tFunc), tClass##tFunc); \

// 结束函数注册
#define END_REGIST_FUNC \
} \

// 执行函数注册
#define DO_REGISTER_LUA_CLASS(tClass) \
	regist##tClass(); \


// 任意类型基数排序法函数宏
// pSrc 待排序序列
// SrcType 序列类型
// SortVal 按类型中的此成员值进行排序，可为空则用序列的值进行排序
// iCount 序列长度
// pBuf 排序用的缓存，需要与序列大小类型相同
// Sombl 类型分隔符号："." 和 "->" 可为空
#define RadixSort(pSrc, SrcType, SortVal, iCount, pBuf, Sombl) \
{ \
	SrcType OffsetTemp; \
	DWORD dwOffset = ((DWORD)&(OffsetTemp##Sombl##SortVal) - (DWORD)&OffsetTemp); \
	DWORD dwBox[256]; \
	DWORD j = 0; \
	DWORD pos = 0 ; \
	DWORD temp = 0; \
	for(DWORD i=0; i<4; i++) \
	{ \
		memset(dwBox, 0, 256 * sizeof(DWORD)); \
		memcpy(pBuf, pSrc, iCount * sizeof(SrcType)); \
		for(j=0; j<iCount; j++) \
		{ \
			++dwBox[((*((DWORD*)((DWORD)(&pBuf[j])+dwOffset))) >> (8 * i)) & 0xFF]; \
		} \
		pos = 0; \
		for(j=0; j<256; j++) \
		{ \
			temp = dwBox[j]; \
			dwBox[j] = pos; \
			pos += temp; \
		} \
		for(j=0; j<iCount; j++) \
		{ \
			pSrc[dwBox[((*((DWORD*)((DWORD)(&pBuf[j])+dwOffset))) >> (8 * i)) & 0xFF]++] = pBuf[j]; \
		} \
	} \
} \

// PGE标准错误 
enum PGE_ERROR_MSG
{
	PGE_OK = 0x0777,
		PGE_FAIL
};

enum PGE_SCREEN_DIRECTION
{
	PGE_SCREEN_H = 0,	// 横屏
		PGE_SCREEN_V	// 竖屏
};
enum PGE_CLASS_ID
{
	PGE_UNDEFINE = -1,
		PGE_DEVICE,
		PGE_SURFACE,
		PGE_MAP,
		PGE_FONT,
		PGE_INPUT,
		PGE_SOUND,
		PGE_MUSIC,
		PGE_NET,
		PGE_APP,
		PGE_VKBD,
		PGE_IME,
		PGE_LOG	
};

struct PGE_PAK_IMAGE_HEAD	// 图像文件包头
{
	DWORD	dwFlag;
	DWORD	dwImageCount;
	BYTE	btWidth;
	BYTE	btHeight;
};

struct FILE_OF_SIZE		// 图像文件包头后面的文件位置表
{
	DWORD dwStart;
	DWORD dwSize;
};

// PGE图像文件头
struct PGEPicBaseHead
{
	DWORD	dwHeadFlag;			// 标志 PGEP
	BYTE	btVersion;			// 版本号	
	BYTE	bBitCount;			// 图像位数
	BYTE	bCompess;			// 是否压缩
	DWORD	dwDataOffset;		// 图像数据偏移
	DWORD	dwDataSize;			// 图像数据大小
	DWORD	dwDeComSize;		// 解压后的大小
	WORD	wWidth;				// 图像宽
	WORD	wHeight;			// 图像高
	WORD	dwPalOffset;		// 调色板
	WORD	dwPalSize;			// 调色板大小
	WORD	wPalPiexlCount;		// 调色板颜色数
	DWORD	dwAlphaOffset;		// alpha通道
	DWORD	dwAlphaSize;		// alpha大小
	DWORD	dwAlphaDeComSize;	// alpha解压后的大小
	DWORD	dwResave;			// 保留
};

struct PGEPixe16
{
	WORD wPixeColor;
	BYTE btPixeCInfo;
};

class CPGEBase
{
public:
	CPGEBase();
	~CPGEBase();

	DWORD m_dwClassID;
	
};

// RECT操作函数
RECT FiRect(int iLeft, int iTop, int iRight, int iBottom);
RECT AdRect(RECT& r1, RECT& r2);
RECT SubRect(RECT& r1, RECT& r2);
RECT MuRect(RECT& r1, RECT& r2);
RECT MuRect(RECT& r1, float fValue);	
BOOL PointInRect(POINT pt, RECT& r);	
BOOL PointInRect(int x, int y, RECT& r);	
BOOL RectEqZero(RECT& r);

RECT RectAndRect(RECT& r1, RECT& r2);
RECT FiRectWithStr(char* caStr);	
RECT TrunRect(RECT& r, const int iValue);

#define RectEqRect(r1, r2) (r1.left == r2.left && r1.top == r2.top && r1.right == r2.right && r1.bottom == r2.bottom) 

#define FILLRECT(tRect, lLeft, lTop, lRight, lBottom) \
	tRect.left = lLeft; \
	tRect.top = lTop; \
	tRect.right = lRight; \
	tRect.bottom = lBottom; \

#define TUNARECT(r, v, sgn) \
	r.left = r.left sgn v ? v : r.left; \
	r.top = r.top sgn v ? v : r.top; \
	r.right = r.right sgn v ? v : r.right; \
	r.bottom = r.bottom sgn v ? v : r.bottom; \

char* GetAppPath();
char* GetResFile(char* caFileName);
FILE* PGEFileOpen(char* fileName, char* tp);
char* wcharTochar(WCHAR *string);
WCHAR* charTowchar(char *string);

void PutDebugString(char *msg, ...);
void CloseDebugFile();

bool CheckFile(char *name);
int GetFileLength(char *name);

void Delay(long time);
void WaitKey(DWORD Key);
void PressKey(DWORD Key,int x);
int random(int nMax);
int random(int nMin, int nMax);