Subversion Repositories Kolibri OS

Rev

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

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