author | unc0rr |
Sun, 13 Nov 2011 13:46:26 +0300 (2011-11-13) | |
changeset 6355 | 734fed7aefd3 |
parent 6132 | 6384c502795f |
child 6453 | 11c578d30bd3 |
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; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
32 |
function Despeckle(X, Y: LongInt): Boolean; |
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 |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
50 |
oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: byte; |
4791 | 51 |
begin |
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
52 |
oAlpha := (OldColor shr AShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
53 |
nAlpha := (NewColor shr AShift); |
5692 | 54 |
// shortcircuit |
55 |
if (oAlpha = 0) or (nAlpha = $FF) then |
|
56 |
begin |
|
57 |
addBgColor:= NewColor; |
|
58 |
exit |
|
59 |
end; |
|
4791 | 60 |
// Get colors |
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
61 |
oRed := (OldColor shr RShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
62 |
oGreen := (OldColor shr GShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
63 |
oBlue := (OldColor shr BShift); |
4791 | 64 |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
65 |
nRed := (NewColor shr RShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
66 |
nGreen := (NewColor shr GShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
67 |
nBlue := (NewColor shr BShift); |
4791 | 68 |
|
69 |
// Mix colors |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
70 |
nRed := min(255,((nRed*nAlpha) div 255) + ((oRed*oAlpha*byte(255-nAlpha)) div 65025)); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
71 |
nGreen := min(255,((nGreen*nAlpha) div 255) + ((oGreen*oAlpha*byte(255-nAlpha)) div 65025)); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
72 |
nBlue := min(255,((nBlue*nAlpha) div 255) + ((oBlue*oAlpha*byte(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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
183 |
if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
192 |
if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
201 |
if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
210 |
if ((Land[t, i] and lfIndestructible) = 0) and (not disableLandBack or (Land[t, i] > 255)) 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
226 |
if (Land[t, i] and lfIndestructible) = 0 then |
5480 | 227 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
228 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
229 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
230 |
by:= t; bx:= i; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
231 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
232 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
233 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
234 |
by:= t div 2; bx:= i div 2; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
235 |
end; |
6355 | 236 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
237 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
238 |
inc(cnt); |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
239 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
240 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
241 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
242 |
LandPixels[by, bx]:= 0 |
5480 | 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
248 |
if (Land[t, i] and lfIndestructible) = 0 then |
5480 | 249 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
250 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
251 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
252 |
by:= t; bx:= i; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
253 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
254 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
255 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
256 |
by:= t div 2; bx:= i div 2; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
257 |
end; |
6355 | 258 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
259 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
260 |
inc(cnt); |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
261 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
262 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
263 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
264 |
LandPixels[by, bx]:= 0 |
5480 | 265 |
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
|
266 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
267 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
268 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 269 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
270 |
if (Land[t, i] and lfIndestructible) = 0 then |
5480 | 271 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
272 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
273 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
274 |
by:= t; bx:= i; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
275 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
276 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
277 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
278 |
by:= t div 2; bx:= i div 2; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
279 |
end; |
6355 | 280 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
281 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
282 |
inc(cnt); |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
283 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
284 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
285 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
286 |
LandPixels[by, bx]:= 0 |
5480 | 287 |
end; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
288 |
t:= y - dx; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
289 |
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
|
290 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
291 |
if (Land[t, i] and lfIndestructible) = 0 then |
5480 | 292 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
293 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
294 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
295 |
by:= t; bx:= i; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
296 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
297 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
298 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
299 |
by:= t div 2; bx:= i div 2; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
300 |
end; |
6355 | 301 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and not (disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
302 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
303 |
inc(cnt); |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
304 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
305 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
306 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
307 |
LandPixels[by, bx]:= 0 |
5480 | 308 |
end; |
3689 | 309 |
FillLandCircleLinesBG:= cnt; |
2647 | 310 |
end; |
311 |
||
371 | 312 |
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
|
313 |
var i, t: LongInt; |
184 | 314 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
315 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
316 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 317 |
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
|
318 |
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
|
319 |
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
|
320 |
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
|
321 |
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
|
322 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
323 |
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
|
324 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
325 |
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
|
326 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
327 |
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
|
328 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
329 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
330 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
331 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 332 |
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
|
333 |
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
|
334 |
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
|
335 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 336 |
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
|
337 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
338 |
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
|
339 |
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
|
340 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
341 |
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
|
342 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
343 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
344 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
345 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 346 |
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
|
347 |
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
|
348 |
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
|
349 |
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
|
350 |
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
|
351 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
352 |
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
|
353 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
354 |
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
|
355 |
//Despeckle(i, t); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
356 |
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
|
357 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
358 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
359 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
360 |
if (t and LAND_HEIGHT_MASK) = 0 then |
4374 | 361 |
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
|
362 |
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
|
363 |
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
|
364 |
if (cReducedQuality and rqBlurryLand) = 0 then |
3697 | 365 |
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
|
366 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
367 |
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
|
368 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
369 |
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
|
370 |
//Despeckle(i, y - dy); |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
371 |
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
|
372 |
end; |
184 | 373 |
end; |
374 |
||
3689 | 375 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
2603 | 376 |
var dx, dy, ty, tx, d: LongInt; |
3689 | 377 |
cnt: Longword; |
184 | 378 |
begin |
2647 | 379 |
|
380 |
// draw background land texture |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
381 |
begin |
3689 | 382 |
cnt:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
383 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
384 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
385 |
d:= 3 - 2 * Radius; |
2647 | 386 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
387 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
388 |
begin |
3689 | 389 |
inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
390 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
391 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
392 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
393 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
394 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
395 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
396 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
397 |
end; |
3689 | 398 |
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
|
399 |
end; |
2647 | 400 |
|
401 |
// draw a hole in land |
|
2733 | 402 |
if Radius > 20 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
403 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
404 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
405 |
dy:= Radius - 15; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
406 |
d:= 3 - 2 * dy; |
2647 | 407 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
408 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
409 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
410 |
FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
411 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
412 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
413 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
414 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
415 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
416 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
417 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
418 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
419 |
if (dx = dy) then FillLandCircleLines0(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
420 |
end; |
2647 | 421 |
|
1849 | 422 |
// 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
|
423 |
FillRoundInLand(X, Y, Radius, 0); |
2647 | 424 |
|
425 |
// draw explosion border |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
426 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
427 |
inc(Radius, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
428 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
429 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
430 |
d:= 3 - 2 * Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
431 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
432 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
433 |
FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
434 |
if (d < 0) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
435 |
then d:= d + 4 * dx + 6 |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
436 |
else begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
437 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
438 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
439 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
440 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
441 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
442 |
if (dx = dy) then FillLandCircleLinesEBC(x, y, dx, dy); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
443 |
end; |
351 | 444 |
|
4374 | 445 |
tx:= Max(X - Radius - 1, 0); |
446 |
dx:= Min(X + Radius + 1, LAND_WIDTH) - tx; |
|
447 |
ty:= Max(Y - Radius - 1, 0); |
|
448 |
dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty; |
|
3689 | 449 |
UpdateLandTexture(tx, dx, ty, dy); |
450 |
DrawExplosion:= cnt |
|
184 | 451 |
end; |
452 |
||
371 | 453 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
5480 | 454 |
var tx, ty, by, bx, i: LongInt; |
184 | 455 |
begin |
456 |
for i:= 0 to Pred(Count) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
457 |
begin |
4374 | 458 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
459 |
for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do |
|
5480 | 460 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
461 |
if (Land[ty, tx] and lfIndestructible) = 0 then |
5480 | 462 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
463 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
464 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
465 |
by:= ty; bx:= tx; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
466 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
467 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
468 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
469 |
by:= ty div 2; bx:= tx div 2; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
470 |
end; |
6355 | 471 |
if ((Land[ty, tx] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
472 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
473 |
else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
474 |
LandPixels[by, bx]:= 0 |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
475 |
end |
5480 | 476 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
477 |
inc(y, dY) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
478 |
end; |
184 | 479 |
|
480 |
inc(Radius, 4); |
|
351 | 481 |
dec(y, Count * dY); |
184 | 482 |
|
483 |
for i:= 0 to Pred(Count) do |
|
484 |
begin |
|
4374 | 485 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
486 |
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
|
487 |
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
|
488 |
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
|
489 |
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
|
490 |
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
|
491 |
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
|
492 |
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
|
493 |
|
3519 | 494 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
3596 | 495 |
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
|
496 |
end; |
184 | 497 |
inc(y, dY) |
498 |
end; |
|
499 |
||
818 | 500 |
|
1807 | 501 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT) |
184 | 502 |
end; |
503 |
||
504 |
// |
|
505 |
// - (dX, dY) - direction, vector of length = 0.5 |
|
506 |
// |
|
371 | 507 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
358 | 508 |
var nx, ny, dX8, dY8: hwFloat; |
5480 | 509 |
i, t, tx, ty, by, bx, stX, stY, ddy, ddx: Longint; |
5332 | 510 |
despeckle : Boolean; |
184 | 511 |
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
|
512 |
stY:= hwRound(Y); |
1809 | 513 |
stX:= hwRound(X); |
772
e8d530ca77be
Don't update all land texture when drawing tunnel (saves video throughput)
unc0rr
parents:
769
diff
changeset
|
514 |
|
5332 | 515 |
despeckle:= HalfWidth > 1; |
516 |
||
184 | 517 |
nx:= X + dY * (HalfWidth + 8); |
518 |
ny:= Y - dX * (HalfWidth + 8); |
|
519 |
||
358 | 520 |
dX8:= dX * 8; |
521 |
dY8:= dY * 8; |
|
184 | 522 |
for i:= 0 to 7 do |
523 |
begin |
|
358 | 524 |
X:= nx - dX8; |
525 |
Y:= ny - dY8; |
|
184 | 526 |
for t:= -8 to ticks + 8 do |
2666 | 527 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
528 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
529 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
530 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
531 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
532 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
533 |
((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
|
534 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
535 |
((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
|
536 |
begin |
5887 | 537 |
if despeckle then |
538 |
begin |
|
539 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
|
540 |
LandDirty[ty div 32, tx div 32]:= 1 |
|
541 |
end; |
|
5332 | 542 |
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
|
543 |
LandPixels[ty, tx]:= cExplosionBorderColor |
5332 | 544 |
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
|
545 |
end |
2666 | 546 |
end; |
184 | 547 |
nx:= nx - dY; |
548 |
ny:= ny + dX; |
|
549 |
end; |
|
550 |
||
551 |
for i:= -HalfWidth to HalfWidth do |
|
552 |
begin |
|
358 | 553 |
X:= nx - dX8; |
554 |
Y:= ny - dY8; |
|
184 | 555 |
for t:= 0 to 7 do |
2666 | 556 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
557 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
558 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
559 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
560 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
561 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
562 |
((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
|
563 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
564 |
((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
|
565 |
begin |
3519 | 566 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 567 |
if despeckle then LandDirty[ty div 32, tx div 32]:= 1; |
568 |
if (cReducedQuality and rqBlurryLand) = 0 then |
|
569 |
LandPixels[ty, tx]:= cExplosionBorderColor |
|
570 |
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
|
571 |
end |
2666 | 572 |
end; |
184 | 573 |
X:= nx; |
574 |
Y:= ny; |
|
575 |
for t:= 0 to ticks do |
|
576 |
begin |
|
577 |
X:= X + dX; |
|
578 |
Y:= Y + dY; |
|
351 | 579 |
tx:= hwRound(X); |
580 |
ty:= hwRound(Y); |
|
3519 | 581 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and ((Land[ty, tx] and lfIndestructible) = 0) then |
2647 | 582 |
begin |
5480 | 583 |
if (cReducedQuality and rqBlurryLand) = 0 then |
584 |
begin |
|
585 |
by:= ty; bx:= tx; |
|
586 |
end |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
587 |
else |
5480 | 588 |
begin |
589 |
by:= ty div 2; bx:= tx div 2; |
|
590 |
end; |
|
6355 | 591 |
if ((Land[ty, tx] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
592 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
593 |
else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6097 | 594 |
LandPixels[by, bx]:= 0; |
595 |
Land[ty, tx]:= 0; |
|
2647 | 596 |
end |
184 | 597 |
end; |
598 |
for t:= 0 to 7 do |
|
2666 | 599 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
600 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
601 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
602 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
603 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
604 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
605 |
((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
|
606 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
607 |
((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
|
608 |
begin |
3519 | 609 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 610 |
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
|
611 |
if (cReducedQuality and rqBlurryLand) = 0 then |
5332 | 612 |
LandPixels[ty, tx]:= cExplosionBorderColor |
613 |
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
|
614 |
end |
2666 | 615 |
end; |
184 | 616 |
nx:= nx - dY; |
617 |
ny:= ny + dX; |
|
618 |
end; |
|
619 |
||
620 |
for i:= 0 to 7 do |
|
621 |
begin |
|
358 | 622 |
X:= nx - dX8; |
623 |
Y:= ny - dY8; |
|
184 | 624 |
for t:= -8 to ticks + 8 do |
2666 | 625 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
626 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
627 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
628 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
629 |
ty:= hwRound(Y); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
630 |
if ((ty and LAND_HEIGHT_MASK) = 0) and |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
631 |
((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
|
632 |
(((Land[ty, tx] and lfBasic) <> 0) or |
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
633 |
((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
|
634 |
begin |
3519 | 635 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
5332 | 636 |
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
|
637 |
if (cReducedQuality and rqBlurryLand) = 0 then |
5332 | 638 |
LandPixels[ty, tx]:= cExplosionBorderColor |
639 |
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
|
640 |
end |
2666 | 641 |
end; |
184 | 642 |
nx:= nx - dY; |
643 |
ny:= ny + dX; |
|
644 |
end; |
|
645 |
||
4374 | 646 |
tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0); |
647 |
ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0); |
|
648 |
ddx:= Min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx; |
|
649 |
ddy:= Min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty; |
|
1809 | 650 |
|
651 |
UpdateLandTexture(tx, ddx, ty, ddy) |
|
184 | 652 |
end; |
653 |
||
4886 | 654 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
6077
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
655 |
var X, Y, bpp, h, w, row, col, gx, gy, numFramesFirstCol: LongInt; |
409 | 656 |
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
|
657 |
Image: PSDL_Surface; |
409 | 658 |
begin |
2235 | 659 |
numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height; |
660 |
||
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
661 |
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
|
662 |
Image:= SpritesData[Obj].Surface; |
409 | 663 |
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
|
664 |
h:= SpritesData[Obj].Height; |
2235 | 665 |
row:= Frame mod numFramesFirstCol; |
666 |
col:= Frame div numFramesFirstCol; |
|
409 | 667 |
|
668 |
if SDL_MustLock(Image) then |
|
669 |
SDLTry(SDL_LockSurface(Image) >= 0, true); |
|
670 |
||
671 |
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
|
672 |
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
|
673 |
// Check that sprite fits free space |
2236 | 674 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 675 |
case bpp of |
676 |
4: for y:= 0 to Pred(h) do |
|
677 |
begin |
|
678 |
for x:= 0 to Pred(w) do |
|
679 |
if PLongword(@(p^[x * 4]))^ <> 0 then |
|
3749 | 680 |
if ((cpY + y) <= Longint(topY)) or |
681 |
((cpY + y) >= LAND_HEIGHT) or |
|
682 |
((cpX + x) <= Longint(leftX)) or |
|
683 |
((cpX + x) >= Longint(rightX)) or |
|
409 | 684 |
(Land[cpY + y, cpX + x] <> 0) then |
685 |
begin |
|
686 |
if SDL_MustLock(Image) then |
|
687 |
SDL_UnlockSurface(Image); |
|
688 |
exit(false) |
|
689 |
end; |
|
690 |
p:= @(p^[Image^.pitch]); |
|
691 |
end; |
|
692 |
end; |
|
693 |
||
520 | 694 |
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
|
695 |
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
|
696 |
begin |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
697 |
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
|
698 |
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
|
699 |
exit |
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
700 |
end; |
520 | 701 |
|
409 | 702 |
// Checked, now place |
2236 | 703 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 704 |
case bpp of |
705 |
4: for y:= 0 to Pred(h) do |
|
706 |
begin |
|
707 |
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
|
708 |
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
|
709 |
begin |
6077
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
710 |
if (cReducedQuality and rqBlurryLand) = 0 then |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
711 |
begin |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
712 |
gX:= cpX + x; |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
713 |
gY:= cpY + y; |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
714 |
end |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
715 |
else |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
716 |
begin |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
717 |
gX:= (cpX + x) div 2; |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
718 |
gY:= (cpY + y) div 2; |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
719 |
end; |
4886 | 720 |
if indestructible then |
721 |
Land[cpY + y, cpX + x]:= lfIndestructible |
|
6077
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
722 |
else if (LandPixels[gY, gX] and AMask) shr AShift = 255 then // This test assumes lfBasic and lfObject differ only graphically |
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
723 |
Land[cpY + y, cpX + x]:= lfBasic |
4886 | 724 |
else |
725 |
Land[cpY + y, cpX + x]:= lfObject; |
|
6081
537bbd5c1a62
Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects.
nemo
parents:
6077
diff
changeset
|
726 |
// For testing only. Intent is to flag this on objects with masks, or use it for an ice ray gun |
537bbd5c1a62
Basic test implementation of an ice flag. Allows for slick parts of terrain. Intended for ice gun, or "ice" mask on portions of land objects.
nemo
parents:
6077
diff
changeset
|
727 |
if (Theme = 'Snow') or (Theme = 'Christmas') then Land[cpY + y, cpX + x]:= Land[cpY + y, cpX + x] or lfIce; |
6077
d8fa5a85d24f
This prevents girders from erasing landbacktex (square windows in tunnels and such), at the cost of requiring lfBasic and lfObject to be treated the same apart from graphically
nemo
parents:
6011
diff
changeset
|
728 |
LandPixels[gY, gX]:= 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
|
729 |
end; |
409 | 730 |
p:= @(p^[Image^.pitch]); |
731 |
end; |
|
732 |
end; |
|
733 |
if SDL_MustLock(Image) then |
|
734 |
SDL_UnlockSurface(Image); |
|
735 |
||
4374 | 736 |
x:= Max(cpX, leftX); |
737 |
w:= Min(cpX + Image^.w, LAND_WIDTH) - x; |
|
738 |
y:= Max(cpY, topY); |
|
739 |
h:= Min(cpY + Image^.h, LAND_HEIGHT) - y; |
|
1807 | 740 |
UpdateLandTexture(x, w, y, h) |
409 | 741 |
end; |
742 |
||
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
743 |
function Despeckle(X, Y: LongInt): boolean; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
744 |
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
|
745 |
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
|
746 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
747 |
if (cReducedQuality and rqBlurryLand) = 0 then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
748 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
749 |
xx:= X; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
750 |
yy:= Y; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
751 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
752 |
else |
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 |
xx:= X div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
755 |
yy:= Y div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
756 |
end; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
757 |
pixelsweep:= ((Land[Y, X] and $FF00) = 0) and (LandPixels[yy, xx] <> 0); |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
758 |
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
|
759 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
760 |
c:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
761 |
for i:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
762 |
for j:= -1 to 1 do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
763 |
if (i <> 0) or (j <> 0) then |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
764 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
765 |
ny:= Y + i; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
766 |
nx:= X + j; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
767 |
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
|
768 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
769 |
if pixelsweep then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
770 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
771 |
if ((cReducedQuality and rqBlurryLand) <> 0) then |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
772 |
begin |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
773 |
nx:= nx div 2; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
774 |
ny:= ny div 2 |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
775 |
end; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
776 |
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
|
777 |
end |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
778 |
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
|
779 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
780 |
end; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
781 |
|
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
782 |
if c < 4 then // 0-3 neighbours |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
783 |
begin |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
784 |
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
|
785 |
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
|
786 |
else |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
787 |
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
|
788 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
789 |
Land[Y, X]:= 0; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
790 |
if not pixelsweep then exit(true); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
791 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
792 |
end; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
793 |
Despeckle:= false |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
794 |
end; |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
795 |
|
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
796 |
procedure Smooth(X, Y: LongInt); |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
797 |
begin |
5261 | 798 |
// a bit of AA for explosions |
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
799 |
if (Land[Y, X] = 0) and (Y > LongInt(topY) + 1) and |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
800 |
(Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then |
5261 | 801 |
begin |
802 |
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 |
|
803 |
(((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then |
|
804 |
begin |
|
5274 | 805 |
if (cReducedQuality and rqBlurryLand) = 0 then |
806 |
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
|
807 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then LandPixels[y,x]:= (cExplosionBorderColor and not AMask) or (128 shl AShift) |
5274 | 808 |
else |
809 |
LandPixels[y,x]:= |
|
810 |
(((((LandPixels[y,x] and RMask shr RShift) div 2)+((cExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or |
|
811 |
(((((LandPixels[y,x] and GMask shr GShift) div 2)+((cExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or |
|
812 |
(((((LandPixels[y,x] and BMask shr BShift) div 2)+((cExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift) |
|
813 |
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
|
814 |
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
|
815 |
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
|
816 |
else Land[y,x]:= lfBasic; |
5261 | 817 |
end |
818 |
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 |
|
819 |
(((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 |
|
820 |
(((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 |
|
821 |
(((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 |
|
822 |
(((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 |
|
823 |
(((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 |
|
824 |
(((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 |
|
825 |
(((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 |
|
826 |
begin |
|
5274 | 827 |
if (cReducedQuality and rqBlurryLand) = 0 then |
828 |
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
|
829 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then LandPixels[y,x]:= (cExplosionBorderColor and not AMask) or (64 shl AShift) |
5274 | 830 |
else |
831 |
LandPixels[y,x]:= |
|
832 |
(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((cExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or |
|
833 |
(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((cExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or |
|
834 |
(((((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) |
|
835 |
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
|
836 |
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
|
837 |
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
|
838 |
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
|
839 |
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
|
840 |
else Land[y,x]:= lfBasic |
5261 | 841 |
end |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
842 |
end |
6132 | 843 |
else if ((cReducedQuality and rqBlurryLand) = 0) and (LandPixels[Y, X] and AMask = 255) and |
6130 | 844 |
((Land[Y, X] and (lfDamaged or lfBasic) = lfBasic) or (Land[Y, X] and (lfDamaged or lfBasic) = lfBasic)) and |
845 |
(Y > LongInt(topY) + 1) and (Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then |
|
846 |
begin |
|
847 |
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 |
|
848 |
(((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then |
|
849 |
begin |
|
850 |
LandPixels[y,x]:= |
|
851 |
(((((LandPixels[y,x] and RMask shr RShift) div 2)+((cExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or |
|
852 |
(((((LandPixels[y,x] and GMask shr GShift) div 2)+((cExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or |
|
853 |
(((((LandPixels[y,x] and BMask shr BShift) div 2)+((cExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift) |
|
854 |
end |
|
855 |
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 |
|
856 |
(((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 |
|
857 |
(((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 |
|
858 |
(((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 |
|
859 |
(((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 |
|
860 |
(((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 |
|
861 |
(((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 |
|
862 |
(((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 |
|
863 |
begin |
|
864 |
LandPixels[y,x]:= |
|
865 |
(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((cExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or |
|
866 |
(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((cExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or |
|
867 |
(((((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) |
|
868 |
end |
|
869 |
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
|
870 |
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
|
871 |
|
1792 | 872 |
function SweepDirty: boolean; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
873 |
var x, y, xx, yy, ty, tx: LongInt; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
874 |
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
|
875 |
begin |
2695 | 876 |
bRes:= false; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
877 |
reCheck:= true; |
1792 | 878 |
|
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
879 |
while recheck do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
880 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
881 |
recheck:= false; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
882 |
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
|
883 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
884 |
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
|
885 |
begin |
5895 | 886 |
if LandDirty[y, x] = 1 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
|
887 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
888 |
updateBlock:= false; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
889 |
resweep:= true; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
890 |
ty:= y * 32; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
891 |
tx:= x * 32; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
892 |
while(resweep) do |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
893 |
begin |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
894 |
resweep:= false; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
895 |
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
|
896 |
for xx:= tx to tx + 31 do |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
897 |
if Despeckle(xx, yy) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
898 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
899 |
bRes:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
900 |
updateBlock:= true; |
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
901 |
resweep:= true; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
902 |
if (yy = ty) and (y > 0) then |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
903 |
begin |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
904 |
LandDirty[y-1, x]:= 1; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
905 |
recheck:= true; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
906 |
end |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
907 |
else if (yy = ty+31) and (y < LAND_HEIGHT div 32 - 1) then |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
908 |
begin |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
909 |
LandDirty[y+1, x]:= 1; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
910 |
recheck:= true; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
911 |
end; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
912 |
if (xx = tx) and (x > 0) then |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
913 |
begin |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
914 |
LandDirty[y, x-1]:= 1; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
915 |
recheck:= true; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
916 |
end |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
917 |
else if (xx = tx+31) and (x < LAND_WIDTH div 32 - 1) then |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
918 |
begin |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
919 |
LandDirty[y, x+1]:= 1; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
920 |
recheck:= true; |
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
921 |
end |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
922 |
end; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
923 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
924 |
if updateBlock then UpdateLandTexture(tx, 32, ty, 32); |
5895 | 925 |
LandDirty[y, x]:= 2; |
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
|
926 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
927 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
928 |
end; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
929 |
end; |
1792 | 930 |
|
5895 | 931 |
for y:= 0 to LAND_HEIGHT div 32 - 1 do |
932 |
for x:= 0 to LAND_WIDTH div 32 - 1 do |
|
933 |
if LandDirty[y, x] <> 0 then |
|
934 |
begin |
|
935 |
LandDirty[y, x]:= 0; |
|
936 |
ty:= y * 32; |
|
937 |
tx:= x * 32; |
|
938 |
for yy:= ty to ty + 31 do |
|
939 |
for xx:= tx to tx + 31 do |
|
940 |
Smooth(xx,yy) |
|
941 |
end; |
|
942 |
||
2695 | 943 |
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
|
944 |
end; |
184 | 945 |
|
5885
ae257409bcff
Remove extra graphical resweeps, and smooth prior to despeckling. Was getting odd desync here without Land[] seemingly incorrect at end of passes. Just removing seems to fix, and code wasn't that good an idea in its prior state anyway.
nemo
parents:
5832
diff
changeset
|
946 |
|
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
|
947 |
// 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 |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
948 |
function CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean; inline; |
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
|
949 |
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
|
950 |
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
|
951 |
end; |
4367 | 952 |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
953 |
function LandBackPixel(x, y: LongInt): LongWord; inline; |
4367 | 954 |
var p: PLongWordArray; |
955 |
begin |
|
956 |
if LandBackSurface = nil then LandBackPixel:= 0 |
|
957 |
else |
|
958 |
begin |
|
959 |
p:= LandBackSurface^.pixels; |
|
960 |
LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000; |
|
961 |
end |
|
962 |
end; |
|
963 |
||
964 |
||
184 | 965 |
end. |