WebSVN – Kolibri OS – Blame – /programs/games/LaserTank/trunk/LaserTank.cpp

Rev	Author	Line No.	Line
5281	ZblCoder	1	#include "smalllibc/kosSyst.h"
		2	#include "smalllibc/kosFile.h"
5283	ZblCoder	3	#include "smalllibc/sprintf.h"
5281	ZblCoder	4	#include "smalllibc/func.h"
5276	ZblCoder	5	#include "render.h"
		6	#include "image.h"
		7
		8	#define MODE_MENU 0
		9	#define MODE_LEVELS 1
		10	#define MODE_GAME 2
5297	ZblCoder	11	#define MODE_PAUSE 4
5276	ZblCoder	12
		13	#define GAME_NONE 0
		14	#define GAME_VICTORY 1
		15	#define GAME_DEFEAT 2
		16
		17	#define MOUSE_LEFT 0
		18
5287	ZblCoder	19	#define FIELD_NONE 0
		20	#define FIELD_WATER 1
		21	#define FIELD_GROUND 2
		22	#define FIELD_BRICK 3
		23	#define FIELD_WALL 4
		24	#define FIELD_BOX 5
		25	#define FIELD_MISSLE_0 6
		26	#define FIELD_MISSLE_1 7
		27	#define FIELD_MISSLE_2 8
		28	#define FIELD_MISSLE_3 9
		29	#define FIELD_HERO 10
		30	#define FIELD_FINISH 11
		31	#define FIELD_GUN_0 12
		32	#define FIELD_GUN_1 13
		33	#define FIELD_GUN_2 14
		34	#define FIELD_GUN_3 15
		35	#define FIELD_BOX_MISSLE_0 16
		36	#define FIELD_BOX_MISSLE_1 17
		37	#define FIELD_BOX_MISSLE_2 18
		38	#define FIELD_BOX_MISSLE_3 19
5296	ZblCoder	39	#define FIELD_WALL_X 20
		40	#define FIELD_WALL_H 21
		41	#define FIELD_WALL_V 22
		42	#define FIELD_BOX_WATER 23
		43	#define FIELD_BRICK_DES 24
		44	#define FIELD_CRATER 25
5287	ZblCoder	45
5276	ZblCoder	46	char* header = "Laser Tank";
5474	ZblCoder	47	bool w_redraw = true;
5276	ZblCoder	48
		49	struct Level
		50	{
5287	ZblCoder	51	Byte fileds[16][16];
5276	ZblCoder	52	};
		53
5287	ZblCoder	54	void pause(int time)
		55	{
		56	kos_Pause(time);
		57	Byte keyCode;
5474	ZblCoder	58	Dword buttons;
		59	int mX, mY;
5287	ZblCoder	60	for (int i = 0; i < 10; ++i)
5474	ZblCoder	61	{
5287	ZblCoder	62	kos_GetKey(keyCode);
5474	ZblCoder	63	kos_GetMouseState(buttons, mX, mY);
		64	}
5287	ZblCoder	65	}
		66
5276	ZblCoder	67	Level *levels;
		68	int levelCount = 0;
		69	int levelIndex = 0;
5296	ZblCoder	70	int levelPage = 0;
5474	ZblCoder	71	float clickTime = 0;
5276	ZblCoder	72
		73	RGBA img_tank[576];
		74	RGB img_water[576];
5287	ZblCoder	75	RGB img_brick[11][576];
5276	ZblCoder	76	RGB img_waterbox[576];
		77	RGB img_ground[576];
5296	ZblCoder	78	RGB img_crater[576];
5276	ZblCoder	79	RGB img_wall[576];
5296	ZblCoder	80	RGB img_wall_x[576];
		81	RGB img_wall_h[576];
		82	RGB img_wall_v[576];
5276	ZblCoder	83	RGB img_finish[576];
		84	RGBA img_box[576];
		85	RGBA img_laser[576];
5287	ZblCoder	86	RGB img_mirror[4][576];
5296	ZblCoder	87	RGBA img_mini_mirror[2304];
5276	ZblCoder	88	RGBA img_laser1[576];
		89	RGBA img_laser2[576];
		90	RGB img_brick1[576];
		91	RGB img_menu[147456];
		92	RGBA img_explosion[8064];
5287	ZblCoder	93	RGBA img_gun[576];
5296	ZblCoder	94	RGB img_gamebg[9216];
5297	ZblCoder	95	RGBA img_black[576];
5276	ZblCoder	96
5331	ZblCoder	97	RGB img_pandus[3][12];
		98
5296	ZblCoder	99	RGBA img_number_box[2550];
		100	RGBA img_numbers[3500];
		101	RGBA img_button1[3249];
		102	RGBA img_button_arrow[375];
5276	ZblCoder	103
5296	ZblCoder	104	RGB img_levels[147456];
		105
5297	ZblCoder	106	RGB img_buttons[3][13053];
		107
		108
		109
5276	ZblCoder	110	Player player;
		111
		112	CKosRender* renderPlayer;
		113	CKosImage* objPlayer;
5297	ZblCoder	114	CKosImage* objPlayer1;
5276	ZblCoder	115
5296	ZblCoder	116	CKosRender* renderBox;
5331	ZblCoder	117	CKosRender* renderWater;
5296	ZblCoder	118
5276	ZblCoder	119	CKosImage* objLaser;
		120	CKosImage* objLaser1;
		121	CKosImage* objLaser2;
5296	ZblCoder	122	CKosImage* objMiniMirror;
5276	ZblCoder	123	CKosImage* objBox;
5287	ZblCoder	124	CKosImage* objGun;
5296	ZblCoder	125	CKosImage* objExplosion;
5276	ZblCoder	126
5297	ZblCoder	127	CKosImage* objblack;
		128
5296	ZblCoder	129	CKosRender* renderLevels;
		130	CKosImage* objnumber_box;
		131	CKosImage* objnumbers;
5276	ZblCoder	132
5296	ZblCoder	133	CKosImage* objbutton1;
		134	CKosImage* objbutton_arrow;
		135
5276	ZblCoder	136	int gameMode = MODE_MENU;
		137	int gameStatus = GAME_NONE;
		138
		139	void draw_window();
		140	void openLevel(int index);
5287	ZblCoder	141	void Laser(Point pos, Point vec, RGB color);
5276	ZblCoder	142
		143	bool CollRecrVsPoint(Point point, Rect rect)
		144	{
		145	return (point.X > rect.X && point.Y > rect.Y && point.X < rect.X + rect.Width && point.Y < rect.Y + rect.Height);
		146	}
		147
		148	struct Button
		149	{
		150	Rect rect;
		151	char* caption;
		152	Button() {}
		153	Button(char* caption, Rect rect)
		154	{
		155	this->caption = caption;
		156	this->rect = rect;
		157	}
		158	};
		159
		160	Button ToGame("Game", Rect(150, 258, 224, 50));
		161	Button ToExit("Exit", Rect(150, 321, 224, 50));
		162
		163	struct LvlItem
		164	{
5287	ZblCoder	165	Byte s;
		166	Byte d;
5276	ZblCoder	167	Byte l;
		168	};
		169
		170	LvlItem level[16][16];
		171
		172	char GetField(Point position, bool din)
		173	{
5331	ZblCoder	174	if (position.X < 0 \|\| position.Y < 0 \|\| position.X > 15 \|\| position.Y > 15)
		175	return FIELD_WALL;
		176
5287	ZblCoder	177	if (din && level[position.Y][position.X].d != FIELD_NONE)
5276	ZblCoder	178	return level[position.Y][position.X].d;
		179	return level[position.Y][position.X].s;
		180	}
		181
5297	ZblCoder	182	void SetMode(int mode)
		183	{
		184	gameMode = mode;
		185	draw_window();
5474	ZblCoder	186
		187	pause(40);
5297	ZblCoder	188	}
		189
