Subversion Repositories Kolibri OS

Rev

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