author  sheepluva 
Wed, 02 Sep 2015 01:25:29 +0200  
changeset 11059  659427d9fd17 
parent 11046  47a8c19ecb60 
child 11174  5cadfe82eaf6 
permissions  rwrr 
4976  1 
(* 
2 
* Hedgewars, a free turn based strategy game 

11046  3 
* Copyright (c) 20042015 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 
* 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

9 
* This program is distributed in the hope that it will be useful, 
4976  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 

10108
c68cf030eded
update FSF address. note: two sdl include files (by Sam Lantinga) still have the old FSF address in their copyright  but I ain't gonna touch their copyright headers
sheepluva
parents:
10082
diff
changeset

16 
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 021101301 USA 
4976  17 
*) 
18 

4388  19 
{$INCLUDE "options.inc"} 
4976  20 

4388  21 
unit uGearsRender; 
22 

23 
interface 

7671  24 
uses uTypes, uConsts, GLunit, uFloat, SDLh; 
4388  25 

8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7978
diff
changeset

26 
type 
10015  27 
Tar = record 
8330  28 
X, Y: hwFloat; 
29 
dLen: hwFloat; 

30 
b : boolean; 

31 
end; 

8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7978
diff
changeset

32 
TRopePoints = record 
8330  33 
Count : Longword; 
34 
HookAngle : GLfloat; 

35 
ar : array[0..MAXROPEPOINTS] of Tar; 

36 
rounded : array[0..MAXROPEPOINTS + 2] of TVertex2f; 

37 
end; 

4388  38 
procedure RenderGear(Gear: PGear; x, y: LongInt); 
10866  39 
procedure DrawHHOrder(); 
4388  40 

41 
var RopePoints: record 

42 
Count: Longword; 

43 
HookAngle: GLfloat; 

44 
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

45 
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

46 
dLen: hwFloat; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

47 
b: boolean; 
8733
b6002f1956d5
Hard math to fix issue 571. Well, not really hard math,
unc0rr
parents:
8689
diff
changeset

48 
sx, sy, sb: boolean; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

49 
end; 
4388  50 
rounded: array[0..MAXROPEPOINTS + 2] of TVertex2f; 
51 
end; 

52 

53 
implementation 

9285  54 
uses uRender, uUtils, uVariables, uAmmos, Math, uVisualGearsList; 
4388  55 

56 
procedure DrawRopeLinesRQ(Gear: PGear); 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

57 
var n: LongInt; 
4388  58 
begin 
59 
with RopePoints do 

60 
begin 

61 
rounded[Count].X:= hwRound(Gear^.X); 

62 
rounded[Count].Y:= hwRound(Gear^.Y); 

63 
rounded[Count + 1].X:= hwRound(Gear^.Hedgehog^.Gear^.X); 

64 
rounded[Count + 1].Y:= hwRound(Gear^.Hedgehog^.Gear^.Y); 

65 
end; 

66 

67 
if (RopePoints.Count > 0) or (Gear^.Elasticity.QWordValue > 0) then 

68 
begin 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

69 
EnableTexture(false); 
4388  70 
//glEnable(GL_LINE_SMOOTH); 
71 

10848  72 

73 
Tint(Gear^.Tint shr 24 div 3, Gear^.Tint shr 16 and $FF div 3, Gear^.Tint shr 8 and $FF div 3, Gear^.Tint and $FF); 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

74 

00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

75 
n:= RopePoints.Count + 2; 
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

76 

00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

77 
SetVertexPointer(@RopePoints.rounded[0], n); 
4388  78 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

79 
openglPushMatrix(); 
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

80 
openglTranslatef(WorldDx, WorldDy, 0); 
4388  81 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

82 
glLineWidth(3.0 * cScaleFactor); 
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

83 
glDrawArrays(GL_LINE_STRIP, 0, n); 
10848  84 
Tint(Gear^.Tint); 
10264
cb4331b032f4
use cScaleFactor where I incorrectly used the variable zoom in the past. i was young and needed the money
sheepluva
parents:
10142
diff
changeset

85 
glLineWidth(2.0 * cScaleFactor); 
10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

86 
glDrawArrays(GL_LINE_STRIP, 0, n); 
4388  87 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

88 
untint; 
4388  89 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

90 
openglPopMatrix(); 
4388  91 

10523
00ac079fa51f
fix some nasty rendering issues reported by Nexia  thanks a lot!
sheepluva
parents:
10443
diff
changeset

92 
EnableTexture(true); 
4388  93 
//glDisable(GL_LINE_SMOOTH) 
94 
end 

95 
end; 

96 

97 

6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset

98 
function DrawRopeLine(X1, Y1, X2, Y2, roplen: LongInt): LongInt; 
6490  99 
var eX, eY, dX, dY: LongInt; 
100 
i, sX, sY, x, y, d: LongInt; 

101 
b: boolean; 

102 
begin 

4388  103 
if (X1 = X2) and (Y1 = Y2) then 
6490  104 
begin 
105 
//OutError('WARNING: zero length rope line!', false); 

10015  106 
DrawRopeLine:= 0; 
6490  107 
exit 
108 
end; 

4388  109 
eX:= 0; 
110 
eY:= 0; 

111 
dX:= X2  X1; 

112 
dY:= Y2  Y1; 

113 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

114 
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

115 
sX:= 1 
4388  116 
else 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

117 
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

118 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

119 
sX:= 1; 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

120 
dX:= dX 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

121 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

122 
else sX:= dX; 
4388  123 

8689  124 
if (dY > 0) then 
6490  125 
sY:= 1 
4388  126 
else 
6490  127 
if (dY < 0) then 
4388  128 
begin 
6490  129 
sY:= 1; 
130 
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

131 
end 
8689  132 
else 
6490  133 
sY:= dY; 
134 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

135 
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

136 
d:= dX 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

137 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

138 
d:= dY; 
6490  139 

140 
x:= X1; 

141 
y:= Y1; 

142 

143 
for i:= 0 to d do 

144 
begin 

145 
inc(eX, dX); 

146 
inc(eY, dY); 

147 
b:= false; 

148 
if (eX > d) then 

149 
begin 

150 
dec(eX, d); 

151 
inc(x, sX); 

152 
b:= true 

153 
end; 

154 
if (eY > d) then 

155 
begin 

156 
dec(eY, d); 

157 
inc(y, sY); 

158 
b:= true 

159 
end; 

160 
if b then 

161 
begin 

162 
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

163 
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

164 
DrawSprite(sprRopeNode, x  2, y  2, 0) 
6490  165 
end 
6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset

166 
end; 
10015  167 
DrawRopeLine:= roplen; 
6490  168 
end; 
169 

170 
procedure DrawRope(Gear: PGear); 

10562  171 
var roplen, i: LongInt; 
4388  172 
begin 
10682  173 
if Gear^.Hedgehog^.Gear = nil then exit; 
10848  174 
if (Gear^.Tag = 1) or ((cReducedQuality and rqSimpleRope) <> 0) then 
4388  175 
DrawRopeLinesRQ(Gear) 
176 
else 

177 
begin 

178 
roplen:= 0; 

179 
if RopePoints.Count > 0 then 

180 
begin 

181 
i:= 0; 

182 
while i < Pred(RopePoints.Count) do 

183 
begin 

6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset

184 
roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, 
6490  185 
hwRound(RopePoints.ar[Succ(i)].X) + WorldDx, hwRound(RopePoints.ar[Succ(i)].Y) + WorldDy, roplen); 
4388  186 
inc(i) 
187 
end; 

6508
bf5db4517148
Fix regression from 6480 too. Extra assignments might make this slightly less efficient.
nemo
parents:
6490
diff
changeset

188 
roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy, 
6490  189 
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

190 
roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 
6490  191 
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

192 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

193 
else 
4388  194 
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

195 
roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 
6490  196 
hwRound(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwRound(Gear^.Hedgehog^.Gear^.Y) + WorldDy, roplen); 
4388  197 
end; 
198 

199 

200 
if RopePoints.Count > 0 then 

6999  201 
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

202 
else 
4388  203 
if Gear^.Elasticity.QWordValue > 0 then 
6999  204 
DrawSpriteRotated(sprRopeHook, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  205 
end; 
206 

207 

208 
procedure DrawAltWeapon(Gear: PGear; sx, sy: LongInt); 

209 
begin 

210 
with Gear^.Hedgehog^ do 

211 
begin 

212 
if not (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) and ((Gear^.State and gstAttacked) = 0)) then 

213 
exit; 

214 
DrawTexture(sx + 16, sy + 16, ropeIconTex); 

215 
DrawTextureF(SpritesData[sprAMAmmos].Texture, 0.75, sx + 30, sy + 30, ord(CurAmmoType)  1, 1, 32, 32); 

216 
end; 

217 
end; 

218 

10866  219 
procedure DrawHHOrder(); 
220 
var HHGear: PGear; 

221 
hh: PHedgehog; 

222 
c, i, t, x, y, sprH, sprW, fSprOff: LongInt; 

223 
begin 

224 
t:= LocalTeam; 

