author | unc0rr |
Wed, 12 Aug 2009 12:27:08 +0000 | |
changeset 2303 | f411e9f8e6d4 |
parent 2251 | bf0b59d3536a |
child 2308 | 4c39fb2bea6e |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
883 | 3 |
* Copyright (c) 2005-2008 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 |
||
19 |
unit uLand; |
|
20 |
interface |
|
1906 | 21 |
uses SDLh, uLandTemplates, uFloat, |
2152 | 22 |
{$IFDEF GLES11} |
1906 | 23 |
gles11, |
24 |
{$ELSE} |
|
25 |
GL, |
|
26 |
{$ENDIF} |
|
27 |
uConsts; |
|
4 | 28 |
{$include options.inc} |
1760 | 29 |
type TLandArray = packed array[0 .. LAND_HEIGHT - 1, 0 .. LAND_WIDTH - 1] of LongWord; |
2243
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
30 |
TCollisionArray = packed array[0 .. LAND_HEIGHT - 1, 0 .. LAND_WIDTH - 1] of Word; |
1760 | 31 |
TPreview = packed array[0..127, 0..31] of byte; |
32 |
TDirtyTag = packed array[0 .. LAND_HEIGHT div 32 - 1, 0 .. LAND_WIDTH div 32 - 1] of byte; |
|
4 | 33 |
|
2243
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
34 |
var Land: TCollisionArray; |
768 | 35 |
LandPixels: TLandArray; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1537
diff
changeset
|
36 |
LandDirty: TDirtyTag; |
1776 | 37 |
hasBorder: boolean; // I'm putting this here for now. I'd like it to be toggleable by user (so user can set a border on a non-cave map) - will turn off air attacks |
2152 | 38 |
hasGirders: boolean; // I think should be on template by template basis. some caverns might have open water and large spaces. Some islands do not need? It might be better to tweak the girder code based upon space above. dunno. |
1792 | 39 |
playHeight, playWidth, leftX, rightX, topY, MaxHedgehogs: Longword; // idea is that a template can specify height/width. Or, a map, a height/width by the dimensions of the image. If the map has pixels near top of image, it triggers border. Maybe not a good idea, but, for now? Could also be used to prevent placing a girder outside play area on maps with hasBorder = true |
1776 | 40 |
|
41 |
// in your coding style, it appears to be "isXXXX" for a verb, and "FooBar" for everything else - should be PlayHeight ? |
|
4 | 42 |
|
37 | 43 |
procedure GenMap; |
766 | 44 |
function GenPreview: TPreview; |
367 | 45 |
procedure CheckLandDigest(s: shortstring); |
4 | 46 |
|
47 |
implementation |
|
1806 | 48 |
uses uConsole, uStore, uMisc, uRandom, uTeams, uLandObjects, uSHA, uIO, uAmmos, uLandTexture; |
4 | 49 |
|
50 |
type TPixAr = record |
|
51 |
Count: Longword; |
|
22 | 52 |
ar: array[0..Pred(cMaxEdgePoints)] of TPoint; |
4 | 53 |
end; |
54 |
||
37 | 55 |
procedure LogLandDigest; |
316 | 56 |
var ctx: TSHA1Context; |
57 |
dig: TSHA1Digest; |
|
58 |
s: shortstring; |
|
37 | 59 |
begin |
316 | 60 |
SHA1Init(ctx); |
2157 | 61 |
SHA1UpdateLongwords(ctx, @Land, sizeof(Land) div 4); |
316 | 62 |
dig:= SHA1Final(ctx); |
367 | 63 |
s:='M{'+inttostr(dig[0])+':' |
316 | 64 |
+inttostr(dig[1])+':' |
65 |
+inttostr(dig[2])+':' |
|
66 |
+inttostr(dig[3])+':' |
|
67 |
+inttostr(dig[4])+'}'; |
|
699 | 68 |
CheckLandDigest(s); |
367 | 69 |
SendIPCRaw(@s[0], Length(s) + 1) |
70 |
end; |
|
71 |
||
72 |
procedure CheckLandDigest(s: shortstring); |
|
73 |
const digest: shortstring = ''; |
|
74 |
begin |
|
368 | 75 |
{$IFDEF DEBUGFILE} |
76 |
AddFileLog('CheckLandDigest: ' + s); |
|
77 |
{$ENDIF} |
|
367 | 78 |
if digest = '' then |
79 |
digest:= s |
|
80 |
else |
|
700 | 81 |
TryDo(s = digest, 'Different maps generated, sorry', true) |
37 | 82 |
end; |
83 |
||
371 | 84 |
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword); |
358 | 85 |
var |
371 | 86 |
eX, eY, dX, dY: LongInt; |
87 |
i, sX, sY, x, y, d: LongInt; |
|
358 | 88 |
begin |
89 |
eX:= 0; |
|
90 |
eY:= 0; |
|
91 |
dX:= X2 - X1; |
|
92 |
dY:= Y2 - Y1; |
|
93 |
||
94 |
if (dX > 0) then sX:= 1 |
|
95 |
else |
|
96 |
if (dX < 0) then |
|
97 |
begin |
|
98 |
sX:= -1; |
|
99 |
dX:= -dX |
|
100 |
end else sX:= dX; |
|
101 |
||
102 |
if (dY > 0) then sY:= 1 |
|
103 |
else |
|
104 |
if (dY < 0) then |
|
105 |
begin |
|
106 |
sY:= -1; |
|
107 |
dY:= -dY |
|
108 |
end else sY:= dY; |
|
109 |
||
110 |
if (dX > dY) then d:= dX |
|
111 |
else d:= dY; |
|
112 |
||
113 |
x:= X1; |
|
114 |
y:= Y1; |
|
115 |
||
116 |
for i:= 0 to d do |
|
117 |
begin |
|
118 |
inc(eX, dX); |
|
119 |
inc(eY, dY); |
|
120 |
if (eX > d) then |
|
121 |
begin |
|
122 |
dec(eX, d); |
|
123 |
inc(x, sX); |
|
124 |
end; |
|
125 |
if (eY > d) then |
|
126 |
begin |
|
127 |
dec(eY, d); |
|
128 |
inc(y, sY); |
|
129 |
end; |
|
364 | 130 |
|
1753 | 131 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
358 | 132 |
Land[y, x]:= Color; |
133 |
end |
|
134 |
end; |
|
135 |
||
365 | 136 |
procedure DrawEdge(var pa: TPixAr; Color: Longword); |
371 | 137 |
var i: LongInt; |
4 | 138 |
begin |
365 | 139 |
i:= 0; |
4 | 140 |
with pa do |
371 | 141 |
while i < LongInt(Count) - 1 do |
365 | 142 |
if (ar[i + 1].X = NTPX) then inc(i, 2) |
143 |
else begin |
|
144 |
DrawLine(ar[i].x, ar[i].y, ar[i + 1].x, ar[i + 1].y, Color); |
|
145 |
inc(i) |
|
146 |
end |
|
22 | 147 |
end; |
148 |
||
365 | 149 |
procedure Vector(p1, p2, p3: TPoint; var Vx, Vy: hwFloat); |
150 |
var d1, d2, d: hwFloat; |
|
364 | 151 |
begin |
498 | 152 |
Vx:= int2hwFloat(p1.X - p3.X); |
153 |
Vy:= int2hwFloat(p1.Y - p3.Y); |
|
154 |
d:= DistanceI(p2.X - p1.X, p2.Y - p1.Y); |
|
155 |
d1:= DistanceI(p2.X - p3.X, p2.Y - p3.Y); |
|
365 | 156 |
d2:= Distance(Vx, Vy); |
157 |
if d1 < d then d:= d1; |
|
158 |
if d2 < d then d:= d2; |
|
159 |
d:= d * _1div3; |
|
160 |
if d2.QWordValue = 0 then |
|
161 |
begin |
|
498 | 162 |
Vx:= _0; |
163 |
Vy:= _0 |
|
365 | 164 |
end else |
165 |
begin |
|
498 | 166 |
d2:= _1 / d2; |
365 | 167 |
Vx:= Vx * d2; |
168 |
Vy:= Vy * d2; |
|
169 |
||
170 |
Vx:= Vx * d; |
|
171 |
Vy:= Vy * d |
|
172 |
end |
|
173 |
end; |
|
174 |
||
371 | 175 |
procedure AddLoopPoints(var pa, opa: TPixAr; StartI, EndI: LongInt; Delta: hwFloat); |
176 |
var i, pi, ni: LongInt; |
|
365 | 177 |
NVx, NVy, PVx, PVy: hwFloat; |
498 | 178 |
x1, x2, y1, y2: LongInt; |
179 |
tsq, tcb, t, r1, r2, r3, cx1, cx2, cy1, cy2: hwFloat; |
|
371 | 180 |
X, Y: LongInt; |
365 | 181 |
begin |
182 |
pi:= EndI; |
|
183 |
i:= StartI; |
|
184 |
ni:= Succ(StartI); |
|
185 |
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy); |
|
186 |
repeat |
|
187 |
inc(pi); |
|
188 |
if pi > EndI then pi:= StartI; |
|
189 |
inc(i); |
|
190 |
if i > EndI then i:= StartI; |
|
191 |
inc(ni); |
|
192 |
if ni > EndI then ni:= StartI; |
|
193 |
PVx:= NVx; |
|
194 |
PVy:= NVy; |
|
195 |
Vector(opa.ar[pi], opa.ar[i], opa.ar[ni], NVx, NVy); |
|
196 |
||
197 |
x1:= opa.ar[pi].x; |
|
198 |
y1:= opa.ar[pi].y; |
|
199 |
x2:= opa.ar[i].x; |
|
200 |
y2:= opa.ar[i].y; |
|
498 | 201 |
cx1:= int2hwFloat(x1) - PVx; |
202 |
cy1:= int2hwFloat(y1) - PVy; |
|
203 |
cx2:= int2hwFloat(x2) + NVx; |
|
204 |
cy2:= int2hwFloat(y2) + NVy; |
|
205 |
t:= _0; |
|
364 | 206 |
while t.Round = 0 do |
207 |
begin |
|
208 |
tsq:= t * t; |
|
209 |
tcb:= tsq * t; |
|
498 | 210 |
r1:= (_1 - t*3 + tsq*3 - tcb); |
211 |
r2:= ( t*3 - tsq*6 + tcb*3); |
|
212 |
r3:= ( tsq*3 - tcb*3); |
|
430 | 213 |
X:= hwRound(r1 * x1 + r2 * cx1 + r3 * cx2 + tcb * x2); |
214 |
Y:= hwRound(r1 * y1 + r2 * cy1 + r3 * cy2 + tcb * y2); |
|
364 | 215 |
t:= t + Delta; |
216 |
pa.ar[pa.Count].x:= X; |
|
217 |
pa.ar[pa.Count].y:= Y; |
|
218 |
inc(pa.Count); |
|
219 |
TryDo(pa.Count <= cMaxEdgePoints, 'Edge points overflow', true) |
|
220 |
end; |
|
365 | 221 |
until i = StartI; |
222 |
pa.ar[pa.Count].x:= opa.ar[StartI].X; |
|
223 |
pa.ar[pa.Count].y:= opa.ar[StartI].Y; |
|
364 | 224 |
inc(pa.Count) |
225 |
end; |
|
226 |
||
365 | 227 |
procedure BezierizeEdge(var pa: TPixAr; Delta: hwFloat); |
495 | 228 |
var i, StartLoop: LongInt; |
365 | 229 |
opa: TPixAr; |
230 |
begin |
|
231 |
opa:= pa; |
|
232 |
pa.Count:= 0; |
|
233 |
i:= 0; |
|
234 |
StartLoop:= 0; |
|
371 | 235 |
while i < LongInt(opa.Count) do |
365 | 236 |
if (opa.ar[i + 1].X = NTPX) then |
237 |
begin |
|
238 |
AddLoopPoints(pa, opa, StartLoop, i, Delta); |
|
239 |
inc(i, 2); |
|
240 |
StartLoop:= i; |
|
241 |
pa.ar[pa.Count].X:= NTPX; |
|
242 |
inc(pa.Count); |
|
243 |
end else inc(i) |
|
244 |
end; |
|
245 |
||
371 | 246 |
procedure FillLand(x, y: LongInt); |
4 | 247 |
var Stack: record |
248 |
Count: Longword; |
|
249 |
points: array[0..8192] of record |
|
371 | 250 |
xl, xr, y, dir: LongInt; |
4 | 251 |
end |
252 |
end; |
|
253 |
||
371 | 254 |
procedure Push(_xl, _xr, _y, _dir: LongInt); |
4 | 255 |
begin |
75 | 256 |
TryDo(Stack.Count <= 8192, 'FillLand: stack overflow', true); |
4 | 257 |
_y:= _y + _dir; |
1760 | 258 |
if (_y < 0) or (_y >= LAND_HEIGHT) then exit; |
4 | 259 |
with Stack.points[Stack.Count] do |
260 |
begin |
|
261 |
xl:= _xl; |
|
262 |
xr:= _xr; |
|
263 |
y:= _y; |
|
264 |
dir:= _dir |
|
265 |
end; |
|
75 | 266 |
inc(Stack.Count) |
4 | 267 |
end; |
268 |
||
371 | 269 |
procedure Pop(var _xl, _xr, _y, _dir: LongInt); |
4 | 270 |
begin |
271 |
dec(Stack.Count); |
|
272 |
with Stack.points[Stack.Count] do |
|
273 |
begin |
|
274 |
_xl:= xl; |
|
275 |
_xr:= xr; |
|
276 |
_y:= y; |
|
277 |
_dir:= dir |
|
278 |
end |
|
279 |
end; |
|
280 |
||
371 | 281 |
var xl, xr, dir: LongInt; |
351 | 282 |
begin |
4 | 283 |
Stack.Count:= 0; |
284 |
xl:= x - 1; |
|
285 |
xr:= x; |
|
23 | 286 |
Push(xl, xr, y, -1); |
287 |
Push(xl, xr, y, 1); |
|
4 | 288 |
while Stack.Count > 0 do |
289 |
begin |
|
290 |
Pop(xl, xr, y, dir); |
|
51 | 291 |
while (xl > 0) and (Land[y, xl] <> 0) do dec(xl); |
1760 | 292 |
while (xr < LAND_WIDTH - 1) and (Land[y, xr] <> 0) do inc(xr); |
4 | 293 |
while (xl < xr) do |
294 |
begin |
|
51 | 295 |
while (xl <= xr) and (Land[y, xl] = 0) do inc(xl); |
4 | 296 |
x:= xl; |
51 | 297 |
while (xl <= xr) and (Land[y, xl] <> 0) do |
4 | 298 |
begin |
51 | 299 |
Land[y, xl]:= 0; |
4 | 300 |
inc(xl) |
301 |
end; |
|
22 | 302 |
if x < xl then |
303 |
begin |
|
304 |
Push(x, Pred(xl), y, dir); |
|
305 |
Push(x, Pred(xl), y,-dir); |
|
306 |
end; |
|
4 | 307 |
end; |
308 |
end; |
|
309 |
end; |
|
310 |
||
311 |
procedure ColorizeLand(Surface: PSDL_Surface); |
|
312 |
var tmpsurf: PSDL_Surface; |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
313 |
r, rr: TSDL_Rect; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
314 |
x, yd, yu: LongInt; |
4 | 315 |
begin |
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
|
316 |
tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/LandTex', ifCritical or ifIgnoreCaps); |
4 | 317 |
r.y:= 0; |
1760 | 318 |
while r.y < LAND_HEIGHT do |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
319 |
begin |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
320 |
r.x:= 0; |
1760 | 321 |
while r.x < LAND_WIDTH do |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
322 |
begin |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
323 |
SDL_UpperBlit(tmpsurf, nil, Surface, @r); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
324 |
inc(r.x, tmpsurf^.w) |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
325 |
end; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
326 |
inc(r.y, tmpsurf^.h) |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
327 |
end; |
4 | 328 |
SDL_FreeSurface(tmpsurf); |
329 |
||
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
|
330 |
tmpsurf:= LoadImage(Pathz[ptCurrTheme] + '/Border', ifCritical or ifIgnoreCaps or ifTransparent); |
1760 | 331 |
for x:= 0 to LAND_WIDTH - 1 do |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
332 |
begin |
1760 | 333 |
yd:= LAND_HEIGHT - 1; |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
334 |
repeat |
1760 | 335 |
while (yd > 0) and (Land[yd, x] = 0) do dec(yd); |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
336 |
|
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
337 |
if (yd < 0) then yd:= 0; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
338 |
|
1760 | 339 |
while (yd < LAND_HEIGHT) and (Land[yd, x] <> 0) do inc(yd); |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
340 |
dec(yd); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
341 |
yu:= yd; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
342 |
|
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
343 |
while (yu > 0 ) and (Land[yu, x] <> 0) do dec(yu); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
344 |
while (yu < yd ) and (Land[yu, x] = 0) do inc(yu); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
345 |
|
1760 | 346 |
if (yd < LAND_HEIGHT - 1) and ((yd - yu) >= 16) then |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
347 |
begin |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
348 |
rr.x:= x; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
349 |
rr.y:= yd - 15; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
350 |
r.x:= x mod tmpsurf^.w; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
351 |
r.y:= 16; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
352 |
r.w:= 1; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
353 |
r.h:= 16; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
354 |
SDL_UpperBlit(tmpsurf, @r, Surface, @rr); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
355 |
end; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
356 |
if (yu > 0) then |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
357 |
begin |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
358 |
rr.x:= x; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
359 |
rr.y:= yu; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
360 |
r.x:= x mod tmpsurf^.w; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
361 |
r.y:= 0; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
362 |
r.w:= 1; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
363 |
r.h:= min(16, yd - yu + 1); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
364 |
SDL_UpperBlit(tmpsurf, @r, Surface, @rr); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
365 |
end; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
366 |
yd:= yu - 1; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
367 |
until yd < 0; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
368 |
end; |
4 | 369 |
end; |
370 |
||
358 | 371 |
procedure SetPoints(var Template: TEdgeTemplate; var pa: TPixAr); |
371 | 372 |
var i: LongInt; |
22 | 373 |
begin |
23 | 374 |
with Template do |
375 |
begin |
|
358 | 376 |
pa.Count:= BasePointsCount; |
377 |
for i:= 0 to pred(pa.Count) do |
|
23 | 378 |
begin |
371 | 379 |
pa.ar[i].x:= BasePoints^[i].x + LongInt(GetRandom(BasePoints^[i].w)); |
1792 | 380 |
if pa.ar[i].x <> NTPX then |
381 |
pa.ar[i].x:= pa.ar[i].x + ((LAND_WIDTH - Template.TemplateWidth) div 2); |
|
1776 | 382 |
pa.ar[i].y:= BasePoints^[i].y + LongInt(GetRandom(BasePoints^[i].h)) + LAND_HEIGHT - Template.TemplateHeight |
23 | 383 |
end; |
1183
540cea859395
Step 4: repair girder rendering (girder is 32bit now)
unc0rr
parents:
1182
diff
changeset
|
384 |
|
358 | 385 |
if canMirror then |
360 | 386 |
if getrandom(2) = 0 then |
358 | 387 |
begin |
388 |
for i:= 0 to pred(BasePointsCount) do |
|
365 | 389 |
if pa.ar[i].x <> NTPX then |
1760 | 390 |
pa.ar[i].x:= LAND_WIDTH - 1 - pa.ar[i].x; |
358 | 391 |
for i:= 0 to pred(FillPointsCount) do |
1760 | 392 |
FillPoints^[i].x:= LAND_WIDTH - 1 - FillPoints^[i].x; |
358 | 393 |
end; |
22 | 394 |
|
358 | 395 |
if canFlip then |
360 | 396 |
if getrandom(2) = 0 then |
358 | 397 |
begin |
398 |
for i:= 0 to pred(BasePointsCount) do |
|
1760 | 399 |
pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y; |
358 | 400 |
for i:= 0 to pred(FillPointsCount) do |
1760 | 401 |
FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y; |
358 | 402 |
end; |
403 |
end |
|
4 | 404 |
end; |
67 | 405 |
|
561 | 406 |
function CheckIntersect(V1, V2, V3, V4: TPoint): boolean; |
407 |
var c1, c2, dm: LongInt; |
|
408 |
begin |
|
409 |
dm:= (V4.y - V3.y) * (V2.x - V1.x) - (V4.x - V3.x) * (V2.y - V1.y); |
|
410 |
c1:= (V4.x - V3.x) * (V1.y - V3.y) - (V4.y - V3.y) * (V1.x - V3.x); |
|
411 |
if dm = 0 then exit(false); |
|
412 |
||
413 |
c2:= (V2.x - V3.x) * (V1.y - V3.y) - (V2.y - V3.y) * (V1.x - V3.x); |
|
414 |
if dm > 0 then |
|
415 |
begin |
|
416 |
if (c1 < 0) or (c1 > dm) then exit(false); |
|
417 |
if (c2 < 0) or (c2 > dm) then exit(false) |
|
418 |
end else |
|
419 |
begin |
|
420 |
if (c1 > 0) or (c1 < dm) then exit(false); |
|
421 |
if (c2 > 0) or (c2 < dm) then exit(false) |
|
422 |
end; |
|
423 |
||
424 |
//AddFileLog('1 (' + inttostr(V1.x) + ',' + inttostr(V1.y) + ')x(' + inttostr(V2.x) + ',' + inttostr(V2.y) + ')'); |
|
425 |
//AddFileLog('2 (' + inttostr(V3.x) + ',' + inttostr(V3.y) + ')x(' + inttostr(V4.x) + ',' + inttostr(V4.y) + ')'); |
|
426 |
CheckIntersect:= true |
|
427 |
end; |
|
428 |
||
429 |
function CheckSelfIntersect(var pa: TPixAr; ind: Longword): boolean; |
|
430 |
var i: Longword; |
|
431 |
begin |
|
432 |
if (ind <= 0) or (ind >= Pred(pa.Count)) then exit(false); |
|
433 |
for i:= 1 to pa.Count - 3 do |
|
434 |
if (i <= ind - 1) or (i >= ind + 2) then |
|
435 |
begin |
|
436 |
if (i <> ind - 1) and |
|
437 |
CheckIntersect(pa.ar[ind], pa.ar[ind - 1], pa.ar[i], pa.ar[i - 1]) then exit(true); |
|
438 |
if (i <> ind + 2) and |
|
439 |
CheckIntersect(pa.ar[ind], pa.ar[ind + 1], pa.ar[i], pa.ar[i - 1]) then exit(true); |
|
440 |
end; |
|
441 |
CheckSelfIntersect:= false |
|
442 |
end; |
|
443 |
||
429 | 444 |
procedure RandomizePoints(var pa: TPixAr); |
364 | 445 |
const cEdge = 55; |
561 | 446 |
cMinDist = 8; |
371 | 447 |
var radz: array[0..Pred(cMaxEdgePoints)] of LongInt; |
561 | 448 |
i, k, dist, px, py: LongInt; |
364 | 449 |
begin |
450 |
radz[0]:= 0; |
|
451 |
for i:= 0 to Pred(pa.Count) do |
|
452 |
with pa.ar[i] do |
|
365 | 453 |
if x <> NTPX then |
454 |
begin |
|
1760 | 455 |
radz[i]:= Min(Max(x - cEdge, 0), Max(LAND_WIDTH - cEdge - x, 0)); |
456 |
radz[i]:= Min(radz[i], Min(Max(y - cEdge, 0), Max(LAND_HEIGHT - cEdge - y, 0))); |
|
365 | 457 |
if radz[i] > 0 then |
458 |
for k:= 0 to Pred(i) do |
|
364 | 459 |
begin |
429 | 460 |
dist:= Max(abs(x - pa.ar[k].x), abs(y - pa.ar[k].y)); |
365 | 461 |
radz[k]:= Max(0, Min((dist - cMinDist) div 2, radz[k])); |
462 |
radz[i]:= Max(0, Min(dist - radz[k] - cMinDist, radz[i])) |
|
463 |
end |
|
464 |
end; |
|
364 | 465 |
|
466 |
for i:= 0 to Pred(pa.Count) do |
|
467 |
with pa.ar[i] do |
|
1753 | 468 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
364 | 469 |
begin |
561 | 470 |
px:= x; |
471 |
py:= y; |
|
371 | 472 |
x:= x + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3; |
561 | 473 |
y:= y + LongInt(GetRandom(7) - 3) * (radz[i] * 5 div 7) div 3; |
474 |
if CheckSelfIntersect(pa, i) then |
|
475 |
begin |
|
476 |
x:= px; |
|
477 |
y:= py |
|
478 |
end; |
|
364 | 479 |
end |
67 | 480 |
end; |
481 |
||
364 | 482 |
|
23 | 483 |
procedure GenBlank(var Template: TEdgeTemplate); |
4 | 484 |
var pa: TPixAr; |
23 | 485 |
i: Longword; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
486 |
y, x: Longword; |
4 | 487 |
begin |
1760 | 488 |
for y:= 0 to LAND_HEIGHT - 1 do |
489 |
for x:= 0 to LAND_WIDTH - 1 do |
|
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
490 |
Land[y, x]:= COLOR_LAND; |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
491 |
|
358 | 492 |
SetPoints(Template, pa); |
429 | 493 |
for i:= 1 to Template.BezierizeCount do |
494 |
begin |
|
431 | 495 |
BezierizeEdge(pa, _0_5); |
561 | 496 |
RandomizePoints(pa); |
429 | 497 |
RandomizePoints(pa) |
498 |
end; |
|
499 |
for i:= 1 to Template.RandPassesCount do RandomizePoints(pa); |
|
365 | 500 |
BezierizeEdge(pa, _0_1); |
27 | 501 |
|
365 | 502 |
DrawEdge(pa, 0); |
27 | 503 |
|
358 | 504 |
with Template do |
23 | 505 |
for i:= 0 to pred(FillPointsCount) do |
506 |
with FillPoints^[i] do |
|
89 | 507 |
FillLand(x, y); |
508 |
||
1773 | 509 |
DrawEdge(pa, COLOR_LAND); |
510 |
||
1792 | 511 |
MaxHedgehogs:= Template.MaxHedgehogs; |
1776 | 512 |
hasGirders:= Template.hasGirders; |
513 |
playHeight:= Template.TemplateHeight; |
|
514 |
playWidth:= Template.TemplateWidth; |
|
515 |
leftX:= ((LAND_WIDTH - playWidth) div 2); |
|
516 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
|
517 |
topY:= LAND_HEIGHT - playHeight; |
|
518 |
||
1797 | 519 |
// force to only cavern even if a cavern map is invertable if cTemplateFilter = 4 ? |
1773 | 520 |
if (Template.canInvert and (getrandom(2) = 0)) or |
521 |
(not Template.canInvert and Template.isNegative) then |
|
1776 | 522 |
begin |
523 |
hasBorder:= true; |
|
1773 | 524 |
for y:= 0 to LAND_HEIGHT - 1 do |
525 |
for x:= 0 to LAND_WIDTH - 1 do |
|
1776 | 526 |
if (y < topY) or (x < leftX) or (x > rightX) then |
527 |
Land[y, x]:= 0 |
|
528 |
else |
|
529 |
begin |
|
530 |
if Land[y, x] = 0 then |
|
531 |
Land[y, x]:= COLOR_LAND |
|
532 |
else if Land[y, x] = COLOR_LAND then |
|
533 |
Land[y, x]:= 0; |
|
534 |
end; |
|
535 |
end; |
|
23 | 536 |
end; |
537 |
||
371 | 538 |
function SelectTemplate: LongInt; |
161 | 539 |
begin |
1797 | 540 |
case cTemplateFilter of |
541 |
0: begin |
|
542 |
SelectTemplate:= getrandom(Succ(High(EdgeTemplates))); |
|
543 |
end; |
|
544 |
1: begin |
|
545 |
SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))]; |
|
546 |
end; |
|
547 |
2: begin |
|
548 |
SelectTemplate:= MediumTemplates[getrandom(Succ(High(MediumTemplates)))]; |
|
549 |
end; |
|
550 |
3: begin |
|
551 |
SelectTemplate:= LargeTemplates[getrandom(Succ(High(LargeTemplates)))]; |
|
552 |
end; |
|
553 |
4: begin |
|
554 |
SelectTemplate:= CavernTemplates[getrandom(Succ(High(CavernTemplates)))]; |
|
555 |
end; |
|
556 |
5: begin |
|
557 |
SelectTemplate:= WackyTemplates[getrandom(Succ(High(WackyTemplates)))]; |
|
558 |
end; |
|
559 |
end; |
|
560 |
WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter)); |
|
161 | 561 |
end; |
562 |
||
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
563 |
procedure LandSurface2LandPixels(Surface: PSDL_Surface); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
564 |
var x, y: LongInt; |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
565 |
p: PLongwordArray; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
566 |
begin |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
567 |
TryDo(Surface <> nil, 'Assert (LandSurface <> nil) failed', true); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
568 |
|
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
569 |
if SDL_MustLock(Surface) then |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
570 |
SDLTry(SDL_LockSurface(Surface) >= 0, true); |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
571 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
572 |
p:= Surface^.pixels; |
1760 | 573 |
for y:= 0 to LAND_HEIGHT - 1 do |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
574 |
begin |
1760 | 575 |
for x:= 0 to LAND_WIDTH - 1 do |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
576 |
if Land[y, x] <> 0 then LandPixels[y, x]:= p^[x] or $FF000000; |
1760 | 577 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
578 |
p:= @(p^[Surface^.pitch div 4]); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
579 |
end; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
580 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
581 |
if SDL_MustLock(Surface) then |
1753 | 582 |
SDL_UnlockSurface(Surface); |
1754 | 583 |
end; |
584 |
||
585 |
procedure GenLandSurface; |
|
586 |
var tmpsurf: PSDL_Surface; |
|
587 |
begin |
|
588 |
WriteLnToConsole('Generating land...'); |
|
589 |
||
590 |
GenBlank(EdgeTemplates[SelectTemplate]); |
|
591 |
||
592 |
AddProgress; |
|
593 |
||
1760 | 594 |
tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, LAND_WIDTH, LAND_HEIGHT, 32, RMask, GMask, BMask, 0); |
1754 | 595 |
|
596 |
TryDo(tmpsurf <> nil, 'Error creating pre-land surface', true); |
|
597 |
ColorizeLand(tmpsurf); |
|
598 |
AddOnLandObjects(tmpsurf); |
|
599 |
||
600 |
LandSurface2LandPixels(tmpsurf); |
|
601 |
SDL_FreeSurface(tmpsurf); |
|
602 |
||
603 |
AddProgress; |
|
604 |
||
605 |
end; |
|
606 |
||
607 |
procedure MakeFortsMap; |
|
608 |
var tmpsurf: PSDL_Surface; |
|
609 |
begin |
|
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
|
610 |
// 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 | 611 |
playHeight:= 1200; |
2096 | 612 |
playWidth:= 2560; |
1776 | 613 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
614 |
rightX:= ((playWidth + (LAND_WIDTH - playWidth) div 2) - 1); |
|
615 |
topY:= LAND_HEIGHT - playHeight; |
|
616 |
||
1754 | 617 |
WriteLnToConsole('Generating forts land...'); |
618 |
||
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
|
619 |
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[0]^.Teams[0]^.FortName + 'L', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
1784 | 620 |
BlitImageAndGenerateCollisionInfo(leftX+150, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
1754 | 621 |
SDL_FreeSurface(tmpsurf); |
622 |
||
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
|
623 |
tmpsurf:= LoadImage(Pathz[ptForts] + '/' + ClansArray[1]^.Teams[0]^.FortName + 'R', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
1784 | 624 |
BlitImageAndGenerateCollisionInfo(rightX - 150 - tmpsurf^.w, LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
1754 | 625 |
SDL_FreeSurface(tmpsurf); |
626 |
end; |
|
627 |
||
1792 | 628 |
// Hi unC0Rr. |
629 |
// This is a function that Tiy assures me would not be good for gameplay. |
|
630 |
// It allows the setting of arbitrary portions of landscape as indestructible, or regular, or even blank. |
|
2154
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2152
diff
changeset
|
631 |
// He said I could add it here only when I swore it would not impact gameplay. Which, as far as I can tell, is true. |
3d2917be12c3
Change default output to stderr since /tmp doesn't exist under windows and is useless under iphoneos, add a couple of extra parameters
nemo
parents:
2152
diff
changeset
|
632 |
// I would just like to play with it with my friends if you do not mind. |
1792 | 633 |
// Can allow for amusing maps. |
634 |
procedure LoadMask; |
|
635 |
var tmpsurf: PSDL_Surface; |
|
636 |
p: PLongwordArray; |
|
637 |
x, y, cpX, cpY: Longword; |
|
638 |
begin |
|
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
|
639 |
tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/mask', ifAlpha or ifTransparent or ifIgnoreCaps); |
1792 | 640 |
if (tmpsurf <> nil) and (tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT) and (tmpsurf^.format^.BytesPerPixel = 4) then |
641 |
begin |
|
642 |
cpX:= (LAND_WIDTH - tmpsurf^.w) div 2; |
|
643 |
cpY:= LAND_HEIGHT - tmpsurf^.h; |
|
644 |
if SDL_MustLock(tmpsurf) then |
|
645 |
SDLTry(SDL_LockSurface(tmpsurf) >= 0, true); |
|
646 |
||
647 |
p:= tmpsurf^.pixels; |
|
648 |
for y:= 0 to Pred(tmpsurf^.h) do |
|
649 |
begin |
|
650 |
for x:= 0 to Pred(tmpsurf^.w) do |
|
1849 | 651 |
begin |
652 |
if (($FF000000 and p^[x]) = 0) then // Tiy was having trouble generating transparent black |
|
653 |
Land[cpY + y, cpX + x]:= 0 |
|
2243
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
654 |
else if p^[x] = $FF0000FF then |
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
655 |
Land[cpY + y, cpX + x]:= COLOR_INDESTRUCTIBLE |
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
656 |
else if p^[x] = $FFFFFFFF then |
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
657 |
Land[cpY + y, cpX + x]:= COLOR_LAND; |
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
658 |
|
1849 | 659 |
end; |
1792 | 660 |
p:= @(p^[tmpsurf^.pitch div 4]); |
661 |
end; |
|
662 |
||
663 |
if SDL_MustLock(tmpsurf) then |
|
664 |
SDL_UnlockSurface(tmpsurf); |
|
665 |
SDL_FreeSurface(tmpsurf); |
|
666 |
end; |
|
667 |
end; |
|
668 |
||
1754 | 669 |
procedure LoadMap; |
670 |
var tmpsurf: PSDL_Surface; |
|
1795 | 671 |
s: string; |
672 |
f: textfile; |
|
1754 | 673 |
begin |
674 |
WriteLnToConsole('Loading land from file...'); |
|
675 |
AddProgress; |
|
2171
8208946331ba
Smaxx refactor of LoadImage to use flags, iphone changes by koda (mostly use of rgba instead of rgb)
nemo
parents:
2163
diff
changeset
|
676 |
tmpsurf:= LoadImage(Pathz[ptMapCurrent] + '/map', ifAlpha or ifCritical or ifTransparent or ifIgnoreCaps); |
1760 | 677 |
TryDo((tmpsurf^.w <= LAND_WIDTH) and (tmpsurf^.h <= LAND_HEIGHT), 'Map dimensions too big!', true); |
1754 | 678 |
|
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
|
679 |
// unC0Rr - should this be passed from the GUI? I am not sure which layer does what |
1792 | 680 |
s:= Pathz[ptMapCurrent] + '/map.cfg'; |
681 |
WriteLnToConsole('Fetching map HH limit'); |
|
682 |
Assign(f, s); |
|
683 |
Reset(f); |
|
1795 | 684 |
Readln(f); |
685 |
if not eof(f) then Readln(f, MaxHedgehogs); |
|
686 |
||
1792 | 687 |
if(MaxHedgehogs = 0) then MaxHedgehogs:= 18; |
688 |
||
1776 | 689 |
playHeight:= tmpsurf^.h; |
690 |
playWidth:= tmpsurf^.w; |
|
691 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
|
692 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
|
693 |
topY:= LAND_HEIGHT - playHeight; |
|
694 |
||
1754 | 695 |
TryDo(tmpsurf^.format^.BytesPerPixel = 4, 'Map should be 32bit', true); |
696 |
||
1772 | 697 |
BlitImageAndGenerateCollisionInfo( |
698 |
(LAND_WIDTH - tmpsurf^.w) div 2, |
|
699 |
LAND_HEIGHT - tmpsurf^.h, |
|
700 |
tmpsurf^.w, |
|
701 |
tmpsurf); |
|
1754 | 702 |
SDL_FreeSurface(tmpsurf); |
1792 | 703 |
|
704 |
LoadMask; |
|
1754 | 705 |
end; |
706 |
||
707 |
procedure GenMap; |
|
1784 | 708 |
var x, y, w, c: Longword; |
1754 | 709 |
begin |
1776 | 710 |
hasBorder:= false; |
711 |
hasGirders:= true; |
|
1754 | 712 |
LoadThemeConfig; |
713 |
||
714 |
if (GameFlags and gfForts) = 0 then |
|
715 |
if Pathz[ptMapCurrent] <> '' then LoadMap |
|
716 |
else GenLandSurface |
|
717 |
else MakeFortsMap; |
|
718 |
AddProgress; |
|
1760 | 719 |
|
1754 | 720 |
{$IFDEF DEBUGFILE}LogLandDigest;{$ENDIF} |
1753 | 721 |
|
1768 | 722 |
// check for land near top |
1784 | 723 |
c:= 0; |
724 |
if (GameFlags and gfBorder) <> 0 then |
|
725 |
hasBorder:= true |
|
726 |
else |
|
727 |
for y:= topY to topY + 5 do |
|
728 |
for x:= leftX to rightX do |
|
729 |
if Land[y, x] <> 0 then |
|
730 |
begin |
|
731 |
inc(c); |
|
732 |
if c > 200 then // avoid accidental triggering |
|
733 |
begin |
|
734 |
hasBorder:= true; |
|
735 |
break; |
|
736 |
end; |
|
737 |
end; |
|
1768 | 738 |
|
1776 | 739 |
if hasBorder then |
1768 | 740 |
begin |
1784 | 741 |
for y:= 0 to LAND_HEIGHT - 1 do |
742 |
for x:= 0 to LAND_WIDTH - 1 do |
|
743 |
if (y < topY) or (x < leftX) or (x > rightX) then |
|
744 |
Land[y, x]:= COLOR_INDESTRUCTIBLE; |
|
1768 | 745 |
// experiment hardcoding cave |
1784 | 746 |
// also try basing cave dimensions on map/template dimensions, if they exist |
747 |
for w:= 0 to 5 do // width of 3 allowed worms to be knocked through with grenade |
|
748 |
begin |
|
749 |
for y:= topY to LAND_HEIGHT - 1 do |
|
750 |
begin |
|
751 |
Land[y, leftX + w]:= COLOR_INDESTRUCTIBLE; |
|
752 |
Land[y, rightX - w]:= COLOR_INDESTRUCTIBLE; |
|
753 |
if (y + w) mod 32 < 16 then |
|
754 |
c:= $FF000000 |
|
755 |
else |
|
756 |
c:= $FF00FFFF; |
|
757 |
LandPixels[y, leftX + w]:= c; |
|
758 |
LandPixels[y, rightX - w]:= c; |
|
759 |
end; |
|
1768 | 760 |
|
1784 | 761 |
for x:= leftX to rightX do |
762 |
begin |
|
763 |
Land[topY + w, x]:= COLOR_INDESTRUCTIBLE; |
|
764 |
if (x + w) mod 32 < 16 then |
|
765 |
c:= $FF000000 |
|
766 |
else |
|
767 |
c:= $FF00FFFF; |
|
768 |
LandPixels[topY + w, x]:= c; |
|
769 |
end; |
|
770 |
end; |
|
1768 | 771 |
end; |
772 |
||
1776 | 773 |
if ((GameFlags and gfForts) = 0) and (Pathz[ptMapCurrent] = '') then AddObjects; |
774 |
||
1807 | 775 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT); |
37 | 776 |
end; |
777 |
||
566 | 778 |
function GenPreview: TPreview; |
371 | 779 |
var x, y, xx, yy, t, bit: LongInt; |
566 | 780 |
Preview: TPreview; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
781 |
begin |
160 | 782 |
WriteLnToConsole('Generating preview...'); |
161 | 783 |
GenBlank(EdgeTemplates[SelectTemplate]); |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
784 |
|
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
785 |
for y:= 0 to 127 do |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
786 |
for x:= 0 to 31 do |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
787 |
begin |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
788 |
Preview[y, x]:= 0; |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
789 |
for bit:= 0 to 7 do |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
790 |
begin |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
791 |
t:= 0; |
1760 | 792 |
for yy:= y * (LAND_HEIGHT div 128) to y * (LAND_HEIGHT div 128) + 7 do |
793 |
for xx:= x * (LAND_WIDTH div 32) + bit * 8 to x * (LAND_WIDTH div 32) + bit * 8 + 7 do |
|
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
794 |
if Land[yy, xx] <> 0 then inc(t); |
351 | 795 |
if t > 8 then Preview[y, x]:= Preview[y, x] or ($80 shr bit) |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
796 |
end |
566 | 797 |
end; |
1768 | 798 |
GenPreview:= Preview |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
799 |
end; |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
800 |
|
51 | 801 |
initialization |
802 |
||
4 | 803 |
end. |