Subversion Repositories Kolibri OS

Rev

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

  1. #include "kosSyst.h"
  2. #include "mcarray.h"
  3. #include "lang.h"
  4.  
  5.  
  6. // áèòìàï ïóñòîãî ìåñòà
  7. RGB bmEmpty[] = {
  8.         0x201010, 0x101020, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  9.         0x101010, 0x102010, 0x201010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  10.         0x101010, 0x101010, 0x101020, 0x102010, 0x101010, 0x101010, 0x101010, 0x101010,
  11.         0x101010, 0x101010, 0x101010, 0x201010, 0x101020, 0x101010, 0x101010, 0x101010,
  12.         0x101010, 0x101010, 0x101010, 0x101010, 0x102010, 0x201010, 0x101010, 0x101010,
  13.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101020, 0x102010, 0x101010,
  14.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x201010, 0x101020,
  15.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x102010
  16. };
  17.  
  18.  
  19. // áèòìàï èãðîêà
  20. RGB bmHero[] = {
  21.         0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020C0,
  22.         0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020E0, 0x2020C0, 0x2020A0,
  23.         0x2020E0, 0x2020E0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020A0, 0x2020A0,
  24.         0x2020E0, 0x2020E0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020A0, 0x2020A0,
  25.         0x2020E0, 0x2020E0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020A0, 0x2020A0,
  26.         0x2020E0, 0x2020E0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020C0, 0x2020A0, 0x2020A0,
  27.         0x2020E0, 0x2020C0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0,
  28.         0x2020C0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0, 0x2020A0
  29. };
  30.  
  31.  
  32. // áèòìàï èãðîêà
  33. RGB bmSuperHero[] = {
  34.         0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720B0,
  35.         0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720D0, 0x5720B0, 0x572090,
  36.         0x5720D0, 0x5720D0, 0x5720B0, 0x5720B0, 0x5720B0, 0x5720B0, 0x572090, 0x572090,
  37.         0x5720D0, 0x5720D0, 0x5720B0, 0x5720B0, 0x5720B0, 0x5720B0, 0x572090, 0x572090,
  38.         0x5720D0, 0x5720D0, 0x5720B0, 0x5720B0, 0x5720B0, 0x5720B0, 0x572090, 0x572090,
  39.         0x5720D0, 0x5720D0, 0x5720B0, 0x5720B0, 0x5720B0, 0x5720B0, 0x572090, 0x572090,
  40.         0x5720D0, 0x5720B0, 0x572090, 0x572090, 0x572090, 0x572090, 0x572090, 0x572090,
  41.         0x5720B0, 0x572090, 0x572090, 0x572090, 0x572090, 0x572090, 0x572090, 0x572090
  42. };
  43.  
  44.  
  45. // áèòìàï ãàäà, áåãàþùåãî ïî çàïîëíåííîé ìåñòíîñòè
  46. RGB bmEnemy1[] = {
  47.         0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xC02020,
  48.         0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xE02020, 0xC02020, 0xA02020,
  49.         0xE02020, 0xE02020, 0xC02020, 0xC02020, 0xC02020, 0xC02020, 0xA02020, 0xA02020,
  50.         0xE02020, 0xE02020, 0xC02020, 0xC02020, 0xC02020, 0xC02020, 0xA02020, 0xA02020,
  51.         0xE02020, 0xE02020, 0xC02020, 0xC02020, 0xC02020, 0xC02020, 0xA02020, 0xA02020,
  52.         0xE02020, 0xE02020, 0xC02020, 0xC02020, 0xC02020, 0xC02020, 0xA02020, 0xA02020,
  53.         0xE02020, 0xC02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020,
  54.         0xC02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020, 0xA02020
  55. };
  56.  
  57.  
  58. // áèòìàï ãàäà, áåãàþùåãî ïî ïóñòîìó ìåñòó
  59. RGB bmEnemy2[] = {
  60.         0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xC08020,
  61.         0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xE08020, 0xC08020, 0xA08020,
  62.         0xE08020, 0xE08020, 0xC08020, 0xC08020, 0xC08020, 0xC08020, 0xA08020, 0xA08020,
  63.         0xE08020, 0xE08020, 0xC08020, 0xC08020, 0xC08020, 0xC08020, 0xA08020, 0xA08020,
  64.         0xE08020, 0xE08020, 0xC08020, 0xC08020, 0xC08020, 0xC08020, 0xA08020, 0xA08020,
  65.         0xE08020, 0xE08020, 0xC08020, 0xC08020, 0xC08020, 0xC08020, 0xA08020, 0xA08020,
  66.         0xE08020, 0xC08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020,
  67.         0xC08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020, 0xA08020
  68. };
  69.  
  70.  
  71. // áèòìàï çàïîëíåíèÿ
  72. RGB bmWall[] = {
  73.         0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xCCCCCC,
  74.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  75.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  76.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  77.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  78.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  79.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  80.         0xCCCCCC, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA
  81. };
  82.  
  83.  
  84. // ñëåä èãðîêà
  85. RGB bmTrack[] = {
  86.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  87.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  88.         0x101010, 0x101010, 0x101010, 0x1010F0, 0x1010F0, 0x101010, 0x101010, 0x101010,
  89.         0x101010, 0x101010, 0x1010F0, 0x1010F0, 0x1010F0, 0x1010F0, 0x101010, 0x101010,
  90.         0x101010, 0x101010, 0x1010F0, 0x1010F0, 0x1010F0, 0x1010F0, 0x101010, 0x101010,
  91.         0x101010, 0x101010, 0x101010, 0x1010F0, 0x1010F0, 0x101010, 0x101010, 0x101010,
  92.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  93.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010
  94. };
  95.  
  96.  
  97. // ñëåä èãðîêà
  98. RGB bmSuperTrack[] = {
  99.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  100.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  101.         0x101010, 0x101010, 0x101010, 0x5310D0, 0x5310D0, 0x101010, 0x101010, 0x101010,
  102.         0x101010, 0x101010, 0x5310D0, 0x5310D0, 0x5310D0, 0x5310D0, 0x101010, 0x101010,
  103.         0x101010, 0x101010, 0x5310D0, 0x5310D0, 0x5310D0, 0x5310D0, 0x101010, 0x101010,
  104.         0x101010, 0x101010, 0x101010, 0x5310D0, 0x5310D0, 0x101010, 0x101010, 0x101010,
  105.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010,
  106.         0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010, 0x101010
  107. };
  108.  
  109.  
  110. // çàïîëíåíèå ýêðàíà äëÿ ñìåíû óðîâíÿ
  111. RGB bmFlip[] = {
  112.         0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0,
  113.         0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010,
  114.         0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0,
  115.         0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010,
  116.         0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0,
  117.         0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010,
  118.         0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0,
  119.         0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010, 0xF0F0F0, 0x101010
  120. };
  121.  
  122.  
  123. // áîíóñ íåóÿçâèìîñòè
  124. RGB bmBonus1[] = {
  125.         0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xCCCCCC,
  126.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0x44AC44, 0x44AC44, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  127.         0xFFFFFF, 0xCCCCCC, 0x44AC44, 0x44AC44, 0x44AC44, 0x44AC44, 0xCCCCCC, 0xAAAAAA,
  128.         0xFFFFFF, 0x44AC44, 0x44AC44, 0x0C8C0C, 0x0C8C0C, 0x44AC44, 0x44AC44, 0xAAAAAA,
  129.         0xFFFFFF, 0x44AC44, 0x44AC44, 0x0C8C0C, 0x0C8C0C, 0x44AC44, 0x44AC44, 0xAAAAAA,
  130.         0xFFFFFF, 0xCCCCCC, 0x44AC44, 0x44AC44, 0x44AC44, 0x44AC44, 0xCCCCCC, 0xAAAAAA,
  131.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0x44AC44, 0x44AC44, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  132.         0xCCCCCC, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA
  133. };
  134.  
  135.  
  136. // áîíóñ æèçíè
  137. RGB bmBonus2[] = {
  138.         0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xFFFFFF, 0xCCCCCC,
  139.         0xFFFFFF, 0xCCCCCC, 0xD41414, 0xCCCCCC, 0xCCCCCC, 0xD41414, 0xCCCCCC, 0xAAAAAA,
  140.         0xFFFFFF, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xAAAAAA,
  141.         0xFFFFFF, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xAAAAAA,
  142.         0xFFFFFF, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xAAAAAA,
  143.         0xFFFFFF, 0xCCCCCC, 0xD41414, 0xD41414, 0xD41414, 0xD41414, 0xCCCCCC, 0xAAAAAA,
  144.         0xFFFFFF, 0xCCCCCC, 0xCCCCCC, 0xD41414, 0xD41414, 0xCCCCCC, 0xCCCCCC, 0xAAAAAA,
  145.         0xCCCCCC, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA, 0xAAAAAA
  146. };
  147.  
  148.  
  149. //
  150. RGB bmPMButton[] = {
  151.         0xCCCCCC, 0xCCCCCC, 0x000000, 0x000000, 0xCCCCCC, 0xCCCCCC,
  152.         0xCCCCCC, 0xCCCCCC, 0x000000, 0x000000, 0xCCCCCC, 0xCCCCCC,
  153.         0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  154.         0x000000, 0x000000, 0x000000, 0x000000, 0x000000, 0x000000,
  155.         0xCCCCCC, 0xCCCCCC, 0x000000, 0x000000, 0xCCCCCC, 0xCCCCCC,
  156.         0xCCCCCC, 0xCCCCCC, 0x000000, 0x000000, 0xCCCCCC, 0xCCCCCC,
  157. };
  158.  
  159.  
  160. //
  161. void DrawAppWindow();
  162. //
  163. void DrawTop10Window();
  164. //
  165. void initWorldMap();
  166. //
  167. void drawWorldMap();
  168. //
  169. void clearWorldMap();
  170. //
  171. void drawWorldMapForFlip();
  172. //
  173. void drawWndTitleGo();
  174. //
  175. void ApplyMapDiffs( bool drawTitle = true );
  176. //
  177. int GetCompletePercents();
  178.  
  179.  
  180. #define EAT_ENEMY_BONUS         100
  181.  
  182. #define BEFORE_START_LEVEL      100
  183. #define BONUS1_LIFETIME         250
  184. #define BONUS1_IND_HSIZE        6
  185.  
  186. #define MIN_LOOP_DELAY          1
  187. #define MAX_LOOP_DELAY          20
  188. #define DEFAULT_LOOP_DELAY      12
  189.  
  190. #define blockSize                       8
  191.  
  192. #define ENTRY_CLIENT_SIZE_X     (400 - 2)
  193. #define ENTRY_CLIENT_SIZE_Y     (144 - 2 - 20)
  194.  
  195. #define TOP10_CLIENT_SIZE_X     (176 - 2)
  196. #define TOP10_CLIENT_SIZE_Y     (144 - 2 - 20)
  197.  
  198. #define MAX_X_SIZE                      96
  199. #define MIN_X_SIZE                      48
  200. #define MAX_Y_SIZE                      56
  201. #define MIN_Y_SIZE                      28
  202.  
  203. #define flipMapSize                     ((mapSizeX * mapSizeY) / 4)
  204. #define freeSpaceCount          ((mapSizeX - 4) * (mapSizeY - 4))
  205. //
  206. #define gmEmpty                         0
  207. #define gmHero                          1
  208. #define gmEnemy1                        2
  209. #define gmEnemy2                        3
  210. #define gmWall                          4
  211. #define gmTrack                         5
  212. #define gmFlip                          6
  213. #define gmBonus1                        7
  214. #define gmBonus2                        8
  215. #define gmSuperHero                     9
  216. #define gmSuperTrack            10
  217. #define gmProbe                         11
  218.  
  219. #define appStateEntry           0
  220. #define appStateGo                      1
  221. #define appStateHideMap         2
  222. #define appStateShowMap         3
  223. #define appStatePause           4
  224. #define appStateAfterDeath      5
  225. #define appStateTop10           6
  226.  
  227. #define spacePerEnemy           30
  228.  
  229.  
  230. #define BT_SIZE_X_PLUS          2
  231. #define BT_SIZE_X_MINUS         3
  232. #define BT_LOOP_PLUS            4
  233. #define BT_LOOP_MINUS           5
  234. #define BT_SIZE_Y_PLUS          6
  235. #define BT_SIZE_Y_MINUS         7
  236.  
  237. #define TOP_TBL_SIZE            10
  238.  
  239.  
  240. //
  241. struct hiScoreHero
  242. {
  243.         char name[12];
  244.         Dword score;
  245.         //
  246.         hiScoreHero()
  247.         {
  248.                 //
  249.                 this->ClearName();
  250.                 this->score = 0;
  251.         };
  252.         //
  253.         void ClearName()
  254.         {
  255.                 memset( (Byte *)(this->name), '.', sizeof(this->name) );
  256.         };
  257. };
  258.  
  259. //
  260. char top10FilePath[MAX_PATH];
  261. hiScoreHero heroTbl[TOP_TBL_SIZE];
  262.  
  263. //
  264. struct hiScoreFile
  265. {
  266.         Byte block[512];
  267.         kosFileInfo fi;
  268.         //
  269.         hiScoreFile()
  270.         {
  271.                 int i;
  272.  
  273.                 //
  274.                 this->fi.offsetLow = this->fi.offsetHigh = 0;
  275.                 this->fi.dataCount = 0;
  276.                 this->fi.bufferPtr = this->block;
  277.                 this->fi.rwMode = 0;
  278.                 memcpy( this->fi.fileURL, top10FilePath, sizeof( top10FilePath ) );
  279.                 //
  280.                 for ( i = 0; i < ( sizeof( this->block ) / sizeof( Dword ) ); i++ )
  281.                 {
  282.                         //
  283.                         ((Dword *)(this->block))[i] = rtlRand();
  284.                 }
  285.         };
  286.         //
  287.         virtual ~hiScoreFile()
  288.         {}
  289.         //
  290.         bool LoadFromDisk()
  291.         {
  292.                 bool result;
  293.                 int i;
  294.                 Dword j, k;
  295.                 Byte *bPtr;
  296.  
  297.                 //
  298.                 this->fi.rwMode = FO_READ;
  299.                 this->fi.dataCount = 512;
  300.                 result = kos_FileSystemAccess( &(this->fi) ) == 0;
  301.                 //
  302.                 if ( result )
  303.                 {
  304.                         // äåêîäèðóåì
  305.                         rtlSrand( ((Dword *)(this->block))[(sizeof(this->block) / sizeof(Dword)) - 1] );
  306.                         //
  307.                         for ( i = 0; i < (sizeof( heroTbl ) * 5); i++ )
  308.                         {
  309.                                 // íå òðîãàåì ïîñëåäíèé Dword
  310.                                 j = rtlRand() % (sizeof(this->block) - 7);
  311.                                 k = ( rtlRand() % 31 ) + 1;
  312.                                 //
  313.                                 bPtr = this->block + j;
  314.                                 //
  315.                                 __asm{
  316.                                         mov edx, bPtr
  317.                                         mov ecx, k
  318.                                         mov eax, [edx]
  319.                                         bswap eax
  320.                                         ror eax, cl
  321.                                         mov [edx], eax
  322.                                 }
  323.                         }
  324.                         //
  325.                         rtlSrand( kos_GetSystemClock() );
  326.                 }
  327.                 //
  328.                 return result;
  329.         };
  330.         //
  331.         bool SaveToDisk()
  332.         {
  333.                 int i;
  334.                 Dword *rndList;
  335.                 Byte *bPtr;
  336.                 Dword k, keyLock;
  337.  
  338.                 //
  339.                 rndList = new Dword[(sizeof( heroTbl ) * 5) * 2];
  340.                 //
  341.                 keyLock = rtlRand();
  342.                 //
  343.                 for ( i = 0; i < (sizeof( heroTbl ) * 5); i++ )
  344.                 {
  345.                         //
  346.                         rndList[i * 2] = rtlRand() % (sizeof(this->block) - 7);
  347.                         rndList[(i * 2) + 1] = ( rtlRand() % 31 ) + 1;
  348.                 }
  349.                 //
  350.                 for ( i = (sizeof( heroTbl ) * 5) - 1; i >= 0; i-- )
  351.                 {
  352.                         //
  353.                         bPtr = this->block + rndList[i * 2];
  354.                         k = rndList[(i * 2) + 1];
  355.                         //
  356.                         __asm{
  357.                                 mov edx, bPtr
  358.                                 mov ecx, k
  359.                                 mov eax, [edx]
  360.                                 rol eax, cl
  361.                                 bswap eax
  362.                                 mov [edx], eax
  363.                         }
  364.                 }
  365.                 //
  366.                 delete rndList;
  367.                 //
  368.                 ((Dword *)(this->block))[(sizeof(this->block) / sizeof(Dword)) - 1] = keyLock;
  369.                 //
  370.                 this->fi.rwMode = FO_WRITE;
  371.                 this->fi.dataCount = 512;
  372.                 return kos_FileSystemAccess( &( this->fi) ) == 0;
  373.         };
  374. };
  375.  
  376. ///
  377. hiScoreFile *top10Heroes = NULL;
  378.  
  379. sProcessInfo process_info;
  380.  
  381. // çàãîëîâîê ãëàâíîãî îêíà
  382. char MainWindowTitle[] = "XONIX (C) MMVI by Rabid Rabbit";
  383. char WindowTitle[128];
  384. char Top10WndTitle[] = "Top 10";
  385. #if LANG == RUS
  386. char goWndTitle[] = "“஢¥­ì %U, § ¢¥à襭® %U%%, ¦¨§­¥©: %U, áçñâ: %U";
  387. char goWndTitleSuperHero[] = "“஢¥­ì %U, § ¢¥à襭® %U%%, ¦¨§­¥©: %U, áçñâ: %U, á㯥ࣥன: %U%%";
  388. char menuStr1[] = "1.  ç âì ¨£àã";
  389. char menuStr2[] = "2. ‚ë室";
  390. char menuStr3[] = "“¯à ¢«¥­¨¥: ‘’…‹Šˆ - ­ ¯à ¢«¥­¨¥ ¤¢¨¦¥­¨ï.";
  391. char menuStr4[] = "SPACE - ¯ ã§ , ESC - ¢ë室 ¢ ¬¥­î.";
  392. char thatsAllStr[] = "ˆ£à  ®ª®­ç¥­ .";
  393. char worldSizeStr[] = " §¬¥à ¯®«ï %U x %U í«¥¬¥­â®¢.";
  394. char mainLoopDelayStr[] = "‘ª®à®áâì %U";
  395. char top10str1[] = "ENTER - ¨¬ï Ok.";
  396. char top10str2[] = "ESC - ¢ë室 ¢ ¬¥­î";
  397. #else
  398. char goWndTitle[] = "Level %U, completed %U%%, lives: %U, scores: %U";
  399. char goWndTitle[] = "Level %U, completed %U%%, lives: %U, scores: %U, superhero: %U%%";
  400. char menuStr1[] = "1. Start game";
  401. char menuStr2[] = "2. Exit";
  402. char menuStr3[] = "Control: ARROWS - direction of movement.";
  403. char menuStr4[] = "SPACE - pause, ESC - leave to menu.";
  404. char thatsAllStr[] = "Game finished.";
  405. char worldSizeStr[] = "Field size %U x %U cells.";
  406. char mainLoopDelayStr[] = "Speed %U";
  407. char top10str1[] = "Enter - name Ok.";
  408. char top10str2[] = "ESC - leave to menu";
  409. #endif
  410. //
  411. Byte beep1[] = { 0x90, 0x33, 0 };
  412. //
  413. Byte *heroPtr = NULL;
  414. int heroDX = 0, heroDY = 0, lastMoveDirection = 0;
  415. //
  416. Byte * worldMap = NULL;
  417. //
  418. int     wndSizeX = 0;
  419. int     wndSizeY = 0;
  420. int mapSizeX = 64;
  421. int mapSizeY = 32;
  422. int loopDelay = DEFAULT_LOOP_DELAY;
  423. int currentLevel = 1;
  424. int appState = appStateEntry;
  425. int levelFillEdge = 0;
  426. int levelFillCount = 0;
  427. int lifeCount = 0;
  428. int flipMapCount = 0;
  429. bool noBonus = false;
  430. bool goToNextLevel = false;
  431. bool bonus1Set = false;
  432. bool bonus2Set = false;
  433. int bonus1Count = 0;
  434. int currentHero = gmHero;
  435. int currentTrack = gmTrack;
  436. Dword scoreCount = 0;
  437. int enterName = -1;
  438. int enterCharNdx = 0;
  439. //
  440. MCArray<Byte*> fillList;
  441.  
  442. //
  443. struct flipMapEl
  444. {
  445.         Word x, y;
  446. };
  447.  
  448. //
  449. flipMapEl *flipMapPtr = NULL;
  450.  
  451.  
  452. //
  453. RGB *mapColours[] = {
  454.         bmEmpty,
  455.         bmHero,
  456.         bmEnemy1,
  457.         bmEnemy2,
  458.         bmWall,
  459.         bmTrack,
  460.         bmFlip,
  461.         bmBonus1,
  462.         bmBonus2,
  463.         bmSuperHero,
  464.         bmSuperTrack,
  465.         NULL
  466. };
  467.  
  468.  
  469. //
  470. struct sMapDiff
  471. {
  472.         Byte *elPtr;
  473.         Byte mapEl;
  474.         //
  475.         sMapDiff() {};
  476.         //
  477.         sMapDiff( Byte *sElPtr, Byte sMapEl )
  478.         {
  479.                 this->elPtr = sElPtr;
  480.                 this->mapEl = sMapEl;
  481.         };
  482. };
  483.  
  484.  
  485. //
  486. class CMapDiff : public MCArray<sMapDiff>
  487. {
  488. public:
  489.         virtual int Add( const sMapDiff &element )
  490.         {
  491.                 element.elPtr[0] = element.mapEl;
  492.                 return MCArray<sMapDiff>::Add( element );
  493.         }
  494. };
  495.  
  496.  
  497. //
  498. CMapDiff mapDiffList;
  499. MCArray<Byte*> sTrackList;
  500.  
  501.  
  502. //
  503. class CGenericEnemy
  504. {
  505. public:
  506.         //
  507.         Byte *ePtr;
  508.         int dx, dy;
  509.         //
  510.         virtual bool Move(void) = 0;
  511. };
  512.  
  513. class CWallEnemy : public CGenericEnemy
  514. {
  515. public:
  516.         virtual bool Move(void);
  517. };
  518.  
  519. class CSpaceEnemy : public CGenericEnemy
  520. {
  521. public:
  522.         virtual bool Move(void);
  523. };
  524.  
  525.  
  526.  
  527. //
  528. bool CWallEnemy::Move()
  529. {
  530.         int ddx;
  531.         Byte *nextPtr;
  532.         Byte mapEl, dirMap;
  533.         bool result, border;
  534.  
  535.         //
  536.         result = false;
  537.         border = false;
  538.         //
  539.         ddx = ( this->ePtr - worldMap ) % mapSizeX;
  540.         //
  541.         if ( ddx == 0 && this->dx < 0 )
  542.         {
  543.                 border = true;
  544.                 this->dx = 0 - this->dx;
  545.         }
  546.         //
  547.         if ( ddx == (mapSizeX - 1) && this->dx > 0 )
  548.         {
  549.                 border = true;
  550.                 this->dx = 0 - this->dx;
  551.         }
  552.         //
  553.         ddx = ( this->ePtr - worldMap ) / mapSizeX;
  554.         //
  555.         if ( ddx == 0 && this->dy < 0 )
  556.         {
  557.                 border = true;
  558.                 this->dy = 0 - this->dy;
  559.         }
  560.         //
  561.         if ( ddx == (mapSizeY - 1) && this->dy > 0 )
  562.         {
  563.                 border = true;
  564.                 this->dy = 0 - this->dy;
  565.         }
  566.         // ïîëó÷èì êîîðäèíàòû ìåñòà, â êîòîðîå ïîïàäàåò îáúåêò
  567.         nextPtr = this->ePtr + ( this->dx + this->dy );
  568.         // ïîëó÷èì ýëåìåíò ñ êàðòû
  569.         mapEl = nextPtr[0];
  570.         //
  571.         // â çàâèñèìîñòè îò ýëåìåíòà
  572.         switch ( mapEl )
  573.         {
  574.         // íàïîðîëèñü íà èãðîêà
  575.         case gmHero:
  576.                 if ( sTrackList.GetCount() <= 0 )
  577.                 {
  578.                         result = true;
  579.                         break;
  580.                 }
  581.  
  582.         // ïóñòîå ìåñòî, ñëåä èãðîêà èëè ãàäû íà ïîëå - íàäî îòñêàêèâàòü
  583.         case gmSuperHero:
  584.         case gmSuperTrack:
  585.         case gmTrack:
  586.         case gmEnemy2:
  587.         case gmEmpty:
  588.                 //
  589.                 dirMap = 0;
  590.                 // -dx +dy
  591.                 mapEl = this->ePtr[this->dy - this->dx];
  592.                 if ( mapEl == gmEmpty
  593.                         || mapEl == gmTrack
  594.                         || mapEl == gmEnemy2
  595.                         || mapEl == gmSuperHero
  596.                         || mapEl == gmSuperTrack
  597.                         ) dirMap |= 1;
  598.                 // +dy
  599.                 mapEl = this->ePtr[this->dy];
  600.                 if ( mapEl == gmEmpty
  601.                         || mapEl == gmTrack
  602.                         || mapEl == gmEnemy2
  603.                         || mapEl == gmSuperHero
  604.                         || mapEl == gmSuperTrack
  605.                         ) dirMap |= 2;
  606.                 // +dx
  607.                 mapEl = this->ePtr[this->dx];
  608.                 if ( mapEl == gmEmpty
  609.                         || mapEl == gmTrack
  610.                         || mapEl == gmEnemy2
  611.                         || mapEl == gmSuperHero
  612.                         || mapEl == gmSuperTrack
  613.                         ) dirMap |= 4;
  614.                 // +dx -dy
  615.                 mapEl = this->ePtr[this->dx - this->dy];
  616.                 if ( mapEl == gmEmpty
  617.                         || mapEl == gmTrack
  618.                         || mapEl == gmEnemy2
  619.                         || mapEl == gmSuperHero
  620.                         || mapEl == gmSuperTrack
  621.                         ) dirMap |= 8;
  622.                 //
  623.                 switch ( dirMap )
  624.                 {
  625.                 case 2:
  626.                 case 3:
  627.                         this->dy = 0 - this->dy;
  628.                         break;
  629.  
  630.                 case 4:
  631.                 case 12:
  632.                         this->dx = 0 - this->dx;
  633.                         break;
  634.  
  635.                 default:
  636.                         this->dx = 0 - this->dx;
  637.                         this->dy = 0 - this->dy;
  638.                         break;
  639.                 }
  640.                 //
  641.                 nextPtr = this->ePtr + ( this->dx + this->dy );
  642.                 // ïîëó÷èì ýëåìåíò ñ êàðòû
  643.                 mapEl = nextPtr[0];
  644.                 //
  645.                 switch ( mapEl )
  646.                 {
  647.                 //
  648.                 case gmHero:
  649.                         if ( sTrackList.GetCount() <= 0 )
  650.                         {
  651.                                 result = true;
  652.                         }
  653.  
  654.                 //
  655.                 case gmSuperHero:
  656.                 case gmSuperTrack:
  657.                 case gmTrack:
  658.                 case gmEmpty:
  659.                 case gmEnemy2:
  660.                         break;
  661.  
  662.                 //
  663.                 default:
  664.                         // ñòèðàåì îáúåêò
  665.                         mapDiffList.Add( sMapDiff( this->ePtr, gmWall ) );
  666.                         // ïåðåìåñòèì îáúåêò
  667.                         this->ePtr = nextPtr;
  668.                         // ðèñóåì îáúåêò ïî íîâûì êîîðäèíàòàì
  669.                         mapDiffList.Add( sMapDiff( this->ePtr, gmEnemy1 ) );
  670.                         break;
  671.                 }
  672.                 //
  673.                 break;
  674.  
  675.         // ëåòèì
  676.         default:
  677.                 // ñòèðàåì îáúåêò
  678.                 mapDiffList.Add( sMapDiff( this->ePtr, gmWall ) );
  679.                 // ïåðåìåñòèì îáúåêò
  680.                 this->ePtr = nextPtr;
  681.                 // ðèñóåì îáúåêò ïî íîâûì êîîðäèíàòàì
  682.                 mapDiffList.Add( sMapDiff( this->ePtr, gmEnemy1 ) );
  683.                 //
  684.                 break;
  685.  
  686.         }
  687.         //
  688.         return result;
  689. }
  690.  
  691. //
  692. bool CSpaceEnemy::Move()
  693. {
  694.         Byte *nextPtr;
  695.         Byte mapEl, dirMap;
  696.         bool result, heroTrack;
  697.  
  698.         //
  699.         result = false;
  700.         //
  701.         heroTrack = ( sTrackList.GetCount() > 0 );
  702.         // ïîëó÷èì êîîðäèíàòû ìåñòà, â êîòîðîå ïîïàäàåò îáúåêò
  703.         nextPtr = this->ePtr + ( this->dx + this->dy );
  704.         // ïîëó÷èì ýëåìåíò ñ êàðòû
  705.         mapEl = nextPtr[0];
  706.         // â çàâèñèìîñòè îò ýëåìåíòà
  707.         switch ( mapEl )
  708.         {
  709.         // íàïîðîëèñü íà èãðîêà èëè åãî ñëåä
  710.         case gmTrack:
  711.                 result = true;
  712.                 break;
  713.  
  714.         //
  715.         case gmHero:
  716.                 if ( heroTrack )
  717.                 {
  718.                         result = true;
  719.                         break;
  720.                 }
  721.  
  722.         // íàäî îòñêàêèâàòü
  723.         case gmSuperHero:
  724.         case gmSuperTrack:
  725.         case gmBonus1:
  726.         case gmBonus2:
  727.         case gmEnemy1:
  728.         case gmWall:
  729.                 //
  730.                 dirMap = 0;
  731.                 // -dx +dy
  732.                 mapEl = this->ePtr[this->dy - this->dx];
  733.                 if ( mapEl == gmWall ||
  734.                         mapEl == gmEnemy1 ||
  735.                         mapEl == gmBonus1 ||
  736.                         mapEl == gmBonus2 ||
  737.                         mapEl == gmSuperHero ||
  738.                         mapEl == gmSuperTrack ||
  739.                         ( mapEl == gmHero && !heroTrack )
  740.                         ) dirMap |= 1;
  741.                 // +dy
  742.                 mapEl = this->ePtr[this->dy];
  743.                 if ( mapEl == gmWall ||
  744.                         mapEl == gmEnemy1 ||
  745.                         mapEl == gmBonus1 ||
  746.                         mapEl == gmBonus2 ||
  747.                         mapEl == gmSuperHero ||
  748.                         mapEl == gmSuperTrack ||
  749.                         ( mapEl == gmHero && !heroTrack )
  750.                         ) dirMap |= 2;
  751.                 // +dx
  752.                 mapEl = this->ePtr[this->dx];
  753.                 if ( mapEl == gmWall ||
  754.                         mapEl == gmEnemy1 ||
  755.                         mapEl == gmBonus1 ||
  756.                         mapEl == gmBonus2 ||
  757.                         mapEl == gmSuperHero ||
  758.                         mapEl == gmSuperTrack ||
  759.                         ( mapEl == gmHero && !heroTrack )
  760.                         ) dirMap |= 4;
  761.                 // +dx -dy
  762.                 mapEl = this->ePtr[this->dx - this->dy];
  763.                 if ( mapEl == gmWall ||
  764.                         mapEl == gmEnemy1 ||
  765.                         mapEl == gmBonus1 ||
  766.                         mapEl == gmBonus2 ||
  767.                         mapEl == gmSuperHero ||
  768.                         mapEl == gmSuperTrack ||
  769.                         ( mapEl == gmHero && !heroTrack )
  770.                         ) dirMap |= 8;
  771.                 //
  772.                 switch ( dirMap )
  773.                 {
  774.                 case 2:
  775.                 case 3:
  776.                         this->dy = 0 - this->dy;
  777.                         break;
  778.  
  779.                 case 4:
  780.                 case 12:
  781.                         this->dx = 0 - this->dx;
  782.                         break;
  783.  
  784.                 default:
  785.                         this->dx = 0 - this->dx;
  786.                         this->dy = 0 - this->dy;
  787.                         break;
  788.                 }
  789.                 //
  790.                 nextPtr = this->ePtr + ( this->dx + this->dy );
  791.                 // ïîëó÷èì ýëåìåíò ñ êàðòû
  792.                 mapEl = nextPtr[0];
  793.                 //
  794.                 switch ( mapEl )
  795.                 {
  796.                 //
  797.                 case gmTrack:
  798.                         result = true;
  799.                         break;
  800.  
  801.                 //
  802.                 case gmHero:
  803.                         if ( heroTrack )
  804.                         {
  805.                                 result = true;
  806.                                 break;
  807.                         }
  808.  
  809.                 //
  810.                 case gmSuperHero:
  811.                 case gmSuperTrack:
  812.                 case gmBonus1:
  813.                 case gmBonus2:
  814.                 case gmWall:
  815.                 case gmEnemy1:
  816.                         break;
  817.  
  818.                 //
  819.                 default:
  820.                         // ñòèðàåì îáúåêò
  821.                         mapDiffList.Add( sMapDiff( this->ePtr, gmEmpty ) );
  822.                         // ïåðåìåñòèì îáúåêò
  823.                         this->ePtr = nextPtr;
  824.                         // ðèñóåì îáúåêò ïî íîâûì êîîðäèíàòàì
  825.                         mapDiffList.Add( sMapDiff( this->ePtr, gmEnemy2 ) );
  826.                         break;
  827.                 }
  828.                 //
  829.                 break;
  830.  
  831.         // ëåòèì
  832.         default:
  833.                 // ñòèðàåì îáúåêò
  834.                 mapDiffList.Add( sMapDiff( this->ePtr, gmEmpty ) );
  835.                 // ïåðåìåñòèì îáúåêò
  836.                 this->ePtr = nextPtr;
  837.                 // ðèñóåì îáúåêò ïî íîâûì êîîðäèíàòàì
  838.                 mapDiffList.Add( sMapDiff( this->ePtr, gmEnemy2 ) );
  839.                 //
  840.                 break;
  841.  
  842.         }
  843.         //
  844.  
  845.         //
  846.         return result;
  847. }
  848.  
  849.  
  850. //
  851. MCArray<CGenericEnemy *> mapEnemies;
  852.  
  853.  
  854. //
  855. void xonixFree(void)
  856. {
  857.         clearWorldMap();
  858.         if ( flipMapPtr != NULL )
  859.         {
  860.                 delete flipMapPtr;
  861.                 flipMapPtr = NULL;
  862.         }
  863. }
  864.  
  865.  
  866. //
  867. void checkAndSetBonus2()
  868. {
  869.         Dword i;
  870.  
  871.         //
  872.         if ( (!bonus2Set)
  873.                 && rtlRand() < 0x40000000
  874.                 && lifeCount < 3
  875.                 && GetCompletePercents() > 50 )
  876.         {
  877.                 //
  878.                 bonus2Set = true;
  879.                 //
  880.                 for ( i = rtlRand() % (mapSizeX * mapSizeY); worldMap[i] != gmWall; i = rtlRand() % (mapSizeX * mapSizeY) );
  881.                 //
  882.                 mapDiffList.Add( sMapDiff( worldMap + i, gmBonus2 ) );
  883.         }
  884. }
  885.  
  886.  
  887. //
  888. void ChangeHero()
  889. {
  890.         if ( bonus1Count < 1 )
  891.         {
  892.                 currentHero = gmHero;
  893.                 currentTrack = gmTrack;
  894.         }
  895.         else
  896.         {
  897.                 currentHero = gmSuperHero;
  898.                 currentTrack = gmSuperTrack;
  899.         }
  900. }
  901.  
  902.  
  903. //
  904. void checkAndSetBonus1()
  905. {
  906.         Dword i;
  907.  
  908.         //
  909.         if ((!bonus1Set)
  910.                 && rtlRand() > 0x80000000
  911.                 && lifeCount < 2
  912.                 && GetCompletePercents() > 75 )
  913.                
  914.         {
  915.                 //
  916.                 bonus1Set = true;
  917.                 //
  918.                 for ( i = rtlRand() % (mapSizeX * mapSizeY); worldMap[i] != gmWall; i = rtlRand() % (mapSizeX * mapSizeY) );
  919.                 //
  920.                 mapDiffList.Add( sMapDiff( worldMap + i, gmBonus1 ) );
  921.         }
  922. }
  923.  
  924.  
  925. //
  926. void CreateFlipMap(void)
  927. {
  928.         Word i, j;
  929.         int ndx, ndx2, k;
  930.         flipMapEl el;
  931.         static int lastMapSizeX = 0, lastMapSizeY = 0;
  932.  
  933.         //
  934.         if ( lastMapSizeX != mapSizeX || lastMapSizeY != mapSizeY )
  935.         {
  936.                 //
  937.                 lastMapSizeX = mapSizeX;
  938.                 lastMapSizeY = mapSizeY;
  939.                 //
  940.                 if ( flipMapPtr != NULL )
  941.                 {
  942.                         delete flipMapPtr;
  943.                         flipMapPtr = NULL;
  944.                 }
  945.         }
  946.         //
  947.         if ( flipMapPtr == NULL )
  948.         {
  949.                 flipMapPtr = new flipMapEl[flipMapSize];
  950.                 //
  951.                 ndx = 0;
  952.                 //
  953.                 for ( i = 0; i < mapSizeY; i += 2 )
  954.                 {
  955.                         for ( j = 0; j < mapSizeX; j += 2 )
  956.                         {
  957.                                 //
  958.                                 flipMapPtr[ndx].x = j;
  959.                                 flipMapPtr[ndx].y = i;
  960.                                 //
  961.                                 ndx++;
  962.                         }
  963.                 }
  964.         }
  965.         //
  966.         for ( k = 0; k < flipMapSize; k++ )
  967.         {
  968.                 //
  969.                 ndx = rtlRand() % flipMapSize;
  970.                 ndx2 = rtlRand() % flipMapSize;
  971.                 //
  972.                 el = flipMapPtr[ndx];
  973.                 flipMapPtr[ndx] = flipMapPtr[ndx2];
  974.                 flipMapPtr[ndx2] = el;
  975.         }
  976. }
  977.  
  978.  
  979. //
  980. bool ProcessEndTrack()
  981. {
  982.         int i, j, k, m;
  983.         bool noFill;
  984.         Byte *mPtr, *findPtr;
  985.  
  986.         //
  987.         j = sTrackList.GetCount();
  988.         //
  989.         scoreCount += j;
  990.         //
  991.         for ( i = 0; i < j; i++ )
  992.         {
  993.                 //
  994.                 mapDiffList.Add( sMapDiff( sTrackList[i], gmWall ) );
  995.         }
  996.         //
  997.         levelFillCount -= j;
  998.         //
  999.         sTrackList.Clear();
  1000.         //
  1001.         heroPtr += heroDX + heroDY;
  1002.         mapDiffList.Add( sMapDiff( heroPtr, currentHero ) );
  1003.         //
  1004.         heroDX = 0;
  1005.         heroDY = 0;
  1006.         lastMoveDirection = 0;
  1007.         // çàëèâêà
  1008.         mPtr = worldMap;
  1009.         //
  1010.         for ( i = 0; i < mapSizeY; i++ )
  1011.         {
  1012.                 for ( j = 0; j < mapSizeX; j++ )
  1013.                 {
  1014.                         //
  1015.                         if ( mPtr[0] == gmEmpty )
  1016.                         {
  1017.                                 //
  1018.                                 fillList.Clear();
  1019.                                 //
  1020.                                 noFill = false;
  1021.                                 //
  1022.                                 fillList.Add( mPtr );
  1023.                                 //
  1024.                                 mPtr[0] = gmProbe;
  1025.                                 //
  1026.                                 for ( k = 0; k < fillList.GetCount(); k++ )
  1027.                                 {
  1028.                                         // ñïðàâà
  1029.                                         findPtr = fillList[k] + 1;
  1030.                                         //
  1031.                                         switch ( findPtr[0] )
  1032.                                         {
  1033.                                         case gmEmpty:
  1034.                                                 fillList.Add( findPtr );
  1035.                                                 findPtr[0] = gmProbe;
  1036.                                                 break;
  1037.                                         case gmEnemy2:
  1038.                                                 noFill = true;
  1039.                                                 break;
  1040.                                         default:
  1041.                                                 break;
  1042.                                         }
  1043.                                         // ñëåâà
  1044.                                         findPtr = fillList[k] - 1;
  1045.                                         //
  1046.                                         switch ( findPtr[0] )
  1047.                                         {
  1048.                                         case gmEmpty:
  1049.                                                 fillList.Add( findPtr );
  1050.                                                 findPtr[0] = gmProbe;
  1051.                                                 break;
  1052.                                         case gmEnemy2:
  1053.                                                 noFill = true;
  1054.                                                 break;
  1055.                                         default:
  1056.                                                 break;
  1057.                                         }
  1058.                                         // ñâåðõó
  1059.                                         findPtr = fillList[k] - mapSizeX;
  1060.                                         //
  1061.                                         switch ( findPtr[0] )
  1062.                                         {
  1063.                                         case gmEmpty:
  1064.                                                 fillList.Add( findPtr );
  1065.                                                 findPtr[0] = gmProbe;
  1066.                                                 break;
  1067.                                         case gmEnemy2:
  1068.                                                 noFill = true;
  1069.                                                 break;
  1070.                                         default:
  1071.                                                 break;
  1072.                                         }
  1073.                                         // ñíèçó
  1074.                                         findPtr = fillList[k] + mapSizeX;
  1075.                                         //
  1076.                                         switch ( findPtr[0] )
  1077.                                         {
  1078.                                         case gmEmpty:
  1079.                                                 fillList.Add( findPtr );
  1080.                                                 findPtr[0] = gmProbe;
  1081.                                                 break;
  1082.                                         case gmEnemy2:
  1083.                                                 noFill = true;
  1084.                                                 break;
  1085.                                         default:
  1086.                                                 break;
  1087.                                         }
  1088.                                 }
  1089.                                 //
  1090.                                 if ( noFill )
  1091.                                 {
  1092.                                         //
  1093.                                         fillList.Clear();
  1094.                                 }
  1095.                                 else
  1096.                                 {
  1097.                                         //
  1098.                                         m = fillList.GetCount();
  1099.                                         //
  1100.                                         scoreCount += m;
  1101.                                         //
  1102.                                         for ( k = 0; k < m; k++ )
  1103.                                         {
  1104.                                                 //
  1105.                                                 mapDiffList.Add( sMapDiff( fillList[k], gmWall ) );
  1106.                                         }
  1107.                                         //
  1108.                                         levelFillCount -= m;
  1109.                                 }
  1110.                         }
  1111.                         else
  1112.                         {
  1113.                                 mPtr++;
  1114.                         }
  1115.                 }
  1116.         }
  1117.         //
  1118.         mPtr = worldMap;
  1119.         //
  1120.         for ( i = 0; i < mapSizeY; i++ )
  1121.         {
  1122.                 for ( j = 0; j < mapSizeX; j++ )
  1123.                 {
  1124.                         //
  1125.                         if ( mPtr[0] == gmProbe ) mPtr[0] = gmEmpty;
  1126.                         //
  1127.                         mPtr++;
  1128.                 }
  1129.         }
  1130.         //
  1131.         checkAndSetBonus1();
  1132.         checkAndSetBonus2();
  1133.         //
  1134.         ApplyMapDiffs();
  1135.         //
  1136.         return levelFillCount <= levelFillEdge;
  1137. }      
  1138.  
  1139.  
  1140. //
  1141. void EatEnemy( Byte *enemyPos )
  1142. {
  1143.         bool Eat = true;
  1144.         int i, j;
  1145.  
  1146.         //
  1147.         while ( Eat )
  1148.         {
  1149.                 //
  1150.                 Eat = false;
  1151.                 //
  1152.                 j = mapEnemies.GetCount();
  1153.                 //
  1154.                 for ( i = 0; i < j; i++ )
  1155.                 {
  1156.                         //
  1157.                         if ( mapEnemies[i]->ePtr == enemyPos )
  1158.                         {
  1159.                                 //
  1160.                                 delete mapEnemies[i];
  1161.                                 //
  1162.                                 mapEnemies.RemoveAt( i );
  1163.                                 //
  1164.                                 Eat = true;
  1165.                                 //
  1166.                                 scoreCount += EAT_ENEMY_BONUS;
  1167.                                 //
  1168.                                 break;
  1169.                         }
  1170.                 }
  1171.         }
  1172. }
  1173.  
  1174.  
  1175. //
  1176. bool MoveHero()
  1177. {
  1178.         int ddx;
  1179.         Byte *nextPtr;
  1180.         Byte mapEl;
  1181.         bool result;
  1182.  
  1183.         //
  1184.         if ( heroDX == 0 && heroDY == 0 ) return false;
  1185.         //
  1186.         result = false;
  1187.         //
  1188.         nextPtr = heroPtr + ( heroDX + heroDY );
  1189.         //
  1190.         ddx = ( ( heroPtr - worldMap ) % mapSizeX ) - ( ( nextPtr - worldMap ) % mapSizeX );
  1191.         //
  1192.         if ( ddx < -1 || ddx > 1 || nextPtr < worldMap || nextPtr >= ( worldMap + ( mapSizeX * mapSizeY ) ) )
  1193.         {
  1194.                 heroDX = 0;
  1195.                 heroDY = 0;
  1196.                 return false;
  1197.         }
  1198.  
  1199.  
  1200.         //
  1201.         mapEl = nextPtr[0];
  1202.         //
  1203.         if ( sTrackList.GetCount() > 0 )
  1204.         {
  1205.                 //
  1206.                 switch ( mapEl )
  1207.                 {
  1208.                 //
  1209.                 case gmEmpty:
  1210.                         sTrackList.Add( nextPtr );
  1211.                         break;
  1212.                 //
  1213.                 case gmBonus1:
  1214.                         bonus1Count = BONUS1_LIFETIME;
  1215.                         ChangeHero();
  1216.                         goToNextLevel = ProcessEndTrack();
  1217.                         return false;
  1218.                         break;
  1219.                 //
  1220.                 case gmBonus2:
  1221.                         lifeCount++;
  1222.                         goToNextLevel = ProcessEndTrack();
  1223.                         return false;
  1224.                         break;
  1225.                 //
  1226.                 case gmWall:
  1227.                         goToNextLevel = ProcessEndTrack();
  1228.                         return false;
  1229.                         break;
  1230.                 //
  1231.                 case gmEnemy1:
  1232.                         if ( bonus1Count > 0 )
  1233.                         {
  1234.                                 //
  1235.                                 EatEnemy( nextPtr );
  1236.                                 //
  1237.                                 goToNextLevel = ProcessEndTrack();
  1238.                                 //
  1239.                                 return false;
  1240.                                 break;
  1241.                         }
  1242.                         else
  1243.                         {
  1244.                                 //
  1245.                                 return true;
  1246.                         }
  1247.                         break;
  1248.                 //
  1249.                 case gmEnemy2:
  1250.                         if ( bonus1Count > 0 )
  1251.                         {
  1252.                                 //
  1253.                                 EatEnemy( nextPtr );
  1254.                                 sTrackList.Add( nextPtr );
  1255.                                 break;
  1256.                         }
  1257.                         else
  1258.                         {
  1259.                                 //
  1260.                                 return true;
  1261.                         }
  1262.                         break;
  1263.                 //
  1264.                 default:
  1265.                         return true;
  1266.                         break;
  1267.                 }
  1268.         }
  1269.         else
  1270.         {
  1271.                 //
  1272.                 switch ( mapEl )
  1273.                 {
  1274.                 //
  1275.                 case gmEmpty:
  1276.                         sTrackList.Add( nextPtr );
  1277.                         break;
  1278.                 //
  1279.                 case gmBonus1:
  1280.                         bonus1Count = BONUS1_LIFETIME;
  1281.                         break;
  1282.                 //
  1283.                 case gmBonus2:
  1284.                         lifeCount++;
  1285.                         break;
  1286.                 //
  1287.                 case gmWall:
  1288.                         break;
  1289.                 //
  1290.                 case gmEnemy1:
  1291.                         if ( bonus1Count > 0 )
  1292.                         {
  1293.                                 EatEnemy( nextPtr );
  1294.                         }
  1295.                         else
  1296.                         {
  1297.                                 result = true;
  1298.                         }
  1299.                         break;
  1300.                 //
  1301.                 case gmEnemy2:
  1302.                         if ( bonus1Count > 0 )
  1303.                         {
  1304.                                 EatEnemy( nextPtr );
  1305.                                 sTrackList.Add( nextPtr );
  1306.                         }
  1307.                         else
  1308.                         {
  1309.                                 result = true;
  1310.                         }
  1311.                         break;
  1312.                 //
  1313.                 default:
  1314.                         result = true;
  1315.                         break;
  1316.                 }
  1317.         }
  1318.  
  1319.         //
  1320.         mapDiffList.Add( sMapDiff( heroPtr, sTrackList.GetCount() <= 1 ? gmWall : currentTrack ) );
  1321.         heroPtr = nextPtr;
  1322.         mapDiffList.Add( sMapDiff( heroPtr, currentHero ) );
  1323.  
  1324.         return result;
  1325. }
  1326.  
  1327.  
  1328. //
  1329. bool MoveEnemies()
  1330. {
  1331.         bool result;
  1332.         int i, j, ir;
  1333.  
  1334.         //
  1335.         result = false;
  1336.         ir = 0;
  1337.         //
  1338.         j = mapEnemies.GetCount();
  1339.         //
  1340.         for ( i = 0; i < j; i++ )
  1341.         {
  1342.                 ir += ( mapEnemies[i]->Move() ? 1 : 0 );
  1343.         }
  1344.         //
  1345.         result = ( ir != 0 );
  1346.         //
  1347.         return result;
  1348. }
  1349.  
  1350.  
  1351. //
  1352. void ApplyMapDiffs( bool drawTitle )
  1353. {
  1354.         int i, j;
  1355.  
  1356.         //
  1357. //      kos_WindowRedrawStatus( 1 );
  1358.         //
  1359.         if ( drawTitle ) drawWndTitleGo();
  1360.         //
  1361.         j = mapDiffList.GetCount();
  1362.         //
  1363.         for ( i = 0; i < j; i++ )
  1364.         {
  1365.                 kos_PutImage(
  1366.                         mapColours[mapDiffList[i].mapEl],
  1367.                         blockSize,
  1368.                         blockSize,
  1369.                         ( ( mapDiffList[i].elPtr - worldMap ) % mapSizeX ) * blockSize,
  1370.                         ( ( mapDiffList[i].elPtr - worldMap ) / mapSizeX ) * blockSize
  1371.                         );
  1372.         }
  1373.         //
  1374. //      kos_WindowRedrawStatus( 2 );
  1375.         //
  1376.         mapDiffList.Clear();
  1377. }
  1378.  
  1379.  
  1380. //
  1381. void DeadHeroProcess()
  1382. {
  1383.         int i, j;
  1384.         Byte *mPtr = beep1;
  1385.  
  1386.         // beep
  1387.         __asm{
  1388.                 mov eax, 55
  1389.                 mov ebx, eax
  1390.                 mov esi, mPtr
  1391.                 push eax
  1392.                 int 0x40
  1393.                 pop eax
  1394.         }
  1395.         //
  1396.         j = sTrackList.GetCount();
  1397.         //
  1398.         for ( i = 0; i < j; i++ )
  1399.         {
  1400.                 //
  1401.                 mapDiffList.Add( sMapDiff( sTrackList[i], gmEmpty ) );
  1402.         }
  1403.         //
  1404.         mapDiffList.Add( sMapDiff( heroPtr, sTrackList.GetCount() > 0 ? gmEmpty : gmWall ) );
  1405.         //
  1406.         sTrackList.Clear();
  1407.         //
  1408.         heroPtr = worldMap;
  1409.         //
  1410.         while ( heroPtr[0] != gmWall ) heroPtr++;
  1411.         //
  1412.         mapDiffList.Add( sMapDiff( heroPtr, gmHero ) );
  1413.         //
  1414.         noBonus = true;
  1415.         //
  1416.         lifeCount--;
  1417.         //
  1418.         heroDX = 0;
  1419.         heroDY = 0;
  1420.         lastMoveDirection = 0;
  1421. }
  1422.  
  1423.  
  1424. //
  1425. bool CheckForNextLevel()
  1426. {
  1427.         //
  1428.         if ( goToNextLevel )
  1429.         {
  1430.                 //
  1431.                 CreateFlipMap();
  1432.                 goToNextLevel = false;
  1433.                 currentLevel++;
  1434.                 appState = appStateHideMap;
  1435.                 flipMapCount = 0;
  1436.                 return true;
  1437.         }
  1438.  
  1439.         //
  1440.         return false;
  1441. }
  1442.  
  1443.  
  1444. //
  1445. void SetGameVars()
  1446. {
  1447.         //
  1448.         currentLevel = 1;
  1449.         lifeCount = 3;
  1450.         noBonus = true;
  1451.         bonus1Set = false;
  1452.         bonus2Set = false;
  1453.         bonus1Count = 0;
  1454.         goToNextLevel = false;
  1455.         currentHero = gmHero;
  1456.         currentTrack = gmTrack;
  1457.         scoreCount = 0;
  1458.         enterName = -1;
  1459.         //
  1460.         wndSizeX = ((mapSizeX*blockSize) + 5*2);
  1461.         wndSizeY = ((mapSizeY*blockSize) + kos_GetSkinHeight() + 5);
  1462.         //
  1463.         kos_ChangeWindow( -1, -1, wndSizeX-1, wndSizeY-1 );
  1464. }
  1465.  
  1466. //
  1467. void SetEntryVars()
  1468. {
  1469.         //
  1470.         wndSizeX = ENTRY_CLIENT_SIZE_X + 5*2;
  1471.         wndSizeY = ENTRY_CLIENT_SIZE_Y + kos_GetSkinHeight() + 5;
  1472.         //
  1473.         kos_SetWindowCaption(MainWindowTitle);
  1474.         kos_ChangeWindow( -1, -1, wndSizeX-1, wndSizeY-1 );
  1475.         kos_SetKeyboardDataMode( KM_SCANS );
  1476. }
  1477.  
  1478.  
  1479. //
  1480. void __cdecl ReleaseTop10()
  1481. {
  1482.         //
  1483.         if ( top10Heroes != NULL )
  1484.         {
  1485.                 //
  1486.                 memcpy( top10Heroes->block, heroTbl, sizeof(heroTbl) );
  1487.                 //
  1488.                 top10Heroes->SaveToDisk();
  1489.                 //
  1490.                 delete top10Heroes;
  1491.         }
  1492. }
  1493.  
  1494.  
  1495. //
  1496. void PrepareTop10()
  1497. {
  1498.         //
  1499.         top10Heroes = new hiScoreFile;
  1500.         //
  1501.         atexit( ReleaseTop10 );
  1502.         //
  1503.         if ( top10Heroes->LoadFromDisk() )
  1504.         {
  1505.                 //
  1506.                 memcpy( heroTbl, top10Heroes->block, sizeof(heroTbl) );
  1507.         }
  1508. }
  1509.  
  1510.  
  1511. //
  1512. void SetUpTop10()
  1513. {
  1514.         int i, j;
  1515.         Byte keyCode;
  1516.  
  1517.         //
  1518.         while ( kos_CheckForEvent() == 2 ) kos_GetKey( keyCode );
  1519.         //
  1520.         kos_SetKeyboardDataMode( KM_CHARS );
  1521.  
  1522.         kos_SetWindowCaption(Top10WndTitle);
  1523.         //
  1524.         kos_ChangeWindow(-1, -1, TOP10_CLIENT_SIZE_X + 5 * 2 - 1, TOP10_CLIENT_SIZE_Y + kos_GetSkinHeight() + 5 - 1);
  1525.         //
  1526.         for ( i = 0; i < TOP_TBL_SIZE; i++ )
  1527.         {
  1528.                 //
  1529.                 if ( heroTbl[i].score < scoreCount )
  1530.                 {
  1531.                         //
  1532.                         for ( j = TOP_TBL_SIZE - 1; j > i; j-- )
  1533.                         {
  1534.                                 //
  1535.                                 heroTbl[j] = heroTbl[j-1];
  1536.                         }
  1537.                         //
  1538.                         heroTbl[i].ClearName();
  1539.                         heroTbl[i].score = scoreCount;
  1540.                         //
  1541.                         enterName = i;
  1542.                         enterCharNdx = 0;
  1543.                         //
  1544.                         break;
  1545.                 }
  1546.         }
  1547. }
  1548.  
  1549.  
  1550. //
  1551. // òî÷êà âõîäà è ôóíêöèÿ îáðàáîòêè ñîîáùåíèé
  1552. //
  1553. void kos_Main()
  1554. {
  1555.         Dword buttonID;
  1556.         Byte keyCode;
  1557.         Byte *bPtr;
  1558.         bool workOn = true;
  1559.         char *cPtr;
  1560.  
  1561.         wndSizeX = ENTRY_CLIENT_SIZE_X + 5 * 2;
  1562.         wndSizeY = ENTRY_CLIENT_SIZE_Y + kos_GetSkinHeight() + 5;
  1563.  
  1564.         // îòäåëÿåì èìÿ ìîäóëÿ îò ïóòè
  1565.         cPtr = strrchr( kosExePath, '/' );
  1566.         // ïðîâåðêà ;)
  1567.         if ( cPtr == NULL )
  1568.         {
  1569.                 //
  1570.                 rtlDebugOutString( "xonix: Invalid path to executable." );
  1571.                 //
  1572.                 return;
  1573.         }
  1574.         //
  1575.         cPtr[1] = 0;
  1576.         //
  1577.         strcpy( top10FilePath, kosExePath );
  1578.         //
  1579.         strcpy( top10FilePath + ((cPtr - kosExePath) + 1), "xonix.t10" );
  1580.  
  1581.         // âûïîëíåíèå ôóíêöèé èíèöèàëèçàöèè
  1582.         kos_SetKeyboardDataMode( KM_SCANS );
  1583.         //
  1584.         PrepareTop10();
  1585.  
  1586.         //
  1587.         while( workOn )
  1588.         {
  1589.                 switch ( appState )
  1590.                 {
  1591.                 //
  1592.                 case appStateEntry:
  1593.                         switch ( kos_WaitForEvent() )
  1594.                         {
  1595.                         // ïåðåðèñîâêà îêíà
  1596.                         case 1:
  1597.                                 DrawAppWindow();
  1598.                                 break;
  1599.  
  1600.                         //
  1601.                         case 2:
  1602.                                 kos_GetKey( keyCode );
  1603.                                 switch ( keyCode )
  1604.                                 {
  1605.                                 //
  1606.                                 case 2:
  1607.                                         //
  1608.                                         appState = appStateGo;
  1609.                                         SetGameVars();
  1610.                                         initWorldMap();
  1611. //                                      DrawAppWindow();
  1612.                                         break;
  1613.  
  1614.                                 //
  1615.                                 case 3:
  1616.                                         xonixFree();
  1617.                                         workOn = false;
  1618.                                         break;
  1619.                                 }
  1620.                                 break;
  1621.                         //
  1622.                         case 3:
  1623.                                 //
  1624.                                 if ( ! kos_GetButtonID( buttonID ) ) break;
  1625.                                 //
  1626.                                 switch ( buttonID )
  1627.                                 {
  1628.                                 //
  1629.                                 case BT_SIZE_X_PLUS:
  1630.                                         mapSizeX += 2;
  1631.                                         if ( mapSizeX > MAX_X_SIZE ) mapSizeX = MAX_X_SIZE;
  1632.                                         break;
  1633.                                 //
  1634.                                 case BT_SIZE_X_MINUS:
  1635.                                         mapSizeX -= 2;
  1636.                                         if ( mapSizeX < MIN_X_SIZE ) mapSizeX = MIN_X_SIZE;
  1637.                                         break;
  1638.                                 //
  1639.                                 case BT_SIZE_Y_PLUS:
  1640.                                         mapSizeY += 2;
  1641.                                         if ( mapSizeY > MAX_Y_SIZE ) mapSizeY = MAX_Y_SIZE;
  1642.                                         break;
  1643.                                 //
  1644.                                 case BT_SIZE_Y_MINUS:
  1645.                                         mapSizeY -= 2;
  1646.                                         if ( mapSizeY < MIN_Y_SIZE ) mapSizeY = MIN_Y_SIZE;
  1647.                                         break;
  1648.                                 //
  1649.                                 case BT_LOOP_MINUS:
  1650.                                         loopDelay++;
  1651.                                         if ( loopDelay > MAX_LOOP_DELAY ) loopDelay = MAX_LOOP_DELAY;
  1652.                                         break;
  1653.                                 //
  1654.                                 case BT_LOOP_PLUS:
  1655.                                         loopDelay--;
  1656.                                         if ( loopDelay < MIN_LOOP_DELAY ) loopDelay = MIN_LOOP_DELAY;
  1657.                                         break;
  1658.                                 case 1:
  1659.                                         xonixFree();
  1660.                                         workOn = false;
  1661.                                         break;
  1662.                                 //
  1663.                                 default:
  1664.                                         break;
  1665.                                 }
  1666.                                 DrawAppWindow();
  1667.                                 break;
  1668.                         //
  1669.                         default:
  1670.                                 break;
  1671.                         }
  1672.                         break;
  1673.                 //
  1674.                 case appStateGo:
  1675.                         //
  1676.                         kos_Pause( loopDelay );
  1677.                         //
  1678.                         if ( bonus1Count > 0 ) bonus1Count--;
  1679.                         //
  1680.                         ChangeHero();
  1681.                         //
  1682.                         switch( kos_WaitForEvent( 1 ) )
  1683.                         {
  1684.                         //
  1685.                         case 0:
  1686.                                 if ( MoveHero() )
  1687.                                 {
  1688.                                         //
  1689.                                         DeadHeroProcess();
  1690.                                 }
  1691.                                 else
  1692.                                 {
  1693.                                         //
  1694.                                         if ( CheckForNextLevel() )
  1695.                                         {
  1696.                                                 break;
  1697.                                         }
  1698.                                 }
  1699.                                 if ( MoveEnemies() )
  1700.                                 {
  1701.                                         // ñîæðàëè èãðîêà
  1702.                                         DeadHeroProcess();
  1703.                                 }
  1704.                                 ApplyMapDiffs();
  1705.                                 break;
  1706.                         //
  1707.                         case 1:
  1708.                                 DrawAppWindow();
  1709.                                 break;
  1710.  
  1711.                         //
  1712.                         case 2:
  1713.                                 do kos_GetKey( keyCode ); while ( keyCode & 0x80 );
  1714.                                 switch ( keyCode )
  1715.                                 {
  1716.                                 //
  1717.                                 case 0x1:
  1718.                                         SetEntryVars();
  1719.                                         appState = appStateEntry;
  1720.                                         clearWorldMap();
  1721.                                         DrawAppWindow();
  1722.                                         continue;
  1723.  
  1724.                                 //
  1725.                                 case 0x39:
  1726.                                         appState = appStatePause;
  1727.                                         break;
  1728.  
  1729.                                 //
  1730.                                 case 0x48:
  1731.                                         heroDX = 0;
  1732.                                         if ( lastMoveDirection == 0x50 )
  1733.                                         {
  1734.                                                 heroDY = 0;
  1735.                                                 lastMoveDirection = 0;
  1736.                                         }
  1737.                                         else
  1738.                                         {
  1739.                                                 heroDY = -mapSizeX;
  1740.                                                 lastMoveDirection = 0x48;
  1741.                                         }
  1742.                                         break;
  1743.  
  1744.                                 //
  1745.                                 case 0x50:
  1746.                                         heroDX = 0;
  1747.                                         if ( lastMoveDirection == 0x48 )
  1748.                                         {
  1749.                                                 heroDY = 0;
  1750.                                                 lastMoveDirection = 0;
  1751.                                         }
  1752.                                         else
  1753.                                         {
  1754.                                                 heroDY = mapSizeX;
  1755.                                                 lastMoveDirection = 0x50;
  1756.                                         }
  1757.                                         break;
  1758.  
  1759.                                 //
  1760.                                 case 0x4B:
  1761.                                         heroDY = 0;
  1762.                                         if ( lastMoveDirection == 0x4D )
  1763.                                         {
  1764.                                                 heroDX = 0;
  1765.                                                 lastMoveDirection = 0;
  1766.                                         }
  1767.                                         else
  1768.                                         {
  1769.                                                 heroDX = -1;
  1770.                                                 lastMoveDirection = 0x4B;
  1771.                                         }
  1772.                                         break;
  1773.  
  1774.                                 //
  1775.                                 case 0x4D:
  1776.                                         heroDY = 0;
  1777.                                         if ( lastMoveDirection == 0x4B )
  1778.                                         {
  1779.                                                 heroDX = 0;
  1780.                                                 lastMoveDirection = 0;
  1781.                                         }
  1782.                                         else
  1783.                                         {
  1784.                                                 heroDX = 1;
  1785.                                                 lastMoveDirection = 0x4D;
  1786.                                         }
  1787.                                         break;
  1788.                                 }
  1789.                                 //
  1790.                                 if ( MoveHero() )
  1791.                                 {
  1792.                                         //
  1793.                                         DeadHeroProcess();
  1794.                                 }
  1795.                                 else
  1796.                                 {
  1797.                                         //
  1798.                                         if ( CheckForNextLevel() )
  1799.                                         {
  1800.                                                 break;
  1801.                                         }
  1802.                                 }
  1803.                                 if ( MoveEnemies() )
  1804.                                 {
  1805.                                         // ñîæðàëè èãðîêà
  1806.                                         DeadHeroProcess();
  1807.                                 }
  1808.                                 ApplyMapDiffs();
  1809.                                 break;
  1810.  
  1811.                         //
  1812.                         case 3:
  1813.                                 kos_GetButtonID(buttonID);
  1814.                                 if (buttonID == 1)
  1815.                                 {
  1816.                                         xonixFree();
  1817.                                         workOn = false;
  1818.                                 }
  1819.                                 break;
  1820.                         default:
  1821.                                 //
  1822.                                 if ( MoveHero() )
  1823.                                 {
  1824.                                         //
  1825.                                         DeadHeroProcess();
  1826.                                 }
  1827.                                 if ( MoveEnemies() )
  1828.                                 {
  1829.                                         // ñîæðàëè èãðîêà
  1830.                                         DeadHeroProcess();
  1831.                                 }
  1832.                                 ApplyMapDiffs();
  1833.                                 break;
  1834.                         }
  1835.                         //
  1836.                         if ( lifeCount <= 0 )
  1837.                         {
  1838.                                 appState = appStateAfterDeath;
  1839.                                 DrawAppWindow();
  1840.                         }
  1841.                         //
  1842.                         break;
  1843.  
  1844.                 //
  1845.                 case appStateAfterDeath:
  1846.                         switch ( kos_WaitForEvent() )
  1847.                         {
  1848.                         //
  1849.                         case 1:
  1850.                                 DrawAppWindow();
  1851.                                 break;
  1852.                         //
  1853.                         case 2:
  1854.                                 do kos_GetKey( keyCode ); while ( keyCode & 0x80 );
  1855.                                 if ( keyCode != 0 )
  1856.                                 {
  1857.                                         //
  1858.                                         appState = appStateTop10;
  1859.                                         SetUpTop10();
  1860.                                         DrawAppWindow();
  1861.                                 }
  1862.                                 break;
  1863.                         //
  1864.                         case 3:
  1865.                                 kos_GetButtonID(buttonID);
  1866.                                 if ( buttonID == 1 )
  1867.                                 {
  1868.                                         //
  1869.                                         appState = appStateTop10;
  1870.                                         SetUpTop10();
  1871.                                         DrawAppWindow();
  1872.                                 }
  1873.                         //
  1874.                         default:
  1875.                                 break;
  1876.                         }
  1877.                         break;
  1878.  
  1879.                 //
  1880.                 case appStateTop10:
  1881.                         switch ( kos_WaitForEvent() )
  1882.                         {
  1883.                         //
  1884.                         case 1:
  1885.                                 DrawAppWindow();
  1886.                                 break;
  1887.                         //
  1888.                         case 2:
  1889.                                 //
  1890.                                 kos_GetKey( keyCode );
  1891.                                 //
  1892.                                 if ( enterName < 0 )
  1893.                                 {
  1894.                                         //
  1895.                                         if ( keyCode == 0x1b )
  1896.                                         {
  1897.                                                 //
  1898.                                                 SetEntryVars();
  1899.                                                 clearWorldMap();
  1900.                                                 appState = appStateEntry;
  1901.                                                 DrawAppWindow();
  1902.                                         }
  1903.                                 }
  1904.                                 else
  1905.                                 {
  1906.                                         //
  1907.                                         switch ( keyCode )
  1908.                                         {
  1909.                                         //
  1910.                                         case 13:
  1911.                                                 //
  1912.                                                 enterName = -1;
  1913.                                                 break;
  1914.                                         //
  1915.                                         case 8:
  1916.                                                 //
  1917.                                                 if ( enterCharNdx > 0 )
  1918.                                                 {
  1919.                                                         //
  1920.                                                         heroTbl[enterName].name[--enterCharNdx] = '.';
  1921.                                                 }
  1922.                                                 break;
  1923.                                         //
  1924.                                         default:
  1925.                                                 if ( keyCode >= 0x20 )
  1926.                                                 {
  1927.                                                         //
  1928.                                                         heroTbl[enterName].name[enterCharNdx++] = keyCode;
  1929.                                                         //
  1930.                                                         if ( enterCharNdx >= sizeof(heroTbl[0].name) )
  1931.                                                         {
  1932.                                                                 //
  1933.                                                                 enterName = -1;
  1934.                                                         }
  1935.                                                 }
  1936.                                                 break;
  1937.                                         }
  1938.                                         //
  1939.                                         DrawAppWindow();
  1940.                                 }
  1941.                                 //
  1942.                                 break;
  1943.                         //
  1944.                         case 3:
  1945.                                 kos_GetButtonID(buttonID);
  1946.                                 if (buttonID == 1)
  1947.                                 {
  1948.                                         xonixFree();
  1949.                                         workOn = false;
  1950.                                 }
  1951.                                 break;
  1952.                         default:
  1953.                                 break;
  1954.                         }
  1955.                         break;
  1956.  
  1957.                 //
  1958.                 case appStatePause:
  1959.                         switch ( kos_WaitForEvent() )
  1960.                         {
  1961.                         case 1:
  1962.                                 DrawAppWindow();
  1963.                                 break;
  1964.  
  1965.                         case 2:
  1966.                                 do kos_GetKey( keyCode ); while ( keyCode & 0x80 );
  1967.                                 if ( keyCode != 0 )
  1968.                                 {
  1969.                                         //
  1970.                                         appState = appStateGo;
  1971.                                 }
  1972.                                 break;
  1973.                         case 3:
  1974.                                 kos_GetButtonID(buttonID);
  1975.                                 if (buttonID == 1)
  1976.                                 {
  1977.                                         xonixFree();
  1978.                                         workOn = false;
  1979.                                 }
  1980.                                 break;
  1981.                         default:
  1982.                                 break;
  1983.                         }
  1984.                         break;
  1985.  
  1986.                 //
  1987.                 case appStateHideMap:
  1988.                         //
  1989.                         switch ( kos_WaitForEvent( 1 ) )
  1990.                         {
  1991.                         case 1:
  1992.                                 DrawAppWindow();
  1993.                                 break;
  1994.                         case 2:
  1995.                                 while ( kos_GetKey( keyCode ) );
  1996.                                 break;
  1997.                         default:
  1998.                                 bPtr = worldMap + (flipMapPtr[flipMapCount].x + (flipMapPtr[flipMapCount].y * mapSizeX));
  1999.                                 mapDiffList.Add( sMapDiff( bPtr, gmFlip ) );
  2000.                                 mapDiffList.Add( sMapDiff( bPtr + 1, gmFlip ) );
  2001.                                 mapDiffList.Add( sMapDiff( bPtr + mapSizeX, gmFlip ) );
  2002.                                 mapDiffList.Add( sMapDiff( bPtr + (mapSizeX + 1), gmFlip ) );
  2003.                                 ApplyMapDiffs( false );
  2004.                                 break;
  2005.                         }
  2006.                         //
  2007.                         flipMapCount++;
  2008.                         //
  2009.                         if ( flipMapCount >= flipMapSize )
  2010.                         {
  2011.                                 flipMapCount = 0;
  2012.                                 appState = appStateShowMap;
  2013.                                 DrawAppWindow();
  2014.                         }
  2015.                         break;
  2016.                 //
  2017.                 case appStateShowMap:
  2018.                         //
  2019.                         switch ( kos_WaitForEvent( 1 ) )
  2020.                         {
  2021.                         case 1:
  2022.                                 DrawAppWindow();
  2023.                                 break;
  2024.                         default:
  2025.                                 break;
  2026.                         }
  2027.                         //
  2028.                         flipMapCount++;
  2029.                         //
  2030.                         if ( flipMapCount >= BEFORE_START_LEVEL )
  2031.                         {
  2032.                                 clearWorldMap();
  2033.                                 flipMapCount = 0;
  2034.                                 initWorldMap();
  2035.                                 appState = appStateGo;
  2036.                                 DrawAppWindow();
  2037.                         }
  2038.                         //
  2039.                         break;
  2040.                 }
  2041.         }
  2042. }
  2043.  
  2044.  
  2045. //
  2046. void DrawEntryScreen()
  2047. {
  2048.         PRINTK pr;
  2049.         char line[64];
  2050.         //
  2051.         kos_DefineAndDrawWindow(
  2052.                 100, 100,
  2053.                 wndSizeX-1, wndSizeY-1,
  2054.                 0x34, 0,
  2055.                 0, 0,
  2056.                 MainWindowTitle
  2057.                 );
  2058.         //
  2059.         if (process_info.processInfo.window_state & 0x06)
  2060.                 return;
  2061.  
  2062.         /*
  2063.         kos_WriteTextToWindow(
  2064.                 4, 4,
  2065.                 0x10, 0x42D2E2,
  2066.                 MainWindowTitle,
  2067.                 sizeof( MainWindowTitle ) - 1
  2068.                 );
  2069.                 */
  2070.         //
  2071.         kos_WriteTextToWindow(
  2072.                 8-1, 32-21,
  2073.                 0x10, 0x12FF12,
  2074.                 menuStr1,
  2075.                 sizeof( menuStr1 ) - 1
  2076.                 );
  2077.         //
  2078.         kos_WriteTextToWindow(
  2079.                 8-1, 48-21,
  2080.                 0x10, 0x12FF12,
  2081.                 menuStr2,
  2082.                 sizeof( menuStr2 ) - 1
  2083.                 );
  2084.         //
  2085.         kos_WriteTextToWindow(
  2086.                 8-1, 80-21,
  2087.                 0x10, 0xD0FF12,
  2088.                 menuStr3,
  2089.                 sizeof( menuStr3 ) - 1
  2090.                 );
  2091.         //
  2092.         kos_WriteTextToWindow(
  2093.                 8-1, 96-21,
  2094.                 0x10, 0xD0FF12,
  2095.                 menuStr4,
  2096.                 sizeof( menuStr4 ) - 1
  2097.                 );
  2098.         // ðàçìåð ïîëÿ
  2099.         pr.fmtline = worldSizeStr;
  2100.         pr.args[0] = mapSizeX;
  2101.         pr.args[1] = mapSizeY;
  2102.         sprintk( line, &pr );
  2103.         //
  2104.         kos_WriteTextToWindow(
  2105.                 8-1, 112-21,
  2106.                 0x10, 0x12C0D0,
  2107.                 line,
  2108.                 strlen( line )
  2109.                 );
  2110.         // êíîïêè X
  2111.         // xo oo
  2112.         //        oo
  2113.         kos_DefineButton(
  2114.                 ENTRY_CLIENT_SIZE_X - 62, 112-24,
  2115.                 13, 13,
  2116.                 BT_SIZE_X_MINUS,
  2117.                 0xCCCCCC
  2118.                 );
  2119.         //
  2120.         kos_PutImage( bmPMButton + 12, 6, 2, ENTRY_CLIENT_SIZE_X - (62-1) + 3, 117-23 );
  2121.         //
  2122.         // ox oo
  2123.         //        oo
  2124.         kos_DefineButton(
  2125.                 ENTRY_CLIENT_SIZE_X - 48, 112-24,
  2126.                 13, 13,
  2127.                 BT_SIZE_X_PLUS,
  2128.                 0xCCCCCC
  2129.                 );
  2130.         //
  2131.         kos_PutImage( bmPMButton, 6, 6, ENTRY_CLIENT_SIZE_X - (48-1) + 3, 115-23 );
  2132.         // êíîïêè Y
  2133.         // oo xo
  2134.         //        oo
  2135.         kos_DefineButton(
  2136.                 ENTRY_CLIENT_SIZE_X - 31, 112-24,
  2137.                 13, 13,
  2138.                 BT_SIZE_Y_MINUS,
  2139.                 0xCCCCCC
  2140.                 );
  2141.         //
  2142.         kos_PutImage( bmPMButton + 12, 6, 2, ENTRY_CLIENT_SIZE_X - (31-1) + 3, 117-23 );
  2143.         //
  2144.         // oo ox
  2145.         //        oo
  2146.         kos_DefineButton(
  2147.                 ENTRY_CLIENT_SIZE_X - 17, 112-24,
  2148.                 13, 13,
  2149.                 BT_SIZE_Y_PLUS,
  2150.                 0xCCCCCC
  2151.                 );
  2152.         //
  2153.         kos_PutImage( bmPMButton, 6, 6, ENTRY_CLIENT_SIZE_X - (17-1) + 3, 115-23 );
  2154.         //
  2155.         //çàäåðæêà â öèêëå âûáîðêè ñîîáùåíèé
  2156.         pr.fmtline = mainLoopDelayStr;
  2157.         pr.args[0] = MAX_LOOP_DELAY + MIN_LOOP_DELAY - loopDelay;
  2158.         sprintk( line, &pr );
  2159.         //
  2160.         kos_WriteTextToWindow(
  2161.                 8-1, 128-21,
  2162.                 0x10, 0x12C0D0,
  2163.                 line,
  2164.                 strlen( line )
  2165.                 );
  2166.         //
  2167.         kos_DefineButton(
  2168.                 ENTRY_CLIENT_SIZE_X - 31, 128-23,
  2169.                 13, 13,
  2170.                 BT_LOOP_MINUS,
  2171.                 0xCCCCCC
  2172.                 );
  2173.         //
  2174.         kos_PutImage( bmPMButton + 12, 6, 2, ENTRY_CLIENT_SIZE_X - (31-1) + 3, 133-22 );
  2175.         //
  2176.         kos_DefineButton(
  2177.                 ENTRY_CLIENT_SIZE_X - 17, 128-23,
  2178.                 13, 13,
  2179.                 BT_LOOP_PLUS,
  2180.                 0xCCCCCC
  2181.                 );
  2182.         //
  2183.         kos_PutImage( bmPMButton, 6, 6, ENTRY_CLIENT_SIZE_X - (17-1) + 3, 131-22 );
  2184. }
  2185.  
  2186.  
  2187. //
  2188. void DrawAppWindow()
  2189. {
  2190.         kos_WindowRedrawStatus( 1 );
  2191.         kos_ProcessInfo(&process_info, -1);
  2192.  
  2193.         switch (appState)
  2194.         {
  2195.                 //
  2196.         case appStateTop10:
  2197.                 DrawTop10Window();
  2198.                 break;
  2199.                 //
  2200.         case appStateEntry:
  2201.                 //
  2202.                 DrawEntryScreen();
  2203.                 break;
  2204.                 //
  2205.         case appStateGo:
  2206.         case appStateShowMap:
  2207.         case appStatePause:
  2208.                 if (process_info.processInfo.window_state & 0x06)
  2209.                 {
  2210.                         appState = appStatePause;
  2211.                 }
  2212.                 drawWorldMap();
  2213.                 break;
  2214.                 //
  2215.         case appStateAfterDeath:
  2216.                 //
  2217.                 drawWorldMap();
  2218.                 //
  2219.                 kos_DefineButton(
  2220.                         ((wndSizeX - 10) / 2) - 64,
  2221.                         ((wndSizeY - kos_GetSkinHeight() - 5) / 2) - 16,
  2222.                         128, 32,
  2223.                         1,
  2224.                         0x136793
  2225.                         );
  2226.                 //
  2227.                 kos_WriteTextToWindow(
  2228.                         ((wndSizeX - 10) / 2) - (sizeof(thatsAllStr)* 4),
  2229.                         ((wndSizeY - kos_GetSkinHeight() - 5) / 2) - 4,
  2230.                         0x10, 0xFFFFFF,
  2231.                         thatsAllStr,
  2232.                         sizeof (thatsAllStr)-1
  2233.                         );
  2234.                         //
  2235.                 break;
  2236.                 //
  2237.         case appStateHideMap:
  2238.                 drawWorldMapForFlip();
  2239.                 break;
  2240.         }
  2241.         //
  2242.         kos_WindowRedrawStatus( 2 );
  2243. }
  2244.  
  2245.  
  2246. //
  2247. void initWorldMap()
  2248. {
  2249.         int i, j, m, allocSize;
  2250.         CWallEnemy *we;
  2251.         CSpaceEnemy *se;
  2252.  
  2253.         //
  2254.         allocSize = mapSizeX * mapSizeY;
  2255.         worldMap = new Byte[allocSize];
  2256.         //
  2257.         __asm{
  2258.                 mov edi, worldMap
  2259.                 mov ecx, allocSize
  2260.                 mov al, gmEmpty
  2261.                 rep stosb
  2262.         }
  2263.  
  2264.  
  2265.         //
  2266.         levelFillEdge = ( ( currentLevel + 1 ) * spacePerEnemy ) + currentLevel;
  2267.         levelFillCount = freeSpaceCount;
  2268.         //
  2269.         if ( ! noBonus )
  2270.         {
  2271.                 lifeCount++;
  2272.         }
  2273.         //
  2274.         noBonus = false;
  2275.         bonus1Set = false;
  2276.         bonus2Set = false;
  2277.         bonus1Count = 0;
  2278.         goToNextLevel = false;
  2279.         currentHero = gmHero;
  2280.         currentTrack = gmTrack;
  2281.  
  2282.         //
  2283.         for ( i = 0; i < mapSizeX; i++ )
  2284.         {
  2285.                 //
  2286.                 worldMap[i] = gmWall;
  2287.                 worldMap[mapSizeX + i] = gmWall;
  2288.                 //
  2289.                 worldMap[((mapSizeY-2)*mapSizeX) + i] = gmWall;
  2290.                 worldMap[((mapSizeY-1)*mapSizeX) + i] = gmWall;
  2291.         }
  2292.         //
  2293.         for ( i = 2; i < (mapSizeY-2); i++ )
  2294.         {
  2295.                 //
  2296.                 worldMap[(i*mapSizeX)] = gmWall;
  2297.                 worldMap[(i*mapSizeX) + 1] = gmWall;
  2298.                 worldMap[(i*mapSizeX) + mapSizeX - 2] = gmWall;
  2299.                 worldMap[(i*mapSizeX) + mapSizeX - 1] = gmWall;
  2300.         }
  2301.         //
  2302.         heroPtr = worldMap + ( mapSizeX / 2 );
  2303.         heroPtr[0] = gmHero;
  2304.         heroDX = 0;
  2305.         heroDY = 0;
  2306.         //
  2307.         for ( i = 0; i < currentLevel; i++ )
  2308.         {
  2309.                 //
  2310.                 for (
  2311.                         j = ( rtlRand() % (mapSizeX * (mapSizeY - 2)) ) + (mapSizeX * 2);
  2312.                         worldMap[j] != gmWall;
  2313.                         j = rtlRand() % (mapSizeX * mapSizeY)
  2314.                         );
  2315.                 //
  2316.                 we = new CWallEnemy();
  2317.                 //
  2318.                 we->ePtr = worldMap + j;
  2319.                 we->dx = rtlRand() & 1 ? 1 : -1;
  2320.                 we->dy = rtlRand() & 1 ? mapSizeX : -mapSizeX;
  2321.                 //
  2322.                 mapEnemies.Add( we );
  2323.                 //
  2324.                 worldMap[j] = gmEnemy1;
  2325.         }
  2326.         //
  2327.         m = currentLevel + 1;
  2328.         //
  2329.         for ( i = 0; i < m; i++ )
  2330.         {
  2331.                 //
  2332.                 for (
  2333.                         j = rtlRand() % (mapSizeX * mapSizeY);
  2334.                         worldMap[j] != gmEmpty;
  2335.                         j = rtlRand() % (mapSizeX * mapSizeY)
  2336.                         );
  2337.                 //
  2338.                 se = new CSpaceEnemy();
  2339.                 //
  2340.                 se->ePtr = worldMap + j;
  2341.                 se->dx = rtlRand() & 1 ? 1 : -1;
  2342.                 se->dy = rtlRand() & 1 ? mapSizeX : -mapSizeX;
  2343.                 //
  2344.                 mapEnemies.Add( se );
  2345.                 //
  2346.                 worldMap[j] = gmEnemy2;
  2347.         }
  2348. }
  2349.  
  2350.  
  2351. //
  2352. void drawWorldMap()
  2353. {
  2354.         //
  2355.         kos_DefineAndDrawWindow(
  2356.                 100, 100,
  2357.                 wndSizeX-1, wndSizeY-1,
  2358.                 0x74, 0,
  2359.                 0, 0,
  2360.                 MainWindowTitle
  2361.                 );
  2362.         //
  2363.         drawWndTitleGo();
  2364.         //
  2365.         drawWorldMapForFlip();
  2366. }
  2367.  
  2368.  
  2369. //
  2370. int GetCompletePercents()
  2371. {
  2372.         int n1, n2;
  2373.  
  2374.         //
  2375.         n1 = freeSpaceCount - levelFillCount;
  2376.         n2 = freeSpaceCount - levelFillEdge;
  2377.         //
  2378.         return ( n1 >= n2 ) ? 100 : ( n1 * 100 ) / n2;
  2379. }
  2380.  
  2381.  
  2382. //
  2383. void drawWndTitleGo()
  2384. {
  2385.         PRINTK pr;
  2386.         static char prev_title[64] = {'\0'};
  2387.  
  2388.         //
  2389.         /*
  2390.         kos_DrawBar(
  2391.                 1, 1,
  2392.                 wndSizeX - 2, 18,
  2393.                 0x2040A0
  2394.                 );
  2395.                 */
  2396.         //
  2397.         //pr.fmtline = goWndTitle;
  2398.         pr.args[0] = currentLevel;
  2399.         pr.args[1] = GetCompletePercents();
  2400.         pr.args[2] = lifeCount;
  2401.         pr.args[3] = scoreCount;
  2402.  
  2403.         if (bonus1Count > 0)
  2404.         {
  2405.                 pr.args[4] = 100*bonus1Count/BONUS1_LIFETIME;
  2406.                 pr.fmtline = goWndTitleSuperHero;
  2407.         }
  2408.         else
  2409.         {
  2410.                 pr.fmtline = goWndTitle;
  2411.                
  2412.         }
  2413.         sprintk(WindowTitle, &pr);
  2414.         //
  2415.         bool same = true;
  2416.         for (int i = 0; i < 64; i++)
  2417.         {
  2418.                 if (WindowTitle[i] != prev_title[i])
  2419.                 {
  2420.                         same = false;
  2421.                         break;
  2422.                 }
  2423.                 if ((WindowTitle[i] == '\0') || (prev_title[i] == '\0'))
  2424.                 {
  2425.                         break;
  2426.                 }
  2427.  
  2428.         }
  2429.  
  2430.         if (!same)
  2431.         {
  2432.                 kos_SetWindowCaption(WindowTitle);
  2433.                 strcpy(prev_title, WindowTitle);
  2434.         }
  2435.        
  2436.                 /*
  2437.         kos_WriteTextToWindow(
  2438.                 4, 4,
  2439.                 0x10, 0x42D2E2,
  2440.                 line,
  2441.                 strlen( line )
  2442.                 );
  2443.                 */
  2444.         //
  2445.         /*
  2446.         if ( bonus1Count > 0 )
  2447.         {
  2448.                 //
  2449.                 kos_DrawBar(
  2450.                         2, 22 - BONUS1_IND_HSIZE - 1,
  2451.                         wndSizeX - 4, BONUS1_IND_HSIZE,
  2452.                         0x2040A0
  2453.                         );
  2454.                 //
  2455.                 kos_DrawBar(
  2456.                         2, 22 - BONUS1_IND_HSIZE - 1,
  2457.                         ( bonus1Count * ( wndSizeX - 4 ) ) / BONUS1_LIFETIME, BONUS1_IND_HSIZE,
  2458.                         0x5720B0
  2459.                         );
  2460.                        
  2461.         }*/
  2462. }
  2463.  
  2464. //
  2465. void drawWorldMapForFlip()
  2466. {
  2467.         int i, j;
  2468.         Byte *mPtr = worldMap;
  2469.  
  2470.         if (process_info.processInfo.window_state & 0x06)
  2471.                 return;
  2472.         //
  2473.         for ( i = 0; i < mapSizeY; i++ )
  2474.         {
  2475.                 //
  2476.                 for ( j = 0; j < mapSizeX; j++ )
  2477.                 {
  2478.                         kos_PutImage(
  2479.                                 mapColours[*mPtr],
  2480.                                 blockSize,
  2481.                                 blockSize,
  2482.                                 j * blockSize,
  2483.                                 i * blockSize
  2484.                                 );
  2485.                         //
  2486.                         mPtr++;
  2487.                 }
  2488.         }
  2489. }
  2490.  
  2491.  
  2492. //
  2493. void clearWorldMap()
  2494. {
  2495.         int i, j;
  2496.  
  2497.         //
  2498.         sTrackList.Clear();
  2499.         fillList.Clear();
  2500.         mapDiffList.Clear();
  2501.         //
  2502.         j = mapEnemies.GetCount();
  2503.         //
  2504.         for ( i = 0; i < j; i++ )
  2505.         {
  2506.                 //
  2507.                 delete mapEnemies[i];
  2508.         }
  2509.         //
  2510.         mapEnemies.Clear();
  2511.         //
  2512.         if ( worldMap != NULL )
  2513.         {
  2514.                 delete worldMap;
  2515.                 worldMap = NULL;
  2516.         }
  2517. }
  2518.  
  2519.  
  2520. //
  2521. void DrawTop10Window()
  2522. {
  2523.         int i;
  2524.  
  2525.         //
  2526.         kos_DefineAndDrawWindow(
  2527.                 100, 100,
  2528.                 0, 0,
  2529.                 0x34, 0,
  2530.                 0, 0,
  2531.                 Top10WndTitle
  2532.                 );
  2533.         //
  2534.         if (process_info.processInfo.window_state & 0x06)
  2535.                 return;
  2536.         /*
  2537.         kos_WriteTextToWindow(
  2538.                 4, 4,
  2539.                 0x0, 0x42D2E2,
  2540.                 Top10WndTitle,
  2541.                 sizeof( Top10WndTitle ) - 1
  2542.                 );
  2543.                 */
  2544.         //
  2545.         for ( i = 0; i < TOP_TBL_SIZE; i++ )
  2546.         {
  2547.                 //
  2548.                 kos_WriteTextToWindow(
  2549.                         6-1, 2 + (i * 10),
  2550.                         0x0, enterName != i ? 0xFFFFFF : 0x00FF00,
  2551.                         heroTbl[i].name,
  2552.                         sizeof( heroTbl[0].name )
  2553.                         );
  2554.                 //
  2555.                 kos_DisplayNumberToWindow(
  2556.                         heroTbl[i].score,
  2557.                         8,
  2558.                         112-1, 2 + (i * 10),
  2559.                         0xFFFF55,
  2560.                         nbDecimal,
  2561.                         false
  2562.                         );
  2563.         }
  2564.         //
  2565.         kos_WriteTextToWindow(
  2566.                 6-1, 6 + (i * 10),
  2567.                 0x10, 0x1060D0,
  2568.                 enterName >= 0 ? top10str1 : top10str2,
  2569.                 enterName >= 0 ? sizeof(top10str1) - 1 : sizeof(top10str2) - 1
  2570.                 );
  2571. }
  2572.  
  2573.  
  2574.