225 

226 
if not CurrentTeam^.ExtDriven then 

227 
for i:= 0 to Pred(TeamsCount) do 

228 
if (TeamsArray[i] = CurrentTeam) then 

229 
t:= i; 

230 

10867
36ca7a39f34d
fix segfault caused by last commit if spectating
sheepluva
parents:
10866
diff
changeset

231 
if t < 0 then 
36ca7a39f34d
fix segfault caused by last commit if spectating
sheepluva
parents:
10866
diff
changeset

232 
exit; 
36ca7a39f34d
fix segfault caused by last commit if spectating
sheepluva
parents:
10866
diff
changeset

233 

10866  234 
if TeamsArray[t] <> nil then 
235 
begin 

236 
sprH:= SpritesData[sprBigDigit].Height; 

237 
sprW:= SpritesData[sprBigDigit].Width; 

238 
fSprOff:= sprW div 4 + SpritesData[sprFrame].Width div 4  1; //  1 for overlap to avoid artifacts 

239 
i:= 0; 

240 
c:= 0; 

241 
repeat 

242 
hh:= @TeamsArray[t]^.Hedgehogs[i]; 

243 
inc(i); 

244 
if (hh <> nil) and (hh^.Gear <> nil) then 

245 
begin 

246 
inc(c); 

247 
HHGear:= hh^.Gear; 

248 
x:= hwRound(HHGear^.X) + WorldDx; 

249 
y:= hwRound(HHGear^.Y) + WorldDy  2; 

10992  250 
DrawTextureF(SpritesData[sprFrame].Texture, 0.5, x  fSprOff, y, 0, 1, SpritesData[sprFrame].Width, SpritesData[sprFrame].Height); 
251 
DrawTextureF(SpritesData[sprFrame].Texture, 0.5, x + fSprOff, y, 1, 1, SpritesData[sprFrame].Width, SpritesData[sprFrame].Height); 

252 
DrawTextureF(SpritesData[sprBigDigit].Texture, 0.5, x, y, c, 1, sprW, sprH); 

253 
if SpeechHogNumber = c then 

10869  254 
DrawCircle(x, y, 20, 3, 0, $FF, $FF, $80); 
10866  255 
end; 
256 
until (i > cMaxHHIndex); 

257 
end 

258 

259 
end; 

260 

4388  261 

262 
procedure DrawHH(Gear: PGear; ox, oy: LongInt); 

263 
var i, t: LongInt; 

264 
amt: TAmmoType; 

5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset

265 
sign, hx, hy, tx, ty, sx, sy, m: LongInt; // hedgehog, crosshair, temp, sprite, direction 
4388  266 
dx, dy, ax, ay, aAngle, dAngle, hAngle, lx, ly: real; // laser, change 
267 
defaultPos, HatVisible: boolean; 

268 
HH: PHedgehog; 

269 
CurWeapon: PAmmo; 

8557  270 
iceOffset:Longint; 
271 
r:TSDL_Rect; 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

272 
curhat: PTexture; 
4388  273 
begin 
274 
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

275 
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

276 
exit; 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

277 
if (HH^.CurAmmoType = amKnife) and (HH = CurrentHedgehog) then 
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

278 
curhat:= ChefHatTexture 
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

279 
else curhat:= HH^.HatTex; 
4388  280 
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

281 
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

282 
m:= 1; 
4388  283 
sx:= ox + 1; // this offset is very common 
284 
sy:= oy  3; 

285 
sign:= hwSign(Gear^.dX); 

286 

287 
if (Gear^.State and gstHHDeath) <> 0 then 

288 
begin 

289 
DrawSprite(sprHHDeath, ox  16, oy  26, Gear^.Pos); 

4810  290 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 
4388  291 
DrawSprite(sprHHDeath, ox  16, oy  26, Gear^.Pos + 8); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

292 
untint; 
4388  293 
exit 
294 
end 

295 
else if (Gear^.State and gstHHGone) <> 0 then 

296 
begin 

6999  297 
DrawSpriteRotatedF(sprTeleport, sx, sy, Gear^.Pos, sign, 0); 
4388  298 
exit 
299 
end; 

300 

301 
defaultPos:= true; 

302 
HatVisible:= false; 

303 

8560  304 
if HH^.Effects[heFrozen] > 0 then 
8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

305 
if HH^.Effects[heFrozen] < 150000 then 
8560  306 
begin 
307 
DrawHedgehog(sx, sy, 

308 
sign, 

309 
0, 

310 
0, 

311 
0); 

312 
defaultPos:= false; 

8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

313 
if HH^.Effects[heFrozen] < 256 then 
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

314 
HatVisible:= true 
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

315 
else HatVisible:= false 
8560  316 
end 
8689  317 
else 
8560  318 
begin 
319 
DrawHedgehog(sx, sy, 

320 
sign, 

321 
2, 

322 
4, 

323 
0); 

324 
defaultPos:= false; 

8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

325 
HatVisible:= false 
8560  326 
end; 
327 

4388  328 

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

329 
if HH^.Effects[hePoisoned] <> 0 then 
4388  330 
begin 
331 
Tint($00, $FF, $40, $40); 

10142  332 
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 2, 0, 0, sx, sy, 0, 1, 22, 22, (RealTicks shr 4) mod 360); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

333 
untint 
4388  334 
end; 
335 

8557  336 

4388  337 
if ((Gear^.State and gstWinner) <> 0) and 
338 
((CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtPickHammer)) then 

339 
begin 

340 
DrawHedgehog(sx, sy, 

341 
sign, 

342 
2, 

343 
0, 

344 
0); 

345 
defaultPos:= false 

346 
end; 

347 
if (Gear^.State and gstDrowning) <> 0 then 

348 
begin 

349 
DrawHedgehog(sx, sy, 

350 
sign, 

351 
1, 

352 
7, 

353 
0); 

354 
defaultPos:= false 

355 
end else 

356 
if (Gear^.State and gstLoser) <> 0 then 

357 
begin 

358 
DrawHedgehog(sx, sy, 

359 
sign, 

360 
2, 

361 
3, 

362 
0); 

363 
defaultPos:= false 

364 
end else 

365 

366 
if (Gear^.State and gstHHDriven) <> 0 then 

367 
begin 

5145
120f4271f197
adjust crosshair criteria again. this should take care of sniper rifle and crosshair after attacking
nemo
parents:
5137
diff
changeset

368 
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

369 
/// 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

