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

Subversion Repositories Kolibri OS

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