Subversion Repositories Kolibri OS

Rev

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

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