author | Wuzzy <Wuzzy2@mail.ru> |
Thu, 15 Mar 2018 15:49:17 +0100 | |
changeset 13224 | b229b3259a76 |
parent 12763 | 49c31d8cc740 |
child 13277 | 5984e8c6cbeb |
permissions | -rw-r--r-- |
4 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
11046 | 3 |
* Copyright (c) 2004-2015 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 |
|
10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright - but I ain't gonna touch their copyright headers
sheepluva
parents:
10040
diff
changeset
|
16 |
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 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 |
|
10249 | 23 |
uses SDLh, uLandTemplates, uConsts, uTypes, uAILandMarks; |
4 | 24 |
|
3038 | 25 |
procedure initModule; |
26 |
procedure freeModule; |
|
5717 | 27 |
procedure DrawBottomBorder; |
37 | 28 |
procedure GenMap; |
7079 | 29 |
procedure GenPreview(out Preview: TPreview); |
10162 | 30 |
procedure GenPreviewAlpha(out Preview: TPreviewAlpha); |
4 | 31 |
|
32 |
implementation |
|
11831
7654e2357934
implement ExtraftFileDir and ExtractFileName in uUtils
sheepluva
parents:
11751
diff
changeset
|
33 |
uses uConsole, uStore, uRandom, uLandObjects, uIO, uLandTexture, |
6626
a447993f2ad7
Further work on propagating types. Now it hopefully works fully, just need to annotate namespace with types first.
unc0rr
parents:
6580
diff
changeset
|
34 |
uVariables, uUtils, uCommands, adler32, uDebug, uLandPainted, uTextures, |
10249 | 35 |
uLandGenMaze, uPhysFSLayer, uScript, uLandGenPerlin, |
11654
1fd1525653d8
SDL blit wraps at 16,384 - not the first time that routine has disappointed us.
nemo
parents:
11544
diff
changeset
|
36 |
uLandGenTemplateBased, uLandUtils, uRenderUtils; |
365 | 37 |
|
7028 | 38 |
var digest: shortstring; |
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
39 |
maskOnly: boolean; |
4 | 40 |
|
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
41 |
|
10016
59a6d65fcb60
(experimental) make the mysterious borders around land/hats/etc that appear on zoom vanish
sheepluva
parents:
9998
diff
changeset
|
42 |
procedure PrettifyLandAlpha(); |
59a6d65fcb60
(experimental) make the mysterious borders around land/hats/etc that appear on zoom vanish
sheepluva
parents:
9998
diff
changeset
|
43 |
begin |
59a6d65fcb60
(experimental) make the mysterious borders around land/hats/etc that appear on zoom vanish
sheepluva
parents:
9998
diff
changeset
|
44 |
if (cReducedQuality and rqBlurryLand) <> 0 then |
10018
bdf75f0350bd
(experimental) merging the new procedures for different pixel representations (1D/2D arrays) into a single procedure with the algorithm and two procedures for the different mapping. - because redundant code sucks (at least twice)
sheepluva
parents:
10016
diff
changeset
|
45 |
PrettifyAlpha2D(LandPixels, LAND_HEIGHT div 2, LAND_WIDTH div 2) |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
46 |
else |
10018
bdf75f0350bd
(experimental) merging the new procedures for different pixel representations (1D/2D arrays) into a single procedure with the algorithm and two procedures for the different mapping. - because redundant code sucks (at least twice)
sheepluva
parents:
10016
diff
changeset
|
47 |
PrettifyAlpha2D(LandPixels, LAND_HEIGHT, LAND_WIDTH); |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
48 |
end; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
49 |
|
9387 | 50 |
procedure DrawBorderFromImage(Surface: PSDL_Surface); |
4 | 51 |
var tmpsurf: PSDL_Surface; |
11655 | 52 |
//r, rr: TSDL_Rect; |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
53 |
x, yd, yu: LongInt; |
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
54 |
targetMask: Word; |
4 | 55 |
begin |
12597 | 56 |
tmpsurf:= LoadDataImage(ptCurrTheme, 'Border', ifCritical or ifIgnoreCaps or ifColorKey); |
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
57 |
|
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
58 |
// if mask only, all land gets filled with landtex and therefore needs borders |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
59 |
if maskOnly then |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
60 |
targetMask:= lfLandMask |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
61 |
else |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
62 |
targetMask:= lfBasic; |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
63 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
64 |
for x:= 0 to LAND_WIDTH - 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
65 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
66 |
yd:= LAND_HEIGHT - 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
67 |
repeat |
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
68 |
while (yd > 0) and ((Land[yd, x] and targetMask) = 0) do dec(yd); |
2376 | 69 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
70 |
if (yd < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
71 |
yd:= 0; |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
72 |
|
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
73 |
while (yd < LAND_HEIGHT) and ((Land[yd, x] and targetMask) <> 0) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
74 |
inc(yd); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
75 |
dec(yd); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
76 |
yu:= yd; |
2376 | 77 |
|
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
78 |
while (yu > 0 ) and ((Land[yu, x] and targetMask) <> 0) do dec(yu); |
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
79 |
while (yu < yd ) and ((Land[yu, x] and targetMask) = 0) do inc(yu); |
2376 | 80 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
81 |
if (yd < LAND_HEIGHT - 1) and ((yd - yu) >= 16) then |
11655 | 82 |
copyToXYFromRect(tmpsurf, Surface, x mod tmpsurf^.w, 16, 1, 16, x, yd - 15); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
83 |
if (yu > 0) then |
11655 | 84 |
copyToXYFromRect(tmpsurf, Surface, x mod tmpsurf^.w, 0, 1, Min(16, yd - yu + 1), x, yu); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
85 |
yd:= yu - 1; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
86 |
until yd < 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
87 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
88 |
SDL_FreeSurface(tmpsurf); |
4 | 89 |
end; |
90 |
||
9387 | 91 |
|
92 |
procedure DrawShoppaBorder; |
|
93 |
var x, y, s, i: Longword; |
|
94 |
c1, c2, c: Longword; |
|
95 |
begin |
|
96 |
c1:= AMask; |
|
97 |
c2:= AMask or RMask or GMask; |
|
98 |
||
99 |
// vertical |
|
100 |
s:= LAND_HEIGHT; |
|
10017 | 101 |
|
9387 | 102 |
for x:= 0 to LAND_WIDTH - 1 do |
103 |
for y:= 0 to LAND_HEIGHT - 1 do |
|
9864 | 104 |
if Land[y, x] = 0 then |
9387 | 105 |
if s < y then |
106 |
begin |
|
107 |
for i:= max(s, y - 8) to y - 1 do |
|
108 |
begin |
|
109 |
if ((x + i) and 16) = 0 then c:= c1 else c:= c2; |
|
10017 | 110 |
|
9387 | 111 |
if (cReducedQuality and rqBlurryLand) = 0 then |
112 |
LandPixels[i, x]:= c |
|
113 |
else |
|
114 |
LandPixels[i div 2, x div 2]:= c |
|
115 |
end; |
|
116 |
s:= LAND_HEIGHT |
|
117 |
end |
|
118 |
else |
|
119 |
else |
|
120 |
begin |
|
121 |
if s > y then s:= y; |
|
122 |
if s + 8 > y then |
|
123 |
begin |
|
124 |
if ((x + y) and 16) = 0 then c:= c1 else c:= c2; |
|
10017 | 125 |
|
9387 | 126 |
if (cReducedQuality and rqBlurryLand) = 0 then |
127 |
LandPixels[y, x]:= c |
|
128 |
else |
|
129 |
LandPixels[y div 2, x div 2]:= c |
|
10017 | 130 |
end; |
9387 | 131 |
end; |
10017 | 132 |
|
9387 | 133 |
// horizontal |
134 |
s:= LAND_WIDTH; |
|
10017 | 135 |
|
9387 | 136 |
for y:= 0 to LAND_HEIGHT - 1 do |
137 |
for x:= 0 to LAND_WIDTH - 1 do |
|
9864 | 138 |
if Land[y, x] = 0 then |
9387 | 139 |
if s < x then |
140 |
begin |
|
141 |
for i:= max(s, x - 8) to x - 1 do |
|
142 |
begin |
|
143 |
if ((y + i) and 16) = 0 then c:= c1 else c:= c2; |
|
10017 | 144 |
|
9387 | 145 |
if (cReducedQuality and rqBlurryLand) = 0 then |
146 |
LandPixels[y, i]:= c |
|
147 |
else |
|
148 |
LandPixels[y div 2, i div 2]:= c |
|
149 |
end; |
|
150 |
s:= LAND_WIDTH |
|
151 |
end |
|
152 |
else |
|
153 |
else |
|
154 |
begin |
|
155 |
if s > x then s:= x; |
|
156 |
if s + 8 > x then |
|
157 |
begin |
|
158 |
if ((x + y) and 16) = 0 then c:= c1 else c:= c2; |
|
10017 | 159 |
|
9387 | 160 |
if (cReducedQuality and rqBlurryLand) = 0 then |
161 |
LandPixels[y, x]:= c |
|
162 |
else |
|
163 |
LandPixels[y div 2, x div 2]:= c |
|
10017 | 164 |
end; |
9387 | 165 |
end |
166 |
end; |
|
167 |
||
12109 | 168 |
procedure ColorizeLandFast(mapsurf: PSDL_Surface); |
169 |
var ltexsurf: PSDL_Surface; |
|
170 |
i: LongInt; |
|
171 |
ltlnp, srcp, dstp, stopp: Pointer; |
|
172 |
c: SizeInt; |
|
12105 | 173 |
begin |
12109 | 174 |
ltexsurf:= LoadDataImage(ptCurrTheme, 'LandTex', ifCritical or ifIgnoreCaps); |
12105 | 175 |
|
12109 | 176 |
// pointer to current line of ltexsurf pixels. will be moved from line to line |
177 |
ltlnp:= ltexsurf^.pixels; |
|
178 |
// pointer to mapsurf pixels. will jump forward after every move() |
|
179 |
dstp:= mapsurf^.pixels; |
|
180 |
||
181 |
// time to get serious |
|
182 |
SDL_LockSurface(mapsurf); |
|
183 |
SDL_LockSurface(ltexsurf); |
|
184 |
||
185 |
// for now only fill a row with the height of landtex. do vertical copies within mapsurf after |
|
12105 | 186 |
|
12109 | 187 |
// do this loop for each line of ltexsurf (unless we run out of map height first) |
188 |
for i:= 1 to min(ltexsurf^.h, mapsurf^.h) do |
|
189 |
begin |
|
190 |
// amount of pixels to write in first move() |
|
191 |
c:= ltexsurf^.pitch; |
|
12105 | 192 |
|
12109 | 193 |
// protect from odd cases where landtex wider than map |
194 |
if c > mapsurf^.pitch then |
|
195 |
c:= mapsurf^.pitch; |
|
196 |
||
197 |
// write line of landtex to mapsurf |
|
198 |
move(ltlnp^, dstp^, c); |
|
12105 | 199 |
|
12109 | 200 |
// fill the rest of the line by copying left-to-right until full |
201 |
||
202 |
// new src is start of line that we've just written to |
|
203 |
srcp:= dstp; |
|
204 |
// set stop pointer to start of next pixel line of mapsurf |
|
205 |
stopp:= dstp + mapsurf^.pitch; |
|
206 |
// move dst pointer to after what we've just written |
|
207 |
inc(dstp, c); |
|
208 |
||
209 |
// loop until dstp went past end of line |
|
210 |
while dstp < stopp do |
|
12105 | 211 |
begin |
12109 | 212 |
// copy all from left of dstp to right of it (or just fill the gap if smaller) |
213 |
c:= min(dstp-srcp, stopp-dstp); |
|
12105 | 214 |
move(srcp^, dstp^, c); |
215 |
inc(dstp, c); |
|
216 |
end; |
|
217 |
||
12109 | 218 |
// move to next line in ltexsurf |
219 |
inc(ltlnp, ltexsurf^.pitch); |
|
12105 | 220 |
end; |
221 |
||
12109 | 222 |
// we don't need ltexsurf itself anymore -> cleanup |
223 |
ltlnp:= nil; |
|
224 |
SDL_UnlockSurface(ltexsurf); |
|
225 |
SDL_FreeSurface(ltexsurf); |
|
226 |
ltexsurf:= nil; |
|
12105 | 227 |
|
12109 | 228 |
// from now on only copy pixels within mapsurf |
12105 | 229 |
|
230 |
// copy all the already written lines at once for that get number of written bytes so far |
|
12109 | 231 |
// already written pixels are between start and current dstp |
232 |
srcp:= mapsurf^.pixels; |
|
12105 | 233 |
|
12109 | 234 |
// first byte after end of pixels |
235 |
stopp:= srcp + (mapsurf^.pitch * mapsurf^.h); |
|
12105 | 236 |
|
12109 | 237 |
while dstp < stopp do |
12105 | 238 |
begin |
12109 | 239 |
// copy all from before dstp to after (or just fill the gap if smaller) |
240 |
c:= min(dstp-srcp, stopp-dstp); |
|
241 |
// worried about size of c with humongous maps? don't be: |
|
242 |
// the OS wouldn't have allowed allocation of object with size > max of SizeInt anyway |
|
12105 | 243 |
move(srcp^, dstp^, c); |
244 |
inc(dstp, c); |
|
245 |
end; |
|
246 |
||
12109 | 247 |
// cleanup |
248 |
srcp:= nil; |
|
249 |
dstp:= nil; |
|
250 |
stopp:= nil; |
|
251 |
SDL_UnlockSurface(mapsurf); |
|
12105 | 252 |
|
253 |
// freed in freeModule() below |
|
12597 | 254 |
LandBackSurface:= LoadDataImage(ptCurrTheme, 'LandBackTex', ifIgnoreCaps or ifColorKey); |
12105 | 255 |
if (LandBackSurface <> nil) and GrayScale then Surface2GrayScale(LandBackSurface); |
256 |
end; |
|
257 |
||
9387 | 258 |
procedure ColorizeLand(Surface: PSDL_Surface); |
259 |
var tmpsurf: PSDL_Surface; |
|
260 |
r: TSDL_Rect; |
|
10197 | 261 |
y: LongInt; // stupid SDL 1.2 uses stupid SmallInt for y which limits us to 32767. But is even worse if LandTex is large, can overflow on 32767 map. |
9387 | 262 |
begin |
263 |
tmpsurf:= LoadDataImage(ptCurrTheme, 'LandTex', ifCritical or ifIgnoreCaps); |
|
264 |
r.y:= 0; |
|
9892
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
265 |
y:= 0; |
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
266 |
while y < LAND_HEIGHT do |
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
267 |
begin |
9387 | 268 |
r.x:= 0; |
269 |
while r.x < LAND_WIDTH do |
|
9892
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
270 |
begin |
11654
1fd1525653d8
SDL blit wraps at 16,384 - not the first time that routine has disappointed us.
nemo
parents:
11544
diff
changeset
|
271 |
copyToXY(tmpsurf, Surface, r.x, r.y); |
1fd1525653d8
SDL blit wraps at 16,384 - not the first time that routine has disappointed us.
nemo
parents:
11544
diff
changeset
|
272 |
//SDL_UpperBlit(tmpsurf, nil, Surface, @r); |
9387 | 273 |
inc(r.x, tmpsurf^.w) |
9892
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
274 |
end; |
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
275 |
inc(y, tmpsurf^.h); |
5a0a7ef7af2d
allow SDL 1.2 to at least do a 32767 map. We probably should add a TryDo somewhere to assert that limit on SDL 1.2 to avoid overflows. Ditto int version for SDL 2
nemo
parents:
9864
diff
changeset
|
276 |
r.y:= y |
9387 | 277 |
end; |
278 |
SDL_FreeSurface(tmpsurf); |
|
279 |
||
280 |
// freed in freeModule() below |
|
12597 | 281 |
LandBackSurface:= LoadDataImage(ptCurrTheme, 'LandBackTex', ifIgnoreCaps or ifColorKey); |
9387 | 282 |
if (LandBackSurface <> nil) and GrayScale then Surface2GrayScale(LandBackSurface); |
283 |
end; |
|
284 |
||
23 | 285 |
|
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
286 |
procedure GenDrawnMap; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
287 |
begin |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
288 |
ResizeLand(4096, 2048); |
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
289 |
uLandPainted.Draw; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
290 |
|
4559 | 291 |
MaxHedgehogs:= 48; |
4494
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
292 |
hasGirders:= true; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
293 |
playHeight:= 2048; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
294 |
playWidth:= 4096; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
295 |
leftX:= ((LAND_WIDTH - playWidth) div 2); |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
296 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
297 |
topY:= LAND_HEIGHT - playHeight; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
298 |
end; |
9585435e20f7
Pass hardcoded drawn map from frontend into engine \o/
unc0rr
parents:
4458
diff
changeset
|
299 |
|
371 | 300 |
function SelectTemplate: LongInt; |
9243
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
301 |
var l: LongInt; |
161 | 302 |
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
|
303 |
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
|
304 |
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
|
305 |
else |
9243
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
306 |
begin |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
307 |
if cTemplateFilter = 0 then |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
308 |
begin |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
309 |
l:= getRandom(GroupedTemplatesCount); |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
310 |
repeat |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
311 |
inc(cTemplateFilter); |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
312 |
dec(l, TemplateCounts[cTemplateFilter]); |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
313 |
until l < 0; |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
314 |
end else getRandom(1); |
10017 | 315 |
|
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
|
316 |
case cTemplateFilter of |
9243
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
317 |
0: OutError('Ask unC0Rr about what you did wrong', true); |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
318 |
1: SelectTemplate:= SmallTemplates[getrandom(TemplateCounts[cTemplateFilter])]; |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
319 |
2: SelectTemplate:= MediumTemplates[getrandom(TemplateCounts[cTemplateFilter])]; |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
320 |
3: SelectTemplate:= LargeTemplates[getrandom(TemplateCounts[cTemplateFilter])]; |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
321 |
4: SelectTemplate:= CavernTemplates[getrandom(TemplateCounts[cTemplateFilter])]; |
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
322 |
5: SelectTemplate:= WackyTemplates[getrandom(TemplateCounts[cTemplateFilter])]; |
7567 | 323 |
// For lua only! |
7575
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7571
diff
changeset
|
324 |
6: begin |
7594 | 325 |
SelectTemplate:= min(LuaTemplateNumber,High(EdgeTemplates)); |
7575
f415b3e0f3b9
Burn a random number in the override. Make sure cirbuf is reset.
nemo
parents:
7571
diff
changeset
|
326 |
GetRandom(2) // burn 1 |
10142 | 327 |
end |
9243
d8f6a396d98e
First select group of templates, then pick template from selected group
unc0rr
parents:
9080
diff
changeset
|
328 |
end |
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
|
329 |
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
|
330 |
|
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
|
331 |
WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter)); |
161 | 332 |
end; |
333 |
||
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
334 |
procedure LandSurface2LandPixels(Surface: PSDL_Surface); |
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
335 |
var x, y: LongInt; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
336 |
p: PLongwordArray; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
337 |
begin |
11537 | 338 |
if checkFails(Surface <> nil, 'Assert (LandSurface <> nil) failed', true) then exit; |
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
339 |
|
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
340 |
if SDL_MustLock(Surface) then |
11512 | 341 |
if SDLCheck(SDL_LockSurface(Surface) >= 0, 'SDL_LockSurface', true) then exit; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
342 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
343 |
p:= Surface^.pixels; |
1760 | 344 |
for y:= 0 to LAND_HEIGHT - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
345 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
346 |
for x:= 0 to LAND_WIDTH - 1 do |
3598 | 347 |
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
|
348 |
if (cReducedQuality and rqBlurryLand) = 0 then |
11478
023db094b22d
Some themers expressed desire to have translucent themes. While the current AA stuff in uLandGraphics won't really allow this to work with LandBackTex properly, seems to me it should be safe to allow alpha for LandTex. Our LandTex should all have alpha of 255 on the existing themes.
nemo
parents:
11342
diff
changeset
|
349 |
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
|
350 |
else |
11478
023db094b22d
Some themers expressed desire to have translucent themes. While the current AA stuff in uLandGraphics won't really allow this to work with LandBackTex properly, seems to me it should be safe to allow alpha for LandTex. Our LandTex should all have alpha of 255 on the existing themes.
nemo
parents:
11342
diff
changeset
|
351 |
LandPixels[y div 2, x div 2]:= p^[x];// or AMask; |
2376 | 352 |
|
10131
4b4a043111f4
- pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10108
diff
changeset
|
353 |
p:= PLongwordArray(@(p^[Surface^.pitch div 4])); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
354 |
end; |
1180
e56317fdf78d
Start implementing support for 32bit sprites concerned in map generation process.
unc0rr
parents:
1085
diff
changeset
|
355 |
|
1182
e2e13aa055c1
Step 3: Maps are rendered correctly, but without objects yet
unc0rr
parents:
1181
diff
changeset
|
356 |
if SDL_MustLock(Surface) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
357 |
SDL_UnlockSurface(Surface); |
1754 | 358 |
end; |
359 |
||
3133 | 360 |
|
1754 | 361 |
procedure GenLandSurface; |
362 |
var tmpsurf: PSDL_Surface; |
|
5225 | 363 |
x,y: Longword; |
1754 | 364 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
365 |
AddProgress(); |
1754 | 366 |
|
11478
023db094b22d
Some themers expressed desire to have translucent themes. While the current AA stuff in uLandGraphics won't really allow this to work with LandBackTex properly, seems to me it should be safe to allow alpha for LandTex. Our LandTex should all have alpha of 255 on the existing themes.
nemo
parents:
11342
diff
changeset
|
367 |
tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, LAND_WIDTH, LAND_HEIGHT, 32, RMask, GMask, BMask, AMask); |
1754 | 368 |
|
11537 | 369 |
if checkFails(tmpsurf <> nil, 'Error creating pre-land surface', true) then exit; |
12105 | 370 |
ColorizeLandFast(tmpsurf); |
9387 | 371 |
if gameFlags and gfShoppaBorder = 0 then DrawBorderFromImage(tmpsurf); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
372 |
AddOnLandObjects(tmpsurf); |
1754 | 373 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
374 |
LandSurface2LandPixels(tmpsurf); |
5227 | 375 |
SDL_FreeSurface(tmpsurf); |
10017 | 376 |
|
9387 | 377 |
if gameFlags and gfShoppaBorder <> 0 then DrawShoppaBorder; |
10017 | 378 |
|
5274 | 379 |
for x:= leftX+2 to rightX-2 do |
380 |
for y:= topY+2 to LAND_HEIGHT-3 do |
|
10017 | 381 |
if (Land[y, x] = 0) and |
5274 | 382 |
(((Land[y, x-1] = lfBasic) and ((Land[y+1,x] = lfBasic)) or (Land[y-1,x] = lfBasic)) or |
383 |
((Land[y, x+1] = lfBasic) and ((Land[y-1,x] = lfBasic) or (Land[y+1,x] = lfBasic)))) then |
|
384 |
begin |
|
385 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
386 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
387 |
if (Land[y, x-1] = lfBasic) and (LandPixels[y, x-1] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
388 |
LandPixels[y, x]:= LandPixels[y, x-1] |
10017 | 389 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
390 |
else if (Land[y, x+1] = lfBasic) and (LandPixels[y, x+1] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
391 |
LandPixels[y, x]:= LandPixels[y, x+1] |
10017 | 392 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
393 |
else if (Land[y-1, x] = lfBasic) and (LandPixels[y-1, x] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
394 |
LandPixels[y, x]:= LandPixels[y-1, x] |
10017 | 395 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
396 |
else if (Land[y+1, x] = lfBasic) and (LandPixels[y+1, x] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
397 |
LandPixels[y, x]:= LandPixels[y+1, x]; |
10017 | 398 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
399 |
if (((LandPixels[y,x] and AMask) shr AShift) > 10) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
400 |
LandPixels[y,x]:= (LandPixels[y,x] and (not AMask)) or (128 shl AShift) |
5274 | 401 |
end; |
402 |
Land[y,x]:= lfObject |
|
403 |
end |
|
404 |
else if (Land[y, x] = 0) and |
|
405 |
(((Land[y, x-1] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y+2,x] = lfBasic)) or |
|
406 |
((Land[y, x-1] = lfBasic) and (Land[y-1,x-1] = lfBasic) and (Land[y-2,x] = lfBasic)) or |
|
407 |
((Land[y, x+1] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y+2,x] = lfBasic)) or |
|
408 |
((Land[y, x+1] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y-2,x] = lfBasic)) or |
|
409 |
((Land[y+1, x] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or |
|
410 |
((Land[y-1, x] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or |
|
411 |
((Land[y+1, x] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y,x-2] = lfBasic)) or |
|
412 |
((Land[y-1, x] = lfBasic) and (Land[y-1,x-1] = lfBasic) and (Land[y,x-2] = lfBasic))) then |
|
10017 | 413 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
414 |
begin |
10017 | 415 |
|
5274 | 416 |
if (cReducedQuality and rqBlurryLand) = 0 then |
10017 | 417 |
|
5274 | 418 |
begin |
10017 | 419 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
420 |
if (Land[y, x-1] = lfBasic) and (LandPixels[y,x-1] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
421 |
LandPixels[y, x]:= LandPixels[y, x-1] |
10017 | 422 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
423 |
else if (Land[y, x+1] = lfBasic) and (LandPixels[y,x+1] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
424 |
LandPixels[y, x]:= LandPixels[y, x+1] |
10017 | 425 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
426 |
else if (Land[y+1, x] = lfBasic) and (LandPixels[y+1,x] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
427 |
LandPixels[y, x]:= LandPixels[y+1, x] |
10017 | 428 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
429 |
else if (Land[y-1, x] = lfBasic) and (LandPixels[y-1,x] and AMask <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
430 |
LandPixels[y, x]:= LandPixels[y-1, x]; |
10017 | 431 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
432 |
if (((LandPixels[y,x] and AMask) shr AShift) > 10) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
433 |
LandPixels[y,x]:= (LandPixels[y,x] and (not AMask)) or (64 shl AShift) |
5274 | 434 |
end; |
435 |
Land[y,x]:= lfObject |
|
436 |
end; |
|
5441
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
437 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
438 |
AddProgress(); |
1754 | 439 |
end; |
440 |
||
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
441 |
procedure MakeFortsPreview; |
11750 | 442 |
var gap: LongInt; |
443 |
h1, h2, w1, w2, x, y, lastX, wbm, bmref: LongWord; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
444 |
const fortHeight = 960; |
11750 | 445 |
fortWidth = 704; |
446 |
bmHeight = 53; |
|
447 |
bmWidth = 64; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
448 |
begin |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
449 |
ResizeLand(4096,2048); |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
450 |
|
11750 | 451 |
lastX:= LAND_WIDTH-1; |
452 |
||
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
453 |
gap:= (1024 - fortWidth) + 60 + 20 * cFeatureSize; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
454 |
|
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
455 |
h2:= LAND_HEIGHT-1; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
456 |
h1:= h2 - fortHeight; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
457 |
w2:= (LAND_WIDTH - gap) div 2; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
458 |
w1:= w2 - fortWidth; |
11750 | 459 |
wbm:= h1 + bmHeight; |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
460 |
|
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
461 |
// generate 2 forts in center |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
462 |
for y:= h1 to h2 do |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
463 |
for x:= w1 to w2 do |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
464 |
begin |
11751 | 465 |
if x mod 4 <> 0 then |
466 |
begin |
|
467 |
if (y <= wbm) and ((x - w1) mod (bmWidth * 2) >= bmWidth) then |
|
468 |
continue; |
|
469 |
Land[y,x]:= lfBasic; |
|
470 |
Land[y,lastX-x]:= lfBasic; |
|
471 |
end; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
472 |
end; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
473 |
|
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
474 |
w2:= w1 - gap; |
11750 | 475 |
w1:= max(0, w2 - fortWidth); |
476 |
wbm:= h1 + bmHeight; |
|
477 |
bmref:= w2 + bmWidth; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
478 |
|
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
479 |
for y:= h1 to h2 do |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
480 |
for x:= w1 to w2 do |
11750 | 481 |
begin |
11751 | 482 |
if ((y - x) mod 2) = 0 then |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
483 |
begin |
11750 | 484 |
// align battlement on inner edge, because real outer edge could be offscreen |
485 |
if (y <= wbm) and ((LAND_WIDTH + x - bmref) mod (bmWidth * 2) >= bmWidth) then |
|
486 |
continue; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
487 |
Land[y,x]:= lfBasic; |
11750 | 488 |
Land[y,lastX-x]:= lfBasic; |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
489 |
end; |
11750 | 490 |
end; |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
491 |
end; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
492 |
|
1754 | 493 |
procedure MakeFortsMap; |
494 |
var tmpsurf: PSDL_Surface; |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
495 |
sectionWidth, i, t, p: integer; |
11710 | 496 |
mirror: boolean; |
11739 | 497 |
pc: PClan; |
1754 | 498 |
begin |
11739 | 499 |
|
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
500 |
// make the gaps between forts adjustable if fort map was selected |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
501 |
if cMapGen = mgForts then |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
502 |
sectionWidth:= 1024 + 60 + 20 * cFeatureSize |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
503 |
else |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
504 |
sectionWidth:= 1024 * 300; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
505 |
|
11739 | 506 |
// mix up spawn/fort order of clans |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
507 |
for i:= 0 to ClansCount - 1 do |
11739 | 508 |
begin |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
509 |
t:= GetRandom(ClansCount); |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
510 |
p:= GetRandom(ClansCount); |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
511 |
if t <> p then |
11739 | 512 |
begin |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
513 |
pc:= SpawnClansArray[t]; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
514 |
SpawnClansArray[t]:= SpawnClansArray[p]; |
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
515 |
SpawnClansArray[p]:= pc; |
11739 | 516 |
end; |
517 |
end; |
|
518 |
||
11710 | 519 |
// figure out how much space we need |
520 |
playWidth:= sectionWidth * ClansCount; |
|
521 |
||
522 |
// note: LAND_WIDTH might be bigger than specified below (rounded to next power of 2) |
|
523 |
ResizeLand(playWidth, 2048); |
|
524 |
||
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
|
525 |
// 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 | 526 |
playHeight:= 1200; |
11710 | 527 |
|
528 |
// center playable area in land array |
|
529 |
leftX:= ((LAND_WIDTH - playWidth) div 2); |
|
1776 | 530 |
rightX:= ((playWidth + (LAND_WIDTH - playWidth) div 2) - 1); |
531 |
topY:= LAND_HEIGHT - playHeight; |
|
532 |
||
1754 | 533 |
WriteLnToConsole('Generating forts land...'); |
534 |
||
11710 | 535 |
for i := 0 to ClansCount - 1 do |
536 |
begin |
|
537 |
||
538 |
// face in random direction |
|
539 |
mirror:= (GetRandom(2) = 0); |
|
540 |
// make first/last fort face inwards |
|
11712
ecbf5e6c2c37
also make forts face inwards in wrap mode, if there are only 2 teams
sheepluva
parents:
11711
diff
changeset
|
541 |
if (WorldEdge <> weWrap) or (ClansCount = 2) then |
11711 | 542 |
mirror:= (i <> 0) and (mirror or (i = ClansCount - 1)); |
1754 | 543 |
|
11710 | 544 |
if mirror then |
545 |
begin |
|
546 |
// not critical because if no R we can fallback to mirrored L |
|
12597 | 547 |
tmpsurf:= LoadDataImage(ptForts, SpawnClansArray[i]^.Teams[0]^.FortName + 'R', ifAlpha or ifColorKey or ifIgnoreCaps); |
11710 | 548 |
// fallback |
549 |
if tmpsurf = nil then |
|
550 |
begin |
|
12597 | 551 |
tmpsurf:= LoadDataImage(ptForts, SpawnClansArray[i]^.Teams[0]^.FortName + 'L', ifAlpha or ifCritical or ifColorKey or ifIgnoreCaps); |
11710 | 552 |
BlitImageAndGenerateCollisionInfo(leftX + sectionWidth * i + ((sectionWidth - tmpsurf^.w) div 2), LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf, 0, true); |
553 |
end |
|
554 |
else |
|
555 |
BlitImageAndGenerateCollisionInfo(leftX + sectionWidth * i + ((sectionWidth - tmpsurf^.w) div 2), LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
|
556 |
SDL_FreeSurface(tmpsurf); |
|
557 |
end |
|
558 |
else |
|
559 |
begin |
|
12597 | 560 |
tmpsurf:= LoadDataImage(ptForts, SpawnClansArray[i]^.Teams[0]^.FortName + 'L', ifAlpha or ifCritical or ifColorKey or ifIgnoreCaps); |
11710 | 561 |
BlitImageAndGenerateCollisionInfo(leftX + sectionWidth * i + ((sectionWidth - tmpsurf^.w) div 2), LAND_HEIGHT - tmpsurf^.h, tmpsurf^.w, tmpsurf); |
562 |
SDL_FreeSurface(tmpsurf); |
|
563 |
end; |
|
564 |
||
565 |
end; |
|
1754 | 566 |
end; |
567 |
||
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
568 |
procedure LoadMapConfig; |
8060 | 569 |
var f: PFSFile; |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
570 |
s: shortstring; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
571 |
begin |
8025 | 572 |
s:= cPathz[ptMapCurrent] + '/map.cfg'; |
573 |
||
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
574 |
WriteLnToConsole('Fetching map HH limit'); |
8060 | 575 |
|
576 |
f:= pfsOpenRead(s); |
|
577 |
if f <> nil then |
|
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
578 |
begin |
8060 | 579 |
pfsReadLn(f, s); |
580 |
if not pfsEof(f) then |
|
581 |
begin |
|
582 |
pfsReadLn(f, s); |
|
583 |
val(s, MaxHedgehogs) |
|
584 |
end; |
|
585 |
||
586 |
pfsClose(f) |
|
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
587 |
end; |
8060 | 588 |
|
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
589 |
if (MaxHedgehogs = 0) then |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
590 |
MaxHedgehogs:= 18; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
591 |
end; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
592 |
|
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
|
593 |
// Loads Land[] from an image, allowing overriding standard collision |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
594 |
procedure LoadMask; |
1792 | 595 |
var tmpsurf: PSDL_Surface; |
596 |
p: PLongwordArray; |
|
597 |
x, y, cpX, cpY: Longword; |
|
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
598 |
mapName: shortstring; |
1792 | 599 |
begin |
12597 | 600 |
tmpsurf:= LoadDataImage(ptMapCurrent, 'mask', ifAlpha or ifColorKey or ifIgnoreCaps); |
5770 | 601 |
if tmpsurf = nil then |
602 |
begin |
|
8025 | 603 |
mapName:= ExtractFileName(cPathz[ptMapCurrent]); |
12597 | 604 |
tmpsurf:= LoadDataImage(ptMissionMaps, mapName + '/mask', ifAlpha or ifColorKey or ifIgnoreCaps); |
5770 | 605 |
end; |
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
606 |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
607 |
|
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
608 |
if (tmpsurf <> nil) and (tmpsurf^.format^.BytesPerPixel = 4) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
609 |
begin |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
610 |
if LAND_WIDTH = 0 then |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
611 |
begin |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
612 |
LoadMapConfig; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
613 |
ResizeLand(tmpsurf^.w, tmpsurf^.h); |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
614 |
playHeight:= tmpsurf^.h; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
615 |
playWidth:= tmpsurf^.w; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
616 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
617 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
618 |
topY:= LAND_HEIGHT - playHeight; |
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
619 |
end; |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
620 |
disableLandBack:= true; |
2376 | 621 |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
622 |
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
|
623 |
cpY:= LAND_HEIGHT - tmpsurf^.h; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
624 |
if SDL_MustLock(tmpsurf) then |
11512 | 625 |
SDLCheck(SDL_LockSurface(tmpsurf) >= 0, 'SDL_LockSurface', true); |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
626 |
|
11512 | 627 |
if allOK then |
628 |
begin |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
629 |
p:= tmpsurf^.pixels; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
630 |
for y:= 0 to Pred(tmpsurf^.h) do |
8848
e9ebd63f8a03
So. Some themes have objects that seem to be large natural extensions of the landscape. Masks allow maintaining that. Lemme know if it doesn't look good. If it doesn't, can still use for ice/bounce/indestructible. Indestructible bunker object for example.
nemo
parents:
8370
diff
changeset
|
631 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
632 |
for x:= 0 to Pred(tmpsurf^.w) do |
8848
e9ebd63f8a03
So. Some themes have objects that seem to be large natural extensions of the landscape. Masks allow maintaining that. Lemme know if it doesn't look good. If it doesn't, can still use for ice/bounce/indestructible. Indestructible bunker object for example.
nemo
parents:
8370
diff
changeset
|
633 |
SetLand(Land[cpY + y, cpX + x], p^[x]); |
10131
4b4a043111f4
- pas2c recognizes typecasts in initialization expressions
unc0rr
parents:
10108
diff
changeset
|
634 |
p:= PLongwordArray(@(p^[tmpsurf^.pitch div 4])); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
635 |
end; |
2243
b4764993f833
additional touch support and nemo's reduced land array size
koda
parents:
2240
diff
changeset
|
636 |
|
11512 | 637 |
if SDL_MustLock(tmpsurf) then |
638 |
SDL_UnlockSurface(tmpsurf); |
|
639 |
if not disableLandBack then |
|
640 |
begin |
|
641 |
// freed in freeModule() below |
|
12597 | 642 |
LandBackSurface:= LoadDataImage(ptCurrTheme, 'LandBackTex', ifIgnoreCaps or ifColorKey); |
11512 | 643 |
if (LandBackSurface <> nil) and GrayScale then |
644 |
Surface2GrayScale(LandBackSurface) |
|
645 |
end; |
|
646 |
end; |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
647 |
end; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
648 |
if (tmpsurf <> nil) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
649 |
SDL_FreeSurface(tmpsurf); |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6082
diff
changeset
|
650 |
tmpsurf:= nil; |
1792 | 651 |
end; |
652 |
||
1754 | 653 |
procedure LoadMap; |
654 |
var tmpsurf: PSDL_Surface; |
|
3920
a54ca6185307
updated lua loading in the ifrontend and also fixed masked maps
koda
parents:
3912
diff
changeset
|
655 |
mapName: shortstring = ''; |
1754 | 656 |
begin |
657 |
WriteLnToConsole('Loading land from file...'); |
|
658 |
AddProgress; |
|
12597 | 659 |
tmpsurf:= LoadDataImage(ptMapCurrent, 'map', ifAlpha or ifColorKey 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
|
660 |
if tmpsurf = nil then |
5770 | 661 |
begin |
8025 | 662 |
mapName:= ExtractFileName(cPathz[ptMapCurrent]); |
12597 | 663 |
tmpsurf:= LoadDataImage(ptMissionMaps, mapName + '/map', ifAlpha or ifCritical or ifColorKey or ifIgnoreCaps); |
11537 | 664 |
if not allOK then exit; |
5770 | 665 |
end; |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
666 |
// (bare) Sanity check. Considering possible LongInt comparisons as well as just how much system memoery it would take |
11537 | 667 |
if checkFails((tmpsurf^.w < $40000000) and (tmpsurf^.h < $40000000) and (QWord(tmpsurf^.w) * tmpsurf^.h < 6*1024*1024*1024), 'Map dimensions too big!', true) |
668 |
then exit; |
|
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
669 |
|
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
670 |
ResizeLand(tmpsurf^.w, tmpsurf^.h); |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
671 |
LoadMapConfig; |
1792 | 672 |
|
1776 | 673 |
playHeight:= tmpsurf^.h; |
674 |
playWidth:= tmpsurf^.w; |
|
675 |
leftX:= (LAND_WIDTH - playWidth) div 2; |
|
676 |
rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1; |
|
677 |
topY:= LAND_HEIGHT - playHeight; |
|
678 |
||
11537 | 679 |
if not checkFails(tmpsurf^.format^.BytesPerPixel = 4, 'Map should be 32bit', true) then |
680 |
BlitImageAndGenerateCollisionInfo( |
|
681 |
(LAND_WIDTH - tmpsurf^.w) div 2, |
|
682 |
LAND_HEIGHT - tmpsurf^.h, |
|
683 |
tmpsurf^.w, |
|
684 |
tmpsurf); |
|
1754 | 685 |
|
686 |
SDL_FreeSurface(tmpsurf); |
|
1792 | 687 |
|
11537 | 688 |
if allOK then LoadMask; |
1754 | 689 |
end; |
690 |
||
5717 | 691 |
procedure DrawBottomBorder; // broken out from other borders for doing a floor-only map, or possibly updating bottom during SD |
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
692 |
var x, w, c, y: Longword; |
5717 | 693 |
begin |
5718
e74de0528ef4
Let's draw the bottom border thicker, so it is more visible
nemo
parents:
5717
diff
changeset
|
694 |
for w:= 0 to 23 do |
5717 | 695 |
for x:= leftX to rightX do |
696 |
begin |
|
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
697 |
y:= Longword(cWaterLine) - 1 - w; |
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
698 |
Land[y, x]:= lfIndestructible; |
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
699 |
if (x + y) mod 32 < 16 then |
5717 | 700 |
c:= AMask |
701 |
else |
|
702 |
c:= AMask or RMask or GMask; // FF00FFFF |
|
703 |
||
704 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
705 |
LandPixels[y, x]:= c |
5717 | 706 |
else |
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
707 |
LandPixels[y 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
|
708 |
end |
5717 | 709 |
end; |
710 |
||
1754 | 711 |
procedure GenMap; |
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
712 |
var x, y, w, c, c2: Longword; |
8025 | 713 |
map, mask: shortstring; |
1754 | 714 |
begin |
3463 | 715 |
hasBorder:= false; |
8011 | 716 |
maskOnly:= false; |
2891
e1f902eb0cfe
Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents:
2866
diff
changeset
|
717 |
|
3463 | 718 |
LoadThemeConfig; |
3697 | 719 |
|
4900 | 720 |
// is this not needed any more? lets hope setlength sets also 0s |
3630 | 721 |
//if ((GameFlags and gfForts) <> 0) or (Pathz[ptMapCurrent] <> '') then |
722 |
// FillChar(Land,SizeOf(TCollisionArray),0);*) |
|
3697 | 723 |
|
11886
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
724 |
if cPathz[ptMapCurrent] <> '' then |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
725 |
begin |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
726 |
map:= cPathz[ptMapCurrent] + '/map.png'; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
727 |
mask:= cPathz[ptMapCurrent] + '/mask.png'; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
728 |
if (not(pfsExists(map)) and pfsExists(mask)) then |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
729 |
begin |
11886
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
730 |
maskOnly:= true; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
731 |
LoadMask; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
732 |
GenLandSurface |
8010
195677b0d06b
something bender asked for. allow a mask without a map
nemo
parents:
8003
diff
changeset
|
733 |
end |
11886
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
734 |
else LoadMap; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
735 |
end |
3463 | 736 |
else |
11886
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
737 |
begin |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
738 |
WriteLnToConsole('Generating land...'); |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
739 |
case cMapGen of |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
740 |
mgRandom: GenTemplated(EdgeTemplates[SelectTemplate]); |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
741 |
mgMaze : begin ResizeLand(4096,2048); GenMaze; end; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
742 |
mgPerlin: begin ResizeLand(4096,2048); GenPerlin; end; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
743 |
mgDrawn : GenDrawnMap; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
744 |
mgForts : begin GameFlags:= (GameFlags or gfForts or gfDivideTeams); MakeFortsMap(); end; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
745 |
else |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
746 |
OutError('Unknown mapgen', true); |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
747 |
end; |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
748 |
if cMapGen <> mgForts then |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
749 |
GenLandSurface |
34ede05e4d4f
Remove old Fort Mode from frontend
Wuzzy <almikes@aol.com>
parents:
11831
diff
changeset
|
750 |
end; |
3463 | 751 |
|
752 |
AddProgress; |
|
1760 | 753 |
|
1768 | 754 |
// check for land near top |
1784 | 755 |
c:= 0; |
756 |
if (GameFlags and gfBorder) <> 0 then |
|
757 |
hasBorder:= true |
|
758 |
else |
|
759 |
for y:= topY to topY + 5 do |
|
760 |
for x:= leftX to rightX do |
|
761 |
if Land[y, x] <> 0 then |
|
762 |
begin |
|
763 |
inc(c); |
|
8370 | 764 |
if c > LongWord((LAND_WIDTH div 2)) then // avoid accidental triggering |
1784 | 765 |
begin |
766 |
hasBorder:= true; |
|
767 |
break; |
|
768 |
end; |
|
769 |
end; |
|
1768 | 770 |
|
1776 | 771 |
if hasBorder then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
772 |
begin |
10661 | 773 |
if WorldEdge = weNone then |
774 |
begin |
|
775 |
for y:= 0 to LAND_HEIGHT - 1 do |
|
776 |
for x:= 0 to LAND_WIDTH - 1 do |
|
777 |
if (y < topY) or (x < leftX) or (x > rightX) then |
|
778 |
Land[y, x]:= lfIndestructible; |
|
779 |
end |
|
780 |
else if topY > 0 then |
|
781 |
begin |
|
782 |
for y:= 0 to LongInt(topY) - 1 do |
|
783 |
for x:= 0 to LAND_WIDTH - 1 do |
|
3519 | 784 |
Land[y, x]:= lfIndestructible; |
10661 | 785 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
786 |
// experiment hardcoding cave |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
787 |
// 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
|
788 |
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
|
789 |
begin |
9524 | 790 |
if (WorldEdge <> weBounce) and (WorldEdge <> weWrap) then |
791 |
for y:= topY to LAND_HEIGHT - 1 do |
|
792 |
begin |
|
793 |
Land[y, leftX + w]:= lfIndestructible; |
|
794 |
Land[y, rightX - w]:= lfIndestructible; |
|
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
795 |
if (y + leftX + w) mod 32 < 16 then |
9524 | 796 |
c:= AMask |
797 |
else |
|
798 |
c:= AMask or RMask or GMask; // FF00FFFF |
|
12092
78e9fbd52ffc
simplify code of previous commit ( ba1807589eaa )
sheepluva
parents:
12091
diff
changeset
|
799 |
if (y + rightX - w) mod 32 < 16 then |
12091
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
800 |
c2:= AMask |
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
801 |
else |
ba1807589eaa
OCD-compatibility-patch: make border stripes consistent in direction and offset, seamless.
sheepluva
parents:
11886
diff
changeset
|
802 |
c2:= 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
|
803 |
|
9524 | 804 |
if (cReducedQuality and rqBlurryLand) = 0 then |
805 |
begin |
|
806 |
LandPixels[y, leftX + w]:= c; |
|
12092
78e9fbd52ffc
simplify code of previous commit ( ba1807589eaa )
sheepluva
parents:
12091
diff
changeset
|
807 |
LandPixels[y, rightX - w]:= c2; |
9524 | 808 |
end |
809 |
else |
|
810 |
begin |
|
811 |
LandPixels[y div 2, (leftX + w) div 2]:= c; |
|
12092
78e9fbd52ffc
simplify code of previous commit ( ba1807589eaa )
sheepluva
parents:
12091
diff
changeset
|
812 |
LandPixels[y div 2, (rightX - w) div 2]:= c2; |
9524 | 813 |
end; |
5717 | 814 |
end; |
1768 | 815 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
816 |
for x:= leftX to rightX do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
817 |
begin |
5717 | 818 |
Land[topY + w, x]:= lfIndestructible; |
819 |
if (x + w) mod 32 < 16 then |
|
820 |
c:= AMask |
|
821 |
else |
|
822 |
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
|
823 |
|
5717 | 824 |
if (cReducedQuality and rqBlurryLand) = 0 then |
825 |
LandPixels[topY + w, x]:= c |
|
826 |
else |
|
827 |
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
|
828 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
829 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
830 |
end; |
1768 | 831 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
832 |
if (GameFlags and gfBottomBorder) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
833 |
DrawBottomBorder; |
5717 | 834 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
835 |
if (GameFlags and gfDisableGirders) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
836 |
hasGirders:= false; |
2891
e1f902eb0cfe
Formerly "Draw Girders" by MrMfS - now "Disable Girders" to allow template prefs to still exist
nemo
parents:
2866
diff
changeset
|
837 |
|
8025 | 838 |
if (GameFlags and gfForts = 0) and (maskOnly or (cPathz[ptMapCurrent] = '')) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
839 |
AddObjects |
10017 | 840 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
841 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
842 |
AddProgress(); |
1776 | 843 |
|
3058 | 844 |
FreeLandObjects; |
845 |
||
11544 | 846 |
if not allOK then exit; |
847 |
||
6982 | 848 |
if GrayScale then |
5441
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
849 |
begin |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
850 |
if (cReducedQuality and rqBlurryLand) = 0 then |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
851 |
for x:= leftX to rightX do |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
852 |
for y:= topY to LAND_HEIGHT-1 do |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
853 |
begin |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
854 |
w:= LandPixels[y,x]; |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
855 |
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
|
856 |
(w shr BShift and $FF) * RGB_LUMINANCE_GREEN + |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
857 |
(w shr GShift and $FF) * RGB_LUMINANCE_BLUE)); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
858 |
if w > 255 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
859 |
w:= 255; |
5441
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
860 |
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
|
861 |
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
|
862 |
end |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
863 |
else |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
864 |
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
|
865 |
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
|
866 |
begin |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
867 |
w:= LandPixels[y div 2,x div 2]; |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
868 |
w:= ((w shr RShift and $FF) + (w shr BShift and $FF) + (w shr GShift and $FF)) div 3; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
869 |
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); |
5441
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
870 |
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
|
871 |
end |
39962b855540
Add grayscale option for 3d, helps with colour clashing
nemo
parents:
5274
diff
changeset
|
872 |
end; |
10016
59a6d65fcb60
(experimental) make the mysterious borders around land/hats/etc that appear on zoom vanish
sheepluva
parents:
9998
diff
changeset
|
873 |
|
59a6d65fcb60
(experimental) make the mysterious borders around land/hats/etc that appear on zoom vanish
sheepluva
parents:
9998
diff
changeset
|
874 |
PrettifyLandAlpha(); |
10626
2562797ab3cf
adjust position of world edges (at 150 px away from outmost land collision, or less if land array ends earlier)
sheepluva
parents:
10603
diff
changeset
|
875 |
|
10661 | 876 |
// adjust world edges for borderless maps |
877 |
if (WorldEdge <> weNone) and (not hasBorder) then |
|
878 |
InitWorldEdges(); |
|
10626
2562797ab3cf
adjust position of world edges (at 150 px away from outmost land collision, or less if land array ends earlier)
sheepluva
parents:
10603
diff
changeset
|
879 |
|
37 | 880 |
end; |
881 |
||
7079 | 882 |
procedure GenPreview(out Preview: TPreview); |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
883 |
var rh, rw, ox, oy, x, y, xx, yy, t, bit, cbit, lh, lw: LongInt; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
884 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
885 |
WriteLnToConsole('Generating preview...'); |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
886 |
case cMapGen of |
10603
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
887 |
mgRandom: GenTemplated(EdgeTemplates[SelectTemplate]); |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
888 |
mgMaze: begin ResizeLand(4096,2048); GenMaze; end; |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
889 |
mgPerlin: begin ResizeLand(4096,2048); GenPerlin; end; |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
890 |
mgDrawn: GenDrawnMap; |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
891 |
mgForts: MakeFortsPreview(); |
4562 | 892 |
else |
893 |
OutError('Unknown mapgen', true); |
|
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
894 |
end; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
895 |
|
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
896 |
// strict scaling needed here since preview assumes a rectangle |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
897 |
rh:= max(LAND_HEIGHT,2048); |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
898 |
rw:= max(LAND_WIDTH,4096); |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
899 |
ox:= 0; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
900 |
if rw < rh*2 then |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
901 |
begin |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
902 |
rw:= rh*2; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
903 |
end; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
904 |
if rh < rw div 2 then rh:= rw * 2; |
10017 | 905 |
|
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
906 |
ox:= (rw-LAND_WIDTH) div 2; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
907 |
oy:= rh-LAND_HEIGHT; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
908 |
|
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
909 |
lh:= rh div 128; |
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
910 |
lw:= rw div 32; |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
911 |
for y:= 0 to 127 do |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
912 |
for x:= 0 to 31 do |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
913 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
914 |
Preview[y, x]:= 0; |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
915 |
for bit:= 0 to 7 do |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
916 |
begin |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
917 |
t:= 0; |
3617 | 918 |
cbit:= bit * 8; |
919 |
for yy:= y * lh to y * lh + 7 do |
|
920 |
for xx:= x * lw + cbit to x * lw + cbit + 7 do |
|
10017 | 921 |
if ((yy-oy) and LAND_HEIGHT_MASK = 0) and ((xx-ox) and LAND_WIDTH_MASK = 0) |
7477
26706bf32ecf
First pass at variable land size. For playing a small map (forced on rqLowRes), this should save 42MiB of RAM.
nemo
parents:
7293
diff
changeset
|
922 |
and (Land[yy-oy, xx-ox] <> 0) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6491
diff
changeset
|
923 |
inc(t); |
3365
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
924 |
if t > 8 then |
37ac593e9027
wow all these files only for land preview and seed generation
koda
parents:
3287
diff
changeset
|
925 |
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
|
926 |
end; |
566 | 927 |
end; |
155
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
928 |
end; |
401f4ea24715
Engine can generate land preview and send it via IPC
unc0rr
parents:
109
diff
changeset
|
929 |
|
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
|
930 |
|
10162 | 931 |
procedure GenPreviewAlpha(out Preview: TPreviewAlpha); |
932 |
var rh, rw, ox, oy, x, y, xx, yy, t, lh, lw: LongInt; |
|
933 |
begin |
|
934 |
WriteLnToConsole('Generating preview...'); |
|
935 |
case cMapGen of |
|
10603
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
936 |
mgRandom: GenTemplated(EdgeTemplates[SelectTemplate]); |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
937 |
mgMaze: begin ResizeLand(4096,2048); GenMaze; end; |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
938 |
mgPerlin: begin ResizeLand(4096,2048); GenPerlin; end; |
bda5c7caf396
switch mapgen to enum. should still try and make sure the values are backwards compatible if possible.
nemo
parents:
10490
diff
changeset
|
939 |
mgDrawn: GenDrawnMap; |
11749
ac58a063d26a
Added "Forts" to map type selection. This makes the mode easier selectable/discoverable. Also the slider can be used to adjust the distance between forts.
sheepluva
parents:
11739
diff
changeset
|
940 |
mgForts: MakeFortsPreview; |
10162 | 941 |
else |
942 |
OutError('Unknown mapgen', true); |
|
943 |
end; |
|
944 |
||
945 |
// strict scaling needed here since preview assumes a rectangle |
|
946 |
rh:= max(LAND_HEIGHT, 2048); |
|
947 |
rw:= max(LAND_WIDTH, 4096); |
|
948 |
ox:= 0; |
|
949 |
if rw < rh*2 then |
|
950 |
begin |
|
951 |
rw:= rh*2; |
|
952 |
end; |
|
953 |
if rh < rw div 2 then rh:= rw * 2; |
|
954 |
||
955 |
ox:= (rw-LAND_WIDTH) div 2; |
|
956 |
oy:= rh-LAND_HEIGHT; |
|
957 |
||
958 |
lh:= rh div 128; |
|
959 |
lw:= rw div 256; |
|
960 |
for y:= 0 to 127 do |
|
961 |
for x:= 0 to 255 do |
|
962 |
begin |
|
963 |
t:= 0; |
|
964 |
||
10165 | 965 |
for yy:= y * lh - oy to y * lh + lh - 1 - oy do |
966 |
for xx:= x * lw - ox to x * lw + lw - 1 - ox do |
|
10162 | 967 |
if (yy and LAND_HEIGHT_MASK = 0) and (xx and LAND_WIDTH_MASK = 0) |
968 |
and (Land[yy, xx] <> 0) then |
|
969 |
inc(t); |
|
970 |
||
10165 | 971 |
Preview[y, x]:= t * 255 div (lh * lw); |
10162 | 972 |
end; |
973 |
end; |
|
974 |
||
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
|
975 |
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
|
976 |
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
|
977 |
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
|
978 |
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
|
979 |
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
|
980 |
else |
12716
20dbb3a03e61
extend land digest to all surfaces that could possibly be loaded into Land[] - i.e. ones that impact sync
nemo
parents:
12597
diff
changeset
|
981 |
checkFails(s = digest, 'Different map or critical resources loaded, sorry', true); |
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
|
982 |
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
|
983 |
|
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
|
984 |
procedure chSendLandDigest(var s: shortstring); |
12716
20dbb3a03e61
extend land digest to all surfaces that could possibly be loaded into Land[] - i.e. ones that impact sync
nemo
parents:
12597
diff
changeset
|
985 |
var i: LongInt; |
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
|
986 |
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
|
987 |
for i:= 0 to LAND_HEIGHT-1 do |
12763 | 988 |
syncedPixelDigest:= Adler32Update(syncedPixelDigest, @Land[i,0], LAND_WIDTH*2); |
12716
20dbb3a03e61
extend land digest to all surfaces that could possibly be loaded into Land[] - i.e. ones that impact sync
nemo
parents:
12597
diff
changeset
|
989 |
s:= 'M' + IntToStr(syncedPixelDigest); // + cScriptName; script name is no longer needed. scripts are hashed |
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
|
990 |
|
10022 | 991 |
ScriptSetString('LandDigest', s); |
992 |
||
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
|
993 |
chLandCheck(s); |
11537 | 994 |
if allOK then SendIPCRaw(@s[0], Length(s) + 1) |
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
|
995 |
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
|
996 |
|
3038 | 997 |
procedure initModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
998 |
begin |
6898 | 999 |
RegisterVariable('landcheck', @chLandCheck, false); |
1000 |
RegisterVariable('sendlanddigest', @chSendLandDigest, false); |
|
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
|
1001 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2905
diff
changeset
|
1002 |
LandBackSurface:= nil; |
3369
c7289e42f0ee
add other controls for map preview, also fix a bug in digest
koda
parents:
3365
diff
changeset
|
1003 |
digest:= ''; |
11019
67ef02300508
always draw border on terrain if there is only a map mask and no map image. this is a workaround for the fact that space campaign masks use white (lfObject) color instead of black (lfBasic)
sheepluva
parents:
11006
diff
changeset
|
1004 |
maskOnly:= false; |
7549 | 1005 |
LAND_WIDTH:= 0; |
1006 |
LAND_HEIGHT:= 0; |
|
1007 |
(* |
|
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
|
1008 |
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
|
1009 |
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
|
1010 |
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
|
1011 |
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
|
1012 |
|
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
|
1013 |
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
|
1014 |
SetLength(LandDirty, (LAND_HEIGHT div 32), (LAND_WIDTH div 32)); |
7549 | 1015 |
*) |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1016 |
end; |
51 | 1017 |
|
3038 | 1018 |
procedure freeModule; |
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1019 |
begin |
7151 | 1020 |
SetLength(Land, 0, 0); |
1021 |
SetLength(LandPixels, 0, 0); |
|
1022 |
SetLength(LandDirty, 0, 0); |
|
2699
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1023 |
end; |
249adefa9c1c
replace initialization/finalization statements with custom init functions
koda
parents:
2692
diff
changeset
|
1024 |
|
4 | 1025 |
end. |