5331	ZblCoder	190	bool IsWater(Point pos)
		191	{
		192	if (pos.X < 0 \|\| pos.Y < 0 \|\| pos.X > 15 \|\| pos.Y > 15)
		193	return true;
		194
		195	Byte code = GetField(pos, false);
		196	return (code == FIELD_WATER \|\| code == FIELD_BOX_WATER);
		197	}
		198
		199	void RenderPandus(Point pos)
		200	{
		201	bool is[10];
		202	for (int y = 0; y < 3; ++y)
		203	for (int x = 0; x < 3; ++x)
		204	is[y * 3 + x + 1] = IsWater(pos + Point(x-1, y-1));
		205
		206	if (!is[6])
		207	{
		208	if (!is[2] \|\| is[3])
		209	renderWater->RenderImg((RGB*)img_pandus[0], Point(23, 0), 1, 12);
		210	else
		211	renderWater->RenderImg((RGB*)img_pandus[1], Point(23, 0), 1, 12);
		212
		213	if (!is[8] \|\| is[9])
		214	renderWater->RenderImg((RGB*)img_pandus[2], Point(23, 12), 1, 12);
		215	else
		216	renderWater->RenderImg((RGB*)img_pandus[1], Point(23, 12), 1, 12);
		217	}
		218
		219	if (!is[2])
		220	{
		221	if (!is[4] \|\| is[1])
		222	renderWater->RenderImg((RGB*)img_pandus[0], Point(0, 0), 12, 1);
		223	else
		224	renderWater->RenderImg((RGB*)img_pandus[1], Point(0, 0), 12, 1);
		225
		226	if (!is[6] \|\| is[3])
		227	renderWater->RenderImg((RGB*)img_pandus[2], Point(12, 0), 12, 1);
		228	else
		229	renderWater->RenderImg((RGB*)img_pandus[1], Point(12, 0), 12, 1);
		230	}
		231
		232	if (!is[4])
		233	{
		234	if (!is[8] \|\| is[7])
		235	renderWater->RenderImg((RGB*)img_pandus[2], Point(0, 12), 1, 12);
		236	else
		237	renderWater->RenderImg((RGB*)img_pandus[1], Point(0, 12), 1, 12);
		238
		239	if (!is[2] \|\| is[1])
		240	renderWater->RenderImg((RGB*)img_pandus[0], Point(0, 0), 1, 12);
		241	else
		242	renderWater->RenderImg((RGB*)img_pandus[1], Point(0, 0), 1, 12);
		243	}
		244
		245	if (!is[8])
		246	{
		247	if (!is[6] \|\| is[9])
		248	renderWater->RenderImg((RGB*)img_pandus[0], Point(12, 23), 12, 1);
		249	else
		250	renderWater->RenderImg((RGB*)img_pandus[1], Point(12, 23), 12, 1);
		251
		252	if (!is[4] \|\| is[7])
		253	renderWater->RenderImg((RGB*)img_pandus[2], Point(0, 23), 12, 1);
		254	else
		255	renderWater->RenderImg((RGB*)img_pandus[1], Point(0, 23), 12, 1);
		256	}
		257	}
		258
5276	ZblCoder	259	RGB* GetImg(Point position, bool din)
		260	{
		261	switch (GetField(position, din))
		262	{
5287	ZblCoder	263	case FIELD_WALL:
5276	ZblCoder	264	return (RGB*)img_wall;
5296	ZblCoder	265	case FIELD_WALL_X:
		266	return (RGB*)img_wall_x;
		267	case FIELD_WALL_H:
		268	return (RGB*)img_wall_h;
		269	case FIELD_WALL_V:
		270	return (RGB*)img_wall_v;
5287	ZblCoder	271	case FIELD_MISSLE_0:
		272	return (RGB*)img_mirror[0];
		273	case FIELD_MISSLE_1:
		274	return (RGB*)img_mirror[1];
		275	case FIELD_MISSLE_2:
		276	return (RGB*)img_mirror[2];
		277	case FIELD_MISSLE_3:
		278	return (RGB*)img_mirror[3];
5296	ZblCoder	279	case FIELD_BOX_MISSLE_0:
		280	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		281	objMiniMirror->Draw(Point(0, 0), 0, 0);
		282	return renderBox->buffer;
		283	case FIELD_BOX_MISSLE_1:
		284	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		285	objMiniMirror->Draw(Point(0, 0), 0, 1);
		286	return renderBox->buffer;
		287	case FIELD_BOX_MISSLE_2:
		288	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		289	objMiniMirror->Draw(Point(0, 0), 0, 2);
		290	return renderBox->buffer;
		291	case FIELD_BOX_MISSLE_3:
		292	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		293	objMiniMirror->Draw(Point(0, 0), 0, 3);
		294	return renderBox->buffer;
5287	ZblCoder	295	case FIELD_GUN_0:
		296	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		297	objGun->Draw(Point(0, 0), 0);
		298	return renderBox->buffer;
		299	case FIELD_GUN_1:
		300	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		301	objGun->Draw(Point(0, 0), 90);
		302	return renderBox->buffer;
		303	case FIELD_GUN_2:
		304	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		305	objGun->Draw(Point(0, 0), 180);
		306	return renderBox->buffer;
		307	case FIELD_GUN_3:
		308	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		309	objGun->Draw(Point(0, 0), 270);
		310	return renderBox->buffer;
		311	case FIELD_GROUND:
5276	ZblCoder	312	return (RGB*)img_ground;
5296	ZblCoder	313	case FIELD_CRATER:
		314	return (RGB*)img_crater;
5287	ZblCoder	315	case FIELD_BOX:
		316	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
5276	ZblCoder	317	objBox->Draw(Point(0, 0), 0);
		318	return renderBox->buffer;
5287	ZblCoder	319	case FIELD_FINISH:
5276	ZblCoder	320	return (RGB*)img_finish;
5287	ZblCoder	321	case FIELD_BRICK:
		322	return (RGB*)img_brick[level[position.Y][position.X].l];
		323	case FIELD_BRICK_DES:
5276	ZblCoder	324	return (RGB*)img_brick1;
5331	ZblCoder	325	case FIELD_BOX_WATER:
		326	// return (RGB*)img_waterbox;
		327	renderWater->RenderImg((RGB*)img_waterbox, Point(0, 0), 24, 24);
		328	RenderPandus(position);
		329	return renderWater->buffer;
		330	case FIELD_WATER:
		331	renderWater->RenderImg((RGB*)img_water, Point(0, 0), 24, 24);
		332	RenderPandus(position);
		333	return renderWater->buffer;
		334	// return (RGB*)img_water;
5276	ZblCoder	335	}
		336	return NULL;
		337	}
		338
5287	ZblCoder	339	Byte CollField(Point position)
		340	{
		341	if (position.X < 0 \|\| position.Y < 0 \|\| position.X > 15 \|\| position.Y > 15)
		342	return 0;
		343
		344	switch (GetField(position, true))
		345	{
		346	case FIELD_NONE:
		347	case FIELD_WATER:
		348	case FIELD_GROUND:
5296	ZblCoder	349	case FIELD_CRATER:
5287	ZblCoder	350	case FIELD_BOX_WATER:
		351	case FIELD_BRICK_DES:
		352	case FIELD_FINISH:
		353	return 1;
		354	case FIELD_GUN_0:
		355	return FIELD_GUN_0;
		356	case FIELD_GUN_1:
		357	return FIELD_GUN_1;
		358	case FIELD_GUN_2:
		359	return FIELD_GUN_2;
		360	case FIELD_GUN_3:
		361	return FIELD_GUN_3;
		362	}
		363	return 0;
		364	}
		365
		366	bool ExistGun1(Point position, Point vec, int gun)
		367	{
		368	Point pos = position;
		369
		370	Byte result = 1;
		371	while (result == 1)
		372	{
		373	pos = pos + vec;
		374	result = CollField(pos);
		375	}
		376	if (result == gun)
		377	{
		378	Laser(pos, vec * -1, (RGB)0x00CCFF);
		379	return true;
		380	}
		381	return false;
		382	}
		383
		384	void ExistGun(Point position)
		385	{
		386	if (ExistGun1(position, Point(1, 0), FIELD_GUN_2))
		387	return;
		388	if (ExistGun1(position, Point(0, 1), FIELD_GUN_3))
		389	return;
		390	if (ExistGun1(position, Point(-1, 0), FIELD_GUN_0))
		391	return;
		392	ExistGun1(position, Point(0, -1), FIELD_GUN_1);
		393	}
		394