370 
(((CurAmmoGear <> nil) and //((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) and 
10390  371 
// don't render crosshair/laser during kamikaze 
372 
((CurAmmoGear^.AmmoType <> amKamikaze) or ((Gear^.State and gstAttacking) = 0)) and 

5136
948da1e50205
Fix a few crosshair bugs. Disable ShowCrosshair and just decide when drawing.
nemo
parents:
5041
diff
changeset

373 
((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

374 
/// 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

375 
((CurAmmoGear = nil) and ((Ammoz[HH^.CurAmmoType].Ammo.Propz and ammoprop_NoCrosshair) = 0) and ((Gear^.State and gstAttacked) = 0))) then 
4388  376 
begin 
377 
(* These calculations are a little complex for a few reasons: 

378 
1: I need to draw the laser from weapon origin to nearest land 

379 
2: I need to start the beam outside the hedgie for attractiveness. 

380 
3: I need to extend the beam beyond land. 

381 
This routine perhaps should be pushed into uStore or somesuch instead of continuuing the increase in size of this function. 

382 
*) 

383 
dx:= sign * m * Sin(Gear^.Angle * pi / cMaxAngle); 

384 
dy:= Cos(Gear^.Angle * pi / cMaxAngle); 

385 
if cLaserSighting then 

386 
begin 

387 
lx:= GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle); 

388 
ly:= GetLaunchY(HH^.CurAmmoType, Gear^.Angle); 

389 

390 
// ensure we start outside the hedgehog (he's solid after all) 

391 
while abs(lx * lx + ly * ly) < (Gear^.radius * Gear^.radius) do 

392 
begin 

393 
lx:= lx + dx; 

394 
ly:= ly + dy 

395 
end; 

396 

397 
// add hog's position 

398 
lx:= lx + ox  WorldDx; 

399 
ly:= ly + oy  WorldDy; 

400 

401 
// decrease number of iterations required 

402 
ax:= dx * 4; 

403 
ay:= dy * 4; 

404 

405 
tx:= round(lx); 

406 
ty:= round(ly); 

407 
hx:= tx; 

408 
hy:= ty; 

409 
while ((ty and LAND_HEIGHT_MASK) = 0) and 

410 
((tx and LAND_WIDTH_MASK) = 0) and 

411 
(Land[ty, tx] = 0) do // TODO: check for constant variable instead 

412 
begin 

413 
lx:= lx + ax; 

414 
ly:= ly + ay; 

415 
tx:= round(lx); 

8854
31133afaa025
remove 70c086d9b03f  I suspect the issue was actually part of more general prob probably fixed in cfc44db21d72 by jaree
nemo
parents:
8733
diff
changeset

416 
ty:= round(ly) 
4388  417 
end; 
418 
// reached edge of land. assume infinite beam. Extend it way out past camera 

419 
if ((ty and LAND_HEIGHT_MASK) <> 0) or ((tx and LAND_WIDTH_MASK) <> 0) then 

420 
begin 

7829
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

421 
tx:= round(lx + ax * (max(LAND_WIDTH,4096) div 2)); 
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

422 
ty:= round(ly + ay * (max(LAND_WIDTH,4096) div 2)); 
4388  423 
end; 
424 

425 
//if (abs(lxtx)>8) or (abs(lyty)>8) then 

426 
begin 

427 
DrawLine(hx, hy, tx, ty, 1.0, $FF, $00, $00, $C0); 

428 
end; 

429 
end; 

430 
// draw crosshair 

5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset

431 
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

432 
CrosshairY := Round(hwRound(Gear^.Y) + dy * 80 + GetLaunchY(HH^.CurAmmoType, Gear^.Angle)); 
8689  433 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

434 
setTintAdd(true); 
9655
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9505
diff
changeset

435 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 
e154ccca4dad
Tinted crosshair (without that cool white dot in the middle)
unc0rr
parents:
9505
diff
changeset

436 
DrawTextureRotated(CrosshairTexture, 
5615
104f69e798bb
changed aiming to be triggered when touching the crosshair
Xeli
parents:
5561
diff
changeset

437 
12, 12, CrosshairX + WorldDx, CrosshairY + WorldDy, 0, 
9667
0b27737fc28f
Don't change crosshair look when hedgehog does high jump
unc0rr
parents:
9666
diff
changeset

438 
sign * m * (Gear^.Angle * 180.0) / cMaxAngle); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

439 
untint; 
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

440 
setTintAdd(false); 
4388  441 
end; 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

442 

4388  443 
hx:= ox + 8 * sign; 
444 
hy:= oy  2; 

445 
aangle:= Gear^.Angle * 180 / cMaxAngle  90; 

5935  446 
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind <> gtTardis) then 
4388  447 
begin 
448 
case CurAmmoGear^.Kind of 

449 
gtShotgunShot: begin 

450 
if (CurAmmoGear^.State and gstAnimation <> 0) then 

6999  451 
DrawSpriteRotated(sprShotgun, hx, hy, sign, aangle) 
4388  452 
else 
6999  453 
DrawSpriteRotated(sprHandShotgun, hx, hy, sign, aangle); 
4388  454 
end; 
6999  455 
gtDEagleShot: DrawSpriteRotated(sprDEagle, hx, hy, sign, aangle); 
4388  456 
gtSniperRifleShot: begin 
457 
if (CurAmmoGear^.State and gstAnimation <> 0) then 

6999  458 
DrawSpriteRotatedF(sprSniperRifle, hx, hy, 1, sign, aangle) 
4388  459 
else 
6999  460 
DrawSpriteRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle) 
4388  461 
end; 
6999  462 
gtBallgun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); 
4388  463 
gtRCPlane: begin 
6999  464 
DrawSpriteRotated(sprHandPlane, hx, hy, sign, 0); 
4388  465 
defaultPos:= false 
466 
end; 

467 
gtRope: begin 

468 
if Gear^.X < CurAmmoGear^.X then 

469 
begin 

470 
dAngle:= 0; 

471 
hAngle:= 180; 

472 
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

473 
end 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

474 
else 
4388  475 
begin 
476 
dAngle:= 180; 

477 
hAngle:= 0; 

478 
i:= 1 

479 
end; 

7547  480 
if ((Gear^.State and gstWinner) = 0) then 
481 
begin 

482 
DrawHedgehog(ox, oy, 

483 
i, 

484 
1, 

485 
0, 

486 
DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + dAngle); 

487 
with HH^ do 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

488 
if (curhat <> nil) then 
4388  489 
begin 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

490 
DrawTextureRotatedF(curhat, 1.0, 1.0, 6.0, ox, oy, 0, i, 32, 32, 
4388  491 
i*DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + hAngle); 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

492 
if curhat^.w > 64 then 
7547  493 
begin 
494 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

495 
DrawTextureRotatedF(curhat, 1.0, 1.0, 6.0, ox, oy, 32, i, 32, 32, 
7547  496 
i*DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + hAngle); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

497 
untint 
7547  498 
end 
4388  499 
end 
500 
end; 

501 
DrawAltWeapon(Gear, ox, oy); 

502 
defaultPos:= false 

503 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

504 
gtBlowTorch: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

505 
begin 
6999  506 
DrawSpriteRotated(sprBlowTorch, hx, hy, sign, aangle); 
4388  507 
DrawHedgehog(sx, sy, 
508 
sign, 

509 
3, 

510 
HH^.visStepPos div 2, 

511 
0); 

512 
with HH^ do 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

513 
if (curhat <> nil) then 
4388  514 
begin 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

515 
DrawTextureF(curhat, 
4388  516 
1, 
517 
sx, 

518 
sy  5, 

519 
0, 

520 
sign, 

521 
32, 

522 
32); 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

523 
if curhat^.w > 64 then 
4388  524 
begin 
4810  525 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

526 
DrawTextureF(curhat, 
4388  527 
1, 
528 
sx, 

529 
sy  5, 

530 
32, 

531 
sign, 

532 
32, 

533 
32); 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

534 
untint 
4388  535 
end 
536 
end; 

537 
defaultPos:= false 

538 
end; 

6999  539 
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

540 
gtFirePunch: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

541 
begin 
4388  542 
DrawHedgehog(sx, sy, 
543 
sign, 

544 
1, 

545 
4, 

546 
0); 

547 
defaultPos:= false 

548 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

549 
gtPickHammer: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

550 
begin 
4388  551 
defaultPos:= false; 
552 
dec(sy,20); 

553 
end; 

554 
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

555 
gtWhip: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

556 
begin 
6999  557 
DrawSpriteRotatedF(sprWhip, 
4388  558 
sx, 
559 
sy, 

560 
1, 

561 
sign, 

562 
0); 

563 
defaultPos:= false 

564 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

565 
gtHammer: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

566 
begin 
6999  567 
DrawSpriteRotatedF(sprHammer, 
4388  568 
sx, 
569 
sy, 

570 
1, 

571 
sign, 

572 
0); 

573 
defaultPos:= false 

574 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

575 
gtResurrector: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

576 
begin 
6999  577 
DrawSpriteRotated(sprHandResurrector, sx, sy, 0, 0); 
4388  578 
defaultPos:= false 
579 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

580 
gtKamikaze: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

581 
begin 
4388  582 
if CurAmmoGear^.Pos = 0 then 
583 
DrawHedgehog(sx, sy, 

584 
sign, 

585 
1, 

586 
6, 

587 
0) 

588 
else 

6999  589 
DrawSpriteRotatedF(sprKamikaze, 
4388  590 
ox, oy, 
591 
CurAmmoGear^.Pos  1, 

592 
sign, 

593 
aangle); 

594 
defaultPos:= false 

595 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

596 
gtSeduction: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

597 
begin 
4388  598 
if CurAmmoGear^.Pos >= 6 then 
599 
DrawHedgehog(sx, sy, 

600 
sign, 

601 
2, 

602 
2, 

603 
0) 

604 
else 

605 
begin 

6999  606 
DrawSpriteRotatedF(sprDress, 
4388  607 
ox, oy, 
608 
CurAmmoGear^.Pos, 

609 
sign, 

610 
0); 

611 
DrawSprite(sprCensored, ox  32, oy  20, 0) 

612 
end; 

613 
defaultPos:= false 

614 
end; 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

615 
gtFlamethrower: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

616 
begin 
6999  617 
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

618 
if CurAmmoGear^.Tex <> nil then 
6999  619 
DrawTextureCentered(sx, sy  40, CurAmmoGear^.Tex) 
4388  620 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

621 
gtLandGun: 
6999  622 
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

623 
if CurAmmoGear^.Tex <> nil then 
6999  624 
DrawTextureCentered(sx, sy  40, CurAmmoGear^.Tex) 
5025
ac1691d35cf2
Land sprayer tweaks, make land spray and mudball not end turn
nemo
parents:
5024
diff
changeset

625 
end; 
7093  626 
gtIceGun: 
8554  627 
begin DrawSpriteRotated(sprIceGun, hx, hy, sign, aangle); 
7093  628 
if CurAmmoGear^.Tex <> nil then 
629 
DrawTextureCentered(sx, sy  40, CurAmmoGear^.Tex) 

630 
end; 

4388  631 
end; 
632 

633 
case CurAmmoGear^.Kind of 

634 
gtShotgunShot, 

635 
gtDEagleShot, 

636 
gtSniperRifleShot, 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

637 
gtShover: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

638 
begin 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

639 
DrawHedgehog(sx, sy, sign, 0, 4, 0); 
4388  640 
defaultPos:= false; 
641 
HatVisible:= true 

642 
end 

643 
end 

644 
end else 

645 

646 
if ((Gear^.State and gstHHJumping) <> 0) then 

647 
begin 

