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