5276	ZblCoder	395	void DrawElevent(Point position, bool din)
		396	{
		397	kos_PutImage(GetImg(position, din), 24, 24, 24 * position.X, 24 * position.Y);
		398	}
		399
5296	ZblCoder	400	void MoveElement(Point a, Point b, int element)
5276	ZblCoder	401	{
5287	ZblCoder	402	level[a.Y][a.X].d = FIELD_NONE;
5296	ZblCoder	403	DrawElevent(a, false);
5287	ZblCoder	404	if (level[b.Y][b.X].s == FIELD_WATER)
5276	ZblCoder	405	{
5296	ZblCoder	406	if (element == FIELD_BOX)
5287	ZblCoder	407	level[b.Y][b.X].s = FIELD_BOX_WATER;
5276	ZblCoder	408	}
		409	else
5296	ZblCoder	410	level[b.Y][b.X].d = element;
		411	DrawElevent(b, true);
5276	ZblCoder	412	}
		413
5287	ZblCoder	414	void animation(Point vector, float angle, int obj)
5276	ZblCoder	415	{
		416	for (int i = 2; i < 23; ++i)
		417	{
		418	kos_WindowRedrawStatus(1);
5296	ZblCoder	419
5276	ZblCoder	420	DrawElevent(player.position, false);
		421	DrawElevent(player.position + vector, false);
		422
5296	ZblCoder	423	renderPlayer->RenderImg(GetImg(player.position, false), vector * -i, 24, 24);
		424	renderPlayer->RenderImg(GetImg(player.position + vector, false), vector * -i + vector * 24, 24, 24);
		425
5276	ZblCoder	426	objPlayer->Draw(Point(0, 0), angle);
		427	renderPlayer->Draw(player.position * 24 + vector * i);
5287	ZblCoder	428	if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == obj)
5276	ZblCoder	429	{
5296	ZblCoder	430	//renderBox->RenderImg(GetImg(player.position + vector, true), Point(0, 0), 24, 24);
		431	renderBox->RenderImg(GetImg(player.position + vector, false), vector * -i, 24, 24);
		432	renderBox->RenderImg(GetImg(player.position + vector * 2, false), vector * -i + vector * 24, 24, 24);
5287	ZblCoder	433	switch (obj)
		434	{
		435	case FIELD_GUN_0:
5296	ZblCoder	436	objGun->Draw(Point(0, 0), 0);
5287	ZblCoder	437	break;
		438	case FIELD_GUN_1:
5296	ZblCoder	439	objGun->Draw(Point(0, 0), 90);
5287	ZblCoder	440	break;
		441	case FIELD_GUN_2:
5296	ZblCoder	442	objGun->Draw(Point(0, 0), 180);
5287	ZblCoder	443	break;
		444	case FIELD_GUN_3:
5296	ZblCoder	445	objGun->Draw(Point(0, 0), 270);
5287	ZblCoder	446	break;
5296	ZblCoder	447	case FIELD_BOX_MISSLE_0:
		448	objMiniMirror->Draw(Point(0, 0), 0, 0);
		449	break;
		450	case FIELD_BOX_MISSLE_1:
		451	objMiniMirror->Draw(Point(0, 0), 0, 1);
		452	break;
		453	case FIELD_BOX_MISSLE_2:
		454	objMiniMirror->Draw(Point(0, 0), 0, 2);
		455	break;
		456	case FIELD_BOX_MISSLE_3:
		457	objMiniMirror->Draw(Point(0, 0), 0, 3);
		458	break;
5287	ZblCoder	459	case FIELD_BOX:
		460	objBox->Draw(Point(0, 0), 0);
		461	}
5276	ZblCoder	462	renderBox->Draw((player.position + vector) * 24 + vector * i);
		463	}
		464	kos_WindowRedrawStatus(2);
5287	ZblCoder	465	pause(1);
5276	ZblCoder	466	}
		467
5287	ZblCoder	468	if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == obj)
5296	ZblCoder	469	MoveElement(player.position + vector, player.position + vector * 2, GetField(player.position + vector, true));
5276	ZblCoder	470
		471	DrawElevent(player.position, true);
		472	DrawElevent(player.position + vector, true);
		473	player.position = player.position + vector;
		474	//kos_PutImage(GetImg(player.position + vector), 24, 24, 24 * player.position.X, 24 * player.position.Y);
		475	renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24);
		476	objPlayer->Draw(Point(0, 0), angle);
		477	renderPlayer->Draw(player.position * 24);
5287	ZblCoder	478	ExistGun(player.position);
5276	ZblCoder	479	}
		480
5287	ZblCoder	481	void DrawLaser(Point position, int frame, RGB color)
5276	ZblCoder	482	{
5296	ZblCoder	483	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		484	Byte code = GetField(position, true);
		485	if (code == FIELD_BOX_MISSLE_0 \|\| code == FIELD_BOX_MISSLE_1 \|\| code == FIELD_BOX_MISSLE_2 \|\| code == FIELD_BOX_MISSLE_3)
		486	objMiniMirror->Draw(Point(0, 0), 0, code - FIELD_BOX_MISSLE_0);
5276	ZblCoder	487	switch (frame)
		488	{
		489	case 1:
5287	ZblCoder	490	objLaser->Draw(Point(0, 0), 0, color);
		491	break;
5276	ZblCoder	492	case 2:
5287	ZblCoder	493	objLaser->Draw(Point(0, 0), 90, color);
5276	ZblCoder	494	break;
		495	case 3:
5287	ZblCoder	496	objLaser2->Draw(Point(0, 0), 0, color);
5276	ZblCoder	497	break;
		498	default:
5296	ZblCoder	499	objLaser1->Draw(Point(0, 0), (float)frame, color);
5276	ZblCoder	500	}
5296	ZblCoder	501	renderBox->Draw(position * 24);
5276	ZblCoder	502	level[position.Y][position.X].l = 1;
		503	}
		504
5296	ZblCoder	505	bool LaserMoveElement(Point position, Point vector, int code, RGB color)
		506	{
		507	if (position + vector != player.position)
		508	{
		509	switch (GetField(position + vector, true))
		510	{
		511	case FIELD_GROUND:
		512	case FIELD_CRATER:
		513	case FIELD_WATER:
		514	case FIELD_BRICK_DES:
		515	case FIELD_BOX_WATER:
		516	for (int i = 2; i < 23; ++i)
		517	{
		518	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
		519	if (vector.X != 0)
		520	objLaser->Draw((vector.X > 0) ? Point(i - 24, 0) : Point(24 - i, 0), 0, color);
		521	else
		522	objLaser->Draw((vector.Y > 0) ? Point(0, i - 24) : Point(0, 24 - i), 90, color);
		523	renderBox->Draw(position * 24);
		524
		525	DrawElevent(position + vector, false);
		526
		527	renderBox->RenderImg(GetImg(position, false), vector * -i, 24, 24);
		528	renderBox->RenderImg(GetImg(position + vector, false), vector * -i + vector * 24, 24, 24);
		529
		530	switch (code)
		531	{
		532	case FIELD_GUN_0:
		533	objGun->Draw(Point(0, 0), 0);
		534	break;
		535	case FIELD_GUN_1:
		536	objGun->Draw(Point(0, 0), 90);
		537	break;
		538	case FIELD_GUN_2:
		539	objGun->Draw(Point(0, 0), 180);
		540	break;
		541	case FIELD_GUN_3:
		542	objGun->Draw(Point(0, 0), 270);
		543	break;
		544	case FIELD_BOX_MISSLE_0:
		545	objMiniMirror->Draw(Point(0, 0), 0, 0);
		546	break;
		547	case FIELD_BOX_MISSLE_1:
		548	objMiniMirror->Draw(Point(0, 0), 0, 1);
		549	break;
		550	case FIELD_BOX_MISSLE_2:
		551	objMiniMirror->Draw(Point(0, 0), 0, 2);
		552	break;
		553	case FIELD_BOX_MISSLE_3:
		554	objMiniMirror->Draw(Point(0, 0), 0, 3);
		555	break;
		556	case FIELD_BOX:
		557	objBox->Draw(Point(0, 0), 0);
		558	}
		559	renderBox->Draw((position)* 24 + vector * i);
		560	kos_Pause(1);
		561	}
		562	MoveElement(position, position + vector, code);
		563	return true;
		564	}
		565	}
		566	return false;
		567	}
		568