648 
DrawHedgehog(sx, sy, 

649 
sign*m, 

650 
1, 

651 
1, 

652 
0); 

653 
HatVisible:= true; 

654 
defaultPos:= false 

655 
end else 

656 

657 
if (Gear^.Message and (gmLeft or gmRight) <> 0) and (not isCursorVisible) then 

658 
begin 

659 
DrawHedgehog(sx, sy, 

660 
sign, 

661 
0, 

662 
HH^.visStepPos div 2, 

663 
0); 

664 
defaultPos:= false; 

665 
HatVisible:= true 

666 
end 

667 
else 

668 

669 
if ((Gear^.State and gstAnimation) <> 0) then 

670 
begin 

10560  671 
if (Gear^.Tag < LongInt(ord(Low(TWave)))) or (Gear^.Tag > LongInt(ord(High(TWave)))) then 
4388  672 
begin 
6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6328
diff
changeset

673 
Gear^.State:= Gear^.State and (not gstAnimation); 
4388  674 
end 
675 
else 

676 
begin 

6999  677 
DrawSpriteRotatedF(Wavez[TWave(Gear^.Tag)].Sprite, 
4388  678 
sx, 
679 
sy, 

680 
Gear^.Pos, 

681 
sign, 

682 
0.0); 

683 
defaultPos:= false 

684 
end 

685 
end 

686 
else 

687 
if ((Gear^.State and gstAttacked) = 0) then 

688 
begin 

689 
if HH^.Timer > 0 then 

690 
begin 

691 
// 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

692 
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

693 
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

694 
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

695 
aangle:= aangle((aangle240)*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

696 
else 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

697 
aangle:= aangle+((240aangle)*HH^.Timer/10); 
4388  698 
dec(HH^.Timer) 
699 
end; 

700 
amt:= CurrentHedgehog^.CurAmmoType; 

6924  701 
CurWeapon:= GetCurAmmoEntry(HH^); 
4388  702 
case amt of 
6999  703 
amBazooka: DrawSpriteRotated(sprHandBazooka, hx, hy, sign, aangle); 
704 
amSnowball: DrawSpriteRotated(sprHandSnowball, hx, hy, sign, aangle); 

705 
amMortar: DrawSpriteRotated(sprHandMortar, hx, hy, sign, aangle); 

706 
amMolotov: DrawSpriteRotated(sprHandMolotov, hx, hy, sign, aangle); 

707 
amBallgun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); 

708 
amDrill: DrawSpriteRotated(sprHandDrill, hx, hy, sign, aangle); 

709 
amRope: DrawSpriteRotated(sprHandRope, hx, hy, sign, aangle); 

710 
amShotgun: DrawSpriteRotated(sprHandShotgun, hx, hy, sign, aangle); 

711 
amDEagle: DrawSpriteRotated(sprHandDEagle, hx, hy, sign, aangle); 

712 
amSineGun: DrawSpriteRotatedF(sprHandSinegun, hx, hy, 73 + (sign * LongInt(RealTicks div 73)) mod 8, sign, aangle); 

8689  713 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

714 
amPortalGun: 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

715 
if (CurWeapon^.Timer and 2) <> 0 then // Add a new Hedgehog value instead of abusing timer? 
6999  716 
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

717 
else 
6999  718 
DrawSpriteRotatedF(sprPortalGun, hx, hy, 1+CurWeapon^.Pos, sign, aangle); 
8689  719 

6999  720 
amSniperRifle: DrawSpriteRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle); 
721 
amBlowTorch: DrawSpriteRotated(sprHandBlowTorch, hx, hy, sign, aangle); 

722 
amCake: DrawSpriteRotated(sprHandCake, hx, hy, sign, aangle); 

723 
amGrenade: DrawSpriteRotated(sprHandGrenade, hx, hy, sign, aangle); 

724 
amWatermelon: DrawSpriteRotated(sprHandMelon, hx, hy, sign, aangle); 

725 
amSkip: DrawSpriteRotated(sprHandSkip, hx, hy, sign, aangle); 

726 
amClusterBomb: DrawSpriteRotated(sprHandCluster, hx, hy, sign, aangle); 

727 
amDynamite: DrawSpriteRotated(sprHandDynamite, hx, hy, sign, aangle); 

728 
amHellishBomb: DrawSpriteRotated(sprHandHellish, hx, hy, sign, aangle); 

729 
amGasBomb: DrawSpriteRotated(sprHandCheese, hx, hy, sign, aangle); 

730 
amMine: DrawSpriteRotated(sprHandMine, hx, hy, sign, aangle); 

10789
acbf69e2e5cf
experiment with air mines. thought they could make shoppa... interesting. ToDo: Allow mines to give up, tweak distances, real graphics, toggle for whether they can acquire a new target while they haven't given up.
nemo
parents:
10683
diff
changeset

731 
amAirMine: DrawSpriteRotated(sprHandMine, hx, hy, sign, aangle); 
6999  732 
amSMine: DrawSpriteRotated(sprHandSMine, hx, hy, sign, aangle); 
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset

733 
amKnife: DrawSpriteRotatedF(sprHandKnife, hx, hy, 0, sign, aangle); 
5525  734 
amSeduction: begin 
6999  735 
DrawSpriteRotated(sprHandSeduction, hx, hy, sign, aangle); 
8689  736 
DrawCircle(ox, oy, 248, 4, $FF, $00, $00, $AA); 
5561
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset

737 
//Tint($FF, $0, $0, $AA); 
dfbe55237c64
Shrink number of circle points to 60, reenable seduction circle (no longer crashes)
nemo
parents:
5560
diff
changeset

738 
//DrawTexture(ox  240, oy  240, SpritesData[sprVampiric].Texture, 10); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

739 
//untint; 
5525  740 
end; 
6999  741 
amVampiric: DrawSpriteRotatedF(sprHandVamp, hx, hy, (RealTicks div 125) mod 4, sign, aangle); 
4388  742 
amRCPlane: begin 
6999  743 
DrawSpriteRotated(sprHandPlane, hx, hy, sign, 0); 
4388  744 
defaultPos:= false 
745 
end; 

9768
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9685
diff
changeset

746 
amRubber, 
4388  747 
amGirder: begin 
6999  748 
DrawSpriteRotated(sprHandConstruction, hx, hy, sign, aangle); 
11059
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

749 
if cBuildMaxDist = cDefaultBuildMaxDist then 
9505
56e0cca99e20
Allow girder construction to wrap. Makes wrapping w/ large bodies of water a bit more interesting.
nemo
parents:
9285
diff
changeset

750 
begin 
11059
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

751 
if WorldEdge = weWrap then 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

752 
begin 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

753 
if hwRound(Gear^.X) < LongInt(leftX) + 256 then 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

754 
DrawSpriteClipped(sprGirder, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

755 
rightX+(oxleftX)256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

756 
oy256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

757 
LongInt(topY)+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

758 
LongInt(rightX)+WorldDx, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

759 
cWaterLine+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

760 
LongInt(leftX)+WorldDx); 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

761 
if hwRound(Gear^.X) > LongInt(rightX)  256 then 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

762 
DrawSpriteClipped(sprGirder, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

763 
leftX(rightXox)256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

764 
oy256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

765 
LongInt(topY)+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

766 
LongInt(rightX)+WorldDx, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

767 
cWaterLine+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

768 
LongInt(leftX)+WorldDx) 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

769 
end; 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

770 
DrawSpriteClipped(sprGirder, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

771 
ox256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

772 
oy256, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

773 
LongInt(topY)+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

774 
LongInt(rightX)+WorldDx, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

775 
cWaterLine+WorldDy, 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

776 
LongInt(leftX)+WorldDx) 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

777 
end 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

778 
else if cBuildMaxDist > 0 then 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

779 
begin 
659427d9fd17
display circle for custom build dist values, display nothing if no limit. map borders are not taken into account at this point
sheepluva
parents:
11046
diff
changeset

780 
DrawCircle(hx, hy, cBuildMaxDist, 3, $FF, 0, 0, $80); 
9505
56e0cca99e20
Allow girder construction to wrap. Makes wrapping w/ large bodies of water a bit more interesting.
nemo
parents:
9285
diff
changeset

781 
end; 
4388  782 
end; 
6999  783 
amBee: DrawSpriteRotatedF(sprHandBee, hx, hy, (RealTicks div 125) mod 4, sign, aangle); 
784 
amFlamethrower: DrawSpriteRotatedF(sprHandFlamethrower, hx, hy, (RealTicks div 125) mod 4, sign, aangle); 

785 
amLandGun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle); 

8554  786 
amIceGun: DrawSpriteRotated(sprIceGun, hx, hy, sign, aangle); 
4388  787 
amResurrector: DrawCircle(ox, oy, 98, 4, $F5, $DB, $35, $AA); // I'd rather not like to hardcode 100 here 
788 
end; 

789 

790 
case amt of 

791 
amAirAttack, 

792 
amMineStrike, 

