Subversion Repositories Kolibri OS

Rev

Rev 5333 | Rev 5340 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. #include "smalllibc/kosSyst.h"
  2. #include "smalllibc/kosFile.h"
  3. #include "smalllibc/sprintf.h"
  4. #include "smalllibc/func.h"
  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. #define MODE_PAUSE              4
  12.  
  13. #define GAME_NONE               0
  14. #define GAME_VICTORY    1
  15. #define GAME_DEFEAT             2
  16.  
  17. #define MOUSE_LEFT              0
  18.  
  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
  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
  45.  
  46. char* header = "Laser Tank";
  47.  
  48. struct Level
  49. {
  50.         Byte fileds[16][16];
  51. };
  52.  
  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.  
  61. Level *levels;
  62. int levelCount = 0;
  63. int levelIndex = 0;
  64. int levelPage = 0;
  65.  
  66. RGBA img_tank[576];
  67. RGB img_water[576];
  68. RGB img_brick[11][576];
  69. RGB img_waterbox[576];
  70. RGB img_ground[576];
  71. RGB img_crater[576];
  72. RGB img_wall[576];
  73. RGB img_wall_x[576];
  74. RGB img_wall_h[576];
  75. RGB img_wall_v[576];
  76. RGB img_finish[576];
  77. RGBA img_box[576];
  78. RGBA img_laser[576];
  79. RGB img_mirror[4][576];
  80. RGBA img_mini_mirror[2304];
  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];
  86. RGBA img_gun[576];
  87. RGB img_gamebg[9216];
  88. RGBA img_black[576];
  89.  
  90. RGB img_pandus[3][12];
  91.  
  92. RGBA img_number_box[2550];
  93. RGBA img_numbers[3500];
  94. RGBA img_button1[3249];
  95. RGBA img_button_arrow[375];
  96.  
  97. RGB img_levels[147456];
  98.  
  99. RGB img_buttons[3][13053];
  100.  
  101.  
  102.  
  103. Player player;
  104.  
  105. CKosRender* renderPlayer;
  106. CKosImage* objPlayer;
  107. CKosImage* objPlayer1;
  108.  
  109. CKosRender* renderBox;
  110. CKosRender* renderWater;
  111.  
  112. CKosImage* objLaser;
  113. CKosImage* objLaser1;
  114. CKosImage* objLaser2;
  115. CKosImage* objMiniMirror;
  116. CKosImage* objBox;
  117. CKosImage* objGun;
  118. CKosImage* objExplosion;
  119.  
  120. CKosImage* objblack;
  121.  
  122. CKosRender* renderLevels;
  123. CKosImage* objnumber_box;
  124. CKosImage* objnumbers;
  125.  
  126. CKosImage* objbutton1;
  127. CKosImage* objbutton_arrow;
  128.  
  129. int gameMode = MODE_MENU;
  130. int gameStatus = GAME_NONE;
  131.  
  132. void draw_window();
  133. void openLevel(int index);
  134. void Laser(Point pos, Point vec, RGB color);
  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. {
  158.         Byte s;
  159.         Byte d;
  160.         Byte l;
  161. };
  162.  
  163. LvlItem level[16][16];
  164.  
  165. char GetField(Point position, bool din)
  166. {
  167.         if (position.X < 0 || position.Y < 0 || position.X > 15 || position.Y > 15)
  168.                 return FIELD_WALL;
  169.  
  170.         if (din && level[position.Y][position.X].d != FIELD_NONE)
  171.                 return level[position.Y][position.X].d;
  172.         return level[position.Y][position.X].s;
  173. }
  174.  
  175. void SetMode(int mode)
  176. {
  177.         gameMode = mode;
  178.         draw_window();
  179. }
  180.  
  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.  
  250. RGB* GetImg(Point position, bool din)
  251. {
  252.         switch (GetField(position, din))
  253.         {
  254.         case FIELD_WALL:
  255.                 return (RGB*)img_wall;
  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;
  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];
  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;
  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:
  303.                 return (RGB*)img_ground;
  304.         case FIELD_CRATER:
  305.                 return (RGB*)img_crater;
  306.         case FIELD_BOX:
  307.                 renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
  308.                 objBox->Draw(Point(0, 0), 0);
  309.                 return renderBox->buffer;
  310.         case FIELD_FINISH:
  311.                 return (RGB*)img_finish;
  312.         case FIELD_BRICK:
  313.                 return (RGB*)img_brick[level[position.Y][position.X].l];
  314.         case FIELD_BRICK_DES:
  315.                 return (RGB*)img_brick1;
  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;
  326.         }
  327.         return NULL;
  328. }
  329.  
  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:
  340.         case FIELD_CRATER:
  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.  
  386. void DrawElevent(Point position, bool din)
  387. {
  388.         kos_PutImage(GetImg(position, din), 24, 24, 24 * position.X, 24 * position.Y);
  389. }
  390.  
  391. void MoveElement(Point a, Point b, int element)
  392. {
  393.         level[a.Y][a.X].d = FIELD_NONE;
  394.         DrawElevent(a, false);
  395.         if (level[b.Y][b.X].s == FIELD_WATER)
  396.         {
  397.                 if (element == FIELD_BOX)
  398.                         level[b.Y][b.X].s = FIELD_BOX_WATER;
  399.         }
  400.         else
  401.                 level[b.Y][b.X].d = element;
  402.         DrawElevent(b, true);
  403. }
  404.  
  405. void animation(Point vector, float angle, int obj)
  406. {
  407.         for (int i = 2; i < 23; ++i)
  408.         {
  409.                 kos_WindowRedrawStatus(1);
  410.  
  411.                 DrawElevent(player.position, false);
  412.                 DrawElevent(player.position + vector, false);
  413.  
  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.  
  417.                 objPlayer->Draw(Point(0, 0), angle);
  418.                 renderPlayer->Draw(player.position * 24 + vector * i);
  419.                 if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == obj)
  420.                 {
  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);
  424.                         switch (obj)
  425.                         {
  426.                         case FIELD_GUN_0:
  427.                                 objGun->Draw(Point(0, 0), 0);
  428.                                 break;
  429.                         case FIELD_GUN_1:
  430.                                 objGun->Draw(Point(0, 0), 90);
  431.                                 break;
  432.                         case FIELD_GUN_2:
  433.                                 objGun->Draw(Point(0, 0), 180);
  434.                                 break;
  435.                         case FIELD_GUN_3:
  436.                                 objGun->Draw(Point(0, 0), 270);
  437.                                 break;
  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;
  450.                         case FIELD_BOX:
  451.                                 objBox->Draw(Point(0, 0), 0);
  452.                         }
  453.                         renderBox->Draw((player.position + vector) * 24 + vector * i);
  454.                 }
  455.                 kos_WindowRedrawStatus(2);
  456.                 pause(1);
  457.         }
  458.  
  459.         if (level[player.position.Y + vector.Y][player.position.X + vector.X].d == obj)
  460.                 MoveElement(player.position + vector, player.position + vector * 2, GetField(player.position + vector, true));
  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);
  469.         ExistGun(player.position);
  470. }
  471.  
  472. void DrawLaser(Point position, int frame, RGB color)
  473. {
  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);
  478.         switch (frame)
  479.         {
  480.         case 1:
  481.                 objLaser->Draw(Point(0, 0), 0, color);
  482.                 break;
  483.         case 2:
  484.                 objLaser->Draw(Point(0, 0), 90, color);
  485.                 break;
  486.         case 3:
  487.                 objLaser2->Draw(Point(0, 0), 0, color);
  488.                 break;
  489.         default:
  490.                 objLaser1->Draw(Point(0, 0), (float)frame, color);
  491.         }
  492.         renderBox->Draw(position * 24);
  493.         level[position.Y][position.X].l = 1;
  494. }
  495.  
  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.  
  560. void Laser(Point pos, Point vec, RGB color)
  561. {
  562.         Point vector = vec;
  563.         Point position = pos + vector;
  564.         bool en = true;
  565.         Byte code;
  566.         bool LaserGun = false;
  567.        
  568.         while (en)
  569.         {
  570.                 code = GetField(position, true);
  571.                 switch (code)
  572.                 {
  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.                                 {
  592.                                         renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
  593.                                         objExplosion->Draw(Point(0, 0), 0, i);
  594.                                         renderBox->Draw((position)* 24);
  595.                                         pause(2);
  596.                                 }
  597.                                 level[position.Y][position.X].d = FIELD_NONE;
  598.                                 if (level[position.Y][position.X].s == FIELD_GROUND)
  599.                                         level[position.Y][position.X].s = FIELD_CRATER;
  600.                                 draw_window();
  601.                                 return;
  602.                         }
  603.                         else
  604.                         {
  605.                                 if (!LaserMoveElement(position, vector, code, color))
  606.                                 {
  607.                                         for (int i = 2; i < 23; ++i)
  608.                                                 pause(1);
  609.                                 }
  610.                                 else
  611.                                         LaserGun = true;
  612.                         }
  613.                         en = false;
  614.                         break;
  615.                 case FIELD_BRICK:
  616.                         for (int i = 0; i < 6; ++i)
  617.                         {
  618.                                 level[position.Y][position.X].l += 1;
  619.                                 if (level[position.Y][position.X].l == 11)
  620.                                 {
  621.                                         level[position.Y][position.X].s = FIELD_BRICK_DES;
  622.                                         level[position.Y][position.X].l = 0;
  623.                                         LaserGun = true;
  624.                                 }
  625.                                 DrawElevent(position, false);
  626.                                 pause(5);
  627.                         }
  628.                         en = false;
  629.                         break;
  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;
  648.                 case FIELD_GROUND:
  649.                 case FIELD_CRATER:
  650.                 case FIELD_WATER:
  651.                 case FIELD_FINISH:
  652.                 case FIELD_BRICK_DES:
  653.                 case FIELD_BOX_WATER:
  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.                                 {
  667.                                         renderBox->RenderImg(GetImg(position, false), Point(0, 0), 24, 24);
  668.                                         objExplosion->Draw(Point(0, 0), 0, i);
  669.                                         renderBox->Draw((position)* 24);
  670.                                         pause(2);
  671.                                 }
  672.                                 level[player.position.Y][player.position.X].s = FIELD_CRATER;
  673.                                 gameStatus = GAME_DEFEAT;
  674.                                 SetMode(MODE_PAUSE);
  675.                                 return;
  676.                         }
  677.                         else
  678.                         {
  679.                                 if (level[position.Y][position.X].l == 1)
  680.                                         DrawLaser(position, 3, color);
  681.                                 else
  682.                                         DrawLaser(position, (vector.X != 0) ? 1 : 2, color);
  683.                         }
  684.                         break;
  685.                 case FIELD_BOX_MISSLE_0:
  686.                         if (vector == Point(-1, 0) || vector == Point(0, -1))
  687.                         {
  688.                                 vector = (vector.Y == -1) ? Point(1, 0) : Point(0, 1);
  689.                                 DrawLaser(position, 0, color);
  690.                         }
  691.                         else
  692.                         {
  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;
  700.                                 en = false;
  701.                         }
  702.                         break;
  703.                 case FIELD_BOX_MISSLE_1:
  704.                         if (vector == Point(0, -1) || vector == Point(1, 0))
  705.                         {
  706.                                 vector = (vector.Y == -1) ? Point(-1, 0) : Point(0, 1);
  707.                                 DrawLaser(position, 90, color);
  708.                         }
  709.                         else
  710.                         {
  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;
  718.                                 en = false;
  719.                         }
  720.                         break;
  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:
  740.                         if (vector == Point(-1, 0) || vector == Point(0, 1))
  741.                         {
  742.                                 vector = (vector.Y == 1) ? Point(1, 0) : Point(0, -1);
  743.                                 DrawLaser(position, 270, color);
  744.                         }
  745.                         else
  746.                         {
  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.                         {
  765.                                 for (int i = 2; i < 23; ++i)
  766.                                         pause(1);
  767.                                 en = false;
  768.                         }
  769.                         break;
  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;
  783.                 case FIELD_MISSLE_2:
  784.                         if (vector == Point(1, 0) || vector == Point(0, 1))
  785.                         {
  786.                                 vector = (vector.Y == 1) ? Point(-1, 0) : Point(0, -1);
  787.                                 DrawLaser(position, 180, color);
  788.                         }
  789.                         else
  790.                         {
  791.                                 for (int i = 2; i < 23; ++i)
  792.                                         pause(1);
  793.                                 en = false;
  794.                         }
  795.                         break;
  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;
  809.                 default:
  810.                         for (int i = 2; i < 23; ++i)
  811.                                 pause(1);
  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.        
  825.         if (LaserGun)
  826.                 ExistGun(player.position);
  827. }
  828.  
  829. void player_move(Point vector, float angle)
  830. {
  831.         if (player.vector == vector)
  832.         {
  833.                 Byte code = GetField(player.position + vector, true);
  834.                 switch (code)
  835.                 {
  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;
  856.                 case FIELD_GUN_0:
  857.                 case FIELD_GUN_1:
  858.                 case FIELD_GUN_2:
  859.                 case FIELD_GUN_3:
  860.                 case FIELD_BOX:        
  861.                         switch (GetField(player.position + vector * 2, true))
  862.                         {
  863.                         case FIELD_GROUND:
  864.                         case FIELD_CRATER:
  865.                         case FIELD_WATER:
  866.                         case FIELD_BOX_WATER:
  867.                         case FIELD_BRICK_DES:
  868.                                 animation(vector, angle, code);
  869.                                 return;
  870.                         }
  871.                         break;
  872.                 case FIELD_FINISH:
  873.                         gameStatus = GAME_VICTORY;
  874.                         SetMode(MODE_PAUSE);
  875.                         draw_window();
  876.                         break;
  877.                 case FIELD_NONE:
  878.                 case FIELD_BRICK:
  879.                 case FIELD_WALL:
  880.                 case FIELD_WALL_H:
  881.                 case FIELD_WALL_V:
  882.                 case FIELD_WALL_X:
  883.                 case FIELD_WATER:
  884.                 case FIELD_MISSLE_0:
  885.                 case FIELD_MISSLE_1:
  886.                 case FIELD_MISSLE_2:
  887.                 case FIELD_MISSLE_3:
  888.                         break;
  889.                 default:
  890.                         animation(vector, angle, -1);
  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);
  917.                         pause(1);
  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));
  932.  
  933.         switch (gameMode)
  934.         {
  935.         case MODE_MENU:
  936.                 if (key == 27)
  937.                         kos_ExitApp();
  938.  
  939.                 if (key == 13 || key == 32)
  940.                         SetMode(MODE_LEVELS);
  941.                 break;
  942.         case MODE_LEVELS:
  943.                 if (key == 27)
  944.                         SetMode(MODE_MENU);
  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.  
  991.                 break;
  992.         case MODE_PAUSE:
  993.                 if (key == 27)
  994.                         SetMode(MODE_LEVELS);
  995.                 else
  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.                         else
  1003.                                 if (key == 114)
  1004.                                 {
  1005.                                         openLevel(levelIndex);
  1006.                                         SetMode(MODE_GAME);
  1007.                                 }
  1008.                 break;
  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)
  1034.                                 Laser(player.position, player.vector, (RGB)0x00FF00);
  1035.                         break;
  1036.                 case 13:
  1037.                         //rtlDebugOutString(ftoa(rtlRand()));
  1038.                        
  1039.                 //      openLevel(levelIndex + 1);
  1040.                         if (gameStatus == GAME_VICTORY)
  1041.                                 openLevel(levelIndex + 1);
  1042.                         else
  1043.                                 if (gameStatus == GAME_DEFEAT)
  1044.                                         openLevel(levelIndex);
  1045.  
  1046.                         break;
  1047.                 case 27:
  1048.                         SetMode(MODE_PAUSE);
  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));
  1059.         Point level_pos = Point(0, 0);
  1060.         switch (gameMode)
  1061.         {
  1062.         case MODE_MENU:
  1063.                 if (CollRecrVsPoint(position, ToGame.rect))
  1064.                         SetMode(MODE_LEVELS);
  1065.                 if (CollRecrVsPoint(position, ToExit.rect))
  1066.                         kos_ExitApp();
  1067.                 break;
  1068.         case MODE_LEVELS:
  1069.                 if (CollRecrVsPoint(position, ToExit.rect))
  1070.                         SetMode(MODE_MENU);
  1071.                 else
  1072.                 if (levelPage > 0 && CollRecrVsPoint(position, Rect(9, 318, 57, 57)))
  1073.                 {
  1074.                         levelIndex -= 30;
  1075.                         draw_window();
  1076.                 }
  1077.                 else
  1078.                         if (levelPage < (int)(levelCount / 30) && CollRecrVsPoint(position, Rect(70, 318, 57, 57)))
  1079.                 {
  1080.                         levelIndex += 30;
  1081.                         if (levelIndex >= levelCount)
  1082.                                 levelIndex = levelCount - 1;
  1083.                         draw_window();
  1084.                 }                      
  1085.                 else
  1086.                 {
  1087.                         levelPage = (int)(levelIndex / 30);
  1088.                         for (int i = levelPage * 30; i < min(levelCount, (levelPage + 1) * 30); i++)
  1089.                         {
  1090.  
  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.                 }
  1106.                 break;
  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
  1117.                                 if (CollRecrVsPoint(position, Rect(77, 192, 229, 57)) && (gameStatus == GAME_NONE || (gameStatus == GAME_VICTORY && levelIndex < (levelCount - 1))))
  1118.                                 {
  1119.                                         if (gameStatus == GAME_VICTORY)
  1120.                                                 openLevel(levelIndex + 1);
  1121.                                         SetMode(MODE_GAME);
  1122.                                 }
  1123.         case MODE_GAME:
  1124.  
  1125.                 break;
  1126.         }
  1127. }
  1128.  
  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.  
  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);
  1152.         Point level_pos = Point(0, 0);
  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:
  1163.                 renderLevels->RenderImg(img_levels, Point(0, 0), 384, 384);
  1164.  
  1165.                 levelPage = (int)(levelIndex / 30);
  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.                         }
  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.                         }
  1183.  
  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));
  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);
  1206.  
  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.  
  1229.                         if (gameStatus == GAME_NONE || (gameStatus == GAME_VICTORY && levelIndex < (levelCount - 1)))
  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));
  1235.                 break;
  1236.         case MODE_GAME:
  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.                
  1241.                 for (int y = 0; y < 16; y++)
  1242.                         for (int x = 0; x < 16; x++)
  1243.                                 if (level[y][x].s != FIELD_NONE)
  1244.                                         kos_PutImage(GetImg(Point(x, y), true), 24, 24, 24 * x, 24 * y);       
  1245.  
  1246.                 if(gameStatus != GAME_DEFEAT)
  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;
  1268.         strcpy(cPtr + 1, "data.lvl");
  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++;
  1278.         //rtlDebugOutString(ftoa(levelCount));
  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.                         {
  1291.                                 levels[i].fileds[y][x] = block[k];
  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];
  1304.                         level[y][x].d = FIELD_NONE;
  1305.                         level[y][x].l = 0;
  1306.                         switch (levels[index].fileds[y][x])
  1307.                         {
  1308.                         case FIELD_BOX:
  1309.                         case FIELD_GUN_0:
  1310.                         case FIELD_GUN_1:
  1311.                         case FIELD_GUN_2:
  1312.                         case FIELD_GUN_3:
  1313.                         case FIELD_BOX_MISSLE_0:
  1314.                         case FIELD_BOX_MISSLE_1:
  1315.                         case FIELD_BOX_MISSLE_2:
  1316.                         case FIELD_BOX_MISSLE_3:
  1317.                                 level[y][x].s = FIELD_GROUND;
  1318.                                 level[y][x].d = levels[index].fileds[y][x];
  1319.                                 break;
  1320.                         case FIELD_HERO:
  1321.                                 player = Player(Point(x, y));
  1322.                                 level[y][x].s = FIELD_GROUND;
  1323.                                 break;
  1324.                         case FIELD_BRICK:
  1325.                                 level[y][x].l = 0;
  1326.                                 break;
  1327.                         }
  1328.                 }
  1329.         gameStatus = GAME_NONE;
  1330.         draw_window();
  1331. }
  1332.  
  1333. void kos_Main()
  1334. {
  1335.         //rtlDebugOutString(" ");
  1336.         //rtlDebugOutString("kos_Main");
  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;
  1346.         strcpy(cPtr + 1, "data01.pak");
  1347.        
  1348.         CKosFile *file = new CKosFile(kosExePath);
  1349.  
  1350.         file->LoadTex((Byte*)img_box, 4, 24, 24);
  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);
  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.  
  1360.         for (int i = 0; i < 4; ++i)
  1361.                 file->LoadTex((Byte*)img_mirror[i], 3, 24, 24);
  1362.  
  1363.         //for (int i = 0; i < 4; ++i)
  1364.         file->LoadTex((Byte*)img_mini_mirror, 4, 24, 96);
  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);       
  1372.         file->LoadTex((Byte*)img_gun, 4, 24, 24);      
  1373.         file->LoadTex((Byte*)img_gamebg, 3, 96, 96);
  1374.  
  1375.        
  1376.         delete file;
  1377.  
  1378.         strcpy(cPtr + 1, "data02.pak");
  1379.        
  1380.         file = new CKosFile(kosExePath);
  1381.  
  1382.         file->LoadTex((Byte*)img_levels, 3, 384, 384);
  1383.  
  1384.         for (int i = 0; i < 3; ++i)
  1385.                 file->LoadTex((Byte*)img_pandus[i], 3, 12, 1);
  1386.  
  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);
  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.  
  1404.  
  1405.         delete file;
  1406.  
  1407.         renderPlayer = new CKosRender(24, 24);
  1408.         objPlayer = new CKosImage(renderPlayer, (RGBA*)img_tank, 24, 24);
  1409.  
  1410.         renderWater = new CKosRender(24, 24);
  1411.  
  1412.         renderBox = new CKosRender(24, 24);
  1413.         objLaser = new CKosImage(renderBox, (RGBA*)img_laser, 24, 24);
  1414.         objLaser->SetMode(DRAW_ALPHA_ADD);
  1415.         objLaser1 = new CKosImage(renderBox, (RGBA*)img_laser1, 24, 24);
  1416.         objLaser1->SetMode(DRAW_ALPHA_ADD);
  1417.         objLaser2 = new CKosImage(renderBox, (RGBA*)img_laser2, 24, 24);
  1418.         objLaser2->SetMode(DRAW_ALPHA_ADD);
  1419.                        
  1420.         //for (int i = 0; i < 4; ++i)
  1421.         objMiniMirror = new CKosImage(renderBox, (RGBA*)img_mini_mirror, 24, 24);
  1422.         objMiniMirror->SetFrameSize(24, 24);
  1423.  
  1424.         objBox = new CKosImage(renderBox, (RGBA*)img_box, 24, 24);
  1425.         objGun = new CKosImage(renderBox, (RGBA*)img_gun, 24, 24);     
  1426.  
  1427.         objExplosion = new CKosImage(renderBox, (RGBA*)img_explosion, 24, 24);
  1428.         objExplosion->SetFrameSize(24, 24);
  1429.  
  1430.         renderLevels = new CKosRender(384, 384);
  1431.  
  1432.         objPlayer1 = new CKosImage(renderLevels, (RGBA*)img_tank, 24, 24);
  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);
  1439.        
  1440.         objblack = new CKosImage(renderLevels, (RGBA*)img_black, 24, 24);
  1441.  
  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. }
  1472.