author | nemo |
Thu, 08 Sep 2011 13:03:58 -0400 | |
changeset 5813 | d5e9c22c59a2 |
parent 5692 | 753ae5d0776c |
child 5832 | f730c8a9777b |
permissions | -rw-r--r-- |
393 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
4976 | 3 |
* Copyright (c) 2004-2011 Andrey Korotaev <unC0Rr@gmail.com> |
393 | 4 |
* |
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 |
|
8 |
* |
|
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. |
|
13 |
* |
|
14 |
* You should have received a copy of the GNU General Public License |
|
15 |
* along with this program; if not, write to the Free Software |
|
16 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA |
|
17 |
*) |
|
18 |
||
2630 | 19 |
{$INCLUDE "options.inc"} |
20 |
||
184 | 21 |
unit uLandGraphics; |
22 |
interface |
|
4357
a1fcfc341a52
Introduce unit uTypes in order to remove some cyclic unit dependencies
unC0Rr
parents:
3749
diff
changeset
|
23 |
uses uFloat, uConsts, uTypes; |
184 | 24 |
|
25 |
type PRangeArray = ^TRangeArray; |
|
26 |
TRangeArray = array[0..31] of record |
|
371 | 27 |
Left, Right: LongInt; |
184 | 28 |
end; |
29 |
||
4791 | 30 |
function addBgColor(OldColor, NewColor: LongWord): LongWord; |
2716
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
31 |
function SweepDirty: boolean; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
32 |
function Despeckle(X, Y: LongInt; gfxOnly: boolean): LongWord; |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
33 |
procedure Smooth(X, Y: LongInt); |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
34 |
function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean; |
4377 | 35 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
371 | 36 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
37 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
|
38 |
procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword); |
|
511 | 39 |
procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean); |
4367 | 40 |
function LandBackPixel(x, y: LongInt): LongWord; |
184 | 41 |
|
4886 | 42 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
409 | 43 |
|
184 | 44 |
implementation |
4403 | 45 |
uses SDLh, uLandTexture, uVariables, uUtils, uDebug; |
184 | 46 |
|
4791 | 47 |
function addBgColor(OldColor, NewColor: LongWord): LongWord; |
48 |
// Factor ranges from 0 to 100% NewColor |
|
49 |
var |
|
5692 | 50 |
oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: LongWord; |
4791 | 51 |
begin |
5692 | 52 |
oAlpha := (OldColor shr AShift) and $FF; |
53 |
nAlpha := (NewColor shr AShift) and $FF; |
|
54 |
// shortcircuit |
|
55 |
if (oAlpha = 0) or (nAlpha = $FF) then |
|
56 |
begin |
|
57 |
addBgColor:= NewColor; |
|
58 |
exit |
|
59 |
end; |
|
4791 | 60 |
// Get colors |
5041 | 61 |
oRed := (OldColor shr RShift) and $FF; |
62 |
oGreen := (OldColor shr GShift) and $FF; |
|
63 |
oBlue := (OldColor shr BShift) and $FF; |
|
4791 | 64 |
|
5041 | 65 |
nRed := (NewColor shr RShift) and $FF; |
66 |
nGreen := (NewColor shr GShift) and $FF; |
|
67 |
nBlue := (NewColor shr BShift) and $FF; |
|
4791 | 68 |
|
69 |
// Mix colors |
|
5692 | 70 |
nRed := min(255,((nRed*nAlpha) div 255) + ((oRed*oAlpha*(255-nAlpha)) div 65025)); |
71 |
nGreen := min(255,((nGreen*nAlpha) div 255) + ((oGreen*oAlpha*(255-nAlpha)) div 65025)); |
|
72 |
nBlue := min(255,((nBlue*nAlpha) div 255) + ((oBlue*oAlpha*(255-nAlpha)) div 65025)); |
|
4791 | 73 |
nAlpha := min(255, oAlpha + nAlpha); |
74 |
||
5041 | 75 |
addBgColor := (nAlpha shl AShift) or (nRed shl RShift) or (nGreen shl GShift) or (nBlue shl BShift); |
4791 | 76 |
end; |
77 |
||
371 | 78 |
procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword); |
79 |
var i: LongInt; |
|
184 | 80 |
begin |
1753 | 81 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 82 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3519 | 83 |
if (Land[y + dy, i] and lfIndestructible) = 0 then |
1753 | 84 |
Land[y + dy, i]:= Value; |
85 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 86 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3519 | 87 |
if (Land[y - dy, i] and lfIndestructible) = 0 then |
1753 | 88 |
Land[y - dy, i]:= Value; |
89 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 90 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3519 | 91 |
if (Land[y + dx, i] and lfIndestructible) = 0 then |
1753 | 92 |
Land[y + dx, i]:= Value; |
93 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 94 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3519 | 95 |
if (Land[y - dx, i] and lfIndestructible) = 0 then |
1753 | 96 |
Land[y - dx, i]:= Value; |
184 | 97 |
end; |
98 |
||
511 | 99 |
procedure ChangeCircleLines(x, y, dx, dy: LongInt; doSet: boolean); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
100 |
var i: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
101 |
begin |
511 | 102 |
if not doSet then |
103 |
begin |
|
1753 | 104 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 105 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
1861 | 106 |
if (Land[y + dy, i] > 0) and (Land[y + dy, i] < 256) then dec(Land[y + dy, i]); // check > 0 because explosion can erase collision data |
1753 | 107 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 108 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
1861 | 109 |
if (Land[y - dy, i] > 0) and (Land[y - dy, i] < 256) then dec(Land[y - dy, i]); |
1753 | 110 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 111 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
1861 | 112 |
if (Land[y + dx, i] > 0) and (Land[y + dx, i] < 256) then dec(Land[y + dx, i]); |
1753 | 113 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 114 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
1861 | 115 |
if (Land[y - dx, i] > 0) and (Land[y - dx, i] < 256) then dec(Land[y - dx, i]); |
511 | 116 |
end else |
117 |
begin |
|
1753 | 118 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 119 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3608
c509bbc779e7
Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists.
nemo
parents:
3603
diff
changeset
|
120 |
if (Land[y + dy, i] < 256) then |
1861 | 121 |
inc(Land[y + dy, i]); |
1753 | 122 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 123 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3608
c509bbc779e7
Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists.
nemo
parents:
3603
diff
changeset
|
124 |
if (Land[y - dy, i] < 256) then |
1861 | 125 |
inc(Land[y - dy, i]); |
1753 | 126 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 127 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3608
c509bbc779e7
Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists.
nemo
parents:
3603
diff
changeset
|
128 |
if (Land[y + dx, i] < 256) then |
1861 | 129 |
inc(Land[y + dx, i]); |
1753 | 130 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 131 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3608
c509bbc779e7
Revert prior attempted optimisation. Gridding the land pays in some situations, but not all. Restricting to an upper bound might help, but overall, seems too fuzzy to be worth it. On one side is increased cost of Add/Delete + extra test on collision check, on the other is skipping the list iteration. Perhaps for large lists.
nemo
parents:
3603
diff
changeset
|
132 |
if (Land[y - dx, i] < 256) then |
1861 | 133 |
inc(Land[y - dx, i]); |
511 | 134 |
end |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
135 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
136 |
|
371 | 137 |
procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword); |
138 |
var dx, dy, d: LongInt; |
|
184 | 139 |
begin |
140 |
dx:= 0; |
|
141 |
dy:= Radius; |
|
142 |
d:= 3 - 2 * Radius; |
|
143 |
while (dx < dy) do |
|
144 |
begin |
|
145 |
FillCircleLines(x, y, dx, dy, Value); |
|
146 |
if (d < 0) |
|
147 |
then d:= d + 4 * dx + 6 |
|
148 |
else begin |
|
149 |
d:= d + 4 * (dx - dy) + 10; |
|
150 |
dec(dy) |
|
151 |
end; |
|
152 |
inc(dx) |
|
153 |
end; |
|
154 |
if (dx = dy) then FillCircleLines(x, y, dx, dy, Value); |
|
155 |
end; |
|
156 |
||
511 | 157 |
procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
158 |
var dx, dy, d: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
159 |
begin |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
160 |
dx:= 0; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
161 |
dy:= Radius; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
162 |
d:= 3 - 2 * Radius; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
163 |
while (dx < dy) do |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
164 |
begin |
511 | 165 |
ChangeCircleLines(x, y, dx, dy, doSet); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
166 |
if (d < 0) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
167 |
then d:= d + 4 * dx + 6 |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
168 |
else begin |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
169 |
d:= d + 4 * (dx - dy) + 10; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
170 |
dec(dy) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
171 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
172 |
inc(dx) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
173 |
end; |
511 | 174 |
if (dx = dy) then ChangeCircleLines(x, y, dx, dy, doSet) |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
175 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
176 |
|
2603 | 177 |
procedure FillLandCircleLines0(x, y, dx, dy: LongInt); |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
178 |
var i, t: LongInt; |
184 | 179 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
180 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
181 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 182 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
183 |
if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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:
3554
diff
changeset
|
184 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
185 |
LandPixels[t, i]:= 0 |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
186 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
187 |
LandPixels[t div 2, i div 2]:= 0; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
188 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
189 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
190 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 191 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
192 |
if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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:
3554
diff
changeset
|
193 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
194 |
LandPixels[t, i]:= 0 |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
195 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
196 |
LandPixels[t div 2, i div 2]:= 0; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
197 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
198 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
199 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 200 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
201 |
if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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:
3554
diff
changeset
|
202 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
203 |
LandPixels[t, i]:= 0 |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
204 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
205 |
LandPixels[t div 2, i div 2]:= 0; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
206 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
207 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
208 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 209 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
210 |
if (not isMap and ((Land[t, i] and lfIndestructible) = 0)) or ((Land[t, i] and lfBasic) <> 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:
3554
diff
changeset
|
211 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
212 |
LandPixels[t, i]:= 0 |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
213 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
214 |
LandPixels[t div 2, i div 2]:= 0; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
215 |
|
184 | 216 |
end; |
217 |
||
3689 | 218 |
function FillLandCircleLinesBG(x, y, dx, dy: LongInt): Longword; |
5480 | 219 |
var i, t, by, bx: LongInt; |
3689 | 220 |
cnt: Longword; |
2647 | 221 |
begin |
3689 | 222 |
cnt:= 0; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
223 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
224 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 225 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
5480 | 226 |
begin |
227 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
228 |
begin |
|
229 |
by:= t; bx:= i; |
|
230 |
end |
|
231 |
else |
|
232 |
begin |
|
233 |
by:= t div 2; bx:= i div 2; |
|
234 |
end; |
|
235 |
if ((Land[t, i] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
3689 | 236 |
begin |
237 |
inc(cnt); |
|
5480 | 238 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
3689 | 239 |
end |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
240 |
else |
5480 | 241 |
if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
242 |
LandPixels[by, bx]:= 0 |
|
243 |
end; |
|
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
244 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
245 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
246 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 247 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
5480 | 248 |
begin |
249 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
250 |
begin |
|
251 |
by:= t; bx:= i; |
|
252 |
end |
|
253 |
else |
|
254 |
begin |
|
255 |
by:= t div 2; bx:= i div 2; |
|
256 |
end; |
|
257 |
if ((Land[t, i] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
3689 | 258 |
begin |
259 |
inc(cnt); |
|
5480 | 260 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
3689 | 261 |
end |
5480 | 262 |
else if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
263 |
LandPixels[by, bx]:= 0 |
|
264 |
end; |
|
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
265 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
266 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
267 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 268 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
5480 | 269 |
begin |
270 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
271 |
begin |
|
272 |
by:= t; bx:= i; |
|
273 |
end |
|
274 |
else |
|
275 |
begin |
|
276 |
by:= t div 2; bx:= i div 2; |
|
277 |
end; |
|
278 |
if ((Land[t, i] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
3689 | 279 |
begin |
280 |
inc(cnt); |
|
5480 | 281 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
3689 | 282 |
end |
5480 | 283 |
else if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
284 |
LandPixels[by, bx]:= 0 |
|
285 |
end; |
|
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
286 |
t:= y - dx; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
287 |
if (t and LAND_HEIGHT_MASK) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
288 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
5480 | 289 |
begin |
290 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
291 |
begin |
|
292 |
by:= t; bx:= i; |
|
293 |
end |
|
294 |
else |
|
295 |
begin |
|
296 |
by:= t div 2; bx:= i div 2; |
|
297 |
end; |
|
298 |
if ((Land[t, i] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
299 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
300 |
inc(cnt); |
5480 | 301 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
302 |
end |
5480 | 303 |
else if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
304 |
LandPixels[by, bx]:= 0 |
|
305 |
end; |
|
3689 | 306 |
FillLandCircleLinesBG:= cnt; |
2647 | 307 |
end; |
308 |
||
371 | 309 |
procedure FillLandCircleLinesEBC(x, y, dx, dy: LongInt); |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
310 |
var i, t: LongInt; |
184 | 311 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
312 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
313 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 314 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
315 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
316 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
317 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
318 |
LandPixels[t, i]:= cExplosionBorderColor |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
319 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
320 |
LandPixels[t div 2, i div 2]:= cExplosionBorderColor; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
321 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
322 |
Land[t, i]:= Land[t, i] or lfDamaged; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
323 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
324 |
LandDirty[t div 32, i div 32]:= 1; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
325 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
326 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
327 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
328 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 329 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
330 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
331 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
332 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 333 |
LandPixels[t, i]:= cExplosionBorderColor |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
334 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
335 |
LandPixels[t div 2, i div 2]:= cExplosionBorderColor; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
336 |
Land[t, i]:= Land[t, i] or lfDamaged; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
337 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
338 |
LandDirty[t div 32, i div 32]:= 1; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
339 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
340 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
341 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
342 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 343 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
344 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
345 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
346 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
347 |
LandPixels[t, i]:= cExplosionBorderColor |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
348 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
349 |
LandPixels[t div 2, i div 2]:= cExplosionBorderColor; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
350 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
351 |
Land[t, i]:= Land[t, i] or lfDamaged; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
352 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
353 |
LandDirty[t div 32, i div 32]:= 1; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
354 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
355 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
356 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
357 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 358 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
359 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
360 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
361 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 362 |
LandPixels[t, i]:= cExplosionBorderColor |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
363 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
364 |
LandPixels[t div 2, i div 2]:= cExplosionBorderColor; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
365 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
366 |
Land[t, i]:= Land[t, i] or lfDamaged; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
367 |
//Despeckle(i, y - dy); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
368 |
LandDirty[t div 32, i div 32]:= 1; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
369 |
end; |
184 | 370 |
end; |
371 |
||
3689 | 372 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
2603 | 373 |
var dx, dy, ty, tx, d: LongInt; |
3689 | 374 |
cnt: Longword; |
184 | 375 |
begin |
2647 | 376 |
|
377 |
// draw background land texture |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
378 |
begin |
3689 | 379 |
cnt:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
380 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
381 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
382 |
d:= 3 - 2 * Radius; |
2647 | 383 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
384 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
385 |
begin |
3689 | 386 |
inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
387 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
388 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
389 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
390 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
391 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
392 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
393 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
394 |
end; |
3689 | 395 |
if (dx = dy) then inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
396 |
end; |
2647 | 397 |
|
398 |
// draw a hole in land |
|
2733 | 399 |
if Radius > 20 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
400 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
401 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
402 |
dy:= Radius - 15; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
403 |
d:= 3 - 2 * dy; |
2647 | 404 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
405 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
406 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
407 |
FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
408 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
409 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
410 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
411 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
412 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
413 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
414 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
415 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
416 |
if (dx = dy) then FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
417 |
end; |
2647 | 418 |
|
1849 | 419 |
// FillRoundInLand after erasing land pixels to allow Land 0 check for mask.png to function |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
420 |
FillRoundInLand(X, Y, Radius, 0); |
2647 | 421 |
|
422 |
// draw explosion border |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
423 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
424 |
inc(Radius, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
425 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
426 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
427 |
d:= 3 - 2 * Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
428 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
429 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
430 |
FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
431 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
432 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
433 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
434 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
435 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
436 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
437 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
438 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
439 |
if (dx = dy) then FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
440 |
end; |
351 | 441 |
|
4374 | 442 |
tx:= Max(X - Radius - 1, 0); |
443 |
dx:= Min(X + Radius + 1, LAND_WIDTH) - tx; |
|
444 |
ty:= Max(Y - Radius - 1, 0); |
|
445 |
dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty; |
|
3689 | 446 |
UpdateLandTexture(tx, dx, ty, dy); |
447 |
DrawExplosion:= cnt |
|
184 | 448 |
end; |
449 |
||
371 | 450 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
5480 | 451 |
var tx, ty, by, bx, i: LongInt; |
184 | 452 |
begin |
453 |
for i:= 0 to Pred(Count) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
454 |
begin |
4374 | 455 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
456 |
for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do |
|
5480 | 457 |
begin |
458 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
459 |
begin |
|
460 |
by:= ty; bx:= tx; |
|
461 |
end |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
462 |
else |
5480 | 463 |
begin |
464 |
by:= ty div 2; bx:= tx div 2; |
|
465 |
end; |
|
466 |
if ((Land[ty, tx] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
467 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
|
468 |
else if ((Land[ty, tx] and lfObject) <> 0) or (disableLandBack and ((Land[ty, tx] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
|
469 |
LandPixels[by, bx]:= 0 |
|
470 |
end; |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
471 |
inc(y, dY) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
472 |
end; |
184 | 473 |
|
474 |
inc(Radius, 4); |
|
351 | 475 |
dec(y, Count * dY); |
184 | 476 |
|
477 |
for i:= 0 to Pred(Count) do |
|
478 |
begin |
|
4374 | 479 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
480 |
for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
481 |
if ((Land[ty, tx] and lfBasic) <> 0) or ((Land[ty, tx] and lfObject) <> 0) then |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
482 |
begin |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
483 |
if (cReducedQuality and rqBlurryLand) = 0 then |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
484 |
LandPixels[ty, tx]:= cExplosionBorderColor |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
485 |
else |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
486 |
LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor; |
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
487 |
|
3519 | 488 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
3596 | 489 |
LandDirty[ty div 32, tx div 32]:= 1; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
490 |
end; |
184 | 491 |
inc(y, dY) |
492 |
end; |
|
493 |
||
818 | 494 |
|
1807 | 495 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT) |
184 | 496 |
end; |
497 |
||
498 |
// |
|
499 |
// - (dX, dY) - direction, vector of length = 0.5 |
|
500 |
// |
|
371 | 501 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
358 | 502 |
var nx, ny, dX8, dY8: hwFloat; |
5480 | 503 |
i, t, tx, ty, by, bx, stX, stY, ddy, ddx: Longint; |
5332 | 504 |
despeckle : Boolean; |
184 | 505 |
begin // (-dY, dX) is (dX, dY) rotated by PI/2 |
772
e8d530ca77be
Don't update all land texture when drawing tunnel (saves video throughput)
unc0rr
parents:
769
diff
changeset
|
506 |
stY:= hwRound(Y); |
1809 | 507 |
stX:= hwRound(X); |
772
e8d530ca77be
Don't update all land texture when drawing tunnel (saves video throughput)
unc0rr
parents:
769
diff
changeset
|
508 |
|
5332 | 509 |
despeckle:= HalfWidth > 1; |
510 |
||
184 | 511 |
nx:= X + dY * (HalfWidth + 8); |
512 |
ny:= Y - dX * (HalfWidth + 8); |
|
513 |
||
358 | 514 |
dX8:= dX * 8; |
515 |
dY8:= dY * 8; |
|
184 | 516 |
for i:= 0 to 7 do |
517 |
begin |
|
358 | 518 |
X:= nx - dX8; |
519 |
Y:= ny - dY8; |
|
184 | 520 |
for t:= -8 to ticks + 8 do |
2666 | 521 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
522 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
523 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
524 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
525 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
526 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
527 |
((tx and LAND_WIDTH_MASK) = 0) and |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
528 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
529 |
((Land[ty, tx] and lfObject) <> 0)) then |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
530 |
begin |
3519 | 531 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 532 |
if despeckle then LandDirty[ty div 32, tx div 32]:= 1; |
533 |
if (cReducedQuality and rqBlurryLand) = 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:
3554
diff
changeset
|
534 |
LandPixels[ty, tx]:= cExplosionBorderColor |
5332 | 535 |
else LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
536 |
end |
2666 | 537 |
end; |
184 | 538 |
nx:= nx - dY; |
539 |
ny:= ny + dX; |
|
540 |
end; |
|
541 |
||
542 |
for i:= -HalfWidth to HalfWidth do |
|
543 |
begin |
|
358 | 544 |
X:= nx - dX8; |
545 |
Y:= ny - dY8; |
|
184 | 546 |
for t:= 0 to 7 do |
2666 | 547 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
548 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
549 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
550 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
551 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
552 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
553 |
((tx and LAND_WIDTH_MASK) = 0) and |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
554 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
555 |
((Land[ty, tx] and lfObject) <> 0)) then |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
556 |
begin |
3519 | 557 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 558 |
if despeckle then LandDirty[ty div 32, tx div 32]:= 1; |
559 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
560 |
LandPixels[ty, tx]:= cExplosionBorderColor |
|
561 |
else LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
|
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
562 |
end |
2666 | 563 |
end; |
184 | 564 |
X:= nx; |
565 |
Y:= ny; |
|
566 |
for t:= 0 to ticks do |
|
567 |
begin |
|
568 |
X:= X + dX; |
|
569 |
Y:= Y + dY; |
|
351 | 570 |
tx:= hwRound(X); |
571 |
ty:= hwRound(Y); |
|
3519 | 572 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and ((Land[ty, tx] and lfIndestructible) = 0) then |
2647 | 573 |
begin |
5480 | 574 |
if (cReducedQuality and rqBlurryLand) = 0 then |
575 |
begin |
|
576 |
by:= ty; bx:= tx; |
|
577 |
end |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
578 |
else |
5480 | 579 |
begin |
580 |
by:= ty div 2; bx:= tx div 2; |
|
581 |
end; |
|
582 |
if ((Land[ty, tx] and lfBasic) <> 0) and ((LandPixels[by,bx] and AMask) shr AShift = 255) and not disableLandBack then |
|
583 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
|
584 |
else if ((Land[ty, tx] and lfObject) <> 0) or (disableLandBack and ((Land[ty, tx] and lfIndestructible) = 0)) or ((LandPixels[by,bx] and AMask) shr AShift < 255) then |
|
585 |
LandPixels[by, bx]:= 0; |
|
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
586 |
|
2647 | 587 |
Land[ty, tx]:= 0; |
588 |
end |
|
184 | 589 |
end; |
590 |
for t:= 0 to 7 do |
|
2666 | 591 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
592 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
593 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
594 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
595 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
596 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
597 |
((tx and LAND_WIDTH_MASK) = 0) and |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
598 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
599 |
((Land[ty, tx] and lfObject) <> 0)) then |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
600 |
begin |
3519 | 601 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 602 |
if despeckle then LandDirty[ty div 32, tx div 32]:= 1; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
603 |
if (cReducedQuality and rqBlurryLand) = 0 then |
5332 | 604 |
LandPixels[ty, tx]:= cExplosionBorderColor |
605 |
else LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
|
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
606 |
end |
2666 | 607 |
end; |
184 | 608 |
nx:= nx - dY; |
609 |
ny:= ny + dX; |
|
610 |
end; |
|
611 |
||
612 |
for i:= 0 to 7 do |
|
613 |
begin |
|
358 | 614 |
X:= nx - dX8; |
615 |
Y:= ny - dY8; |
|
184 | 616 |
for t:= -8 to ticks + 8 do |
2666 | 617 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
618 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
619 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
620 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
621 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
622 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
623 |
((tx and LAND_WIDTH_MASK) = 0) and |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
624 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
625 |
((Land[ty, tx] and lfObject) <> 0)) then |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
626 |
begin |
3519 | 627 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 628 |
if despeckle then LandDirty[ty div 32, tx div 32]:= 1; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
629 |
if (cReducedQuality and rqBlurryLand) = 0 then |
5332 | 630 |
LandPixels[ty, tx]:= cExplosionBorderColor |
631 |
else LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
|
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
632 |
end |
2666 | 633 |
end; |
184 | 634 |
nx:= nx - dY; |
635 |
ny:= ny + dX; |
|
636 |
end; |
|
637 |
||
4374 | 638 |
tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0); |
639 |
ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0); |
|
640 |
ddx:= Min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx; |
|
641 |
ddy:= Min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty; |
|
1809 | 642 |
|
643 |
UpdateLandTexture(tx, ddx, ty, ddy) |
|
184 | 644 |
end; |
645 |
||
4886 | 646 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
2235 | 647 |
var X, Y, bpp, h, w, row, col, numFramesFirstCol: LongInt; |
409 | 648 |
p: PByteArray; |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
649 |
Image: PSDL_Surface; |
409 | 650 |
begin |
2235 | 651 |
numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height; |
652 |
||
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
653 |
TryDo(SpritesData[Obj].Surface <> nil, 'Assert SpritesData[Obj].Surface failed', true); |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
654 |
Image:= SpritesData[Obj].Surface; |
409 | 655 |
w:= SpritesData[Obj].Width; |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
656 |
h:= SpritesData[Obj].Height; |
2235 | 657 |
row:= Frame mod numFramesFirstCol; |
658 |
col:= Frame div numFramesFirstCol; |
|
409 | 659 |
|
660 |
if SDL_MustLock(Image) then |
|
661 |
SDLTry(SDL_LockSurface(Image) >= 0, true); |
|
662 |
||
663 |
bpp:= Image^.format^.BytesPerPixel; |
|
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
664 |
TryDo(bpp = 4, 'It should be 32 bpp sprite', true); |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
665 |
// Check that sprite fits free space |
2236 | 666 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 667 |
case bpp of |
668 |
4: for y:= 0 to Pred(h) do |
|
669 |
begin |
|
670 |
for x:= 0 to Pred(w) do |
|
671 |
if PLongword(@(p^[x * 4]))^ <> 0 then |
|
3749 | 672 |
if ((cpY + y) <= Longint(topY)) or |
673 |
((cpY + y) >= LAND_HEIGHT) or |
|
674 |
((cpX + x) <= Longint(leftX)) or |
|
675 |
((cpX + x) >= Longint(rightX)) or |
|
409 | 676 |
(Land[cpY + y, cpX + x] <> 0) then |
677 |
begin |
|
678 |
if SDL_MustLock(Image) then |
|
679 |
SDL_UnlockSurface(Image); |
|
680 |
exit(false) |
|
681 |
end; |
|
682 |
p:= @(p^[Image^.pitch]); |
|
683 |
end; |
|
684 |
end; |
|
685 |
||
520 | 686 |
TryPlaceOnLand:= true; |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
687 |
if not doPlace then |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
688 |
begin |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
689 |
if SDL_MustLock(Image) then |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
690 |
SDL_UnlockSurface(Image); |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
691 |
exit |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
692 |
end; |
520 | 693 |
|
409 | 694 |
// Checked, now place |
2236 | 695 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 696 |
case bpp of |
697 |
4: for y:= 0 to Pred(h) do |
|
698 |
begin |
|
699 |
for x:= 0 to Pred(w) do |
|
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
700 |
if PLongword(@(p^[x * 4]))^ <> 0 then |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
701 |
begin |
4886 | 702 |
if indestructible then |
703 |
Land[cpY + y, cpX + x]:= lfIndestructible |
|
704 |
else |
|
705 |
Land[cpY + y, cpX + x]:= lfObject; |
|
3596 | 706 |
if (cReducedQuality and rqBlurryLand) = 0 then |
707 |
LandPixels[cpY + y, cpX + x]:= PLongword(@(p^[x * 4]))^ |
|
708 |
else |
|
709 |
LandPixels[(cpY + y) div 2, (cpX + x) div 2]:= PLongword(@(p^[x * 4]))^ |
|
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
710 |
end; |
409 | 711 |
p:= @(p^[Image^.pitch]); |
712 |
end; |
|
713 |
end; |
|
714 |
if SDL_MustLock(Image) then |
|
715 |
SDL_UnlockSurface(Image); |
|
716 |
||
4374 | 717 |
x:= Max(cpX, leftX); |
718 |
w:= Min(cpX + Image^.w, LAND_WIDTH) - x; |
|
719 |
y:= Max(cpY, topY); |
|
720 |
h:= Min(cpY + Image^.h, LAND_HEIGHT) - y; |
|
1807 | 721 |
UpdateLandTexture(x, w, y, h) |
409 | 722 |
end; |
723 |
||
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
724 |
// was experimenting with applying as damage occurred. |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
725 |
function Despeckle(X, Y: LongInt; gfxOnly: boolean): LongWord; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
726 |
var nx, ny, i, j, c, xx, yy: LongInt; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
727 |
pixelsweep: boolean; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
728 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
729 |
if (cReducedQuality and rqBlurryLand) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
730 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
731 |
xx:= X; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
732 |
yy:= Y; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
733 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
734 |
else |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
735 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
736 |
xx:= X div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
737 |
yy:= Y div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
738 |
end; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
739 |
pixelsweep:= ((Land[Y, X] and $FF00) = 0) and (LandPixels[yy, xx] <> 0); |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
740 |
if not pixelsweep and gfxOnly then exit(0); |
5364
30752b2e99b3
Sweep all pixels at 0 or 1 neighbours, whether damaged or not. Intended to handled output of Smooth, might be nice to cut down on the counting somehow though.
nemo
parents:
5349
diff
changeset
|
741 |
if ((Land[Y, X] > 255) and ((Land[Y, X] and lfIndestructible) = 0)) or pixelsweep then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
742 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
743 |
c:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
744 |
for i:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
745 |
for j:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
746 |
if (i <> 0) or (j <> 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
747 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
748 |
ny:= Y + i; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
749 |
nx:= X + j; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
750 |
if ((ny and LAND_HEIGHT_MASK) = 0) and ((nx and LAND_WIDTH_MASK) = 0) then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
751 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
752 |
if pixelsweep then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
753 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
754 |
if ((cReducedQuality and rqBlurryLand) <> 0) then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
755 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
756 |
nx:= nx div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
757 |
ny:= ny div 2 |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
758 |
end; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
759 |
if LandPixels[ny, nx] <> 0 then inc(c); |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
760 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
761 |
else if Land[ny, nx] > 255 then inc(c); |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
762 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
763 |
end; |
5364
30752b2e99b3
Sweep all pixels at 0 or 1 neighbours, whether damaged or not. Intended to handled output of Smooth, might be nice to cut down on the counting somehow though.
nemo
parents:
5349
diff
changeset
|
764 |
if (c < 2) or |
30752b2e99b3
Sweep all pixels at 0 or 1 neighbours, whether damaged or not. Intended to handled output of Smooth, might be nice to cut down on the counting somehow though.
nemo
parents:
5349
diff
changeset
|
765 |
((c < 4) and (((Land[Y, X] and lfDamaged) <> 0) or pixelsweep)) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
766 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
767 |
if ((Land[Y, X] and lfBasic) <> 0) and not disableLandBack then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
768 |
LandPixels[yy, xx]:= LandBackPixel(X, Y) |
4686
3682db294dae
remove all screwing about with uLandGraphics - have not found a way to properly handle LandBackTex through despeckling or fill checks that does not result in ugly fire damage or wiped out landbacktex. Would rather some snowflakes lines than that.
nemo
parents:
4659
diff
changeset
|
769 |
else |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
770 |
LandPixels[yy, xx]:= 0; |
3595
341e407e3754
partially removing DOWNSCALE ifdef -- only two remain and their removal requires dynamic allocation (btw this breaks low quality mode)
koda
parents:
3554
diff
changeset
|
771 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
772 |
Land[Y, X]:= 0; |
5480 | 773 |
if not pixelsweep then exit(1) |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
774 |
else exit(2) |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
775 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
776 |
end; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
777 |
Despeckle:= 0 |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
778 |
end; |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
779 |
|
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
780 |
procedure Smooth(X, Y: LongInt); |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
781 |
begin |
5261 | 782 |
// a bit of AA for explosions |
5274 | 783 |
if (Land[Y, X] = 0) and (Y > topY+1) and |
5261 | 784 |
(Y < LAND_HEIGHT-2) and (X>leftX+1) and (X<rightX-1) then |
785 |
begin |
|
786 |
if ((((Land[y, x-1] and lfDamaged) <> 0) and (((Land[y+1,x] and lfDamaged) <> 0)) or ((Land[y-1,x] and lfDamaged) <> 0)) or |
|
787 |
(((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then |
|
788 |
begin |
|
5274 | 789 |
if (cReducedQuality and rqBlurryLand) = 0 then |
790 |
begin |
|
5687
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
791 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then LandPixels[y,x]:= (cExplosionBorderColor and not AMask) or (128 shl AShift) |
5274 | 792 |
else |
793 |
LandPixels[y,x]:= |
|
794 |
(((((LandPixels[y,x] and RMask shr RShift) div 2)+((cExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or |
|
795 |
(((((LandPixels[y,x] and GMask shr GShift) div 2)+((cExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or |
|
796 |
(((((LandPixels[y,x] and BMask shr BShift) div 2)+((cExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift) |
|
797 |
end; |
|
5687
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
798 |
if (Land[y, x-1] = lfObject) then Land[y,x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
799 |
else if (Land[y, x+1] = lfObject) then Land[y,x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
800 |
else Land[y,x]:= lfBasic; |
5261 | 801 |
end |
802 |
else if ((((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0)) or |
|
803 |
(((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) or |
|
804 |
(((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0)) or |
|
805 |
(((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) or |
|
806 |
(((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) or |
|
807 |
(((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) or |
|
808 |
(((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0)) or |
|
809 |
(((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0))) then |
|
810 |
begin |
|
5274 | 811 |
if (cReducedQuality and rqBlurryLand) = 0 then |
812 |
begin |
|
5687
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
813 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then LandPixels[y,x]:= (cExplosionBorderColor and not AMask) or (64 shl AShift) |
5274 | 814 |
else |
815 |
LandPixels[y,x]:= |
|
816 |
(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((cExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or |
|
817 |
(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((cExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or |
|
818 |
(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((cExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift) |
|
819 |
end; |
|
5687
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
820 |
if (Land[y, x-1] = lfObject) then Land[y, x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
821 |
else if (Land[y, x+1] = lfObject) then Land[y, x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
822 |
else if (Land[y+1, x] = lfObject) then Land[y, x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
823 |
else if (Land[y-1, x] = lfObject) then Land[y, x]:= lfObject |
fac606654317
Die speckles, round N. Check that alpha is not basically empty while blending, try to match the damaged land type.
nemo
parents:
5480
diff
changeset
|
824 |
else Land[y,x]:= lfBasic |
5261 | 825 |
end |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
826 |
end |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
827 |
end; |
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
828 |
|
1792 | 829 |
function SweepDirty: boolean; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
830 |
var x, y, xx, yy, ty, tx, d: LongInt; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
831 |
bRes, updateBlock, resweepCol, resweepGfx, gfxOnly, recheck, firstpass: boolean; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
832 |
begin |
2695 | 833 |
bRes:= false; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
834 |
reCheck:= true; |
1792 | 835 |
|
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
836 |
while recheck do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
837 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
838 |
recheck:= false; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
839 |
for y:= 0 to LAND_HEIGHT div 32 - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
840 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
841 |
for x:= 0 to LAND_WIDTH div 32 - 1 do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
842 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
843 |
if LandDirty[y, x] <> 0 then |
2167
4e9ad395c1d1
Loop sweeping to avoid stray pixels. Avoided at first hoping there was a cleverer approach. Fortunately sweep is infrequent.
nemo
parents:
1892
diff
changeset
|
844 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
845 |
updateBlock:= false; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
846 |
resweepCol:= true; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
847 |
resweepGfx:= true; |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
848 |
firstpass:= true; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
849 |
ty:= y * 32; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
850 |
tx:= x * 32; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
851 |
while(resweepCol or resweepGfx) do |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
852 |
begin |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
853 |
gfxOnly:= resweepGfx and not resweepCol; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
854 |
resweepCol:= false; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
855 |
resweepGfx:= false; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
856 |
for yy:= ty to ty + 31 do |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
857 |
for xx:= tx to tx + 31 do |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
858 |
begin |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
859 |
d:= Despeckle(xx, yy, gfxOnly); |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
860 |
if d <> 0 then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
861 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
862 |
bRes:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
863 |
updateBlock:= true; |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
864 |
if d = 1 then resweepCol:= true |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
865 |
else resweepGfx:= true; |
5386 | 866 |
if d = 1 then |
5384
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
867 |
if (yy = ty) and (y > 0) then |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
868 |
begin |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
869 |
LandDirty[y-1, x]:= 1; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
870 |
recheck:= true; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
871 |
end |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
872 |
else if (yy = ty+31) and (y < LAND_HEIGHT div 32 - 1) then |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
873 |
begin |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
874 |
LandDirty[y+1, x]:= 1; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
875 |
recheck:= true; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
876 |
end; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
877 |
if (xx = tx) and (x > 0) then |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
878 |
begin |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
879 |
LandDirty[y, x-1]:= 1; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
880 |
recheck:= true; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
881 |
end |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
882 |
else if (xx = tx+31) and (x < LAND_WIDTH div 32 - 1) then |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
883 |
begin |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
884 |
LandDirty[y, x+1]:= 1; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
885 |
recheck:= true; |
83d3b50d7e24
separate landpixels/land despeckling results to avoid desyncing on blurry land due to extra despeckling passes. right now, this does mean landpixels edge-of-block recheck is not done
nemo
parents:
5364
diff
changeset
|
886 |
end |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
887 |
end; |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
888 |
if firstpass then Smooth(xx,yy); |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
889 |
end; |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
890 |
firstpass:= false |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
891 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
892 |
if updateBlock then UpdateLandTexture(tx, 32, ty, 32); |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
893 |
LandDirty[y, x]:= 0; |
2167
4e9ad395c1d1
Loop sweeping to avoid stray pixels. Avoided at first hoping there was a cleverer approach. Fortunately sweep is infrequent.
nemo
parents:
1892
diff
changeset
|
894 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
895 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
896 |
end; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
897 |
end; |
1792 | 898 |
|
2695 | 899 |
SweepDirty:= bRes; |
1738
00e8dadce69a
Add nemo's depixeling patch. Still needs some polishing for the case when we delete pixel on which hedgehog stays
unc0rr
parents:
1066
diff
changeset
|
900 |
end; |
184 | 901 |
|
2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2236
diff
changeset
|
902 |
// Return true if outside of land or not the value tested, used right now for some X/Y movement that does not use normal hedgehog movement in GSHandlers.inc |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
903 |
function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean; |
2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2236
diff
changeset
|
904 |
begin |
3509
d72c2219595d
Make land types flagged (to allow stacking future attributes such as indestructible ice, but also for a damaged flag)
nemo
parents:
3236
diff
changeset
|
905 |
CheckLandValue:= ((X and LAND_WIDTH_MASK <> 0) or (Y and LAND_HEIGHT_MASK <> 0)) or ((Land[Y, X] and LandFlag) = 0) |
2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2236
diff
changeset
|
906 |
end; |
4367 | 907 |
|
908 |
function LandBackPixel(x, y: LongInt): LongWord; |
|
909 |
var p: PLongWordArray; |
|
910 |
begin |
|
911 |
if LandBackSurface = nil then LandBackPixel:= 0 |
|
912 |
else |
|
913 |
begin |
|
914 |
p:= LandBackSurface^.pixels; |
|
915 |
LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000; |
|
916 |
end |
|
917 |
end; |
|
918 |
||
919 |
||
184 | 920 |
end. |