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