5287	ZblCoder	569	void Laser(Point pos, Point vec, RGB color)
5276	ZblCoder	570	{
5287	ZblCoder	571	Point vector = vec;
		572	Point position = pos + vector;
5276	ZblCoder	573	bool en = true;
5287	ZblCoder	574	Byte code;
		575	bool LaserGun = false;
		576
5276	ZblCoder	577	while (en)
		578	{
5287	ZblCoder	579	code = GetField(position, true);
		580	switch (code)
5276	ZblCoder	581	{
5287	ZblCoder	582	case FIELD_BOX:
		583	case FIELD_GUN_0:
		584	case FIELD_GUN_1:
		585	case FIELD_GUN_2:
		586	case FIELD_GUN_3:
		587	if (code == FIELD_GUN_0 && vector == Point(-1, 0) \|\| code == FIELD_GUN_1 && vector == Point(0, -1)
		588	\|\| code == FIELD_GUN_2 && vector == Point(1, 0) \|\| code == FIELD_GUN_3 && vector == Point(0, 1))
		589	{
		590	for (int i = 2; i < 23; ++i)
		591	kos_Pause(1);
		592	for (int y = 0; y < 16; y++)
		593	for (int x = 0; x < 16; x++)
		594	if (level[y][x].l == 1)
		595	{
		596	DrawElevent(Point(x, y), true);
		597	level[y][x].l = 0;
		598	}
		599	for (int i = 0; i < 14; ++i)
		600	{
5296	ZblCoder	601	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
5287	ZblCoder	602	objExplosion->Draw(Point(0, 0), 0, i);
5296	ZblCoder	603	renderBox->Draw((position)* 24);
5287	ZblCoder	604	pause(2);
		605	}
		606	level[position.Y][position.X].d = FIELD_NONE;
5296	ZblCoder	607	if (level[position.Y][position.X].s == FIELD_GROUND)
		608	level[position.Y][position.X].s = FIELD_CRATER;
5287	ZblCoder	609	draw_window();
		610	return;
		611	}
		612	else
5296	ZblCoder	613	{
		614	if (!LaserMoveElement(position, vector, code, color))
5276	ZblCoder	615	{
		616	for (int i = 2; i < 23; ++i)
5296	ZblCoder	617	pause(1);
		618	}
		619	else
5287	ZblCoder	620	LaserGun = true;
		621	}
5276	ZblCoder	622	en = false;
		623	break;
5287	ZblCoder	624	case FIELD_BRICK:
		625	for (int i = 0; i < 6; ++i)
5276	ZblCoder	626	{
5287	ZblCoder	627	level[position.Y][position.X].l += 1;
		628	if (level[position.Y][position.X].l == 11)
5276	ZblCoder	629	{
5287	ZblCoder	630	level[position.Y][position.X].s = FIELD_BRICK_DES;
		631	level[position.Y][position.X].l = 0;
		632	LaserGun = true;
5276	ZblCoder	633	}
5287	ZblCoder	634	DrawElevent(position, false);
		635	pause(5);
5276	ZblCoder	636	}
		637	en = false;
		638	break;
5296	ZblCoder	639	case FIELD_WALL_X:
		640	break;
		641	case FIELD_WALL_H:
		642	if (vector.X == 0)
		643	{
		644	for (int i = 2; i < 23; ++i)
		645	pause(1);
		646	en = false;
		647	}
		648	break;
		649	case FIELD_WALL_V:
		650	if (vector.Y == 0)
		651	{
		652	for (int i = 2; i < 23; ++i)
		653	pause(1);
		654	en = false;
		655	}
		656	break;
5287	ZblCoder	657	case FIELD_GROUND:
5296	ZblCoder	658	case FIELD_CRATER:
5287	ZblCoder	659	case FIELD_WATER:
		660	case FIELD_FINISH:
		661	case FIELD_BRICK_DES:
		662	case FIELD_BOX_WATER:
5276	ZblCoder	663	if (player.position == position)
		664	{
		665	for (int i = 2; i < 23; ++i)
		666	kos_Pause(1);
		667	for (int y = 0; y < 16; y++)
		668	for (int x = 0; x < 16; x++)
		669	if (level[y][x].l == 1)
		670	{
		671	DrawElevent(Point(x, y), true);
		672	level[y][x].l = 0;
		673	}
		674	for (int i = 0; i < 14; ++i)
		675	{
5296	ZblCoder	676	renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
5276	ZblCoder	677	objExplosion->Draw(Point(0, 0), 0, i);
5296	ZblCoder	678	renderBox->Draw((position)* 24);
5287	ZblCoder	679	pause(2);
5276	ZblCoder	680	}
5296	ZblCoder	681	level[player.position.Y][player.position.X].s = FIELD_CRATER;
5276	ZblCoder	682	gameStatus = GAME_DEFEAT;
5297	ZblCoder	683	SetMode(MODE_PAUSE);
5276	ZblCoder	684	return;
		685	}
		686	else
		687	{
		688	if (level[position.Y][position.X].l == 1)
5287	ZblCoder	689	DrawLaser(position, 3, color);
5276	ZblCoder	690	else
5287	ZblCoder	691	DrawLaser(position, (vector.X != 0) ? 1 : 2, color);
5276	ZblCoder	692	}
		693	break;
5296	ZblCoder	694	case FIELD_BOX_MISSLE_0:
5276	ZblCoder	695	if (vector == Point(-1, 0) \|\| vector == Point(0, -1))
		696	{
		697	vector = (vector.Y == -1) ? Point(1, 0) : Point(0, 1);
5287	ZblCoder	698	DrawLaser(position, 0, color);
5276	ZblCoder	699	}
		700	else
		701	{
5296	ZblCoder	702	if (!LaserMoveElement(position, vector, code, color))
		703	{
		704	for (int i = 2; i < 23; ++i)
		705	pause(1);
		706	}
		707	else
		708	LaserGun = true;
5276	ZblCoder	709	en = false;
		710	}
		711	break;
5296	ZblCoder	712	case FIELD_BOX_MISSLE_1:
5276	ZblCoder	713	if (vector == Point(0, -1) \|\| vector == Point(1, 0))
		714	{
		715	vector = (vector.Y == -1) ? Point(-1, 0) : Point(0, 1);
5287	ZblCoder	716	DrawLaser(position, 90, color);
5276	ZblCoder	717	}
		718	else
		719	{
5296	ZblCoder	720	if (!LaserMoveElement(position, vector, code, color))
		721	{
		722	for (int i = 2; i < 23; ++i)
		723	pause(1);
		724	}
		725	else
		726	LaserGun = true;
5276	ZblCoder	727	en = false;
		728	}
		729	break;
5296	ZblCoder	730	case FIELD_BOX_MISSLE_2:
		731	if (vector == Point(1, 0) \|\| vector == Point(0, 1))
		732	{
		733	vector = (vector.Y == 1) ? Point(-1, 0) : Point(0, -1);
		734	DrawLaser(position, 180, color);
		735	}
		736	else
		737	{
		738	if (!LaserMoveElement(position, vector, code, color))
		739	{
		740	for (int i = 2; i < 23; ++i)
		741	pause(1);
		742	}
		743	else
		744	LaserGun = true;
		745	en = false;
		746	}
		747	break;
		748	case FIELD_BOX_MISSLE_3:
5276	ZblCoder	749	if (vector == Point(-1, 0) \|\| vector == Point(0, 1))
		750	{
		751	vector = (vector.Y == 1) ? Point(1, 0) : Point(0, -1);
5287	ZblCoder	752	DrawLaser(position, 270, color);
5276	ZblCoder	753	}
		754	else
		755	{
5296	ZblCoder	756	if (!LaserMoveElement(position, vector, code, color))
		757	{
		758	for (int i = 2; i < 23; ++i)
		759	pause(1);
		760	}
		761	else
		762	LaserGun = true;
		763	en = false;
		764	}
		765	break;
		766	case FIELD_MISSLE_0:
		767	if (vector == Point(-1, 0) \|\| vector == Point(0, -1))
		768	{
		769	vector = (vector.Y == -1) ? Point(1, 0) : Point(0, 1);
		770	DrawLaser(position, 0, color);
		771	}
		772	else
		773	{
5276	ZblCoder	774	for (int i = 2; i < 23; ++i)
5287	ZblCoder	775	pause(1);
5276	ZblCoder	776	en = false;
		777	}
		778	break;
5296	ZblCoder	779	case FIELD_MISSLE_1:
		780	if (vector == Point(0, -1) \|\| vector == Point(1, 0))
		781	{
		782	vector = (vector.Y == -1) ? Point(-1, 0) : Point(0, 1);
		783	DrawLaser(position, 90, color);
		784	}
		785	else
		786	{
		787	for (int i = 2; i < 23; ++i)
		788	pause(1);
		789	en = false;
		790	}
		791	break;
5287	ZblCoder	792	case FIELD_MISSLE_2:
5276	ZblCoder	793	if (vector == Point(1, 0) \|\| vector == Point(0, 1))
		794	{
		795	vector = (vector.Y == 1) ? Point(-1, 0) : Point(0, -1);
5287	ZblCoder	796	DrawLaser(position, 180, color);
5276	ZblCoder	797	}
		798	else
		799	{
		800	for (int i = 2; i < 23; ++i)
5287	ZblCoder	801	pause(1);
5276	ZblCoder	802	en = false;
		803	}
		804	break;
5296	ZblCoder	805	case FIELD_MISSLE_3:
		806	if (vector == Point(-1, 0) \|\| vector == Point(0, 1))
		807	{
		808	vector = (vector.Y == 1) ? Point(1, 0) : Point(0, -1);
		809	DrawLaser(position, 270, color);
		810	}
		811	else
		812	{
		813	for (int i = 2; i < 23; ++i)
		814	pause(1);
		815	en = false;
		816	}
		817	break;
5276	ZblCoder	818	default:
		819	for (int i = 2; i < 23; ++i)
5287	ZblCoder	820	pause(1);
5276	ZblCoder	821	en = false;
		822	}
		823	position = position + vector;
		824	}
		825
		826	for (int y = 0; y < 16; y++)
		827	for (int x = 0; x < 16; x++)
		828	if (level[y][x].l == 1)
		829	{
		830	DrawElevent(Point(x, y), true);
		831	level[y][x].l = 0;
		832	}
		833
5287	ZblCoder	834	if (LaserGun)
		835	ExistGun(player.position);
5276	ZblCoder	836	}
		837
		838	void player_move(Point vector, float angle)
		839	{
		840	if (player.vector == vector)
		841	{
5287	ZblCoder	842	Byte code = GetField(player.position + vector, true);
		843	switch (code)
5276	ZblCoder	844	{
5296	ZblCoder	845	case FIELD_BOX_MISSLE_0:
		846	case FIELD_BOX_MISSLE_1:
		847	case FIELD_BOX_MISSLE_2:
		848	case FIELD_BOX_MISSLE_3:
		849	switch (GetField(player.position + vector * 2, true))
		850	{
		851	case FIELD_GROUND:
		852	case FIELD_CRATER:
		853	case FIELD_WATER:
		854	case FIELD_BOX_WATER:
		855	case FIELD_BRICK_DES:
		856	if (code == FIELD_BOX_MISSLE_0 && (vector == Point(1, 0) \|\| vector == Point(0, 1))
		857	\|\| code == FIELD_BOX_MISSLE_1 && (vector == Point(-1, 0) \|\| vector == Point(0, 1))
		858	\|\| code == FIELD_BOX_MISSLE_2 && (vector == Point(-1, 0) \|\| vector == Point(0, -1))
		859	\|\| code == FIELD_BOX_MISSLE_3 && (vector == Point(1, 0) \|\| vector == Point(0, -1))
		860	)
		861	animation(vector, angle, code);
		862	return;
		863	}
		864	break;
5287	ZblCoder	865	case FIELD_GUN_0:
		866	case FIELD_GUN_1:
		867	case FIELD_GUN_2:
		868	case FIELD_GUN_3:
5296	ZblCoder	869	case FIELD_BOX:
5276	ZblCoder	870	switch (GetField(player.position + vector * 2, true))
		871	{
5287	ZblCoder	872	case FIELD_GROUND:
5296	ZblCoder	873	case FIELD_CRATER:
5287	ZblCoder	874	case FIELD_WATER:
		875	case FIELD_BOX_WATER:
		876	case FIELD_BRICK_DES:
		877	animation(vector, angle, code);
5276	ZblCoder	878	return;
		879	}
		880	break;
5287	ZblCoder	881	case FIELD_FINISH:
5276	ZblCoder	882	gameStatus = GAME_VICTORY;
5297	ZblCoder	883	SetMode(MODE_PAUSE);
5276	ZblCoder	884	draw_window();
		885	break;
5287	ZblCoder	886	case FIELD_NONE:
		887	case FIELD_BRICK:
		888	case FIELD_WALL:
5296	ZblCoder	889	case FIELD_WALL_H:
		890	case FIELD_WALL_V:
		891	case FIELD_WALL_X:
5287	ZblCoder	892	case FIELD_WATER:
		893	case FIELD_MISSLE_0:
		894	case FIELD_MISSLE_1:
		895	case FIELD_MISSLE_2:
		896	case FIELD_MISSLE_3:
5276	ZblCoder	897	break;
		898	default:
5287	ZblCoder	899	animation(vector, angle, -1);
5276	ZblCoder	900	}
		901	}
		902	else
		903	{
		904	int cnt;
		905	float addAngle;
		906	if (player.vector == vector * -1)
		907	{
		908	cnt = 48;
		909	addAngle = 3.5f;
		910	}
		911	else
		912	{
		913	cnt = 24;
		914	if (player.angle == 270 && angle == 0 \|\| player.angle == 0 && angle == 270)
		915	addAngle = (player.angle == 0) ? -3.5f : 3.5f;
		916	else
		917	addAngle = (angle < player.angle) ? -3.5f : 3.5f;
		918	}
		919
		920	for (int i = 1; i < cnt - 1; ++i)
		921	{
		922	player.angle += addAngle;
		923	renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24);
		924	objPlayer->Draw(Point(0, 0), player.angle);
		925	renderPlayer->Draw(player.position * 24);
5287	ZblCoder	926	pause(1);
5276	ZblCoder	927	}
		928
		929	player.vector = vector;
		930	player.angle = angle;
		931
		932	renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24);
		933	objPlayer->Draw(Point(0, 0), player.angle);
		934	renderPlayer->Draw(player.position * 24);
		935	}
		936	}
		937
		938	void key_press(int key)
		939	{
5474	ZblCoder	940	sProcessInfo sPI;
		941	kos_ProcessInfo(&sPI);
		942	if (sPI.rawData[70] & 0x04)
		943	return;
5276	ZblCoder	944	//rtlDebugOutString(ftoa(key));
5474	ZblCoder	945
5276	ZblCoder	946	switch (gameMode)
		947	{
		948	case MODE_MENU:
5338	ZblCoder	949	if (key == 27)
5296	ZblCoder	950	kos_ExitApp();
5338	ZblCoder	951
		952	if (key == 13 \|\| key == 32)
		953	SetMode(MODE_LEVELS);
5276	ZblCoder	954	break;
		955	case MODE_LEVELS:
5338	ZblCoder	956	if (key == 27)
5296	ZblCoder	957	SetMode(MODE_MENU);
5338	ZblCoder	958
		959	if (levelPage > 0 && key == 183)
		960	{
		961	levelIndex -= 30;
		962	draw_window();
		963	}
		964	else
		965	if (levelPage < (int)(levelCount / 30) && key == 184)
		966	{
		967	levelIndex += 30;
		968	if (levelIndex >= levelCount)
		969	levelIndex = levelCount - 1;
		970	draw_window();
		971	}
		972
		973	// 179, 100 D Right
		974	if ((key == 179 \|\| key == 100) && (levelIndex + 1) < levelCount)
		975	{
		976	levelIndex++;
		977	draw_window();
		978	}
		979	// 176, 97 A Left
		980	if ((key == 176 \|\| key == 97) && levelIndex > 0)
		981	{
		982	levelIndex--;
		983	draw_window();
		984	}
		985	// 119, 178: W Up
		986	if ((key == 119 \|\| key == 178) && (levelIndex - 6) >= 0)
		987	{
		988	levelIndex -= 6;
		989	draw_window();
		990	}
		991	// 177, 115 S Down
		992	if ((key == 177 \|\| key == 115) && (levelIndex + 6) < levelCount)
		993	{
		994	levelIndex += 6;
		995	draw_window();
		996	}
		997
		998	if (key == 13 \|\| key == 32)
		999	{
		1000	openLevel(levelIndex);
		1001	SetMode(MODE_GAME);
		1002	}
		1003
5276	ZblCoder	1004	break;
5338	ZblCoder	1005	case MODE_PAUSE:
		1006	if (key == 27)
		1007	SetMode(MODE_LEVELS);
5474	ZblCoder	1008	else
		1009	if ((key == 32 \|\| key == 13) && (gameStatus == GAME_NONE \|\| (gameStatus == GAME_VICTORY && levelIndex < (levelCount - 1))))
		1010	{
		1011	if (gameStatus == GAME_VICTORY)
		1012	openLevel(levelIndex + 1);
		1013	SetMode(MODE_GAME);
		1014	}
		1015	else
		1016	if (key == 114)
		1017	{
		1018	openLevel(levelIndex);
		1019	SetMode(MODE_GAME);
		1020	}
5338	ZblCoder	1021	break;
5276	ZblCoder	1022	case MODE_GAME:
		1023	switch (key)
		1024	{
		1025	case 119: // Up
		1026	case 178: // W
		1027	if (gameStatus == GAME_NONE)
		1028	player_move(Point(0, -1), 270);
		1029	break;
		1030	case 177: // Down
		1031	case 115: // S
		1032	if (gameStatus == GAME_NONE)
		1033	player_move(Point(0, 1), 90);
		1034	break;
		1035	case 176: // Left
		1036	case 97: // A
		1037	if (gameStatus == GAME_NONE)
		1038	player_move(Point(-1, 0), 180);
		1039	break;
		1040	case 179: // Right
		1041	case 100: // D
		1042	if (gameStatus == GAME_NONE)
		1043	player_move(Point(1, 0), 0);
		1044	break;
		1045	case 32: // Space
		1046	if (gameStatus == GAME_NONE)
5287	ZblCoder	1047	Laser(player.position, player.vector, (RGB)0x00FF00);
5276	ZblCoder	1048	break;
		1049	case 13:
5331	ZblCoder	1050	//rtlDebugOutString(ftoa(rtlRand()));
5296	ZblCoder	1051
5287	ZblCoder	1052	// openLevel(levelIndex + 1);
5276	ZblCoder	1053	if (gameStatus == GAME_VICTORY)
		1054	openLevel(levelIndex + 1);
		1055	else
		1056	if (gameStatus == GAME_DEFEAT)
		1057	openLevel(levelIndex);
5296	ZblCoder	1058
5276	ZblCoder	1059	break;
5296	ZblCoder	1060	case 27:
5297	ZblCoder	1061	SetMode(MODE_PAUSE);
5276	ZblCoder	1062	}
		1063	break;
		1064	}
		1065	}
		1066
		1067	void MousePress(int button, Point position)
		1068	{
		1069	//rtlDebugOutString("Mouse");
		1070	//rtlDebugOutString(ftoa(position.X));
		1071	//rtlDebugOutString(ftoa(position.Y));
5296	ZblCoder	1072	Point level_pos = Point(0, 0);
5276	ZblCoder	1073	switch (gameMode)
		1074	{
		1075	case MODE_MENU:
		1076	if (CollRecrVsPoint(position, ToGame.rect))
5296	ZblCoder	1077	SetMode(MODE_LEVELS);
5276	ZblCoder	1078	if (CollRecrVsPoint(position, ToExit.rect))
		1079	kos_ExitApp();
		1080	break;
		1081	case MODE_LEVELS:
5296	ZblCoder	1082	if (CollRecrVsPoint(position, ToExit.rect))
		1083	SetMode(MODE_MENU);
		1084	else
		1085	if (levelPage > 0 && CollRecrVsPoint(position, Rect(9, 318, 57, 57)))
		1086	{
5338	ZblCoder	1087	levelIndex -= 30;
5296	ZblCoder	1088	draw_window();
		1089	}
		1090	else
5338	ZblCoder	1091	if (levelPage < (int)(levelCount / 30) && CollRecrVsPoint(position, Rect(70, 318, 57, 57)))
5296	ZblCoder	1092	{
5338	ZblCoder	1093	levelIndex += 30;
		1094	if (levelIndex >= levelCount)
		1095	levelIndex = levelCount - 1;
5296	ZblCoder	1096	draw_window();
		1097	}
		1098	else
		1099	{
5338	ZblCoder	1100	levelPage = (int)(levelIndex / 30);
5296	ZblCoder	1101	for (int i = levelPage * 30; i < min(levelCount, (levelPage + 1) * 30); i++)
		1102	{
5276	ZblCoder	1103
5296	ZblCoder	1104	if (i % 6 == 0 && i != levelPage * 30)
		1105	{
		1106	level_pos.X = 0;
		1107	level_pos.Y++;
		1108	}
		1109	if (CollRecrVsPoint(position, Rect(11 + level_pos.X * 62, 11 + 61 * level_pos.Y, 51, 50)))
		1110	{
		1111	openLevel(i);
		1112	//rtlDebugOutString(ftoa(i));
		1113	SetMode(MODE_GAME);
		1114	return;
		1115	}
		1116	level_pos.X++;
		1117	}
		1118	}
5276	ZblCoder	1119	break;
5297	ZblCoder	1120	case MODE_PAUSE:
		1121	if (CollRecrVsPoint(position, Rect(77, 318, 229, 57)))
		1122	SetMode(MODE_LEVELS);
		1123	else
		1124	if (CollRecrVsPoint(position, Rect(77, 255, 229, 57)))
		1125	{
		1126	openLevel(levelIndex);
		1127	SetMode(MODE_GAME);
		1128	}
		1129	else
5338	ZblCoder	1130	if (CollRecrVsPoint(position, Rect(77, 192, 229, 57)) && (gameStatus == GAME_NONE \|\| (gameStatus == GAME_VICTORY && levelIndex < (levelCount - 1))))
5297	ZblCoder	1131	{
		1132	if (gameStatus == GAME_VICTORY)
		1133	openLevel(levelIndex + 1);
		1134	SetMode(MODE_GAME);
		1135	}
5276	ZblCoder	1136	case MODE_GAME:
		1137
		1138	break;
		1139	}
		1140	}
		1141
