Subversion Repositories Kolibri OS

Rev

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