author | nemo |
Sat, 25 Aug 2012 09:17:42 -0400 | |
changeset 7598 | f06d8603097c |
parent 7547 | 6e9c5feb88eb |
child 7671 | 43f38923bc6e |
permissions | -rw-r--r-- |
4976 | 1 |
(* |
2 |
* Hedgewars, a free turn based strategy game |
|
6700 | 3 |
* Copyright (c) 2004-2012 Andrey Korotaev <unC0Rr@gmail.com> |
4976 | 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 |
||
4388 | 19 |
{$INCLUDE "options.inc"} |
4976 | 20 |
|
4388 | 21 |
unit uGearsRender; |
22 |
||
23 |
interface |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7339
diff
changeset
|
24 |
uses uTypes, uConsts, GLunit, uFloat, SDLh, uRandom; |
4388 | 25 |
|
26 |
procedure RenderGear(Gear: PGear; x, y: LongInt); |
|
27 |
||
28 |
var RopePoints: record |
|
29 |
Count: Longword; |
|
30 |
HookAngle: GLfloat; |
|
31 |
ar: array[0..MAXROPEPOINTS] of record |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
32 |
X, Y: hwFloat; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
33 |
dLen: hwFloat; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
34 |
b: boolean; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
35 |
end; |
4388 | 36 |
rounded: array[0..MAXROPEPOINTS + 2] of TVertex2f; |
37 |
end; |
|
38 |
||
39 |
implementation |
|
7093 | 40 |
uses uRender, uUtils, uVariables, uAmmos, Math, uVisualGears; |
4388 | 41 |
|
42 |
procedure DrawRopeLinesRQ(Gear: PGear); |
|
43 |
begin |
|
44 |
with RopePoints do |
|
45 |
begin |
|
46 |
rounded[Count].X:= hwRound(Gear^.X); |
|
47 |
rounded[Count].Y:= hwRound(Gear^.Y); |
|
48 |
rounded[Count + 1].X:= hwRound(Gear^.Hedgehog^.Gear^.X); |
|
49 |
rounded[Count + 1].Y:= hwRound(Gear^.Hedgehog^.Gear^.Y); |
|
50 |
end; |
|
51 |
||
52 |
if (RopePoints.Count > 0) or (Gear^.Elasticity.QWordValue > 0) then |
|
53 |
begin |
|
54 |
glDisable(GL_TEXTURE_2D); |
|
55 |
//glEnable(GL_LINE_SMOOTH); |
|
56 |
||
57 |
glPushMatrix; |
|
58 |
||
59 |
glTranslatef(WorldDx, WorldDy, 0); |
|
60 |
||
61 |
glLineWidth(4.0); |
|
62 |
||
63 |
Tint($C0, $C0, $C0, $FF); |
|
64 |
||
65 |
glVertexPointer(2, GL_FLOAT, 0, @RopePoints.rounded[0]); |
|
66 |
glDrawArrays(GL_LINE_STRIP, 0, RopePoints.Count + 2); |
|
67 |
Tint($FF, $FF, $FF, $FF); |
|
68 |
||
69 |
glPopMatrix; |
|
70 |
||
71 |
glEnable(GL_TEXTURE_2D); |
|
72 |
//glDisable(GL_LINE_SMOOTH) |
|
73 |
end |
|
74 |
end; |
|
75 |
||
76 |
||
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
77 |
function DrawRopeLine(X1, Y1, X2, Y2, roplen: LongInt): LongInt; |
6490 | 78 |
var eX, eY, dX, dY: LongInt; |
79 |
i, sX, sY, x, y, d: LongInt; |
|
80 |
b: boolean; |
|
81 |
begin |
|
4388 | 82 |
if (X1 = X2) and (Y1 = Y2) then |
6490 | 83 |
begin |
84 |
//OutError('WARNING: zero length rope line!', false); |
|
85 |
exit |
|
86 |
end; |
|
4388 | 87 |
eX:= 0; |
88 |
eY:= 0; |
|
89 |
dX:= X2 - X1; |
|
90 |
dY:= Y2 - Y1; |
|
91 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
92 |
if (dX > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
93 |
sX:= 1 |
4388 | 94 |
else |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
95 |
if (dX < 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
96 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
97 |
sX:= -1; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
98 |
dX:= -dX |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
99 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
100 |
else sX:= dX; |
4388 | 101 |
|
6490 | 102 |
if (dY > 0) then |
103 |
sY:= 1 |
|
4388 | 104 |
else |
6490 | 105 |
if (dY < 0) then |
4388 | 106 |
begin |
6490 | 107 |
sY:= -1; |
108 |
dY:= -dY |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
109 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
110 |
else |
6490 | 111 |
sY:= dY; |
112 |
||
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
113 |
if (dX > dY) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
114 |
d:= dX |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
115 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
116 |
d:= dY; |
6490 | 117 |
|
118 |
x:= X1; |
|
119 |
y:= Y1; |
|
120 |
||
121 |
for i:= 0 to d do |
|
122 |
begin |
|
123 |
inc(eX, dX); |
|
124 |
inc(eY, dY); |
|
125 |
b:= false; |
|
126 |
if (eX > d) then |
|
127 |
begin |
|
128 |
dec(eX, d); |
|
129 |
inc(x, sX); |
|
130 |
b:= true |
|
131 |
end; |
|
132 |
if (eY > d) then |
|
133 |
begin |
|
134 |
dec(eY, d); |
|
135 |
inc(y, sY); |
|
136 |
b:= true |
|
137 |
end; |
|
138 |
if b then |
|
139 |
begin |
|
140 |
inc(roplen); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
141 |
if (roplen mod 4) = 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
142 |
DrawSprite(sprRopeNode, x - 2, y - 2, 0) |
6490 | 143 |
end |
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
144 |
end; |
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
145 |
DrawRopeLine:= roplen; |
6490 | 146 |
end; |
147 |
||
148 |
procedure DrawRope(Gear: PGear); |
|
149 |
var roplen: LongInt; |
|
150 |
i: Longword; |
|
4388 | 151 |
begin |
152 |
if (cReducedQuality and rqSimpleRope) <> 0 then |
|
153 |
DrawRopeLinesRQ(Gear) |
|
154 |
else |
|
155 |
begin |
|
156 |
roplen:= 0; |
|
157 |
if RopePoints.Count > 0 then |
|
158 |
begin |
|
159 |
i:= 0; |
|
160 |
while i < Pred(RopePoints.Count) do |
|
161 |
begin |
|
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
162 |
roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, |
6490 | 163 |
hwRound(RopePoints.ar[Succ(i)].X) + WorldDx, hwRound(RopePoints.ar[Succ(i)].Y) + WorldDy, roplen); |
4388 | 164 |
inc(i) |
165 |
end; |
|
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
166 |
roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, |
6490 | 167 |
hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, roplen); |
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
168 |
roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, |
6490 | 169 |
hwRound(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwRound(Gear^.Hedgehog^.Gear^.Y) + WorldDy, roplen); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
170 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
171 |
else |
4388 | 172 |
if Gear^.Elasticity.QWordValue > 0 then |
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset
|
173 |
roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, |
6490 | 174 |
hwRound(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwRound(Gear^.Hedgehog^.Gear^.Y) + WorldDy, roplen); |
4388 | 175 |
end; |
176 |
||
177 |
||
178 |
if RopePoints.Count > 0 then |
|
6999 | 179 |
DrawSpriteRotated(sprRopeHook, hwRound(RopePoints.ar[0].X) + WorldDx, hwRound(RopePoints.ar[0].Y) + WorldDy, 1, RopePoints.HookAngle) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
180 |
else |
4388 | 181 |
if Gear^.Elasticity.QWordValue > 0 then |
6999 | 182 |
DrawSpriteRotated(sprRopeHook, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 183 |
end; |
184 |
||
185 |
||
186 |
procedure DrawAltWeapon(Gear: PGear; sx, sy: LongInt); |
|
187 |
begin |
|
188 |
with Gear^.Hedgehog^ do |
|
189 |
begin |
|
190 |
if not (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) and ((Gear^.State and gstAttacked) = 0)) then |
|
191 |
exit; |
|
192 |
DrawTexture(sx + 16, sy + 16, ropeIconTex); |
|
193 |
DrawTextureF(SpritesData[sprAMAmmos].Texture, 0.75, sx + 30, sy + 30, ord(CurAmmoType) - 1, 1, 32, 32); |
|
194 |
end; |
|
195 |
end; |
|
196 |
||
197 |
||
198 |
procedure DrawHH(Gear: PGear; ox, oy: LongInt); |
|
199 |
var i, t: LongInt; |
|
200 |
amt: TAmmoType; |
|
5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
201 |
sign, hx, hy, tx, ty, sx, sy, m: LongInt; // hedgehog, crosshair, temp, sprite, direction |
4388 | 202 |
dx, dy, ax, ay, aAngle, dAngle, hAngle, lx, ly: real; // laser, change |
203 |
defaultPos, HatVisible: boolean; |
|
204 |
HH: PHedgehog; |
|
205 |
CurWeapon: PAmmo; |
|
206 |
begin |
|
207 |
HH:= Gear^.Hedgehog; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
208 |
if HH^.Unplaced then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
209 |
exit; |
4388 | 210 |
m:= 1; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
211 |
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
212 |
m:= -1; |
4388 | 213 |
sx:= ox + 1; // this offset is very common |
214 |
sy:= oy - 3; |
|
215 |
sign:= hwSign(Gear^.dX); |
|
216 |
||
217 |
if (Gear^.State and gstHHDeath) <> 0 then |
|
218 |
begin |
|
219 |
DrawSprite(sprHHDeath, ox - 16, oy - 26, Gear^.Pos); |
|
4810 | 220 |
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); |
4388 | 221 |
DrawSprite(sprHHDeath, ox - 16, oy - 26, Gear^.Pos + 8); |
222 |
Tint($FF, $FF, $FF, $FF); |
|
223 |
exit |
|
224 |
end |
|
225 |
else if (Gear^.State and gstHHGone) <> 0 then |
|
226 |
begin |
|
6999 | 227 |
DrawSpriteRotatedF(sprTeleport, sx, sy, Gear^.Pos, sign, 0); |
4388 | 228 |
exit |
229 |
end; |
|
230 |
||
231 |
defaultPos:= true; |
|
232 |
HatVisible:= false; |
|
233 |
||
234 |
||
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
235 |
if HH^.Effects[hePoisoned] <> 0 then |
4388 | 236 |
begin |
237 |
Tint($00, $FF, $40, $40); |
|
6999 | 238 |
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 2, 0, 0, sx, sy, 0, 1, 22, 22, (RealTicks shr 36) mod 360); |
4388 | 239 |
Tint($FF, $FF, $FF, $FF) |
240 |
end; |
|
241 |
||
242 |
if ((Gear^.State and gstWinner) <> 0) and |
|
243 |
((CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtPickHammer)) then |
|
244 |
begin |
|
245 |
DrawHedgehog(sx, sy, |
|
246 |
sign, |
|
247 |
2, |
|
248 |
0, |
|
249 |
0); |
|
250 |
defaultPos:= false |
|
251 |
end; |
|
252 |
if (Gear^.State and gstDrowning) <> 0 then |
|
253 |
begin |
|
254 |
DrawHedgehog(sx, sy, |
|
255 |
sign, |
|
256 |
1, |
|
257 |
7, |
|
258 |
0); |
|
259 |
defaultPos:= false |
|
260 |
end else |
|
261 |
if (Gear^.State and gstLoser) <> 0 then |
|
262 |
begin |
|
263 |
DrawHedgehog(sx, sy, |
|
264 |
sign, |
|
265 |
2, |
|
266 |
3, |
|
267 |
0); |
|
268 |
defaultPos:= false |
|
269 |
end else |
|
270 |
||
271 |
if (Gear^.State and gstHHDriven) <> 0 then |
|
272 |
begin |
|
5145
120f4271f197
adjust crosshair criteria again. this should take care of sniper rifle and crosshair after attacking
nemo
parents:
5137
diff
changeset
|
273 |
if ((Gear^.State and (gstHHThinking or gstAnimation)) = 0) and |
5136
948da1e50205
Fix a few crosshair bugs. Disable ShowCrosshair and just decide when drawing.
nemo
parents:
5041
diff
changeset
|
274 |
/// If current ammo is active, and current ammo has alt attack and uses a crosshair (rope, basically, right now, with no crosshair for parachute/saucer |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
275 |
(((CurAmmoGear <> nil) and //((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) and |
5136
948da1e50205
Fix a few crosshair bugs. Disable ShowCrosshair and just decide when drawing.
nemo
parents:
5041
diff
changeset
|
276 |
((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_NoCrossHair) = 0)) or |
948da1e50205
Fix a few crosshair bugs. Disable ShowCrosshair and just decide when drawing.
nemo
parents:
5041
diff
changeset
|
277 |
/// If no current ammo is active, and the selected ammo uses a crosshair |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
278 |
((CurAmmoGear = nil) and ((Ammoz[HH^.CurAmmoType].Ammo.Propz and ammoprop_NoCrosshair) = 0) and ((Gear^.State and gstAttacked) = 0))) then |
4388 | 279 |
begin |
280 |
(* These calculations are a little complex for a few reasons: |
|
281 |
1: I need to draw the laser from weapon origin to nearest land |
|
282 |
2: I need to start the beam outside the hedgie for attractiveness. |
|
283 |
3: I need to extend the beam beyond land. |
|
284 |
This routine perhaps should be pushed into uStore or somesuch instead of continuuing the increase in size of this function. |
|
285 |
*) |
|
286 |
dx:= sign * m * Sin(Gear^.Angle * pi / cMaxAngle); |
|
287 |
dy:= -Cos(Gear^.Angle * pi / cMaxAngle); |
|
288 |
if cLaserSighting then |
|
289 |
begin |
|
290 |
lx:= GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle); |
|
291 |
ly:= GetLaunchY(HH^.CurAmmoType, Gear^.Angle); |
|
292 |
||
293 |
// ensure we start outside the hedgehog (he's solid after all) |
|
294 |
while abs(lx * lx + ly * ly) < (Gear^.radius * Gear^.radius) do |
|
295 |
begin |
|
296 |
lx:= lx + dx; |
|
297 |
ly:= ly + dy |
|
298 |
end; |
|
299 |
||
300 |
// add hog's position |
|
301 |
lx:= lx + ox - WorldDx; |
|
302 |
ly:= ly + oy - WorldDy; |
|
303 |
||
304 |
// decrease number of iterations required |
|
305 |
ax:= dx * 4; |
|
306 |
ay:= dy * 4; |
|
307 |
||
308 |
tx:= round(lx); |
|
309 |
ty:= round(ly); |
|
310 |
hx:= tx; |
|
311 |
hy:= ty; |
|
312 |
while ((ty and LAND_HEIGHT_MASK) = 0) and |
|
313 |
((tx and LAND_WIDTH_MASK) = 0) and |
|
314 |
(Land[ty, tx] = 0) do // TODO: check for constant variable instead |
|
315 |
begin |
|
316 |
lx:= lx + ax; |
|
317 |
ly:= ly + ay; |
|
318 |
tx:= round(lx); |
|
319 |
ty:= round(ly) |
|
320 |
end; |
|
321 |
// reached edge of land. assume infinite beam. Extend it way out past camera |
|
322 |
if ((ty and LAND_HEIGHT_MASK) <> 0) or ((tx and LAND_WIDTH_MASK) <> 0) then |
|
323 |
begin |
|
7165
aad1aea05f1e
add onGameTick20 to basic training, extend laser sight out way more (it was visible at top when completely zoomed out), move call of new turn to after AfterSwitchHedgehog to avoid lua issues in onNewTurn - if this causes problems, lua can do delayed actions in onGameTick
nemo
parents:
7098
diff
changeset
|
324 |
tx:= round(lx + ax * (LAND_WIDTH div 2)); |
aad1aea05f1e
add onGameTick20 to basic training, extend laser sight out way more (it was visible at top when completely zoomed out), move call of new turn to after AfterSwitchHedgehog to avoid lua issues in onNewTurn - if this causes problems, lua can do delayed actions in onGameTick
nemo
parents:
7098
diff
changeset
|
325 |
ty:= round(ly + ay * (LAND_WIDTH div 2)); |
4388 | 326 |
end; |
327 |
||
328 |
//if (abs(lx-tx)>8) or (abs(ly-ty)>8) then |
|
329 |
begin |
|
330 |
DrawLine(hx, hy, tx, ty, 1.0, $FF, $00, $00, $C0); |
|
331 |
end; |
|
332 |
end; |
|
333 |
// draw crosshair |
|
5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
334 |
CrosshairX := Round(hwRound(Gear^.X) + dx * 80 + GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle)); |
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
335 |
CrosshairY := Round(hwRound(Gear^.Y) + dy * 80 + GetLaunchY(HH^.CurAmmoType, Gear^.Angle)); |
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
336 |
|
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
337 |
|
6999 | 338 |
DrawTextureRotated(HH^.Team^.CrosshairTex, |
5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset
|
339 |
12, 12, CrosshairX + WorldDx, CrosshairY + WorldDy, 0, |
4388 | 340 |
sign * (Gear^.Angle * 180.0) / cMaxAngle); |
341 |
end; |
|
342 |
hx:= ox + 8 * sign; |
|
343 |
hy:= oy - 2; |
|
344 |
aangle:= Gear^.Angle * 180 / cMaxAngle - 90; |
|
5935 | 345 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind <> gtTardis) then |
4388 | 346 |
begin |
347 |
case CurAmmoGear^.Kind of |
|
348 |
gtShotgunShot: begin |
|
349 |
if (CurAmmoGear^.State and gstAnimation <> 0) then |
|
6999 | 350 |
DrawSpriteRotated(sprShotgun, hx, hy, sign, aangle) |
4388 | 351 |
else |
6999 | 352 |
DrawSpriteRotated(sprHandShotgun, hx, hy, sign, aangle); |
4388 | 353 |
end; |
6999 | 354 |
gtDEagleShot: DrawSpriteRotated(sprDEagle, hx, hy, sign, aangle); |
4388 | 355 |
gtSniperRifleShot: begin |
356 |
if (CurAmmoGear^.State and gstAnimation <> 0) then |
|
6999 | 357 |
DrawSpriteRotatedF(sprSniperRifle, hx, hy, 1, sign, aangle) |
4388 | 358 |
else |
6999 | 359 |
DrawSpriteRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle) |
4388 | 360 |
end; |
6999 | 361 |
gtBallgun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
4388 | 362 |
gtRCPlane: begin |
6999 | 363 |
DrawSpriteRotated(sprHandPlane, hx, hy, sign, 0); |
4388 | 364 |
defaultPos:= false |
365 |
end; |
|
366 |
gtRope: begin |
|
367 |
if Gear^.X < CurAmmoGear^.X then |
|
368 |
begin |
|
369 |
dAngle:= 0; |
|
370 |
hAngle:= 180; |
|
371 |
i:= 1 |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
372 |
end |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
373 |
else |
4388 | 374 |
begin |
375 |
dAngle:= 180; |
|
376 |
hAngle:= 0; |
|
377 |
i:= -1 |
|
378 |
end; |
|
7547 | 379 |
if ((Gear^.State and gstWinner) = 0) then |
380 |
begin |
|
381 |
DrawHedgehog(ox, oy, |
|
382 |
i, |
|
383 |
1, |
|
384 |
0, |
|
385 |
DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + dAngle); |
|
386 |
with HH^ do |
|
387 |
if (HatTex <> nil) then |
|
4388 | 388 |
begin |
7547 | 389 |
DrawTextureRotatedF(HatTex, 1.0, -1.0, -6.0, ox, oy, 0, i, 32, 32, |
4388 | 390 |
i*DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + hAngle); |
7547 | 391 |
if HatTex^.w > 64 then |
392 |
begin |
|
393 |
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); |
|
394 |
DrawTextureRotatedF(HatTex, 1.0, -1.0, -6.0, ox, oy, 32, i, 32, 32, |
|
395 |
i*DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + hAngle); |
|
396 |
Tint($FF, $FF, $FF, $FF) |
|
397 |
end |
|
4388 | 398 |
end |
399 |
end; |
|
400 |
DrawAltWeapon(Gear, ox, oy); |
|
401 |
defaultPos:= false |
|
402 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
403 |
gtBlowTorch: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
404 |
begin |
6999 | 405 |
DrawSpriteRotated(sprBlowTorch, hx, hy, sign, aangle); |
4388 | 406 |
DrawHedgehog(sx, sy, |
407 |
sign, |
|
408 |
3, |
|
409 |
HH^.visStepPos div 2, |
|
410 |
0); |
|
411 |
with HH^ do |
|
412 |
if (HatTex <> nil) then |
|
413 |
begin |
|
414 |
DrawTextureF(HatTex, |
|
415 |
1, |
|
416 |
sx, |
|
417 |
sy - 5, |
|
418 |
0, |
|
419 |
sign, |
|
420 |
32, |
|
421 |
32); |
|
422 |
if HatTex^.w > 64 then |
|
423 |
begin |
|
4810 | 424 |
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); |
4388 | 425 |
DrawTextureF(HatTex, |
426 |
1, |
|
427 |
sx, |
|
428 |
sy - 5, |
|
429 |
32, |
|
430 |
sign, |
|
431 |
32, |
|
432 |
32); |
|
433 |
Tint($FF, $FF, $FF, $FF) |
|
434 |
end |
|
435 |
end; |
|
436 |
defaultPos:= false |
|
437 |
end; |
|
6999 | 438 |
gtShover: DrawSpriteRotated(sprHandBaseball, hx, hy, sign, aangle + 180); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
439 |
gtFirePunch: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
440 |
begin |
4388 | 441 |
DrawHedgehog(sx, sy, |
442 |
sign, |
|
443 |
1, |
|
444 |
4, |
|
445 |
0); |
|
446 |
defaultPos:= false |
|
447 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
448 |
gtPickHammer: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
449 |
begin |
4388 | 450 |
defaultPos:= false; |
451 |
dec(sy,20); |
|
452 |
end; |
|
453 |
gtTeleport: defaultPos:= false; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
454 |
gtWhip: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
455 |
begin |
6999 | 456 |
DrawSpriteRotatedF(sprWhip, |
4388 | 457 |
sx, |
458 |
sy, |
|
459 |
1, |
|
460 |
sign, |
|
461 |
0); |
|
462 |
defaultPos:= false |
|
463 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
464 |
gtHammer: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
465 |
begin |
6999 | 466 |
DrawSpriteRotatedF(sprHammer, |
4388 | 467 |
sx, |
468 |
sy, |
|
469 |
1, |
|
470 |
sign, |
|
471 |
0); |
|
472 |
defaultPos:= false |
|
473 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
474 |
gtResurrector: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
475 |
begin |
6999 | 476 |
DrawSpriteRotated(sprHandResurrector, sx, sy, 0, 0); |
4388 | 477 |
defaultPos:= false |
478 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
479 |
gtKamikaze: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
480 |
begin |
4388 | 481 |
if CurAmmoGear^.Pos = 0 then |
482 |
DrawHedgehog(sx, sy, |
|
483 |
sign, |
|
484 |
1, |
|
485 |
6, |
|
486 |
0) |
|
487 |
else |
|
6999 | 488 |
DrawSpriteRotatedF(sprKamikaze, |
4388 | 489 |
ox, oy, |
490 |
CurAmmoGear^.Pos - 1, |
|
491 |
sign, |
|
492 |
aangle); |
|
493 |
defaultPos:= false |
|
494 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
495 |
gtSeduction: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
496 |
begin |
4388 | 497 |
if CurAmmoGear^.Pos >= 6 then |
498 |
DrawHedgehog(sx, sy, |
|
499 |
sign, |
|
500 |
2, |
|
501 |
2, |
|
502 |
0) |
|
503 |
else |
|
504 |
begin |
|
6999 | 505 |
DrawSpriteRotatedF(sprDress, |
4388 | 506 |
ox, oy, |
507 |
CurAmmoGear^.Pos, |
|
508 |
sign, |
|
509 |
0); |
|
510 |
DrawSprite(sprCensored, ox - 32, oy - 20, 0) |
|
511 |
end; |
|
512 |
defaultPos:= false |
|
513 |
end; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
514 |
gtFlamethrower: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
515 |
begin |
6999 | 516 |
DrawSpriteRotatedF(sprHandFlamethrower, hx, hy, (RealTicks div 125) mod 4, sign, aangle); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
517 |
if CurAmmoGear^.Tex <> nil then |
6999 | 518 |
DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex) |
4388 | 519 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
520 |
gtLandGun: |
6999 | 521 |
begin DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
522 |
if CurAmmoGear^.Tex <> nil then |
6999 | 523 |
DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex) |
5025
ac1691d35cf2
Land sprayer tweaks, make land spray and mudball not end turn
nemo
parents:
5024
diff
changeset
|
524 |
end; |
7093 | 525 |
gtIceGun: |
526 |
begin DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
|
527 |
if CurAmmoGear^.Tex <> nil then |
|
528 |
DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex) |
|
529 |
end; |
|
4388 | 530 |
end; |
531 |
||
532 |
case CurAmmoGear^.Kind of |
|
533 |
gtShotgunShot, |
|
534 |
gtDEagleShot, |
|
535 |
gtSniperRifleShot, |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
536 |
gtShover: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
537 |
begin |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
538 |
DrawHedgehog(sx, sy, sign, 0, 4, 0); |
4388 | 539 |
defaultPos:= false; |
540 |
HatVisible:= true |
|
541 |
end |
|
542 |
end |
|
543 |
end else |
|
544 |
||
545 |
if ((Gear^.State and gstHHJumping) <> 0) then |
|
546 |
begin |
|
547 |
DrawHedgehog(sx, sy, |
|
548 |
sign*m, |
|
549 |
1, |
|
550 |
1, |
|
551 |
0); |
|
552 |
HatVisible:= true; |
|
553 |
defaultPos:= false |
|
554 |
end else |
|
555 |
||
556 |
if (Gear^.Message and (gmLeft or gmRight) <> 0) and (not isCursorVisible) then |
|
557 |
begin |
|
558 |
DrawHedgehog(sx, sy, |
|
559 |
sign, |
|
560 |
0, |
|
561 |
HH^.visStepPos div 2, |
|
562 |
0); |
|
563 |
defaultPos:= false; |
|
564 |
HatVisible:= true |
|
565 |
end |
|
566 |
else |
|
567 |
||
568 |
if ((Gear^.State and gstAnimation) <> 0) then |
|
569 |
begin |
|
570 |
if (TWave(Gear^.Tag) < Low(TWave)) or (TWave(Gear^.Tag) > High(TWave)) then |
|
571 |
begin |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6328
diff
changeset
|
572 |
Gear^.State:= Gear^.State and (not gstAnimation); |
4388 | 573 |
end |
574 |
else |
|
575 |
begin |
|
6999 | 576 |
DrawSpriteRotatedF(Wavez[TWave(Gear^.Tag)].Sprite, |
4388 | 577 |
sx, |
578 |
sy, |
|
579 |
Gear^.Pos, |
|
580 |
sign, |
|
581 |
0.0); |
|
582 |
defaultPos:= false |
|
583 |
end |
|
584 |
end |
|
585 |
else |
|
586 |
if ((Gear^.State and gstAttacked) = 0) then |
|
587 |
begin |
|
588 |
if HH^.Timer > 0 then |
|
589 |
begin |
|
590 |
// There must be a tidier way to do this. Anyone? |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
591 |
if aangle <= 90 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
592 |
aangle:= aangle+360; |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
593 |
if Gear^.dX > _0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
594 |
aangle:= aangle-((aangle-240)*HH^.Timer/10) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
595 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
596 |
aangle:= aangle+((240-aangle)*HH^.Timer/10); |
4388 | 597 |
dec(HH^.Timer) |
598 |
end; |
|
599 |
amt:= CurrentHedgehog^.CurAmmoType; |
|
6924 | 600 |
CurWeapon:= GetCurAmmoEntry(HH^); |
4388 | 601 |
case amt of |
6999 | 602 |
amBazooka: DrawSpriteRotated(sprHandBazooka, hx, hy, sign, aangle); |
603 |
amSnowball: DrawSpriteRotated(sprHandSnowball, hx, hy, sign, aangle); |
|
604 |
amMortar: DrawSpriteRotated(sprHandMortar, hx, hy, sign, aangle); |
|
605 |
amMolotov: DrawSpriteRotated(sprHandMolotov, hx, hy, sign, aangle); |
|
606 |
amBallgun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
|
607 |
amDrill: DrawSpriteRotated(sprHandDrill, hx, hy, sign, aangle); |
|
608 |
amRope: DrawSpriteRotated(sprHandRope, hx, hy, sign, aangle); |
|
609 |
amShotgun: DrawSpriteRotated(sprHandShotgun, hx, hy, sign, aangle); |
|
610 |
amDEagle: DrawSpriteRotated(sprHandDEagle, hx, hy, sign, aangle); |
|
611 |
amSineGun: DrawSpriteRotatedF(sprHandSinegun, hx, hy, 73 + (sign * LongInt(RealTicks div 73)) mod 8, sign, aangle); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
612 |
|
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
613 |
amPortalGun: |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
614 |
if (CurWeapon^.Timer and 2) <> 0 then // Add a new Hedgehog value instead of abusing timer? |
6999 | 615 |
DrawSpriteRotatedF(sprPortalGun, hx, hy, 0, sign, aangle) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
616 |
else |
6999 | 617 |
DrawSpriteRotatedF(sprPortalGun, hx, hy, 1+CurWeapon^.Pos, sign, aangle); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
618 |
|
6999 | 619 |
amSniperRifle: DrawSpriteRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle); |
620 |
amBlowTorch: DrawSpriteRotated(sprHandBlowTorch, hx, hy, sign, aangle); |
|
621 |
amCake: DrawSpriteRotated(sprHandCake, hx, hy, sign, aangle); |
|
622 |
amGrenade: DrawSpriteRotated(sprHandGrenade, hx, hy, sign, aangle); |
|
623 |
amWatermelon: DrawSpriteRotated(sprHandMelon, hx, hy, sign, aangle); |
|
624 |
amSkip: DrawSpriteRotated(sprHandSkip, hx, hy, sign, aangle); |
|
625 |
amClusterBomb: DrawSpriteRotated(sprHandCluster, hx, hy, sign, aangle); |
|
626 |
amDynamite: DrawSpriteRotated(sprHandDynamite, hx, hy, sign, aangle); |
|
627 |
amHellishBomb: DrawSpriteRotated(sprHandHellish, hx, hy, sign, aangle); |
|
628 |
amGasBomb: DrawSpriteRotated(sprHandCheese, hx, hy, sign, aangle); |
|
629 |
amMine: DrawSpriteRotated(sprHandMine, hx, hy, sign, aangle); |
|
630 |
amSMine: DrawSpriteRotated(sprHandSMine, hx, hy, sign, aangle); |
|
5525 | 631 |
amSeduction: begin |
6999 | 632 |
DrawSpriteRotated(sprHandSeduction, hx, hy, sign, aangle); |
5561
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset
|
633 |
DrawCircle(ox, oy, 248, 4, $FF, $00, $00, $AA); |
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset
|
634 |
//Tint($FF, $0, $0, $AA); |
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset
|
635 |
//DrawTexture(ox - 240, oy - 240, SpritesData[sprVampiric].Texture, 10); |
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset
|
636 |
//Tint($FF, $FF, $FF, $FF); |
5525 | 637 |
end; |
6999 | 638 |
amVampiric: DrawSpriteRotatedF(sprHandVamp, hx, hy, (RealTicks div 125) mod 4, sign, aangle); |
4388 | 639 |
amRCPlane: begin |
6999 | 640 |
DrawSpriteRotated(sprHandPlane, hx, hy, sign, 0); |
4388 | 641 |
defaultPos:= false |
642 |
end; |
|
643 |
amGirder: begin |
|
6999 | 644 |
DrawSpriteRotated(sprHandConstruction, hx, hy, sign, aangle); |
4388 | 645 |
DrawSpriteClipped(sprGirder, |
646 |
ox-256, |
|
647 |
oy-256, |
|
648 |
LongInt(topY)+WorldDy, |
|
649 |
LongInt(rightX)+WorldDx, |
|
650 |
cWaterLine+WorldDy, |
|
651 |
LongInt(leftX)+WorldDx) |
|
652 |
end; |
|
6999 | 653 |
amBee: DrawSpriteRotatedF(sprHandBee, hx, hy, (RealTicks div 125) mod 4, sign, aangle); |
654 |
amFlamethrower: DrawSpriteRotatedF(sprHandFlamethrower, hx, hy, (RealTicks div 125) mod 4, sign, aangle); |
|
655 |
amLandGun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
|
7093 | 656 |
amIceGun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); |
4388 | 657 |
amResurrector: DrawCircle(ox, oy, 98, 4, $F5, $DB, $35, $AA); // I'd rather not like to hardcode 100 here |
658 |
end; |
|
659 |
||
660 |
case amt of |
|
661 |
amAirAttack, |
|
662 |
amMineStrike, |
|
6999 | 663 |
amDrillStrike: DrawSpriteRotated(sprHandAirAttack, sx, oy, sign, 0); |
4388 | 664 |
amPickHammer: DrawHedgehog(sx, sy, |
665 |
sign, |
|
666 |
1, |
|
667 |
2, |
|
668 |
0); |
|
6999 | 669 |
amTeleport: DrawSpriteRotatedF(sprTeleport, sx, sy, 0, sign, 0); |
4388 | 670 |
amKamikaze: DrawHedgehog(sx, sy, |
671 |
sign, |
|
672 |
1, |
|
673 |
5, |
|
674 |
0); |
|
6999 | 675 |
amWhip: DrawSpriteRotatedF(sprWhip, |
4388 | 676 |
sx, |
677 |
sy, |
|
678 |
0, |
|
679 |
sign, |
|
680 |
0); |
|
6999 | 681 |
amHammer: DrawSpriteRotatedF(sprHammer, |
4388 | 682 |
sx, |
683 |
sy, |
|
684 |
0, |
|
685 |
sign, |
|
686 |
0); |
|
687 |
else |
|
688 |
DrawHedgehog(sx, sy, |
|
689 |
sign, |
|
690 |
0, |
|
691 |
4, |
|
692 |
0); |
|
693 |
||
694 |
HatVisible:= true; |
|
695 |
(* with HH^ do |
|
696 |
if (HatTex <> nil) |
|
697 |
and (HatVisibility > 0) then |
|
698 |
DrawTextureF(HatTex, |
|
699 |
HatVisibility, |
|
700 |
sx, |
|
701 |
sy - 5, |
|
702 |
0, |
|
703 |
sign, |
|
704 |
32, |
|
705 |
32); *) |
|
706 |
end; |
|
707 |
||
708 |
case amt of |
|
6999 | 709 |
amBaseballBat: DrawSpriteRotated(sprHandBaseball, |
4388 | 710 |
sx - 4 * sign, |
711 |
sy + 9, sign, aangle); |
|
712 |
end; |
|
713 |
||
714 |
defaultPos:= false |
|
715 |
end; |
|
716 |
||
717 |
end else // not gstHHDriven |
|
718 |
begin |
|
719 |
if (Gear^.Damage > 0) |
|
720 |
and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then |
|
721 |
begin |
|
722 |
DrawHedgehog(sx, sy, |
|
723 |
sign, |
|
724 |
2, |
|
725 |
1, |
|
726 |
Gear^.DirAngle); |
|
727 |
defaultPos:= false |
|
728 |
end else |
|
729 |
||
730 |
if ((Gear^.State and gstHHJumping) <> 0) then |
|
731 |
begin |
|
732 |
DrawHedgehog(sx, sy, |
|
733 |
sign*m, |
|
734 |
1, |
|
735 |
1, |
|
736 |
0); |
|
737 |
defaultPos:= false |
|
738 |
end; |
|
739 |
end; |
|
740 |
||
741 |
with HH^ do |
|
742 |
begin |
|
743 |
if defaultPos then |
|
744 |
begin |
|
6999 | 745 |
DrawSpriteRotatedF(sprHHIdle, |
4388 | 746 |
sx, |
747 |
sy, |
|
748 |
(RealTicks div 128 + Gear^.Pos) mod 19, |
|
749 |
sign, |
|
750 |
0); |
|
751 |
HatVisible:= true; |
|
752 |
end; |
|
753 |
||
754 |
if HatVisible then |
|
755 |
if HatVisibility < 1.0 then |
|
756 |
HatVisibility:= HatVisibility + 0.2 |
|
757 |
else |
|
758 |
else |
|
759 |
if HatVisibility > 0.0 then |
|
760 |
HatVisibility:= HatVisibility - 0.2; |
|
761 |
||
762 |
if (HatTex <> nil) |
|
763 |
and (HatVisibility > 0) then |
|
764 |
if DefaultPos then |
|
765 |
begin |
|
766 |
DrawTextureF(HatTex, |
|
767 |
HatVisibility, |
|
768 |
sx, |
|
769 |
sy - 5, |
|
770 |
(RealTicks div 128 + Gear^.Pos) mod 19, |
|
771 |
sign, |
|
772 |
32, |
|
773 |
32); |
|
774 |
if HatTex^.w > 64 then |
|
775 |
begin |
|
4810 | 776 |
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); |
4388 | 777 |
DrawTextureF(HatTex, |
778 |
HatVisibility, |
|
779 |
sx, |
|
780 |
sy - 5, |
|
781 |
(RealTicks div 128 + Gear^.Pos) mod 19 + 32, |
|
782 |
sign, |
|
783 |
32, |
|
784 |
32); |
|
785 |
Tint($FF, $FF, $FF, $FF) |
|
786 |
end |
|
787 |
end |
|
788 |
else |
|
789 |
begin |
|
790 |
DrawTextureF(HatTex, |
|
791 |
HatVisibility, |
|
792 |
sx, |
|
793 |
sy - 5, |
|
794 |
0, |
|
795 |
sign*m, |
|
796 |
32, |
|
797 |
32); |
|
798 |
if HatTex^.w > 64 then |
|
799 |
begin |
|
4810 | 800 |
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); |
4388 | 801 |
DrawTextureF(HatTex, |
802 |
HatVisibility, |
|
803 |
sx, |
|
804 |
sy - 5, |
|
805 |
32, |
|
806 |
sign*m, |
|
807 |
32, |
|
808 |
32); |
|
809 |
Tint($FF, $FF, $FF, $FF) |
|
810 |
end |
|
811 |
end |
|
812 |
end; |
|
813 |
if (Gear^.State and gstHHDriven) <> 0 then |
|
814 |
begin |
|
815 |
(* if (CurAmmoGear = nil) then |
|
816 |
begin |
|
817 |
amt:= CurrentHedgehog^.CurAmmoType; |
|
818 |
case amt of |
|
819 |
amJetpack: DrawSprite(sprJetpack, sx-32, sy-32, 0); |
|
820 |
end |
|
821 |
end; *) |
|
822 |
if CurAmmoGear <> nil then |
|
823 |
begin |
|
824 |
case CurAmmoGear^.Kind of |
|
825 |
gtJetpack: begin |
|
826 |
DrawSprite(sprJetpack, sx-32, sy-32, 0); |
|
827 |
if cWaterLine > hwRound(Gear^.Y) + Gear^.Radius then |
|
828 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
829 |
if (CurAmmoGear^.MsgParam and gmUp) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
830 |
DrawSprite(sprJetpack, sx-32, sy-28, 1); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
831 |
if (CurAmmoGear^.MsgParam and gmLeft) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
832 |
DrawSprite(sprJetpack, sx-28, sy-28, 2); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
833 |
if (CurAmmoGear^.MsgParam and gmRight) <> 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
834 |
DrawSprite(sprJetpack, sx-36, sy-28, 3) |
4388 | 835 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
836 |
if CurAmmoGear^.Tex <> nil then |
6999 | 837 |
DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex); |
4388 | 838 |
DrawAltWeapon(Gear, sx, sy) |
839 |
end; |
|
840 |
end; |
|
841 |
end |
|
842 |
end; |
|
843 |
||
844 |
with HH^ do |
|
845 |
begin |
|
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6328
diff
changeset
|
846 |
if ((Gear^.State and (not gstWinner)) = 0) |
4388 | 847 |
or ((Gear^.State = gstWait) and (Gear^.dY.QWordValue = 0)) |
848 |
or (bShowFinger and ((Gear^.State and gstHHDriven) <> 0)) then |
|
849 |
begin |
|
850 |
t:= sy - cHHRadius - 9; |
|
851 |
if (cTagsMask and htTransparent) <> 0 then |
|
852 |
Tint($FF, $FF, $FF, $80); |
|
853 |
if ((cTagsMask and htHealth) <> 0) then |
|
854 |
begin |
|
855 |
dec(t, HealthTagTex^.h + 2); |
|
6999 | 856 |
DrawTextureCentered(ox, t, HealthTagTex) |
4388 | 857 |
end; |
858 |
if (cTagsMask and htName) <> 0 then |
|
859 |
begin |
|
860 |
dec(t, NameTagTex^.h + 2); |
|
6999 | 861 |
DrawTextureCentered(ox, t, NameTagTex) |
4388 | 862 |
end; |
863 |
if (cTagsMask and htTeamName) <> 0 then |
|
864 |
begin |
|
865 |
dec(t, Team^.NameTagTex^.h + 2); |
|
6999 | 866 |
DrawTextureCentered(ox, t, Team^.NameTagTex) |
4388 | 867 |
end; |
868 |
if (cTagsMask and htTransparent) <> 0 then |
|
869 |
Tint($FF, $FF, $FF, $FF) |
|
870 |
end; |
|
871 |
if (Gear^.State and gstHHDriven) <> 0 then // Current hedgehog |
|
872 |
begin |
|
4394 | 873 |
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtResurrector) then |
6999 | 874 |
DrawTextureCentered(ox, sy - cHHRadius - 7 - HealthTagTex^.h, HealthTagTex); |
4394 | 875 |
|
4388 | 876 |
if bShowFinger and ((Gear^.State and gstHHDriven) <> 0) then |
877 |
DrawSprite(sprFinger, ox - 16, oy - 64, |
|
878 |
GameTicks div 32 mod 16); |
|
879 |
||
880 |
if (Gear^.State and gstDrowning) = 0 then |
|
881 |
if (Gear^.State and gstHHThinking) <> 0 then |
|
882 |
DrawSprite(sprQuestion, ox - 10, oy - cHHRadius - 34, (RealTicks shr 9) mod 8) |
|
883 |
end |
|
884 |
end; |
|
885 |
||
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
886 |
if HH^.Effects[hePoisoned] <> 0 then |
4388 | 887 |
begin |
888 |
Tint($00, $FF, $40, $80); |
|
6999 | 889 |
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 1.5, 0, 0, sx, sy, 0, 1, 22, 22, 360 - (RealTicks shr 37) mod 360); |
4388 | 890 |
end; |
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
891 |
if HH^.Effects[heResurrected] <> 0 then |
4388 | 892 |
begin |
893 |
Tint($f5, $db, $35, $20); |
|
894 |
DrawSprite(sprVampiric, sx - 24, sy - 24, 0); |
|
895 |
end; |
|
896 |
||
897 |
if Gear^.Invulnerable then |
|
898 |
begin |
|
899 |
Tint($FF, $FF, $FF, max($40, round($FF * abs(1 - ((RealTicks div 2 + Gear^.uid * 491) mod 1500) / 750)))); |
|
900 |
DrawSprite(sprInvulnerable, sx - 24, sy - 24, 0); |
|
901 |
end; |
|
902 |
if cVampiric and |
|
903 |
(CurrentHedgehog^.Gear <> nil) and |
|
904 |
(CurrentHedgehog^.Gear = Gear) then |
|
905 |
begin |
|
906 |
Tint($FF, 0, 0, max($40, round($FF * abs(1 - (RealTicks mod 1500) / 750)))); |
|
907 |
DrawSprite(sprVampiric, sx - 24, sy - 24, 0); |
|
908 |
end; |
|
909 |
Tint($FF, $FF, $FF, $FF) |
|
910 |
end; |
|
911 |
||
912 |
||
913 |
procedure RenderGear(Gear: PGear; x, y: LongInt); |
|
914 |
var |
|
915 |
HHGear: PGear; |
|
7093 | 916 |
vg: PVisualGear; |
4388 | 917 |
i: Longword; |
6788
88036f0e0a92
I think this is a little more efficient than dxdy, and easier to read. We call DxDy2 a lot, can any of those use Angle/DirAngle?
nemo
parents:
6700
diff
changeset
|
918 |
aAngle: real; |
4388 | 919 |
startX, endX, startY, endY: LongInt; |
920 |
begin |
|
5612
2638dec1b323
This really should have been a TPoint for consistency
nemo
parents:
5561
diff
changeset
|
921 |
if Gear^.Target.X <> NoPointX then |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5472
diff
changeset
|
922 |
if Gear^.AmmoType = amBee then |
6999 | 923 |
DrawSpriteRotatedF(sprTargetBee, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, 0, 0, (RealTicks shr 3) mod 360) |
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
924 |
else if Gear^.AmmoType = amIceGun then |
7093 | 925 |
//DrawSprite(sprSnowDust, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, (RealTicks shr 2) mod 8) |
926 |
//DrawTextureRotatedF(SpritesData[sprSnowDust].Texture, 1, 0, 0, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, (RealTicks shr 2) mod 8, 1, 22, 22, (RealTicks shr 3) mod 360) |
|
927 |
DrawTextureRotatedF(SpritesData[sprSnowDust].Texture, 1/(1+(RealTicks shr 8) mod 5), 0, 0, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, (RealTicks shr 2) mod 8, 1, 22, 22, (RealTicks shr 3) mod 360) |
|
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
928 |
else |
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6999
diff
changeset
|
929 |
DrawSpriteRotatedF(sprTargetP, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, 0, 0, (RealTicks shr 3) mod 360); |
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5472
diff
changeset
|
930 |
|
4388 | 931 |
case Gear^.Kind of |
6999 | 932 |
gtGrenade: DrawSpriteRotated(sprBomb, x, y, 0, Gear^.DirAngle); |
933 |
gtSnowball: DrawSpriteRotated(sprSnowball, x, y, 0, Gear^.DirAngle); |
|
934 |
gtGasBomb: DrawSpriteRotated(sprCheese, x, y, 0, Gear^.DirAngle); |
|
5871
09daa06191d7
Since we are tweaking molotov. make the flame flickery and add a drowning frame
nemo
parents:
5787
diff
changeset
|
935 |
|
09daa06191d7
Since we are tweaking molotov. make the flame flickery and add a drowning frame
nemo
parents:
5787
diff
changeset
|
936 |
gtMolotov: if (Gear^.State and gstDrowning) = 0 then |
6999 | 937 |
DrawSpriteRotatedF(sprMolotov, x, y, (RealTicks div 125) mod 8, hwSign(Gear^.dX), Gear^.DirAngle * hwSign(Gear^.dX)) |
5871
09daa06191d7
Since we are tweaking molotov. make the flame flickery and add a drowning frame
nemo
parents:
5787
diff
changeset
|
938 |
else DrawSprite(sprMolotov, x, y, 8); |
4388 | 939 |
|
940 |
gtRCPlane: begin |
|
6788
88036f0e0a92
I think this is a little more efficient than dxdy, and easier to read. We call DxDy2 a lot, can any of those use Angle/DirAngle?
nemo
parents:
6700
diff
changeset
|
941 |
aangle:= Gear^.Angle * 360 / 4096; |
88036f0e0a92
I think this is a little more efficient than dxdy, and easier to read. We call DxDy2 a lot, can any of those use Angle/DirAngle?
nemo
parents:
6700
diff
changeset
|
942 |
if Gear^.Tag < 0 then aangle:= 360-aangle; |
6138 | 943 |
Tint(Gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF); |
6999 | 944 |
DrawSpriteRotatedF(sprPlane, x, y, 0, Gear^.Tag, aangle - 90); |
6788
88036f0e0a92
I think this is a little more efficient than dxdy, and easier to read. We call DxDy2 a lot, can any of those use Angle/DirAngle?
nemo
parents:
6700
diff
changeset
|
945 |
Tint($FF, $FF, $FF, $FF); |
6999 | 946 |
DrawSpriteRotatedF(sprPlane, x, y, 1, Gear^.Tag, aangle - 90) |
4388 | 947 |
end; |
6999 | 948 |
gtBall: DrawSpriteRotatedF(sprBalls, x, y, Gear^.Tag,0, Gear^.DirAngle); |
4388 | 949 |
|
950 |
gtPortal: if ((Gear^.Tag and 1) = 0) // still moving? |
|
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7168
diff
changeset
|
951 |
or (Gear^.LinkedGear = nil) or (Gear^.LinkedGear^.LinkedGear <> Gear) // not linked&backlinked? |
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7168
diff
changeset
|
952 |
or ((Gear^.LinkedGear^.Tag and 1) = 0) then // linked portal still moving? |
6999 | 953 |
DrawSpriteRotatedF(sprPortal, x, y, Gear^.Tag, hwSign(Gear^.dX), Gear^.DirAngle) |
954 |
else DrawSpriteRotatedF(sprPortal, x, y, 4 + Gear^.Tag div 2, hwSign(Gear^.dX), Gear^.DirAngle); |
|
4388 | 955 |
|
956 |
gtDrill: if (Gear^.State and gsttmpFlag) <> 0 then |
|
6999 | 957 |
DrawSpriteRotated(sprAirDrill, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)) |
4388 | 958 |
else |
6999 | 959 |
DrawSpriteRotated(sprDrill, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 960 |
|
961 |
gtHedgehog: DrawHH(Gear, x, y); |
|
962 |
||
6999 | 963 |
gtShell: DrawSpriteRotated(sprBazookaShell, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 964 |
|
965 |
gtGrave: begin |
|
966 |
DrawTextureF(Gear^.Hedgehog^.Team^.GraveTex, 1, x, y, (GameTicks shr 7+Gear^.uid) and 7, 1, 32, 32); |
|
967 |
if Gear^.Health > 0 then |
|
968 |
begin |
|
969 |
//Tint($33, $33, $FF, max($40, round($FF * abs(1 - (GameTicks mod (6000 div Gear^.Health)) / 750)))); |
|
970 |
Tint($f5, $db, $35, max($40, round($FF * abs(1 - (GameTicks mod 1500) / (750 + Gear^.Health))))); |
|
971 |
//Tint($FF, $FF, $FF, max($40, round($FF * abs(1 - (RealTicks mod 1500) / 750)))); |
|
972 |
DrawSprite(sprVampiric, x - 24, y - 24, 0); |
|
973 |
Tint($FF, $FF, $FF, $FF) |
|
974 |
end |
|
975 |
end; |
|
6999 | 976 |
gtBee: DrawSpriteRotatedF(sprBee, x, y, (GameTicks shr 5) mod 2, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 977 |
gtPickHammer: DrawSprite(sprPHammer, x - 16, y - 50 + LongInt(((GameTicks shr 5) and 1) * 2), 0); |
978 |
gtRope: DrawRope(Gear); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
979 |
|
4388 | 980 |
gtMine: if (((Gear^.State and gstAttacking) = 0)or((Gear^.Timer and $3FF) < 420)) and (Gear^.Health <> 0) then |
6999 | 981 |
DrawSpriteRotated(sprMineOff, x, y, 0, Gear^.DirAngle) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
982 |
else if Gear^.Health <> 0 then |
6999 | 983 |
DrawSpriteRotated(sprMineOn, x, y, 0, Gear^.DirAngle) |
984 |
else DrawSpriteRotated(sprMineDead, x, y, 0, Gear^.DirAngle); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
985 |
|
4388 | 986 |
gtSMine: if (((Gear^.State and gstAttacking) = 0)or((Gear^.Timer and $3FF) < 420)) and (Gear^.Health <> 0) then |
6999 | 987 |
DrawSpriteRotated(sprSMineOff, x, y, 0, Gear^.DirAngle) |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
988 |
else if Gear^.Health <> 0 then |
6999 | 989 |
DrawSpriteRotated(sprSMineOn, x, y, 0, Gear^.DirAngle) |
990 |
else DrawSpriteRotated(sprMineDead, x, y, 0, Gear^.DirAngle); |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
991 |
|
7168
8defaabce92e
warp sound when AI survival hog respawns. attempt at a bit of a crate spawn animation (moar sparkles and a quick fadein)
nemo
parents:
7165
diff
changeset
|
992 |
gtCase: begin |
7276 | 993 |
if Gear^.Timer > 1000 then |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5197
diff
changeset
|
994 |
begin |
7276 | 995 |
if ((Gear^.Pos and posCaseAmmo) <> 0) then |
996 |
begin |
|
997 |
i:= (GameTicks shr 6) mod 64; |
|
998 |
if i > 18 then |
|
999 |
i:= 0; |
|
1000 |
DrawSprite(sprCase, x - 24, y - 24, i); |
|
1001 |
end |
|
1002 |
else if ((Gear^.Pos and posCaseHealth) <> 0) then |
|
1003 |
begin |
|
1004 |
i:= ((GameTicks shr 6) + 38) mod 64; |
|
1005 |
if i > 13 then |
|
1006 |
i:= 0; |
|
1007 |
DrawSprite(sprFAid, x - 24, y - 24, i); |
|
1008 |
end |
|
1009 |
else if ((Gear^.Pos and posCaseUtility) <> 0) then |
|
1010 |
begin |
|
1011 |
i:= (GameTicks shr 6) mod 70; |
|
1012 |
if i > 23 then |
|
1013 |
i:= 0; |
|
1014 |
i:= i mod 12; |
|
1015 |
DrawSprite(sprUtility, x - 24, y - 24, i); |
|
1016 |
end; |
|
1017 |
end; |
|
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7276
diff
changeset
|
1018 |
if Gear^.Timer < 1833 then |
5313
5e18eaef65d0
now scripts can create unique crates: dummy (empty) crates and booby traps. scripts can also set health crate values
Henek
parents:
5197
diff
changeset
|
1019 |
begin |
7276 | 1020 |
DrawTextureRotatedF(SpritesData[sprPortal].texture, min(abs(1.25 - (Gear^.Timer mod 1333) / 400), 1.25), 0, 0, |
7339 | 1021 |
x, Gear^.Angle+WorldDy-16, 4+Gear^.Tag, 1, 32, 32, 270); |
7276 | 1022 |
end |
7168
8defaabce92e
warp sound when AI survival hog respawns. attempt at a bit of a crate spawn animation (moar sparkles and a quick fadein)
nemo
parents:
7165
diff
changeset
|
1023 |
end; |
4388 | 1024 |
gtExplosives: begin |
1025 |
if ((Gear^.State and gstDrowning) <> 0) then |
|
1026 |
DrawSprite(sprExplosivesRoll, x - 24, y - 24, 0) |
|
1027 |
else if Gear^.State and gstAnimation = 0 then |
|
1028 |
begin |
|
1029 |
i:= (GameTicks shr 6 + Gear^.uid*3) mod 64; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1030 |
if i > 18 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1031 |
i:= 0; |
4388 | 1032 |
DrawSprite(sprExplosives, x - 24, y - 24, i) |
1033 |
end |
|
1034 |
else if Gear^.State and gsttmpFlag = 0 then |
|
6999 | 1035 |
DrawSpriteRotatedF(sprExplosivesRoll, x, y + 4, 0, 0, Gear^.DirAngle) |
4388 | 1036 |
else |
6999 | 1037 |
DrawSpriteRotatedF(sprExplosivesRoll, x, y + 4, 1, 0, Gear^.DirAngle); |
4388 | 1038 |
end; |
6986
409dd3851309
add support for default pascal mode by removing default arguments value (maybe this also helps the parser)
koda
parents:
6982
diff
changeset
|
1039 |
gtDynamite: DrawSprite(sprDynamite, x - 16, y - 25, Gear^.Tag and 1, Gear^.Tag shr 1); |
6999 | 1040 |
gtClusterBomb: DrawSpriteRotated(sprClusterBomb, x, y, 0, Gear^.DirAngle); |
4388 | 1041 |
gtCluster: DrawSprite(sprClusterParticle, x - 8, y - 8, 0); |
6324 | 1042 |
gtFlame: if Gear^.Tag and 1 = 0 then |
1043 |
DrawTextureF(SpritesData[sprFlame].Texture, 2 / (Gear^.Tag mod 3 + 2), x, y, (GameTicks shr 7 + LongWord(Gear^.Tag)) mod 8, 1, 16, 16) |
|
1044 |
else DrawTextureF(SpritesData[sprFlame].Texture, 2 / (Gear^.Tag mod 3 + 2), x, y, (GameTicks shr 7 + LongWord(Gear^.Tag)) mod 8, -1, 16, 16); |
|
4388 | 1045 |
gtParachute: begin |
1046 |
DrawSprite(sprParachute, x - 24, y - 48, 0); |
|
1047 |
DrawAltWeapon(Gear, x + 1, y - 3) |
|
1048 |
end; |
|
6308 | 1049 |
gtAirAttack: begin |
1050 |
Tint(Gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF); |
|
6999 | 1051 |
DrawSpriteRotatedF(sprAirplane, x, y, 0, Gear^.Tag, 0); |
6308 | 1052 |
Tint($FF, $FF, $FF, $FF); |
6999 | 1053 |
DrawSpriteRotatedF(sprAirplane, x, y, 1, Gear^.Tag, 0); |
6308 | 1054 |
end; |
6999 | 1055 |
gtAirBomb: DrawSpriteRotated(sprAirBomb, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 1056 |
gtTeleport: begin |
1057 |
HHGear:= Gear^.Hedgehog^.Gear; |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1058 |
if not Gear^.Hedgehog^.Unplaced then |
6999 | 1059 |
DrawSpriteRotatedF(sprTeleport, x + 1, y - 3, Gear^.Pos, hwSign(Gear^.dX), 0); |
1060 |
DrawSpriteRotatedF(sprTeleport, hwRound(HHGear^.X) + 1 + WorldDx, hwRound(HHGear^.Y) - 3 + WorldDy, 11 - Gear^.Pos, hwSign(HHGear^.dX), 0); |
|
4388 | 1061 |
end; |
1062 |
gtSwitcher: DrawSprite(sprSwitch, x - 16, y - 56, (GameTicks shr 6) mod 12); |
|
1063 |
gtTarget: begin |
|
1064 |
Tint($FF, $FF, $FF, round($FF * Gear^.Timer / 1000)); |
|
1065 |
DrawSprite(sprTarget, x - 16, y - 16, 0); |
|
1066 |
Tint($FF, $FF, $FF, $FF); |
|
1067 |
end; |
|
6999 | 1068 |
gtMortar: DrawSpriteRotated(sprMortar, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
4388 | 1069 |
gtCake: if Gear^.Pos = 6 then |
6999 | 1070 |
DrawSpriteRotatedF(sprCakeWalk, x, y, (GameTicks div 40) mod 6, hwSign(Gear^.dX), Gear^.DirAngle * hwSign(Gear^.dX) + 90) |
4388 | 1071 |
else |
6999 | 1072 |
DrawSpriteRotatedF(sprCakeDown, x, y, 5 - Gear^.Pos, hwSign(Gear^.dX), Gear^.DirAngle * hwSign(Gear^.dX) + 90); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1073 |
gtSeduction: if Gear^.Pos >= 14 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1074 |
DrawSprite(sprSeduction, x - 16, y - 16, 0); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1075 |
|
6999 | 1076 |
gtWatermelon: DrawSpriteRotatedF(sprWatermelon, x, y, 0, 0, Gear^.DirAngle); |
1077 |
gtMelonPiece: DrawSpriteRotatedF(sprWatermelon, x, y, 1, 0, Gear^.DirAngle); |
|
1078 |
gtHellishBomb: DrawSpriteRotated(sprHellishBomb, x, y, 0, Gear^.DirAngle); |
|
4388 | 1079 |
gtBirdy: begin |
1080 |
if Gear^.State and gstAnimation = gstAnimation then |
|
1081 |
begin |
|
1082 |
if Gear^.State and gstTmpFlag = 0 then // Appearing |
|
1083 |
begin |
|
1084 |
endX:= x - WorldDx; |
|
1085 |
endY:= y - WorldDy; |
|
1086 |
if Gear^.Tag < 0 then |
|
1087 |
startX:= max(LAND_WIDTH + 1024, endX + 2048) |
|
1088 |
else |
|
1089 |
startX:= max(-LAND_WIDTH - 1024, endX - 2048); |
|
1090 |
startY:= endY - 256; |
|
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5145
diff
changeset
|
1091 |
DrawTextureF(SpritesData[sprBirdy].Texture, 1, startX + WorldDx + LongInt(round((endX - startX) * (-power(2, -10 * LongInt(Gear^.Timer)/2000) + 1))), startY + WorldDy + LongInt(round((endY - startY) * sqrt(1 - power((LongInt(Gear^.Timer)/2000)-1, 2)))), ((Gear^.Pos shr 6) or (RealTicks shr 8)) mod 2, Gear^.Tag, 75, 75); |
4388 | 1092 |
end |
1093 |
else // Disappearing |
|
1094 |
begin |
|
1095 |
startX:= x - WorldDx; |
|
1096 |
startY:= y - WorldDy; |
|
1097 |
if Gear^.Tag > 0 then |
|
1098 |
endX:= max(LAND_WIDTH + 1024, startX + 2048) |
|
1099 |
else |
|
1100 |
endX:= max(-LAND_WIDTH - 1024, startX - 2048); |
|
1101 |
endY:= startY + 256; |
|
5179
8d64dcb566ea
Fix "Mixing signed expressions and longwords gives a 64bit result" warnings
unc0rr
parents:
5145
diff
changeset
|
1102 |
DrawTextureF(SpritesData[sprBirdy].Texture, 1, startX + WorldDx + LongInt(round((endX - startX) * power(2, 10 * (LongInt(Gear^.Timer)/2000 - 1)))) + hwRound(Gear^.dX * Gear^.Timer), startY + WorldDy + LongInt(round((endY - startY) * cos(LongInt(Gear^.Timer)/2000 * (Pi/2)) - (endY - startY))) + hwRound(Gear^.dY * Gear^.Timer), ((Gear^.Pos shr 6) or (RealTicks shr 8)) mod 2, Gear^.Tag, 75, 75); |
4388 | 1103 |
end; |
1104 |
end |
|
1105 |
else |
|
5528
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1106 |
begin |
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1107 |
if Gear^.Health < 250 then |
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1108 |
DrawTextureF(SpritesData[sprBirdy].Texture, 1, x, y, ((Gear^.Pos shr 6) or (RealTicks shr 7)) mod 2, Gear^.Tag, 75, 75) |
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1109 |
else |
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1110 |
DrawTextureF(SpritesData[sprBirdy].Texture, 1, x, y, ((Gear^.Pos shr 6) or (RealTicks shr 8)) mod 2, Gear^.Tag, 75, 75); |
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset
|
1111 |
end; |
4388 | 1112 |
end; |
6999 | 1113 |
gtEgg: DrawTextureRotatedF(SpritesData[sprEgg].Texture, 1, 0, 0, x, y, 0, 1, 16, 16, Gear^.DirAngle); |
4388 | 1114 |
gtPiano: begin |
1115 |
if (Gear^.State and gstDrowning) = 0 then |
|
1116 |
begin |
|
1117 |
Tint($FF, $FF, $FF, $10); |
|
1118 |
for i:= 8 downto 1 do |
|
6322
b310f0bc8dde
If I'm going to be arbitrary about it, might as well go for the more minimal arbitrariness
nemo
parents:
6318
diff
changeset
|
1119 |
DrawTextureF(SpritesData[sprPiano].Texture, 1, x, y - hwRound(Gear^.dY * 4 * i), 0, 1, 128, 128); |
4388 | 1120 |
Tint($FF, $FF, $FF, $FF) |
1121 |
end; |
|
6322
b310f0bc8dde
If I'm going to be arbitrary about it, might as well go for the more minimal arbitrariness
nemo
parents:
6318
diff
changeset
|
1122 |
DrawTextureF(SpritesData[sprPiano].Texture, 1, x, y, 0, 1, 128, 128); |
4388 | 1123 |
end; |
1124 |
gtPoisonCloud: begin |
|
1125 |
if Gear^.Timer < 1020 then |
|
1126 |
Tint($C0, $C0, $00, Gear^.Timer div 8) |
|
1127 |
else if Gear^.Timer > 3980 then |
|
1128 |
Tint($C0, $C0, $00, (5000 - Gear^.Timer) div 8) |
|
1129 |
else |
|
1130 |
Tint($C0, $C0, $00, $C0); |
|
6999 | 1131 |
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 3, 0, 0, x, y, 0, 1, 22, 22, (RealTicks shr 36 + Gear^.UID * 100) mod 360); |
4388 | 1132 |
Tint($FF, $FF, $FF, $FF) |
1133 |
end; |
|
1134 |
gtResurrector: begin |
|
6999 | 1135 |
DrawSpriteRotated(sprCross, x, y, 0, 0); |
4388 | 1136 |
Tint($f5, $db, $35, max($00, round($C0 * abs(1 - (GameTicks mod 6000) / 3000)))); |
1137 |
DrawTexture(x - 108, y - 108, SpritesData[sprVampiric].Texture, 4.5); |
|
1138 |
Tint($FF, $FF, $FF, $FF); |
|
1139 |
end; |
|
6999 | 1140 |
gtNapalmBomb: DrawSpriteRotated(sprNapalmBomb, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); |
5519 | 1141 |
gtFlake: if Gear^.State and (gstDrowning or gstTmpFlag) <> 0 then |
5024 | 1142 |
begin |
6982 | 1143 |
Tint((ExplosionBorderColor shr RShift) and $FF, |
1144 |
(ExplosionBorderColor shr GShift) and $FF, |
|
1145 |
(ExplosionBorderColor shr BShift) and $FF, |
|
5461 | 1146 |
$FF); |
5025
ac1691d35cf2
Land sprayer tweaks, make land spray and mudball not end turn
nemo
parents:
5024
diff
changeset
|
1147 |
// Needs a nicer white texture to tint |
6999 | 1148 |
DrawTextureRotatedF(SpritesData[sprSnowDust].Texture, 1, 0, 0, x, y, 0, 1, 8, 8, Gear^.DirAngle); |
1149 |
//DrawSpriteRotated(sprSnowDust, x, y, 0, Gear^.DirAngle); |
|
5472 | 1150 |
//DrawTexture(x, y, SpritesData[sprVampiric].Texture, 0.1); |
5024 | 1151 |
Tint($FF, $FF, $FF, $FF); |
1152 |
end |
|
5787 | 1153 |
else //if not isInLag then |
5024 | 1154 |
begin |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1155 |
if isInLag and (Gear^.FlightTime < 256) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1156 |
inc(Gear^.FlightTime, 8) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1157 |
else if not isInLag and (Gear^.FlightTime > 0) then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1158 |
dec(Gear^.FlightTime, 8); |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1159 |
if Gear^.FlightTime > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1160 |
Tint($FF, $FF, $FF, $FF-min(255,Gear^.FlightTime)); |
4617 | 1161 |
if vobVelocity = 0 then |
5024 | 1162 |
DrawSprite(sprFlake, x, y, Gear^.Timer) |
1163 |
else |
|
6999 | 1164 |
DrawSpriteRotatedF(sprFlake, x, y, Gear^.Timer, 1, Gear^.DirAngle); |
5024 | 1165 |
//DrawSprite(sprFlake, x-SpritesData[sprFlake].Width div 2, y-SpritesData[sprFlake].Height div 2, Gear^.Timer) |
6999 | 1166 |
//DrawSpriteRotatedF(sprFlake, x-SpritesData[sprFlake].Width div 2, y-SpritesData[sprFlake].Height div 2, Gear^.Timer, 1, Gear^.DirAngle); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1167 |
if Gear^.FlightTime > 0 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1168 |
Tint($FF, $FF, $FF, $FF); |
5024 | 1169 |
end; |
4883
7cddc9201a1d
added dummy for tardis and ugly icons for tardis and structure
Henek
parents:
4881
diff
changeset
|
1170 |
gtStructure: DrawSprite(sprTarget, x - 16, y - 16, 0); |
5706 | 1171 |
gtTardis: if Gear^.Pos <> 4 then |
1172 |
begin |
|
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1173 |
if Gear^.Pos = 2 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1174 |
Tint(Gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1175 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1176 |
Tint(Gear^.Hedgehog^.Team^.Clan^.Color shl 8 or max($00, round(Gear^.Power * (1-abs(0.5 - (GameTicks mod 2000) / 2000))))); |
5706 | 1177 |
DrawSprite(sprTardis, x-24, y-63,0); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1178 |
if Gear^.Pos = 2 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1179 |
Tint($FF, $FF, $FF, $FF) |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1180 |
else |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1181 |
Tint($FF,$FF,$FF,max($00, round(Gear^.Power * (1-abs(0.5 - (GameTicks mod 2000) / 2000))))); |
5740 | 1182 |
DrawSprite(sprTardis, x-24, y-63,1); |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1183 |
if Gear^.Pos <> 2 then |
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1184 |
Tint($FF, $FF, $FF, $FF) |
5740 | 1185 |
(* |
5728 | 1186 |
Tint(Gear^.Hedgehog^.Team^.Clan^.Color shl 8 or max($00, round(Gear^.Power * abs(1 - (RealTicks mod 500) / 250)))); |
1187 |
DrawTexture(x-6, y-70, SpritesData[sprVampiric].Texture, 0.25); |
|
1188 |
Tint($FF, $FF, $FF, $FF) |
|
5740 | 1189 |
*) |
5706 | 1190 |
end; |
7093 | 1191 |
gtIceGun: begin |
1192 |
HHGear := Gear^.Hedgehog^.Gear; |
|
1193 |
if HHGear <> nil then |
|
1194 |
begin |
|
1195 |
i:= hwRound(hwSqr(Gear^.X-HHGear^.X)+hwSqr(Gear^.Y-HHGear^.Y)); |
|
1196 |
if RealTicks mod max(1,50-(round(sqrt(i)) div 4)) = 0 then // experiment in "intensifying" might not get used |
|
1197 |
begin |
|
1198 |
vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtDust, 1); |
|
1199 |
if vg <> nil then |
|
1200 |
begin |
|
1201 |
i:= random(100)+155; |
|
1202 |
vg^.Tint:= i shl 24 or i shl 16 or $FF shl 8 or ((random(200)+55)); |
|
1203 |
vg^.Angle:= random(360); |
|
1204 |
vg^.dx:= 0.001 * (random(80)); |
|
1205 |
vg^.dy:= 0.001 * (random(80)) |
|
1206 |
end |
|
1207 |
end; |
|
1208 |
if RealTicks mod 2 = 0 then |
|
1209 |
begin |
|
1210 |
i:= random(100)+100; |
|
1211 |
if Gear^.Target.X <> NoPointX then |
|
7098
f8c453ade379
Minor tweaks to freezer, mostly to simplify current state to laptop
nemo
parents:
7093
diff
changeset
|
1212 |
DrawLine(Gear^.Target.X, Gear^.Target.Y, hwRound(HHGear^.X), hwRound(HHGear^.Y), 4.0, i, i, $FF, $40) |
f8c453ade379
Minor tweaks to freezer, mostly to simplify current state to laptop
nemo
parents:
7093
diff
changeset
|
1213 |
else DrawLine(hwRound(HHGear^.X), hwRound(HHGear^.Y), hwRound(Gear^.X), hwRound(Gear^.Y), 4.0, i, i, $FF, $40); |
7093 | 1214 |
end |
1215 |
end |
|
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7339
diff
changeset
|
1216 |
end; |
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7339
diff
changeset
|
1217 |
gtGenericFaller: DrawCircle(x, y, 3, 3, $FF, $00, $00, $FF); // debug |
4388 | 1218 |
end; |
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset
|
1219 |
if Gear^.RenderTimer and (Gear^.Tex <> nil) then |
6999 | 1220 |
DrawTextureCentered(x + 8, y + 8, Gear^.Tex); |
4388 | 1221 |
end; |
1222 |
||
1223 |
end. |