5296	ZblCoder	1142	void draw_level_number(Point position, int number, RGB color) // 0x252317
		1143	{
		1144	if (number > 99)
		1145	{
		1146	objnumbers->Draw(position + Point(4, 12), 0, (int)(number / 100), color);
		1147	objnumbers->Draw(position + Point(18, 12), 0, (int)((number % 100) / 10), color);
		1148	objnumbers->Draw(position + Point(32, 12), 0, (int)(number % 10), color);
		1149	}
		1150	else
		1151	if (number > 9)
		1152	{
		1153	objnumbers->Draw(position + Point(11, 12), 0, (int)((number % 100) / 10), color);
		1154	objnumbers->Draw(position + Point(25, 12), 0, (int)(number % 10), color);
		1155	}
		1156	else
		1157	if (number < 10)
		1158	objnumbers->Draw(position + Point(18, 12), 0, number, color);
		1159	}
		1160
5276	ZblCoder	1161	void draw_window(void)
		1162	{
5474	ZblCoder	1163	if (w_redraw)
		1164	{
		1165	kos_WindowRedrawStatus(1);
		1166
		1167	//kos_DefineAndDrawWindow(50, 50, 640, 506 - 22 + kos_GetSkinHeight(), 0x74, 0xEEEEEE, 0, 0, (Dword)windowTitle);
		1168
		1169	kos_DefineAndDrawWindow(10, 40, 384 + 9, 384 + 25, 0x74, 0x444444, 0, 0, (Dword)header);
		1170	kos_WindowRedrawStatus(2);
		1171	w_redraw = false;
		1172	}
		1173
5296	ZblCoder	1174	Point level_pos = Point(0, 0);
5276	ZblCoder	1175	switch (gameMode)
		1176	{
		1177	case MODE_MENU:
		1178	kos_PutImage((RGB*)img_menu, 384, 384, 0, 0);
		1179
		1180	// kos_PutImage((RGB*)img_button, 150, 50, ToGame.rect.X, ToGame.rect.Y);
		1181
		1182
		1183	break;
		1184	case MODE_LEVELS:
5296	ZblCoder	1185	renderLevels->RenderImg(img_levels, Point(0, 0), 384, 384);
5338	ZblCoder	1186
		1187	levelPage = (int)(levelIndex / 30);
5296	ZblCoder	1188	for (int i = levelPage * 30; i < min(levelCount, (levelPage + 1) * 30); i++)
		1189	{
		1190	if (i % 6 == 0 && i != levelPage * 30)
		1191	{
		1192	level_pos.X = 0;
		1193	level_pos.Y++;
		1194	}
5338	ZblCoder	1195	if (levelIndex != i)
		1196	{
		1197	objnumber_box->Draw(Point(11 + level_pos.X * 62, 11 + 61 * level_pos.Y), 0);
		1198	draw_level_number(Point(11 + level_pos.X * 62, 11 + 61 * level_pos.Y), i + 1, (RGB)0x252317);
		1199	}
		1200	else
		1201	{
		1202	objnumber_box->Draw(Point(11 + level_pos.X * 62, 11 + 61 * level_pos.Y), 0, (RGB)0xAA0000);
		1203	draw_level_number(Point(11 + level_pos.X * 62, 11 + 61 * level_pos.Y), i + 1, (RGB)0xAA0000);
		1204	}
5276	ZblCoder	1205
5296	ZblCoder	1206	level_pos.X++;
		1207	}
		1208
		1209	if (levelPage > 0)
		1210	{
		1211	objbutton1->Draw(Point(9, 318), 0);
		1212	objbutton_arrow->Draw(Point(24, 338), 0);
		1213	}
		1214
		1215	if (levelPage < (int)(levelCount / 30))
		1216	{
		1217	objbutton1->Draw(Point(70, 318), 0);
		1218	objbutton_arrow->Draw(Point(89, 339), 180);
		1219	}
		1220
		1221	renderLevels->Draw(Point(0, 0));
5297	ZblCoder	1222	//kos_PutImage((RGB*)img_ground, 24, 24, 100, 100);
		1223	break;
		1224	case MODE_PAUSE:
		1225	for (int y = 0; y < 4; y++)
		1226	for (int x = 0; x < 4; x++)
		1227	renderLevels->RenderImg((RGB)img_gamebg, Point(96 x, 96 * y), 96, 96);
5296	ZblCoder	1228
5297	ZblCoder	1229	for (int y = 0; y < 16; y++)
		1230	for (int x = 0; x < 16; x++)
		1231	if (level[y][x].s != FIELD_NONE)
		1232	renderLevels->RenderImg(GetImg(Point(x, y), true), Point(24 * x, 24 * y), 24, 24);
		1233
		1234	switch (gameStatus)
		1235	{
		1236	case GAME_NONE:
		1237	objPlayer1->Draw(player.position * 24, player.angle);
		1238	break;
		1239	case GAME_VICTORY:
		1240	kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "VICTORY", 0);
		1241	break;
		1242	case GAME_DEFEAT:
		1243	kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "DEFEAT", 0);
		1244	break;
		1245	}
		1246
		1247	for (int y = 0; y < 16; y++)
		1248	for (int x = 0; x < 16; x++)
		1249	objblack->Draw(Point(24 * x, 24 * y), 0);
		1250