6999  793 
amDrillStrike: DrawSpriteRotated(sprHandAirAttack, sx, oy, sign, 0); 
4388  794 
amPickHammer: DrawHedgehog(sx, sy, 
795 
sign, 

796 
1, 

797 
2, 

798 
0); 

6999  799 
amTeleport: DrawSpriteRotatedF(sprTeleport, sx, sy, 0, sign, 0); 
4388  800 
amKamikaze: DrawHedgehog(sx, sy, 
801 
sign, 

802 
1, 

803 
5, 

804 
0); 

6999  805 
amWhip: DrawSpriteRotatedF(sprWhip, 
4388  806 
sx, 
807 
sy, 

808 
0, 

809 
sign, 

810 
0); 

6999  811 
amHammer: DrawSpriteRotatedF(sprHammer, 
4388  812 
sx, 
813 
sy, 

814 
0, 

815 
sign, 

816 
0); 

817 
else 

818 
DrawHedgehog(sx, sy, 

819 
sign, 

820 
0, 

821 
4, 

822 
0); 

823 

824 
HatVisible:= true; 

825 
(* with HH^ do 

826 
if (HatTex <> nil) 

827 
and (HatVisibility > 0) then 

828 
DrawTextureF(HatTex, 

829 
HatVisibility, 

830 
sx, 

831 
sy  5, 

832 
0, 

833 
sign, 

834 
32, 

835 
32); *) 

836 
end; 

837 

838 
case amt of 

6999  839 
amBaseballBat: DrawSpriteRotated(sprHandBaseball, 
4388  840 
sx  4 * sign, 
841 
sy + 9, sign, aangle); 

842 
end; 

843 

844 
defaultPos:= false 

845 
end; 

846 

847 
end else // not gstHHDriven 

848 
begin 

8681
d0fc1dca739c
yeah. this was a bad idea. the minor difference in thaw speed vs last hog of team never unthawing.
nemo
parents:
8656
diff
changeset

849 
if (Gear^.Damage > 0) and (HH^.Effects[heFrozen] = 0) 
4388  850 
and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then 
851 
begin 

10526
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

852 
defaultPos:= false; 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

853 
DrawHedgehog(sx, sy, 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

854 
sign, 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

855 
2, 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

856 
1, 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

857 
Gear^.DirAngle); 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

858 
if AprilOne and (curhat <> nil) then 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

859 
DrawTextureRotatedF(curhat, 1.0, 1.0, 0, sx, sy, 18, sign, 32, 32, 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

860 
sign*Gear^.DirAngle) 
b43d175d1577
Avoid promoting violence to hedgehogs. At least once a year.
nemo
parents:
10523
diff
changeset

861 
end; 
10528  862 

4388  863 

864 
if ((Gear^.State and gstHHJumping) <> 0) then 

865 
begin 

866 
DrawHedgehog(sx, sy, 

867 
sign*m, 

868 
1, 

869 
1, 

870 
0); 

871 
defaultPos:= false 

872 
end; 

873 
end; 

874 

875 
with HH^ do 

876 
begin 

877 
if defaultPos then 

878 
begin 

10441
d2f599997b54
Revert hog tinting from rdb65298717da since it wasn't sufficiently complete for a release. More sprites need converting, and there's a slight bug in hog tinting, for away hogs with hats I believe.
nemo
parents:
10390
diff
changeset

879 
if HH^.Team^.hasGone then Tint($FFFFFF80); 
6999  880 
DrawSpriteRotatedF(sprHHIdle, 
4388  881 
sx, 
882 
sy, 

883 
(RealTicks div 128 + Gear^.Pos) mod 19, 

884 
sign, 

885 
0); 

886 
HatVisible:= true; 

887 
end; 

888 

889 
if HatVisible then 

890 
if HatVisibility < 1.0 then 

891 
HatVisibility:= HatVisibility + 0.2 

892 
else 

893 
else 

894 
if HatVisibility > 0.0 then 

895 
HatVisibility:= HatVisibility  0.2; 

896 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

897 
if (curhat <> nil) 
4388  898 
and (HatVisibility > 0) then 
899 
if DefaultPos then 

900 
begin 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

901 
DrawTextureF(curhat, 
4388  902 
HatVisibility, 
903 
sx, 

904 
sy  5, 

905 
(RealTicks div 128 + Gear^.Pos) mod 19, 

906 
sign, 

907 
32, 

908 
32); 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

909 
if curhat^.w > 64 then 
4388  910 
begin 
4810  911 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

912 
DrawTextureF(curhat, 
4388  913 
HatVisibility, 
914 
sx, 

915 
sy  5, 

916 
(RealTicks div 128 + Gear^.Pos) mod 19 + 32, 

917 
sign, 

918 
32, 

919 
32); 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

920 
untint 
7978  921 
end; 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

922 
if HH^.Team^.hasGone then untint 
4388  923 
end 
924 
else 

925 
begin 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

926 
DrawTextureF(curhat, 
4388  927 
HatVisibility, 
928 
sx, 

929 
sy  5, 

930 
0, 

931 
sign*m, 

932 
32, 

933 
32); 

10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

934 
if curhat^.w > 64 then 
4388  935 
begin 
4810  936 
Tint(HH^.Team^.Clan^.Color shl 8 or $FF); 
10443
42dadeb6e8ae
Remove switching of hog's hat to chef. do it in draw instead.
nemo
parents:
10441
diff
changeset

937 
DrawTextureF(curhat, 
4388  938 
HatVisibility, 
939 
sx, 

940 
sy  5, 

941 
32, 

942 
sign*m, 

943 
32, 

944 
32); 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

945 
untint 
4388  946 
end 
947 
end 

948 
end; 

949 
if (Gear^.State and gstHHDriven) <> 0 then 

950 
begin 

951 
(* if (CurAmmoGear = nil) then 

952 
begin 

953 
amt:= CurrentHedgehog^.CurAmmoType; 

954 
case amt of 

955 
amJetpack: DrawSprite(sprJetpack, sx32, sy32, 0); 

956 
end 

957 
end; *) 

958 
if CurAmmoGear <> nil then 

959 
begin 

960 
case CurAmmoGear^.Kind of 

961 
gtJetpack: begin 

962 
DrawSprite(sprJetpack, sx32, sy32, 0); 

963 
if cWaterLine > hwRound(Gear^.Y) + Gear^.Radius then 

964 
begin 

6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

965 
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

966 
DrawSprite(sprJetpack, sx32, sy28, 1); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

967 
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

968 
DrawSprite(sprJetpack, sx28, sy28, 2); 
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

969 
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

970 
DrawSprite(sprJetpack, sx36, sy28, 3) 
4388  971 
end; 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

972 
if CurAmmoGear^.Tex <> nil then 
6999  973 
DrawTextureCentered(sx, sy  40, CurAmmoGear^.Tex); 
4388  974 
DrawAltWeapon(Gear, sx, sy) 
975 
end; 

976 
end; 

977 
end 

978 
end; 

979 

980 
with HH^ do 

981 
begin 

6453
11c578d30bd3
Countless imporvements to the parser and countless help to the parser in sources.
unc0rr
parents:
6328
diff
changeset

982 
if ((Gear^.State and (not gstWinner)) = 0) 
4388  983 
or ((Gear^.State = gstWait) and (Gear^.dY.QWordValue = 0)) 
984 
or (bShowFinger and ((Gear^.State and gstHHDriven) <> 0)) then 

985 
begin 

986 
t:= sy  cHHRadius  9; 

987 
if (cTagsMask and htTransparent) <> 0 then 

988 
Tint($FF, $FF, $FF, $80); 

989 
if ((cTagsMask and htHealth) <> 0) then 

990 
begin 

991 
dec(t, HealthTagTex^.h + 2); 

6999  992 
DrawTextureCentered(ox, t, HealthTagTex) 
4388  993 
end; 
994 
if (cTagsMask and htName) <> 0 then 

995 
begin 

996 
dec(t, NameTagTex^.h + 2); 

6999  997 
DrawTextureCentered(ox, t, NameTagTex) 
4388  998 
end; 
999 
if (cTagsMask and htTeamName) <> 0 then 

1000 
begin 

1001 
dec(t, Team^.NameTagTex^.h + 2); 

6999  1002 
DrawTextureCentered(ox, t, Team^.NameTagTex) 
4388  1003 
end; 
1004 
if (cTagsMask and htTransparent) <> 0 then 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1005 
untint 
4388  1006 
end; 
1007 
if (Gear^.State and gstHHDriven) <> 0 then // Current hedgehog 

1008 
begin 

4394  1009 
if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtResurrector) then 
6999  1010 
DrawTextureCentered(ox, sy  cHHRadius  7  HealthTagTex^.h, HealthTagTex); 
4394  1011 

4388  1012 
if bShowFinger and ((Gear^.State and gstHHDriven) <> 0) then 
10000
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1013 
begin 
10001
ec523563826e
disallow currenthh arrow to go offscreen, always point in direction of the hog  this should make the life of new players easier
sheepluva
parents:
10000
diff
changeset

