author | nemo |
Sun, 20 Mar 2011 12:52:36 -0400 | |
changeset 5031 | e26f430be1ed |
parent 4976 | 088d40d8aba2 |
child 5041 | 3dc6ad20cbfe |
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; |
b9ca1bfca24f
complete the replacement of init/free wrappers for every unit
koda
parents:
2695
diff
changeset
|
32 |
function Despeckle(X, Y: LongInt): boolean; |
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
|
33 |
function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean; |
4377 | 34 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
371 | 35 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
36 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
|
37 |
procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword); |
|
511 | 38 |
procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet: boolean); |
4367 | 39 |
function LandBackPixel(x, y: LongInt): LongWord; |
184 | 40 |
|
4886 | 41 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
409 | 42 |
|
184 | 43 |
implementation |
4403 | 44 |
uses SDLh, uLandTexture, uVariables, uUtils, uDebug; |
184 | 45 |
|
4791 | 46 |
function addBgColor(OldColor, NewColor: LongWord): LongWord; |
47 |
// Factor ranges from 0 to 100% NewColor |
|
48 |
var |
|
49 |
oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: Byte; |
|
50 |
begin |
|
51 |
// Get colors |
|
52 |
oAlpha := (OldColor shr 24) and $FF; |
|
53 |
oRed := (OldColor shr 16) and $FF; |
|
54 |
oGreen := (OldColor shr 8) and $FF; |
|
55 |
oBlue := (OldColor) and $FF; |
|
56 |
||
57 |
nAlpha := (NewColor shr 24) and $FF; |
|
58 |
nRed := (NewColor shr 16) and $FF; |
|
59 |
nGreen := (NewColor shr 8) and $FF; |
|
60 |
nBlue := (NewColor) and $FF; |
|
61 |
||
62 |
// Mix colors |
|
63 |
nAlpha := min(255, oAlpha + nAlpha); |
|
64 |
nRed := ((oRed * oAlpha) + (nRed * (255-oAlpha))) div 255; |
|
65 |
nGreen := ((oGreen * oAlpha) + (nGreen * (255-oAlpha))) div 255; |
|
66 |
nBlue := ((oBlue * oAlpha) + (nBlue * (255-oAlpha))) div 255; |
|
67 |
||
68 |
addBgColor := (nAlpha shl 24) or (nRed shl 16) or (nGreen shl 8) or (nBlue); |
|
69 |
end; |
|
70 |
||
371 | 71 |
procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword); |
72 |
var i: LongInt; |
|
184 | 73 |
begin |
1753 | 74 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 75 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3519 | 76 |
if (Land[y + dy, i] and lfIndestructible) = 0 then |
1753 | 77 |
Land[y + dy, i]:= Value; |
78 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 79 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3519 | 80 |
if (Land[y - dy, i] and lfIndestructible) = 0 then |
1753 | 81 |
Land[y - dy, i]:= Value; |
82 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 83 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3519 | 84 |
if (Land[y + dx, i] and lfIndestructible) = 0 then |
1753 | 85 |
Land[y + dx, i]:= Value; |
86 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
|
4374 | 87 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3519 | 88 |
if (Land[y - dx, i] and lfIndestructible) = 0 then |
1753 | 89 |
Land[y - dx, i]:= Value; |
184 | 90 |
end; |
91 |
||
511 | 92 |
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
|
93 |
var i: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
94 |
begin |
511 | 95 |
if not doSet then |
96 |
begin |
|
1753 | 97 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 98 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
1861 | 99 |
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 | 100 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 101 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
1861 | 102 |
if (Land[y - dy, i] > 0) and (Land[y - dy, i] < 256) then dec(Land[y - dy, i]); |
1753 | 103 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 104 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
1861 | 105 |
if (Land[y + dx, i] > 0) and (Land[y + dx, i] < 256) then dec(Land[y + dx, i]); |
1753 | 106 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 107 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
1861 | 108 |
if (Land[y - dx, i] > 0) and (Land[y - dx, i] < 256) then dec(Land[y - dx, i]); |
511 | 109 |
end else |
110 |
begin |
|
1753 | 111 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 112 |
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
|
113 |
if (Land[y + dy, i] < 256) then |
1861 | 114 |
inc(Land[y + dy, i]); |
1753 | 115 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
4374 | 116 |
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
|
117 |
if (Land[y - dy, i] < 256) then |
1861 | 118 |
inc(Land[y - dy, i]); |
1753 | 119 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 120 |
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
|
121 |
if (Land[y + dx, i] < 256) then |
1861 | 122 |
inc(Land[y + dx, i]); |
1753 | 123 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
4374 | 124 |
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
|
125 |
if (Land[y - dx, i] < 256) then |
1861 | 126 |
inc(Land[y - dx, i]); |
511 | 127 |
end |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
128 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
129 |
|
371 | 130 |
procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword); |
131 |
var dx, dy, d: LongInt; |
|
184 | 132 |
begin |
133 |
dx:= 0; |
|
134 |
dy:= Radius; |
|
135 |
d:= 3 - 2 * Radius; |
|
136 |
while (dx < dy) do |
|
137 |
begin |
|
138 |
FillCircleLines(x, y, dx, dy, Value); |
|
139 |
if (d < 0) |
|
140 |
then d:= d + 4 * dx + 6 |
|
141 |
else begin |
|
142 |
d:= d + 4 * (dx - dy) + 10; |
|
143 |
dec(dy) |
|
144 |
end; |
|
145 |
inc(dx) |
|
146 |
end; |
|
147 |
if (dx = dy) then FillCircleLines(x, y, dx, dy, Value); |
|
148 |
end; |
|
149 |
||
511 | 150 |
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
|
151 |
var dx, dy, d: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
152 |
begin |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
153 |
dx:= 0; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
154 |
dy:= Radius; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
155 |
d:= 3 - 2 * Radius; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
156 |
while (dx < dy) do |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
157 |
begin |
511 | 158 |
ChangeCircleLines(x, y, dx, dy, doSet); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
159 |
if (d < 0) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
160 |
then d:= d + 4 * dx + 6 |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
161 |
else begin |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
162 |
d:= d + 4 * (dx - dy) + 10; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
163 |
dec(dy) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
164 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
165 |
inc(dx) |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
166 |
end; |
511 | 167 |
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
|
168 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
169 |
|
2603 | 170 |
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
|
171 |
var i, t: LongInt; |
184 | 172 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
173 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
174 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 175 |
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
|
176 |
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
|
177 |
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
|
178 |
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
|
179 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
180 |
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
|
181 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
182 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
183 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 184 |
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
|
185 |
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
|
186 |
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
|
187 |
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
|
188 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
189 |
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
|
190 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
191 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
192 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 193 |
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
|
194 |
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
|
195 |
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
|
196 |
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
|
197 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
198 |
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
|
199 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
200 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
201 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 202 |
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
|
203 |
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
|
204 |
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
|
205 |
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
|
206 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
207 |
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
|
208 |
|
184 | 209 |
end; |
210 |
||
3689 | 211 |
function FillLandCircleLinesBG(x, y, dx, dy: LongInt): Longword; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
212 |
var i, t: LongInt; |
3689 | 213 |
cnt: Longword; |
2647 | 214 |
begin |
3689 | 215 |
cnt:= 0; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
216 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
217 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 218 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
219 |
if ((Land[t, i] and lfBasic) <> 0) and not disableLandBack then |
3689 | 220 |
begin |
221 |
inc(cnt); |
|
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
|
222 |
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
|
223 |
LandPixels[t, i]:= LandBackPixel(i, t) |
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
|
224 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
225 |
LandPixels[t div 2, i div 2]:= LandBackPixel(i, t) |
3689 | 226 |
end |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
227 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
228 |
if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
229 |
if (cReducedQuality and rqBlurryLand) = 0 then |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
230 |
LandPixels[t, i]:= 0 |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
231 |
else |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
232 |
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
|
233 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
234 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
235 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 236 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
237 |
if ((Land[t, i] and lfBasic) <> 0) and not disableLandBack then |
3689 | 238 |
begin |
239 |
inc(cnt); |
|
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
|
240 |
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
|
241 |
LandPixels[t, i]:= LandBackPixel(i, t) |
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
|
242 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
243 |
LandPixels[t div 2, i div 2]:= LandBackPixel(i, t) |
3689 | 244 |
end |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
245 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
246 |
if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
247 |
if (cReducedQuality and rqBlurryLand) = 0 then |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
248 |
LandPixels[t, i]:= 0 |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
249 |
else |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
250 |
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
|
251 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
252 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
253 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 254 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
255 |
if ((Land[t, i] and lfBasic) <> 0) and not disableLandBack then |
3689 | 256 |
begin |
257 |
inc(cnt); |
|
258 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
259 |
LandPixels[t, i]:= LandBackPixel(i, t) |
|
3697 | 260 |
else |
3689 | 261 |
LandPixels[t div 2, i div 2]:= LandBackPixel(i, t) |
262 |
end |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
263 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
264 |
if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
265 |
if (cReducedQuality and rqBlurryLand) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
266 |
LandPixels[t, i]:= 0 |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
267 |
else |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
268 |
LandPixels[t div 2, i div 2]:= 0; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
269 |
|
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
270 |
t:= y - dx; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
271 |
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
|
272 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
273 |
if ((Land[t, i] and lfBasic) <> 0) and not disableLandBack then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
274 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
275 |
inc(cnt); |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
276 |
if (cReducedQuality and rqBlurryLand) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
277 |
LandPixels[t, i]:= LandBackPixel(i, t) |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
278 |
else |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
279 |
LandPixels[t div 2, i div 2]:= LandBackPixel(i, t) |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
280 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
281 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
282 |
if ((Land[t, i] and lfObject) <> 0) or (disableLandBack and ((Land[t, i] and lfIndestructible) = 0)) then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
283 |
if (cReducedQuality and rqBlurryLand) = 0 then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
284 |
LandPixels[t, i]:= 0 |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
285 |
else |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
286 |
LandPixels[t div 2, i div 2]:= 0; |
3689 | 287 |
FillLandCircleLinesBG:= cnt; |
2647 | 288 |
end; |
289 |
||
371 | 290 |
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
|
291 |
var i, t: LongInt; |
184 | 292 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
293 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
294 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 295 |
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
|
296 |
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
|
297 |
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
|
298 |
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
|
299 |
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
|
300 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
301 |
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
|
302 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
303 |
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
|
304 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
305 |
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
|
306 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
307 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
308 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
309 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 310 |
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
|
311 |
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
|
312 |
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
|
313 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 314 |
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
|
315 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
316 |
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
|
317 |
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
|
318 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
319 |
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
|
320 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
321 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
322 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
323 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 324 |
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
|
325 |
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
|
326 |
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
|
327 |
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
|
328 |
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
|
329 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
330 |
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
|
331 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
332 |
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
|
333 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
334 |
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
|
335 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
336 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
337 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
338 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 339 |
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
|
340 |
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
|
341 |
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
|
342 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 343 |
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
|
344 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
345 |
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
|
346 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
347 |
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
|
348 |
//Despeckle(i, y - dy); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
349 |
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
|
350 |
end; |
184 | 351 |
end; |
352 |
||
3689 | 353 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
2603 | 354 |
var dx, dy, ty, tx, d: LongInt; |
3689 | 355 |
cnt: Longword; |
184 | 356 |
begin |
2647 | 357 |
|
358 |
// draw background land texture |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
359 |
begin |
3689 | 360 |
cnt:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
361 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
362 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
363 |
d:= 3 - 2 * Radius; |
2647 | 364 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
365 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
366 |
begin |
3689 | 367 |
inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
368 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
369 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
370 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
371 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
372 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
373 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
374 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
375 |
end; |
3689 | 376 |
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
|
377 |
end; |
2647 | 378 |
|
379 |
// draw a hole in land |
|
2733 | 380 |
if Radius > 20 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
381 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
382 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
383 |
dy:= Radius - 15; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
384 |
d:= 3 - 2 * dy; |
2647 | 385 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
386 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
387 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
388 |
FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
389 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
390 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
391 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
392 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
393 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
394 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
395 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
396 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
397 |
if (dx = dy) then FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
398 |
end; |
2647 | 399 |
|
1849 | 400 |
// 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
|
401 |
FillRoundInLand(X, Y, Radius, 0); |
2647 | 402 |
|
403 |
// draw explosion border |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
404 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
405 |
inc(Radius, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
406 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
407 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
408 |
d:= 3 - 2 * Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
409 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
410 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
411 |
FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
412 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
413 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
414 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
415 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
416 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
417 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
418 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
419 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
420 |
if (dx = dy) then FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
421 |
end; |
351 | 422 |
|
4374 | 423 |
tx:= Max(X - Radius - 1, 0); |
424 |
dx:= Min(X + Radius + 1, LAND_WIDTH) - tx; |
|
425 |
ty:= Max(Y - Radius - 1, 0); |
|
426 |
dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty; |
|
3689 | 427 |
UpdateLandTexture(tx, dx, ty, dy); |
428 |
DrawExplosion:= cnt |
|
184 | 429 |
end; |
430 |
||
371 | 431 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
184 | 432 |
var tx, ty, i: LongInt; |
433 |
begin |
|
434 |
for i:= 0 to Pred(Count) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
435 |
begin |
4374 | 436 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
437 |
for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do |
|
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
438 |
if ((Land[ty, tx] and lfBasic) <> 0) and not disableLandBack 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
|
439 |
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
|
440 |
LandPixels[ty, tx]:= LandBackPixel(tx, ty) |
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
|
441 |
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
|
442 |
LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty) |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
443 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
444 |
if ((Land[ty, tx] and lfObject) <> 0) or (disableLandBack and ((Land[ty, tx] and lfIndestructible) = 0)) then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
445 |
if (cReducedQuality and rqBlurryLand) = 0 then |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
446 |
LandPixels[ty, tx]:= 0 |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
447 |
else |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
448 |
LandPixels[ty div 2, tx div 2]:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
449 |
inc(y, dY) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
450 |
end; |
184 | 451 |
|
452 |
inc(Radius, 4); |
|
351 | 453 |
dec(y, Count * dY); |
184 | 454 |
|
455 |
for i:= 0 to Pred(Count) do |
|
456 |
begin |
|
4374 | 457 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
458 |
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
|
459 |
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
|
460 |
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
|
461 |
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
|
462 |
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
|
463 |
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
|
464 |
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
|
465 |
|
3519 | 466 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
3596 | 467 |
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
|
468 |
end; |
184 | 469 |
inc(y, dY) |
470 |
end; |
|
471 |
||
818 | 472 |
|
1807 | 473 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT) |
184 | 474 |
end; |
475 |
||
476 |
// |
|
477 |
// - (dX, dY) - direction, vector of length = 0.5 |
|
478 |
// |
|
371 | 479 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
358 | 480 |
var nx, ny, dX8, dY8: hwFloat; |
1809 | 481 |
i, t, tx, ty, stX, stY, ddy, ddx: Longint; |
184 | 482 |
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
|
483 |
stY:= hwRound(Y); |
1809 | 484 |
stX:= hwRound(X); |
772
e8d530ca77be
Don't update all land texture when drawing tunnel (saves video throughput)
unc0rr
parents:
769
diff
changeset
|
485 |
|
184 | 486 |
nx:= X + dY * (HalfWidth + 8); |
487 |
ny:= Y - dX * (HalfWidth + 8); |
|
488 |
||
358 | 489 |
dX8:= dX * 8; |
490 |
dY8:= dY * 8; |
|
184 | 491 |
for i:= 0 to 7 do |
492 |
begin |
|
358 | 493 |
X:= nx - dX8; |
494 |
Y:= ny - dY8; |
|
184 | 495 |
for t:= -8 to ticks + 8 do |
2666 | 496 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
497 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
498 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
499 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
500 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
501 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
502 |
((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
|
503 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
504 |
((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
|
505 |
begin |
3519 | 506 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
507 |
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
|
508 |
LandPixels[ty, tx]:= cExplosionBorderColor |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
509 |
else |
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
|
510 |
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
|
511 |
end |
2666 | 512 |
end; |
184 | 513 |
nx:= nx - dY; |
514 |
ny:= ny + dX; |
|
515 |
end; |
|
516 |
||
517 |
for i:= -HalfWidth to HalfWidth do |
|
518 |
begin |
|
358 | 519 |
X:= nx - dX8; |
520 |
Y:= ny - dY8; |
|
184 | 521 |
for t:= 0 to 7 do |
2666 | 522 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
523 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
524 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
525 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
526 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
527 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
528 |
((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
|
529 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
530 |
((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
|
531 |
begin |
3519 | 532 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
533 |
if (cReducedQuality and rqBlurryLand) = 0 then |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
534 |
LandPixels[ty, tx]:= cExplosionBorderColor |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
535 |
else |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
536 |
LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
537 |
|
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
|
538 |
end |
2666 | 539 |
end; |
184 | 540 |
X:= nx; |
541 |
Y:= ny; |
|
542 |
for t:= 0 to ticks do |
|
543 |
begin |
|
544 |
X:= X + dX; |
|
545 |
Y:= Y + dY; |
|
351 | 546 |
tx:= hwRound(X); |
547 |
ty:= hwRound(Y); |
|
3519 | 548 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and ((Land[ty, tx] and lfIndestructible) = 0) then |
2647 | 549 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
550 |
if ((Land[ty, tx] and lfBasic) <> 0) and not disableLandBack 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
|
551 |
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
|
552 |
LandPixels[ty, tx]:= LandBackPixel(tx, ty) |
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
|
553 |
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
|
554 |
LandPixels[ty div 2, tx div 2]:= LandBackPixel(tx, ty) |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
555 |
else |
4700
e8fd20b2d66b
oops. forgot to check on indestructible in combination with disableLandBack
nemo
parents:
4695
diff
changeset
|
556 |
if ((Land[ty, tx] and lfObject) <> 0) or (disableLandBack and ((Land[ty, tx] and lfIndestructible) = 0)) then |
4640
bc30434ae156
oops. hopefully unbreak maps while still preserving mask behaviour as before (basketball nets etc)
nemo
parents:
4635
diff
changeset
|
557 |
if (cReducedQuality and rqBlurryLand) = 0 then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
558 |
LandPixels[ty, tx]:= 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
|
559 |
else |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
560 |
LandPixels[ty div 2, tx 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
|
561 |
|
2647 | 562 |
Land[ty, tx]:= 0; |
563 |
end |
|
184 | 564 |
end; |
565 |
for t:= 0 to 7 do |
|
2666 | 566 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
567 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
568 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
569 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
570 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
571 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
572 |
((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
|
573 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
574 |
((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
|
575 |
begin |
3519 | 576 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
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
|
577 |
if (cReducedQuality and rqBlurryLand) = 0 then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
578 |
LandPixels[ty, tx]:= 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
|
579 |
else |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
580 |
LandPixels[ty div 2, tx div 2]:= cExplosionBorderColor |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
581 |
|
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
|
582 |
end |
2666 | 583 |
end; |
184 | 584 |
nx:= nx - dY; |
585 |
ny:= ny + dX; |
|
586 |
end; |
|
587 |
||
588 |
for i:= 0 to 7 do |
|
589 |
begin |
|
358 | 590 |
X:= nx - dX8; |
591 |
Y:= ny - dY8; |
|
184 | 592 |
for t:= -8 to ticks + 8 do |
2666 | 593 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
594 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
595 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
596 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
597 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
598 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
599 |
((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
|
600 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
601 |
((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
|
602 |
begin |
3519 | 603 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
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
|
604 |
if (cReducedQuality and rqBlurryLand) = 0 then |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
605 |
LandPixels[ty, tx]:= 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
|
606 |
else |
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
607 |
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
|
608 |
end |
2666 | 609 |
end; |
184 | 610 |
nx:= nx - dY; |
611 |
ny:= ny + dX; |
|
612 |
end; |
|
613 |
||
4374 | 614 |
tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0); |
615 |
ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0); |
|
616 |
ddx:= Min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx; |
|
617 |
ddy:= Min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty; |
|
1809 | 618 |
|
619 |
UpdateLandTexture(tx, ddx, ty, ddy) |
|
184 | 620 |
end; |
621 |
||
4886 | 622 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
2235 | 623 |
var X, Y, bpp, h, w, row, col, numFramesFirstCol: LongInt; |
409 | 624 |
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
|
625 |
Image: PSDL_Surface; |
409 | 626 |
begin |
2235 | 627 |
numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height; |
628 |
||
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
629 |
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
|
630 |
Image:= SpritesData[Obj].Surface; |
409 | 631 |
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
|
632 |
h:= SpritesData[Obj].Height; |
2235 | 633 |
row:= Frame mod numFramesFirstCol; |
634 |
col:= Frame div numFramesFirstCol; |
|
409 | 635 |
|
636 |
if SDL_MustLock(Image) then |
|
637 |
SDLTry(SDL_LockSurface(Image) >= 0, true); |
|
638 |
||
639 |
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
|
640 |
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
|
641 |
// Check that sprite fits free space |
2236 | 642 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 643 |
case bpp of |
644 |
4: for y:= 0 to Pred(h) do |
|
645 |
begin |
|
646 |
for x:= 0 to Pred(w) do |
|
647 |
if PLongword(@(p^[x * 4]))^ <> 0 then |
|
3749 | 648 |
if ((cpY + y) <= Longint(topY)) or |
649 |
((cpY + y) >= LAND_HEIGHT) or |
|
650 |
((cpX + x) <= Longint(leftX)) or |
|
651 |
((cpX + x) >= Longint(rightX)) or |
|
409 | 652 |
(Land[cpY + y, cpX + x] <> 0) then |
653 |
begin |
|
654 |
if SDL_MustLock(Image) then |
|
655 |
SDL_UnlockSurface(Image); |
|
656 |
exit(false) |
|
657 |
end; |
|
658 |
p:= @(p^[Image^.pitch]); |
|
659 |
end; |
|
660 |
end; |
|
661 |
||
520 | 662 |
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
|
663 |
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
|
664 |
begin |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
665 |
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
|
666 |
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
|
667 |
exit |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
668 |
end; |
520 | 669 |
|
409 | 670 |
// Checked, now place |
2236 | 671 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 672 |
case bpp of |
673 |
4: for y:= 0 to Pred(h) do |
|
674 |
begin |
|
675 |
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
|
676 |
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
|
677 |
begin |
4886 | 678 |
if indestructible then |
679 |
Land[cpY + y, cpX + x]:= lfIndestructible |
|
680 |
else |
|
681 |
Land[cpY + y, cpX + x]:= lfObject; |
|
3596 | 682 |
if (cReducedQuality and rqBlurryLand) = 0 then |
683 |
LandPixels[cpY + y, cpX + x]:= PLongword(@(p^[x * 4]))^ |
|
684 |
else |
|
685 |
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
|
686 |
end; |
409 | 687 |
p:= @(p^[Image^.pitch]); |
688 |
end; |
|
689 |
end; |
|
690 |
if SDL_MustLock(Image) then |
|
691 |
SDL_UnlockSurface(Image); |
|
692 |
||
4374 | 693 |
x:= Max(cpX, leftX); |
694 |
w:= Min(cpX + Image^.w, LAND_WIDTH) - x; |
|
695 |
y:= Max(cpY, topY); |
|
696 |
h:= Min(cpY + Image^.h, LAND_HEIGHT) - y; |
|
1807 | 697 |
UpdateLandTexture(x, w, y, h) |
409 | 698 |
end; |
699 |
||
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
700 |
// was experimenting with applying as damage occurred. |
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
|
701 |
function Despeckle(X, Y: LongInt): boolean; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
702 |
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
|
703 |
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
|
704 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
705 |
if (cReducedQuality and rqBlurryLand) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
706 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
707 |
xx:= X; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
708 |
yy:= Y; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
709 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
710 |
else |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
711 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
712 |
xx:= X div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
713 |
yy:= Y div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
714 |
end; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
715 |
pixelsweep:= ((Land[Y, X] and $FF00) = 0) and (LandPixels[yy, xx] <> 0); |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
716 |
if (((Land[Y, X] and lfDamaged) <> 0) 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
|
717 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
718 |
c:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
719 |
for i:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
720 |
for j:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
721 |
if (i <> 0) or (j <> 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
722 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
723 |
ny:= Y + i; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
724 |
nx:= X + j; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
725 |
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
|
726 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
727 |
if pixelsweep then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
728 |
begin |
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 |
nx:= nx div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
732 |
ny:= ny div 2 |
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 |
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
|
735 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
736 |
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
|
737 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
738 |
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
|
739 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
740 |
if c < 4 then // 0-3 neighbours |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
741 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
742 |
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
|
743 |
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
|
744 |
else |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
745 |
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
|
746 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
747 |
Land[Y, X]:= 0; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
748 |
if not pixelsweep then exit(true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
749 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
750 |
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
|
751 |
Despeckle:= false |
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
|
752 |
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
|
753 |
|
1792 | 754 |
function SweepDirty: boolean; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
755 |
var x, y, xx, yy, ty, tx: LongInt; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
756 |
bRes, updateBlock, resweep, recheck: 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
|
757 |
begin |
2695 | 758 |
bRes:= false; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
759 |
reCheck:= true; |
1792 | 760 |
|
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
761 |
while recheck do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
762 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
763 |
recheck:= false; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
764 |
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
|
765 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
766 |
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
|
767 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
768 |
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
|
769 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
770 |
updateBlock:= false; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
771 |
resweep:= true; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
772 |
ty:= y * 32; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
773 |
tx:= x * 32; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
774 |
while(resweep) do |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
775 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
776 |
resweep:= false; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
777 |
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
|
778 |
for xx:= tx to tx + 31 do |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
779 |
if Despeckle(xx, yy) then |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
780 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
781 |
bRes:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
782 |
updateBlock:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
783 |
resweep:= true; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
784 |
if (yy = ty) and (y > 0) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
785 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
786 |
LandDirty[y-1, x]:= 1; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
787 |
recheck:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
788 |
end |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
789 |
else if (yy = ty+31) and (y < LAND_HEIGHT div 32 - 1) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
790 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
791 |
LandDirty[y+1, x]:= 1; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
792 |
recheck:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
793 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
794 |
if (xx = tx) and (x > 0) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
795 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
796 |
LandDirty[y, x-1]:= 1; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
797 |
recheck:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
798 |
end |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
799 |
else if (xx = tx+31) and (x < LAND_WIDTH div 32 - 1) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
800 |
begin |
3601
8a74c9ceaf71
Revert most of optimisation except for some obvious fixes to errors someone or other introduced.
nemo
parents:
3596
diff
changeset
|
801 |
LandDirty[y, x+1]:= 1; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
802 |
recheck:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
803 |
end |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
804 |
end; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
805 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
806 |
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
|
807 |
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
|
808 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
809 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
810 |
end; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
811 |
end; |
1792 | 812 |
|
2695 | 813 |
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
|
814 |
end; |
184 | 815 |
|
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
|
816 |
// 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
|
817 |
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
|
818 |
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
|
819 |
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
|
820 |
end; |
4367 | 821 |
|
822 |
function LandBackPixel(x, y: LongInt): LongWord; |
|
823 |
var p: PLongWordArray; |
|
824 |
begin |
|
825 |
if LandBackSurface = nil then LandBackPixel:= 0 |
|
826 |
else |
|
827 |
begin |
|
828 |
p:= LandBackSurface^.pixels; |
|
829 |
LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000; |
|
830 |
end |
|
831 |
end; |
|
832 |
||
833 |
||
184 | 834 |
end. |