Subversion Repositories Kolibri OS

Rev

Rev 1805 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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