1014 
ty := oy  32; 
10000
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1015 
// move finger higher up if tags are above hog 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1016 
if (cTagsMask and htTeamName) <> 0 then 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1017 
ty := ty  Team^.NameTagTex^.h  2; 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1018 
if (cTagsMask and htName) <> 0 then 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1019 
ty := ty  NameTagTex^.h  2; 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1020 
if (cTagsMask and htHealth) <> 0 then 
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1021 
ty := ty  HealthTagTex^.h  2; 
10001
ec523563826e
disallow currenthh arrow to go offscreen, always point in direction of the hog  this should make the life of new players easier
sheepluva
parents:
10000
diff
changeset

1022 
tx := ox; 
10312  1023 

1024 
// don't go offscreen 

1025 
//tx := round(max(((cScreenWidth + 16) / cScaleFactor) + SpritesData[sprFinger].Width div 2, min(((cScreenWidth  16) / cScaleFactor)  SpritesData[sprFinger].Width div 2, tx))); 

1026 
//ty := round(max(cScreenHeight div 2  ((cScreenHeight  16) / cScaleFactor) + SpritesData[sprFinger].Height div 2, min(cScreenHeight div 2  ((cScreenHeight + SpritesData[sprFinger].Height) / (cScaleFactor))  SpritesData[sprFinger].Width div 2  96, ty))); 

1027 
t:= 32;//trunc((SpritesData[sprFinger].Width + t) / cScaleFactor); 

1028 
tx := min(max(tx, ViewLeftX + t), ViewRightX  t); 

1029 
t:= 32;//trunc((SpritesData[sprFinger].Height + t) / cScaleFactor); 

1030 
ty := min(ty, ViewBottomY  96); 

1031 
// don't overlap with HH or HH tags 

10313  1032 
if ty < ViewTopY + t then 
1033 
begin 

1034 
if abs(tx  ox) < abs(ty  oy) then 

1035 
ty:= max(ViewTopY + t, oy + t) 

1036 
else 

1037 
ty:= max(ViewTopY + t, ty); 

1038 
end; 

10080  1039 

10082  1040 
dAngle := DxDy2Angle(int2hwfloat(ty  oy), int2hwfloat(tx  ox)) + 90; 
10080  1041 

10312  1042 
DrawSpriteRotatedF(sprFinger, tx, ty, RealTicks div 32 mod 16, 1, dAngle); 
10000
d657b6656c19
position "finger"/pointer over current hog above tags
sheepluva
parents:
9998
diff
changeset

1043 
end; 
4388  1044 

10001
ec523563826e
disallow currenthh arrow to go offscreen, always point in direction of the hog  this should make the life of new players easier
sheepluva
parents:
10000
diff
changeset

1045 

4388  1046 
if (Gear^.State and gstDrowning) = 0 then 
1047 
if (Gear^.State and gstHHThinking) <> 0 then 

1048 
DrawSprite(sprQuestion, ox  10, oy  cHHRadius  34, (RealTicks shr 9) mod 8) 

1049 
end 

1050 
end; 

1051 

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

1052 
if HH^.Effects[hePoisoned] <> 0 then 
4388  1053 
begin 
1054 
Tint($00, $FF, $40, $80); 

10142  1055 
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 1.5, 0, 0, sx, sy, 0, 1, 22, 22, 360  (RealTicks shr 5) mod 360); 
4388  1056 
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

1057 
if HH^.Effects[heResurrected] <> 0 then 
4388  1058 
begin 
1059 
Tint($f5, $db, $35, $20); 

1060 
DrawSprite(sprVampiric, sx  24, sy  24, 0); 

1061 
end; 

1062 

9685
7d925e82e572
Tweak trophyrace to work better w/ skip (probably, needs testing), drop Invulnerable in favour of effects  heInvulnerable is already in effects,
nemo
parents:
9667
diff
changeset

1063 
if (Gear^.Hedgehog^.Effects[heInvulnerable] <> 0) then 
4388  1064 
begin 
1065 
Tint($FF, $FF, $FF, max($40, round($FF * abs(1  ((RealTicks div 2 + Gear^.uid * 491) mod 1500) / 750)))); 

1066 
DrawSprite(sprInvulnerable, sx  24, sy  24, 0); 

1067 
end; 

8557  1068 

8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

1069 
if HH^.Effects[heFrozen] < 150000 then 
8557  1070 
begin 
8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

1071 
if HH^.Effects[heFrozen] < 150000 then 
8681
d0fc1dca739c
yeah. this was a bad idea. the minor difference in thaw speed vs last hog of team never unthawing.
nemo
parents:
8656
diff
changeset

1072 
Tint($FF, $FF, $FF, min(255,127+HH^.Effects[heFrozen] div 800)); 
8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

1073 

8684  1074 
iceOffset:= min(32, HH^.Effects[heFrozen] div 8); 
8560  1075 
r.x := 128; 
8684  1076 
r.y := 96  iceOffset; 
1077 
r.w := 32; 

8689  1078 
r.h := iceOffset; 
10324
5d90d8ca9657
tweak code of DrawTextureFromRectDir a bit, removing issue with different x offset depending on dir. also removing the workaround wrt that issue in the frozen hog code
sheepluva
parents:
10313
diff
changeset

1079 
DrawTextureFromRectDir(sx  16 + sign*2, sy + 16  iceoffset, r.w, r.h, @r, HHTexture, sign); 
8684  1080 

8557  1081 

8656
a8282143a8df
use opacity to indicate thawing. not totally happy w/ effect, but argument was made to indicate some progress towards thaw. drop "exit" since it really wasn't helpful, and not rendering tags, was more annoying than fun.
nemo
parents:
8628
diff
changeset

1082 
if HH^.Effects[heFrozen] < 150000 then 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1083 
untint; 
8557  1084 
end; 
1085 

1086 

4388  1087 
if cVampiric and 
1088 
(CurrentHedgehog^.Gear <> nil) and 

1089 
(CurrentHedgehog^.Gear = Gear) then 

1090 
begin 

1091 
Tint($FF, 0, 0, max($40, round($FF * abs(1  (RealTicks mod 1500) / 750)))); 

1092 
DrawSprite(sprVampiric, sx  24, sy  24, 0); 

1093 
end; 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1094 
untint 
4388  1095 
end; 
1096 

1097 

1098 
procedure RenderGear(Gear: PGear; x, y: LongInt); 

1099 
var 

1100 
HHGear: PGear; 

7093  1101 
vg: PVisualGear; 
4388  1102 
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

1103 
aAngle: real; 
4388  1104 
startX, endX, startY, endY: LongInt; 
1105 
begin 

9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1106 
if Gear^.State and gstFrozen <> 0 then Tint($A0, $A0, $FF, $FF); 
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1107 
//if Gear^.State and gstFrozen <> 0 then Tint(IceColor or $FF); 
5612
2638dec1b323
This really should have been a TPoint for consistency
nemo
parents:
5561
diff
changeset

1108 
if Gear^.Target.X <> NoPointX then 
5507
1040c0946ef8
This should make bee/airstrikes play nicer with infinite attack mode
nemo
parents:
5472
diff
changeset

1109 
if Gear^.AmmoType = amBee then 
6999  1110 
DrawSpriteRotatedF(sprTargetBee, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, 0, 0, (RealTicks shr 3) mod 360) 
8689  1111 
else if Gear^.AmmoType = amIceGun then 
1112 
//DrawSprite(sprSnowDust, Gear^.Target.X + WorldDx, Gear^.Target.Y + WorldDy, (RealTicks shr 2) mod 8) 

7093  1113 
//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) 
1114 
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

1115 
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

1116 
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

1117 

4388  1118 
case Gear^.Kind of 
6999  1119 
gtGrenade: DrawSpriteRotated(sprBomb, x, y, 0, Gear^.DirAngle); 
1120 
gtSnowball: DrawSpriteRotated(sprSnowball, x, y, 0, Gear^.DirAngle); 

1121 
gtGasBomb: DrawSpriteRotated(sprCheese, x, y, 0, Gear^.DirAngle); 

8689  1122 

5871
09daa06191d7
Since we are tweaking molotov. make the flame flickery and add a drowning frame
nemo
parents:
5787
diff
changeset

1123 
gtMolotov: if (Gear^.State and gstDrowning) = 0 then 
6999  1124 
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

1125 
else DrawSprite(sprMolotov, x, y, 8); 
4388  1126 

1127 
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

1128 
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

1129 
if Gear^.Tag < 0 then aangle:= 360aangle; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1130 
Tint(Gear^.Tint); 
6999  1131 
DrawSpriteRotatedF(sprPlane, x, y, 0, Gear^.Tag, aangle  90); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1132 
untint; 
6999  1133 
DrawSpriteRotatedF(sprPlane, x, y, 1, Gear^.Tag, aangle  90) 
4388  1134 
end; 
6999  1135 
gtBall: DrawSpriteRotatedF(sprBalls, x, y, Gear^.Tag,0, Gear^.DirAngle); 
4388  1136 

1137 
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

1138 
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

