Subversion Repositories Kolibri OS

Rev

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