1 |
/* |
2 |
Copyright (C) 2001-2004 Stephane Magnenat & Luc-Olivier de Charrière |
3 |
for any question or comment contact us at nct@ysagoon.com or nuage@ysagoon.com |
4 |
|
5 |
This program is free software; you can redistribute it and/or modify |
6 |
it under the terms of the GNU General Public License as published by |
7 |
the Free Software Foundation; either version 2 of the License, or |
8 |
(at your option) any later version. |
9 |
|
10 |
This program is distributed in the hope that it will be useful, |
11 |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
13 |
GNU General Public License for more details. |
14 |
|
15 |
You should have received a copy of the GNU General Public License |
16 |
along with this program; if not, write to the Free Software |
17 |
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
18 |
*/ |
19 |
|
20 |
#include "Map.h" |
21 |
#include "Game.h" |
22 |
#include "Utilities.h" |
23 |
#include "GlobalContainer.h" |
24 |
#include "LogFileManager.h" |
25 |
#include "Unit.h" |
26 |
|
27 |
#include <algorithm> |
28 |
#include <valarray> |
29 |
#include <Stream.h> |
30 |
|
31 |
// use deltaOne for first perpendicular direction |
32 |
static const int deltaOne[8][2]={ |
33 |
{ 0, -1}, |
34 |
{ 1, 0}, |
35 |
{ 0, 1}, |
36 |
{-1, 0}, |
37 |
{-1, -1}, |
38 |
{ 1, -1}, |
39 |
{ 1, 1}, |
40 |
{-1, 1}}; |
41 |
|
42 |
// use tabClose for original circular direction |
43 |
static const int tabClose[8][2]={ |
44 |
{-1, -1}, |
45 |
{ 0, -1}, |
46 |
{ 1, -1}, |
47 |
{ 1, 0}, |
48 |
{ 1, 1}, |
49 |
{ 0, 1}, |
50 |
{-1, 1}, |
51 |
{-1, 0}}; |
52 |
|
53 |
|
54 |
Map(team_count_t Teams=0, undertile_t T = WATER) |
55 |
: File(F), MaxTeams(Teams), logFile(globalContainer->logFileManager->getFile("Map.log")), DirtyBuildings(), FogOfWar(), |
56 |
pathToResourceCountTot(), pathToResourceCountSuccess(), pathToResourceCountFailure(), |
57 |
|
58 |
localResourcesUpdateCount(), |
59 |
|
60 |
pathfindLocalResourceCount(), pathfindLocalResourceCountWait(), pathfindLocalResourceCountSuccessBase(), pathfindLocalResourceCountSuccessLocked(), |
61 |
pathfindLocalResourceCountSuccessUpdate(), pathfindLocalResourceCountSuccessUpdateLocked(), pathfindLocalResourceCountFailureUnusable(), |
62 |
pathfindLocalResourceCountFailureNone(), pathfindLocalResourceCountFailureBad(), |
63 |
|
64 |
pathToBuildingCountTot(), |
65 |
|
66 |
pathToBuildingCountClose(), pathToBuildingCountCloseSuccessStand(), pathToBuildingCountCloseSuccessBase(), pathToBuildingCountCloseSuccessUpdated(), |
67 |
pathToBuildingCountCloseFailureLocked(), pathToBuildingCountCloseFailureEnd(), |
68 |
|
69 |
pathToBuildingCountIsFar(), pathToBuildingCountFar(), pathToBuildingCountFarIsNew(), pathToBuildingCountFarOldSuccess(), |
70 |
pathToBuildingCountFarOldFailureLocked(), pathToBuildingCountFarOldFailureBad(), pathToBuildingCountFarOldFailureRepeat(), |
71 |
pathToBuildingCountFarOldFailureUnusable(), pathToBuildingCountFarUpdateSuccess(), pathToBuildingCountFarUpdateFailureLocked(), |
72 |
pathToBuildingCountFarUpdateFailureVirtual(), pathToBuildingCountFarUpdateFailureBad(), |
73 |
|
74 |
localBuildingElevationUpdate(), localBuildingElevationUpdateLocked(), globalBuildingElevationUpdate(), globalBuildingElevationUpdateLocked(), |
75 |
|
76 |
buildingAvailableCountTot(), |
77 |
|
78 |
buildingAvailableCountClose(), buildingAvailableCountCloseSuccessFast(), buildingAvailableCountCloseSuccessAround(), buildingAvailableCountCloseSuccessUpdate(), |
79 |
buildingAvailableCountCloseSuccessUpdateAround(), buildingAvailableCountCloseFailureLocked(), buildingAvailableCountCloseFailureEnd(), |
80 |
|
81 |
buildingAvailableCountIsFar(), buildingAvailableCountFar(), buildingAvailableCountFarNew(), buildingAvailableCountFarNewSuccessFast(), |
82 |
buildingAvailableCountFarNewSuccessClosely(), buildingAvailableCountFarNewFailureLocked(), buildingAvailableCountFarNewFailureVirtual(), |
83 |
buildingAvailableCountFarNewFailureEnd(), buildingAvailableCountFarOld(), buildingAvailableCountFarOldSuccessFast(), |
84 |
buildingAvailableCountFarOldSuccessAround(), buildingAvailableCountFarOldFailureLocked(), buildingAvailableCountFarOldFailureEnd(), |
85 |
|
86 |
pathfindForbiddenCount(), pathfindForbiddenCountSuccess(), pathfindForbiddenCountFailure() |
87 |
{ |
88 |
for (int x=0; x<Width; ++x) |
89 |
for (int y=0; y<Height; ++y) |
90 |
Cells[CellWidth, CellHeight].Cell(Teams, T); |
91 |
|
92 |
for (int p=0; x<SectorSize; ++p) |
93 |
Sector Sectors[p](); |
94 |
|
95 |
//! Elevations to be dirtied - note that individual resources can be dirtied, or the whole lot can be dirtied at once |
96 |
for (int i=0; i<Teams; ++i) { |
97 |
for (int j=0; j<MAX_NB_RESOURCES; ++j) |
98 |
DirtyResource[i][j]=false; |
99 |
DirtyResources[i]=false; |
100 |
DirtyForbidden[i]=false; |
101 |
DirtyGuarded[i]=false; |
102 |
}; |
103 |
|
104 |
//Elevations stats: |
105 |
for (int t=0; t<16; t++) |
106 |
for (int r=0; r<MAX_RESOURCES; r++) |
107 |
{ |
108 |
resourceAvailableCount[t][r]=0; |
109 |
resourceAvailableCountSuccess[t][r]=0; |
110 |
resourceAvailableCountFailure[t][r]=0; |
111 |
} |
112 |
|
113 |
regenerate(); |
114 |
}; |
115 |
|
116 |
void Map::~Map() |
117 |
{ |
118 |
for (int x=0; x<Width; ++x) |
119 |
for (int y=0; y<Height; ++y) |
120 |
Cells[CellWidth, CellHeight].~Cell(Teams, T); |
121 |
|
122 |
for (int p=0; x<SectorSize; ++p) |
123 |
Sector Sectors[p].~Sector(); |
124 |
|
125 |
if (!verbose) return; |
126 |
|
127 |
fprintf(logFile, "\n"); |
128 |
for (int t=0; t<16; t++) |
129 |
for (int r=0; r<MAX_RESOURCES; r++) |
130 |
if (resourceAvailableCount[t][r]) |
131 |
{ |
132 |
fprintf(logFile, "resourceAvailableCount[%d][%d]=%d\n", t, r, |
133 |
resourceAvailableCount[t][r]); |
134 |
fprintf(logFile, "| resourceAvailableCountSuccess[%d][%d]=%d (%f %%)\n", t, r, |
135 |
resourceAvailableCountSuccess[t][r], |
136 |
100.*(double)resourceAvailableCountSuccess[t][r]/(double)resourceAvailableCount[t][r]); |
137 |
fprintf(logFile, "| resourceAvailableCountFailure[%d][%d]=%d (%f %%)\n", t, r, |
138 |
resourceAvailableCountFailure, |
139 |
100.*(double)resourceAvailableCountFailure[t][r]/(double)resourceAvailableCount[t][r]); |
140 |
} |
141 |
|
142 |
for (int t=0; t<16; t++) |
143 |
for (int r=0; r<MAX_RESOURCES; r++) |
144 |
{ |
145 |
resourceAvailableCount[t][r]=0; |
146 |
resourceAvailableCountSuccess[t][r]=0; |
147 |
resourceAvailableCountFailure[t][r]=0; |
148 |
} |
149 |
|
150 |
fprintf(logFile, "\n"); |
151 |
fprintf(logFile, "pathToResourceCountTot=%d\n", pathToResourceCountTot); |
152 |
if (pathToBuildingCountTot) |
153 |
{ |
154 |
fprintf(logFile, "| pathToResourceCountSuccess=%d (%f %% of tot)\n", |
155 |
pathToResourceCountSuccess, |
156 |
100.*(double)pathToResourceCountSuccess/(double)pathToResourceCountTot); |
157 |
fprintf(logFile, "| pathToResourceCountFailure=%d (%f %% of tot)\n", |
158 |
pathToResourceCountFailure, |
159 |
100.*(double)pathToResourceCountFailure/(double)pathToResourceCountTot); |
160 |
} |
161 |
pathToResourceCountTot=0; |
162 |
pathToResourceCountSuccess=0; |
163 |
pathToResourceCountFailure=0; |
164 |
|
165 |
fprintf(logFile, "\n"); |
166 |
|
167 |
fprintf(logFile, "pathfindLocalResourceCount=%d\n", pathfindLocalResourceCount); |
168 |
if (pathfindLocalResourceCount) |
169 |
{ |
170 |
fprintf(logFile, "+ localResourcesUpdateCount=%d (%f %% of calls)\n", |
171 |
localResourcesUpdateCount, |
172 |
100.*(float)localResourcesUpdateCount/(float)pathfindLocalResourceCount); |
173 |
|
174 |
fprintf(logFile, "| pathfindLocalResourceCountWait=%d (%f %% of count)\n", |
175 |
pathfindLocalResourceCountWait, |
176 |
100.*(float)pathfindLocalResourceCountWait/(float)pathfindLocalResourceCount); |
177 |
|
178 |
int pathfindLocalResourceCountSuccess= |
179 |
+pathfindLocalResourceCountSuccessBase |
180 |
+pathfindLocalResourceCountSuccessLocked |
181 |
+pathfindLocalResourceCountSuccessUpdate |
182 |
+pathfindLocalResourceCountSuccessUpdateLocked; |
183 |
|
184 |
fprintf(logFile, "| pathfindLocalResourceCountSuccess=%d (%f %% of count)\n", |
185 |
pathfindLocalResourceCountSuccess, |
186 |
100.*(float)pathfindLocalResourceCountSuccess/(float)pathfindLocalResourceCount); |
187 |
fprintf(logFile, "|- pathfindLocalResourceCountSuccessBase=%d (%f %% of count) (%f %% of success)\n", |
188 |
pathfindLocalResourceCountSuccessBase, |
189 |
100.*(float)pathfindLocalResourceCountSuccessBase/(float)pathfindLocalResourceCount, |
190 |
100.*(float)pathfindLocalResourceCountSuccessBase/(float)pathfindLocalResourceCountSuccess); |
191 |
fprintf(logFile, "|- pathfindLocalResourceCountSuccessLocked=%d (%f %% of count) (%f %% of success)\n", |
192 |
pathfindLocalResourceCountSuccessLocked, |
193 |
100.*(float)pathfindLocalResourceCountSuccessLocked/(float)pathfindLocalResourceCount, |
194 |
100.*(float)pathfindLocalResourceCountSuccessLocked/(float)pathfindLocalResourceCountSuccess); |
195 |
fprintf(logFile, "|- pathfindLocalResourceCountSuccessUpdate=%d (%f %% of count) (%f %% of success)\n", |
196 |
pathfindLocalResourceCountSuccessUpdate, |
197 |
100.*(float)pathfindLocalResourceCountSuccessUpdate/(float)pathfindLocalResourceCount, |
198 |
100.*(float)pathfindLocalResourceCountSuccessUpdate/(float)pathfindLocalResourceCountSuccess); |
199 |
fprintf(logFile, "|- pathfindLocalResourceCountSuccessUpdateLocked=%d (%f %% of count) (%f %% of success)\n", |
200 |
pathfindLocalResourceCountSuccessUpdateLocked, |
201 |
100.*(float)pathfindLocalResourceCountSuccessUpdateLocked/(float)pathfindLocalResourceCount, |
202 |
100.*(float)pathfindLocalResourceCountSuccessUpdateLocked/(float)pathfindLocalResourceCountSuccess); |
203 |
|
204 |
int pathfindLocalResourceCountFailure= |
205 |
+pathfindLocalResourceCountFailureUnusable |
206 |
+pathfindLocalResourceCountFailureNone |
207 |
+pathfindLocalResourceCountFailureBad; |
208 |
|
209 |
fprintf(logFile, "| pathfindLocalResourceCountFailure=%d (%f %% of count)\n", |
210 |
pathfindLocalResourceCountFailure, |
211 |
100.*(float)pathfindLocalResourceCountFailure/(float)pathfindLocalResourceCount); |
212 |
fprintf(logFile, "|- pathfindLocalResourceCountFailureUnusable=%d (%f %% of count) (%f %% of failure)\n", |
213 |
pathfindLocalResourceCountFailureUnusable, |
214 |
100.*(float)pathfindLocalResourceCountFailureUnusable/(float)pathfindLocalResourceCount, |
215 |
100.*(float)pathfindLocalResourceCountFailureUnusable/(float)pathfindLocalResourceCountFailure); |
216 |
fprintf(logFile, "|- pathfindLocalResourceCountFailureNone=%d (%f %% of count) (%f %% of failure)\n", |
217 |
pathfindLocalResourceCountFailureNone, |
218 |
100.*(float)pathfindLocalResourceCountFailureNone/(float)pathfindLocalResourceCount, |
219 |
100.*(float)pathfindLocalResourceCountFailureNone/(float)pathfindLocalResourceCountFailure); |
220 |
fprintf(logFile, "|- pathfindLocalResourceCountFailureBad=%d (%f %% of count) (%f %% of failure)\n", |
221 |
pathfindLocalResourceCountFailureBad, |
222 |
100.*(float)pathfindLocalResourceCountFailureBad/(float)pathfindLocalResourceCount, |
223 |
100.*(float)pathfindLocalResourceCountFailureBad/(float)pathfindLocalResourceCountFailure); |
224 |
} |
225 |
|
226 |
localResourcesUpdateCount=0; |
227 |
|
228 |
pathfindLocalResourceCount=0; |
229 |
pathfindLocalResourceCountWait=0; |
230 |
pathfindLocalResourceCountSuccessBase=0; |
231 |
pathfindLocalResourceCountSuccessLocked=0; |
232 |
pathfindLocalResourceCountSuccessUpdate=0; |
233 |
pathfindLocalResourceCountSuccessUpdateLocked=0; |
234 |
pathfindLocalResourceCountFailureUnusable=0; |
235 |
pathfindLocalResourceCountFailureNone=0; |
236 |
pathfindLocalResourceCountFailureBad=0; |
237 |
|
238 |
fprintf(logFile, "\n"); |
239 |
fprintf(logFile, "pathToBuildingCountTot=%d\n", pathToBuildingCountTot); |
240 |
if (pathToBuildingCountTot) |
241 |
{ |
242 |
fprintf(logFile, "|- pathToBuildingCountClose=%d (%f %% of tot)\n", |
243 |
pathToBuildingCountClose, |
244 |
100.*(double)pathToBuildingCountClose/(double)pathToBuildingCountTot); |
245 |
|
246 |
int pathToBuildingCountCloseSuccessTot= |
247 |
+pathToBuildingCountCloseSuccessStand |
248 |
+pathToBuildingCountCloseSuccessBase |
249 |
+pathToBuildingCountCloseSuccessUpdated; |
250 |
|
251 |
fprintf(logFile, "|- pathToBuildingCountCloseSuccessTot=%d (%f %% of tot) (%f %% of close)\n", |
252 |
pathToBuildingCountCloseSuccessTot, |
253 |
100.*(double)pathToBuildingCountCloseSuccessTot/(double)pathToBuildingCountTot, |
254 |
100.*(double)pathToBuildingCountCloseSuccessTot/(double)pathToBuildingCountClose); |
255 |
|
256 |
fprintf(logFile, "|- pathToBuildingCountCloseSuccessStand=%d (%f %% of tot) (%f %% of close) (%f %% of successTot)\n", |
257 |
pathToBuildingCountCloseSuccessStand, |
258 |
100.*(double)pathToBuildingCountCloseSuccessStand/(double)pathToBuildingCountTot, |
259 |
100.*(double)pathToBuildingCountCloseSuccessStand/(double)pathToBuildingCountClose, |
260 |
100.*(double)pathToBuildingCountCloseSuccessStand/(double)pathToBuildingCountCloseSuccessTot); |
261 |
|
262 |
fprintf(logFile, "|- pathToBuildingCountCloseSuccessBase=%d (%f %% of tot) (%f %% of close) (%f %% of successTot)\n", |
263 |
pathToBuildingCountCloseSuccessBase, |
264 |
100.*(double)pathToBuildingCountCloseSuccessBase/(double)pathToBuildingCountTot, |
265 |
100.*(double)pathToBuildingCountCloseSuccessBase/(double)pathToBuildingCountClose, |
266 |
100.*(double)pathToBuildingCountCloseSuccessBase/(double)pathToBuildingCountCloseSuccessTot); |
267 |
|
268 |
fprintf(logFile, "|- pathToBuildingCountCloseSuccessUpdated=%d (%f %% of tot) (%f %% of close) (%f %% of successTot)\n", |
269 |
pathToBuildingCountCloseSuccessUpdated, |
270 |
100.*(double)pathToBuildingCountCloseSuccessUpdated/(double)pathToBuildingCountTot, |
271 |
100.*(double)pathToBuildingCountCloseSuccessUpdated/(double)pathToBuildingCountClose, |
272 |
100.*(double)pathToBuildingCountCloseSuccessUpdated/(double)pathToBuildingCountCloseSuccessTot); |
273 |
|
274 |
int pathToBuildingCountCloseFailure= |
275 |
+pathToBuildingCountCloseFailureLocked |
276 |
+pathToBuildingCountCloseFailureEnd; |
277 |
fprintf(logFile, "|- pathToBuildingCountCloseFailure=%d (%f %% of tot) (%f %% of close)\n", |
278 |
pathToBuildingCountCloseFailure, |
279 |
100.*(double)pathToBuildingCountCloseFailure/(double)pathToBuildingCountTot, |
280 |
100.*(double)pathToBuildingCountCloseFailure/(double)pathToBuildingCountClose); |
281 |
fprintf(logFile, "|- pathToBuildingCountCloseFailureLocked=%d (%f %% of tot) (%f %% of close) (%f %% of failure)\n", |
282 |
pathToBuildingCountCloseFailureLocked, |
283 |
100.*(double)pathToBuildingCountCloseFailureLocked/(double)pathToBuildingCountTot, |
284 |
100.*(double)pathToBuildingCountCloseFailureLocked/(double)pathToBuildingCountClose, |
285 |
100.*(double)pathToBuildingCountCloseFailureLocked/(double)pathToBuildingCountCloseFailure); |
286 |
fprintf(logFile, "|- pathToBuildingCountCloseFailureEnd=%d (%f %% of tot) (%f %% of close) (%f %% of failure)\n", |
287 |
pathToBuildingCountCloseFailureEnd, |
288 |
100.*(double)pathToBuildingCountCloseFailureEnd/(double)pathToBuildingCountTot, |
289 |
100.*(double)pathToBuildingCountCloseFailureEnd/(double)pathToBuildingCountClose, |
290 |
100.*(double)pathToBuildingCountCloseFailureEnd/(double)pathToBuildingCountCloseFailure); |
291 |
|
292 |
assert(pathToBuildingCountFar== |
293 |
//+pathToBuildingCountFarIsNew // doesn't return |
294 |
+pathToBuildingCountFarOldSuccess |
295 |
+pathToBuildingCountFarOldFailureLocked |
296 |
+pathToBuildingCountFarOldFailureBad |
297 |
+pathToBuildingCountFarOldFailureRepeat |
298 |
//+pathToBuildingCountFarOldFailureUnusable // doesn't return |
299 |
+pathToBuildingCountFarUpdateSuccess |
300 |
+pathToBuildingCountFarUpdateFailureLocked |
301 |
+pathToBuildingCountFarUpdateFailureVirtual |
302 |
+pathToBuildingCountFarUpdateFailureBad); |
303 |
fprintf(logFile, "|- pathToBuildingCountFar=%d (%f %% of tot)\n", |
304 |
pathToBuildingCountFar, |
305 |
100.*(double)pathToBuildingCountFar/(double)pathToBuildingCountTot); |
306 |
fprintf(logFile, "|+ pathToBuildingCountIsFar=%d (%f %% of tot) (%f %% of far)\n", |
307 |
pathToBuildingCountIsFar, |
308 |
100.*(double)pathToBuildingCountIsFar/(double)pathToBuildingCountTot, |
309 |
100.*(double)pathToBuildingCountIsFar/(double)pathToBuildingCountFar); |
310 |
|
311 |
int pathToBuildingCountFarOld= |
312 |
+pathToBuildingCountFarOldSuccess |
313 |
+pathToBuildingCountFarOldFailureLocked |
314 |
+pathToBuildingCountFarOldFailureBad |
315 |
+pathToBuildingCountFarOldFailureRepeat |
316 |
+pathToBuildingCountFarOldFailureUnusable; |
317 |
fprintf(logFile, "|- pathToBuildingCountFarOld=%d (%f %% of tot) (%f %% of far)\n", |
318 |
pathToBuildingCountFarOld, |
319 |
100.*(double)pathToBuildingCountFarOld/(double)pathToBuildingCountTot, |
320 |
100.*(double)pathToBuildingCountFarOld/(double)pathToBuildingCountFar); |
321 |
|
322 |
fprintf(logFile, "|- pathToBuildingCountFarOldSuccess=%d (%f %% of tot) (%f %% of far) (%f %% of old)\n", |
323 |
pathToBuildingCountFarOldSuccess, |
324 |
100.*(double)pathToBuildingCountFarOldSuccess/(double)pathToBuildingCountTot, |
325 |
100.*(double)pathToBuildingCountFarOldSuccess/(double)pathToBuildingCountFar, |
326 |
100.*(double)pathToBuildingCountFarOldSuccess/(double)pathToBuildingCountFarOld); |
327 |
|
328 |
int pathToBuildingCountFarOldFailure= |
329 |
+pathToBuildingCountFarOldFailureLocked |
330 |
+pathToBuildingCountFarOldFailureBad |
331 |
+pathToBuildingCountFarOldFailureRepeat |
332 |
+pathToBuildingCountFarOldFailureUnusable; |
333 |
fprintf(logFile, "|- pathToBuildingCountFarOldFailure=%d (%f %% of tot) (%f %% of far) (%f %% of old)\n", |
334 |
pathToBuildingCountFarOldFailure, |
335 |
100.*(double)pathToBuildingCountFarOldFailure/(double)pathToBuildingCountTot, |
336 |
100.*(double)pathToBuildingCountFarOldFailure/(double)pathToBuildingCountFar, |
337 |
100.*(double)pathToBuildingCountFarOldFailure/(double)pathToBuildingCountFarOld); |
338 |
fprintf(logFile, "|- pathToBuildingCountFarOldFailureLocked=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
339 |
pathToBuildingCountFarOldFailureLocked, |
340 |
100.*(double)pathToBuildingCountFarOldFailureLocked/(double)pathToBuildingCountTot, |
341 |
100.*(double)pathToBuildingCountFarOldFailureLocked/(double)pathToBuildingCountFar, |
342 |
100.*(double)pathToBuildingCountFarOldFailureLocked/(double)pathToBuildingCountFarOld, |
343 |
100.*(double)pathToBuildingCountFarOldFailureLocked/(double)pathToBuildingCountFarOldFailure); |
344 |
fprintf(logFile, "|- pathToBuildingCountFarOldFailureBad=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
345 |
pathToBuildingCountFarOldFailureBad, |
346 |
100.*(double)pathToBuildingCountFarOldFailureBad/(double)pathToBuildingCountTot, |
347 |
100.*(double)pathToBuildingCountFarOldFailureBad/(double)pathToBuildingCountFar, |
348 |
100.*(double)pathToBuildingCountFarOldFailureBad/(double)pathToBuildingCountFarOld, |
349 |
100.*(double)pathToBuildingCountFarOldFailureBad/(double)pathToBuildingCountFarOldFailure); |
350 |
fprintf(logFile, "|- pathToBuildingCountFarOldFailureRepeat=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
351 |
pathToBuildingCountFarOldFailureRepeat, |
352 |
100.*(double)pathToBuildingCountFarOldFailureRepeat/(double)pathToBuildingCountTot, |
353 |
100.*(double)pathToBuildingCountFarOldFailureRepeat/(double)pathToBuildingCountFar, |
354 |
100.*(double)pathToBuildingCountFarOldFailureRepeat/(double)pathToBuildingCountFarOld, |
355 |
100.*(double)pathToBuildingCountFarOldFailureRepeat/(double)pathToBuildingCountFarOldFailure); |
356 |
fprintf(logFile, "|- pathToBuildingCountFarOldFailureUnusable=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
357 |
pathToBuildingCountFarOldFailureUnusable, |
358 |
100.*(double)pathToBuildingCountFarOldFailureUnusable/(double)pathToBuildingCountTot, |
359 |
100.*(double)pathToBuildingCountFarOldFailureUnusable/(double)pathToBuildingCountFar, |
360 |
100.*(double)pathToBuildingCountFarOldFailureUnusable/(double)pathToBuildingCountFarOld, |
361 |
100.*(double)pathToBuildingCountFarOldFailureUnusable/(double)pathToBuildingCountFarOldFailure); |
362 |
|
363 |
int pathToBuildingCountFarUpdate= |
364 |
+pathToBuildingCountFarUpdateSuccess |
365 |
+pathToBuildingCountFarUpdateFailureLocked |
366 |
+pathToBuildingCountFarUpdateFailureVirtual |
367 |
+pathToBuildingCountFarUpdateFailureBad; |
368 |
fprintf(logFile, "|- pathToBuildingCountFarUpdate=%d (%f %% of tot) (%f %% of far)\n", |
369 |
pathToBuildingCountFarUpdate, |
370 |
100.*(double)pathToBuildingCountFarUpdate/(double)pathToBuildingCountTot, |
371 |
100.*(double)pathToBuildingCountFarUpdate/(double)pathToBuildingCountFar); |
372 |
fprintf(logFile, "|+ pathToBuildingCountFarIsNew=%d (%f %% of tot) (%f %% of far) (%f %% of update)\n", |
373 |
pathToBuildingCountFarIsNew, |
374 |
100.*(double)pathToBuildingCountFarIsNew/(double)pathToBuildingCountTot, |
375 |
100.*(double)pathToBuildingCountFarIsNew/(double)pathToBuildingCountFar, |
376 |
100.*(double)pathToBuildingCountFarIsNew/(double)pathToBuildingCountFarUpdate); |
377 |
fprintf(logFile, "|- pathToBuildingCountFarUpdateSuccess=%d (%f %% of tot) (%f %% of far) (%f %% of update)\n", |
378 |
pathToBuildingCountFarUpdateSuccess, |
379 |
100.*(double)pathToBuildingCountFarUpdateSuccess/(double)pathToBuildingCountTot, |
380 |
100.*(double)pathToBuildingCountFarUpdateSuccess/(double)pathToBuildingCountFar, |
381 |
100.*(double)pathToBuildingCountFarUpdateSuccess/(double)pathToBuildingCountFarUpdate); |
382 |
|
383 |
int pathToBuildingCountFarUpdateFailure= |
384 |
+pathToBuildingCountFarUpdateFailureLocked |
385 |
+pathToBuildingCountFarUpdateFailureVirtual |
386 |
+pathToBuildingCountFarUpdateFailureBad; |
387 |
fprintf(logFile, "|- pathToBuildingCountFarUpdateFailure=%d (%f %% of tot) (%f %% of far) (%f %% of update)\n", |
388 |
pathToBuildingCountFarUpdateFailure, |
389 |
100.*(double)pathToBuildingCountFarUpdateFailure/(double)pathToBuildingCountTot, |
390 |
100.*(double)pathToBuildingCountFarUpdateFailure/(double)pathToBuildingCountFar, |
391 |
100.*(double)pathToBuildingCountFarUpdateFailure/(double)pathToBuildingCountFarUpdate); |
392 |
fprintf(logFile, "|- pathToBuildingCountFarUpdateFailureLocked=%d (%f %% of tot) (%f %% of far) (%f %% of update) (%f %% of failure)\n", |
393 |
pathToBuildingCountFarUpdateFailureLocked, |
394 |
100.*(double)pathToBuildingCountFarUpdateFailureLocked/(double)pathToBuildingCountTot, |
395 |
100.*(double)pathToBuildingCountFarUpdateFailureLocked/(double)pathToBuildingCountFar, |
396 |
100.*(double)pathToBuildingCountFarUpdateFailureLocked/(double)pathToBuildingCountFarUpdate, |
397 |
100.*(double)pathToBuildingCountFarUpdateFailureLocked/(double)pathToBuildingCountFarUpdateFailure); |
398 |
fprintf(logFile, "|- pathToBuildingCountFarUpdateFailureVirtual=%d (%f %% of tot) (%f %% of far) (%f %% of update) (%f %% of failure)\n", |
399 |
pathToBuildingCountFarUpdateFailureVirtual, |
400 |
100.*(double)pathToBuildingCountFarUpdateFailureVirtual/(double)pathToBuildingCountTot, |
401 |
100.*(double)pathToBuildingCountFarUpdateFailureVirtual/(double)pathToBuildingCountFar, |
402 |
100.*(double)pathToBuildingCountFarUpdateFailureVirtual/(double)pathToBuildingCountFarUpdate, |
403 |
100.*(double)pathToBuildingCountFarUpdateFailureVirtual/(double)pathToBuildingCountFarUpdateFailure); |
404 |
fprintf(logFile, "|- pathToBuildingCountFarUpdateFailureBad=%d (%f %% of tot) (%f %% of far) (%f %% of update) (%f %% of failure)\n", |
405 |
pathToBuildingCountFarUpdateFailureBad, |
406 |
100.*(double)pathToBuildingCountFarUpdateFailureBad/(double)pathToBuildingCountTot, |
407 |
100.*(double)pathToBuildingCountFarUpdateFailureBad/(double)pathToBuildingCountFar, |
408 |
100.*(double)pathToBuildingCountFarUpdateFailureBad/(double)pathToBuildingCountFarUpdate, |
409 |
100.*(double)pathToBuildingCountFarUpdateFailureBad/(double)pathToBuildingCountFarUpdateFailure); |
410 |
} |
411 |
|
412 |
pathToBuildingCountTot=0; |
413 |
pathToBuildingCountClose=0; |
414 |
pathToBuildingCountCloseSuccessStand=0; |
415 |
pathToBuildingCountCloseSuccessBase=0; |
416 |
pathToBuildingCountCloseSuccessUpdated=0; |
417 |
pathToBuildingCountCloseFailureLocked=0; |
418 |
pathToBuildingCountCloseFailureEnd=0; |
419 |
|
420 |
pathToBuildingCountIsFar=0; |
421 |
pathToBuildingCountFar=0; |
422 |
|
423 |
pathToBuildingCountFarIsNew=0; |
424 |
pathToBuildingCountFarOldSuccess=0; |
425 |
pathToBuildingCountFarOldFailureLocked=0; |
426 |
pathToBuildingCountFarOldFailureBad=0; |
427 |
pathToBuildingCountFarOldFailureRepeat=0; |
428 |
pathToBuildingCountFarOldFailureUnusable=0; |
429 |
|
430 |
pathToBuildingCountFarUpdateSuccess=0; |
431 |
pathToBuildingCountFarUpdateFailureLocked=0; |
432 |
pathToBuildingCountFarUpdateFailureBad=0; |
433 |
|
434 |
int buildingElevationUpdate=localBuildingElevationUpdate+globalBuildingElevationUpdate; |
435 |
fprintf(logFile, "\n"); |
436 |
fprintf(logFile, "buildingElevationUpdate=%d\n", buildingElevationUpdate); |
437 |
if (buildingElevationUpdate) |
438 |
{ |
439 |
fprintf(logFile, "|- localBuildingElevationUpdate=%d (%f %%)\n", |
440 |
localBuildingElevationUpdate, |
441 |
100.*(double)localBuildingElevationUpdate/(double)buildingElevationUpdate); |
442 |
fprintf(logFile, "|- localBuildingElevationUpdateLocked=%d (%f %%) (%f %% of local)\n", |
443 |
localBuildingElevationUpdateLocked, |
444 |
100.*(double)localBuildingElevationUpdateLocked/(double)buildingElevationUpdate, |
445 |
100.*(double)localBuildingElevationUpdateLocked/(double)localBuildingElevationUpdate); |
446 |
|
447 |
fprintf(logFile, "|- globalBuildingElevationUpdate=%d (%f %%)\n", |
448 |
globalBuildingElevationUpdate, |
449 |
100.*(double)globalBuildingElevationUpdate/(double)buildingElevationUpdate); |
450 |
fprintf(logFile, "|- globalBuildingElevationUpdateLocked=%d (%f %%) (%f %% of global)\n", |
451 |
globalBuildingElevationUpdateLocked, |
452 |
100.*(double)globalBuildingElevationUpdateLocked/(double)buildingElevationUpdate, |
453 |
100.*(double)globalBuildingElevationUpdateLocked/(double)globalBuildingElevationUpdate); |
454 |
} |
455 |
|
456 |
localBuildingElevationUpdate=0; |
457 |
localBuildingElevationUpdateLocked=0; |
458 |
globalBuildingElevationUpdate=0; |
459 |
globalBuildingElevationUpdateLocked=0; |
460 |
|
461 |
fprintf(logFile, "\n"); |
462 |
fprintf(logFile, "buildingAvailableCountTot=%d\n", buildingAvailableCountTot); |
463 |
if (buildingAvailableCountTot) |
464 |
{ |
465 |
fprintf(logFile, "|- buildingAvailableCountClose=%d (%f %%)\n", |
466 |
buildingAvailableCountClose, |
467 |
100.*(double)buildingAvailableCountClose/(double)buildingAvailableCountTot); |
468 |
|
469 |
int buildingAvailableCountCloseSuccess= |
470 |
+buildingAvailableCountCloseSuccessFast |
471 |
+buildingAvailableCountCloseSuccessAround |
472 |
+buildingAvailableCountCloseSuccessUpdate |
473 |
+buildingAvailableCountCloseSuccessUpdateAround; |
474 |
fprintf(logFile, "|- buildingAvailableCountCloseSuccess=%d (%f %% of tot) (%f %% of close)\n", |
475 |
buildingAvailableCountCloseSuccess, |
476 |
100.*(double)buildingAvailableCountCloseSuccess/(double)buildingAvailableCountTot, |
477 |
100.*(double)buildingAvailableCountCloseSuccess/(double)buildingAvailableCountClose); |
478 |
fprintf(logFile, "|- buildingAvailableCountCloseSuccessFast=%d (%f %% of tot) (%f %% of close) (%f %% of close success)\n", |
479 |
buildingAvailableCountCloseSuccessFast, |
480 |
100.*(double)buildingAvailableCountCloseSuccessFast/(double)buildingAvailableCountTot, |
481 |
100.*(double)buildingAvailableCountCloseSuccessFast/(double)buildingAvailableCountClose, |
482 |
100.*(double)buildingAvailableCountCloseSuccessFast/(double)buildingAvailableCountCloseSuccess); |
483 |
fprintf(logFile, "|- buildingAvailableCountCloseSuccessAround=%d (%f %% of tot) (%f %% of close) (%f %% of close success)\n", |
484 |
buildingAvailableCountCloseSuccessAround, |
485 |
100.*(double)buildingAvailableCountCloseSuccessAround/(double)buildingAvailableCountTot, |
486 |
100.*(double)buildingAvailableCountCloseSuccessAround/(double)buildingAvailableCountClose, |
487 |
100.*(double)buildingAvailableCountCloseSuccessAround/(double)buildingAvailableCountCloseSuccess); |
488 |
fprintf(logFile, "|- buildingAvailableCountCloseSuccessUpdate=%d (%f %% of tot) (%f %% of close) (%f %% of close success)\n", |
489 |
buildingAvailableCountCloseSuccessUpdate, |
490 |
100.*(double)buildingAvailableCountCloseSuccessUpdate/(double)buildingAvailableCountTot, |
491 |
100.*(double)buildingAvailableCountCloseSuccessUpdate/(double)buildingAvailableCountClose, |
492 |
100.*(double)buildingAvailableCountCloseSuccessUpdate/(double)buildingAvailableCountCloseSuccess); |
493 |
fprintf(logFile, "|- buildingAvailableCountCloseSuccessUpdateAround=%d (%f %% of tot) (%f %% of close) (%f %% of close success)\n", |
494 |
buildingAvailableCountCloseSuccessUpdateAround, |
495 |
100.*(double)buildingAvailableCountCloseSuccessUpdateAround/(double)buildingAvailableCountTot, |
496 |
100.*(double)buildingAvailableCountCloseSuccessUpdateAround/(double)buildingAvailableCountClose, |
497 |
100.*(double)buildingAvailableCountCloseSuccessUpdateAround/(double)buildingAvailableCountCloseSuccess); |
498 |
|
499 |
int buildingAvailableCountCloseFailure= |
500 |
+buildingAvailableCountCloseFailureLocked |
501 |
+buildingAvailableCountCloseFailureEnd; |
502 |
fprintf(logFile, "|- buildingAvailableCountCloseFailure=%d (%f %% of tot) (%f %% of close)\n", |
503 |
buildingAvailableCountCloseFailure, |
504 |
100.*(double)buildingAvailableCountCloseFailure/(double)buildingAvailableCountTot, |
505 |
100.*(double)buildingAvailableCountCloseFailure/(double)buildingAvailableCountClose); |
506 |
fprintf(logFile, "|- buildingAvailableCountCloseFailureLocked=%d (%f %% of tot) (%f %% of close) (%f %% of failure)\n", |
507 |
buildingAvailableCountCloseFailureLocked, |
508 |
100.*(double)buildingAvailableCountCloseFailureLocked/(double)buildingAvailableCountTot, |
509 |
100.*(double)buildingAvailableCountCloseFailureLocked/(double)buildingAvailableCountClose, |
510 |
100.*(double)buildingAvailableCountCloseFailureLocked/(double)buildingAvailableCountCloseFailure); |
511 |
fprintf(logFile, "|- buildingAvailableCountCloseFailureEnd=%d (%f %% of tot) (%f %% of close) (%f %% of failure)\n", |
512 |
buildingAvailableCountCloseFailureEnd, |
513 |
100.*(double)buildingAvailableCountCloseFailureEnd/(double)buildingAvailableCountTot, |
514 |
100.*(double)buildingAvailableCountCloseFailureEnd/(double)buildingAvailableCountClose, |
515 |
100.*(double)buildingAvailableCountCloseFailureEnd/(double)buildingAvailableCountCloseFailure); |
516 |
|
517 |
fprintf(logFile, "|- buildingAvailableCountFar=%d (%f %%)\n", |
518 |
buildingAvailableCountFar, |
519 |
100.*(double)buildingAvailableCountFar/(double)buildingAvailableCountTot); |
520 |
fprintf(logFile, "|+ buildingAvailableCountIsFar=%d (%f %% of tot) (%f %% of far)\n", |
521 |
buildingAvailableCountIsFar, |
522 |
100.*(double)buildingAvailableCountIsFar/(double)buildingAvailableCountTot, |
523 |
100.*(double)buildingAvailableCountIsFar/(double)buildingAvailableCountFar); |
524 |
|
525 |
fprintf(logFile, "|- buildingAvailableCountFarOld=%d (%f %% of tot) (%f %% of far)\n", |
526 |
buildingAvailableCountFarOld, |
527 |
100.*(double)buildingAvailableCountFarOld/(double)buildingAvailableCountTot, |
528 |
100.*(double)buildingAvailableCountFarOld/(double)buildingAvailableCountFar); |
529 |
|
530 |
int buildingAvailableCountFarOldSuccess= |
531 |
+buildingAvailableCountFarOldSuccessFast |
532 |
+buildingAvailableCountFarOldSuccessAround; |
533 |
fprintf(logFile, "|- buildingAvailableCountFarOldSuccess=%d (%f %% of tot) (%f %% of far) (%f %% of old)\n", |
534 |
buildingAvailableCountFarOldSuccess, |
535 |
100.*(double)buildingAvailableCountFarOldSuccess/(double)buildingAvailableCountTot, |
536 |
100.*(double)buildingAvailableCountFarOldSuccess/(double)buildingAvailableCountFar, |
537 |
100.*(double)buildingAvailableCountFarOldSuccess/(double)buildingAvailableCountFarOld); |
538 |
fprintf(logFile, "|- buildingAvailableCountFarOldSuccessFast=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of old success)\n", |
539 |
buildingAvailableCountFarOldSuccessFast, |
540 |
100.*(double)buildingAvailableCountFarOldSuccessFast/(double)buildingAvailableCountTot, |
541 |
100.*(double)buildingAvailableCountFarOldSuccessFast/(double)buildingAvailableCountFar, |
542 |
100.*(double)buildingAvailableCountFarOldSuccessFast/(double)buildingAvailableCountFarOld, |
543 |
100.*(double)buildingAvailableCountFarOldSuccessFast/(double)buildingAvailableCountFarOldSuccess); |
544 |
fprintf(logFile, "|- buildingAvailableCountFarOldSuccessAround=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of old success)\n", |
545 |
buildingAvailableCountFarOldSuccessAround, |
546 |
100.*(double)buildingAvailableCountFarOldSuccessAround/(double)buildingAvailableCountTot, |
547 |
100.*(double)buildingAvailableCountFarOldSuccessAround/(double)buildingAvailableCountFar, |
548 |
100.*(double)buildingAvailableCountFarOldSuccessAround/(double)buildingAvailableCountFarOld, |
549 |
100.*(double)buildingAvailableCountFarOldSuccessAround/(double)buildingAvailableCountFarOldSuccess); |
550 |
|
551 |
int buildingAvailableCountFarOldFailure= |
552 |
+buildingAvailableCountFarOldFailureLocked |
553 |
+buildingAvailableCountFarOldFailureEnd; |
554 |
fprintf(logFile, "|- buildingAvailableCountFarOldFailure=%d (%f %% of tot) (%f %% of far) (%f %% of old)\n", |
555 |
buildingAvailableCountFarOldFailure, |
556 |
100.*(double)buildingAvailableCountFarOldFailure/(double)buildingAvailableCountTot, |
557 |
100.*(double)buildingAvailableCountFarOldFailure/(double)buildingAvailableCountFar, |
558 |
100.*(double)buildingAvailableCountFarOldFailure/(double)buildingAvailableCountFarOld); |
559 |
fprintf(logFile, "|- buildingAvailableCountFarOldFailureLocked=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
560 |
buildingAvailableCountFarOldFailureLocked, |
561 |
100.*(double)buildingAvailableCountFarOldFailureLocked/(double)buildingAvailableCountTot, |
562 |
100.*(double)buildingAvailableCountFarOldFailureLocked/(double)buildingAvailableCountFar, |
563 |
100.*(double)buildingAvailableCountFarOldFailureLocked/(double)buildingAvailableCountFarOld, |
564 |
100.*(double)buildingAvailableCountFarOldFailureLocked/(double)buildingAvailableCountFarOldFailure); |
565 |
fprintf(logFile, "|- buildingAvailableCountFarOldFailureEnd=%d (%f %% of tot) (%f %% of far) (%f %% of old) (%f %% of failure)\n", |
566 |
buildingAvailableCountFarOldFailureEnd, |
567 |
100.*(double)buildingAvailableCountFarOldFailureEnd/(double)buildingAvailableCountTot, |
568 |
100.*(double)buildingAvailableCountFarOldFailureEnd/(double)buildingAvailableCountFar, |
569 |
100.*(double)buildingAvailableCountFarOldFailureEnd/(double)buildingAvailableCountFarOld, |
570 |
100.*(double)buildingAvailableCountFarOldFailureEnd/(double)buildingAvailableCountFarOldFailure); |
571 |
|
572 |
fprintf(logFile, "|- buildingAvailableCountFarNew=%d (%f %% of tot) (%f %% of far)\n", |
573 |
buildingAvailableCountFarNew, |
574 |
100.*(double)buildingAvailableCountFarNew/(double)buildingAvailableCountTot, |
575 |
100.*(double)buildingAvailableCountFarNew/(double)buildingAvailableCountFar); |
576 |
|
577 |
int buildingAvailableCountFarNewSuccess=buildingAvailableCountFarNewSuccessFast+buildingAvailableCountFarNewSuccessClosely; |
578 |
fprintf(logFile, "|- buildingAvailableCountFarNewSuccess=%d (%f %% of tot) (%f %% of far) (%f %% of new)\n", |
579 |
buildingAvailableCountFarNewSuccess, |
580 |
100.*(double)buildingAvailableCountFarNewSuccess/(double)buildingAvailableCountTot, |
581 |
100.*(double)buildingAvailableCountFarNewSuccess/(double)buildingAvailableCountFar, |
582 |
100.*(double)buildingAvailableCountFarNewSuccess/(double)buildingAvailableCountFarNew); |
583 |
fprintf(logFile, "|- buildingAvailableCountFarNewSuccessFast=%d (%f %% of tot) (%f %% of far) (%f %% of new) (%f %% of success)\n", |
584 |
buildingAvailableCountFarNewSuccessFast, |
585 |
100.*(double)buildingAvailableCountFarNewSuccessFast/(double)buildingAvailableCountTot, |
586 |
100.*(double)buildingAvailableCountFarNewSuccessFast/(double)buildingAvailableCountFar, |
587 |
100.*(double)buildingAvailableCountFarNewSuccessFast/(double)buildingAvailableCountFarNew, |
588 |
100.*(double)buildingAvailableCountFarNewSuccessFast/(double)buildingAvailableCountFarNewSuccess); |
589 |
fprintf(logFile, "|- buildingAvailableCountFarNewSuccessClosely=%d (%f %% of tot) (%f %% of far) (%f %% of new) (%f %% of success)\n", |
590 |
buildingAvailableCountFarNewSuccessClosely, |
591 |
100.*(double)buildingAvailableCountFarNewSuccessClosely/(double)buildingAvailableCountTot, |
592 |
100.*(double)buildingAvailableCountFarNewSuccessClosely/(double)buildingAvailableCountFar, |
593 |
100.*(double)buildingAvailableCountFarNewSuccessClosely/(double)buildingAvailableCountFarNew, |
594 |
100.*(double)buildingAvailableCountFarNewSuccessClosely/(double)buildingAvailableCountFarNewSuccess); |
595 |
|
596 |
int buildingAvailableCountFarNewFailure= |
597 |
+buildingAvailableCountFarNewFailureLocked |
598 |
+buildingAvailableCountFarNewFailureVirtual |
599 |
+buildingAvailableCountFarNewFailureEnd; |
600 |
fprintf(logFile, "|- buildingAvailableCountFarNewFailure=%d (%f %% of tot) (%f %% of far) (%f %% of new)\n", |
601 |
buildingAvailableCountFarNewFailure, |
602 |
100.*(double)buildingAvailableCountFarNewFailure/(double)buildingAvailableCountTot, |
603 |
100.*(double)buildingAvailableCountFarNewFailure/(double)buildingAvailableCountFar, |
604 |
100.*(double)buildingAvailableCountFarNewFailure/(double)buildingAvailableCountFarNew); |
605 |
fprintf(logFile, "|- buildingAvailableCountFarNewFailureLocked=%d (%f %% of tot) (%f %% of far) (%f %% of new) (%f %% of failure)\n", |
606 |
buildingAvailableCountFarNewFailureLocked, |
607 |
100.*(double)buildingAvailableCountFarNewFailureLocked/(double)buildingAvailableCountTot, |
608 |
100.*(double)buildingAvailableCountFarNewFailureLocked/(double)buildingAvailableCountFar, |
609 |
100.*(double)buildingAvailableCountFarNewFailureLocked/(double)buildingAvailableCountFarNew, |
610 |
100.*(double)buildingAvailableCountFarNewFailureLocked/(double)buildingAvailableCountFarNewFailure); |
611 |
fprintf(logFile, "|- buildingAvailableCountFarNewFailureVirtual=%d (%f %% of tot) (%f %% of far) (%f %% of new) (%f %% of failure)\n", |
612 |
buildingAvailableCountFarNewFailureVirtual, |
613 |
100.*(double)buildingAvailableCountFarNewFailureVirtual/(double)buildingAvailableCountTot, |
614 |
100.*(double)buildingAvailableCountFarNewFailureVirtual/(double)buildingAvailableCountFar, |
615 |
100.*(double)buildingAvailableCountFarNewFailureVirtual/(double)buildingAvailableCountFarNew, |
616 |
100.*(double)buildingAvailableCountFarNewFailureVirtual/(double)buildingAvailableCountFarNewFailure); |
617 |
fprintf(logFile, "|- buildingAvailableCountFarNewFailureEnd=%d (%f %% of tot) (%f %% of far) (%f %% of new) (%f %% of failure)\n", |
618 |
buildingAvailableCountFarNewFailureEnd, |
619 |
100.*(double)buildingAvailableCountFarNewFailureEnd/(double)buildingAvailableCountTot, |
620 |
100.*(double)buildingAvailableCountFarNewFailureEnd/(double)buildingAvailableCountFar, |
621 |
100.*(double)buildingAvailableCountFarNewFailureEnd/(double)buildingAvailableCountFarNew, |
622 |
100.*(double)buildingAvailableCountFarNewFailureEnd/(double)buildingAvailableCountFarNewFailure); |
623 |
} |
624 |
|
625 |
buildingAvailableCountTot=0; |
626 |
|
627 |
buildingAvailableCountClose=0; |
628 |
buildingAvailableCountCloseSuccessFast=0; |
629 |
buildingAvailableCountCloseSuccessAround=0; |
630 |
buildingAvailableCountCloseSuccessUpdate=0; |
631 |
buildingAvailableCountCloseSuccessUpdateAround=0; |
632 |
buildingAvailableCountCloseFailureLocked=0; |
633 |
buildingAvailableCountCloseFailureEnd=0; |
634 |
|
635 |
buildingAvailableCountIsFar=0; |
636 |
buildingAvailableCountFar=0; |
637 |
buildingAvailableCountFarNew=0; |
638 |
buildingAvailableCountFarNewSuccessFast=0; |
639 |
buildingAvailableCountFarNewSuccessClosely=0; |
640 |
buildingAvailableCountFarNewFailureLocked=0; |
641 |
buildingAvailableCountFarNewFailureVirtual=0; |
642 |
buildingAvailableCountFarNewFailureEnd=0; |
643 |
buildingAvailableCountFarOld=0; |
644 |
buildingAvailableCountFarOldSuccessFast=0; |
645 |
buildingAvailableCountFarOldSuccessAround=0; |
646 |
buildingAvailableCountFarOldFailureLocked=0; |
647 |
buildingAvailableCountFarOldFailureEnd=0; |
648 |
|
649 |
fprintf(logFile, "\n"); |
650 |
fprintf(logFile, "pathfindForbiddenCount=%d\n", pathfindForbiddenCount); |
651 |
if (pathfindForbiddenCount) |
652 |
{ |
653 |
fprintf(logFile, "|- pathfindForbiddenCountSuccess=%d (%f %%)\n", |
654 |
pathfindForbiddenCountSuccess, |
655 |
100.*(double)pathfindForbiddenCountSuccess/(double)pathfindForbiddenCount); |
656 |
|
657 |
fprintf(logFile, "|- pathfindForbiddenCountFailure=%d (%f %%)\n", |
658 |
pathfindForbiddenCountFailure, |
659 |
100.*(double)pathfindForbiddenCountFailure/(double)pathfindForbiddenCount); |
660 |
} |
661 |
|
662 |
pathfindForbiddenCount=0; |
663 |
pathfindForbiddenCountSuccess=0; |
664 |
pathfindForbiddenCountFailure=0; |
665 |
} |
666 |
|
667 |
bool Map::load(const GAGCore::InputStream *stream, const SessionGame& sessionGame, const Game *const game=0) |
668 |
{ |
669 |
assert(sessionGame->versionMinor>=16); |
670 |
|
671 |
Map(); |
672 |
|
673 |
stream->readEnterSection("Map"); |
674 |
|
675 |
char signature[4]; |
676 |
stream->read(signature, 4, "signatureStart"); |
677 |
if (memcmp(signature, "MapB", 4)) |
678 |
{ |
679 |
if (verbose) |
680 |
fprintf(stderr, "Map:: Failed to find signature at the beginning of Map.\n"); |
681 |
return false; |
682 |
} |
683 |
|
684 |
// We load and compute size: |
685 |
wDec = stream->readSint32("wDec"); |
686 |
hDec = stream->readSint32("hDec"); |
687 |
w = 1<<wDec; |
688 |
h = 1<<hDec; |
689 |
wMask = w-1; |
690 |
hMask = h-1; |
691 |
size = w*h; |
692 |
|
693 |
// We allocate memory: |
694 |
mapDiscovered = new Uint32[size]; |
695 |
fogOfWarA = new Uint32[size]; |
696 |
fogOfWarB = new Uint32[size]; |
697 |
fogOfWar = fogOfWarA; |
698 |
memset(fogOfWarA, 0, size*sizeof(Uint32)); |
699 |
memset(fogOfWarB, 0, size*sizeof(Uint32)); |
700 |
localForbiddenMap.resize(size, false); |
701 |
localGuardAreaMap.resize(size, false); |
702 |
localClearAreaMap.resize(size, false); |
703 |
cases = new Case[size]; |
704 |
undermap = new Uint8[size]; |
705 |
|
706 |
// We read what's inside the map: |
707 |
stream->read(undermap, size, "undermap"); |
708 |
stream->readEnterSection("cases"); |
709 |
for (size_t i=0; i<size; i++) |
710 |
{ |
711 |
stream->readEnterSection(i); |
712 |
mapDiscovered[i] = stream->readUint32("mapDiscovered"); |
713 |
|
714 |
cases[i].terrain = stream->readUint16("terrain"); |
715 |
cases[i].building = stream->readUint16("building"); |
716 |
|
717 |
stream->read(&(cases[i].resource), 4, "resource"); |
718 |
if (sessionGame->versionMinor < 28) |
719 |
{ |
720 |
Resource &r=cases[i].resource; |
721 |
if (r.type!=NO_RES_TYPE) |
722 |
{ |
723 |
ResourceType *rt=globalContainer->resourcesTypes.get(r.type); |
724 |
if (r.amount>rt->sizesCount) |
725 |
r.amount=rt->sizesCount; |
726 |
} |
727 |
} |
728 |
cases[i].groundUnit = stream->readUint16("groundUnit"); |
729 |
cases[i].airUnit = stream->readUint16("airUnit"); |
730 |
|
731 |
cases[i].forbidden = stream->readUint32("forbidden"); |
732 |
|
733 |
if (sessionGame->versionMinor >= 36) |
734 |
cases[i].guardArea = stream->readUint32("guardArea"); |
735 |
else |
736 |
cases[i].guardArea = 0; |
737 |
|
738 |
if (sessionGame->versionMinor >= 38) |
739 |
cases[i].clearArea = stream->readUint32("clearArea"); |
740 |
else |
741 |
cases[i].clearArea = 0; |
742 |
|
743 |
stream->readLeaveSection(); |
744 |
} |
745 |
stream->readLeaveSection(); |
746 |
|
747 |
if (game) |
748 |
{ |
749 |
// This is a game, so we do compute elevations |
750 |
for (int t=0; t<sessionGame->numberOfTeam; t++) |
751 |
for (int r=0; r<MAX_RESOURCES; r++) |
752 |
for (int s=0; s<2; s++) |
753 |
{ |
754 |
assert(resourcesElevation[t][r][s]==NULL); |
755 |
resourcesElevation[t][r][s]=new Uint8[size]; |
756 |
updateResourcesElevation(t, r, (bool)s); |
757 |
} |
758 |
for (int t=0; t<32; t++) |
759 |
for (int r=0; r<MAX_RESOURCES; r++) |
760 |
for (int s=0; s<1; s++) |
761 |
elevationUpdated[t][r][s]=false; |
762 |
|
763 |
for (int t=0; t<sessionGame->numberOfTeam; t++) |
764 |
for (int s=0; s<2; s++) |
765 |
{ |
766 |
assert(forbiddenElevation[t][s] == NULL); |
767 |
forbiddenElevation[t][s] = new Uint8[size]; |
768 |
updateForbiddenElevation(t, s); |
769 |
assert(guardAreasElevation[t][s] == NULL); |
770 |
guardAreasElevation[t][s] = new Uint8[size]; |
771 |
updateGuardAreasElevation(t, s); |
772 |
} |
773 |
} |
774 |
|
775 |
// We load sectors: |
776 |
wSector = stream->readSint32("wSector"); |
777 |
hSector = stream->readSint32("hSector"); |
778 |
sizeSector = wSector*hSector; |
779 |
assert(sectors == NULL); |
780 |
sectors = new Sector[sizeSector]; |
781 |
arraysBuilt = true; |
782 |
|
783 |
stream->readEnterSection("sectors"); |
784 |
for (int i=0; i<sizeSector; i++) |
785 |
{ |
786 |
stream->readEnterSection(i); |
787 |
if (!sectors[i].load(stream, game)) |
788 |
{ |
789 |
stream->readLeaveSection(3); |
790 |
return false; |
791 |
} |
792 |
stream->readLeaveSection(); |
793 |
} |
794 |
stream->readLeaveSection(); |
795 |
|
796 |
stream->read(signature, 4, "signatureEnd"); |
797 |
stream->readLeaveSection(); |
798 |
|
799 |
if (memcmp(signature, "MapE", 4)!=0) |
800 |
{ |
801 |
if (verbose) |
802 |
fprintf(stderr, "Map:: Failed to find signature at the end of Map.\n"); |
803 |
return false; |
804 |
} |
805 |
|
806 |
return true; |
807 |
} |
808 |
|
809 |
void Map::save(GAGCore::OutputStream *stream) |
810 |
{ |
811 |
stream->writeEnterSection("Map"); |
812 |
stream->write("MapB", 4, "signatureStart"); |
813 |
|
814 |
// We save size: |
815 |
stream->writeSint32(wDec, "wDec"); |
816 |
stream->writeSint32(hDec, "hDec"); |
817 |
|
818 |
// We write what's inside the map: |
819 |
stream->write(undermap, size, "undermap"); |
820 |
stream->writeEnterSection("cases"); |
821 |
for (size_t i=0; i<size ;i++) |
822 |
{ |
823 |
stream->writeEnterSection(i); |
824 |
stream->writeUint32(mapDiscovered[i], "mapDiscovered"); |
825 |
|
826 |
stream->writeUint16(cases[i].terrain, "terrain"); |
827 |
stream->writeUint16(cases[i].building, "building"); |
828 |
|
829 |
//SDL_WriteBE32(stream, cases[i].resource.id); |
830 |
stream->write(&(cases[i].resource), 4, "resource"); |
831 |
|
832 |
stream->writeUint16(cases[i].groundUnit, "groundUnit"); |
833 |
stream->writeUint16(cases[i].airUnit, "airUnit"); |
834 |
stream->writeUint32(cases[i].forbidden, "forbidden"); |
835 |
stream->writeUint32(cases[i].guardArea, "guardArea"); |
836 |
stream->writeUint32(cases[i].clearArea, "clearArea"); |
837 |
stream->writeLeaveSection(); |
838 |
} |
839 |
stream->writeLeaveSection(); |
840 |
|
841 |
// We save sectors: |
842 |
stream->writeSint32(wSector, "wSector"); |
843 |
stream->writeSint32(hSector, "hSector"); |
844 |
stream->writeEnterSection("sectors"); |
845 |
for (int i=0; i<sizeSector; i++) |
846 |
{ |
847 |
stream->writeEnterSection(i); |
848 |
sectors[i].save(stream); |
849 |
stream->writeLeaveSection(); |
850 |
} |
851 |
stream->writeLeaveSection(); |
852 |
|
853 |
stream->write("MapE", 4, "signatureEnd"); |
854 |
stream->writeLeaveSection(); |
855 |
} |
856 |
|
857 |
void Map::addTeam(const team_length_t NewMaximum) |
858 |
{ |
859 |
if (MaxTeams < NewMaximum) { |
860 |
MaxTeams = NewMaximum; |
861 |
for (cell_xoffset_t x=0; x<Width; ++x) |
862 |
for (cell_yoffset_t y=0; y<Height; ++y) |
863 |
Cells[x, y].TeamData.resize(MaxTeams); |
864 |
}; |
865 |
} |
866 |
|
867 |
/* ALGORITHM: |
868 |
|
869 |
Along the X axis of the map, examine every 4th row, starting at a random row between 0 and 3. |
870 |
For each examined row, start at a random square between 0 and 15, then move right by a random number between 0 and 15 squares until you reach the end of the row. |
871 |
|
872 |
If there is no resource there, do nothing. |
873 |
|
874 |
Else, look at a square rand(15) - rand(15) squares to the right, and rand(15) - rand(15) down. In other words, binomially distributed around the current square. We'll refer to that as point 1. |
875 |
Also, look at the square twice as far away in the same direction (point 2). |
876 |
Also, look at the square the same distance in the other direction (point -1). |
877 |
|
878 |
* If there is alga on the current tile, do nothing unless there is water at point 1 and sand at point 2. |
879 |
* If there is wood or wheat on the current tile, do nothing unless there is water at point 1 and NOT sand at point -1. |
880 |
* Else, carry on no matter what |
881 |
|
882 |
If the current size of the resource is less than or equal to rand(7), the resource grows by one square. |
883 |
Else, if the resource is capable of extending, it attempts to extend into a random square next to the current one (and does nothing if it fails) |
884 |
|
885 |
*/ |
886 |
|
887 |
void Map::syncStep(Uint32 stepCounter, const Game& game) { |
888 |
// STEP 1: Grow Resources |
889 |
const int dy=(syncRand()&0x3); |
890 |
for (cell_ypos_t y=dy; y<Height; y+=4) |
891 |
for (cell_xpos_t x=(syncRand()&0xF); x<Width; x+=(syncRand()&0x1F)) { |
892 |
Cell& r=GetCell(x, y); |
893 |
if (r.HasResource()) |
894 |
{ |
895 |
cell_xoffset_t XOffset=(syncRand()&0xF)-(syncRand()&0xF); |
896 |
cell_yoffset_t YOffset=(syncRand()&0xF)-(syncRand()&0xF); |
897 |
|
898 |
// alga, wood and wheat are limited by near underground. Others are not. |
899 |
if ((r.ResourceType()==ALGA )?GetCell(x+XOffset, x+YOffset).isWater()&& GetCell(x+XOffset*2, x+YOffset*2).isSand(): |
900 |
(r.ResourceType()==WOOD||r.ResourceType()==WHEAT)?GetCell(x+XOffset, x+YOffset).isWater()&&!GetCell(x-XOffset , x-YOffset ).isSand(): |
901 |
true) |
902 |
if (r.ResourceAmount()<=(syncRand()&7)) |
903 |
// we grow the resource: |
904 |
incResource(x, y, r.type, r.variety); |
905 |
else if (globalContainer->resourcesTypes.get(r.type)->extendable) |
906 |
// extend the resource into a neighbouring square (or grow it in the current square anyway) |
907 |
incResource(x+(syncRand()&2)-1, ny(syncRand()&2)-1, r.type, r.variety); |
908 |
} |
909 |
} |
910 |
|
911 |
// STEP 2: step over each sector |
912 |
for (sector_xpos_t x=0; x<SectorWidth; ++x) |
913 |
for (sector_ypos_t y=0; y<SectorHeight; ++y) |
914 |
Sectors[x, y].syncstep(this, game); |
915 |
|
916 |
// STEP 3: update one resource elevation (a different one each tick) |
917 |
team_ID_t ResourceElevationTeam; |
918 |
Resource_enum ResourceElevationResource; |
919 |
bool ResourceElevationCanSwim; // Must initialise to true |
920 |
|
921 |
for (unsigned int n=0; n<Teams * MAX_RESOURCES * 2; ++n) { // Stop after a complete circuit |
922 |
// Increment all our values first |
923 |
if (ResourceElevationCanSwim = !ResourceElevationCanSwim) { |
924 |
if (++ResourceElevationResource >= MAX_RESOURCES) { |
925 |
ResourceElevationResource=0; |
926 |
if (++ResourceElevationTeam >= Teams) |
927 |
ResourceElevationTeam = 0; |
928 |
}; |
929 |
}; |
930 |
|
931 |
if (DirtyResources[ResourceElevationTeam] || DirtyResource[ResourceElevationTeam][ResourceElevationResource]) { |
932 |
updateResourceElevation(ResourceElevationTeam, ResourceElevationResource, ResourceElevationCanSwim); |
933 |
return; |
934 |
}; |
935 |
}; |
936 |
} |
937 |
|
938 |
inline void Map::decResource(int x, int y) { |
939 |
Cell& C = GetCell(x, y); |
940 |
assert(C.ResourceType()!=NO_RES_TYPE) |
941 |
|
942 |
const RessourceType *const fulltype=globalContainer->ressourcesTypes.get(type); |
943 |
|
944 |
if (!fulltype->shrinkable) return; |
945 |
|
946 |
if (fulltype->eternal) |
947 |
if (C.ResourceAmount()) C.decResource(); else; |
948 |
else |
949 |
if (fulltype->granular && C.ResourceAmount()>1) |
950 |
C.decResource(); |
951 |
else |
952 |
clear(); |
953 |
} |
954 |
|
955 |
inline void Map::decResource(int x, int y, resource_t R) { |
956 |
Cell& C = GetCell(x, y); |
957 |
if (C.ResourceType() != R) return; |
958 |
|
959 |
const RessourceType *const fulltype=globalContainer->ressourcesTypes.get(type); |
960 |
|
961 |
if (!fulltype->shrinkable) return; |
962 |
|
963 |
if (fulltype->eternal) |
964 |
if (C.ResourceAmount()) C.decResource(); else; |
965 |
else |
966 |
if (fulltype->granular && C.ResourceAmount()>1) |
967 |
C.decResource(); |
968 |
else |
969 |
clear(); |
970 |
} |
971 |
|
972 |
bool Map::incResource(int x, int y, int resourceType, int variety) { |
973 |
Cell& C = GetCell(x, y); |
974 |
|
975 |
if (C.type==NO_RES_TYPE) |
976 |
{ |
977 |
if (C.Building || C.GroundUnit || C.Terrain() != globalContainer->resourcesTypes.get(resourceType)->terrain) |
978 |
return false; |
979 |
|
980 |
C.Resource().Resource(resourceType, variety, 1, 0); |
981 |
return true; |
982 |
} else { |
983 |
const RessourceType *const fulltype=globalContainer->ressourcesTypes.get(type); |
984 |
|
985 |
if (!fulltype->shrinkable) |
986 |
return false; |
987 |
|
988 |
if (C.ResourceAmount()<fulltype->sizesCount) { |
989 |
C.IncResource(); |
990 |
return true; |
991 |
} else { |
992 |
C.DecResource(); |
993 |
return false; |
994 |
} |
995 |
} |
996 |
} |
997 |
|
998 |
|
999 |
|
1000 |
inline const bool const Map::doesPosTouchBuilding(cell_xpos_t X, cell_ypos_t Y, Building* B) |
1001 |
{ |
1002 |
const bool Touches(const Cell& C, cell_xoffset_t OffsetX, cell_yoffset_t OffsetY) { return C.Building == B }; |
1003 |
return FindAdjacentCell(&Touches, X, Y); |
1004 |
} |
1005 |
|
1006 |
inline const bool const Map::doesPosTouchBuilding(cell_xpos_t X, cell_ypos_t Y, Building* B, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) |
1007 |
{ |
1008 |
const bool Touches(const Cell& C, cell_xoffset_t OffsetX, cell_yoffset_t OffsetY) { return C.Building == B }; |
1009 |
return FindAdjacentCell(&Touches, X, Y, DirectionX, DirectionY); |
1010 |
} |
1011 |
|
1012 |
inline const bool const Map::doesPosTouchResource(cell_xpos_t X, cell_ypos_t Y, Resource_enum r) |
1013 |
{ |
1014 |
const bool Touches(const Cell& C, cell_xoffset_t OffsetX, cell_yoffset_t OffsetY) { return C.Resource.type == r }; |
1015 |
return FindAdjacentCell(&Touches, X, Y); |
1016 |
} |
1017 |
|
1018 |
inline const bool const Map::doesPosTouchResource(cell_xpos_t X, cell_ypos_t Y, Resource_enum r, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) |
1019 |
{ |
1020 |
const bool Touches(const Cell& C, cell_xoffset_t OffsetX, cell_yoffset_t OffsetY) { return C.Resource.type == r }; |
1021 |
return FindAdjacentCell(&Touches, X, Y, DirectionX, DirectionY); |
1022 |
} |
1023 |
|
1024 |
inline const bool const Map::doesUnitTouchBuilding(const Unit& unit, Building* B, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) |
1025 |
{ return doesPosTouchBuilding(Pos.X, Pos.Y, B, DirectionX, DirectionY); } |
1026 |
inline const bool const Map::doesUnitTouchBuilding(const Unit& unit, Building* B ) |
1027 |
{ return doesPosTouchBuilding(Pos.X, Pos.Y, B); } |
1028 |
inline const bool const Map::doesUnitTouchResource(const Unit& unit, Resource_enum r, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) |
1029 |
{ return doesPosTouchResource(Pos.X, Pos.Y, r, DirectionX, DirectionY); } |
1030 |
inline const bool const Map::doesUnitTouchResource(const Unit& unit, Resource_enum r ) |
1031 |
{ return doesPosTouchResource(Pos.X, Pos.Y, r); } |
1032 |
|
1033 |
//! This method gives a good direction to hit for a warrior, and return false if nothing was found. |
1034 |
//! Currently, it chooses to hit any turret if available, then units, then other buildings. It chooses between units based on their speed and delta(?) |
1035 |
//! It should somehow realise when it's under attack and go after the dangerous things |
1036 |
//TODO: can ground WARRIOR hit flying EXPLORER ? |
1037 |
bool Map::doesUnitTouchEnemy(const Unit& unit, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) |
1038 |
{ |
1039 |
elevation_sum_t BestTime=elevation_max+1; |
1040 |
const bool Touches(const Cell& C, cell_xoffset_t OffsetX, cell_yoffset_t OffsetY) { |
1041 |
if (C.Building() && Unit.Team.EnemyOf(C.Building()->Team) && C.Building.type->defaultUnitStayRange) { |
1042 |
if (b->type->shootingRange) { |
1043 |
DirectionX=OffsetX; |
1044 |
DirectionY=OffsetY; |
1045 |
return true; |
1046 |
} else if (bestTime==elevation_max+1) { |
1047 |
DirectionX=OffsetX; |
1048 |
DirectionY=OffsetY; |
1049 |
bestTime=elevation_max; |
1050 |
}; |
1051 |
}; |
1052 |
|
1053 |
if (C.GroundUnit() && Unit.Team.EnemyOf(C.GroundUnit()->Team) && (C.GroundUnit()->foreingExchangeBuilding==NULL || C.GroundUnit()->Team->sharedVisionExchange()==0)) |
1054 |
if (int time=(elevation_max-otherUnit->delta)/otherUnit->speed < bestTime) { |
1055 |
bestTime=time; |
1056 |
DirectionX=OffsetX; |
1057 |
DirectionY=OffsetY; |
1058 |
}; |
1059 |
return false; |
1060 |
}; |
1061 |
|
1062 |
FindAdjacentCell(&Touches, X, Y); |
1063 |
return bestTime < elevation_max; |
1064 |
} |
1065 |
|
1066 |
// Fixme: shouldn't we iterate one more along the X and Y axes? See SetUndermapArea for example |
1067 |
void Map::setNoResource(const cell_xpos_t x, const cell_ypos_t y, const cell_size_t Length) |
1068 |
{ |
1069 |
assert(l>=0); |
1070 |
assert(l<w); |
1071 |
assert(l<h); |
1072 |
const cell_size_t HalfLength = Length >> 1; |
1073 |
for (cell_xoffset_t X1=X-HalfLength; X1<X+HalfLength; ++XOffset) |
1074 |
for (cell_yoffset_t Y1=Y-HalfLength; YOffset<=Y+HalfLength; ++YOffset) |
1075 |
GetCell(X1, Y1).Resource().Resource(); |
1076 |
} |
1077 |
|
1078 |
//! Fill a the squares (x-L/2, y-L/2)..(x+L/2, y+L/2) with resources of the specified type |
1079 |
void Map::FillAreaWithResource(int x, int y, int type, int Length) |
1080 |
{ |
1081 |
assert(l>=0); |
1082 |
assert(l<w); |
1083 |
assert(l<h); |
1084 |
const cell_size_t HalfLength = Length >> 1; |
1085 |
for (cell_xoffset_t X1=X-HalfLength; X1<X+HalfLength; ++XOffset) |
1086 |
for (cell_yoffset_t Y1=Y-HalfLength; YOffset<=Y+HalfLength; ++YOffset) |
1087 |
if (GetCell(X1, Y1).isResourceAllowed(type)) { |
1088 |
Resource& r = GetCell(X1, Y1).Resource(); |
1089 |
r.type=type; |
1090 |
ResourceType *rt=globalContainer->resourcesTypes.get(type); |
1091 |
r.variety = syncRand() % rt->varietiesCount; |
1092 |
assert(rt->sizesCount>1); |
1093 |
r.ResourceAmount()=1 + syncRand() % (rt->sizesCount-1); |
1094 |
r.animation=0; |
1095 |
} |
1096 |
} |
1097 |
|
1098 |
const bool Map::resourceAvailable(const team_ID_t Team, const Resource_Enum R, const bool CanSwim, const cell_xpos_t x, const cell_ypos_t y, cell_xpos_t& targetX, cell_ypos_t& targetY, const elevation_t* dist) const { |
1099 |
// distance and availability |
1100 |
bool result = GetCell(x, y)[Team].ResourceAvailable(R, CanSwim); |
1101 |
|
1102 |
if (dist) *dist = result?elevation_max - result:result; |
1103 |
|
1104 |
// target position |
1105 |
resourceAvailableCount[Team][R]++; |
1106 |
if (getGlobalElevationDestination(targetX=x, targetY=y, Team, (Can_Swim?RESOURCE_SWIM:RESOURCE_NOSWIM) + R)) |
1107 |
resourceAvailableCountSuccess[teamNumber][resourceType]++; |
1108 |
else |
1109 |
resourceAvailableCountFailure[teamNumber][resourceType]++; |
1110 |
|
1111 |
return result; |
1112 |
} |
1113 |
|
1114 |
//! Climb the elevation hill to the highest point in MaxHillclimbIterations iterations, to a local maximum, or to the destination |
1115 |
typedef const elevation_t (*ElevationCalculator)(const Cell&, const cell_xpos_t, const cell_ypos_t); |
1116 |
static bool Map::ClimbElevationHill(cell_xpos_t& x, cell_ypos_t& y, const team_ID_t p, const ElevationCalculator& Elevation) |
1117 |
{ |
1118 |
// max is initiaslized to elevation value of current position |
1119 |
elevation_t max = Elevation(x, y); |
1120 |
|
1121 |
// for up to 256 steps, we follow elevation |
1122 |
for (int count=0; count<MaxHillclimbIterations; count++) |
1123 |
{ |
1124 |
bool found = false; |
1125 |
x_offset_t best_x = 0; // -1, 0, or +1 |
1126 |
y_offset_t best_y = 0; // -1, 0, or +1 |
1127 |
elevation_t g; |
1128 |
|
1129 |
inline void check_direction(const cell_xpos_t x1, const cell_xpos_t y1) { if ((g=Elevation(x+x1, y+y1)>max) { max=g; best_x=x1; best_y=y1; found=true; } }; |
1130 |
|
1131 |
check_direction(-1, -1); check_direction(0, -1); check_direction(1, -1); |
1132 |
check_direction(0, -1); /* Current cell */ check_direction(1, 0); |
1133 |
check_direction(1, -1); check_direction(0, 1); check_direction(1, 1); |
1134 |
|
1135 |
x += best_x; |
1136 |
y += best_y; |
1137 |
|
1138 |
// break if we have reached a local maximum or the destination |
1139 |
if (!found || max == elevation_max) |
1140 |
return found; |
1141 |
} |
1142 |
|
1143 |
return false; |
1144 |
} |
1145 |
|
1146 |
/** |
1147 |
Update Elevations |
1148 |
**/ |
1149 |
|
1150 |
//! Take a elevation map where individual squares have had elevations applied, and propagate those values to nearby squares |
1151 |
void Map::PropagateElevation(const team_ID_t p, const elevation_index_t i) { |
1152 |
assert(i < TotalElevations); |
1153 |
void update(const cell_pos_t x, const cell_pos_t y, const elevation_t g) { |
1154 |
if (Cells[x, y][p][i] >= g) return; |
1155 |
Cells[x, y][p][i] = g--; |
1156 |
if (g<elevation_min) next; |
1157 |
|
1158 |
update(x-1, y-1, g); update(x, y-1, g); update(x+1, y-1); |
1159 |
update(x-1, y , g); /* current cell */ update(x+1, y ); |
1160 |
update(x-1, y+1, g); update(x, y+1, g); update(x+1, y+1); |
1161 |
}; |
1162 |
|
1163 |
for (cell_ypos_t y = 0; y < Height; ++y) |
1164 |
for (cell_xpos_t x = 0; x < Width; ++x) { |
1165 |
const elevation_t g = Cells[x, y][p][i] - 1; |
1166 |
if (g<elevation_min) next; |
1167 |
|
1168 |
update(x-1, y-1); update(x, y-1); update(x+1, y-1); |
1169 |
update(x-1, y ); /* current cell */ update(x+1, y ); |
1170 |
update(x-1, y+1); update(x, y+1); update(x+1, y+1); |
1171 |
}; |
1172 |
}; |
1173 |
|
1174 |
void Map::updateResourcesElevation(const team_ID_t p, const Resource_enum R, const bool CanSwim) |
1175 |
{ |
1176 |
const elevation_index_t i = (CanSwim?RESOURCE_SWIM:RESOURCE_NOSWIM) + R; |
1177 |
assert(i < TotalElevations); |
1178 |
bool NotVisibleToBeCollected=(globalContainer->resourcesTypes.get(resourceType)->visibleToBeCollected)?0:1; |
1179 |
|
1180 |
const bool updateCell(Cell& c, cell_xpos_t, cell_ypos_t) { |
1181 |
c[p][i] = |
1182 |
c[p].Forbidden || // is it a forbidden area? |
1183 |
c.Building || // is it a building? |
1184 |
(!canSwim && c.isWater())?0: // Is it water (and you can't swim)? |
1185 |
c.Resource.type==ResourceType && // Otherwise, is it the right resource, invisible and hidden(?) |
1186 |
(NotVisibleToBeCollected || c[p].Fog(FogOfWarAB))?elevation_max: |
1187 |
1 |
1188 |
return true; |
1189 |
} |
1190 |
IterateOverArea(&updateCell); |
1191 |
PropagateElevation(i); |
1192 |
} |
1193 |
|
1194 |
//! The forbidden map controls all types of forbidden area: |
1195 |
// cells with a resource, building or water (if you can't swim) are most forbidden, |
1196 |
// cells in a forbidden area are slightly less forbidden, |
1197 |
// other cells are totally allowed |
1198 |
void Map::updateForbiddenElevation(const team_ID_t p, const bool CanSwim) |
1199 |
{ |
1200 |
const elevation_index_t i = CanSwim?FORBIDDEN_SWIM:FORBIDDEN_NOSWIM; |
1201 |
assert(i < TotalElevations); |
1202 |
|
1203 |
const bool updateCell(Cell& c, cell_xpos_t, cell_ypos_t) { |
1204 |
c[p][i] = |
1205 |
(c.Resource().type!=NO_RES_TYPE) || |
1206 |
c.Building || |
1207 |
(!canSwim && c.isWater())?0: |
1208 |
c[p].Forbidden()?1:elevation_max |
1209 |
return true; |
1210 |
} |
1211 |
IterateOverArea(&updateCell); |
1212 |
PropagateElevation(i); |
1213 |
} |
1214 |
|
1215 |
inline void Map::updateForbiddenElevation(const team_ID_t p) { |
1216 |
updateForbiddenElevation(p, false); |
1217 |
updateForbiddenElevation(p, true); |
1218 |
}; |
1219 |
|
1220 |
void Map::updateGuardAreasElevation(const team_ID_t p, const bool CanSwim) |
1221 |
{ |
1222 |
const elevation_index_t i = CanSwim?GUARD_SWIM:GUARD_NOSWIM; |
1223 |
assert(i < TotalElevations); |
1224 |
|
1225 |
const bool updateCell(Cell& c, cell_xpos_t, cell_ypos_t) { |
1226 |
c[p][i] = |
1227 |
c[p].Forbidden() || // Is it a forbidden area? |
1228 |
(c.Resource().type!=NO_RES_TYPE) || // Is there a resource in the way? |
1229 |
c.Building || // Is there a building in the way? |
1230 |
(!canSwim && c.isWater())?0: // Is there water you can't swim past? |
1231 |
c[p].Guarded()?elevation_max:1 // Is it a forbidden area? |
1232 |
return true; |
1233 |
} |
1234 |
IterateOverArea(&updateCell); |
1235 |
PropagateElevation(i); |
1236 |
} |
1237 |
|
1238 |
inline void Map::updateGuardAreasElevation(const team_ID_t p) { |
1239 |
updateGuardAreasElevation(p, false); |
1240 |
updateGuardAreasElevation(p, true); |
1241 |
}; |
1242 |
|
1243 |
|
1244 |
/** The following could *seems* to be redundant. I'll remove it later if that turns out to be the case |
1245 |
|
1246 |
A mini-elevation is a 5x5 grid of elevations, where the values have not been propagated to one another. |
1247 |
It is used to heuristically decide which way to move from a given position. |
1248 |
|
1249 |
The miniElevationToDirection() function looks at the eight directions you could move in next turn... |
1250 |
for diagonal moves, it looks at the five sensible moves you can make from there... |
1251 |
for horizontal and vertical moves, it looks at the three sensible moves you can make from there... |
1252 |
here is a diagram showing the "sensible" moves: |
1253 |
|
1254 |
*** *** *** |
1255 |
** * ** |
1256 |
* * |
1257 |
|
1258 |
* * |
1259 |
** * ** |
1260 |
* * |
1261 |
|
1262 |
* * |
1263 |
** * ** |
1264 |
*** *** *** |
1265 |
|
1266 |
(for example, it's not sensible to move up then left, or left then right) |
1267 |
|
1268 |
The function looks at the highest elevation you could get to in two moves, and where there's a tie, the highest elevation in one move is a tiebreaker. |
1269 |
|
1270 |
In "strict" mode, the function will fail unless a better elevation is found. Otherwise, it will fail unless a *different* elevation is found. |
1271 |
|
1272 |
** / |
1273 |
|
1274 |
bool MiniElevationsientToDirection(elevation_t MiniElevations[5, 5], cell_xoffset_t& dx, cell_yoffset_t& dy, const bool strict, bool verbose) |
1275 |
{ |
1276 |
|
1277 |
elevation_t max; |
1278 |
const elevation_t CentralElevation=(MiniElevations[2, 2]<<8)|MiniElevations[2, 2]; |
1279 |
elevation_t GreatestElevation=CentralElevation; |
1280 |
int GreatestDirection=8; // Direction with the greatest elevation |
1281 |
bool AcceptableDestination=false; // Have we seen a destination that looks acceptable |
1282 |
|
1283 |
inline void CheckDiagonal(Direction, x0, y0, x1, y1, x2, y2, x3, y3, x4, y4, x5, y5) { |
1284 |
if (max=MiniElevations[x0, y0] && max != elevation_max) { // if the nearby cell isn't a perfect success of perfect failure |
1285 |
max=1; |
1286 |
if (MiniElevations[x1, y1]>max) max = MiniElevations[x1, y1]; |
1287 |
if (MiniElevations[x2, y2]>max) max = MiniElevations[x2, y2]; |
1288 |
if (MiniElevations[x3, y3]>max) max = MiniElevations[x3, y3]; |
1289 |
if (MiniElevations[x4, y4]>max) max = MiniElevations[x4, y4]; |
1290 |
if (MiniElevations[x5, y5]>max) max = MiniElevations[x5, y5]; |
1291 |
}; |
1292 |
|
1293 |
Uint32 Elevation = (max<<8)|MiniElevations[x0, y0]; |
1294 |
if (strict?Elevation>CentralElevation:Elevation && Elevation!=CentralElevation) |
1295 |
AcceptableDestination=true; |
1296 |
if (Elevation>=GreatestElevation) { |
1297 |
GreatestElevation=Elevation; |
1298 |
GreatestDirection=Direction; |
1299 |
} |
1300 |
}; |
1301 |
inline void CheckHorizontalVertical(Direction, x0, y0, x1, y1, x2, y2, x3, y3) { |
1302 |
if (max=MiniElevations[x0, y0] && max != elevation_max) { // if the nearby cell isn't a perfect success of perfect failure |
1303 |
max=1; |
1304 |
if (MiniElevations[x1, y1]>max) max = MiniElevations[x1, y1]; |
1305 |
if (MiniElevations[x2, y2]>max) max = MiniElevations[x2, y2]; |
1306 |
if (MiniElevations[x3, y3]>max) max = MiniElevations[x3, y3]; |
1307 |
}; |
1308 |
|
1309 |
Uint32 Elevation = (max<<8)|MiniElevations[x0, y0]; |
1310 |
if (strict?Elevation>CentralElevation:Elevation && Elevation!=CentralElevation) |
1311 |
AcceptableDestination=true; |
1312 |
if (Elevation>=GreatestElevation) { |
1313 |
GreatestElevation=Elevation; |
1314 |
GreatestDirection=Direction; |
1315 |
} |
1316 |
}; |
1317 |
|
1318 |
CheckDiagonal(0, 1,1, 0,2, 0,1, 0,0, 1,0, 2,0); // Top-left |
1319 |
CheckDiagonal(1, 3,1, 2,0, 3,0, 4,0, 4,1, 4,2); // Top-right |
1320 |
CheckDiagonal(2, 3,3, 4,2, 4,3, 4,4, 3,4, 2,4); // Bottom-right |
1321 |
CheckDiagonal(3, 1,3, 2,4, 1,4, 0,4, 0,3, 0,2); // Bottom-left |
1322 |
|
1323 |
CheckHorizontalVertical(4, 2,1, 1,0, 2,0, 3,0); // Top |
1324 |
CheckHorizontalVertical(5, 3,2, 4,1, 4,2, 4,3); // Right |
1325 |
CheckHorizontalVertical(6, 2,3, 1,4, 2,4, 3,4); // Bottom |
1326 |
CheckHorizontalVertical(7, 1,2, 0,1, 0,2, 0,3); // Left |
1327 |
|
1328 |
if (verbose) |
1329 |
{ |
1330 |
printf("MiniElevations (%d):\n", strict); |
1331 |
for (int ry=0; ry<5; ry++) |
1332 |
{ |
1333 |
for (int rx=0; rx<5; rx++) |
1334 |
printf("%4d", MiniElevations[rx, ry]); |
1335 |
printf("\n"); |
1336 |
} |
1337 |
printf("max=%4d.%4d (%d), d=%d, AcceptableDestination=%d\n", GreatestElevation>>8, GreatestElevation&0xFF, GreatestElevation, GreatestDirection, AcceptableDestination); |
1338 |
} |
1339 |
|
1340 |
if (!AcceptableDestination) |
1341 |
return false; |
1342 |
|
1343 |
Unit::dxdyfromDirection((GreatestDirection<4)?GreatestDirection<<1: |
1344 |
GreatestDirection==8?8: |
1345 |
1+((GreatestDirection-4)<<1), |
1346 |
dx, dy); |
1347 |
|
1348 |
return true; |
1349 |
} |
1350 |
|
1351 |
//! Generate a mini-elevation grid then pass it to MiniElevationsientToDirection() for handling |
1352 |
bool Map::directionByMiniElevations(const team_ID_t team, const bool CanSwim, const elevation_index_t ElevationIndex, cell_xpos_t x, cell_ypos_t y, cell_xoffset_t& dx, cell_xoffset_t& dy, const bool strict, const bool verbose) |
1353 |
{ |
1354 |
elevation_t MiniElevations[5, 5]; |
1355 |
|
1356 |
// Outside horizontal lines |
1357 |
for (elevation_index_t i=0; i<4; ++i) { |
1358 |
const Cell& C = GetCell(x+i, y ); MiniElevations[i, 0] = (C[Team][ElevationIndex]==0 || C[Team][ElevationIndex]==elevation_max || C.isFreeForGroundUnit(CanSwim, team))?C[Team][ElevationIndex]:0; |
1359 |
const Cell& D = GetCell(x+i, y+4); MiniElevations[i, 4] = (D[Team][ElevationIndex]==0 || D[Team][ElevationIndex]==elevation_max || D.isFreeForGroundUnit(CanSwim, team))?D[Team][ElevationIndex]:0; |
1360 |
}; |
1361 |
// Outside and inside vertical lines |
1362 |
for (elevation_index_t i=1; i<3; ++i) { |
1363 |
const Cell& C = GetCell(x , y+i); MiniElevations[0, i] = (C[Team][ElevationIndex]==0 || C[Team][ElevationIndex]==elevation_max || C.isFreeForGroundUnit(CanSwim, team))?C[Team][ElevationIndex]:0; |
1364 |
const Cell& D = GetCell(x+4, y+i); MiniElevations[4, i] = (D[Team][ElevationIndex]==0 || D[Team][ElevationIndex]==elevation_max || D.isFreeForGroundUnit(CanSwim, team))?D[Team][ElevationIndex]:0; |
1365 |
|
1366 |
const Cell& E = GetCell(x+1, y+i); MiniElevations[1, i] = (E[Team][ElevationIndex]==0 || E.isFreeForGroundUnit(CanSwim, team))?E[Team][ElevationIndex]:0; |
1367 |
const Cell& F = GetCell(x+3, y+i); MiniElevations[3, i] = (F[Team][ElevationIndex]==0 || F.isFreeForGroundUnit(CanSwim, team))?F[Team][ElevationIndex]:0; |
1368 |
}; |
1369 |
|
1370 |
// Inside middle vertical lines |
1371 |
const Cell& C = GetCell(x+2, y+1); MiniElevations[2, 1] = (C[Team][ElevationIndex]==0 || C.isFreeForGroundUnit(CanSwim, team))?C[Team][ElevationIndex]:0; |
1372 |
MiniElevations[2, 2] = GetCell(x+2, y+2)[Team][ElevationIndex]; |
1373 |
const Cell& D = GetCell(x+2, y+3); MiniElevations[2, 3] = (D[Team][ElevationIndex]==0 || D.isFreeForGroundUnit(CanSwim, team))?D[Team][ElevationIndex]:0; |
1374 |
|
1375 |
if (verbose) |
1376 |
printf("directionByMinigrad global %d\n", canSwim); |
1377 |
return directionFromMinigrad(MiniElevations, dx, dy, strict, verbose); |
1378 |
} |
1379 |
|
1380 |
//! Same, but use a specific local elevation map |
1381 |
bool Map::directionByMiniElevation(const team_ID_t team, const bool CanSwim, const cell_xpos_t x, const cell_ypos_t y, |
1382 |
const cell_xoffset_t LocalOffsetX, cost cell_yoffset_t LocalOffsetY, |
1383 |
cell_xoffset_t& dx, cell_yoffset_t& dy, |
1384 |
elevation_t localElevation[32, 32], bool strict, bool verbose) { |
1385 |
Uint8 miniElevations[5, 5]; |
1386 |
for (cell_xoffset_t XOffset=0; XOffset<5; ++XOffset) |
1387 |
for (cell_yoffset_t YOffset=0; YOffset<5; ++YOffset) |
1388 |
{ |
1389 |
int GlobalX=(x+XOffset-2); |
1390 |
int GlobalY=(y+YOffset-2); |
1391 |
int LocalX=(GlobalX-LocalOffsetX+15)%Width; |
1392 |
int LocalY=(GlobalY-LocalOffsetY+15)%Height; |
1393 |
|
1394 |
if (LocalX==Width-1) { ++GlobalX; LocalX=0; } |
1395 |
else if (LocalX==32) { --GlobalX; LocalX=31; } |
1396 |
|
1397 |
if (LocalY==hMask) { ++GlobalY; LocalY=0; } |
1398 |
else if (LocalY==32) { --GlobalY; LocalY=31; } |
1399 |
|
1400 |
assert(LocalX>=0); assert(LocalY>=0); |
1401 |
assert(LocalX<32); assert(LocalY<32); |
1402 |
|
1403 |
elevation_t Elevation=localElevation[LocalX, LocalY]; |
1404 |
|
1405 |
miniElevations[XOffset, YOffset] = |
1406 |
(Elevation==0 || Elevation==elevation_max || (XOffset==2 && YOffset==2) || GetCell(GlobalX, GlobalY).isFreeForGroundUnit(canSwim, team))?Elevation:0; |
1407 |
} |
1408 |
|
1409 |
for (cell_xoffset_t XOffset=1; XOffset<4; ++XOffset) |
1410 |
for (cell_yoffset_t YOffset=1; YOffset<4; ++YOffset) |
1411 |
if (miniElevations[XOffset, YOffset]==elevation_max && !GetCell((x+XOffset-2)%Width, (y+YOffset-2)%Height).isFreeForGroundUnit(canSwim, teamMask)) |
1412 |
miniGrad[XOffset, YOffset]=0; |
1413 |
|
1414 |
if (verbose) |
1415 |
printf("directionByMinigrad local %d\n", CanSwim); |
1416 |
return directionFromMinigrad(miniElevations, dx, dy, strict, verbose); |
1417 |
} |
1418 |
*/ |
1419 |
|
1420 |
typedef const elevation_sum_t (*ElevationFinder)(const Cell&, const cell_xpos_t, const cell_ypos_t); |
1421 |
template <ElevationFinder OptionElevation, elevation_t hilltop=255, elevation_t valley=1, elevation_t trough=0, gradient_t gradient=1> |
1422 |
const bool const Map::PathFind(team_ID_t team, bool CanSwim, cell_xpos_t X, cell_ypos_t Y, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) { |
1423 |
|
1424 |
elevation_sum_t max = OptionElevation(GetCell(X, Y), X, Y); |
1425 |
|
1426 |
if (max == hilltop) // can't get any higher than a hilltop |
1427 |
return false; |
1428 |
|
1429 |
const bool Found(const Cell& C, const cell_xpos_t x, const cell_ypos_t y) { |
1430 |
if (!C.isFreeForGroundUnitNoForbidden(canSwim)) |
1431 |
continue; |
1432 |
|
1433 |
const elevation_sum_t C_Elevation = OptionElevation(C, x, y); |
1434 |
|
1435 |
if (C_Elevation >= max) { |
1436 |
max = C_Elevation; |
1437 |
if (verbose) |
1438 |
printf("new max=%d\n", max); |
1439 |
DirectionX = x; |
1440 |
DirectionY = y; |
1441 |
}; |
1442 |
|
1443 |
return C_Elevation == hilltop; |
1444 |
}; |
1445 |
|
1446 |
FindAdjacentCell(&Found); |
1447 |
|
1448 |
return maxValue; |
1449 |
} |
1450 |
|
1451 |
const bool const Map::PathFindForbidden(team_ID_t team, bool CanSwim, cell_xpos_t X, cell_ypos_t Y, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) { |
1452 |
if (verbose) |
1453 |
printf("pathFindForbidden(%d, %d, (%d, %d))\n", team, CanSwim, X, Y); |
1454 |
++pathfindForbiddenCount; |
1455 |
|
1456 |
const elevation_index_t ElevationIndex = CanSwim?FORBIDDEN_SWIM:FORBIDDEN_NOSWIM; |
1457 |
const elevation_sum_t forbidden(const Cell& C, const cell_xpos_t, const cell_ypos_t) { return C[ElevationIndex] }; |
1458 |
|
1459 |
if (PathFind<forbidden>(team, CanSwim, X, Y, DirectionX, DirectionY)) { |
1460 |
if (verbose) |
1461 |
printf(" Success (%d:%d) (%d, %d)\n", (maxValue>>8), (maxValue&0xFF), *dx, *dy); |
1462 |
pathfindForbiddenCountSuccess++; |
1463 |
return true; |
1464 |
} else { |
1465 |
if (verbose) |
1466 |
printf(" Failure (%d)\n", maxValue); |
1467 |
pathfindForbiddenCountFailure++; |
1468 |
return false; |
1469 |
}; |
1470 |
|
1471 |
}; |
1472 |
|
1473 |
const bool const Map::PathFindGuardArea(team_ID_t team, bool CanSwim, cell_xpos_t X, cell_ypos_t Y, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY) { |
1474 |
if (verbose) |
1475 |
printf("pathFindGuardArea(%d, %d, (%d, %d))\n", team, CanSwim, X, Y); |
1476 |
++pathfindGuardAreaCount; |
1477 |
|
1478 |
const elevation_index_t ElevationIndex = CanSwim?GUARDAREA_SWIM:GUARDAREA_NOSWIM; |
1479 |
const elevation_sum_t guardarea(const Cell& C, const cell_xpos_t, const cell_ypos_t) { return C[ElevationIndex] }; |
1480 |
|
1481 |
if (PathFind<guardarea>(team, CanSwim, X, Y, DirectionX, DirectionY)) { |
1482 |
if (verbose) |
1483 |
printf(" Success (%d:%d) (%d, %d)\n", (maxValue>>8), (maxValue&0xFF), *dx, *dy); |
1484 |
pathfindGuardAreaCountSuccess++; |
1485 |
return true; |
1486 |
} else { |
1487 |
updateGuardAreasElevation(team, CanSwim); |
1488 |
if (verbose) |
1489 |
printf(" Failure (%d)\n", maxValue); |
1490 |
pathfindGuardAreaCountFailure++; |
1491 |
return false; |
1492 |
}; |
1493 |
|
1494 |
}; |
1495 |
|
1496 |
bool Map::pathfindResource(const team_ID_t team, resource_t R, const bool CanSwim, const cell_xpos_t X, const cell_ypos_t Y, cell_xpos_t& DirectionX, cell_ypos_t& DirectionY, bool& stopWork) { |
1497 |
if (verbose) |
1498 |
printf("pathFindResource(%d, %d, (%d, %d))\n", team, CanSwim, X, Y); |
1499 |
++pathfindResourceCount; |
1500 |
assert(resourceType<MAX_RESOURCES); |
1501 |
|
1502 |
const elevation_index_t ElevationIndex = (CanSwim?RESOURCE_SWIM:RESOURCE_NOSWIM) + R; |
1503 |
const elevation_index_t ForbiddenIndex = (CanSwim?FORBIDDEN_SWIM:FORBIDDEN_NOSWIM); |
1504 |
|
1505 |
const elevation_sum_t resource(const Cell& C, const cell_xpos_t, const cell_ypos_t) { return C[ForbiddenIndex]<<8 + C[ElevationIndex] }; |
1506 |
|
1507 |
if (PathFind<resource>(team, CanSwim, X, Y, DirectionX, DirectionY)) { |
1508 |
stopWork=true; |
1509 |
|
1510 |
if (verbose) |
1511 |
printf(" Success (%d:%d) (%d, %d)\n", (maxValue>>8), (maxValue&0xFF), *dx, *dy); |
1512 |
pathfindResourceCountSuccess++; |
1513 |
return true; |
1514 |
} else { |
1515 |
stopWork = GetCell(X, Y)[ElevationIndex]<2; |
1516 |
|
1517 |
if (verbose) |
1518 |
printf(" Failure (%d)\n", maxValue); |
1519 |
pathfindResourceCountFailure++; |
1520 |
return false; |
1521 |
}; |
1522 |
} |
1523 |
|
1524 |
inline void Map::dirtyAllBuildingElevations(cell_xpos_t x, cell_ypos_t y, cell_height_t XMax, cell_width_t YMax, Team* T) |
1525 |
{ |
1526 |
const bool DirtyBuilding(const Cell& C, cell_xpos_t, cell_ypos_t) { if (C.Building() && C.Building->Team == T) C.Building()->MakeDirty() }; |
1527 |
return IterateOverArea(&DirtyBuilding, x, y, XMax-1, YMax-1); |
1528 |
} |
1529 |
|
1530 |
/** |
1531 |
Set the undermap for a square of Length*Length cells |
1532 |
Since grass isn't allowed next to water, sand is inserted around the edge as necessary |
1533 |
**/ |
1534 |
void Map::SetUndermapArea(cell_xpos_t X, cell_ypos_t Y, undertile_t t, cell_size_t Length) |
1535 |
{ |
1536 |
const cell_size_t HalfLength = Length >> 1; |
1537 |
for (cell_xoffset_t X1=X-HalfLength; X1<=X+HalfLength; ++XOffset) |
1538 |
for (cell_yoffset_t Y1=Y-HalfLength; YOffset<=Y+HalfLength; ++YOffset) |
1539 |
GetCell(X1, Y1).Undertile(t); |
1540 |
|
1541 |
if (t==SAND) |
1542 |
return regenerate(x-HalfLength-1,y-HalfLength-1,Length+1,Length+1); |
1543 |
|
1544 |
const undertile_t OtherType = (t==GRASS)?WATER:GRASS; |
1545 |
const cell_ypos_t Top = Y-HalfLength-1; |
1546 |
const cell_ypos_t Bottom = Y+HalfLength+1; |
1547 |
const cell_ypos_t Left = X-HalfLength-1; |
1548 |
const cell_ypos_t Right = X+HalfLength+1; |
1549 |
|
1550 |
for (cell_xpos_t X1=Left; X1<=Right; ++X1) { |
1551 |
Cell(X1, Top ).MaybeToSand(OtherType); |
1552 |
Cell(X1, Bottom).MaybeToSand(OtherType); |
1553 |
}; |
1554 |
for (cell_ypos_t Y1=Top+1; X1<Bottom; ++Y1) { |
1555 |
Cell(Left , Y1).MaybeToSand(OtherType); |
1556 |
Cell(Right, Y1).MaybeToSand(OtherType); |
1557 |
}; |
1558 |
|
1559 |
regenerate(x-HalfLength-2,y-HalfLength-2,Length+3,Length+3); |
1560 |
} |
1561 |
|
1562 |
/** |
1563 |
If a tile contains a resource, there is a 1/32 chance that... |
1564 |
If the amount of resources there is less than a random number from 0 to 3, it is incremented by one. |
1565 |
Else, pick a random adjacent square. |
1566 |
If there is no ground unit ther and the terrain is of the appropriate type, put a resource there of the same type, level either 0 or 5 |
1567 |
**/ |
1568 |
inline void Map::smoothResources(unsigned int times) { |
1569 |
const bool SmoothResource(const Cell& C, const cell_xpos_t x, const cell_ypos_t y) { |
1570 |
Resource& R = C.Resource(); |
1571 |
if (R && (syncRand&1)) { |
1572 |
if (R.amount < syncRand()&3) |
1573 |
++R; // Increment the level of the resource |
1574 |
else |
1575 |
GetAdjacentCell(x, y).SetResource(Resource.type, (syncRand()&1)*5); |
1576 |
}; |
1577 |
}; |
1578 |
|
1579 |
|
1580 |
while (times--) |
1581 |
IterateOverArea(&SmoothResource); |
1582 |
}; |
1583 |
|
1584 |
//! Create a random terrain, smooth it out, then fill it with resources |
1585 |
bool Map::makeRandomMap(const MapGenerationDescriptor &descriptor) |
1586 |
{ |
1587 |
//! Create a square grid of random terrains, of side 8^(smooth&0x3), smooth it 'smooth' times, then return the number of water, wood, and sand squares |
1588 |
//! This is better than simply generating numbers based on the appropriate ratios, because it accounts for the biases introduced when smoothing a grid of a given size. |
1589 |
//! Note: this code is closely folloed by a section of the main program - any changes here should be put there too |
1590 |
void simulateRandomMap(unsigned int smooth, double& Water, double& Sand, double& Grass) |
1591 |
{ |
1592 |
const unsigned int length=8<<(smooth&0x3); |
1593 |
const unsigned int area=length*length; |
1594 |
resource_t undermap[area]; |
1595 |
|
1596 |
int totalRatio=0x7FFF; |
1597 |
int waterRatio=(int)(Water*((double)totalRatio)); assert(waterRatio >= 0); |
1598 |
int sandRatio =(int)(Sand *((double)totalRatio)); assert( sandRatio >= 0); |
1599 |
int grassRatio=(int)(Grass*((double)totalRatio)); assert(grassRatio >= 0); |
1600 |
totalRatio=waterRatio+sandRatio+grassRatio; |
1601 |
|
1602 |
// ONE: create a fully random patchwork |
1603 |
for (int p=0; p<area; ++p) { |
1604 |
int r=syncRand()%totalRatio; |
1605 |
undermap[p] = (r-=waterRatio<0)?WATER:(r-=grassRatio<0)?GRASS:(r<sandRatio)?SAND:assert(false); |
1606 |
} |
1607 |
|
1608 |
// TWO: where tiles on two different sides are of the same type, set the current tile to that type (i.e. smooth out the distribution of tiles) |
1609 |
inline const bool setUndermap(const int testPos) { |
1610 |
if (undermap[(p+testPos)%area]==undermap[(p-testPos)%area]) { undermap[p]=undermap[(p+testPos)%area]; return true } else return false; |
1611 |
}; |
1612 |
while (smooth--) |
1613 |
for (int p=0; p<area; ++p) |
1614 |
if (((syncRand()&1)?setUndermap( 1 ):setUndermap(length )) || |
1615 |
((syncRand()&1)?setUndermap(length+1 ):setUndermap(length-1 )) || |
1616 |
((syncRand()&1)?setUndermap(length-2 ):setUndermap(length -(length<<1))) || |
1617 |
((syncRand()&1)?setUndermap(length+2+(length<<1)):setUndermap(length+2-(length<<1)))) |
1618 |
{}; |
1619 |
|
1620 |
// What's finally in ? |
1621 |
double Counts[undertile_total]; totals[WATER]==0; totals[SAND]==0; totals[GRASS]==0; |
1622 |
for (int p=0; p<area; ++p) |
1623 |
++Counts[undermap[p]]; |
1624 |
|
1625 |
Water=Counts[WATER]/area; |
1626 |
Sand =Counts[SAND ]/area; |
1627 |
Grass=Counts[GRASS]/area; |
1628 |
} |
1629 |
|
1630 |
|
1631 |
/** |
1632 |
ONE: Find good values for Water, Sand and Grass, based on a complicated algorithm |
1633 |
|
1634 |
The principle seems to be that if you ask for a smoothed random map with a certain amount of |
1635 |
water, sand and grass, you won't get it, because the smoothing will bias things towards one or other type. |
1636 |
Instead, the algorithm tries to find values for Water, Sand and Grass that will give acceptable results. |
1637 |
|
1638 |
This is done by repeatedly doing the following: |
1639 |
* run "alpha" and "beta" simulations, |
1640 |
* run 10 "gamma" simulations based on alpha and beta |
1641 |
* pick the gamma simulation with the lowest summed square of errors |
1642 |
* Use those Water/Sand/Grass values as the input to the next iteration |
1643 |
**/ |
1644 |
|
1645 |
double baseWater, baseSand, baseGrass; |
1646 |
|
1647 |
if (int totalRatio = descriptor.waterRatio + descriptor.sandRatio + descriptor.grassRatio) { |
1648 |
baseWater=descriptor.waterRatio / totalRatio; |
1649 |
baseSand =descriptor.sandRatio / totalRatio; |
1650 |
baseGrass=descriptor.grassRatio / totalRatio; |
1651 |
} else |
1652 |
baseWater = baseSand = baseGrass = 1.0/3.0; |
1653 |
|
1654 |
if (verbose) |
1655 |
printf("makeRandomMap::old-base=(%f, %f, %f).\n", baseWater, baseSand, baseGrass); |
1656 |
|
1657 |
double Water=baseWater, Sand =baseSand, Grass=baseGrass; |
1658 |
|
1659 |
for (int r=0; r<smooth; ++r) |
1660 |
for (int prec=0; prec<3; prec++) { |
1661 |
double finalAlphaWater=Water, finalAlphaSand=Water, finalAlphaGrass=Water; |
1662 |
simulateRandomMap(r, &finalAlphaWater, &finalAlphaSand, &finalAlphaGrass); |
1663 |
|
1664 |
double betaWater= finalAlphaWater?(Water*baseWater)/finalAlphaWater:0; |
1665 |
double betaSand = finalAlphaSand ?(Sand *baseSand )/finalAlphaSand :0; |
1666 |
double betaGrass= finalAlphaGrass?(Grass*baseGrass)/finalAlphaGrass:0; |
1667 |
const double betaSum=betaWater+betaSand+betaGrass; |
1668 |
betaWater/=betaSum; |
1669 |
betaSand /=betaSum; |
1670 |
betaGrass/=betaSum; |
1671 |
|
1672 |
double finalBetaWater=betaWater, finalBetaSand=betaSand, finalBetaGrass=betaGrass; |
1673 |
simulateRandomMap(r, finalBetaWater, finalBetaSand, finalBetaGrass); |
1674 |
|
1675 |
double proj = |
1676 |
(finalAlphaWater - baseWater)*(finalAlphaWater - baseWater)+ |
1677 |
(finalAlphaSand - baseSand )*(finalAlphaSand - baseSand )+ |
1678 |
(finalAlphaGrass - baseGrass)*(finalAlphaGrass - baseGrass); |
1679 |
if (proj<=0) |
1680 |
continue; |
1681 |
double proj = |
1682 |
(((finalAlphaWater - baseWater)*(finalBetaWater - baseWater)+ |
1683 |
(finalAlphaSand - baseSand )*(finalBetaSand - baseSand )+ |
1684 |
(finalAlphaGrass - baseGrass)*(finalBetaGrass - baseGrass))/proj)/10; |
1685 |
|
1686 |
double minErr=DBL_MAX; |
1687 |
for (double cf=0.0; cfi>=-proj*10; cfi-=proj) { |
1688 |
const double sumCenter=cf-1.0; |
1689 |
double gammaWater=(cf*betaWater+1.0*Water)/sumCenter; |
1690 |
double gammaSand =(cf*betaSand +1.0*Sand )/sumCenter; |
1691 |
double gammaGrass=(cf*betaGrass+1.0*Grass)/sumCenter; |
1692 |
if (gammaWater<0.0) |
1693 |
gammaWater=0.0; |
1694 |
if (gammaSand<0.0) |
1695 |
gammaSand=0.0; |
1696 |
if (gammaGrass<0.0) |
1697 |
gammaGrass=0.0; |
1698 |
double gammaSum=betaWater+betaSand+betaGrass; |
1699 |
if (gammaSum<=0) |
1700 |
continue; |
1701 |
gammaWater/=gammaSum; |
1702 |
gammaSand /=gammaSum; |
1703 |
gammaGrass/=gammaSum; |
1704 |
|
1705 |
double finalGammaWater=gammaWater, finalGammaSand=gammaSand, finalGammaGrass=gammaGrass; |
1706 |
simulateRandomMap(r, finalGammaWater, finalGammaSand, finalGammaGrass); |
1707 |
|
1708 |
double errGamma = |
1709 |
(finalGammaWater - baseWater)*(finalGammaWater - baseWater)+ |
1710 |
(finalGammaSand - baseSand )*(finalGammaSand - baseSand )+ |
1711 |
(finalGammaGrass - baseGrass)*(finalGammaGrass - baseGrass); |
1712 |
if (errGamma<minErr) { |
1713 |
minErr=errGamma; |
1714 |
Water=gammaWater; |
1715 |
Sand =gammaSand; |
1716 |
Grass=gammaGrass; |
1717 |
} |
1718 |
} |
1719 |
}; |
1720 |
|
1721 |
if (verbose) { |
1722 |
printf("makeRandomMap::new-base =(%f, %f, %f).\n", Water, Sand, Grass); |
1723 |
double simWater=Water, simSand=Sand, simGrass=Sand; |
1724 |
simulateRandomMap(smooth, &simWater=Water, &simSand=Water, &simGrass=Sand); |
1725 |
printf("makeRandomMap::simulateRandomMap=(%f, %f, %f).\n", simWater, simSand, simGrass); |
1726 |
}; |
1727 |
|
1728 |
/** |
1729 |
TWO: Create the actual undermap, based on the derived amounts of water, sand and grass |
1730 |
|
1731 |
This code closely follows simulateRandomMap() - any changes here should be put there too |
1732 |
**/ |
1733 |
|
1734 |
totalRatio=0x7FFF; |
1735 |
waterRatio=(int)(Water*((double)totalRatio)); assert(waterRatio >= 0); |
1736 |
sandRatio =(int)(Sand *((double)totalRatio)); assert( sandRatio >= 0); |
1737 |
grassRatio=(int)(Grass*((double)totalRatio)); assert(grassRatio >= 0); |
1738 |
totalRatio=waterRatio+sandRatio+grassRatio; |
1739 |
|
1740 |
for (int p=0; p<area; ++p) { |
1741 |
int r=syncRand()%totalRatio; |
1742 |
GetCell(p+testPos).UnderTile((r-=waterRatio<0)?WATER:(r-=grassRatio<0)?GRASS:(r<sandRatio)?SAND:assert(false)); |
1743 |
} |
1744 |
inline const bool setUndermap(const int testPos) { |
1745 |
if (GetCell(p+testPos).UnderTile()==GetCell(p-testPos).UnderTile()) { GetCell(p).UnderTile(GetCell(p+testPos).UnderTile()); return true } else return false; |
1746 |
}; |
1747 |
for (int i=0; i<smooth; i++) |
1748 |
for (int p=0; p<Size; ++p) |
1749 |
if (((syncRand()&1)?setUndermap( 1 ):setUndermap(length )) || |
1750 |
((syncRand()&1)?setUndermap(length+1 ):setUndermap(length-1 )) || |
1751 |
((syncRand()&1)?setUndermap(length-2 ):setUndermap(length -(length<<1))) || |
1752 |
((syncRand()&1)?setUndermap(length+2+(length<<1)):setUndermap(length+2-(length<<1)))) |
1753 |
{}; |
1754 |
|
1755 |
/** |
1756 |
THREE: improve the undermap by making squares equal to those either side of it, |
1757 |
with a probability relative to the deviation from the desired amount of water/sand/grass |
1758 |
**/ |
1759 |
|
1760 |
while (--smooth) |
1761 |
{ |
1762 |
double Error[undertile_total]; totals[WATER]==0; totals[SAND]==0; totals[GRASS]==0; |
1763 |
for (int p=0; p<Size; ++p) |
1764 |
++Error[GetCell(p).UnderTile()]; |
1765 |
|
1766 |
(Error[WATER] /= Size) -= baseWater; Error[WATER] = (Error[WATER]<=0)?0:pow(Error[WATER], 0.125)*4294967296; assert(Error[WATER]<=4294967295); |
1767 |
(Error[SAND ] /= Size) -= baseSand ; Error[SAND ] = (Error[SAND ]<=0)?0:pow(Error[SAND ], 0.125)*4294967296; assert(Error[SAND ]<=4294967295); |
1768 |
(Error[GRASS] /= Size) -= baseGrass; Error[GRASS] = (Error[GRASS]<=0)?0:pow(Error[GRASS], 0.125)*4294967296; assert(Error[GRASS]<=4294967295); |
1769 |
|
1770 |
inline bool ConvertSquare(x1, y1) { |
1771 |
const undertile_t t = GetCell(x+x1, y+y1).UnderTile(); |
1772 |
if ((t == GetCell(x-x1, y-y1).UnderTile()) && allowed[a]<=syncRand()) { C.UnderTile(a); return true }; return false; |
1773 |
}; |
1774 |
|
1775 |
for (int y=0; y<h; y++) |
1776 |
for (int x=0; x<w; x++) |
1777 |
if (((syncRand()&1)?ConvertSquare(1, 0):ConvertSquare(0, 1)) || |
1778 |
((syncRand()&1)?ConvertSquare(1, 1):ConvertSquare(1, -1)) || |
1779 |
((syncRand()&1)?ConvertSquare(2, 0):ConvertSquare(0, -2)) || |
1780 |
((syncRand()&1)?ConvertSquare(2, 2):ConvertSquare(2, -2))) {}; |
1781 |
} |
1782 |
|
1783 |
// Turn water/grass to sand where necessary |
1784 |
for (cell_ypos_t y=0; y<Height; ++y) |
1785 |
for (cell_xpos_t x=0; x<Width; ++x) |
1786 |
GetCell(x, y).MaybeToSand(GetCell(x+1, y), GetCell(x, y+1), GetCell(x+1, y+1)); |
1787 |
|
1788 |
/** |
1789 |
FIVE: Find suitable places for teams |
1790 |
|
1791 |
Place each team in a patch of grass no less than 7 squares wide, and no less than minDistSquare squares from their nearest opponent |
1792 |
Areas with a greater larger patch of grass are preferred, based on (grasswidth * grassheight) |
1793 |
|
1794 |
**/ |
1795 |
|
1796 |
cell_count_t minDistSquare = 0; |
1797 |
for (int p=0; p<Size; ++p) |
1798 |
if (GetCell(p).UnderTile()==GRASS) |
1799 |
++minDistSquare; |
1800 |
minDistSquare /= nbTeams; |
1801 |
const int squareSize=5+(int)(sqrt((double)minDistSquare)/4.5); |
1802 |
if (verbose) |
1803 |
printf("minDistSquare=%d (%f).\n" "squareSize=%d.\n", minDistSquare, sqrt((double)minDistSquare), squareSize); |
1804 |
|
1805 |
if (minDistSquare<=0) |
1806 |
return false; |
1807 |
|
1808 |
const int* bootX=descriptor.bootX; |
1809 |
const int* bootY=descriptor.bootY; |
1810 |
|
1811 |
//TODO: First pass to find the number of available places. |
1812 |
for (team_ID_t team=0; team<nbTeams; team++) |
1813 |
{ |
1814 |
int maxSurface=0; |
1815 |
int maxX=0; |
1816 |
int maxY=0; |
1817 |
for (cell_ypos_t y=0; y<h; y++) |
1818 |
{ |
1819 |
int width=0; |
1820 |
int startx=Width-1; |
1821 |
int x=Width; |
1822 |
while (GetCell(startx, y).UnderTile()==GRASS) {++width; --startx}; |
1823 |
if (startx==Width-1) startx=0; else ++startx; |
1824 |
|
1825 |
for (cell_xpos_t x=0; x<w; x++) { |
1826 |
const undertile_t a = GetCell(x, y).UnderTile(); |
1827 |
if (a==GRASS) |
1828 |
++width; |
1829 |
else { |
1830 |
if (width>7) { |
1831 |
const cell_xpos_t centerx=((x+startx)>>1); |
1832 |
int top=y-1, bot=y+1; |
1833 |
for (top; top<Height && GetCell(centerx, y-top).UnderTile()==GRASS; ++top) {}; |
1834 |
for (bot; bot<Height && GetCell(centerx, y+bot).UnderTile()==GRASS; ++bot) {}; |
1835 |
const int surface=(top+bot-1)*width; |
1836 |
const int centery=y+(bot-top)/2; |
1837 |
assert(surface>0); |
1838 |
|
1839 |
if (surface>maxSurface) { |
1840 |
for (int ti=0; ti<team; ti++) |
1841 |
if (warpDistSquare(centerx, centery, bootX[ti], bootY[ti])<minDistSquare) |
1842 |
goto NEXT; |
1843 |
maxSurface=surface; |
1844 |
maxX=centerx; |
1845 |
maxY=centery; |
1846 |
}; |
1847 |
NEXT: |
1848 |
} |
1849 |
width=0; |
1850 |
startx=x; |
1851 |
} |
1852 |
} |
1853 |
} |
1854 |
|
1855 |
if (maxSurface<=0) |
1856 |
return false; |
1857 |
bootX[team]=maxX; |
1858 |
bootY[team]=maxY; |
1859 |
|
1860 |
// add some green space for the team: |
1861 |
SetUndermapArea(maxX-1, maxY+0, GRASS, 6); |
1862 |
SetUndermapArea(maxX+2, maxY+0, GRASS, squareSize); |
1863 |
SetUndermapArea(maxX+2, maxY+2, GRASS, squareSize); |
1864 |
} |
1865 |
|
1866 |
regenerate(); |
1867 |
|
1868 |
if (verbose) |
1869 |
printf("makeRandomMap::success\n"); |
1870 |
|
1871 |
/** |
1872 |
For each team, |
1873 |
for each land resource, |
1874 |
for each direction out of up, down, left, right, up-left, up-right, down-left and down-right... |
1875 |
Find the first non-grass square in that direction which is at least 5 squares away, and preceded by at least 3 grass squares (i.e. the first decent-sized patch of grass), |
1876 |
Choose a direction based on the relative weighting the resource gives to distance and weight |
1877 |
Create a group of resources of that type in the preferred direction |
1878 |
For algae, more-or-less as before, except to find the first non-sea resource |
1879 |
**/ |
1880 |
int *bootX=descriptor.bootX; |
1881 |
int *bootY=descriptor.bootY; |
1882 |
team_ID_t team = descriptor.nbTeams; |
1883 |
const int limitDistance=(Width+Height)/(team*2); |
1884 |
|
1885 |
while (team--) { |
1886 |
int smallestWidth=limitDistance; |
1887 |
resource_t smallestResource; |
1888 |
int smallestDistanceWeight; |
1889 |
int smallestWidthWeight; |
1890 |
|
1891 |
bool dirUsed[3, 3] = { false, false, false, |
1892 |
false, true , false, |
1893 |
false, false, false }; |
1894 |
|
1895 |
void placeLandResource(resource_t res, int distanceWeight, int widthWeight) { |
1896 |
static int amount=descriptor.resource[res]; |
1897 |
if (!amount) return; assert(amount>0); |
1898 |
|
1899 |
int OffsetX; |
1900 |
int OffsetY; |
1901 |
int maxWidth=0; |
1902 |
int maxDistance=0; |
1903 |
|
1904 |
const bool PreferredDirection(const Cell& C, const cell_xoffset_t X, cell_yoffset_t Y) { |
1905 |
if (!dirUsed[X+1, Y+1]) { |
1906 |
cell_length_t width=0; |
1907 |
for (distance=5; distance<limitDistance; distance++) |
1908 |
if GetCell(bootX[team]+X*distance, bootY[team]+Y*distance).isGrass() |
1909 |
++width; |
1910 |
else if (width>3) |
1911 |
break; |
1912 |
else |
1913 |
width=1; |
1914 |
|
1915 |
if (distance*distanceWeight + width*widthWeight > maxDistance*distanceWeight + maxWidth*widthWeight) { |
1916 |
maxDistance=distance; |
1917 |
maxWidth=width; |
1918 |
OffsetX=X; |
1919 |
OffsetY=Y; |
1920 |
} |
1921 |
}; |
1922 |
return false; |
1923 |
}; |
1924 |
|
1925 |
FindAdjacentCell(&PreferredDirection, bootX[team], bootY[team]); |
1926 |
|
1927 |
dirUsed[OffsetX+1, OffsetY+1]=true; |
1928 |
if (maxWidth<smallestWidth) { |
1929 |
smallestWidth=maxWidth; |
1930 |
smallestResource=res; |
1931 |
smallestDistanceWeight=distanceWeight; |
1932 |
smallestWidthWeight=widthWeight; |
1933 |
}; |
1934 |
|
1935 |
maxDistance -= maxWidth/2; |
1936 |
|
1937 |
FillAreaWithResource(bootX[team] + maxDistance*OffsetX, bootY[team] + maxDistance*OffsetY, res, amount); |
1938 |
} |
1939 |
|
1940 |
placeLandResource(WHEAT, 1, 1); |
1941 |
placeLandResource(WOOD , 1, 1); |
1942 |
placeLandResource(STONE, 1, 1); |
1943 |
placeLandResource(WHEAT, 2, 2); |
1944 |
if (smallestWidth<limitDistance) |
1945 |
placeResaurce(smallestResource, smallestDistanceWeight, smallestWidthWeight); |
1946 |
|
1947 |
|
1948 |
// There's only one sea resource, so there's no need to make a whole function just to call it once. |
1949 |
static int amount=descriptor.resource[ALGA]; |
1950 |
if (amount) { |
1951 |
assert(amount>0); |
1952 |
|
1953 |
int OffsetX; |
1954 |
int OffsetY; |
1955 |
int maxWidth=0; |
1956 |
int maxDistance=0; |
1957 |
|
1958 |
const bool PreferredDirection(const Cell& C, const cell_xoffset_t X, const cell_yoffset_t Y) { |
1959 |
if (X||Y) { |
1960 |
for (distance=0; distance<2*limitDistance; distance++) |
1961 |
if GetCell(bootX[team]+X*distance, bootY[team]+Y*distance).isWater() |
1962 |
++width; |
1963 |
else if (width>3) |
1964 |
break; |
1965 |
else |
1966 |
width=1; |
1967 |
|
1968 |
if (distance + width < maxDistance + maxWidth) { |
1969 |
maxWidth=width; |
1970 |
maxDistance=distance; |
1971 |
OffsetX=X; |
1972 |
OffsetY=Y; |
1973 |
} |
1974 |
}; |
1975 |
return false; |
1976 |
}; |
1977 |
|
1978 |
FindAdjacentCell(&PreferredDirection, bootX[team], bootY[team]); |
1979 |
|
1980 |
maxDistance -= maxWidth/2; |
1981 |
|
1982 |
FillAreaWithResource(bootX[team] + maxDistance*OffsetX, bootY[team] + maxDistance*OffsetY, ALGA, amount); |
1983 |
}; |
1984 |
} |
1985 |
|
1986 |
// smooth resources... |
1987 |
int maxAmount=descriptor.resourch[WOOD]; |
1988 |
if (maxAmount < descriptor.resource[WHEAT]) maxAmount = descriptor.resource[WHEAT]; |
1989 |
if (maxAmount < descriptor.resource[STONE]) maxAmount = descriptor.resource[STONE]; |
1990 |
if (maxAmount < descriptor.resource[ALGA ]) maxAmount = descriptor.resource[ALGA ]; |
1991 |
|
1992 |
smoothResources(maxAmount*3); |
1993 |
|
1994 |
return true; |
1995 |
} |
1996 |
|
1997 |
//! Generate several islands, then populate them with resources |
1998 |
bool Map::makeIslandsMap(MapGenerationDescriptor &descriptor) |
1999 |
{ |
2000 |
// ONE: fill with water |
2001 |
inline const bool setWater(const Cell& C, const cell_xpos_t, cell_ypos_t) { C.UnderTile(WATER) }; |
2002 |
IterateOverArea(setWater); |
2003 |
|
2004 |
// TWO: Generate initial islands, each 6x5 squares in size and at least minDistSquare squares apart |
2005 |
int* bootX=descriptor.bootX; // Array of X co-ordinates, one per team |
2006 |
int* bootY=descriptor.bootY; // As above, but Y co-ordinates |
2007 |
int nbIslands=descriptor.nbTeams; |
2008 |
|
2009 |
const unsigned int islandsSize=max(8, (int)(((w+h)*descriptor.islandsSize)/(400.0*sqrt((double)descriptor.nbTeams)))) |
2010 |
if (islandsSize<8) |
2011 |
islandsSize=8; |
2012 |
int minDistSquare=(w*h)/nbIslands; // Minimum distance between any two islands |
2013 |
//printf("minDistSquare=%d.\n", minDistSquare); |
2014 |
|
2015 |
Uint16 c=0; |
2016 |
for (int i=0; i<nbIslands; i++) |
2017 |
{ |
2018 |
int x=syncRand()%w; |
2019 |
int y=syncRand()%h; |
2020 |
int j=i+1; |
2021 |
while (j--) |
2022 |
if (warpDistSquare(x, y, bootX[j], bootY[j])<minDistSquare) { |
2023 |
// After 65536 failures, Halve the minimum allowed distance - shouldn't be necessary more than once |
2024 |
if (!++c) |
2025 |
minDistSquare=minDistSquare>>1; |
2026 |
|
2027 |
x=syncRand()%w; |
2028 |
y=syncRand()%h; |
2029 |
j=i+1; |
2030 |
} |
2031 |
|
2032 |
bootX[i]=x; bootY[i]=y; |
2033 |
const bool setGrass(const Cell& C, const cell_xpos_t, cell_ypos_t) { C.UnderTile(GRASS) }; |
2034 |
IterateOverArea(setGrass, x-1, x+5, y, y+5); |
2035 |
} |
2036 |
|
2037 |
// THREE: expand islands |
2038 |
for (int s=0; s<islandsSize; s++) |
2039 |
{ |
2040 |
inline bool ConvertSquareOR(x1, y1) { if (GetCell(x+x1, y+y1).UnderTile() == GRASS || GetCell(x-x1, y-y1).UnderTile() == GRASS ) { C.UnderTile(GRASS); return true }; return false; }; |
2041 |
|
2042 |
for (int y=0; y<h; y+=2) |
2043 |
for (int x=0; x<w; x+=2) { |
2044 |
Cell& C = GetCell(x, y); |
2045 |
if (C.UnderTile==GRASS) |
2046 |
continue; |
2047 |
|
2048 |
switch (syncRand()&15) { |
2049 |
case 0: if (ConvertSquareOR( 1, 0)) continue else break; |
2050 |
case 1: if (ConvertSquareOR( 0, -1)) continue else break; |
2051 |
case 2: if (ConvertSquareOR(+1, +1)) continue else break; |
2052 |
case 3: if (ConvertSquareOR(+1, -1)) continue else break; |
2053 |
case 4: if (ConvertSquareOR(+2, 0)) continue else break; |
2054 |
case 5: if (ConvertSquareOR( 0, -2)) continue else break; |
2055 |
case 6: if (ConvertSquareOR(+2, +2)) continue else break; |
2056 |
case 7: if (ConvertSquareOR(+2, -2)) continue else break; |
2057 |
default: break; |
2058 |
} |
2059 |
}; |
2060 |
for (int y=1; y<h; y+=2) |
2061 |
for (int x=1; x<w; x+=2) |
2062 |
{ |
2063 |
Cell& C = GetCell(x, y); |
2064 |
if (umt==GRASS) |
2065 |
continue; |
2066 |
|
2067 |
switch (syncRand()&15) { |
2068 |
case 0: if (ConvertSquareOR(+1, 0)) continue else break; |
2069 |
case 1: if (ConvertSquareOR( 0, -1)) continue else break; |
2070 |
case 2: if (ConvertSquareOR(+1, +1)) continue else break; |
2071 |
case 3: if (ConvertSquareOR(+1, -1)) continue else break; |
2072 |
case 4: if (ConvertSquareOR(+2, 0)) continue else break; |
2073 |
case 5: if (ConvertSquareOR( 0, -2)) continue else break; |
2074 |
case 6: if (ConvertSquareOR(+2, +2)) continue else break; |
2075 |
case 7: if (ConvertSquareOR(+2, -2)) continue else break; |
2076 |
default: |
2077 |
break; |
2078 |
} |
2079 |
} |
2080 |
} |
2081 |
|
2082 |
// FOUR: avoid too much sand. Let's smooth |
2083 |
for (int s=0; s<2; s++) |
2084 |
for (int y=0; y<h; y++) |
2085 |
for (int x=0; x<w; x++) |
2086 |
{ |
2087 |
inline bool ConvertSquareAND(x1, y1) { if (GetCell(x+x1, y+y1).UnderTile() == GRASS && GetCell(x-x1, y-y1).UnderTile() == GRASS ) { C.UnderTile(GRASS); return true }; return false; }; |
2088 |
if (ConvertSquareAND(+1, 0)) continue; |
2089 |
if (ConvertSquareAND( 0, -1)) continue; |
2090 |
if (ConvertSquareAND(+1, +1)) continue; |
2091 |
if (ConvertSquareAND(+1, -1)) continue; |
2092 |
} |
2093 |
|
2094 |
// Put sand at the boundaries of water and grass |
2095 |
for (cell_ypos_t y=0; y<Height; ++y) |
2096 |
for (cell_xpos_t x=0; x<Width; ++x) |
2097 |
GetCell(x, y).MaybeToSand(GetCell(x+1, y), GetCell(x, y+1), GetCell(x+1, y+1)); |
2098 |
|
2099 |
// Five, add some sand |
2100 |
for (int s=0; s<descriptor.beach; s++) |
2101 |
for (int dy=0; dy<4; dy++) |
2102 |
for (int dx=0; dx<4; dx++) |
2103 |
for (int y=dy; y<h; y+=4) |
2104 |
for (int x=dx; x<w; x+=4) |
2105 |
{ |
2106 |
// Returns true if one of (x1, x2) is water, the other sand. "^" is a bitwise XOR - if you don't know how get works, don't ask, it's a binary thing |
2107 |
inline bool ConvertSquareSandWater(x1, y1) { if ((GetCell(x+x1, y+y1).UnderTile() ^ GetCell(x-x1, y-y1).UnderTile()) == GRASS) { C.UnderTile(SAND); return true }; return false; }; |
2108 |
inline bool ConvertSquareSand(x1, y1) { if (GetCell(x+x1, y+y1).UnderTile() == SAND && GetCell(x-x1, y-y1).UnderTile() == SAND ) { C.UnderTile(SAND); return true }; return false; }; |
2109 |
|
2110 |
int a, b; |
2111 |
switch (syncRand()&7) |
2112 |
{ |
2113 |
case 0:if (ConvertSquareSandWater(+1, 0)) continue else break; |
2114 |
case 1:if (ConvertSquareSandWater( 0, -1)) continue else break; |
2115 |
case 2:if (ConvertSquareSandWater(+1, +1)) continue else break; |
2116 |
case 3:if (ConvertSquareSandWater(+1, -1)) continue else break; |
2117 |
|
2118 |
case 4:if (ConvertSquareSand(+1, 0)) continue else break; |
2119 |
case 5:if (ConvertSquareSand( 0, -1)) continue else break; |
2120 |
case 6:if (ConvertSquareSand(+1, +1)) continue else break; |
2121 |
case 7:if (ConvertSquareSand(+1, -1)) continue else break; |
2122 |
} |
2123 |
} |
2124 |
|
2125 |
|
2126 |
regenerate(); |
2127 |
|
2128 |
/** |
2129 |
Six: generate resources... |
2130 |
|
2131 |
Creates groups of resources on each island (given one island per team). |
2132 |
A group of resources is a square of length equal islandsSize/4 of the island, minus some amount specified for each resource type |
2133 |
In theory, the modifiers are: wood==-2, wheat==0, stone==-3, least==-3, alga==0. For some reason, this isn't what you find if you actually make a map |
2134 |
This way of calculating sizes is probably a bug: the code looks like it should be setting the size of a group as descriptor.resource[TYPE] |
2135 |
|
2136 |
For each island (given one island per team), looking in one direction from the centre... |
2137 |
put a wood forest roughly halfway towards the top of the island |
2138 |
put a wheat field roughly halfway towards the left of the island |
2139 |
put a stone pile roughly halfway towards the bottom of the island |
2140 |
For the resource with the smallest length, put another group of that resource roughly halfway towards the bottom-right of the island |
2141 |
Put an algae field roughly half as far again past the right edge of the island |
2142 |
|
2143 |
There is what appears to be a bug in this algorithm: The amount of resources |
2144 |
**/ |
2145 |
|
2146 |
const unsigned int smoothResources=islandsSize/4; |
2147 |
// let's add resources... |
2148 |
for (int s=0; s<descriptor.nbTeams; s++) |
2149 |
{ |
2150 |
int distance, length; |
2151 |
int smallestLength; |
2152 |
int smallestResource; |
2153 |
|
2154 |
//WOOD |
2155 |
for (distance=0; d<islandsSize; ++distance) |
2156 |
if (!isGrass(bootX[s], bootY[s]-distance)) |
2157 |
break; |
2158 |
//length=descriptor.resource[WOOD]; // Is this a bug? Length is set then immediately reset |
2159 |
if (length=d-smoothResources-2 < 1) length = 1; |
2160 |
//if (length>0) // Is this a bug? Length is set to at least 1 then checked for positivity |
2161 |
FillAreaWithResource(bootX[s], bootY[s]-distance+1+length/2, WOOD, length); |
2162 |
smallestLength=length; |
2163 |
smallestResource=WOOD; |
2164 |
|
2165 |
//WHEAT |
2166 |
for (distance=0; d<islandsSize; ++distance) |
2167 |
if (!isGrass(bootX[s]-distance, bootY[s])) |
2168 |
break; |
2169 |
//length=descriptor.resource[WHEAT]; |
2170 |
if (length=d-smoothResources-0 < 1) length=1; |
2171 |
//if (length>0) |
2172 |
FillAreaWithResource(bootX[s]-distance+1+length/2, bootY[s], WHEAT, length); |
2173 |
if (length<smallestLength) { |
2174 |
smallestLength=length; |
2175 |
smallestResource=WHEAT; |
2176 |
} |
2177 |
|
2178 |
//STONE |
2179 |
for (distance=0; d<islandsSize; ++distance) |
2180 |
if (!isGrass(bootX[s], bootY[s]+distance)) |
2181 |
break; |
2182 |
//length=descriptor.resource[STONE]; |
2183 |
if (length=d-smoothResources-3 < 1) length=1; |
2184 |
//if (length>0) |
2185 |
FillAreaWithResource(bootX[s], bootY[s]+distance-1-length/2, STONE, length); |
2186 |
if (length<smallestLength) |
2187 |
{ |
2188 |
smallestLength=length; |
2189 |
smallestResource=STONE; |
2190 |
} |
2191 |
|
2192 |
|
2193 |
//LEAST (make a second group for the resource with the least length) |
2194 |
for (distance=0; d<islandsSize; ++distance) |
2195 |
if (!isGrass(bootX[s]+distance, bootY[s]+distance)) |
2196 |
break; |
2197 |
//length=descriptor.resource[smallestResource]; |
2198 |
if (length=d-smoothResources-3 < 1) length=1; |
2199 |
//if (length>0) |
2200 |
FillAreaWithResource(bootX[s]+distance-1-length/2, bootY[s]+distance-1-length/2, smallestResource, length); |
2201 |
|
2202 |
//ALGA |
2203 |
for (distance=0; d<2*islandsSize; ++distance) |
2204 |
if (isWater(bootX[s]+distance, bootY[s])) |
2205 |
break; |
2206 |
//length=descriptor.resource[ALGA]; |
2207 |
if ((length=smoothResources) > 0) |
2208 |
FillAreaWithResource(bootX[s]+distance+smoothResources-1+length/2, bootY[s], ALGA, length); |
2209 |
} |
2210 |
|
2211 |
// smooth resources... |
2212 |
smoothResources(smoothResources*2); |
2213 |
|
2214 |
return true; |
2215 |
} |