author | koda |
Wed, 22 Dec 2010 04:09:56 +0100 | |
changeset 4609 | e78287f80074 |
parent 4562 | b55f78fd2bf6 |
child 4900 | 8ad0e23e6d63 |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
3236
4ab3917d7d44
Update (c) lines to 2010 as unc0rr requested - they all had varying values so I just took the first year mentioned, then tacked on -2010
nemo
parents:
3228
diff
changeset
|
3 |
* Copyright (c) 2005-2010 Andrey Korotaev <unC0Rr@gmail.com> |
4 | 4 |
* |
183 | 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; version 2 of the License |
|
4 | 8 |
* |
183 | 9 |
* This program is distributed in the hope that it will be useful, |
10 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
11 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
12 |
* GNU General Public License for more details. |
|
4 | 13 |
* |
183 | 14 |
* You should have received a copy of the GNU General Public License |
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
4 | 17 |
*) |
18 |
||
2599 | 19 |
{$INCLUDE "options.inc"} |
2587
0dfa56a8513c
fix a segfault in the iphone simulator by moving options.inc at the beginning of the file
koda
parents:
2376
diff
changeset
|
20 |
|
4 | 21 |
unit uLand; |
22 |
interface |
|
4367 | 23 |
uses SDLh, uLandTemplates, uFloat, uConsts, GLunit, uTypes; |
4 | 24 |
|
3242 | 25 |
type direction = record x, y: LongInt; end; |
3181 | 26 |
const DIR_N: direction = (x: 0; y: -1); |
27 |
DIR_E: direction = (x: 1; y: 0); |
|
28 |
DIR_S: direction = (x: 0; y: 1); |
|
29 |
DIR_W: direction = (x: -1; y: 0); |
|
3133 | 30 |
|
3038 | 31 |
procedure initModule; |
32 |
procedure freeModule; |
|
37 | 33 |
procedure GenMap; |
766 | 34 |
function GenPreview: TPreview; |
4 | 35 |
|
36 |
implementation |
|
4389 | 37 |
uses uConsole, uStore, uRandom, uLandObjects, uIO, uLandTexture, sysutils, |
4458 | 38 |
uVariables, uUtils, uCommands, Adler32, uDebug, uLandPainted; |
4 | 39 |
|
3133 | 40 |
operator=(const a, b: direction) c: Boolean; |
41 |
begin |
|
42 |
c := (a.x = b.x) and (a.y = b.y); |
|
43 |
end; |
|
44 |
||
4 | 45 |
type TPixAr = record |
46 |
Count: Longword; |
|
22 | 47 |
ar: array[0..Pred(cMaxEdgePoints)] of TPoint; |
4 | 48 |
end; |
49 |
||
371 | 50 |
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword); |
358 | 51 |
var |
371 | 52 |
eX, eY, dX, dY: LongInt; |
53 |
i, sX, sY, x, y, d: LongInt; |
|
358 | 54 |
begin |
55 |
eX:= 0; |
|
56 |
eY:= 0; |
|
57 |
dX:= X2 - X1; |
|
58 |
dY:= Y2 - Y1; |
|
59 |
||
60 |
if (dX > 0) then sX:= 1 |
|
61 |
else |
|
62 |
if (dX < 0) then |
|
63 |
begin |
|
64 |
sX:= -1; |
|
65 |
dX:= -dX |
|
66 |
end else sX:= dX; |
|
67 |
||
68 |
if (dY > 0) then sY:= 1 |
|
69 |
else |
|
70 |
if (dY < 0) then |
|
71 |
begin |
|
72 |
sY:= -1; |
|
73 |
dY:= -dY |
|
74 |
end else sY:= dY; |
|
75 |
||
76 |
if (dX > dY) then d:= dX |
|
77 |
else d:= dY; |
|
78 |
||
79 |
x:= X1; |
|
80 |
y:= Y1; |
|
2376 | 81 |
|
358 | 82 |
for i:= 0 to d do |
83 |
begin |
|
84 |
inc(eX, dX); |
|
85 |
inc(eY, dY); |
|
86 |
if (eX > d) then |
|
87 |
begin |
|
88 |
dec(eX, d); |
|
89 |
inc(x, sX); |
|
90 |
end; |
|
91 |
if (eY > d) then |
|
92 |
begin |
|
93 |
dec(eY, d); |
|
94 |
inc(y, sY); |
|
95 |
end; |
|
364 | 96 |
|
1753 | 97 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
358 | 98 |
Land[y, x]:= Color; |
99 |
end |
|
100 |
end; |
|
101 |
||
365 | 102 |
procedure DrawEdge(var pa: TPixAr; Color: Longword); |
371 | 103 |
var i: LongInt; |
4 | 104 |
begin |
365 | 105 |
i:= 0; |
4 | 106 |
with pa do |
371 | 107 |
while i < LongInt(Count) - 1 do |
365 | 108 |
if (ar[i + 1].X = NTPX) then inc(i, 2) |
109 |
else begin |
|
110 |
DrawLine(ar[i].x, ar[i].y, ar[i + 1].x, ar[i + 1].y, Color); |
|
111 |
inc(i) |
|
112 |
end |
|
22 | 113 |
end; |
114 |
||
365 | 115 |
procedure Vector(p1, p2, p3: TPoint; var Vx, Vy: hwFloat); |
116 |
var d1, d2, d: hwFloat; |
|
364 | 117 |
begin |
498 | 118 |
Vx:= int2hwFloat(p1.X - p3.X); |
119 |
Vy:= int2hwFloat(p1.Y - p3.Y); |
|
120 |
d:= DistanceI(p2.X - p1.X, p2.Y - p1.Y); |
|
121 |
d1:= DistanceI(p2.X - p3.X, p2.Y - p3.Y); |
|
365 | 122 |
d2:= Distance(Vx, Vy); |
123 |
if d1 < d then d:= d1; |
|
124 |
if d2 < d then d:= d2; |
|
125 |
d:= d * _1div3; |
|
126 |
if d2.QWordValue = 0 then |
|
127 |
begin |
|
498 | 128 |
Vx:= _0; |
129 |
Vy:= _0 |
|
365 | 130 |
end else |
131 |
begin |
|
498 | 132 |
d2:= _1 / d2; |
365 | 133 |
Vx:= Vx * d2; |
134 |
Vy:= Vy * d2; |
|
135 |
||
136 |
Vx:= Vx * d; |
|
137 |
Vy:= Vy * d |
|
138 |
end |
|
139 |
end; |
|
140 |
||
371 | 141 |
procedure AddLoopPoints(var pa, opa: TPixAr; StartI, EndI: LongInt; Delta: hwFloat); |
142 |
var i, pi, ni: LongInt; |
|
365 | 143 |
NVx, NVy, PVx, PVy: hwFloat; |
498 | 144 |
x1, x2, y1, y2: LongInt; |
145 |
tsq, tcb, t, r1, r2, r3, cx1, cx2, cy1, cy2: hwFloat; |
|
371 | 146 |
X, Y: LongInt; |
365 | 147 |
begin |
148 |
pi:= EndI; |
|
149 |
i:= StartI; |
|
150 |
ni:= Succ(StartI); |
|
3407 | 151 |
{$HINTS OFF} |
365 | 152 |
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy); |
3407 | 153 |
{$HINTS ON} |
365 | 154 |
repeat |
155 |
inc(pi); |
|
156 |
if pi > EndI then pi:= StartI; |
|
157 |
inc(i); |
|
158 |
if i > EndI then i:= StartI; |
|
159 |
inc(ni); |
|
160 |
if ni > EndI then ni:= StartI; |
|
161 |
PVx:= NVx; |
|
162 |
PVy:= NVy; |
|
163 |
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy); |
|
164 |
||
165 |
x1:= opa.ar[pi].x; |
|
166 |
y1:= opa.ar[pi].y; |
|
167 |
x2:= opa.ar[i].x; |
|
168 |
y2:= opa.ar[i].y; |
|
498 | 169 |
cx1:= int2hwFloat(x1) - PVx; |
170 |
cy1:= int2hwFloat(y1) - PVy; |
|
171 |
cx2:= int2hwFloat(x2) + NVx; |
|
172 |
cy2:= int2hwFloat(y2) + NVy; |
|
173 |
t:= _0; |
|
364 | 174 |
while t.Round = 0 do |
175 |
begin |
|
176 |
tsq:= t * t; |
|
177 |
tcb:= tsq * t; |
|
498 | 178 |
r1:= (_1 - t*3 + tsq*3 - tcb); |
179 |
r2:= ( t*3 - tsq*6 + tcb*3); |
|
180 |
r3:= ( tsq*3 - tcb*3); |
|
430 | 181 |
X:= hwRound(r1 * x1 + r2 * cx1 + r3 * cx2 + tcb * x2); |
182 |
Y:= hwRound(r1 * y1 + r2 * cy1 + r3 * cy2 + tcb * y2); |
|
364 | 183 |
t:= t + Delta; |
184 |
pa.ar[pa.Count].x:= X; |
|
185 |
pa.ar[pa.Count].y:= Y; |
|
186 |
inc(pa.Count); |
|
187 |
TryDo(pa.Count <= cMaxEdgePoints, 'Edge points overflow', true) |
|
188 |
end; |
|
365 | 189 |
until i = StartI; |
190 |
pa.ar[pa.Count].x:= opa.ar[StartI].X; |
|
191 |
pa.ar[pa.Count].y:= opa.ar[StartI].Y; |
|
364 | 192 |
inc(pa.Count) |
193 |
end; |
|
194 |
||
365 | 195 |
procedure BezierizeEdge(var pa: TPixAr; Delta: hwFloat); |
495 | 196 |
var i, StartLoop: LongInt; |
365 | 197 |
opa: TPixAr; |
198 |
begin |
|
199 |
opa:= pa; |
|
200 |
pa.Count:= 0; |
|
201 |
i:= 0; |
|
202 |
StartLoop:= 0; |
|
371 | 203 |
while i < LongInt(opa.Count) do |
365 | 204 |
if (opa.ar[i + 1].X = NTPX) then |
205 |
begin |
|
206 |
AddLoopPoints(pa, opa, StartLoop, i, Delta); |
|
207 |
inc(i, 2); |
|
208 |
StartLoop:= i; |
|
209 |
pa.ar[pa.Count].X:= NTPX; |
|
3224 | 210 |
pa.ar[pa.Count].Y:= 0; |
365 | 211 |
inc(pa.Count); |
212 |
end else inc(i) |
|
213 |
end; |
|
214 |
||
371 | 215 |
procedure FillLand(x, y: LongInt); |
4 | 216 |
var Stack: record |
217 |
Count: Longword; |
|
218 |
points: array[0..8192] of record |
|
371 | 219 |
xl, xr, y, dir: LongInt; |
4 | 220 |
end |
221 |
end; |
|
222 |
||
371 | 223 |
procedure Push(_xl, _xr, _y, _dir: LongInt); |
4 | 224 |
begin |
75 | 225 |
TryDo(Stack.Count <= 8192, 'FillLand: stack overflow', true); |
4 | 226 |
_y:= _y + _dir; |
1760 | 227 |
if (_y < 0) or (_y >= LAND_HEIGHT) then exit; |
4 | 228 |
with Stack.points[Stack.Count] do |
229 |
begin |
|
230 |
xl:= _xl; |
|
231 |
xr:= _xr; |
|
232 |
y:= _y; |
|
233 |
dir:= _dir |
|
234 |
end; |
|
75 | 235 |
inc(Stack.Count) |
4 | 236 |
end; |
237 |
||
371 | 238 |
procedure Pop(var _xl, _xr, _y, _dir: LongInt); |
4 | 239 |
begin |
240 |
dec(Stack.Count); |
|
241 |
with Stack.points[Stack.Count] do |
|
242 |
begin |
|
243 |
_xl:= xl; |
|
244 |
_xr:= xr; |
|
245 |
_y:= y; |
|
246 |
_dir:= dir |
|
247 |
end |
|
248 |
end; |
|
249 |
||
371 | 250 |
var xl, xr, dir: LongInt; |
351 | 251 |
begin |
4 | 252 |
Stack.Count:= 0; |
253 |
xl:= x - 1; |
|
254 |
xr:= x; |
|
23 | 255 |
Push(xl, xr, y, -1); |
256 |
Push(xl, xr, y, 1); |
|
3407 | 257 |
dir:= 0; |
4 | 258 |
while Stack.Count > 0 do |
259 |
begin |
|
260 |
Pop(xl, xr, y, dir); |
|
51 | 261 |
while (xl > 0) and (Land[y, xl] <> 0) do dec(xl); |
1760 | 262 |
while (xr < LAND_WIDTH - 1) and (Land[y, xr] <> 0) do inc(xr); |
4 | 263 |
while (xl < xr) do |
264 |
begin |
|
51 | 265 |
while (xl <= xr) and (Land[y, xl] = 0) do inc(xl); |
4 | 266 |
x:= xl; |
51 | 267 |
while (xl <= xr) and (Land[y, xl] <> 0) do |
4 | 268 |
begin |
51 | 269 |
Land[y, xl]:= 0; |
4 | 270 |
inc(xl) |
271 |
end; |
|
22 | 272 |
if x < xl then |
273 |
begin |
|
274 |
Push(x, Pred(xl), y, dir); |
|
275 |
Push(x, Pred(xl), y,-dir); |
|
276 |
end; |
|
4 | 277 |
end; |
278 |
end; |
|
279 |
end; |
|
280 |
||
281 |
procedure ColorizeLand(Surface: PSDL_Surface); |
|
282 |
var tmpsurf: PSDL_Surface; |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
283 |
r, rr: TSDL_Rect; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
284 |
x, yd, yu: LongInt; |
4 | 285 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
286 |
tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/LandTex', ifCritical or ifIgnoreCaps); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
287 |
r.y:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
288 |
while r.y < LAND_HEIGHT do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
289 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
290 |
r.x:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
291 |
while r.x < LAND_WIDTH do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
292 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
293 |
SDL_UpperBlit(tmpsurf, nil, Surface, @r); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
294 |
inc(r.x, tmpsurf^.w) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
295 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
296 |
inc(r.y, tmpsurf^.h) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
297 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
298 |
SDL_FreeSurface(tmpsurf); |
4 | 299 |
|
3038 | 300 |
// freed in freeModule() below |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
301 |
LandBackSurface:= LoadImage(Pathz[ptCurrTheme] + '/LandBackTex', ifIgnoreCaps or ifTransparent); |
2647 | 302 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
303 |
tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/Border', ifCritical or ifIgnoreCaps or ifTransparent); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
304 |
for x:= 0 to LAND_WIDTH - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
305 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
306 |
yd:= LAND_HEIGHT - 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
307 |
repeat |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
308 |
while (yd > 0) and (Land[yd, x] = 0) do dec(yd); |
2376 | 309 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
310 |
if (yd < 0) then yd:= 0; |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
311 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
312 |
while (yd < LAND_HEIGHT) and (Land[yd, x] <> 0) do inc(yd); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
313 |
dec(yd); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
314 |
yu:= yd; |
2376 | 315 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
316 |
while (yu > 0 ) and (Land[yu, x] <> 0) do dec(yu); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
317 |
while (yu < yd ) and (Land[yu, x] = 0) do inc(yu); |
2376 | 318 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
319 |
if (yd < LAND_HEIGHT - 1) and ((yd - yu) >= 16) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
320 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
321 |
rr.x:= x; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
322 |
rr.y:= yd - 15; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
323 |
r.x:= x mod tmpsurf^.w; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
324 |
r.y:= 16; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
325 |
r.w:= 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
326 |
r.h:= 16; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
327 |
SDL_UpperBlit(tmpsurf, @r, Surface, @rr); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
328 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
329 |
if (yu > 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
330 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
331 |
rr.x:= x; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
332 |
rr.y:= yu; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
333 |
r.x:= x mod tmpsurf^.w; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
334 |
r.y:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
335 |
r.w:= 1; |
4374 | 336 |
r.h:= Min(16, yd - yu + 1); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
337 |
SDL_UpperBlit(tmpsurf, @r, Surface, @rr); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
338 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
339 |
yd:= yu - 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
340 |
until yd < 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
341 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
342 |
SDL_FreeSurface(tmpsurf); |
4 | 343 |
end; |
344 |
||
358 | 345 |
procedure SetPoints(var Template: TEdgeTemplate; var pa: TPixAr); |
371 | 346 |
var i: LongInt; |
22 | 347 |
begin |
23 | 348 |
with Template do |
349 |
begin |
|
358 | 350 |
pa.Count:= BasePointsCount; |
351 |
for i:= 0 to pred(pa.Count) do |
|
23 | 352 |
begin |
371 | 353 |
pa.ar[i].x:= BasePoints^[i].x + LongInt(GetRandom(BasePoints^[i].w)); |
1792 | 354 |
if pa.ar[i].x <> NTPX then |
355 |
pa.ar[i].x:= pa.ar[i].x + ((LAND_WIDTH - Template.TemplateWidth) div 2); |
|
3407 | 356 |
pa.ar[i].y:= BasePoints^[i].y + LongInt(GetRandom(BasePoints^[i].h)) + LAND_HEIGHT - LongInt(Template.TemplateHeight) |
23 | 357 |
end; |
1183
540cea859395
Step 4: repair girder rendering (girder is 32bit now)
unc0rr
parents:
1182
diff
changeset
|
358 |
|
358 | 359 |
if canMirror then |
360 | 360 |
if getrandom(2) = 0 then |
358 | 361 |
begin |
362 |
for i:= 0 to pred(BasePointsCount) do |
|
365 | 363 |
if pa.ar[i].x <> NTPX then |
1760 | 364 |
pa.ar[i].x:= LAND_WIDTH - 1 - pa.ar[i].x; |
358 | 365 |
for i:= 0 to pred(FillPointsCount) do |
1760 | 366 |
FillPoints^[i].x:= LAND_WIDTH - 1 - FillPoints^[i].x; |
358 | 367 |
end; |
22 | 368 |
|
2338
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
369 |
(* Experiment in making this option more useful |
2376 | 370 |
if ((not isNegative) and (cTemplateFilter = 4)) or |
2338
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
371 |
(canFlip and (getrandom(2) = 0)) then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
372 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
373 |
for i:= 0 to pred(BasePointsCount) do |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
374 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
375 |
pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y + (LAND_HEIGHT - TemplateHeight) * 2; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
376 |
if pa.ar[i].y > LAND_HEIGHT - 1 then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
377 |
pa.ar[i].y:= LAND_HEIGHT - 1; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
378 |
end; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
379 |
for i:= 0 to pred(FillPointsCount) do |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
380 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
381 |
FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y + (LAND_HEIGHT - TemplateHeight) * 2; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
382 |
if FillPoints^[i].y > LAND_HEIGHT - 1 then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
383 |
FillPoints^[i].y:= LAND_HEIGHT - 1; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
384 |
end; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
385 |
end; |
2376 | 386 |
end |
2338
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
387 |
*) |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
388 |
// template recycling. Pull these off the floor a bit |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
389 |
if (not isNegative) and (cTemplateFilter = 4) then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
390 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
391 |
for i:= 0 to pred(BasePointsCount) do |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
392 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
393 |
dec(pa.ar[i].y, 100); |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
394 |
if pa.ar[i].y < 0 then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
395 |
pa.ar[i].y:= 0; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
396 |
end; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
397 |
for i:= 0 to pred(FillPointsCount) do |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
398 |
begin |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
399 |
dec(FillPoints^[i].y, 100); |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
400 |
if FillPoints^[i].y < 0 then |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
401 |
FillPoints^[i].y:= 0; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
402 |
end; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
403 |
end; |
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
404 |
|
8f6508c97f3f
An experiment with increasing number of caves by selecting a few potential non-cave maps and adding to the cave map array. Ones selected here might not actually be that playable as caves.
nemo
parents:
2308
diff
changeset
|
405 |
if (canFlip and (getrandom(2) = 0)) then |
358 | 406 |
begin |
407 |
for i:= 0 to pred(BasePointsCount) do |
|
1760 | 408 |
pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y; |
358 | 409 |
for i:= 0 to pred(FillPointsCount) do |
1760 | 410 |
FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y; |
358 | 411 |
end; |
412 |
end |
|
4 | 413 |
end; |
67 | 414 |
|
561 | 415 |
function CheckIntersect(V1, V2, V3, V4: TPoint): boolean; |
416 |
var c1, c2, dm: LongInt; |
|
417 |
begin |
|
418 |
dm:= (V4.y - V3.y) * (V2.x - V1.x) - (V4.x - V3.x) * (V2.y - V1.y); |
|
419 |
c1:= (V4.x - V3.x) * (V1.y - V3.y) - (V4.y - V3.y) * (V1.x - V3.x); |
|
420 |
if dm = 0 then exit(false); |
|
421 |
||
422 |
c2:= (V2.x - V3.x) * (V1.y - V3.y) - (V2.y - V3.y) * (V1.x - V3.x); |
|
423 |
if dm > 0 then |
|
424 |
begin |
|
425 |
if (c1 < 0) or (c1 > dm) then exit(false); |
|
426 |
if (c2 < 0) or (c2 > dm) then exit(false) |
|
427 |
end else |
|
428 |
begin |
|
429 |
if (c1 > 0) or (c1 < dm) then exit(false); |
|
430 |
if (c2 > 0) or (c2 < dm) then exit(false) |
|
431 |
end; |
|
432 |
||
433 |
//AddFileLog('1 (' + inttostr(V1.x) + ',' + inttostr(V1.y) + ')x(' + inttostr(V2.x) + ',' + inttostr(V2.y) + ')'); |
|
434 |
//AddFileLog('2 (' + inttostr(V3.x) + ',' + inttostr(V3.y) + ')x(' + inttostr(V4.x) + ',' + inttostr(V4.y) + ')'); |
|
435 |
CheckIntersect:= true |
|
436 |
end; |
|
437 |
||
438 |
function CheckSelfIntersect(var pa: TPixAr; ind: Longword): boolean; |
|
439 |
var i: Longword; |
|
440 |
begin |
|
441 |
if (ind <= 0) or (ind >= Pred(pa.Count)) then exit(false); |
|
442 |
for i:= 1 to pa.Count - 3 do |
|
443 |
if (i <= ind - 1) or (i >= ind + 2) then |
|
444 |
begin |
|
445 |
if (i <> ind - 1) and |
|
446 |
CheckIntersect(pa.ar[ind], pa.ar[ind - 1], pa.ar[i], pa.ar[i - 1]) then exit(true); |
|
447 |
if (i <> ind + 2) and |
|
448 |
CheckIntersect(pa.ar[ind], pa.ar[ind + 1], pa.ar[i], pa.ar[i - 1]) then exit(true); |
|
449 |
end; |
|
450 |
CheckSelfIntersect:= false |
|
451 |
end; |
|
452 |
||
429 | 453 |
procedure RandomizePoints(var pa: TPixAr); |
364 | 454 |
const cEdge = 55; |
561 | 455 |
cMinDist = 8; |
371 | 456 |
var radz: array[0..Pred(cMaxEdgePoints)] of LongInt; |
561 | 457 |
i, k, dist, px, py: LongInt; |
364 | 458 |
begin |
459 |
for i:= 0 to Pred(pa.Count) do |
|
3225
5d8f4737b6cd
another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents:
3224
diff
changeset
|
460 |
begin |
5d8f4737b6cd
another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents:
3224
diff
changeset
|
461 |
radz[i]:= 0; |
364 | 462 |
with pa.ar[i] do |
365 | 463 |
if x <> NTPX then |
464 |
begin |
|
1760 | 465 |
radz[i]:= Min(Max(x - cEdge, 0), Max(LAND_WIDTH - cEdge - x, 0)); |
466 |
radz[i]:= Min(radz[i], Min(Max(y - cEdge, 0), Max(LAND_HEIGHT - cEdge - y, 0))); |
|
365 | 467 |
if radz[i] > 0 then |
468 |
for k:= 0 to Pred(i) do |
|
364 | 469 |
begin |
429 | 470 |
dist:= Max(abs(x - pa.ar[k].x), abs(y - pa.ar[k].y)); |
365 | 471 |
radz[k]:= Max(0, Min((dist - cMinDist) div 2, radz[k])); |
472 |
radz[i]:= Max(0, Min(dist - radz[k] - cMinDist, radz[i])) |
|
473 |
end |
|
474 |
end; |
|
3225
5d8f4737b6cd
another uninitialised value radz[k] for corresponding pa.ar of NTPX
nemo
parents:
3224
diff
changeset
|
475 |
end; |
364 | 476 |
|
477 |
for i:= 0 to Pred(pa.Count) do |
|
478 |
with pa.ar[i] do |
|
1753 | 479 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
364 | 480 |
begin |
561 | 481 |
px:= x; |
482 |
py:= y; |
|
371 | 483 |
x:= x + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3; |
561 | 484 |
y:= y + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3; |
485 |
if CheckSelfIntersect(pa, i) then |
|
486 |
begin |
|
487 |
x:= px; |
|
488 |
y:= py |
|
489 |
end; |
|
364 | 490 |
end |
67 | 491 |
end; |
492 |
||
364 | 493 |
|
23 | 494 |
procedure GenBlank(var Template: TEdgeTemplate); |
4 | 495 |
var pa: TPixAr; |
23 | 496 |
i: Longword; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
497 |
y, x: Longword; |
4 | 498 |
begin |
1773 | 499 |
for y:= 0 to LAND_HEIGHT - 1 do |
500 |
for x:= 0 to LAND_WIDTH - 1 do |
|
4458 | 501 |
Land[y, x]:= lfBasic; |
502 |
{$HINTS OFF} |
|
503 |
SetPoints(Template, pa); |
|
504 |
{$HINTS ON} |
|
505 |
for i:= 1 to Template.BezierizeCount do |
|
506 |
begin |
|
507 |
BezierizeEdge(pa, _0_5); |
|
508 |
RandomizePoints(pa); |
|
509 |
RandomizePoints(pa) |
|
510 |
end; |
|
511 |
for i:= 1 to Template.RandPassesCount do RandomizePoints(pa); |
|
512 |
BezierizeEdge(pa, _0_1); |
|
513 |
||
514 |
||
515 |
DrawEdge(pa, 0); |
|
516 |
||
517 |
with Template do |
|
518 |
for i:= 0 to pred(FillPointsCount) do |
|
519 |
with FillPoints^[i] do |
|
520 |
FillLand(x, y); |
|
521 |
||
522 |
DrawEdge(pa, lfBasic); |
|
523 |
||
524 |
MaxHedgehogs:= Template.MaxHedgehogs; |
|
525 |
hasGirders:= Template.hasGirders; |
|
526 |
playHeight:= Template.TemplateHeight; |
|
527 |
playWidth:= Template.TemplateWidth; |
|
528 |
leftX:= ((LAND_WIDTH - playWidth) div 2); |
|
529 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
|
530 |
topY:= LAND_HEIGHT - playHeight; |
|
531 |
||
532 |
// HACK: force to only cavern even if a cavern map is invertable if cTemplateFilter = 4 ? |
|
533 |
if (cTemplateFilter = 4) or |
|
534 |
(Template.canInvert and (getrandom(2) = 0)) or |
|
535 |
(not Template.canInvert and Template.isNegative) then |
|
536 |
begin |
|
537 |
hasBorder:= true; |
|
538 |
for y:= 0 to LAND_HEIGHT - 1 do |
|
539 |
for x:= 0 to LAND_WIDTH - 1 do |
|
540 |
if (y < topY) or (x < leftX) or (x > rightX) then |
|
541 |
Land[y, x]:= 0 |
|
542 |
else |
|
543 |
begin |
|
544 |
if Land[y, x] = 0 then |
|
545 |
Land[y, x]:= lfBasic |
|
546 |
else if Land[y, x] = lfBasic then |
|
547 |
Land[y, x]:= 0; |
|
548 |
end; |
|
549 |
end; |
|
23 | 550 |
end; |
551 |
||
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
552 |
procedure GenDrawnMap; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
553 |
begin |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
554 |
uLandPainted.Draw; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
555 |
|
4559 | 556 |
MaxHedgehogs:= 48; |
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
557 |
hasGirders:= true; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
558 |
playHeight:= 2048; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
559 |
playWidth:= 4096; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
560 |
leftX:= ((LAND_WIDTH - playWidth) div 2); |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
561 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
562 |
topY:= LAND_HEIGHT - playHeight; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
563 |
end; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
564 |
|
371 | 565 |
function SelectTemplate: LongInt; |
161 | 566 |
begin |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
567 |
if (cReducedQuality and rqLowRes) <> 0 then |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
568 |
SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))] |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
569 |
else |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
570 |
case cTemplateFilter of |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
571 |
0: SelectTemplate:= getrandom(Succ(High(EdgeTemplates))); |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
572 |
1: SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))]; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
573 |
2: SelectTemplate:= MediumTemplates[getrandom(Succ(High(MediumTemplates)))]; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
574 |
3: SelectTemplate:= LargeTemplates[getrandom(Succ(High(LargeTemplates)))]; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
575 |
4: SelectTemplate:= CavernTemplates[getrandom(Succ(High(CavernTemplates)))]; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
576 |
5: SelectTemplate:= WackyTemplates[getrandom(Succ(High(WackyTemplates)))]; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
577 |
end; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
578 |
|
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
579 |
WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter)); |
161 | 580 |
end; |
581 |
||
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
582 |
procedure LandSurface2LandPixels(Surface: PSDL_Surface); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
583 |
var x, y: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
584 |
p: PLongwordArray; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
585 |
begin |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
586 |
TryDo(Surface <> nil, 'Assert (LandSurface <> nil) failed', true); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
587 |
|
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
588 |
if SDL_MustLock(Surface) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
589 |
SDLTry(SDL_LockSurface(Surface) >= 0, true); |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
590 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
591 |
p:= Surface^.pixels; |
1760 | 592 |
for y:= 0 to LAND_HEIGHT - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
593 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
594 |
for x:= 0 to LAND_WIDTH - 1 do |
3598 | 595 |
if Land[y, x] <> 0 then |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
596 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3598 | 597 |
LandPixels[y, x]:= p^[x] or AMask |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
598 |
else |
3598 | 599 |
LandPixels[y div 2, x div 2]:= p^[x] or AMask; |
2376 | 600 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
601 |
p:= @(p^[Surface^.pitch div 4]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
602 |
end; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
603 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
604 |
if SDL_MustLock(Surface) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
605 |
SDL_UnlockSurface(Surface); |
1754 | 606 |
end; |
607 |
||
3133 | 608 |
procedure GenMaze; |
609 |
const small_cell_size = 128; |
|
610 |
medium_cell_size = 192; |
|
611 |
large_cell_size = 256; |
|
3138 | 612 |
braidness = 10; |
3133 | 613 |
|
3242 | 614 |
var x, y: LongInt; |
3133 | 615 |
cellsize: LongInt; //selected by the user in the gui |
3242 | 616 |
seen_cells_x, seen_cells_y: LongInt; //number of cells that can be visited by the generator, that is every second cell in x and y direction. the cells between there are walls that will be removed when we move from one cell to another |
617 |
num_edges_x, num_edges_y: LongInt; //number of resulting edges that need to be vertexificated |
|
618 |
num_cells_x, num_cells_y: LongInt; //actual number of cells, depending on cell size |
|
619 |
seen_list: array of array of LongInt; |
|
3133 | 620 |
xwalls: array of array of Boolean; |
621 |
ywalls: array of array of Boolean; |
|
622 |
x_edge_list: array of array of Boolean; |
|
623 |
y_edge_list: array of array of Boolean; |
|
624 |
maze: array of array of Boolean; |
|
625 |
pa: TPixAr; |
|
3242 | 626 |
num_vertices: LongInt; |
3133 | 627 |
off_y: LongInt; |
3242 | 628 |
num_steps: LongInt; |
629 |
current_step: LongInt; |
|
3181 | 630 |
step_done: array of Boolean; |
631 |
done: Boolean; |
|
3242 | 632 |
last_cell: array of record x, y: LongInt; end; |
633 |
came_from: array of array of record x, y: LongInt; end; |
|
634 |
came_from_pos: array of LongInt; |
|
3181 | 635 |
maze_inverted: Boolean; |
3133 | 636 |
|
3242 | 637 |
function when_seen(x: LongInt; y: LongInt): LongInt; |
3133 | 638 |
begin |
639 |
if (x < 0) or (x >= seen_cells_x) or (y < 0) or (y >= seen_cells_y) then |
|
3181 | 640 |
when_seen := current_step |
3133 | 641 |
else |
3181 | 642 |
when_seen := seen_list[x, y]; |
3133 | 643 |
end; |
644 |
||
3242 | 645 |
function is_x_edge(x, y: LongInt): Boolean; |
3133 | 646 |
begin |
647 |
if (x < 0) or (x > num_edges_x) or (y < 0) or (y > num_cells_y) then |
|
648 |
is_x_edge := false |
|
649 |
else |
|
650 |
is_x_edge := x_edge_list[x, y]; |
|
651 |
end; |
|
652 |
||
3242 | 653 |
function is_y_edge(x, y: LongInt): Boolean; |
3133 | 654 |
begin |
655 |
if (x < 0) or (x > num_cells_x) or (y < 0) or (y > num_edges_y) then |
|
656 |
is_y_edge := false |
|
657 |
else |
|
658 |
is_y_edge := y_edge_list[x, y]; |
|
659 |
end; |
|
660 |
||
3181 | 661 |
procedure see_cell; |
3133 | 662 |
var dir: direction; |
3242 | 663 |
tries: LongInt; |
664 |
x, y: LongInt; |
|
3181 | 665 |
found_cell: Boolean; |
666 |
next_dir_clockwise: Boolean; |
|
667 |
||
3133 | 668 |
begin |
3181 | 669 |
x := last_cell[current_step].x; |
670 |
y := last_cell[current_step].y; |
|
671 |
seen_list[x, y] := current_step; |
|
3133 | 672 |
case GetRandom(4) of |
673 |
0: dir := DIR_N; |
|
674 |
1: dir := DIR_E; |
|
675 |
2: dir := DIR_S; |
|
676 |
3: dir := DIR_W; |
|
677 |
end; |
|
678 |
tries := 0; |
|
3181 | 679 |
found_cell := false; |
680 |
if getrandom(2) = 1 then next_dir_clockwise := true |
|
681 |
else next_dir_clockwise := false; |
|
682 |
||
683 |
while (tries < 5) and not found_cell do |
|
3133 | 684 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
685 |
if when_seen(x + dir.x, y + dir.y) = current_step then //we are seeing ourselves, try another direction |
3133 | 686 |
begin |
687 |
//we have already seen the target cell, decide if we should remove the wall anyway |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
688 |
//(or put a wall there if maze_inverted, but we are not doing that right now) |
3133 | 689 |
if not maze_inverted and (GetRandom(braidness) = 0) then |
3181 | 690 |
//or just warn that inverted+braid+indestructible terrain != good idea |
3133 | 691 |
begin |
692 |
case dir.x of |
|
693 |
-1: if x > 0 then ywalls[x-1, y] := false; |
|
694 |
1: if x < seen_cells_x - 1 then ywalls[x, y] := false; |
|
695 |
end; |
|
696 |
case dir.y of |
|
697 |
-1: if y > 0 then xwalls[x, y-1] := false; |
|
698 |
1: if y < seen_cells_y - 1 then xwalls[x, y] := false; |
|
699 |
end; |
|
700 |
end; |
|
3181 | 701 |
if next_dir_clockwise then |
702 |
begin |
|
703 |
if dir = DIR_N then |
|
704 |
dir := DIR_E |
|
705 |
else if dir = DIR_E then |
|
706 |
dir := DIR_S |
|
707 |
else if dir = DIR_S then |
|
708 |
dir := DIR_W |
|
709 |
else |
|
710 |
dir := DIR_N; |
|
711 |
end |
|
3133 | 712 |
else |
3181 | 713 |
begin |
714 |
if dir = DIR_N then |
|
715 |
dir := DIR_W |
|
716 |
else if dir = DIR_E then |
|
717 |
dir := DIR_N |
|
718 |
else if dir = DIR_S then |
|
719 |
dir := DIR_E |
|
720 |
else |
|
721 |
dir := DIR_S; |
|
722 |
end |
|
3133 | 723 |
end |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
724 |
else if when_seen(x + dir.x, y + dir.y) = -1 then //cell was not seen yet, go there |
3133 | 725 |
begin |
726 |
case dir.y of |
|
727 |
-1: xwalls[x, y-1] := false; |
|
728 |
1: xwalls[x, y] := false; |
|
729 |
end; |
|
730 |
case dir.x of |
|
731 |
-1: ywalls[x-1, y] := false; |
|
732 |
1: ywalls[x, y] := false; |
|
733 |
end; |
|
3181 | 734 |
last_cell[current_step].x := x+dir.x; |
735 |
last_cell[current_step].y := y+dir.y; |
|
736 |
came_from_pos[current_step] := came_from_pos[current_step] + 1; |
|
737 |
came_from[current_step, came_from_pos[current_step]].x := x; |
|
738 |
came_from[current_step, came_from_pos[current_step]].y := y; |
|
739 |
found_cell := true; |
|
740 |
end |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
741 |
else //we are seeing someone else, quit |
3181 | 742 |
begin |
743 |
step_done[current_step] := true; |
|
744 |
found_cell := true; |
|
3133 | 745 |
end; |
746 |
||
747 |
tries := tries + 1; |
|
748 |
end; |
|
3181 | 749 |
if not found_cell then |
750 |
begin |
|
751 |
last_cell[current_step].x := came_from[current_step, came_from_pos[current_step]].x; |
|
752 |
last_cell[current_step].y := came_from[current_step, came_from_pos[current_step]].y; |
|
753 |
came_from_pos[current_step] := came_from_pos[current_step] - 1; |
|
754 |
if came_from_pos[current_step] >= 0 then see_cell |
|
755 |
else step_done[current_step] := true; |
|
756 |
end; |
|
757 |
end; |
|
3133 | 758 |
|
3242 | 759 |
procedure add_vertex(x, y: LongInt); |
760 |
var tmp_x, tmp_y: LongInt; |
|
3133 | 761 |
begin |
762 |
if x = NTPX then |
|
763 |
begin |
|
3138 | 764 |
if pa.ar[num_vertices - 6].x = NTPX then |
765 |
begin |
|
766 |
num_vertices := num_vertices - 6; |
|
767 |
end |
|
768 |
else |
|
769 |
begin |
|
770 |
pa.ar[num_vertices].x := NTPX; |
|
771 |
pa.ar[num_vertices].y := 0; |
|
772 |
end |
|
3133 | 773 |
end |
774 |
else |
|
775 |
begin |
|
3181 | 776 |
if maze_inverted or (x mod 2 = 0) then tmp_x := cellsize |
3138 | 777 |
else tmp_x := cellsize * 2 div 3; |
3181 | 778 |
if maze_inverted or (y mod 2 = 0) then tmp_y := cellsize |
3138 | 779 |
else tmp_y := cellsize * 2 div 3; |
780 |
||
781 |
pa.ar[num_vertices].x := (x-1)*cellsize + tmp_x; |
|
782 |
pa.ar[num_vertices].y := (y-1)*cellsize + tmp_y + off_y; |
|
3133 | 783 |
end; |
784 |
num_vertices := num_vertices + 1; |
|
785 |
end; |
|
786 |
||
3242 | 787 |
procedure add_edge(x, y: LongInt; dir: direction); |
788 |
var i: LongInt; |
|
3133 | 789 |
begin |
790 |
if dir = DIR_N then |
|
791 |
begin |
|
792 |
dir := DIR_W |
|
793 |
end |
|
794 |
else if dir = DIR_E then |
|
795 |
begin |
|
796 |
dir := DIR_N |
|
797 |
end |
|
798 |
else if dir = DIR_S then |
|
799 |
begin |
|
800 |
dir := DIR_E |
|
801 |
end |
|
802 |
else |
|
803 |
begin |
|
804 |
dir := DIR_S; |
|
805 |
end; |
|
806 |
||
807 |
for i := 0 to 3 do |
|
808 |
begin |
|
809 |
if dir = DIR_N then |
|
810 |
dir := DIR_E |
|
811 |
else if dir = DIR_E then |
|
812 |
dir := DIR_S |
|
813 |
else if dir = DIR_S then |
|
814 |
dir := DIR_W |
|
815 |
else |
|
816 |
dir := DIR_N; |
|
817 |
||
818 |
if (dir = DIR_N) and is_x_edge(x, y) then |
|
819 |
begin |
|
820 |
x_edge_list[x, y] := false; |
|
821 |
add_vertex(x+1, y); |
|
822 |
add_edge(x, y-1, DIR_N); |
|
823 |
break; |
|
824 |
end; |
|
825 |
||
826 |
if (dir = DIR_E) and is_y_edge(x+1, y) then |
|
827 |
begin |
|
828 |
y_edge_list[x+1, y] := false; |
|
829 |
add_vertex(x+2, y+1); |
|
830 |
add_edge(x+1, y, DIR_E); |
|
831 |
break; |
|
832 |
end; |
|
833 |
||
834 |
if (dir = DIR_S) and is_x_edge(x, y+1) then |
|
835 |
begin |
|
836 |
x_edge_list[x, y+1] := false; |
|
837 |
add_vertex(x+1, y+2); |
|
838 |
add_edge(x, y+1, DIR_S); |
|
839 |
break; |
|
840 |
end; |
|
841 |
||
842 |
if (dir = DIR_W) and is_y_edge(x, y) then |
|
843 |
begin |
|
844 |
y_edge_list[x, y] := false; |
|
845 |
add_vertex(x, y+1); |
|
846 |
add_edge(x-1, y, DIR_W); |
|
847 |
break; |
|
848 |
end; |
|
849 |
end; |
|
850 |
||
851 |
end; |
|
852 |
||
853 |
begin |
|
854 |
case cMazeSize of |
|
3181 | 855 |
0: begin |
856 |
cellsize := small_cell_size; |
|
857 |
maze_inverted := false; |
|
858 |
end; |
|
859 |
1: begin |
|
860 |
cellsize := medium_cell_size; |
|
861 |
maze_inverted := false; |
|
862 |
end; |
|
863 |
2: begin |
|
864 |
cellsize := large_cell_size; |
|
865 |
maze_inverted := false; |
|
866 |
end; |
|
867 |
3: begin |
|
868 |
cellsize := small_cell_size; |
|
869 |
maze_inverted := true; |
|
870 |
end; |
|
871 |
4: begin |
|
872 |
cellsize := medium_cell_size; |
|
873 |
maze_inverted := true; |
|
874 |
end; |
|
875 |
5: begin |
|
876 |
cellsize := large_cell_size; |
|
877 |
maze_inverted := true; |
|
878 |
end; |
|
3133 | 879 |
end; |
880 |
||
881 |
num_cells_x := LAND_WIDTH div cellsize; |
|
3228 | 882 |
if not odd(num_cells_x) then num_cells_x := num_cells_x - 1; //needs to be odd |
3133 | 883 |
num_cells_y := LAND_HEIGHT div cellsize; |
3228 | 884 |
if not odd(num_cells_y) then num_cells_y := num_cells_y - 1; |
3133 | 885 |
num_edges_x := num_cells_x - 1; |
886 |
num_edges_y := num_cells_y - 1; |
|
887 |
seen_cells_x := num_cells_x div 2; |
|
888 |
seen_cells_y := num_cells_y div 2; |
|
889 |
||
3181 | 890 |
if maze_inverted then |
891 |
num_steps := 3 //TODO randomize, between 3 and 5? |
|
892 |
else |
|
893 |
num_steps := 1; |
|
894 |
SetLength(step_done, num_steps); |
|
895 |
SetLength(last_cell, num_steps); |
|
896 |
SetLength(came_from_pos, num_steps); |
|
897 |
SetLength(came_from, num_steps, num_cells_x*num_cells_y); |
|
898 |
done := false; |
|
899 |
for current_step := 0 to num_steps - 1 do |
|
900 |
step_done[current_step] := false; |
|
901 |
came_from_pos[current_step] := 0; |
|
902 |
current_step := 0; |
|
903 |
||
3133 | 904 |
SetLength(seen_list, seen_cells_x, seen_cells_y); |
905 |
SetLength(xwalls, seen_cells_x, seen_cells_y - 1); |
|
906 |
SetLength(ywalls, seen_cells_x - 1, seen_cells_y); |
|
907 |
SetLength(x_edge_list, num_edges_x, num_cells_y); |
|
908 |
SetLength(y_edge_list, num_cells_x, num_edges_y); |
|
909 |
SetLength(maze, num_cells_x, num_cells_y); |
|
910 |
||
911 |
num_vertices := 0; |
|
912 |
||
913 |
playHeight := num_cells_y * cellsize; |
|
914 |
playWidth := num_cells_x * cellsize; |
|
915 |
off_y := LAND_HEIGHT - playHeight; |
|
916 |
||
917 |
for x := 0 to playWidth do |
|
918 |
for y := 0 to off_y - 1 do |
|
3181 | 919 |
Land[y, x] := 0; |
3133 | 920 |
|
921 |
for x := 0 to playWidth do |
|
922 |
for y := off_y to LAND_HEIGHT - 1 do |
|
3519 | 923 |
Land[y, x] := lfBasic; |
3133 | 924 |
|
925 |
for y := 0 to num_cells_y - 1 do |
|
926 |
for x := 0 to num_cells_x - 1 do |
|
927 |
maze[x, y] := false; |
|
928 |
||
929 |
for x := 0 to seen_cells_x - 1 do |
|
930 |
for y := 0 to seen_cells_y - 2 do |
|
931 |
xwalls[x, y] := true; |
|
932 |
||
933 |
for x := 0 to seen_cells_x - 2 do |
|
934 |
for y := 0 to seen_cells_y - 1 do |
|
935 |
ywalls[x, y] := true; |
|
936 |
||
937 |
for x := 0 to seen_cells_x - 1 do |
|
938 |
for y := 0 to seen_cells_y - 1 do |
|
3181 | 939 |
seen_list[x, y] := -1; |
3133 | 940 |
|
941 |
for x := 0 to num_edges_x - 1 do |
|
942 |
for y := 0 to num_cells_y - 1 do |
|
943 |
x_edge_list[x, y] := false; |
|
944 |
||
945 |
for x := 0 to num_cells_x - 1 do |
|
946 |
for y := 0 to num_edges_y - 1 do |
|
947 |
y_edge_list[x, y] := false; |
|
948 |
||
3181 | 949 |
for current_step := 0 to num_steps-1 do |
950 |
begin |
|
3242 | 951 |
x := GetRandom(seen_cells_x - 1) div LongWord(num_steps); |
3181 | 952 |
last_cell[current_step].x := x + current_step * seen_cells_x div num_steps; |
953 |
last_cell[current_step].y := GetRandom(seen_cells_y); |
|
954 |
end; |
|
955 |
||
956 |
while not done do |
|
957 |
begin |
|
958 |
done := true; |
|
959 |
for current_step := 0 to num_steps-1 do |
|
960 |
begin |
|
961 |
if not step_done[current_step] then |
|
962 |
begin |
|
963 |
see_cell; |
|
964 |
done := false; |
|
965 |
end; |
|
966 |
end; |
|
967 |
end; |
|
3133 | 968 |
|
969 |
for x := 0 to seen_cells_x - 1 do |
|
970 |
for y := 0 to seen_cells_y - 1 do |
|
3181 | 971 |
if seen_list[x, y] > -1 then |
3133 | 972 |
maze[(x+1)*2-1, (y+1)*2-1] := true; |
973 |
||
974 |
for x := 0 to seen_cells_x - 1 do |
|
975 |
for y := 0 to seen_cells_y - 2 do |
|
976 |
if not xwalls[x, y] then |
|
977 |
maze[x*2 + 1, y*2 + 2] := true; |
|
978 |
||
979 |
||
980 |
for x := 0 to seen_cells_x - 2 do |
|
981 |
for y := 0 to seen_cells_y - 1 do |
|
982 |
if not ywalls[x, y] then |
|
983 |
maze[x*2 + 2, y*2 + 1] := true; |
|
984 |
||
985 |
for x := 0 to num_edges_x - 1 do |
|
986 |
for y := 0 to num_cells_y - 1 do |
|
987 |
if maze[x, y] xor maze[x+1, y] then |
|
988 |
x_edge_list[x, y] := true |
|
989 |
else |
|
990 |
x_edge_list[x, y] := false; |
|
991 |
||
992 |
for x := 0 to num_cells_x - 1 do |
|
993 |
for y := 0 to num_edges_y - 1 do |
|
994 |
if maze[x, y] xor maze[x, y+1] then |
|
995 |
y_edge_list[x, y] := true |
|
996 |
else |
|
997 |
y_edge_list[x, y] := false; |
|
998 |
||
999 |
for x := 0 to num_edges_x - 1 do |
|
1000 |
for y := 0 to num_cells_y - 1 do |
|
1001 |
if x_edge_list[x, y] then |
|
1002 |
begin |
|
1003 |
x_edge_list[x, y] := false; |
|
1004 |
add_vertex(x+1, y+1); |
|
1005 |
add_vertex(x+1, y); |
|
1006 |
add_edge(x, y-1, DIR_N); |
|
1007 |
add_vertex(NTPX, 0); |
|
1008 |
end; |
|
1009 |
||
1010 |
pa.count := num_vertices; |
|
1011 |
||
1012 |
RandomizePoints(pa); |
|
1013 |
BezierizeEdge(pa, _0_25); |
|
1014 |
RandomizePoints(pa); |
|
3138 | 1015 |
BezierizeEdge(pa, _0_25); |
3133 | 1016 |
|
1017 |
DrawEdge(pa, 0); |
|
1018 |
||
3181 | 1019 |
if maze_inverted then |
1020 |
FillLand(1, 1+off_y) |
|
1021 |
else |
|
1022 |
begin |
|
1023 |
x := 0; |
|
3519 | 1024 |
while Land[cellsize div 2 + cellsize + off_y, x] = lfBasic do |
3181 | 1025 |
x := x + 1; |
1026 |
while Land[cellsize div 2 + cellsize + off_y, x] = 0 do |
|
1027 |
x := x + 1; |
|
1028 |
FillLand(x+1, cellsize div 2 + cellsize + off_y); |
|
1029 |
end; |
|
3133 | 1030 |
|
1031 |
MaxHedgehogs:= 32; |
|
3141
70d65353bd60
prg adds option to toggle girders in maze, adjusts some frontend strings
nemo
parents:
3138
diff
changeset
|
1032 |
if (GameFlags and gfDisableGirders) <> 0 then hasGirders:= false |
70d65353bd60
prg adds option to toggle girders in maze, adjusts some frontend strings
nemo
parents:
3138
diff
changeset
|
1033 |
else hasGirders := true; |
3133 | 1034 |
leftX:= 0; |
1035 |
rightX:= playWidth; |
|
1036 |
topY:= off_y; |
|
3181 | 1037 |
hasBorder := false; |
3133 | 1038 |
end; |
1039 |
||
1754 | 1040 |
procedure GenLandSurface; |
1041 |
var tmpsurf: PSDL_Surface; |
|
1042 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1043 |
WriteLnToConsole('Generating land...'); |
3133 | 1044 |
case cMapGen of |
1045 |
0: GenBlank(EdgeTemplates[SelectTemplate]); |
|
1046 |
1: GenMaze; |
|
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
1047 |
2: GenDrawnMap; |
4562 | 1048 |
else |
1049 |
OutError('Unknown mapgen', true); |
|
3133 | 1050 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1051 |
AddProgress(); |
1754 | 1052 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1053 |
tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, LAND_WIDTH, LAND_HEIGHT, 32, RMask, GMask, BMask, 0); |
1754 | 1054 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1055 |
TryDo(tmpsurf <> nil, 'Error creating pre-land surface', true); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1056 |
ColorizeLand(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1057 |
AddOnLandObjects(tmpsurf); |
1754 | 1058 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1059 |
LandSurface2LandPixels(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1060 |
SDL_FreeSurface(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1061 |
AddProgress(); |
1754 | 1062 |
end; |
1063 |
||
1064 |
procedure MakeFortsMap; |
|
1065 |
var tmpsurf: PSDL_Surface; |
|
1066 |
begin |
|
2866 | 1067 |
MaxHedgehogs:= 32; |
2171
8208946331ba
Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents:
2163
diff
changeset
|
1068 |
// For now, defining a fort is playable area as 3072x1200 - there are no tall forts. The extra height is to avoid triggering border with current code, also if user turns on a border, it will give a bit more maneuvering room. |
1784 | 1069 |
playHeight:= 1200; |
2096 | 1070 |
playWidth:= 2560; |
1776 | 1071 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
1072 |
rightX:= ((playWidth + (LAND_WIDTH - playWidth) div 2) - 1); |
|
1073 |
topY:= LAND_HEIGHT - playHeight; |
|
1074 |
||
1754 | 1075 |
WriteLnToConsole('Generating forts land...'); |
1076 |
||
2171
8208946331ba
Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents:
2163
diff
changeset
|
1077 |
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[0]^.Teams[0]^.FortName + 'L', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
1784 | 1078 |
BlitImageAndGenerateCollisionInfo(leftX+150, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
1754 | 1079 |
SDL_FreeSurface(tmpsurf); |
1080 |
||
2171
8208946331ba
Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents:
2163
diff
changeset
|
1081 |
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[1]^.Teams[0]^.FortName + 'R', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
1784 | 1082 |
BlitImageAndGenerateCollisionInfo(rightX - 150 - tmpsurf^.w, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
1754 | 1083 |
SDL_FreeSurface(tmpsurf); |
1084 |
end; |
|
1085 |
||
1792 | 1086 |
// Hi unC0Rr. |
1087 |
// This is a function that Tiy assures me would not be good for gameplay. |
|
1088 |
// It allows the setting of arbitrary portions of landscape as indestructible, or regular, or even blank. |
|
2154
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2152
diff
changeset
|
1089 |
// He said I could add it here only when I swore it would not impact gameplay. Which, as far as I can tell, is true. |
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2152
diff
changeset
|
1090 |
// I would just like to play with it with my friends if you do not mind. |
1792 | 1091 |
// Can allow for amusing maps. |
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1092 |
procedure LoadMask(mapName: shortstring); |
1792 | 1093 |
var tmpsurf: PSDL_Surface; |
1094 |
p: PLongwordArray; |
|
1095 |
x, y, cpX, cpY: Longword; |
|
1096 |
begin |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1097 |
tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps); |
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1098 |
if (tmpsurf = nil) and (mapName <> '') then |
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1099 |
tmpsurf:= LoadImage(Pathz[ptMissionMaps] + '/' + mapName +'/mask', ifAlpha or ifTransparent or ifIgnoreCaps); |
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1100 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1101 |
if (tmpsurf <> nil) and (tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT) and (tmpsurf^.format^.BytesPerPixel = 4) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1102 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1103 |
cpX:= (LAND_WIDTH - tmpsurf^.w) div 2; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1104 |
cpY:= LAND_HEIGHT - tmpsurf^.h; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1105 |
if SDL_MustLock(tmpsurf) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1106 |
SDLTry(SDL_LockSurface(tmpsurf) >= 0, true); |
2376 | 1107 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1108 |
p:= tmpsurf^.pixels; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1109 |
for y:= 0 to Pred(tmpsurf^.h) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1110 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1111 |
for x:= 0 to Pred(tmpsurf^.w) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1112 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1113 |
if ((AMask and p^[x]) = 0) then // Tiy was having trouble generating transparent black |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1114 |
Land[cpY + y, cpX + x]:= 0 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1115 |
else if p^[x] = (AMask or RMask) then |
3519 | 1116 |
Land[cpY + y, cpX + x]:= lfIndestructible |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1117 |
else if p^[x] = $FFFFFFFF then |
3519 | 1118 |
Land[cpY + y, cpX + x]:= lfBasic; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1119 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1120 |
p:= @(p^[tmpsurf^.pitch div 4]); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1121 |
end; |
2243
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
1122 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1123 |
if SDL_MustLock(tmpsurf) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1124 |
SDL_UnlockSurface(tmpsurf); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1125 |
end; |
3697 | 1126 |
if (tmpsurf <> nil) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1127 |
SDL_FreeSurface(tmpsurf); |
3513
f589230fa21b
now it's possible to select the scheme file in the ifrontendfix a type about loading an image (iphone file system IS case senstive)
koda
parents:
3509
diff
changeset
|
1128 |
tmpsurf:= nil; |
1792 | 1129 |
end; |
1130 |
||
1754 | 1131 |
procedure LoadMap; |
1132 |
var tmpsurf: PSDL_Surface; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1133 |
s: shortstring; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1134 |
f: textfile; |
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1135 |
mapName: shortstring = ''; |
1754 | 1136 |
begin |
2981 | 1137 |
isMap:= true; |
1754 | 1138 |
WriteLnToConsole('Loading land from file...'); |
1139 |
AddProgress; |
|
3912
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1140 |
tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/map', ifAlpha or ifTransparent or ifIgnoreCaps); |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1141 |
if tmpsurf = nil then |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1142 |
begin |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1143 |
mapName:= ExtractFileName(Pathz[ptMapCurrent]); |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1144 |
tmpsurf:= LoadImage(Pathz[ptMissionMaps] + '/' + mapName + '/map', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1145 |
end; |
1760 | 1146 |
TryDo((tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT), 'Map dimensions too big!', true); |
1754 | 1147 |
|
2154
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2152
diff
changeset
|
1148 |
// unC0Rr - should this be passed from the GUI? I am not sure which layer does what |
1792 | 1149 |
s:= Pathz[ptMapCurrent] + '/map.cfg'; |
1150 |
WriteLnToConsole('Fetching map HH limit'); |
|
3912
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1151 |
{$I-} |
1792 | 1152 |
Assign(f, s); |
2747 | 1153 |
filemode:= 0; // readonly |
1792 | 1154 |
Reset(f); |
3912
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1155 |
if IOResult <> 0 then |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1156 |
begin |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1157 |
s:= Pathz[ptMissionMaps] + '/' + mapName + '/map.cfg'; |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1158 |
Assign(f, s); |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1159 |
Reset(f); |
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1160 |
end; |
1795 | 1161 |
Readln(f); |
1162 |
if not eof(f) then Readln(f, MaxHedgehogs); |
|
3912
e11df2de6af2
have engine try for a second position when map loading fails (in this way it's possible to move Missions data to any path)
koda
parents:
3836
diff
changeset
|
1163 |
{$I+} |
2705
2b5625c4ec16
fix a nasty 196 bytes memory leak in engine, plus other stuff for iphone frontend
koda
parents:
2699
diff
changeset
|
1164 |
if (MaxHedgehogs = 0) then MaxHedgehogs:= 18; |
1792 | 1165 |
|
1776 | 1166 |
playHeight:= tmpsurf^.h; |
1167 |
playWidth:= tmpsurf^.w; |
|
1168 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
|
1169 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
|
1170 |
topY:= LAND_HEIGHT - playHeight; |
|
1171 |
||
1754 | 1172 |
TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Map should be 32bit', true); |
1173 |
||
1772 | 1174 |
BlitImageAndGenerateCollisionInfo( |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1175 |
(LAND_WIDTH - tmpsurf^.w) div 2, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1176 |
LAND_HEIGHT - tmpsurf^.h, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1177 |
tmpsurf^.w, |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1178 |
tmpsurf); |
1754 | 1179 |
SDL_FreeSurface(tmpsurf); |
1792 | 1180 |
|
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
1181 |
LoadMask(mapname); |
1754 | 1182 |
end; |
1183 |
||
1184 |
procedure GenMap; |
|
1784 | 1185 |
var x, y, w, c: Longword; |
1754 | 1186 |
begin |
3463 | 1187 |
hasBorder:= false; |
2891
e1f902eb0cfe
Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents:
2866
diff
changeset
|
1188 |
|
3463 | 1189 |
LoadThemeConfig; |
1190 |
isMap:= false; |
|
3697 | 1191 |
|
3630 | 1192 |
// is this not needed any more? let's hope setlength sets also 0s |
1193 |
//if ((GameFlags and gfForts) <> 0) or (Pathz[ptMapCurrent] <> '') then |
|
1194 |
// FillChar(Land,SizeOf(TCollisionArray),0);*) |
|
3697 | 1195 |
|
3463 | 1196 |
if (GameFlags and gfForts) = 0 then |
1197 |
if Pathz[ptMapCurrent] <> '' then |
|
1198 |
LoadMap |
|
1199 |
else |
|
1200 |
GenLandSurface |
|
1201 |
else |
|
1202 |
MakeFortsMap; |
|
1203 |
||
1204 |
AddProgress; |
|
1760 | 1205 |
|
1768 | 1206 |
// check for land near top |
1784 | 1207 |
c:= 0; |
1208 |
if (GameFlags and gfBorder) <> 0 then |
|
1209 |
hasBorder:= true |
|
1210 |
else |
|
1211 |
for y:= topY to topY + 5 do |
|
1212 |
for x:= leftX to rightX do |
|
1213 |
if Land[y, x] <> 0 then |
|
1214 |
begin |
|
1215 |
inc(c); |
|
1216 |
if c > 200 then // avoid accidental triggering |
|
1217 |
begin |
|
1218 |
hasBorder:= true; |
|
1219 |
break; |
|
1220 |
end; |
|
1221 |
end; |
|
1768 | 1222 |
|
1776 | 1223 |
if hasBorder then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1224 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1225 |
for y:= 0 to LAND_HEIGHT - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1226 |
for x:= 0 to LAND_WIDTH - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1227 |
if (y < topY) or (x < leftX) or (x > rightX) then |
3519 | 1228 |
Land[y, x]:= lfIndestructible; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1229 |
// experiment hardcoding cave |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1230 |
// also try basing cave dimensions on map/template dimensions, if they exist |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1231 |
for w:= 0 to 5 do // width of 3 allowed hogs to be knocked through with grenade |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1232 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1233 |
for y:= topY to LAND_HEIGHT - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1234 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1235 |
Land[y, leftX + w]:= lfIndestructible; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1236 |
Land[y, rightX - w]:= lfIndestructible; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1237 |
if (y + w) mod 32 < 16 then |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1238 |
c:= AMask |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1239 |
else |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1240 |
c:= AMask or RMask or GMask; // FF00FFFF |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1241 |
|
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1242 |
if (cReducedQuality and rqBlurryLand) = 0 then |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1243 |
begin |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1244 |
LandPixels[y, leftX + w]:= c; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1245 |
LandPixels[y, rightX - w]:= c; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1246 |
end |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1247 |
else |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1248 |
begin |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1249 |
LandPixels[y div 2, (leftX + w) div 2]:= c; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1250 |
LandPixels[y div 2, (rightX - w) div 2]:= c; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1251 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1252 |
end; |
1768 | 1253 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1254 |
for x:= leftX to rightX do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1255 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1256 |
Land[topY + w, x]:= lfIndestructible; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1257 |
if (x + w) mod 32 < 16 then |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1258 |
c:= AMask |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1259 |
else |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1260 |
c:= AMask or RMask or GMask; // FF00FFFF |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1261 |
|
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1262 |
if (cReducedQuality and rqBlurryLand) = 0 then |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1263 |
LandPixels[topY + w, x]:= c |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1264 |
else |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3551
diff
changeset
|
1265 |
LandPixels[(topY + w) div 2, x div 2]:= c; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1266 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1267 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1268 |
end; |
1768 | 1269 |
|
2891
e1f902eb0cfe
Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents:
2866
diff
changeset
|
1270 |
if (GameFlags and gfDisableGirders) <> 0 then hasGirders:= false; |
e1f902eb0cfe
Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents:
2866
diff
changeset
|
1271 |
|
3287 | 1272 |
if ((GameFlags and gfForts) = 0) |
1273 |
and (Pathz[ptMapCurrent] = '') |
|
3936
0b982d340633
bug #83 - move test of disabled land objects into AddObjects
nemo
parents:
3920
diff
changeset
|
1274 |
then AddObjects |
0b982d340633
bug #83 - move test of disabled land objects into AddObjects
nemo
parents:
3920
diff
changeset
|
1275 |
else AddProgress(); |
1776 | 1276 |
|
3058 | 1277 |
FreeLandObjects; |
1278 |
||
1807 | 1279 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT); |
37 | 1280 |
end; |
1281 |
||
566 | 1282 |
function GenPreview: TPreview; |
3617 | 1283 |
var x, y, xx, yy, t, bit, cbit, lh, lw: LongInt; |
566 | 1284 |
Preview: TPreview; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1285 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1286 |
WriteLnToConsole('Generating preview...'); |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1287 |
case cMapGen of |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1288 |
0: GenBlank(EdgeTemplates[SelectTemplate]); |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1289 |
1: GenMaze; |
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
1290 |
2: GenDrawnMap; |
4562 | 1291 |
else |
1292 |
OutError('Unknown mapgen', true); |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1293 |
end; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1294 |
|
3617 | 1295 |
lh:= LAND_HEIGHT div 128; |
1296 |
lw:= LAND_WIDTH div 32; |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1297 |
for y:= 0 to 127 do |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1298 |
for x:= 0 to 31 do |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1299 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1300 |
Preview[y, x]:= 0; |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1301 |
for bit:= 0 to 7 do |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1302 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1303 |
t:= 0; |
3617 | 1304 |
cbit:= bit * 8; |
1305 |
for yy:= y * lh to y * lh + 7 do |
|
1306 |
for xx:= x * lw + cbit to x * lw + cbit + 7 do |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1307 |
if Land[yy, xx] <> 0 then inc(t); |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1308 |
if t > 8 then |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1309 |
Preview[y, x]:= Preview[y, x] or ($80 shr bit); |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1310 |
end; |
566 | 1311 |
end; |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1312 |
|
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
1313 |
GenPreview:= Preview |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1314 |
end; |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
1315 |
|
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1316 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1317 |
procedure chLandCheck(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1318 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1319 |
{$IFDEF DEBUGFILE} |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1320 |
AddFileLog('CheckLandDigest: ' + s + ' digest : ' + digest); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1321 |
{$ENDIF} |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1322 |
if digest = '' then |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1323 |
digest:= s |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1324 |
else |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1325 |
TryDo(s = digest, 'Different maps generated, sorry', true); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1326 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1327 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1328 |
procedure chSendLandDigest(var s: shortstring); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1329 |
var adler, i: LongInt; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1330 |
begin |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1331 |
adler:= 1; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1332 |
for i:= 0 to LAND_HEIGHT-1 do |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1333 |
Adler32Update(adler, @Land[i,0], LAND_WIDTH); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1334 |
s:= 'M' + IntToStr(adler); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1335 |
|
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1336 |
chLandCheck(s); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1337 |
SendIPCRaw(@s[0], Length(s) + 1) |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1338 |
end; |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1339 |
|
3038 | 1340 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1341 |
begin |
4398
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1342 |
RegisterVariable('landcheck', vtCommand, @chLandCheck, false); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1343 |
RegisterVariable('sendlanddigest', vtCommand, @chSendLandDigest, false); |
36d7e4b6ca81
Move some command handlers out of uCommands into more appropriate places, thus removing some dependencies. Ideally uCommands shouldn't depend on anything (except for uTypes and uConsts probably)
unc0rr
parents:
4389
diff
changeset
|
1344 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1345 |
LandBackSurface:= nil; |
3369
c7289e42f0ee
add other controls for map preview, also fix a bug in digest
koda
parents:
3365
diff
changeset
|
1346 |
digest:= ''; |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1347 |
|
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1348 |
if (cReducedQuality and rqBlurryLand) = 0 then |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1349 |
SetLength(LandPixels, LAND_HEIGHT, LAND_WIDTH) |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1350 |
else |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1351 |
SetLength(LandPixels, LAND_HEIGHT div 2, LAND_WIDTH div 2); |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1352 |
|
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1353 |
SetLength(Land, LAND_HEIGHT, LAND_WIDTH); |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1354 |
SetLength(LandDirty, (LAND_HEIGHT div 32), (LAND_WIDTH div 32)); |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1355 |
end; |
51 | 1356 |
|
3038 | 1357 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1358 |
begin |
3612
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1359 |
Land:= nil; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1360 |
LandPixels:= nil; |
b50215a8a43d
land arrays are allocated dynamically, so DOWNSCALE and LOWRES macros are now removed and replaced by run time flags rqBlurryLand and rqLowRes
koda
parents:
3608
diff
changeset
|
1361 |
LandDirty:= nil; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1362 |
end; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1363 |
|
4 | 1364 |
end. |