Rev 5276 | Rev 5283 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
5281 | ZblCoder | 1 | #include "smalllibc/kosSyst.h" |
2 | #include "smalllibc/kosFile.h" |
||
3 | #include "smalllibc/sprintf.cpp" |
||
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 |
||
11 | |||
12 | #define GAME_NONE 0 |
||
13 | #define GAME_VICTORY 1 |
||
14 | #define GAME_DEFEAT 2 |
||
15 | |||
16 | #define MOUSE_LEFT 0 |
||
17 | |||
18 | char* header = "Laser Tank"; |
||
19 | |||
20 | struct Level |
||
21 | { |
||
22 | char fileds[16][16]; |
||
23 | }; |
||
24 | |||
25 | Level *levels; |
||
26 | int levelCount = 0; |
||
27 | int levelIndex = 0; |
||
28 | |||
29 | RGBA img_tank[576]; |
||
30 | RGB img_water[576]; |
||
31 | RGB img_brick[576]; |
||
32 | RGB img_waterbox[576]; |
||
33 | RGB img_ground[576]; |
||
34 | RGB img_wall[576]; |
||
35 | RGB img_finish[576]; |
||
36 | RGBA img_box[576]; |
||
37 | RGBA img_laser[576]; |
||
38 | RGBA img_mirror[576]; |
||
39 | RGBA img_mirror90[576]; |
||
40 | RGBA img_mirror180[576]; |
||
41 | RGBA img_mirror270[576]; |
||
42 | RGBA img_mini_mirror[576]; |
||
43 | RGBA img_mini_mirror90[576]; |
||
44 | RGBA img_mini_mirror180[576]; |
||
45 | RGBA img_mini_mirror270[576]; |
||
46 | RGBA img_laser1[576]; |
||
47 | RGBA img_laser2[576]; |
||
48 | RGB img_brick1[576]; |
||
49 | RGB img_menu[147456]; |
||
50 | RGBA img_explosion[8064]; |
||
51 | |||
52 | RGB img_button[7500]; |
||
53 | |||
54 | Player player; |
||
55 | |||
56 | CKosRender* renderPlayer; |
||
57 | CKosImage* objPlayer; |
||
58 | |||
59 | CKosRender* renderLaser; |
||
60 | CKosImage* objLaser; |
||
61 | CKosImage* objLaser1; |
||
62 | CKosImage* objLaser2; |
||
63 | |||
64 | CKosRender* renderMirror; |
||
65 | CKosImage* objMirror; |
||
66 | CKosImage* objMirror90; |
||
67 | CKosImage* objMirror180; |
||
68 | CKosImage* objMirror270; |
||
69 | |||
70 | CKosImage* objMiniMirror; |
||
71 | CKosImage* objMiniMirror90; |
||
72 | CKosImage* objMiniMirror180; |
||
73 | CKosImage* objMiniMirror270; |
||
74 | |||
75 | CKosRender* renderBox; |
||
76 | CKosImage* objBox; |
||
77 | |||
78 | CKosRender* renderExplosion; |
||
79 | CKosImage* objExplosion; |
||
80 | |||
81 | int gameMode = MODE_MENU; |
||
82 | int gameStatus = GAME_NONE; |
||
83 | |||
84 | void draw_window(); |
||
85 | void openLevel(int index); |
||
86 | |||
87 | bool CollRecrVsPoint(Point point, Rect rect) |
||
88 | { |
||
89 | return (point.X > rect.X && point.Y > rect.Y && point.X < rect.X + rect.Width && point.Y < rect.Y + rect.Height); |
||
90 | } |
||
91 | |||
92 | struct Button |
||
93 | { |
||
94 | Rect rect; |
||
95 | char* caption; |
||
96 | Button() {} |
||
97 | Button(char* caption, Rect rect) |
||
98 | { |
||
99 | this->caption = caption; |
||
100 | this->rect = rect; |
||
101 | } |
||
102 | }; |
||
103 | |||
104 | Button ToGame("Game", Rect(150, 258, 224, 50)); |
||
105 | Button ToExit("Exit", Rect(150, 321, 224, 50)); |
||
106 | |||
107 | struct LvlItem |
||
108 | { |
||
109 | char s; |
||
110 | char d; |
||
111 | Byte l; |
||
112 | }; |
||
113 | |||
114 | LvlItem level[16][16]; |
||
115 | |||
116 | char GetField(Point position, bool din) |
||
117 | { |
||
118 | if (din && level[position.Y][position.X].d != ' ') |
||
119 | return level[position.Y][position.X].d; |
||
120 | return level[position.Y][position.X].s; |
||
121 | } |
||
122 | |||
123 | RGB* GetImg(Point position, bool din) |
||
124 | { |
||
125 | switch (GetField(position, din)) |
||
126 | { |
||
127 | case 's': |
||
128 | return (RGB*)img_wall; |
||
129 | case '7': |
||
130 | renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
131 | objMirror->Draw(Point(0, 0), 0); |
||
132 | return renderMirror->buffer; |
||
133 | case '9': |
||
134 | renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
135 | objMirror90->Draw(Point(0, 0), 0); |
||
136 | return renderMirror->buffer; |
||
137 | case '3': |
||
138 | renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
139 | objMirror180->Draw(Point(0, 0), 0); |
||
140 | return renderMirror->buffer; |
||
141 | case '1': |
||
142 | renderMirror->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
143 | objMirror270->Draw(Point(0, 0), 0); |
||
144 | return renderMirror->buffer; |
||
145 | case 'h': |
||
146 | case 'g': |
||
147 | return (RGB*)img_ground; |
||
148 | case 'b': |
||
149 | renderBox->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
150 | objBox->Draw(Point(0, 0), 0); |
||
151 | return renderBox->buffer; |
||
152 | // return (RGB*)img_box; |
||
153 | case 'f': |
||
154 | return (RGB*)img_finish; |
||
155 | case 'x': |
||
156 | return (RGB*)img_brick; |
||
157 | case 'w': |
||
158 | return (RGB*)img_water; |
||
159 | case 'e': |
||
160 | return (RGB*)img_waterbox; |
||
161 | case 'y': |
||
162 | return (RGB*)img_brick1; |
||
163 | } |
||
164 | return NULL; |
||
165 | } |
||
166 | |||
167 | void DrawElevent(Point position, bool din) |
||
168 | { |
||
169 | kos_PutImage(GetImg(position, din), 24, 24, 24 * position.X, 24 * position.Y); |
||
170 | } |
||
171 | |||
172 | void MoveBox(Point a, Point b) |
||
173 | { |
||
174 | level[a.Y][a.X].d = ' '; |
||
175 | DrawElevent(a, true); |
||
176 | if (level[b.Y][b.X].s == 'w') |
||
177 | { |
||
178 | level[b.Y][b.X].s = 'e'; |
||
179 | DrawElevent(b, true); |
||
180 | } |
||
181 | else |
||
182 | { |
||
183 | level[b.Y][b.X].d = 'b'; |
||
184 | DrawElevent(b, true); |
||
185 | } |
||
186 | } |
||
187 | |||
188 | void animation(Point vector, float angle) |
||
189 | { |
||
190 | for (int i = 2; i < 23; ++i) |
||
191 | { |
||
192 | kos_WindowRedrawStatus(1); |
||
193 | DrawElevent(player.position, false); |
||
194 | DrawElevent(player.position + vector, false); |
||
195 | |||
196 | renderPlayer->RenderImg(GetImg(player.position, true), Point(0, 0), 24, 24); |
||
197 | objPlayer->Draw(Point(0, 0), angle); |
||
198 | renderPlayer->Draw(player.position * 24 + vector * i); |
||
199 | if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == 'b') |
||
200 | { |
||
201 | renderBox->RenderImg(GetImg(player.position, true), Point(0, 0), 24, 24); |
||
202 | objBox->Draw(Point(0, 0), 0); |
||
203 | renderBox->Draw((player.position + vector) * 24 + vector * i); |
||
204 | } |
||
205 | kos_WindowRedrawStatus(2); |
||
206 | kos_Pause(1); |
||
207 | } |
||
208 | |||
209 | if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == 'b') |
||
210 | MoveBox(player.position + vector, player.position + vector * 2); |
||
211 | |||
212 | DrawElevent(player.position, true); |
||
213 | DrawElevent(player.position + vector, true); |
||
214 | player.position = player.position + vector; |
||
215 | //kos_PutImage(GetImg(player.position + vector), 24, 24, 24 * player.position.X, 24 * player.position.Y); |
||
216 | renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
217 | objPlayer->Draw(Point(0, 0), angle); |
||
218 | renderPlayer->Draw(player.position * 24); |
||
219 | } |
||
220 | |||
221 | void DrawLaser(Point position, int frame) |
||
222 | { |
||
223 | renderLaser->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
||
224 | switch (frame) |
||
225 | { |
||
226 | case 1: |
||
227 | objLaser->Draw(Point(0, 0), 0, (RGB)0x00FF00); |
||
228 | break; |
||
229 | case 2: |
||
230 | objLaser->Draw(Point(0, 0), 90, (RGB)0x00FF00); |
||
231 | break; |
||
232 | case 3: |
||
233 | objLaser2->Draw(Point(0, 0), 0, (RGB)0x00FF00); |
||
234 | break; |
||
235 | default: |
||
236 | objLaser1->Draw(Point(-1, 0), (float)frame, (RGB)0x00FF00); |
||
237 | } |
||
238 | renderLaser->Draw(position * 24); |
||
239 | level[position.Y][position.X].l = 1; |
||
240 | } |
||
241 | |||
242 | void PlayerLaser(void) |
||
243 | { |
||
244 | Point vector = player.vector; |
||
245 | Point position = player.position + vector; |
||
246 | bool en = true; |
||
247 | |||
248 | while (en) |
||
249 | { |
||
250 | switch (GetField(position, true)) |
||
251 | { |
||
252 | case 'b': |
||
253 | if (position + vector != player.position) |
||
254 | switch (GetField(position + vector, true)) |
||
255 | { |
||
256 | case 'g': |
||
257 | case 'w': |
||
258 | case 'e': |
||
259 | for (int i = 2; i < 23; ++i) |
||
260 | { |
||
261 | DrawElevent(position, false); |
||
262 | DrawElevent(position + vector, true); |
||
263 | DrawLaser(position, (vector.X != 0) ? 1 : 2); |
||
264 | renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
||
265 | objBox->Draw(Point(0, 0), 0); |
||
266 | renderBox->Draw((position) * 24 + vector * i); |
||
267 | kos_Pause(1); |
||
268 | } |
||
269 | MoveBox(position, position + vector); |
||
270 | } |
||
271 | en = false; |
||
272 | break; |
||
273 | case 'x': |
||
274 | for (int i = 0; i < 23; ++i) |
||
275 | { |
||
276 | if (i == 11 || i == 22) |
||
277 | { |
||
278 | level[position.Y][position.X].l -= 1; |
||
279 | if (level[position.Y][position.X].l == 2) |
||
280 | { |
||
281 | level[position.Y][position.X].s = 'y'; |
||
282 | level[position.Y][position.X].l = 0; |
||
283 | } |
||
284 | // rtlDebugOutString(ftoa(level[position.Y][position.X].l)); |
||
285 | |||
286 | DrawElevent(position, false); |
||
287 | } |
||
288 | kos_Pause(1); |
||
289 | } |
||
290 | en = false; |
||
291 | break; |
||
292 | case 'g': |
||
293 | case 'w': |
||
294 | case 'y': |
||
295 | case 'e': |
||
296 | if (player.position == position) |
||
297 | { |
||
298 | |||
299 | for (int i = 2; i < 23; ++i) |
||
300 | kos_Pause(1); |
||
301 | for (int y = 0; y < 16; y++) |
||
302 | for (int x = 0; x < 16; x++) |
||
303 | if (level[y][x].l == 1) |
||
304 | { |
||
305 | DrawElevent(Point(x, y), true); |
||
306 | level[y][x].l = 0; |
||
307 | } |
||
308 | for (int i = 0; i < 14; ++i) |
||
309 | { |
||
310 | renderExplosion->RenderImg(GetImg(position, false), Point(0, 0), 24, 24); |
||
311 | objExplosion->Draw(Point(0, 0), 0, i); |
||
312 | renderExplosion->Draw((position)* 24); |
||
313 | kos_Pause(2); |
||
314 | } |
||
315 | gameStatus = GAME_DEFEAT; |
||
316 | draw_window(); |
||
317 | return; |
||
318 | } |
||
319 | else |
||
320 | { |
||
321 | if (level[position.Y][position.X].l == 1) |
||
322 | DrawLaser(position, 3); |
||
323 | else |
||
324 | DrawLaser(position, (vector.X != 0) ? 1 : 2); |
||
325 | } |
||
326 | break; |
||
327 | case '7': |
||
328 | if (vector == Point(-1, 0) || vector == Point(0, -1)) |
||
329 | { |
||
330 | vector = (vector.Y == -1) ? Point(1, 0) : Point(0, 1); |
||
331 | DrawLaser(position, 0); |
||
332 | } |
||
333 | else |
||
334 | { |
||
335 | for (int i = 2; i < 23; ++i) |
||
336 | kos_Pause(1); |
||
337 | en = false; |
||
338 | } |
||
339 | break; |
||
340 | case '9': |
||
341 | if (vector == Point(0, -1) || vector == Point(1, 0)) |
||
342 | { |
||
343 | vector = (vector.Y == -1) ? Point(-1, 0) : Point(0, 1); |
||
344 | DrawLaser(position, 90); |
||
345 | } |
||
346 | else |
||
347 | { |
||
348 | for (int i = 2; i < 23; ++i) |
||
349 | kos_Pause(1); |
||
350 | en = false; |
||
351 | } |
||
352 | break; |
||
353 | case '1': |
||
354 | if (vector == Point(-1, 0) || vector == Point(0, 1)) |
||
355 | { |
||
356 | vector = (vector.Y == 1) ? Point(1, 0) : Point(0, -1); |
||
357 | DrawLaser(position, 270); |
||
358 | } |
||
359 | else |
||
360 | { |
||
361 | for (int i = 2; i < 23; ++i) |
||
362 | kos_Pause(1); |
||
363 | en = false; |
||
364 | } |
||
365 | break; |
||
366 | case '3': |
||
367 | if (vector == Point(1, 0) || vector == Point(0, 1)) |
||
368 | { |
||
369 | vector = (vector.Y == 1) ? Point(-1, 0) : Point(0, -1); |
||
370 | DrawLaser(position, 180); |
||
371 | } |
||
372 | else |
||
373 | { |
||
374 | for (int i = 2; i < 23; ++i) |
||
375 | kos_Pause(1); |
||
376 | en = false; |
||
377 | } |
||
378 | break; |
||
379 | default: |
||
380 | for (int i = 2; i < 23; ++i) |
||
381 | kos_Pause(1); |
||
382 | en = false; |
||
383 | } |
||
384 | position = position + vector; |
||
385 | } |
||
386 | |||
387 | for (int y = 0; y < 16; y++) |
||
388 | for (int x = 0; x < 16; x++) |
||
389 | if (level[y][x].l == 1) |
||
390 | { |
||
391 | DrawElevent(Point(x, y), true); |
||
392 | level[y][x].l = 0; |
||
393 | } |
||
394 | |||
395 | } |
||
396 | |||
397 | void player_move(Point vector, float angle) |
||
398 | { |
||
399 | if (player.vector == vector) |
||
400 | { |
||
401 | switch (GetField(player.position + vector, true)) |
||
402 | { |
||
403 | case 'b': |
||
404 | switch (GetField(player.position + vector * 2, true)) |
||
405 | { |
||
406 | case 'g': |
||
407 | case 'w': |
||
408 | case 'e': |
||
409 | case 'y': |
||
410 | animation(vector, angle); |
||
411 | return; |
||
412 | } |
||
413 | break; |
||
414 | case 'f': |
||
415 | gameStatus = GAME_VICTORY; |
||
416 | draw_window(); |
||
417 | break; |
||
418 | case ' ': |
||
419 | case 'x': |
||
420 | case 's': |
||
421 | case 'w': |
||
422 | case '7': |
||
423 | case '9': |
||
424 | case '3': |
||
425 | case '1': |
||
426 | break; |
||
427 | default: |
||
428 | animation(vector, angle); |
||
429 | } |
||
430 | } |
||
431 | else |
||
432 | { |
||
433 | int cnt; |
||
434 | float addAngle; |
||
435 | if (player.vector == vector * -1) |
||
436 | { |
||
437 | cnt = 48; |
||
438 | addAngle = 3.5f; |
||
439 | } |
||
440 | else |
||
441 | { |
||
442 | cnt = 24; |
||
443 | if (player.angle == 270 && angle == 0 || player.angle == 0 && angle == 270) |
||
444 | addAngle = (player.angle == 0) ? -3.5f : 3.5f; |
||
445 | else |
||
446 | addAngle = (angle < player.angle) ? -3.5f : 3.5f; |
||
447 | } |
||
448 | |||
449 | for (int i = 1; i < cnt - 1; ++i) |
||
450 | { |
||
451 | player.angle += addAngle; |
||
452 | renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
453 | objPlayer->Draw(Point(0, 0), player.angle); |
||
454 | renderPlayer->Draw(player.position * 24); |
||
455 | kos_Pause(1); |
||
456 | } |
||
457 | |||
458 | player.vector = vector; |
||
459 | player.angle = angle; |
||
460 | |||
461 | renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
462 | objPlayer->Draw(Point(0, 0), player.angle); |
||
463 | renderPlayer->Draw(player.position * 24); |
||
464 | } |
||
465 | } |
||
466 | |||
467 | void SetMode(int mode) |
||
468 | { |
||
469 | gameMode = mode; |
||
470 | draw_window(); |
||
471 | } |
||
472 | |||
473 | void key_press(int key) |
||
474 | { |
||
475 | //rtlDebugOutString(ftoa(key)); |
||
476 | |||
477 | switch (gameMode) |
||
478 | { |
||
479 | case MODE_MENU: |
||
480 | |||
481 | break; |
||
482 | case MODE_LEVELS: |
||
483 | |||
484 | break; |
||
485 | case MODE_GAME: |
||
486 | switch (key) |
||
487 | { |
||
488 | case 119: // Up |
||
489 | case 178: // W |
||
490 | if (gameStatus == GAME_NONE) |
||
491 | player_move(Point(0, -1), 270); |
||
492 | break; |
||
493 | case 177: // Down |
||
494 | case 115: // S |
||
495 | if (gameStatus == GAME_NONE) |
||
496 | player_move(Point(0, 1), 90); |
||
497 | break; |
||
498 | case 176: // Left |
||
499 | case 97: // A |
||
500 | if (gameStatus == GAME_NONE) |
||
501 | player_move(Point(-1, 0), 180); |
||
502 | break; |
||
503 | case 179: // Right |
||
504 | case 100: // D |
||
505 | if (gameStatus == GAME_NONE) |
||
506 | player_move(Point(1, 0), 0); |
||
507 | break; |
||
508 | case 32: // Space |
||
509 | if (gameStatus == GAME_NONE) |
||
510 | PlayerLaser(); |
||
511 | break; |
||
512 | case 13: |
||
513 | if (gameStatus == GAME_VICTORY) |
||
514 | openLevel(levelIndex + 1); |
||
515 | else |
||
516 | if (gameStatus == GAME_DEFEAT) |
||
517 | openLevel(levelIndex); |
||
518 | break; |
||
519 | } |
||
520 | break; |
||
521 | } |
||
522 | } |
||
523 | |||
524 | void MousePress(int button, Point position) |
||
525 | { |
||
526 | //rtlDebugOutString("Mouse"); |
||
527 | //rtlDebugOutString(ftoa(position.X)); |
||
528 | //rtlDebugOutString(ftoa(position.Y)); |
||
529 | |||
530 | switch (gameMode) |
||
531 | { |
||
532 | case MODE_MENU: |
||
533 | if (CollRecrVsPoint(position, ToGame.rect)) |
||
534 | SetMode(MODE_GAME); |
||
535 | if (CollRecrVsPoint(position, ToExit.rect)) |
||
536 | kos_ExitApp(); |
||
537 | break; |
||
538 | case MODE_LEVELS: |
||
539 | |||
540 | break; |
||
541 | case MODE_GAME: |
||
542 | |||
543 | break; |
||
544 | } |
||
545 | } |
||
546 | |||
547 | void draw_window(void) |
||
548 | { |
||
549 | kos_WindowRedrawStatus(1); |
||
550 | kos_DefineAndDrawWindow(10, 40, 384 + 9, 384 + 25, 0x33, 0x444444, 0, 0, (Dword)header); |
||
551 | |||
552 | switch (gameMode) |
||
553 | { |
||
554 | case MODE_MENU: |
||
555 | kos_PutImage((RGB*)img_menu, 384, 384, 0, 0); |
||
556 | |||
557 | // kos_PutImage((RGB*)img_button, 150, 50, ToGame.rect.X, ToGame.rect.Y); |
||
558 | |||
559 | |||
560 | break; |
||
561 | case MODE_LEVELS: |
||
562 | |||
563 | break; |
||
564 | case MODE_GAME: |
||
565 | for (int y = 0; y < 16; y++) |
||
566 | for (int x = 0; x < 16; x++) |
||
567 | { |
||
568 | if (level[y][x].s != ' ') |
||
569 | kos_PutImage(GetImg(Point(x, y), true), 24, 24, 24 * x, 24 * y); |
||
570 | if (level[y][x].d == 'b') |
||
571 | { |
||
572 | renderBox->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
573 | objBox->Draw(Point(0, 0), 0); |
||
574 | renderBox->Draw(Point(x, y) * 24); |
||
575 | } |
||
576 | } |
||
577 | |||
578 | switch (gameStatus) |
||
579 | { |
||
580 | case GAME_NONE: |
||
581 | renderPlayer->RenderImg(GetImg(player.position, false), Point(0, 0), 24, 24); |
||
582 | objPlayer->Draw(Point(0, 0), player.angle); |
||
583 | renderPlayer->Draw(player.position * 24); |
||
584 | break; |
||
585 | case GAME_VICTORY: |
||
586 | kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "VICTORY", 0); |
||
587 | break; |
||
588 | case GAME_DEFEAT: |
||
589 | kos_WriteTextToWindow(30, 10, 0x80, 0xFFFFFF, "DEFEAT", 0); |
||
590 | break; |
||
591 | } |
||
592 | break; |
||
593 | } |
||
594 | kos_WindowRedrawStatus(2); |
||
595 | } |
||
596 | |||
597 | void LevelsLoad() |
||
598 | { |
||
599 | char *cPtr; |
||
600 | cPtr = strrchr(kosExePath, '/'); |
||
601 | |||
602 | if (cPtr == NULL) |
||
603 | { |
||
604 | rtlDebugOutString("Invalid path to executable."); |
||
605 | return; |
||
606 | } |
||
607 | cPtr[1] = 0; |
||
608 | strcpy(cPtr + 1, "levels.lvl"); |
||
609 | |||
610 | CKosFile *file = new CKosFile(kosExePath); |
||
611 | |||
612 | Byte block[256]; |
||
613 | while (file->Read(block, 256) == 256) |
||
614 | { |
||
615 | levelCount++; |
||
616 | } |
||
617 | //levelCount++; |
||
618 | rtlDebugOutString(ftoa(levelCount)); |
||
619 | |||
620 | levels = new Level[levelCount]; |
||
621 | |||
622 | file->Seek(0, SEEK_SET); |
||
623 | for (int i = 0; i < levelCount; ++i) |
||
624 | { |
||
625 | file->Read(block, 256); |
||
626 | int k = 0; |
||
627 | |||
628 | for (int y = 0; y < 16; y++) |
||
629 | for (int x = 0; x < 16; x++) |
||
630 | { |
||
631 | // if (block[k] != 0) |
||
632 | // rtlDebugOutString(ftoa(block[k])); |
||
633 | switch (block[k]) |
||
634 | { |
||
635 | case 0: |
||
636 | levels[i].fileds[y][x] = ' '; |
||
637 | break; |
||
638 | case 1: |
||
639 | levels[i].fileds[y][x] = 'w'; |
||
640 | break; |
||
641 | case 2: |
||
642 | levels[i].fileds[y][x] = 'g'; |
||
643 | break; |
||
644 | case 3: |
||
645 | levels[i].fileds[y][x] = 'x'; |
||
646 | break; |
||
647 | case 4: |
||
648 | levels[i].fileds[y][x] = 's'; |
||
649 | break; |
||
650 | case 5: |
||
651 | levels[i].fileds[y][x] = 'b'; |
||
652 | break; |
||
653 | case 6: |
||
654 | levels[i].fileds[y][x] = '7'; |
||
655 | break; |
||
656 | case 7: |
||
657 | levels[i].fileds[y][x] = '9'; |
||
658 | break; |
||
659 | case 8: |
||
660 | levels[i].fileds[y][x] = '3'; |
||
661 | break; |
||
662 | case 9: |
||
663 | levels[i].fileds[y][x] = '1'; |
||
664 | break; |
||
665 | case 10: |
||
666 | levels[i].fileds[y][x] = 'h'; |
||
667 | break; |
||
668 | case 11: |
||
669 | levels[i].fileds[y][x] = 'f'; |
||
670 | break; |
||
671 | } |
||
672 | k++; |
||
673 | } |
||
674 | } |
||
675 | |||
676 | |||
677 | } |
||
678 | |||
679 | void openLevel(int index) |
||
680 | { |
||
681 | levelIndex = index; |
||
682 | for (int y = 0; y < 16; y++) |
||
683 | for (int x = 0; x < 16; x++) |
||
684 | { |
||
685 | level[y][x].s = levels[index].fileds[y][x]; |
||
686 | level[y][x].d = ' '; |
||
687 | level[y][x].l = 0; |
||
688 | switch (levels[index].fileds[y][x]) |
||
689 | { |
||
690 | case 'b': |
||
691 | level[y][x].s = 'g'; |
||
692 | level[y][x].d = 'b'; |
||
693 | break; |
||
694 | case 'h': |
||
695 | player = Player(Point(x, y)); |
||
696 | level[y][x].s = 'g'; |
||
697 | break; |
||
698 | case 'x': |
||
699 | level[y][x].l = 6; |
||
700 | break; |
||
701 | } |
||
702 | } |
||
703 | gameStatus = GAME_NONE; |
||
704 | draw_window(); |
||
705 | } |
||
706 | |||
707 | void kos_Main() |
||
708 | { |
||
709 | rtlDebugOutString(" "); |
||
710 | rtlDebugOutString("kos_Main"); |
||
711 | char *cPtr; |
||
712 | cPtr = strrchr(kosExePath, '/'); |
||
713 | // проверка ;) |
||
714 | if (cPtr == NULL) |
||
715 | { |
||
716 | rtlDebugOutString("Invalid path to executable."); |
||
717 | return; |
||
718 | } |
||
719 | cPtr[1] = 0; |
||
720 | strcpy(cPtr + 1, "arh.pak"); |
||
721 | |||
722 | CKosFile *file = new CKosFile(kosExePath); |
||
723 | |||
724 | file->LoadTex((Byte*)img_box, 4, 24, 24); |
||
725 | file->LoadTex((Byte*)img_brick, 3, 24, 24); |
||
726 | file->LoadTex((Byte*)img_finish, 3, 24, 24); |
||
727 | file->LoadTex((Byte*)img_ground, 3, 24, 24); |
||
728 | file->LoadTex((Byte*)img_laser, 4, 24, 24); |
||
729 | file->LoadTex((Byte*)img_laser1, 4, 24, 24); |
||
730 | file->LoadTex((Byte*)img_laser2, 4, 24, 24); |
||
731 | |||
732 | file->LoadTex((Byte*)img_mirror, 4, 24, 24); |
||
733 | file->LoadTex((Byte*)img_mirror90, 4, 24, 24); |
||
734 | file->LoadTex((Byte*)img_mirror180, 4, 24, 24); |
||
735 | file->LoadTex((Byte*)img_mirror270, 4, 24, 24); |
||
736 | |||
737 | file->LoadTex((Byte*)img_mini_mirror, 4, 24, 24); |
||
738 | file->LoadTex((Byte*)img_mini_mirror90, 4, 24, 24); |
||
739 | file->LoadTex((Byte*)img_mini_mirror180, 4, 24, 24); |
||
740 | file->LoadTex((Byte*)img_mini_mirror270, 4, 24, 24); |
||
741 | |||
742 | file->LoadTex((Byte*)img_tank, 4, 24, 24); |
||
743 | file->LoadTex((Byte*)img_wall, 3, 24, 24); |
||
744 | file->LoadTex((Byte*)img_water, 3, 24, 24); |
||
745 | file->LoadTex((Byte*)img_waterbox, 3, 24, 24); |
||
746 | file->LoadTex((Byte*)img_brick1, 3, 24, 24); |
||
747 | file->LoadTex((Byte*)img_menu, 3, 384, 384); |
||
748 | file->LoadTex((Byte*)img_button, 3, 150, 50); |
||
749 | file->LoadTex((Byte*)img_explosion, 4, 24, 336); |
||
750 | |||
751 | delete file; |
||
752 | |||
753 | renderPlayer = new CKosRender(24, 24); |
||
754 | objPlayer = new CKosImage(renderPlayer, (RGBA*)img_tank, 24, 24); |
||
755 | |||
756 | renderLaser = new CKosRender(24, 24); |
||
757 | objLaser = new CKosImage(renderLaser, (RGBA*)img_laser, 24, 24); |
||
758 | objLaser->SetMode(DRAW_ALPHA_ADD); |
||
759 | objLaser1 = new CKosImage(renderLaser, (RGBA*)img_laser1, 24, 24); |
||
760 | objLaser1->SetMode(DRAW_ALPHA_ADD); |
||
761 | objLaser2 = new CKosImage(renderLaser, (RGBA*)img_laser2, 24, 24); |
||
762 | objLaser2->SetMode(DRAW_ALPHA_ADD); |
||
763 | |||
764 | renderMirror = new CKosRender(24, 24); |
||
765 | objMirror = new CKosImage(renderMirror, (RGBA*)img_mirror, 24, 24); |
||
766 | objMirror90 = new CKosImage(renderMirror, (RGBA*)img_mirror90, 24, 24); |
||
767 | objMirror180 = new CKosImage(renderMirror, (RGBA*)img_mirror180, 24, 24); |
||
768 | objMirror270 = new CKosImage(renderMirror, (RGBA*)img_mirror270, 24, 24); |
||
769 | |||
770 | objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror, 24, 24); |
||
771 | objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror90, 24, 24); |
||
772 | objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror180, 24, 24); |
||
773 | objMiniMirror = new CKosImage(renderMirror, (RGBA*)img_mini_mirror270, 24, 24); |
||
774 | |||
775 | renderBox = new CKosRender(24, 24); |
||
776 | objBox = new CKosImage(renderBox, (RGBA*)img_box, 24, 24); |
||
777 | |||
778 | renderExplosion = new CKosRender(24, 24); |
||
779 | objExplosion = new CKosImage(renderExplosion, (RGBA*)img_explosion, 24, 24); |
||
780 | objExplosion->SetFrameSize(24, 24); |
||
781 | |||
782 | LevelsLoad(); |
||
783 | |||
784 | openLevel(0); |
||
785 | |||
786 | kos_SetMaskForEvents(0x27); |
||
787 | for (;;) |
||
788 | { |
||
789 | switch (kos_WaitForEvent()) |
||
790 | { |
||
791 | case 1: |
||
792 | draw_window(); |
||
793 | break; |
||
794 | case 2: |
||
795 | Byte keyCode; |
||
796 | kos_GetKey(keyCode); |
||
797 | key_press(keyCode); |
||
798 | break; |
||
799 | case 3: |
||
800 | kos_ExitApp(); |
||
801 | break; |
||
802 | case 6: |
||
803 | Dword buttons; |
||
804 | int mX, mY; |
||
805 | kos_GetMouseState(buttons, mX, mY); |
||
806 | if (buttons & 1) |
||
807 | MousePress(MOUSE_LEFT, Point(mX, mY)); |
||
808 | break; |
||
809 | } |
||
810 | } |
||
811 | }>>>>>>>>>>>>>>>>>>>>>>>>> |