author | nemo |
Tue, 26 Mar 2013 17:47:06 -0400 (2013-03-26) | |
changeset 8774 | 39754516eee6 |
parent 8751 | 4609823efc94 |
child 8795 | b5b79a8f9354 |
permissions | -rw-r--r-- |
393 | 1 |
(* |
1066 | 2 |
* Hedgewars, a free turn based strategy game |
6700 | 3 |
* Copyright (c) 2004-2012 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 |
|
7035 | 25 |
type TRangeArray = array[0..31] of record |
371 | 26 |
Left, Right: LongInt; |
184 | 27 |
end; |
7035 | 28 |
PRangeArray = ^TRangeArray; |
184 | 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); |
|
8583 | 39 |
procedure FillRoundInLandWithIce(X, Y, Radius: LongInt); |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7268
diff
changeset
|
40 |
procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent: boolean); |
4367 | 41 |
function LandBackPixel(x, y: LongInt): LongWord; |
6490 | 42 |
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword); |
7147 | 43 |
procedure DrawThickLine(X1, Y1, X2, Y2, radius: LongInt; color: Longword); |
7268 | 44 |
procedure DumpLandToLog(x, y, r: LongInt); |
8602 | 45 |
procedure DrawIceBreak(x, y, iceRadius, iceHeight: Longint); |
4886 | 46 |
function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; indestructible: boolean): boolean; |
409 | 47 |
|
184 | 48 |
implementation |
4403 | 49 |
uses SDLh, uLandTexture, uVariables, uUtils, uDebug; |
184 | 50 |
|
4791 | 51 |
function addBgColor(OldColor, NewColor: LongWord): LongWord; |
52 |
// Factor ranges from 0 to 100% NewColor |
|
53 |
var |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
54 |
oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: byte; |
4791 | 55 |
begin |
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
56 |
oAlpha := (OldColor shr AShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
57 |
nAlpha := (NewColor shr AShift); |
5692 | 58 |
// shortcircuit |
59 |
if (oAlpha = 0) or (nAlpha = $FF) then |
|
60 |
begin |
|
61 |
addBgColor:= NewColor; |
|
62 |
exit |
|
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
63 |
end; |
4791 | 64 |
// Get colors |
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
65 |
oRed := (OldColor shr RShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
66 |
oGreen := (OldColor shr GShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
67 |
oBlue := (OldColor shr BShift); |
4791 | 68 |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
69 |
nRed := (NewColor shr RShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
70 |
nGreen := (NewColor shr GShift); |
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
71 |
nBlue := (NewColor shr BShift); |
4791 | 72 |
|
73 |
// Mix colors |
|
6011
519f8a58c021
Fix a bunch of warnings (also improves speed a bit in 32 bit code)
unC0Rr
parents:
5895
diff
changeset
|
74 |
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
|
75 |
nGreen := min(255,((nGreen*nAlpha) div 255) + ((oGreen*oAlpha*byte(255-nAlpha)) div 65025)); |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
76 |
nBlue := min(255,((nBlue*nAlpha) div 255) + ((oBlue*oAlpha*byte(255-nAlpha)) div 65025)); |
4791 | 77 |
nAlpha := min(255, oAlpha + nAlpha); |
78 |
||
5041 | 79 |
addBgColor := (nAlpha shl AShift) or (nRed shl RShift) or (nGreen shl GShift) or (nBlue shl BShift); |
4791 | 80 |
end; |
81 |
||
371 | 82 |
procedure FillCircleLines(x, y, dx, dy: LongInt; Value: Longword); |
83 |
var i: LongInt; |
|
184 | 84 |
begin |
1753 | 85 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
7509 | 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 - dy) and LAND_HEIGHT_MASK) = 0 then |
|
7509 | 90 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
3519 | 91 |
if (Land[y - dy, i] and lfIndestructible) = 0 then |
1753 | 92 |
Land[y - dy, i]:= Value; |
93 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
|
7509 | 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; |
97 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
|
7509 | 98 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
3519 | 99 |
if (Land[y - dx, i] and lfIndestructible) = 0 then |
1753 | 100 |
Land[y - dx, i]:= Value; |
184 | 101 |
end; |
102 |
||
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7268
diff
changeset
|
103 |
procedure ChangeCircleLines(x, y, dx, dy: LongInt; doSet, isCurrent: boolean); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
104 |
var i: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
105 |
begin |
511 | 106 |
if not doSet then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
107 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
108 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
7509 | 109 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
110 |
if isCurrent then |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
111 |
Land[y + dy, i]:= Land[y + dy, i] and lfNotCurrentMask |
8744 | 112 |
else if Land[y + dy, i] and lfObjMask > 0 then |
113 |
Land[y + dy, i]:= (Land[y + dy, i] and lfNotObjMask) or ((Land[y + dy, i] and lfObjMask) - 1); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
114 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
7509 | 115 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
116 |
if isCurrent then |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
117 |
Land[y - dy, i]:= Land[y - dy, i] and lfNotCurrentMask |
8744 | 118 |
else if Land[y - dy, i] and lfObjMask > 0 then |
119 |
Land[y - dy, i]:= (Land[y - dy, i] and lfNotObjMask) or ((Land[y - dy, i] and lfObjMask) - 1); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
120 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
7509 | 121 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
122 |
if isCurrent then |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
123 |
Land[y + dx, i]:= Land[y + dx, i] and lfNotCurrentMask |
8744 | 124 |
else if Land[y + dx, i] and lfObjMask > 0 then |
125 |
Land[y + dx, i]:= (Land[y + dx, i] and lfNotObjMask) or ((Land[y + dx, i] and lfObjMask) - 1); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
126 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
7509 | 127 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
128 |
if isCurrent then |
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
129 |
Land[y - dx, i]:= Land[y - dx, i] and lfNotCurrentMask |
8744 | 130 |
else if Land[y - dx, i] and lfObjMask > 0 then |
131 |
Land[y - dx, i]:= (Land[y - dx, i] and lfNotObjMask) or ((Land[y - dx, i] and lfObjMask) - 1) |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
132 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
133 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
134 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
135 |
if ((y + dy) and LAND_HEIGHT_MASK) = 0 then |
7509 | 136 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
137 |
if isCurrent then |
8744 | 138 |
Land[y + dy, i]:= Land[y + dy, i] or lfCurrentHog |
139 |
else if Land[y + dy, i] and lfObjMask < lfObjMask then |
|
140 |
Land[y + dy, i]:= (Land[y + dy, i] and lfNotObjMask) or ((Land[y + dy, i] and lfObjMask) + 1); |
|
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
141 |
if ((y - dy) and LAND_HEIGHT_MASK) = 0 then |
7509 | 142 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
143 |
if isCurrent then |
8744 | 144 |
Land[y - dy, i]:= Land[y - dy, i] or lfCurrentHog |
145 |
else if Land[y - dy, i] and lfObjMask < lfObjMask then |
|
146 |
Land[y - dy, i]:= (Land[y - dy, i] and lfNotObjMask) or ((Land[y - dy, i] and lfObjMask) + 1); |
|
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
147 |
if ((y + dx) and LAND_HEIGHT_MASK) = 0 then |
7509 | 148 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
149 |
if isCurrent then |
8744 | 150 |
Land[y + dx, i]:= Land[y + dx, i] or lfCurrentHog |
151 |
else if Land[y + dx, i] and lfObjMask < lfObjMask then |
|
152 |
Land[y + dx, i]:= (Land[y + dx, i] and lfNotObjMask) or ((Land[y + dx, i] and lfObjMask) + 1); |
|
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
153 |
if ((y - dx) and LAND_HEIGHT_MASK) = 0 then |
7509 | 154 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
155 |
if isCurrent then |
8744 | 156 |
Land[y - dx, i]:= Land[y - dx, i] or lfCurrentHog |
157 |
else if Land[y - dx, i] and lfObjMask < lfObjMask then |
|
158 |
Land[y - dx, i]:= (Land[y - dx, i] and lfNotObjMask) or ((Land[y - dx, i] and lfObjMask) + 1) |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
159 |
end |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
160 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
161 |
|
8583 | 162 |
|
163 |
||
371 | 164 |
procedure FillRoundInLand(X, Y, Radius: LongInt; Value: Longword); |
165 |
var dx, dy, d: LongInt; |
|
184 | 166 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
167 |
dx:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
168 |
dy:= Radius; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
169 |
d:= 3 - 2 * Radius; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
170 |
while (dx < dy) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
171 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
172 |
FillCircleLines(x, y, dx, dy, Value); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
173 |
if (d < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
174 |
d:= d + 4 * dx + 6 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
175 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
176 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
177 |
d:= d + 4 * (dx - dy) + 10; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
178 |
dec(dy) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
179 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
180 |
inc(dx) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
181 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
182 |
if (dx = dy) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
183 |
FillCircleLines(x, y, dx, dy, Value); |
184 | 184 |
end; |
185 |
||
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7268
diff
changeset
|
186 |
procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent: boolean); |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
187 |
var dx, dy, d: LongInt; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
188 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
189 |
dx:= 0; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
190 |
dy:= Radius; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
191 |
d:= 3 - 2 * Radius; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
192 |
while (dx < dy) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
193 |
begin |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7268
diff
changeset
|
194 |
ChangeCircleLines(x, y, dx, dy, doSet, isCurrent); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
195 |
if (d < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
196 |
d:= d + 4 * dx + 6 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
197 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
198 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
199 |
d:= d + 4 * (dx - dy) + 10; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
200 |
dec(dy) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
201 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
202 |
inc(dx) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
203 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
204 |
if (dx = dy) then |
7270
93e92e82d5c8
Step 1. Add current hedgehog as top bit of bottom byte.
nemo
parents:
7268
diff
changeset
|
205 |
ChangeCircleLines(x, y, dx, dy, doSet, isCurrent) |
504
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
206 |
end; |
13b6ebc53627
Fix collision info artifacts in Land array when two objects intersect
unc0rr
parents:
495
diff
changeset
|
207 |
|
2603 | 208 |
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
|
209 |
var i, t: LongInt; |
184 | 210 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
211 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
212 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 213 |
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
|
214 |
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
|
215 |
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
|
216 |
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
|
217 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
218 |
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
|
219 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
220 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
221 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 222 |
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
|
223 |
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
|
224 |
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
|
225 |
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
|
226 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
227 |
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
|
228 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
229 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
230 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 231 |
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
|
232 |
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
|
233 |
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
|
234 |
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
|
235 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
236 |
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
|
237 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
238 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
239 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 240 |
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
|
241 |
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
|
242 |
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
|
243 |
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
|
244 |
else |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
245 |
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
|
246 |
|
184 | 247 |
end; |
248 |
||
8583 | 249 |
|
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
250 |
function isLandscapeEdge(weight:Longint):boolean; inline; |
8583 | 251 |
begin |
252 |
result := (weight < 8) and (weight >= 2); |
|
253 |
end; |
|
254 |
||
255 |
function getPixelWeight(x, y:Longint): Longint; |
|
256 |
var |
|
257 |
i, j:Longint; |
|
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
258 |
begin |
8583 | 259 |
result := 0; |
260 |
for i := x - 1 to x + 1 do |
|
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
261 |
for j := y - 1 to y + 1 do |
8583 | 262 |
begin |
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
263 |
if (i < 0) or |
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
264 |
(i > LAND_WIDTH - 1) or |
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
265 |
(j < 0) or |
8602 | 266 |
(j > LAND_HEIGHT -1) then |
8624 | 267 |
begin |
8628 | 268 |
result := 9; |
8624 | 269 |
exit; |
270 |
end; |
|
8602 | 271 |
|
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
272 |
if Land[j, i] and lfLandMask and not lfIce = 0 then |
8583 | 273 |
result := result + 1; |
274 |
end; |
|
275 |
end; |
|
276 |
||
277 |
procedure drawIcePixel(y, x:Longint); |
|
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
278 |
var |
8583 | 279 |
iceSurface: PSDL_Surface; |
280 |
icePixels: PLongwordArray; |
|
8774
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
281 |
//pictureX, pictureY: LongInt; |
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
282 |
w: LongWord; |
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGun-specific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset
|
283 |
//weight: Longint; |
8583 | 284 |
begin |
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
285 |
// So. 3 parameters here. Ice colour, Ice opacity, and a bias on the greyscaled pixel towards lightness |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
286 |
iceSurface:= SpritesData[sprIceTexture].Surface; |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
287 |
icePixels := iceSurface^.pixels; |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
288 |
w:= LandPixels[y, x]; |
8624 | 289 |
if w > 0 then |
290 |
begin |
|
291 |
w:= round(((w shr RShift and $FF) * RGB_LUMINANCE_RED + |
|
292 |
(w shr BShift and $FF) * RGB_LUMINANCE_GREEN + |
|
293 |
(w shr GShift and $FF) * RGB_LUMINANCE_BLUE)); |
|
294 |
if w < 128 then w:= w+128; |
|
295 |
if w > 255 then w:= 255; |
|
296 |
w:= (w shl RShift) or (w shl BShift) or (w shl GShift) or (LandPixels[y,x] and AMask); |
|
297 |
LandPixels[y, x]:= addBgColor(w, IceColor); |
|
298 |
LandPixels[y, x]:= addBgColor(LandPixels[y, x], icePixels^[iceSurface^.w * (y mod iceSurface^.h) + (x mod iceSurface^.w)]) |
|
299 |
end |
|
300 |
else |
|
301 |
begin |
|
302 |
LandPixels[y, x]:= IceColor and not AMask or $E8 shl AShift; |
|
303 |
LandPixels[y, x]:= addBgColor(LandPixels[y, x], icePixels^[iceSurface^.w * (y mod iceSurface^.h) + (x mod iceSurface^.w)]); |
|
304 |
// silly workaround to avoid having to make background erasure a tadb it smarter about sea ice |
|
305 |
if LandPixels[y, x] and AMask shr AShift = 255 then |
|
306 |
LandPixels[y, x]:= LandPixels[y, x] and not AMask or 254 shl AShift; |
|
307 |
end; |
|
8583 | 308 |
end; |
309 |
||
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
310 |
function getIncrementInquarter(dx, dy, quarter: Longint): Longint; inline; |
8583 | 311 |
const directionX : array [0..3] of Longint = (0, 0, 1, -1); |
312 |
const directionY : array [0..3] of Longint = (1, -1, 0, 0); |
|
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
313 |
begin |
8583 | 314 |
getIncrementInquarter := directionX[quarter] * dx + directionY[quarter] * dy; |
315 |
end; |
|
316 |
||
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
317 |
function getIncrementInquarter2(dx, dy, quarter: Longint): Longint; inline; |
8583 | 318 |
const directionY : array [0..3] of Longint = (0, 0, 1, 1); |
319 |
const directionX : array [0..3] of Longint = (1, 1, 0, 0); |
|
8584
ea20d9cc8515
put ice colour in uVariables, add check for land that is already ice
nemo
parents:
8583
diff
changeset
|
320 |
begin |
8583 | 321 |
getIncrementInquarter2 := directionX[quarter] * dx + directionY[quarter] * dy; |
322 |
end; |
|
323 |
||
324 |
procedure FillLandCircleLinesIce(x, y, dx, dy: LongInt); |
|
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
325 |
var q, i, t, px, py: LongInt; |
8583 | 326 |
begin |
327 |
for q := 0 to 3 do |
|
328 |
begin |
|
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
329 |
t:= y + getIncrementInquarter(dx, dy, q); |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
330 |
if (t and LAND_HEIGHT_MASK) = 0 then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
331 |
for i:= Max(x - getIncrementInquarter2(dx, dy, q), 0) to Min(x + getIncrementInquarter2(dx, dy, q), LAND_WIDTH - 1) do |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
332 |
if Land[t, i] and lfIce = 0 then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
333 |
begin |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
334 |
if (cReducedQuality and rqBlurryLand) = 0 then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
335 |
begin |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
336 |
px:= i; py:= t |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
337 |
end |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
338 |
else |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
339 |
begin |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
340 |
px:= i div 2; py:= t div 2 |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
341 |
end; |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
342 |
if isLandscapeEdge(getPixelWeight(i, t)) then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
343 |
begin |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
344 |
if (LandPixels[py, px] and AMask < 255) and (LandPixels[py, px] and AMask > 0) then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
345 |
LandPixels[py, px] := (IceEdgeColor and not AMask) or (LandPixels[py, px] and AMask) |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
346 |
else if (LandPixels[py, px] and AMask < 255) or (Land[t, i] > 255) then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
347 |
LandPixels[py, px] := IceEdgeColor |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
348 |
end |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
349 |
else if Land[t, i] > 255 then |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
350 |
begin |
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
351 |
drawIcePixel(py, px) |
8602 | 352 |
end; |
353 |
if Land[t, i] > 255 then Land[t, i] := Land[t, i] or lfIce and not lfDamaged; |
|
8601
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
354 |
end; |
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
355 |
end |
8583 | 356 |
end; |
357 |
||
358 |
procedure FillRoundInLandWithIce(X, Y, Radius: LongInt); |
|
359 |
var dx, dy, d: LongInt; |
|
8601
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
360 |
landRect: TSDL_Rect; |
8583 | 361 |
begin |
362 |
dx:= 0; |
|
363 |
dy:= Radius; |
|
364 |
d:= 3 - 2 * Radius; |
|
8601
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
365 |
while (dx < dy) do |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
366 |
begin |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
367 |
FillLandCircleLinesIce(x, y, dx, dy); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
368 |
if (d < 0) then |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
369 |
d:= d + 4 * dx + 6 |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
370 |
else |
8583 | 371 |
begin |
8601
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
372 |
d:= d + 4 * (dx - dy) + 10; |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
373 |
dec(dy) |
8583 | 374 |
end; |
8601
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
375 |
inc(dx) |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
376 |
end; |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
377 |
if (dx = dy) then |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
378 |
FillLandCircleLinesIce(x, y, dx, dy); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
379 |
landRect.x := min(max(x - Radius, 0), LAND_WIDTH - 1); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
380 |
landRect.y := min(max(y - Radius, 0), LAND_HEIGHT - 1); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
381 |
landRect.w := min(2*Radius, LAND_WIDTH - landRect.x - 1); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
382 |
landRect.h := min(2*Radius, LAND_HEIGHT - landRect.y - 1); |
7668f92734b8
Make refactoring. Remove DrawIce function
Urbertar@gmail.com
parents:
8598
diff
changeset
|
383 |
UpdateLandTexture(landRect.x, landRect.w, landRect.y, landRect.h, true); |
8583 | 384 |
end; |
385 |
||
386 |
||
8602 | 387 |
procedure DrawIceBreak(x, y, iceRadius, iceHeight: Longint); |
388 |
var |
|
389 |
i, j: integer; |
|
390 |
landRect: TSDL_Rect; |
|
391 |
begin |
|
392 |
for i := min(max(x - iceRadius, 0), LAND_WIDTH - 1) to min(max(x + iceRadius, 0), LAND_WIDTH - 1) do |
|
393 |
begin |
|
394 |
for j := min(max(y, 0), LAND_HEIGHT - 1) to min(max(y + iceHeight, 0), LAND_HEIGHT - 1) do |
|
395 |
begin |
|
8624 | 396 |
if Land[j, i] = 0 then |
8602 | 397 |
begin |
8624 | 398 |
Land[j, i] := lfIce; |
399 |
drawIcePixel(j, i); |
|
8602 | 400 |
end; |
401 |
end; |
|
402 |
end; |
|
403 |
landRect.x := min(max(x - iceRadius, 0), LAND_WIDTH - 1); |
|
404 |
landRect.y := min(max(y, 0), LAND_HEIGHT - 1); |
|
405 |
landRect.w := min(2*iceRadius, LAND_WIDTH - landRect.x - 1); |
|
406 |
landRect.h := min(iceHeight, LAND_HEIGHT - landRect.y - 1); |
|
407 |
UpdateLandTexture(landRect.x, landRect.w, landRect.y, landRect.h, true); |
|
408 |
end; |
|
409 |
||
410 |
||
411 |
||
3689 | 412 |
function FillLandCircleLinesBG(x, y, dx, dy: LongInt): Longword; |
5480 | 413 |
var i, t, by, bx: LongInt; |
3689 | 414 |
cnt: Longword; |
2647 | 415 |
begin |
3689 | 416 |
cnt:= 0; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
417 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
418 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 419 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
420 |
if (Land[t, i] and lfIndestructible) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
421 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
422 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
423 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
424 |
by:= t; bx:= i; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
425 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
426 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
427 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
428 |
by:= t div 2; bx:= i div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
429 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
430 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
431 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
432 |
inc(cnt); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
433 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
434 |
end |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
435 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
436 |
LandPixels[by, bx]:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
437 |
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
|
438 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
439 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
440 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 441 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
442 |
if (Land[t, i] and lfIndestructible) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
443 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
444 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
445 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
446 |
by:= t; bx:= i; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
447 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
448 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
449 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
450 |
by:= t div 2; bx:= i div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
451 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
452 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
453 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
454 |
inc(cnt); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
455 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
456 |
end |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
457 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
458 |
LandPixels[by, bx]:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
459 |
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
|
460 |
|
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
461 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
462 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 463 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
464 |
if (Land[t, i] and lfIndestructible) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
465 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
466 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
467 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
468 |
by:= t; bx:= i; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
469 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
470 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
471 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
472 |
by:= t div 2; bx:= i div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
473 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
474 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
475 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
476 |
inc(cnt); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
477 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
478 |
end |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
479 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
480 |
LandPixels[by, bx]:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
481 |
end; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
482 |
t:= y - dx; |
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
483 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 484 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
485 |
if (Land[t, i] and lfIndestructible) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
486 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
487 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
488 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
489 |
by:= t; bx:= i; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
490 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
491 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
492 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
493 |
by:= t div 2; bx:= i div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
494 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
495 |
if ((Land[t, i] and lfBasic) <> 0) and (((LandPixels[by,bx] and AMask) shr AShift) = 255) and (not disableLandBack) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
496 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
497 |
inc(cnt); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
498 |
LandPixels[by, bx]:= LandBackPixel(i, t) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
499 |
end |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
500 |
else if ((Land[t, i] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
501 |
LandPixels[by, bx]:= 0 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
502 |
end; |
3689 | 503 |
FillLandCircleLinesBG:= cnt; |
2647 | 504 |
end; |
505 |
||
371 | 506 |
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
|
507 |
var i, t: LongInt; |
184 | 508 |
begin |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
509 |
t:= y + dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
510 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 511 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
512 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
513 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
514 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 515 |
LandPixels[t, i]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
516 |
else |
6982 | 517 |
LandPixels[t div 2, i div 2]:= ExplosionBorderColor; |
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
|
518 |
|
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
519 |
Land[t, i]:= (Land[t, i] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
520 |
//Despeckle(i, t); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
521 |
LandDirty[t div 32, i div 32]:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
522 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
523 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
524 |
t:= y - dy; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
525 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 526 |
for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
527 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
528 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
529 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 530 |
LandPixels[t, i]:= ExplosionBorderColor |
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
|
531 |
else |
6982 | 532 |
LandPixels[t div 2, i div 2]:= ExplosionBorderColor; |
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
533 |
Land[t, i]:= (Land[t, i] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
534 |
//Despeckle(i, t); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
535 |
LandDirty[t div 32, i div 32]:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
536 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
537 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
538 |
t:= y + dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
539 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 540 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
541 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
542 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
543 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 544 |
LandPixels[t, i]:= ExplosionBorderColor |
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
|
545 |
else |
6982 | 546 |
LandPixels[t div 2, i div 2]:= ExplosionBorderColor; |
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
|
547 |
|
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
548 |
Land[t, i]:= (Land[t, i] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
549 |
//Despeckle(i, t); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
550 |
LandDirty[t div 32, i div 32]:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
551 |
end; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
552 |
|
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
553 |
t:= y - dx; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
554 |
if (t and LAND_HEIGHT_MASK) = 0 then |
7509 | 555 |
for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
556 |
if ((Land[t, i] and lfBasic) <> 0) or ((Land[t, i] and lfObject) <> 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
557 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
558 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 559 |
LandPixels[t, i]:= ExplosionBorderColor |
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
|
560 |
else |
6982 | 561 |
LandPixels[t div 2, i div 2]:= ExplosionBorderColor; |
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
|
562 |
|
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
563 |
Land[t, i]:= (Land[t, i] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
564 |
//Despeckle(i, y - dy); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
565 |
LandDirty[t div 32, i div 32]:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
566 |
end; |
184 | 567 |
end; |
568 |
||
3689 | 569 |
function DrawExplosion(X, Y, Radius: LongInt): Longword; |
2603 | 570 |
var dx, dy, ty, tx, d: LongInt; |
3689 | 571 |
cnt: Longword; |
184 | 572 |
begin |
2647 | 573 |
|
574 |
// draw background land texture |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
575 |
begin |
3689 | 576 |
cnt:= 0; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
577 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
578 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
579 |
d:= 3 - 2 * Radius; |
2647 | 580 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
581 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
582 |
begin |
3689 | 583 |
inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
584 |
if (d < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
585 |
d:= d + 4 * dx + 6 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
586 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
587 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
588 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
589 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
590 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
591 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
592 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
593 |
if (dx = dy) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
594 |
inc(cnt, FillLandCircleLinesBG(x, y, dx, dy)); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
595 |
end; |
2647 | 596 |
|
597 |
// draw a hole in land |
|
2733 | 598 |
if Radius > 20 then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
599 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
600 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
601 |
dy:= Radius - 15; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
602 |
d:= 3 - 2 * dy; |
2647 | 603 |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
604 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
605 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
606 |
FillLandCircleLines0(x, y, dx, dy); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
607 |
if (d < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
608 |
d:= d + 4 * dx + 6 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
609 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
610 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
611 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
612 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
613 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
614 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
615 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
616 |
if (dx = dy) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
617 |
FillLandCircleLines0(x, y, dx, dy); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
618 |
end; |
2647 | 619 |
|
1849 | 620 |
// 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
|
621 |
FillRoundInLand(X, Y, Radius, 0); |
2647 | 622 |
|
623 |
// draw explosion border |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
624 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
625 |
inc(Radius, 4); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
626 |
dx:= 0; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
627 |
dy:= Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
628 |
d:= 3 - 2 * Radius; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
629 |
while (dx < dy) do |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
630 |
begin |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
631 |
FillLandCircleLinesEBC(x, y, dx, dy); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
632 |
if (d < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
633 |
d:= d + 4 * dx + 6 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
634 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
635 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
636 |
d:= d + 4 * (dx - dy) + 10; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
637 |
dec(dy) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
638 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
639 |
inc(dx) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
640 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
641 |
if (dx = dy) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
642 |
FillLandCircleLinesEBC(x, y, dx, dy); |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
643 |
end; |
351 | 644 |
|
4374 | 645 |
tx:= Max(X - Radius - 1, 0); |
646 |
dx:= Min(X + Radius + 1, LAND_WIDTH) - tx; |
|
647 |
ty:= Max(Y - Radius - 1, 0); |
|
648 |
dy:= Min(Y + Radius + 1, LAND_HEIGHT) - ty; |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7150
diff
changeset
|
649 |
UpdateLandTexture(tx, dx, ty, dy, false); |
3689 | 650 |
DrawExplosion:= cnt |
184 | 651 |
end; |
652 |
||
371 | 653 |
procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte); |
5480 | 654 |
var tx, ty, by, bx, i: LongInt; |
184 | 655 |
begin |
656 |
for i:= 0 to Pred(Count) do |
|
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
657 |
begin |
7509 | 658 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
659 |
for tx:= Max(0, ar^[i].Left - Radius) to Min(LAND_WIDTH, ar^[i].Right + Radius) do |
|
5480 | 660 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
661 |
if (Land[ty, tx] and lfIndestructible) = 0 then |
5480 | 662 |
begin |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
663 |
if (cReducedQuality and rqBlurryLand) = 0 then |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
664 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
665 |
by:= ty; bx:= tx; |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
666 |
end |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
667 |
else |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
668 |
begin |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
669 |
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
|
670 |
end; |
6355 | 671 |
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
|
672 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
673 |
else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
674 |
LandPixels[by, bx]:= 0 |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
675 |
end |
5480 | 676 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
677 |
inc(y, dY) |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
678 |
end; |
184 | 679 |
|
680 |
inc(Radius, 4); |
|
351 | 681 |
dec(y, Count * dY); |
184 | 682 |
|
683 |
for i:= 0 to Pred(Count) do |
|
684 |
begin |
|
7509 | 685 |
for ty:= Max(y - Radius, 0) to Min(y + Radius, LAND_HEIGHT) do |
686 |
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
|
687 |
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
|
688 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
689 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 690 |
LandPixels[ty, tx]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
691 |
else |
6982 | 692 |
LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor; |
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
|
693 |
|
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
694 |
Land[ty, tx]:= (Land[ty, tx] or lfDamaged) and not lfIce; |
3596 | 695 |
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
|
696 |
end; |
184 | 697 |
inc(y, dY) |
698 |
end; |
|
699 |
||
818 | 700 |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7150
diff
changeset
|
701 |
UpdateLandTexture(0, LAND_WIDTH, 0, LAND_HEIGHT, false) |
184 | 702 |
end; |
703 |
||
704 |
// |
|
705 |
// - (dX, dY) - direction, vector of length = 0.5 |
|
706 |
// |
|
371 | 707 |
procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt); |
358 | 708 |
var nx, ny, dX8, dY8: hwFloat; |
5480 | 709 |
i, t, tx, ty, by, bx, stX, stY, ddy, ddx: Longint; |
5332 | 710 |
despeckle : Boolean; |
184 | 711 |
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
|
712 |
stY:= hwRound(Y); |
1809 | 713 |
stX:= hwRound(X); |
772
e8d530ca77be
Don't update all land texture when drawing tunnel (saves video throughput)
unc0rr
parents:
769
diff
changeset
|
714 |
|
5332 | 715 |
despeckle:= HalfWidth > 1; |
716 |
||
184 | 717 |
nx:= X + dY * (HalfWidth + 8); |
718 |
ny:= Y - dX * (HalfWidth + 8); |
|
719 |
||
358 | 720 |
dX8:= dX * 8; |
721 |
dY8:= dY * 8; |
|
184 | 722 |
for i:= 0 to 7 do |
723 |
begin |
|
358 | 724 |
X:= nx - dX8; |
725 |
Y:= ny - dY8; |
|
184 | 726 |
for t:= -8 to ticks + 8 do |
2666 | 727 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
728 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
729 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
730 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
731 |
ty:= hwRound(Y); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
732 |
if ((ty and LAND_HEIGHT_MASK) = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
733 |
and ((tx and LAND_WIDTH_MASK) = 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
734 |
and (((Land[ty, tx] and lfBasic) <> 0) or ((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
|
735 |
begin |
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
736 |
Land[ty, tx]:= Land[ty, tx] and not lfIce; |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
737 |
if despeckle then |
5887 | 738 |
begin |
739 |
Land[ty, tx]:= Land[ty, tx] or lfDamaged; |
|
740 |
LandDirty[ty div 32, tx div 32]:= 1 |
|
741 |
end; |
|
5332 | 742 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 743 |
LandPixels[ty, tx]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
744 |
else |
6982 | 745 |
LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor |
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
|
746 |
end |
2666 | 747 |
end; |
184 | 748 |
nx:= nx - dY; |
749 |
ny:= ny + dX; |
|
750 |
end; |
|
751 |
||
752 |
for i:= -HalfWidth to HalfWidth do |
|
753 |
begin |
|
358 | 754 |
X:= nx - dX8; |
755 |
Y:= ny - dY8; |
|
184 | 756 |
for t:= 0 to 7 do |
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
|
757 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
758 |
X:= X + dX; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
759 |
Y:= Y + dY; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
760 |
tx:= hwRound(X); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
761 |
ty:= hwRound(Y); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
762 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
763 |
or ((Land[ty, tx] and lfObject) <> 0)) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
764 |
begin |
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
765 |
Land[ty, tx]:= (Land[ty, tx] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
766 |
if despeckle then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
767 |
LandDirty[ty div 32, tx div 32]:= 1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
768 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 769 |
LandPixels[ty, tx]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
770 |
else |
6982 | 771 |
LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
772 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
773 |
end; |
184 | 774 |
X:= nx; |
775 |
Y:= ny; |
|
776 |
for t:= 0 to ticks do |
|
777 |
begin |
|
778 |
X:= X + dX; |
|
779 |
Y:= Y + dY; |
|
351 | 780 |
tx:= hwRound(X); |
781 |
ty:= hwRound(Y); |
|
3519 | 782 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and ((Land[ty, tx] and lfIndestructible) = 0) then |
2647 | 783 |
begin |
5480 | 784 |
if (cReducedQuality and rqBlurryLand) = 0 then |
785 |
begin |
|
786 |
by:= ty; bx:= tx; |
|
787 |
end |
|
4690
490cf71b436a
revert last change. ordinary fire is fine, but HHG screws up.
nemo
parents:
4688
diff
changeset
|
788 |
else |
5480 | 789 |
begin |
790 |
by:= ty div 2; bx:= tx div 2; |
|
791 |
end; |
|
6355 | 792 |
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
|
793 |
LandPixels[by, bx]:= LandBackPixel(tx, ty) |
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
794 |
else if ((Land[ty, tx] and lfObject) <> 0) or (((LandPixels[by,bx] and AMask) shr AShift) < 255) then |
6097 | 795 |
LandPixels[by, bx]:= 0; |
796 |
Land[ty, tx]:= 0; |
|
2647 | 797 |
end |
184 | 798 |
end; |
799 |
for t:= 0 to 7 do |
|
2666 | 800 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
801 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
802 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
803 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
804 |
ty:= hwRound(Y); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
805 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
806 |
or ((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
|
807 |
begin |
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
808 |
Land[ty, tx]:=( Land[ty, tx] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
809 |
if despeckle then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
810 |
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
|
811 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 812 |
LandPixels[ty, tx]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
813 |
else |
6982 | 814 |
LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor |
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
|
815 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
816 |
end; |
184 | 817 |
nx:= nx - dY; |
818 |
ny:= ny + dX; |
|
819 |
end; |
|
820 |
||
821 |
for i:= 0 to 7 do |
|
822 |
begin |
|
358 | 823 |
X:= nx - dX8; |
824 |
Y:= ny - dY8; |
|
184 | 825 |
for t:= -8 to ticks + 8 do |
2666 | 826 |
begin |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
827 |
X:= X + dX; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
828 |
Y:= Y + dY; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
829 |
tx:= hwRound(X); |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
830 |
ty:= hwRound(Y); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
831 |
if ((ty and LAND_HEIGHT_MASK) = 0) and ((tx and LAND_WIDTH_MASK) = 0) and (((Land[ty, tx] and lfBasic) <> 0) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
832 |
or ((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
|
833 |
begin |
8579
d18bc19d780a
graphics tweak. flag a couple more overeager setall HH
nemo
parents:
7509
diff
changeset
|
834 |
Land[ty, tx]:= (Land[ty, tx] or lfDamaged) and not lfIce; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
835 |
if despeckle then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
836 |
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
|
837 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6982 | 838 |
LandPixels[ty, tx]:= ExplosionBorderColor |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
839 |
else |
6982 | 840 |
LandPixels[ty div 2, tx div 2]:= ExplosionBorderColor |
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
|
841 |
end |
2666 | 842 |
end; |
184 | 843 |
nx:= nx - dY; |
844 |
ny:= ny + dX; |
|
845 |
end; |
|
846 |
||
4374 | 847 |
tx:= Max(stX - HalfWidth * 2 - 4 - abs(hwRound(dX * ticks)), 0); |
848 |
ty:= Max(stY - HalfWidth * 2 - 4 - abs(hwRound(dY * ticks)), 0); |
|
849 |
ddx:= Min(stX + HalfWidth * 2 + 4 + abs(hwRound(dX * ticks)), LAND_WIDTH) - tx; |
|
850 |
ddy:= Min(stY + HalfWidth * 2 + 4 + abs(hwRound(dY * ticks)), LAND_HEIGHT) - ty; |
|
1809 | 851 |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7150
diff
changeset
|
852 |
UpdateLandTexture(tx, ddx, ty, ddy, false) |
184 | 853 |
end; |
854 |
||
4886 | 855 |
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
|
856 |
var X, Y, bpp, h, w, row, col, gx, gy, numFramesFirstCol: LongInt; |
409 | 857 |
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
|
858 |
Image: PSDL_Surface; |
409 | 859 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
860 |
TryPlaceOnLand:= false; |
2235 | 861 |
numFramesFirstCol:= SpritesData[Obj].imageHeight div SpritesData[Obj].Height; |
862 |
||
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
863 |
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
|
864 |
Image:= SpritesData[Obj].Surface; |
409 | 865 |
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
|
866 |
h:= SpritesData[Obj].Height; |
2235 | 867 |
row:= Frame mod numFramesFirstCol; |
868 |
col:= Frame div numFramesFirstCol; |
|
409 | 869 |
|
870 |
if SDL_MustLock(Image) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
871 |
SDLTry(SDL_LockSurface(Image) >= 0, true); |
409 | 872 |
|
873 |
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
|
874 |
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
|
875 |
// Check that sprite fits free space |
2236 | 876 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 877 |
case bpp of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
878 |
4: for y:= 0 to Pred(h) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
879 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
880 |
for x:= 0 to Pred(w) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
881 |
if (PLongword(@(p^[x * 4]))^) <> 0 then |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
882 |
if ((cpY + y) <= Longint(topY)) or ((cpY + y) >= LAND_HEIGHT) or |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
883 |
((cpX + x) <= Longint(leftX)) or ((cpX + x) >= Longint(rightX)) or (Land[cpY + y, cpX + x] <> 0) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
884 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
885 |
if SDL_MustLock(Image) then |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
886 |
SDL_UnlockSurface(Image); |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
887 |
exit; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
888 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
889 |
p:= @(p^[Image^.pitch]); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
890 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
891 |
end; |
409 | 892 |
|
520 | 893 |
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
|
894 |
if not doPlace then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
895 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
896 |
if SDL_MustLock(Image) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
897 |
SDL_UnlockSurface(Image); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
898 |
exit |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
899 |
end; |
520 | 900 |
|
409 | 901 |
// Checked, now place |
2236 | 902 |
p:= @(PByteArray(Image^.pixels)^[ Image^.pitch * row * h + col * w * 4 ]); |
409 | 903 |
case bpp of |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
904 |
4: for y:= 0 to Pred(h) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
905 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
906 |
for x:= 0 to Pred(w) do |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
907 |
if (PLongword(@(p^[x * 4]))^) <> 0 then |
769
788efc1d649f
- Save 8 MB of memory by freeing LandSurface and not using it anymore after game initialization
unc0rr
parents:
768
diff
changeset
|
908 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
909 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
910 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
911 |
gX:= cpX + x; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
912 |
gY:= cpY + y; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
913 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
914 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
915 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
916 |
gX:= (cpX + x) div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
917 |
gY:= (cpY + y) div 2; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
918 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
919 |
if indestructible then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
920 |
Land[cpY + y, cpX + x]:= lfIndestructible |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
921 |
else if (LandPixels[gY, gX] and AMask) shr AShift = 255 then // This test assumes lfBasic and lfObject differ only graphically |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
922 |
Land[cpY + y, cpX + x]:= lfBasic |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
923 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
924 |
Land[cpY + y, cpX + x]:= lfObject; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
925 |
// For testing only. Intent is to flag this on objects with masks, or use it for an ice ray gun |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
926 |
if (Theme = 'Snow') or (Theme = 'Christmas') then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
927 |
Land[cpY + y, cpX + x]:= Land[cpY + y, cpX + x] or lfIce; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
928 |
LandPixels[gY, gX]:= PLongword(@(p^[x * 4]))^ |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
929 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
930 |
p:= @(p^[Image^.pitch]); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
931 |
end; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
932 |
end; |
409 | 933 |
if SDL_MustLock(Image) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
934 |
SDL_UnlockSurface(Image); |
409 | 935 |
|
4374 | 936 |
x:= Max(cpX, leftX); |
937 |
w:= Min(cpX + Image^.w, LAND_WIDTH) - x; |
|
938 |
y:= Max(cpY, topY); |
|
939 |
h:= Min(cpY + Image^.h, LAND_HEIGHT) - y; |
|
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7150
diff
changeset
|
940 |
UpdateLandTexture(x, w, y, h, true) |
409 | 941 |
end; |
942 |
||
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
|
943 |
function Despeckle(X, Y: LongInt): boolean; |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
944 |
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
|
945 |
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
|
946 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
947 |
Despeckle:= true; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
948 |
|
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
949 |
if (cReducedQuality and rqBlurryLand) = 0 then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
950 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
951 |
xx:= X; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
952 |
yy:= Y; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
953 |
end |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
954 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
955 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
956 |
xx:= X div 2; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
957 |
yy:= Y div 2; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
958 |
end; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
959 |
|
8751
4609823efc94
More flagging of Land values. Also use less than for tests of non-terrain, instead of "and $FF00 = 0". Saves a couple of ops, which actually matters a small amount in a few places.
nemo
parents:
8744
diff
changeset
|
960 |
pixelsweep:= (Land[Y, X] <= lfAllObjMask) and (LandPixels[yy, xx] <> 0); |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
961 |
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
|
962 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
963 |
c:= 0; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
964 |
for i:= -1 to 1 do |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
965 |
for j:= -1 to 1 do |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
966 |
if (i <> 0) or (j <> 0) then |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
967 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
968 |
ny:= Y + i; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
969 |
nx:= X + j; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
970 |
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
|
971 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
972 |
if pixelsweep then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
973 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
974 |
if ((cReducedQuality and rqBlurryLand) <> 0) then |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
975 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
976 |
nx:= nx div 2; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
977 |
ny:= ny div 2 |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
978 |
end; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
979 |
if LandPixels[ny, nx] <> 0 then |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
980 |
inc(c); |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
981 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
982 |
else if Land[ny, nx] > 255 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
983 |
inc(c); |
4695
ac2cb3b99d70
add a disabling for landback, set it if flakes are enabled
nemo
parents:
4690
diff
changeset
|
984 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
985 |
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
|
986 |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
987 |
if c < 4 then // 0-3 neighbours |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
988 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
989 |
if ((Land[Y, X] and lfBasic) <> 0) and (not disableLandBack) then |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
990 |
LandPixels[yy, xx]:= LandBackPixel(X, Y) |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
991 |
else |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
992 |
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
|
993 |
|
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
994 |
if not pixelsweep then |
6681 | 995 |
begin |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
996 |
Land[Y, X]:= 0; |
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
997 |
exit |
6681 | 998 |
end |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
999 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
1000 |
end; |
6990
40e5af28d026
change every return value into a more pascal-ish form, using the name of the fucntion (helps the parser and macpas compaitilibity)
koda
parents:
6982
diff
changeset
|
1001 |
Despeckle:= false |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
1002 |
end; |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
1003 |
|
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
1004 |
procedure Smooth(X, Y: LongInt); |
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
1005 |
begin |
5261 | 1006 |
// a bit of AA for explosions |
7492
3188794b9d87
Perf opt for the c conversion. Use downto instead to avoid repeated function calls in the loop
nemo
parents:
7270
diff
changeset
|
1007 |
if (Land[Y, X] = 0) and (Y > LongInt(topY) + 1) and |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1008 |
(Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then |
5261 | 1009 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1010 |
if ((((Land[y, x-1] and lfDamaged) <> 0) and (((Land[y+1,x] and lfDamaged) <> 0)) or ((Land[y-1,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1011 |
or (((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then |
5261 | 1012 |
begin |
5274 | 1013 |
if (cReducedQuality and rqBlurryLand) = 0 then |
1014 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1015 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then |
6982 | 1016 |
LandPixels[y,x]:= (ExplosionBorderColor and (not AMask)) or (128 shl AShift) |
5274 | 1017 |
else |
1018 |
LandPixels[y,x]:= |
|
6982 | 1019 |
(((((LandPixels[y,x] and RMask shr RShift) div 2)+((ExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or |
1020 |
(((((LandPixels[y,x] and GMask shr GShift) div 2)+((ExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or |
|
1021 |
(((((LandPixels[y,x] and BMask shr BShift) div 2)+((ExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift) |
|
5274 | 1022 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1023 |
if (Land[y, x-1] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1024 |
Land[y,x]:= lfObject |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1025 |
else if (Land[y, x+1] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1026 |
Land[y,x]:= lfObject |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1027 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1028 |
Land[y,x]:= lfBasic; |
5261 | 1029 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1030 |
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)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1031 |
or (((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1032 |
or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1033 |
or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1034 |
or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1035 |
or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1036 |
or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1037 |
or (((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 |
5261 | 1038 |
begin |
5274 | 1039 |
if (cReducedQuality and rqBlurryLand) = 0 then |
1040 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1041 |
if ((LandPixels[y,x] and AMask) shr AShift) < 10 then |
6982 | 1042 |
LandPixels[y,x]:= (ExplosionBorderColor and (not AMask)) or (64 shl AShift) |
5274 | 1043 |
else |
1044 |
LandPixels[y,x]:= |
|
6982 | 1045 |
(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((ExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or |
1046 |
(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((ExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or |
|
1047 |
(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((ExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift) |
|
5274 | 1048 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1049 |
if (Land[y, x-1] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1050 |
Land[y, x]:= lfObject |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1051 |
else if (Land[y, x+1] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1052 |
Land[y, x]:= lfObject |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1053 |
else if (Land[y+1, x] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1054 |
Land[y, x]:= lfObject |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1055 |
else if (Land[y-1, x] = lfObject) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1056 |
Land[y, x]:= lfObject |
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
|
1057 |
else Land[y,x]:= lfBasic |
5261 | 1058 |
end |
5267
e9ae019e9bb4
move smoothing into separate function, adjust call order
nemo
parents:
5266
diff
changeset
|
1059 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1060 |
else if ((cReducedQuality and rqBlurryLand) = 0) and (LandPixels[Y, X] and AMask = 255) |
8598
9d21bab30893
Apologies if jaree had done something similar, but didn't see anything in repo pull. This removes Land[] mixed w/ LandPixels[] and streamlines things a little
nemo
parents:
8596
diff
changeset
|
1061 |
and (Land[Y, X] and (lfDamaged or lfBasic) = lfBasic) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1062 |
and (Y > LongInt(topY) + 1) and (Y < LAND_HEIGHT-2) and (X > LongInt(leftX) + 1) and (X < LongInt(rightX) - 1) then |
6130 | 1063 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1064 |
if ((((Land[y, x-1] and lfDamaged) <> 0) and (((Land[y+1,x] and lfDamaged) <> 0)) or ((Land[y-1,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1065 |
or (((Land[y, x+1] and lfDamaged) <> 0) and (((Land[y-1,x] and lfDamaged) <> 0) or ((Land[y+1,x] and lfDamaged) <> 0)))) then |
6130 | 1066 |
begin |
1067 |
LandPixels[y,x]:= |
|
6982 | 1068 |
(((((LandPixels[y,x] and RMask shr RShift) div 2)+((ExplosionBorderColor and RMask) shr RShift) div 2) and $FF) shl RShift) or |
1069 |
(((((LandPixels[y,x] and GMask shr GShift) div 2)+((ExplosionBorderColor and GMask) shr GShift) div 2) and $FF) shl GShift) or |
|
1070 |
(((((LandPixels[y,x] and BMask shr BShift) div 2)+((ExplosionBorderColor and BMask) shr BShift) div 2) and $FF) shl BShift) or ($FF shl AShift) |
|
6130 | 1071 |
end |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1072 |
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)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1073 |
or (((Land[y, x-1] and lfDamaged) <> 0) and ((Land[y-1,x-1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1074 |
or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y+2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1075 |
or (((Land[y, x+1] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y-2,x] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1076 |
or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1077 |
or (((Land[y-1, x] and lfDamaged) <> 0) and ((Land[y-1,x+1] and lfDamaged) <> 0) and ((Land[y,x+2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1078 |
or (((Land[y+1, x] and lfDamaged) <> 0) and ((Land[y+1,x-1] and lfDamaged) <> 0) and ((Land[y,x-2] and lfDamaged) <> 0)) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1079 |
or (((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 |
6130 | 1080 |
begin |
1081 |
LandPixels[y,x]:= |
|
6982 | 1082 |
(((((LandPixels[y,x] and RMask shr RShift) * 3 div 4)+((ExplosionBorderColor and RMask) shr RShift) div 4) and $FF) shl RShift) or |
1083 |
(((((LandPixels[y,x] and GMask shr GShift) * 3 div 4)+((ExplosionBorderColor and GMask) shr GShift) div 4) and $FF) shl GShift) or |
|
1084 |
(((((LandPixels[y,x] and BMask shr BShift) * 3 div 4)+((ExplosionBorderColor and BMask) shr BShift) div 4) and $FF) shl BShift) or ($FF shl AShift) |
|
6130 | 1085 |
end |
1086 |
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
|
1087 |
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
|
1088 |
|
1792 | 1089 |
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
|
1090 |
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
|
1091 |
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
|
1092 |
begin |
2695 | 1093 |
bRes:= false; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1094 |
reCheck:= true; |
1792 | 1095 |
|
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1096 |
while recheck do |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
1097 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1098 |
recheck:= false; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1099 |
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
|
1100 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1101 |
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
|
1102 |
begin |
5895 | 1103 |
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
|
1104 |
begin |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1105 |
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
|
1106 |
resweep:= true; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
1107 |
ty:= y * 32; |
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
1108 |
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
|
1109 |
while(resweep) do |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1110 |
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
|
1111 |
resweep:= false; |
3602
99c93fa258d6
Restore prior optimisation with the wildly out-of-bounds tx in LandDirty removed
nemo
parents:
3601
diff
changeset
|
1112 |
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
|
1113 |
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
|
1114 |
if Despeckle(xx, yy) then |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1115 |
begin |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1116 |
bRes:= true; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1117 |
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
|
1118 |
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
|
1119 |
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
|
1120 |
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
|
1121 |
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
|
1122 |
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
|
1123 |
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
|
1124 |
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
|
1125 |
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
|
1126 |
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
|
1127 |
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
|
1128 |
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
|
1129 |
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
|
1130 |
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
|
1131 |
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
|
1132 |
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
|
1133 |
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
|
1134 |
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
|
1135 |
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
|
1136 |
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
|
1137 |
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
|
1138 |
end |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1139 |
end; |
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1140 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1141 |
if updateBlock then |
7170
84ac6c6d2d8e
Only create textures for non-empty LandPixel chunks. This should save a fair amount of memory, especially on smaller maps, and eliminate a number of draws
nemo
parents:
7150
diff
changeset
|
1142 |
UpdateLandTexture(tx, 32, ty, 32, false); |
5895 | 1143 |
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
|
1144 |
end; |
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
1145 |
end; |
3f21a9dc93d0
Replace tabs with spaces using 'expand -t 4' command
unc0rr
parents:
2741
diff
changeset
|
1146 |
end; |
3554
066faceb977d
Extend pixel sweep to recheck neighbours if erasing on edges
nemo
parents:
3521
diff
changeset
|
1147 |
end; |
1792 | 1148 |
|
5895 | 1149 |
for y:= 0 to LAND_HEIGHT div 32 - 1 do |
1150 |
for x:= 0 to LAND_WIDTH div 32 - 1 do |
|
1151 |
if LandDirty[y, x] <> 0 then |
|
1152 |
begin |
|
1153 |
LandDirty[y, x]:= 0; |
|
1154 |
ty:= y * 32; |
|
1155 |
tx:= x * 32; |
|
1156 |
for yy:= ty to ty + 31 do |
|
1157 |
for xx:= tx to tx + 31 do |
|
1158 |
Smooth(xx,yy) |
|
1159 |
end; |
|
1160 |
||
2695 | 1161 |
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
|
1162 |
end; |
184 | 1163 |
|
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
|
1164 |
|
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
|
1165 |
// 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
|
1166 |
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
|
1167 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1168 |
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
|
1169 |
end; |
4367 | 1170 |
|
6096
a00dbbf49d6c
Add landbacktex to a few maps, just to see how it looks.
nemo
parents:
6081
diff
changeset
|
1171 |
function LandBackPixel(x, y: LongInt): LongWord; inline; |
4367 | 1172 |
var p: PLongWordArray; |
1173 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1174 |
if LandBackSurface = nil then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1175 |
LandBackPixel:= 0 |
4367 | 1176 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1177 |
begin |
4367 | 1178 |
p:= LandBackSurface^.pixels; |
1179 |
LandBackPixel:= p^[LandBackSurface^.w * (y mod LandBackSurface^.h) + (x mod LandBackSurface^.w)];// or $FF000000; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1180 |
end |
4367 | 1181 |
end; |
1182 |
||
1183 |
||
6490 | 1184 |
procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword); |
1185 |
var |
|
1186 |
eX, eY, dX, dY: LongInt; |
|
1187 |
i, sX, sY, x, y, d: LongInt; |
|
1188 |
begin |
|
1189 |
eX:= 0; |
|
1190 |
eY:= 0; |
|
1191 |
dX:= X2 - X1; |
|
1192 |
dY:= Y2 - Y1; |
|
1193 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1194 |
if (dX > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1195 |
sX:= 1 |
6490 | 1196 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1197 |
if (dX < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1198 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1199 |
sX:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1200 |
dX:= -dX |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1201 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1202 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1203 |
sX:= dX; |
6490 | 1204 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1205 |
if (dY > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1206 |
sY:= 1 |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1207 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1208 |
if (dY < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1209 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1210 |
sY:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1211 |
dY:= -dY |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1212 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1213 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1214 |
sY:= dY; |
6490 | 1215 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1216 |
if (dX > dY) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1217 |
d:= dX |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1218 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1219 |
d:= dY; |
6490 | 1220 |
|
1221 |
x:= X1; |
|
1222 |
y:= Y1; |
|
1223 |
||
1224 |
for i:= 0 to d do |
|
1225 |
begin |
|
1226 |
inc(eX, dX); |
|
1227 |
inc(eY, dY); |
|
1228 |
if (eX > d) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1229 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1230 |
dec(eX, d); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1231 |
inc(x, sX); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1232 |
end; |
6490 | 1233 |
if (eY > d) then |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1234 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1235 |
dec(eY, d); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1236 |
inc(y, sY); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1237 |
end; |
6490 | 1238 |
|
1239 |
if ((x and LAND_WIDTH_MASK) = 0) and ((y and LAND_HEIGHT_MASK) = 0) then |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6490
diff
changeset
|
1240 |
Land[y, x]:= Color; |
6490 | 1241 |
end |
1242 |
end; |
|
1243 |
||
7150
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1244 |
procedure DrawDots(x, y, xx, yy: Longint; Color: Longword); inline; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1245 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1246 |
if (((x + xx) and LAND_WIDTH_MASK) = 0) and (((y + yy) and LAND_HEIGHT_MASK) = 0) then Land[y + yy, x + xx]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1247 |
if (((x + xx) and LAND_WIDTH_MASK) = 0) and (((y - yy) and LAND_HEIGHT_MASK) = 0) then Land[y - yy, x + xx]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1248 |
if (((x - xx) and LAND_WIDTH_MASK) = 0) and (((y + yy) and LAND_HEIGHT_MASK) = 0) then Land[y + yy, x - xx]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1249 |
if (((x - xx) and LAND_WIDTH_MASK) = 0) and (((y - yy) and LAND_HEIGHT_MASK) = 0) then Land[y - yy, x - xx]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1250 |
if (((x + yy) and LAND_WIDTH_MASK) = 0) and (((y + xx) and LAND_HEIGHT_MASK) = 0) then Land[y + xx, x + yy]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1251 |
if (((x + yy) and LAND_WIDTH_MASK) = 0) and (((y - xx) and LAND_HEIGHT_MASK) = 0) then Land[y - xx, x + yy]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1252 |
if (((x - yy) and LAND_WIDTH_MASK) = 0) and (((y + xx) and LAND_HEIGHT_MASK) = 0) then Land[y + xx, x - yy]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1253 |
if (((x - yy) and LAND_WIDTH_MASK) = 0) and (((y - xx) and LAND_HEIGHT_MASK) = 0) then Land[y - xx, x - yy]:= Color; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1254 |
end; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1255 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1256 |
procedure DrawLines(X1, Y1, X2, Y2, XX, YY: LongInt; color: Longword); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1257 |
var |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1258 |
eX, eY, dX, dY: LongInt; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1259 |
i, sX, sY, x, y, d: LongInt; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1260 |
f: boolean; |
7147 | 1261 |
begin |
7150
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1262 |
eX:= 0; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1263 |
eY:= 0; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1264 |
dX:= X2 - X1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1265 |
dY:= Y2 - Y1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1266 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1267 |
if (dX > 0) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1268 |
sX:= 1 |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1269 |
else |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1270 |
if (dX < 0) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1271 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1272 |
sX:= -1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1273 |
dX:= -dX |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1274 |
end |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1275 |
else |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1276 |
sX:= dX; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1277 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1278 |
if (dY > 0) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1279 |
sY:= 1 |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1280 |
else |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1281 |
if (dY < 0) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1282 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1283 |
sY:= -1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1284 |
dY:= -dY |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1285 |
end |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1286 |
else |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1287 |
sY:= dY; |
7147 | 1288 |
|
7150
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1289 |
if (dX > dY) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1290 |
d:= dX |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1291 |
else |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1292 |
d:= dY; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1293 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1294 |
x:= X1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1295 |
y:= Y1; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1296 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1297 |
for i:= 0 to d do |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1298 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1299 |
inc(eX, dX); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1300 |
inc(eY, dY); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1301 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1302 |
f:= eX > d; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1303 |
if f then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1304 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1305 |
dec(eX, d); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1306 |
inc(x, sX); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1307 |
DrawDots(x, y, xx, yy, color) |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1308 |
end; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1309 |
if (eY > d) then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1310 |
begin |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1311 |
dec(eY, d); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1312 |
inc(y, sY); |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1313 |
f:= true; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1314 |
DrawDots(x, y, xx, yy, color) |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1315 |
end; |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1316 |
|
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1317 |
if not f then |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1318 |
DrawDots(x, y, xx, yy, color) |
fba3b14ff746
This should make drawn maps rendering even more faster
unc0rr
parents:
7147
diff
changeset
|
1319 |
end |
7147 | 1320 |
end; |
1321 |
||
1322 |
procedure DrawThickLine(X1, Y1, X2, Y2, radius: LongInt; color: Longword); |
|
1323 |
var dx, dy, d: LongInt; |
|
1324 |
begin |
|
1325 |
dx:= 0; |
|
1326 |
dy:= Radius; |
|
1327 |
d:= 3 - 2 * Radius; |
|
1328 |
while (dx < dy) do |
|
1329 |
begin |
|
1330 |
DrawLines(x1, y1, x2, y2, dx, dy, color); |
|
1331 |
if (d < 0) then |
|
1332 |
d:= d + 4 * dx + 6 |
|
1333 |
else |
|
1334 |
begin |
|
1335 |
d:= d + 4 * (dx - dy) + 10; |
|
1336 |
dec(dy) |
|
1337 |
end; |
|
1338 |
inc(dx) |
|
1339 |
end; |
|
1340 |
if (dx = dy) then |
|
1341 |
DrawLines(x1, y1, x2, y2, dx, dy, color); |
|
1342 |
end; |
|
1343 |
||
7268 | 1344 |
|
1345 |
procedure DumpLandToLog(x, y, r: LongInt); |
|
1346 |
var xx, yy, dx: LongInt; |
|
1347 |
s: shortstring; |
|
1348 |
begin |
|
1349 |
s[0]:= char(r * 2 + 1); |
|
1350 |
for yy:= y - r to y + r do |
|
1351 |
begin |
|
1352 |
for dx:= 0 to r*2 do |
|
1353 |
begin |
|
1354 |
xx:= dx - r + x; |
|
1355 |
if (xx = x) and (yy = y) then |
|
1356 |
s[dx + 1]:= 'X' |
|
1357 |
else if Land[yy, xx] > 255 then |
|
1358 |
s[dx + 1]:= 'O' |
|
1359 |
else if Land[yy, xx] > 0 then |
|
1360 |
s[dx + 1]:= '*' |
|
1361 |
else |
|
1362 |
s[dx + 1]:= '.' |
|
1363 |
end; |
|
1364 |
AddFileLog('Land dump: ' + s); |
|
1365 |
end; |
|
1366 |
end; |
|
1367 |
||
184 | 1368 |
end. |