1139 
or ((Gear^.LinkedGear^.Tag and 1) = 0) then // linked portal still moving? 
6999  1140 
DrawSpriteRotatedF(sprPortal, x, y, Gear^.Tag, hwSign(Gear^.dX), Gear^.DirAngle) 
1141 
else DrawSpriteRotatedF(sprPortal, x, y, 4 + Gear^.Tag div 2, hwSign(Gear^.dX), Gear^.DirAngle); 

4388  1142 

1143 
gtDrill: if (Gear^.State and gsttmpFlag) <> 0 then 

6999  1144 
DrawSpriteRotated(sprAirDrill, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)) 
4388  1145 
else 
6999  1146 
DrawSpriteRotated(sprDrill, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  1147 

1148 
gtHedgehog: DrawHH(Gear, x, y); 

1149 

6999  1150 
gtShell: DrawSpriteRotated(sprBazookaShell, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  1151 

1152 
gtGrave: begin 

1153 
DrawTextureF(Gear^.Hedgehog^.Team^.GraveTex, 1, x, y, (GameTicks shr 7+Gear^.uid) and 7, 1, 32, 32); 

1154 
if Gear^.Health > 0 then 

1155 
begin 

1156 
//Tint($33, $33, $FF, max($40, round($FF * abs(1  (GameTicks mod (6000 div Gear^.Health)) / 750)))); 

1157 
Tint($f5, $db, $35, max($40, round($FF * abs(1  (GameTicks mod 1500) / (750 + Gear^.Health))))); 

1158 
//Tint($FF, $FF, $FF, max($40, round($FF * abs(1  (RealTicks mod 1500) / 750)))); 

1159 
DrawSprite(sprVampiric, x  24, y  24, 0); 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1160 
untint 
4388  1161 
end 
1162 
end; 

6999  1163 
gtBee: DrawSpriteRotatedF(sprBee, x, y, (GameTicks shr 5) mod 2, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  1164 
gtPickHammer: DrawSprite(sprPHammer, x  16, y  50 + LongInt(((GameTicks shr 5) and 1) * 2), 0); 
1165 
gtRope: DrawRope(Gear); 

8689  1166 

9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1167 
gtMine: begin 
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1168 
if (((Gear^.State and gstAttacking) = 0)or((Gear^.Timer and $3FF) < 420)) and (Gear^.Health <> 0) then 
6999  1169 
DrawSpriteRotated(sprMineOff, x, y, 0, Gear^.DirAngle) 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1170 
else if Gear^.Health <> 0 then 
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1171 
DrawSpriteRotated(sprMineOn, x, y, 0, Gear^.DirAngle) 
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1172 
else DrawSpriteRotated(sprMineDead, x, y, 0, Gear^.DirAngle); 
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1173 
end; 
10807
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1174 
gtAirMine: if Gear^.State and gstTmpFlag = 0 then // mine is inactive 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1175 
begin 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1176 
Tint(150,150,150,255); 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1177 
DrawSprite(sprAirMine, x16, y16, 15); 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1178 
untint 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1179 
end 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1180 
else if (Gear^.Hedgehog <> nil) and (Gear^.Hedgehog^.Gear <> nil) then // mine is chasing a hog 
10800  1181 
DrawSprite(sprAirMine, x16, y16, (RealTicks div 25) mod 16) 
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10807
diff
changeset

1182 
else if Gear^.State and gstChooseTarget <> 0 then // mine is seeking for hogs 
10807
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1183 
DrawSprite(sprAirMine, x16, y16, (RealTicks div 125) mod 16) 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1184 
else 
66cde98f8cbe
Make the various mine states a bit clearer (inactive, active but not in seek mode, seek mode, chasing target)
nemo
parents:
10800
diff
changeset

1185 
DrawSprite(sprAirMine, x16, y16, 4); // mine is active but not seeking 
8689  1186 

4388  1187 
gtSMine: if (((Gear^.State and gstAttacking) = 0)or((Gear^.Timer and $3FF) < 420)) and (Gear^.Health <> 0) then 
6999  1188 
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

1189 
else if Gear^.Health <> 0 then 
6999  1190 
DrawSpriteRotated(sprSMineOn, x, y, 0, Gear^.DirAngle) 
1191 
else DrawSpriteRotated(sprMineDead, x, y, 0, Gear^.DirAngle); 

7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7721
diff
changeset

1192 
gtKnife: DrawSpriteRotatedF(sprKnife, x, y, 0, hwSign(Gear^.dX), Gear^.DirAngle); 
8689  1193 

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

1194 
gtCase: begin 
7276  1195 
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

1196 
begin 
7276  1197 
if ((Gear^.Pos and posCaseAmmo) <> 0) then 
1198 
begin 

9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1199 
if Gear^.State and gstFrozen <> 0 then 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1200 
DrawSprite(sprCase, x  24, y  28, 0) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1201 
else 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1202 
begin 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1203 
i:= (GameTicks shr 6) mod 64; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1204 
if i > 18 then i:= 0; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1205 
DrawSprite(sprCase, x  24, y  24, i) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1206 
end 
7276  1207 
end 
1208 
else if ((Gear^.Pos and posCaseHealth) <> 0) then 

1209 
begin 

9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1210 
if Gear^.State and gstFrozen <> 0 then 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1211 
DrawSprite(sprFAid, x  24, y  28, 0) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1212 
else 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1213 
begin 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1214 
i:= ((GameTicks shr 6) + 38) mod 64; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1215 
if i > 13 then i:= 0; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1216 
DrawSprite(sprFAid, x  24, y  24, i) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1217 
end 
7276  1218 
end 
1219 
else if ((Gear^.Pos and posCaseUtility) <> 0) then 

1220 
begin 

9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1221 
if Gear^.State and gstFrozen <> 0 then 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1222 
DrawSprite(sprUtility, x  24, y  28, 0) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1223 
else 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1224 
begin 
9044
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1225 
i:= (GameTicks shr 6) mod 70; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1226 
if i > 23 then i:= 0; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1227 
i:= i mod 12; 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1228 
DrawSprite(sprUtility, x  24, y  24, i) 
8a829987d514
as long as a generic placeholder tint is in place. can't just exit
nemo
parents:
9041
diff
changeset

1229 
end 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1230 
end 
7276  1231 
end; 
7337
c224cd2d32f3
Allow script to set number of ammo in a crate. untested.
nemo
parents:
7276
diff
changeset

1232 
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

1233 
begin 
10562  1234 
DrawTextureRotatedF(SpritesData[sprPortal].texture, MinD(abs(1.25  (Gear^.Timer mod 1333) / 400), 1.25), 0, 0, 
7721  1235 
x, LongInt(Gear^.Angle) + WorldDy  16, 4 + Gear^.Tag, 1, 32, 32, 270); 
7276  1236 
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

1237 
end; 
4388  1238 
gtExplosives: begin 
1239 
if ((Gear^.State and gstDrowning) <> 0) then 

1240 
DrawSprite(sprExplosivesRoll, x  24, y  24, 0) 

1241 
else if Gear^.State and gstAnimation = 0 then 

1242 
begin 

1243 
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

1244 
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

1245 
i:= 0; 
4388  1246 
DrawSprite(sprExplosives, x  24, y  24, i) 
1247 
end 

1248 
else if Gear^.State and gsttmpFlag = 0 then 

6999  1249 
DrawSpriteRotatedF(sprExplosivesRoll, x, y + 4, 0, 0, Gear^.DirAngle) 
4388  1250 
else 
9041
aefe46d64dd9
Make frozen crates uncollectable, add some tinting to frozen items. Suggestions needed for what should happen to explosives
nemo
parents:
8854
diff
changeset

1251 
DrawSpriteRotatedF(sprExplosivesRoll, x, y + 4, 1, 0, Gear^.DirAngle) 
4388  1252 
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

1253 
gtDynamite: DrawSprite(sprDynamite, x  16, y  25, Gear^.Tag and 1, Gear^.Tag shr 1); 
6999  1254 
gtClusterBomb: DrawSpriteRotated(sprClusterBomb, x, y, 0, Gear^.DirAngle); 
4388  1255 
gtCluster: DrawSprite(sprClusterParticle, x  8, y  8, 0); 
6324  1256 
gtFlame: if Gear^.Tag and 1 = 0 then 
1257 
DrawTextureF(SpritesData[sprFlame].Texture, 2 / (Gear^.Tag mod 3 + 2), x, y, (GameTicks shr 7 + LongWord(Gear^.Tag)) mod 8, 1, 16, 16) 

1258 
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  1259 
gtParachute: begin 
1260 
DrawSprite(sprParachute, x  24, y  48, 0); 

1261 
DrawAltWeapon(Gear, x + 1, y  3) 

1262 
end; 

6308  1263 
gtAirAttack: begin 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1264 
Tint(Gear^.Tint); 
6999  1265 
DrawSpriteRotatedF(sprAirplane, x, y, 0, Gear^.Tag, 0); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1266 
untint; 
6999  1267 
DrawSpriteRotatedF(sprAirplane, x, y, 1, Gear^.Tag, 0); 
6308  1268 
end; 
6999  1269 
gtAirBomb: DrawSpriteRotated(sprAirBomb, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  1270 
gtTeleport: begin 
1271 
HHGear:= Gear^.Hedgehog^.Gear; 

10683  1272 
if HHGear <> nil then 
1273 
begin 

1274 
if ((Gear^.State and gstAnimation) <> 0) then 

1275 
DrawSpriteRotatedF(sprTeleport, x + 1, y  3, Gear^.Pos, hwSign(Gear^.dX), 0); 

1276 
DrawSpriteRotatedF(sprTeleport, hwRound(HHGear^.X) + 1 + WorldDx, hwRound(HHGear^.Y)  3 + WorldDy, 11  Gear^.Pos, hwSign(HHGear^.dX), 0) 

1277 
end 

4388  1278 
end; 
1279 
gtSwitcher: DrawSprite(sprSwitch, x  16, y  56, (GameTicks shr 6) mod 12); 

1280 
gtTarget: begin 

1281 
Tint($FF, $FF, $FF, round($FF * Gear^.Timer / 1000)); 

1282 
DrawSprite(sprTarget, x  16, y  16, 0); 

9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1283 
untint; 
4388  1284 
end; 
6999  1285 
gtMortar: DrawSpriteRotated(sprMortar, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
4388  1286 
gtCake: if Gear^.Pos = 6 then 
6999  1287 
DrawSpriteRotatedF(sprCakeWalk, x, y, (GameTicks div 40) mod 6, hwSign(Gear^.dX), Gear^.DirAngle * hwSign(Gear^.dX) + 90) 
4388  1288 
else 
6999  1289 
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

1290 
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

1291 
DrawSprite(sprSeduction, x  16, y  16, 0); 
8689  1292 

6999  1293 
gtWatermelon: DrawSpriteRotatedF(sprWatermelon, x, y, 0, 0, Gear^.DirAngle); 
1294 
gtMelonPiece: DrawSpriteRotatedF(sprWatermelon, x, y, 1, 0, Gear^.DirAngle); 

1295 
gtHellishBomb: DrawSpriteRotated(sprHellishBomb, x, y, 0, Gear^.DirAngle); 

4388  1296 
gtBirdy: begin 
1297 
if Gear^.State and gstAnimation = gstAnimation then 

1298 
begin 

1299 
if Gear^.State and gstTmpFlag = 0 then // Appearing 

1300 
begin 

1301 
endX:= x  WorldDx; 

1302 
endY:= y  WorldDy; 

1303 
if Gear^.Tag < 0 then 

7829
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

1304 
startX:= max(max(LAND_WIDTH,4096) + 1024, endX + 2048) 
4388  1305 
else 
7829
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

1306 
startX:= max(max(LAND_WIDTH,4096)  1024, endX  2048); 
8414
c1ac0b64315e
Start piano higher (piano on maps that matched land_height was really weird before). Experiment w/ trying to make birdy shrink into distance to avoid odd birdy vanishes if tracking it.
nemo
parents:
8370
diff
changeset

1307 
startY:= endY  1024; 
c1ac0b64315e
Start piano higher (piano on maps that matched land_height was really weird before). Experiment w/ trying to make birdy shrink into distance to avoid odd birdy vanishes if tracking it.
nemo
parents:
8370
diff
changeset

1308 
DrawTextureF(SpritesData[sprBirdy].Texture, min(Gear^.Timer/750,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  1309 
end 
1310 
else // Disappearing 

1311 
begin 

1312 
startX:= x  WorldDx; 

1313 
startY:= y  WorldDy; 

1314 
if Gear^.Tag > 0 then 

7829
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

1315 
endX:= max(max(LAND_WIDTH,4096) + 1024, startX + 2048) 
4388  1316 
else 
7829
c1dc7839d7b9
Set minimums on a few values to avoid camera zooming out past them. partly Issue #430. Might be worth defining a new constant for this.
nemo
parents:
7730
diff
changeset

1317 
endX:= max(max(LAND_WIDTH,4096)  1024, startX  2048); 
8414
c1ac0b64315e
Start piano higher (piano on maps that matched land_height was really weird before). Experiment w/ trying to make birdy shrink into distance to avoid odd birdy vanishes if tracking it.
nemo
parents:
8370
diff
changeset

1318 
endY:= startY + 1024; 
c1ac0b64315e
Start piano higher (piano on maps that matched land_height was really weird before). Experiment w/ trying to make birdy shrink into distance to avoid odd birdy vanishes if tracking it.
nemo
parents:
8370
diff
changeset

1319 
DrawTextureF(SpritesData[sprBirdy].Texture, min((2000Gear^.Timer)/750,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  1320 
end; 
1321 
end 

1322 
else 

5528
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset

1323 
begin 
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset

1324 
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

1325 
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

1326 
else 
c539e5c81870
slight visual tweak. birdy's wings beat faster if he's just about tired out
nemo
parents:
5526
diff
changeset

1327 
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

1328 
end; 
4388  1329 
end; 
6999  1330 
gtEgg: DrawTextureRotatedF(SpritesData[sprEgg].Texture, 1, 0, 0, x, y, 0, 1, 16, 16, Gear^.DirAngle); 
4388  1331 
gtPiano: begin 
1332 
if (Gear^.State and gstDrowning) = 0 then 

1333 
begin 

1334 
Tint($FF, $FF, $FF, $10); 

1335 
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

1336 
DrawTextureF(SpritesData[sprPiano].Texture, 1, x, y  hwRound(Gear^.dY * 4 * i), 0, 1, 128, 128); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1337 
untint 
4388  1338 
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

1339 
DrawTextureF(SpritesData[sprPiano].Texture, 1, x, y, 0, 1, 128, 128); 
4388  1340 
end; 
1341 
gtPoisonCloud: begin 

1342 
if Gear^.Timer < 1020 then 

10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1343 
Tint(Gear^.Tint and $FFFFFF00 or Gear^.Timer div 8) 
4388  1344 
else if Gear^.Timer > 3980 then 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1345 
Tint(Gear^.Tint and $FFFFFF00 or (5000  Gear^.Timer) div 8) 
4388  1346 
else 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1347 
Tint(Gear^.Tint); 
10142  1348 
DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 3, 0, 0, x, y, 0, 1, 22, 22, (RealTicks shr 4 + Gear^.UID * 100) mod 360); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1349 
untint 
4388  1350 
end; 
1351 
gtResurrector: begin 

6999  1352 
DrawSpriteRotated(sprCross, x, y, 0, 0); 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1353 
Tint(Gear^.Tint and $FFFFFF00 or max($00, round($C0 * abs(1  (GameTicks mod 6000) / 3000)))); 
4388  1354 
DrawTexture(x  108, y  108, SpritesData[sprVampiric].Texture, 4.5); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1355 
untint; 
4388  1356 
end; 
6999  1357 
gtNapalmBomb: DrawSpriteRotated(sprNapalmBomb, x, y, 0, DxDy2Angle(Gear^.dY, Gear^.dX)); 
5519  1358 
gtFlake: if Gear^.State and (gstDrowning or gstTmpFlag) <> 0 then 
5024  1359 
begin 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
10001
diff
changeset

1360 
Tint(Gear^.Tint); 
5025
ac1691d35cf2
Land sprayer tweaks, make land spray and mudball not end turn
nemo
parents:
5024
diff
changeset

1361 
// Needs a nicer white texture to tint 
6999  1362 
DrawTextureRotatedF(SpritesData[sprSnowDust].Texture, 1, 0, 0, x, y, 0, 1, 8, 8, Gear^.DirAngle); 
1363 
//DrawSpriteRotated(sprSnowDust, x, y, 0, Gear^.DirAngle); 

5472  1364 
//DrawTexture(x, y, SpritesData[sprVampiric].Texture, 0.1); 
9666
8dcb25112d96
 Bring back white dot in the center of crosshair. Crosshair is blurred now!
unc0rr
parents:
9655
diff
changeset

1365 
untint; 
5024  1366 
end 
5787  1367 
else //if not isInLag then 
5024  1368 
begin 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

1369 
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

1370 
inc(Gear^.FlightTime, 8) 
8026
4a4f21070479
merge xymeng's gsoc engine with a few updates (and further checks on symbol definitions)
koda
parents:
7978
diff
changeset

1371 
else if (not isInLag) and (Gear^.FlightTime > 0) then 
6580
6155187bf599
A partial reformatting of the pascal code to have consistent syntax. Things that are still inconsistent.
lovelacer
parents:
6508
diff
changeset

1372 
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

1373 
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

1374 
Tint($FF, $FF, $FF, $FFmin(255,Gear^.FlightTime)); 
4617  1375 
if vobVelocity = 0 then 
5024  1376 
DrawSprite(sprFlake, x, y, Gear^.Timer) 
1377 
else 

6999  1378 
DrawSpriteRotatedF(sprFlake, x, y, Gear^.Timer, 1, Gear^.DirAngle); 
5024  1379 
//DrawSprite(sprFlake, xSpritesData[sprFlake].Width div 2, ySpritesData[sprFlake].Height div 2, Gear^.Timer) 
6999