5338	ZblCoder	1251	if (gameStatus == GAME_NONE \|\| (gameStatus == GAME_VICTORY && levelIndex < (levelCount - 1)))
5297	ZblCoder	1252	renderLevels->RenderImg((RGB*)img_buttons[1], Point(77, 192), 229, 57);
		1253	renderLevels->RenderImg((RGB*)img_buttons[2], Point(77, 255), 229, 57);
		1254	renderLevels->RenderImg((RGB*)img_buttons[0], Point(77, 318), 229, 57);
		1255
		1256	renderLevels->Draw(Point(0, 0));
5276	ZblCoder	1257	break;
		1258	case MODE_GAME:
5296	ZblCoder	1259	for (int y = 0; y < 4; y++)
		1260	for (int x = 0; x < 4; x++)
		1261	kos_PutImage((RGB)img_gamebg, 96, 96, 96 x, 96 * y);
		1262
5276	ZblCoder	1263	for (int y = 0; y < 16; y++)
		1264	for (int x = 0; x < 16; x++)
5287	ZblCoder	1265	if (level[y][x].s != FIELD_NONE)
5297	ZblCoder	1266	kos_PutImage(GetImg(Point(x, y), true), 24, 24, 24 * x, 24 * y);
5276	ZblCoder	1267
5297	ZblCoder	1268	if(gameStatus != GAME_DEFEAT)
5276	ZblCoder	1269	{
		1270	renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24);
		1271	objPlayer->Draw(Point(0, 0), player.angle);
		1272	renderPlayer->Draw(player.position * 24);
		1273	}
		1274	break;
		1275	}
		1276	}
		1277
		1278	void LevelsLoad()
		1279	{
		1280	char *cPtr;
		1281	cPtr = strrchr(kosExePath, '/');
		1282
		1283	if (cPtr == NULL)
		1284	{
		1285	rtlDebugOutString("Invalid path to executable.");
		1286	return;
		1287	}
		1288	cPtr[1] = 0;
5296	ZblCoder	1289	strcpy(cPtr + 1, "data.lvl");
5276	ZblCoder	1290
		1291	CKosFile *file = new CKosFile(kosExePath);
		1292
		1293	Byte block[256];
		1294	while (file->Read(block, 256) == 256)
		1295	{
		1296	levelCount++;
		1297	}
		1298	//levelCount++;
5331	ZblCoder	1299	//rtlDebugOutString(ftoa(levelCount));
5276	ZblCoder	1300
		1301	levels = new Level[levelCount];
		1302
		1303	file->Seek(0, SEEK_SET);
		1304	for (int i = 0; i < levelCount; ++i)
		1305	{
		1306	file->Read(block, 256);
		1307	int k = 0;
		1308
		1309	for (int y = 0; y < 16; y++)
		1310	for (int x = 0; x < 16; x++)
		1311	{
5287	ZblCoder	1312	levels[i].fileds[y][x] = block[k];
5276	ZblCoder	1313	k++;
		1314	}
		1315	}
		1316	}
		1317
		1318	void openLevel(int index)
		1319	{
		1320	levelIndex = index;
		1321	for (int y = 0; y < 16; y++)
		1322	for (int x = 0; x < 16; x++)
		1323	{
		1324	level[y][x].s = levels[index].fileds[y][x];
5287	ZblCoder	1325	level[y][x].d = FIELD_NONE;
5276	ZblCoder	1326	level[y][x].l = 0;
		1327	switch (levels[index].fileds[y][x])
		1328	{
5287	ZblCoder	1329	case FIELD_BOX:
		1330	case FIELD_GUN_0:
		1331	case FIELD_GUN_1:
		1332	case FIELD_GUN_2:
		1333	case FIELD_GUN_3:
5296	ZblCoder	1334	case FIELD_BOX_MISSLE_0:
		1335	case FIELD_BOX_MISSLE_1:
		1336	case FIELD_BOX_MISSLE_2:
		1337	case FIELD_BOX_MISSLE_3:
5287	ZblCoder	1338	level[y][x].s = FIELD_GROUND;
		1339	level[y][x].d = levels[index].fileds[y][x];
5276	ZblCoder	1340	break;
5287	ZblCoder	1341	case FIELD_HERO:
5276	ZblCoder	1342	player = Player(Point(x, y));
5287	ZblCoder	1343	level[y][x].s = FIELD_GROUND;
5276	ZblCoder	1344	break;
5287	ZblCoder	1345	case FIELD_BRICK:
		1346	level[y][x].l = 0;
5276	ZblCoder	1347	break;
		1348	}
		1349	}
		1350	gameStatus = GAME_NONE;
		1351	draw_window();
		1352	}
		1353
		1354	void kos_Main()
		1355	{
5338	ZblCoder	1356	//rtlDebugOutString(" ");
		1357	//rtlDebugOutString("kos_Main");
5276	ZblCoder	1358	char *cPtr;
		1359	cPtr = strrchr(kosExePath, '/');
		1360	// �� ;)
		1361	if (cPtr == NULL)
		1362	{
		1363	rtlDebugOutString("Invalid path to executable.");
		1364	return;
		1365	}
		1366	cPtr[1] = 0;
5296	ZblCoder	1367	strcpy(cPtr + 1, "data01.pak");
5276	ZblCoder	1368
		1369	CKosFile *file = new CKosFile(kosExePath);
		1370
		1371	file->LoadTex((Byte*)img_box, 4, 24, 24);
5287	ZblCoder	1372	for (int i = 0; i < 11; ++i)
		1373	file->LoadTex((Byte*)img_brick[i], 3, 24, 24);
		1374	file->LoadTex((Byte*)img_brick1, 3, 24, 24);
5276	ZblCoder	1375	file->LoadTex((Byte*)img_finish, 3, 24, 24);
		1376	file->LoadTex((Byte*)img_ground, 3, 24, 24);
		1377	file->LoadTex((Byte*)img_laser, 4, 24, 24);
		1378	file->LoadTex((Byte*)img_laser1, 4, 24, 24);
		1379	file->LoadTex((Byte*)img_laser2, 4, 24, 24);
		1380
5287	ZblCoder	1381	for (int i = 0; i < 4; ++i)
		1382	file->LoadTex((Byte*)img_mirror[i], 3, 24, 24);
5276	ZblCoder	1383
5296	ZblCoder	1384	//for (int i = 0; i < 4; ++i)
		1385	file->LoadTex((Byte*)img_mini_mirror, 4, 24, 96);
5276	ZblCoder	1386
		1387	file->LoadTex((Byte*)img_tank, 4, 24, 24);
		1388	file->LoadTex((Byte*)img_wall, 3, 24, 24);
		1389	file->LoadTex((Byte*)img_water, 3, 24, 24);
		1390	file->LoadTex((Byte*)img_waterbox, 3, 24, 24);
		1391	file->LoadTex((Byte*)img_menu, 3, 384, 384);
		1392	file->LoadTex((Byte*)img_explosion, 4, 24, 336);
5287	ZblCoder	1393	file->LoadTex((Byte*)img_gun, 4, 24, 24);
5296	ZblCoder	1394	file->LoadTex((Byte*)img_gamebg, 3, 96, 96);
5331	ZblCoder	1395
5276	ZblCoder	1396
		1397	delete file;
		1398
5296	ZblCoder	1399	strcpy(cPtr + 1, "data02.pak");
		1400
		1401	file = new CKosFile(kosExePath);
		1402
		1403	file->LoadTex((Byte*)img_levels, 3, 384, 384);
5331	ZblCoder	1404
		1405	for (int i = 0; i < 3; ++i)
		1406	file->LoadTex((Byte*)img_pandus[i], 3, 12, 1);
		1407
5296	ZblCoder	1408	file->LoadTex((Byte*)img_number_box, 4, 51, 50);
		1409	file->LoadTex((Byte*)img_numbers, 4, 14, 250);
		1410
		1411	file->LoadTex((Byte*)img_button1, 4, 57, 57);
		1412	file->LoadTex((Byte*)img_button_arrow, 4, 25, 15);
		1413
		1414	file->LoadTex((Byte*)img_wall_h, 3, 24, 24);
		1415	file->LoadTex((Byte*)img_wall_v, 3, 24, 24);
		1416	file->LoadTex((Byte*)img_wall_x, 3, 24, 24);
		1417
		1418	file->LoadTex((Byte*)img_crater, 3, 24, 24);
5297	ZblCoder	1419
		1420	file->LoadTex((Byte*)img_black, 4, 24, 24);
		1421
		1422	for (int i = 0; i < 3; ++i)
		1423	file->LoadTex((Byte*)img_buttons[i], 3, 229, 57);
		1424
5331	ZblCoder	1425
5296	ZblCoder	1426	delete file;
		1427
5276	ZblCoder	1428	renderPlayer = new CKosRender(24, 24);
		1429	objPlayer = new CKosImage(renderPlayer, (RGBA*)img_tank, 24, 24);
		1430
5331	ZblCoder	1431	renderWater = new CKosRender(24, 24);
		1432
5296	ZblCoder	1433	renderBox = new CKosRender(24, 24);
		1434	objLaser = new CKosImage(renderBox, (RGBA*)img_laser, 24, 24);
5276	ZblCoder	1435	objLaser->SetMode(DRAW_ALPHA_ADD);
5296	ZblCoder	1436	objLaser1 = new CKosImage(renderBox, (RGBA*)img_laser1, 24, 24);
5276	ZblCoder	1437	objLaser1->SetMode(DRAW_ALPHA_ADD);
5296	ZblCoder	1438	objLaser2 = new CKosImage(renderBox, (RGBA*)img_laser2, 24, 24);
5276	ZblCoder	1439	objLaser2->SetMode(DRAW_ALPHA_ADD);
		1440
5296	ZblCoder	1441	//for (int i = 0; i < 4; ++i)
		1442	objMiniMirror = new CKosImage(renderBox, (RGBA*)img_mini_mirror, 24, 24);
		1443	objMiniMirror->SetFrameSize(24, 24);
5276	ZblCoder	1444
		1445	objBox = new CKosImage(renderBox, (RGBA*)img_box, 24, 24);
5287	ZblCoder	1446	objGun = new CKosImage(renderBox, (RGBA*)img_gun, 24, 24);
5276	ZblCoder	1447
5296	ZblCoder	1448	objExplosion = new CKosImage(renderBox, (RGBA*)img_explosion, 24, 24);
5276	ZblCoder	1449	objExplosion->SetFrameSize(24, 24);
		1450
5296	ZblCoder	1451	renderLevels = new CKosRender(384, 384);
5297	ZblCoder	1452
		1453	objPlayer1 = new CKosImage(renderLevels, (RGBA*)img_tank, 24, 24);
5296	ZblCoder	1454	objnumber_box = new CKosImage(renderLevels, (RGBA*)img_number_box, 51, 50);
		1455	objnumbers = new CKosImage(renderLevels, (RGBA*)img_numbers, 14, 25);
		1456	objnumbers->SetFrameSize(14, 25);
		1457
		1458	objbutton1 = new CKosImage(renderLevels, (RGBA*)img_button1, 57, 57);
		1459	objbutton_arrow = new CKosImage(renderLevels, (RGBA*)img_button_arrow, 25, 15);
5297	ZblCoder	1460
		1461	objblack = new CKosImage(renderLevels, (RGBA*)img_black, 24, 24);
5296	ZblCoder	1462
5276	ZblCoder	1463	LevelsLoad();
		1464
		1465	openLevel(0);
		1466
		1467	kos_SetMaskForEvents(0x27);
		1468	for (;;)
		1469	{
		1470	switch (kos_WaitForEvent())
		1471	{
		1472	case 1:
5474	ZblCoder	1473	w_redraw = true;
5276	ZblCoder	1474	draw_window();
		1475	break;
		1476	case 2:
		1477	Byte keyCode;
		1478	kos_GetKey(keyCode);
		1479	key_press(keyCode);
		1480	break;
		1481	case 3:
		1482	kos_ExitApp();
		1483	break;
		1484	case 6:
		1485	Dword buttons;
		1486	int mX, mY;
		1487	kos_GetMouseState(buttons, mX, mY);
		1488	if (buttons & 1)
		1489	MousePress(MOUSE_LEFT, Point(mX, mY));
		1490	break;
		1491	}
		1492	}
		1493	}

Subversion Repositories Kolibri OS

(root)/programs/games/LaserTank/trunk/LaserTank.cpp – Rev 6752