author  Wuzzy <Wuzzy2@mail.ru> 
Sun, 07 Apr 2019 19:26:16 +0200  
changeset 14750  ab7bf5036314 
parent 14749  533ac9774279 
child 14752  56098968df90 
permissions  rwrr 
6581  1 
(* 
2 
* Hedgewars, a free turn based strategy game 

11046  3 
* Copyright (c) 20042015 Andrey Korotaev <unC0Rr@gmail.com> 
6581  4 
* 
5 
* This program is free software; you can redistribute it and/or modify 

6 
* it under the terms of the GNU General Public License as published by 

7 
* the Free Software Foundation; version 2 of the License 

8 
* 

9 
* This program is distributed in the hope that it will be useful, 

10 
* but WITHOUT ANY WARRANTY; without even the implied warranty of 

11 
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

12 
* GNU General Public License for more details. 

13 
* 

14 
* You should have received a copy of the GNU General Public License 

15 
* along with this program; if not, write to the Free Software 

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:
10040
diff
changeset

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

19 
{$INCLUDE "options.inc"} 

20 
unit uGearsList; 

21 

22 
interface 

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

23 
uses uFloat, uTypes, SDLh; 
6581  24 

25 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; 

11203  26 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear; 
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

27 
procedure DeleteGear(Gear: PGear); 
6581  28 
procedure InsertGearToList(Gear: PGear); 
29 
procedure RemoveGearFromList(Gear: PGear); 

30 

7395  31 
var curHandledGear: PGear; 
32 

6581  33 
implementation 
34 

35 
uses uRandom, uUtils, uConsts, uVariables, uAmmos, uTeams, uStats, 

36 
uTextures, uScript, uRenderUtils, uAI, uCollisions, 

7395  37 
uGearsRender, uGearsUtils, uDebug; 
6581  38 

8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

39 
const 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

40 
GearKindAmmoTypeMap : array [TGearType] of TAmmoType = ( 
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

41 
(* gtFlame *) amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

42 
(* gtHedgehog *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

43 
(* gtMine *) , amMine 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

44 
(* gtCase *) , amNothing 
10829  45 
(* gtAirMine *) , amAirMine 
8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

46 
(* gtExplosives *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

47 
(* gtGrenade *) , amGrenade 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

48 
(* gtShell *) , amBazooka 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

49 
(* gtGrave *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

50 
(* gtBee *) , amBee 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

51 
(* gtShotgunShot *) , amShotgun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

52 
(* gtPickHammer *) , amPickHammer 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

53 
(* gtRope *) , amRope 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

54 
(* gtDEagleShot *) , amDEagle 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

55 
(* gtDynamite *) , amDynamite 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

56 
(* gtClusterBomb *) , amClusterBomb 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

57 
(* gtCluster *) , amClusterBomb 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

58 
(* gtShover *) , amBaseballBat // Shover is only used for baseball bat right now 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

59 
(* gtFirePunch *) , amFirePunch 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

60 
(* gtATStartGame *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

61 
(* gtATFinishGame *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

62 
(* gtParachute *) , amParachute 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

63 
(* gtAirAttack *) , amAirAttack 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

64 
(* gtAirBomb *) , amAirAttack 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

65 
(* gtBlowTorch *) , amBlowTorch 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

66 
(* gtGirder *) , amGirder 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

67 
(* gtTeleport *) , amTeleport 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

68 
(* gtSwitcher *) , amSwitch 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

69 
(* gtTarget *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

70 
(* gtMortar *) , amMortar 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

71 
(* gtWhip *) , amWhip 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

72 
(* gtKamikaze *) , amKamikaze 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

73 
(* gtCake *) , amCake 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

74 
(* gtSeduction *) , amSeduction 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

75 
(* gtWatermelon *) , amWatermelon 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

76 
(* gtMelonPiece *) , amWatermelon 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

77 
(* gtHellishBomb *) , amHellishBomb 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

78 
(* gtWaterUp *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

79 
(* gtDrill *) , amDrill 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

80 
(* gtBallGun *) , amBallgun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

81 
(* gtBall *) , amBallgun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

82 
(* gtRCPlane *) , amRCPlane 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

83 
(*gtSniperRifleShot *) , amSniperRifle 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

84 
(* gtJetpack *) , amJetpack 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

85 
(* gtMolotov *) , amMolotov 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

86 
(* gtBirdy *) , amBirdy 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

87 
(* gtEgg *) , amBirdy 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

88 
(* gtPortal *) , amPortalGun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

89 
(* gtPiano *) , amPiano 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

90 
(* gtGasBomb *) , amGasBomb 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

91 
(* gtSineGunShot *) , amSineGun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

92 
(* gtFlamethrower *) , amFlamethrower 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

93 
(* gtSMine *) , amSMine 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

94 
(* gtPoisonCloud *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

95 
(* gtHammer *) , amHammer 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

96 
(* gtHammerHit *) , amHammer 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

97 
(* gtResurrector *) , amResurrector 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

98 
(* gtPoisonCloud *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

99 
(* gtSnowball *) , amSnowball 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

100 
(* gtFlake *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

101 
(* gtLandGun *) , amLandGun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

102 
(* gtTardis *) , amTardis 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

103 
(* gtIceGun *) , amIceGun 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

104 
(* gtAddAmmo *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

105 
(* gtGenericFaller *) , amNothing 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

106 
(* gtKnife *) , amKnife 
13851
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13850
diff
changeset

107 
(* gtCreeper *) , amCreeper 
12898  108 
(* gtMinigun *) , amMinigun 
109 
(* gtMinigunBullet *) , amMinigun 

8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

110 
); 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

111 

6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

112 

7093  113 
var GCounter: LongWord = 0; // this does not get reinitialized, but should be harmless 
7028  114 

8145
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

115 
const 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

116 
cUsualZ = 500; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

117 
cOnHHZ = 2000; 
6408c0ba4ba1
Move global variables to units that use them
Joe Doyle (Ginto8) <ginto8@gmail.com>
parents:
7754
diff
changeset

118 

6581  119 
procedure InsertGearToList(Gear: PGear); 
120 
var tmp, ptmp: PGear; 

121 
begin 

122 
tmp:= GearsList; 

123 
ptmp:= GearsList; 

7366
e5a0856708dc
Insert at front of same Z, not end. Saves a little time on insertion and lua lookup of recent adds.
nemo
parents:
7364
diff
changeset

124 
while (tmp <> nil) and (tmp^.Z < Gear^.Z) do 
6581  125 
begin 
126 
ptmp:= tmp; 

127 
tmp:= tmp^.NextGear 

128 
end; 

129 

130 
if ptmp <> tmp then 

131 
begin 

132 
Gear^.NextGear:= ptmp^.NextGear; 

133 
Gear^.PrevGear:= ptmp; 

134 
if ptmp^.NextGear <> nil then 

135 
ptmp^.NextGear^.PrevGear:= Gear; 

136 
ptmp^.NextGear:= Gear 

137 
end 

138 
else 

139 
begin 

140 
Gear^.NextGear:= GearsList; 

141 
if Gear^.NextGear <> nil then 

142 
Gear^.NextGear^.PrevGear:= Gear; 

143 
GearsList:= Gear; 

144 
end; 

145 
end; 

146 

7395  147 

6581  148 
procedure RemoveGearFromList(Gear: PGear); 
149 
begin 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

150 
if (Gear <> GearsList) and (Gear <> nil) and (Gear^.NextGear = nil) and (Gear^.PrevGear = nil) then 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

151 
begin 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

152 
AddFileLog('Attempted to remove Gear #'+inttostr(Gear^.uid)+' from the list twice.'); 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

153 
exit 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

154 
end; 
11539  155 

156 
checkFails((Gear = nil) or (curHandledGear = nil) or (Gear = curHandledGear), 'You''re doing it wrong', true); 

7395  157 

6581  158 
if Gear^.NextGear <> nil then 
159 
Gear^.NextGear^.PrevGear:= Gear^.PrevGear; 

160 
if Gear^.PrevGear <> nil then 

161 
Gear^.PrevGear^.NextGear:= Gear^.NextGear 

11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

162 
else 
10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

163 
GearsList:= Gear^.NextGear; 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

164 

35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

165 
Gear^.NextGear:= nil; 
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

166 
Gear^.PrevGear:= nil 
6581  167 
end; 
7395  168 

169 

6581  170 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer: LongWord): PGear; 
11203  171 
begin 
172 
AddGear:= AddGear(X, Y, Kind, State, dX, dY, Timer, 0); 

173 
end; 

174 
function AddGear(X, Y: LongInt; Kind: TGearType; State: Longword; dX, dY: hwFloat; Timer, newUid: LongWord): PGear; 

6581  175 
var gear: PGear; 
10518
dbbe2f6c0a96
make gear ability to speak somewhat less ironic
sheepluva
parents:
10495
diff
changeset

176 
//c: byte; 
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

177 
cakeData: PCakeData; 
6581  178 
begin 
11203  179 
if newUid = 0 then 
180 
inc(GCounter); 

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

181 

7028  182 
AddFileLog('AddGear: #' + inttostr(GCounter) + ' (' + inttostr(x) + ',' + inttostr(y) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); 
6581  183 

8330  184 

6581  185 
New(gear); 
186 
FillChar(gear^, sizeof(TGear), 0); 

187 
gear^.X:= int2hwFloat(X); 

188 
gear^.Y:= int2hwFloat(Y); 

189 
gear^.Target.X:= NoPointX; 

190 
gear^.Kind := Kind; 

191 
gear^.State:= State; 

192 
gear^.Active:= true; 

193 
gear^.dX:= dX; 

194 
gear^.dY:= dY; 

195 
gear^.doStep:= doStepHandlers[Kind]; 

196 
gear^.CollisionIndex:= 1; 

197 
gear^.Timer:= Timer; 

11203  198 
if newUid = 0 then 
199 
gear^.uid:= GCounter 

200 
else gear^.uid:= newUid; 

6581  201 
gear^.SoundChannel:= 1; 
202 
gear^.ImpactSound:= sndNone; 

203 
gear^.Density:= _1; 

204 
// Define ammo association, if any. 

205 
gear^.AmmoType:= GearKindAmmoTypeMap[Kind]; 

13464
7b4643ff60ea
Refactor collision mask checks, remove hardcoded numbers
Wuzzy <Wuzzy2@mail.ru>
parents:
13463
diff
changeset

206 
gear^.CollisionMask:= lfAll; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

207 
gear^.Tint:= $FFFFFFFF; 
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

208 
gear^.Data:= nil; 
13610
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

209 
gear^.Sticky:= false; 
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset

210 

8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

211 
if CurrentHedgehog <> nil then 
7726
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset

212 
begin 
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset

213 
gear^.Hedgehog:= CurrentHedgehog; 
1137406bce12
Set default collision mask for gears at currenthedgehog X/Y to FF7F, expose mask to scripting as well. This should resolve the collision part of bug #420
nemo
parents:
7721
diff
changeset

214 
if (CurrentHedgehog^.Gear <> nil) and (hwRound(CurrentHedgehog^.Gear^.X) = X) and (hwRound(CurrentHedgehog^.Gear^.Y) = Y) then 
13463
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
13399
diff
changeset

215 
gear^.CollisionMask:= lfNotCurHogCrate 
7730
2013733f9ca9
A bit more on the knife. Also add missing files to CMakeLists
nemo
parents:
7726
diff
changeset

216 
end; 
7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset

217 

7364  218 
if (Ammoz[Gear^.AmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0) then 
6581  219 
gear^.Z:= cHHZ+1 
220 
else gear^.Z:= cUsualZ; 

221 

11468
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

222 
case Kind of 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

223 
gtFlame: Gear^.Boom := 2; // some additional expl in there are x3, x4 this 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

224 
gtHedgehog: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

225 
gtMine: Gear^.Boom := 50; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

226 
gtCase: Gear^.Boom := 25; 
13399  227 
gtAirMine: Gear^.Boom := 30; 
11468
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

228 
gtExplosives: Gear^.Boom := 75; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

229 
gtGrenade: Gear^.Boom := 50; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

230 
gtShell: Gear^.Boom := 50; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

231 
gtBee: Gear^.Boom := 50; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

232 
gtShotgunShot: Gear^.Boom := 25; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

233 
gtPickHammer: Gear^.Boom := 6; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

234 
// gtRope: Gear^.Boom := 2; could be funny to have rope attaching to hog deal small amount of dmg? 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

235 
gtDEagleShot: Gear^.Boom := 7; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

236 
gtDynamite: Gear^.Boom := 75; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

237 
gtClusterBomb: Gear^.Boom := 20; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

238 
gtMelonPiece, 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

239 
gtCluster: Gear^.Boom := Timer; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

240 
gtShover: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

241 
gtFirePunch: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

242 
gtAirBomb: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

243 
gtBlowTorch: Gear^.Boom := 2; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

244 
gtMortar: Gear^.Boom := 20; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

245 
gtWhip: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

246 
gtKamikaze: Gear^.Boom := 30; // both shove and explosion 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

247 
gtCake: Gear^.Boom := cakeDmg; // why is cake damage a global constant 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

248 
gtWatermelon: Gear^.Boom := 75; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

249 
gtHellishBomb: Gear^.Boom := 90; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

250 
gtDrill: if Gear^.State and gsttmpFlag = 0 then 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

251 
Gear^.Boom := 50 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

252 
else Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

253 
gtBall: Gear^.Boom := 40; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

254 
gtRCPlane: Gear^.Boom := 25; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

255 
// sniper rifle is distance linked, this Boom is just an arbitrary scaling factor applied to timerbaseddamage 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

256 
// because, eh, why not.. 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

257 
gtSniperRifleShot: Gear^.Boom := 100000; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

258 
gtEgg: Gear^.Boom := 10; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

259 
gtPiano: Gear^.Boom := 80; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

260 
gtGasBomb: Gear^.Boom := 20; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

261 
gtSineGunShot: Gear^.Boom := 35; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

262 
gtSMine: Gear^.Boom := 30; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

263 
gtSnowball: Gear^.Boom := 200000; // arbitrary scaling for the shove 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

264 
gtHammer: if cDamageModifier > _1 then // scale it based on cDamageModifier? 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

265 
Gear^.Boom := 2 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

266 
else Gear^.Boom := 3; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

267 
gtPoisonCloud: Gear^.Boom := 20; 
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

268 
gtKnife: Gear^.Boom := 40000; // arbitrary scaling factor since impactbased 
13851
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13850
diff
changeset

269 
gtCreeper: Gear^.Boom := 100; 
12898  270 
gtMinigunBullet: Gear^.Boom := 2; 
11468
2f6f8baa2a97
Make weapon damage in most cases be a structure value and also expose it to lua. Needs testing/review due to conditions at time of doing this (w/ one arm, dizzy/tingling due to sodium citrate), and just number of places changed..
nemo
parents:
11203
diff
changeset

271 
end; 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

272 

6581  273 
case Kind of 
274 
gtGrenade, 

275 
gtClusterBomb, 

276 
gtGasBomb: begin 

277 
gear^.ImpactSound:= sndGrenadeImpact; 

278 
gear^.nImpactSounds:= 1; 

279 
gear^.AdvBounce:= 1; 

280 
gear^.Radius:= 5; 

281 
gear^.Elasticity:= _0_8; 

282 
gear^.Friction:= _0_8; 

283 
gear^.Density:= _1_5; 

284 
gear^.RenderTimer:= true; 

285 
if gear^.Timer = 0 then 

286 
gear^.Timer:= 3000 

287 
end; 

288 
gtWatermelon: begin 

289 
gear^.ImpactSound:= sndMelonImpact; 

290 
gear^.nImpactSounds:= 1; 

291 
gear^.AdvBounce:= 1; 

292 
gear^.Radius:= 6; 

293 
gear^.Elasticity:= _0_8; 

294 
gear^.Friction:= _0_995; 

295 
gear^.Density:= _2; 

296 
gear^.RenderTimer:= true; 

297 
if gear^.Timer = 0 then 

298 
gear^.Timer:= 3000 

299 
end; 

300 
gtMelonPiece: begin 

9825  301 
gear^.AdvBounce:= 1; 
10889
f7200e614295
give melon pieces a radius. is why they weren't bouncing.
nemo
parents:
10875
diff
changeset

302 
gear^.Density:= _2; 
11036
6e866be63b1d
oops. melon pieces need friction and elasticity to bounce right.
nemo
parents:
11002
diff
changeset

303 
gear^.Elasticity:= _0_8; 
6e866be63b1d
oops. melon pieces need friction and elasticity to bounce right.
nemo
parents:
11002
diff
changeset

304 
gear^.Friction:= _0_995; 
10889
f7200e614295
give melon pieces a radius. is why they weren't bouncing.
nemo
parents:
10875
diff
changeset

305 
gear^.Radius:= 4 
6581  306 
end; 
307 
gtHedgehog: begin 

308 
gear^.AdvBounce:= 1; 

309 
gear^.Radius:= cHHRadius; 

310 
gear^.Elasticity:= _0_35; 

311 
gear^.Friction:= _0_999; 

312 
gear^.Angle:= cMaxAngle div 2; 

313 
gear^.Density:= _3; 

314 
gear^.Z:= cHHZ; 

14734
e57c8ace7d96
Nemo is right, it's better to set hedgehog pos in uGearsList
Wuzzy <Wuzzy2@mail.ru>
parents:
14616
diff
changeset

315 
gear^.Pos:= GetRandom(19); 
6581  316 
if (GameFlags and gfAISurvival) <> 0 then 
317 
if gear^.Hedgehog^.BotLevel > 0 then 

7077  318 
gear^.Hedgehog^.Effects[heResurrectable] := 1; 
13096
d78e65c66573
Add hedgehog effect heArtillery, allows to set perhedgehog artillery mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12898
diff
changeset

319 
if (GameFlags and gfArtillery) <> 0 then 
d78e65c66573
Add hedgehog effect heArtillery, allows to set perhedgehog artillery mode
Wuzzy <Wuzzy2@mail.ru>
parents:
12898
diff
changeset

320 
gear^.Hedgehog^.Effects[heArtillery] := 1; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

321 
// this would presumably be set in the frontend 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

322 
// if we weren't going to do that yet, would need to reinit GetRandom 
10040  323 
// oh, and, randomising slightly R and B might be nice too. 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

324 
//gear^.Tint:= $fa00efff or ((random(80)+128) shl 16) 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

325 
//gear^.Tint:= $faa4efff 
10040  326 
//gear^.Tint:= (($e0+random(32)) shl 24) or 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

327 
// ((random(80)+128) shl 16) or 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

328 
// (($d5+random(32)) shl 8) or $ff 
10495
6d61b44a5652
 Comment out getrandom in addgear for hedgehog, causes previewgame desync
unc0rr
parents:
10494
diff
changeset

329 
{c:= GetRandom(32); 
10040  330 
gear^.Tint:= (($e0+c) shl 24) or 
10494  331 
((GetRandom(90)+128) shl 16) or 
10495
6d61b44a5652
 Comment out getrandom in addgear for hedgehog, causes previewgame desync
unc0rr
parents:
10494
diff
changeset

332 
(($d5+c) shl 8) or $ff} 
6581  333 
end; 
334 
gtShell: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

335 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

336 
gear^.Friction:= _0_8; 
6581  337 
gear^.Radius:= 4; 
338 
gear^.Density:= _1; 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

339 
gear^.AdvBounce:= 1; 
6581  340 
end; 
341 
gtSnowball: begin 

342 
gear^.ImpactSound:= sndMudballImpact; 

343 
gear^.nImpactSounds:= 1; 

344 
gear^.Radius:= 4; 

345 
gear^.Density:= _0_5; 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

346 
gear^.AdvBounce:= 1; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

347 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

348 
gear^.Friction:= _0_8; 
6581  349 
end; 
350 

351 
gtFlake: begin 

352 
with Gear^ do 

353 
begin 

354 
Pos:= 0; 

355 
Radius:= 1; 

7069  356 
DirAngle:= random(360); 
13610
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

357 
Sticky:= true; 
6581  358 
if State and gstTmpFlag = 0 then 
359 
begin 

360 
dx.isNegative:= GetRandom(2) = 0; 

9809  361 
dx.QWordValue:= QWord($40DA) * GetRandom(10000) * 8; 
6581  362 
dy.isNegative:= false; 
9809  363 
dy.QWordValue:= QWord($3AD3) * GetRandom(7000) * 8; 
6581  364 
if GetRandom(2) = 0 then 
10645
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

365 
dx := dx; 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

366 
Tint:= $FFFFFFFF 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

367 
end 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

368 
else 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

369 
Tint:= (ExplosionBorderColor shr RShift and $FF shl 24) or 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

370 
(ExplosionBorderColor shr GShift and $FF shl 16) or 
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

371 
(ExplosionBorderColor shr BShift and $FF shl 8) or $FF; 
6581  372 
State:= State or gstInvisible; 
10625
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

373 
// use health field to store current frameticks 
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

374 
if vobFrameTicks > 0 then 
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

375 
Health:= random(vobFrameTicks) 
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

376 
else 
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

377 
Health:= 0; 
125e120165aa
flake FrameTicks value of 0 now indicades that the frame should not be changed
sheepluva
parents:
10589
diff
changeset

378 
// use timer to store currently displayed frame index 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

379 
if gear^.Timer = 0 then Timer:= random(vobFramesCount); 
10645
b8c73bacb31e
Fix inflight colouring of land spray, make it use tint when added to land too (lua might find that handy), tweak climbhome cake delay slightly
nemo
parents:
10643
diff
changeset

380 
Damage:= (random(2) * 2  1) * (vobVelocity + random(vobVelocity)) * 8 
6581  381 
end 
382 
end; 

383 
gtGrave: begin 

384 
gear^.ImpactSound:= sndGraveImpact; 

385 
gear^.nImpactSounds:= 1; 

386 
gear^.Radius:= 10; 

387 
gear^.Elasticity:= _0_6; 

11541  388 
gear^.Z:= 1; 
6581  389 
end; 
390 
gtBee: begin 

391 
gear^.Radius:= 5; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

392 
if gear^.Timer = 0 then gear^.Timer:= 500; 
6581  393 
gear^.RenderTimer:= true; 
394 
gear^.Elasticity:= _0_9; 

395 
gear^.Tag:= 0; 

9479
167dea42d7d7
move border back a bit from left/right bounds, bee tweak
nemo
parents:
9195
diff
changeset

396 
gear^.State:= Gear^.State or gstSubmersible 
6581  397 
end; 
398 
gtSeduction: begin 

399 
gear^.Radius:= 250; 

400 
end; 

401 
gtShotgunShot: begin 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

402 
if gear^.Timer = 0 then gear^.Timer:= 900; 
6581  403 
gear^.Radius:= 2 
404 
end; 

405 
gtPickHammer: begin 

406 
gear^.Radius:= 10; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

407 
if gear^.Timer = 0 then gear^.Timer:= 4000 
6581  408 
end; 
409 
gtHammerHit: begin 

410 
gear^.Radius:= 8; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

411 
if gear^.Timer = 0 then gear^.Timer:= 125 
6581  412 
end; 
413 
gtRope: begin 

414 
gear^.Radius:= 3; 

415 
gear^.Friction:= _450 * _0_01 * cRopePercent; 

416 
RopePoints.Count:= 0; 

10848  417 
gear^.Tint:= $D8D8D8FF; 
418 
gear^.Tag:= 0; // normal rope render 

13463
f1d349a52bc7
Refactor: lfCurrentHogâ†’lfCurHogCrate, lfNotCurrentMaskâ†’lfNotCurHogCrate
Wuzzy <Wuzzy2@mail.ru>
parents:
13399
diff
changeset

419 
gear^.CollisionMask:= lfNotCurHogCrate //lfNotObjMask or lfNotHHObjMask; 
6581  420 
end; 
421 
gtMine: begin 

422 
gear^.ImpactSound:= sndMineImpact; 

423 
gear^.nImpactSounds:= 1; 

424 
gear^.Health:= 10; 

425 
gear^.State:= gear^.State or gstMoving; 

426 
gear^.Radius:= 2; 

427 
gear^.Elasticity:= _0_55; 

428 
gear^.Friction:= _0_995; 

7602
a620319d377e
Fix throwing things off rope, also make throwing things a bit more generic and gear density dependent (so you can throw mines further, and also throw dynamite a little).
nemo
parents:
7395
diff
changeset

429 
gear^.Density:= _1; 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

430 
if gear^.Timer = 0 then 
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

431 
begin 
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

432 
if cMinesTime < 0 then 
12169
869cf5f34700
More ticker messages: Sick, king died, resurrect, time box return, timeout, kamikaze
Wuzzy <almikes@aol.com>
parents:
12119
diff
changeset

433 
gear^.Timer:= getrandom(51)*100 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

434 
else 
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

435 
gear^.Timer:= cMinesTime 
14750
ab7bf5036314
Render mine timer if gear info is active
Wuzzy <Wuzzy2@mail.ru>
parents:
14749
diff
changeset

436 
end; 
ab7bf5036314
Render mine timer if gear info is active
Wuzzy <Wuzzy2@mail.ru>
parents:
14749
diff
changeset

437 
gear^.RenderTimer:= true; 
6581  438 
end; 
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:
10663
diff
changeset

439 
gtAirMine: begin 
13347
e7b89e87a1b3
Airmines should have been set for 45Â° bounce  the only reason they weren't I guess is they were a clone of some mine values  and mines use traditional behaviour.
nemo
parents:
13154
diff
changeset

440 
gear^.AdvBounce:= 1; 
11765
10860d4bca22
Add sound effects for: cleaver impact, air mine impact, using extra time
Wuzzy <almikes@aol.com>
parents:
11589
diff
changeset

441 
gear^.ImpactSound:= sndAirMineImpact; 
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:
10663
diff
changeset

442 
gear^.nImpactSounds:= 1; 
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:
10663
diff
changeset

443 
gear^.Health:= 30; 
10827  444 
gear^.State:= gear^.State or gstMoving or gstNoGravity or gstSubmersible; 
10802
089e43d01f74
Use the larger scaled airmine sprite originally intended, add some antidickery measures.
nemo
parents:
10800
diff
changeset

445 
gear^.Radius:= 8; 
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:
10663
diff
changeset

446 
gear^.Elasticity:= _0_55; 
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:
10663
diff
changeset

447 
gear^.Friction:= _0_995; 
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:
10663
diff
changeset

448 
gear^.Density:= _1; 
10791
0311c9fa7498
tweak a few params. still something wtf going on when on rope
nemo
parents:
10789
diff
changeset

449 
gear^.Angle:= 175; // Radius at which air bombs will start "seeking". $FFFFFFFF = unlimited. check is skipped. 
10800  450 
gear^.Power:= cMaxWindSpeed.QWordValue div 2; // hwFloat converted. 1/2 g default. defines the "seek" speed when a gear is in range. 
10828
9867dd60a66a
bit more friction. remove gstSubmersible clearing. was for the old "sea" thing that is totally gone now. As a general attribute, better to let other stuff clear it as needed.
nemo
parents:
10827
diff
changeset

451 
gear^.Pos:= cMaxWindSpeed.QWordValue * 3 div 2; // air friction. slows it down when not hitting stuff 
14200  452 
gear^.Tag:= 0; 
14750
ab7bf5036314
Render mine timer if gear info is active
Wuzzy <Wuzzy2@mail.ru>
parents:
14749
diff
changeset

453 
gear^.RenderTimer:= true; 
10805  454 
if gear^.Timer = 0 then 
455 
begin 

456 
if cMinesTime < 0 then 

457 
gear^.Timer:= getrandom(13)*100 

458 
else 

459 
gear^.Timer:= cMinesTime div 4 

460 
end; 

461 
gear^.WDTimer:= gear^.Timer 

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:
10663
diff
changeset

462 
end; 
6581  463 
gtSMine: begin 
464 
gear^.Health:= 10; 

465 
gear^.State:= gear^.State or gstMoving; 

466 
gear^.Radius:= 2; 

467 
gear^.Elasticity:= _0_55; 

468 
gear^.Friction:= _0_995; 

7602
a620319d377e
Fix throwing things off rope, also make throwing things a bit more generic and gear density dependent (so you can throw mines further, and also throw dynamite a little).
nemo
parents:
7395
diff
changeset

469 
gear^.Density:= _1_6; 
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

470 
gear^.AdvBounce:= 1; 
13610
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

471 
gear^.Sticky:= true; 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

472 
if gear^.Timer = 0 then gear^.Timer:= 500; 
14750
ab7bf5036314
Render mine timer if gear info is active
Wuzzy <Wuzzy2@mail.ru>
parents:
14749
diff
changeset

473 
gear^.RenderTimer:= true; 
6581  474 
end; 
7733  475 
gtKnife: begin 
11765
10860d4bca22
Add sound effects for: cleaver impact, air mine impact, using extra time
Wuzzy <almikes@aol.com>
parents:
11589
diff
changeset

476 
gear^.ImpactSound:= sndKnifeImpact; 
9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

477 
gear^.AdvBounce:= 1; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

478 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

479 
gear^.Friction:= _0_8; 
7754  480 
gear^.Density:= _4; 
13610
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

481 
gear^.Radius:= 7; 
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

482 
gear^.Sticky:= true; 
7733  483 
end; 
6581  484 
gtCase: begin 
13988
c28a4f76d37d
Add separate sound symbols for case impact and extra damage
Wuzzy <Wuzzy2@mail.ru>
parents:
13984
diff
changeset

485 
gear^.ImpactSound:= sndCaseImpact; 
6581  486 
gear^.nImpactSounds:= 1; 
487 
gear^.Radius:= 16; 

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:
7093
diff
changeset

488 
gear^.Elasticity:= _0_3; 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

489 
if gear^.Timer = 0 then gear^.Timer:= 500 
6581  490 
end; 
491 
gtExplosives: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

492 
gear^.AdvBounce:= 1; 
14749
533ac9774279
Add key to display extra gear info tags
Wuzzy <Wuzzy2@mail.ru>
parents:
14734
diff
changeset

493 
if GameType in [gmtDemo, gmtSave, gmtRecord] then 
533ac9774279
Add key to display extra gear info tags
Wuzzy <Wuzzy2@mail.ru>
parents:
14734
diff
changeset

494 
gear^.RenderHealth:= true; 
6581  495 
gear^.ImpactSound:= sndGrenadeImpact; 
496 
gear^.nImpactSounds:= 1; 

497 
gear^.Radius:= 16; 

498 
gear^.Elasticity:= _0_4; 

499 
gear^.Friction:= _0_995; 

500 
gear^.Density:= _6; 

501 
gear^.Health:= cBarrelHealth; 

502 
gear^.Z:= cHHZ1 

503 
end; 

504 
gtDEagleShot: begin 

505 
gear^.Radius:= 1; 

506 
gear^.Health:= 50 

507 
end; 

508 
gtSniperRifleShot: begin 

509 
gear^.Radius:= 1; 

510 
gear^.Health:= 50 

511 
end; 

512 
gtDynamite: begin 

513 
gear^.Radius:= 3; 

514 
gear^.Elasticity:= _0_55; 

515 
gear^.Friction:= _0_03; 

516 
gear^.Density:= _2; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

517 
if gear^.Timer = 0 then gear^.Timer:= 5000; 
6581  518 
end; 
519 
gtCluster: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

520 
gear^.AdvBounce:= 1; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

521 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

522 
gear^.Friction:= _0_8; 
6581  523 
gear^.Radius:= 2; 
524 
gear^.Density:= _1_5; 

525 
gear^.RenderTimer:= true 

526 
end; 

12119  527 
gtShover: begin 
528 
gear^.Radius:= 20; 

529 
gear^.Tag:= 0; 

12828  530 
gear^.Timer:= 50; 
12119  531 
end; 
6581  532 
gtFlame: begin 
533 
gear^.Tag:= GetRandom(32); 

534 
gear^.Radius:= 1; 

535 
gear^.Health:= 5; 

536 
gear^.Density:= _1; 

10589
98ea597e5cd9
expose FlightTime to lua, disable inair flame harming moving hogs â˜¹ aaaand override that in ClimbHome â˜º
nemo
parents:
10518
diff
changeset

537 
gear^.FlightTime:= 9999999; // determines whether inair flames do damage. disabled by default 
6581  538 
if (gear^.dY.QWordValue = 0) and (gear^.dX.QWordValue = 0) then 
539 
begin 

7001  540 
gear^.dY:= (getrandomf  _0_8) * _0_03; 
541 
gear^.dX:= (getrandomf  _0_5) * _0_4 

6581  542 
end 
543 
end; 

544 
gtFirePunch: begin 

9824  545 
if gear^.Timer = 0 then gear^.Timer:= 3000; 
6581  546 
gear^.Radius:= 15; 
547 
gear^.Tag:= Y 

548 
end; 

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

549 
gtAirAttack: begin 
11171  550 
gear^.Health:= 6; 
11170
22d8835beb4d
Allow for arbitrary number of airstrike bombs and spacing.
nemo
parents:
11169
diff
changeset

551 
gear^.Damage:= 30; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

552 
gear^.Z:= cHHZ+2; 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

553 
gear^.Tint:= gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

554 
end; 
6581  555 
gtAirBomb: begin 
10891
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset

556 
gear^.AdvBounce:= 1; 
6581  557 
gear^.Radius:= 5; 
558 
gear^.Density:= _2; 

10891
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset

559 
gear^.Elasticity:= _0_55; 
a4c454ef80a6
enable bounce on rubber for air bombs. give them the missing elasticity they needed for the code there to work properly.
nemo
parents:
10889
diff
changeset

560 
gear^.Friction:= _0_995 
6581  561 
end; 
562 
gtBlowTorch: begin 

563 
gear^.Radius:= cHHRadius + cBlowTorchC; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

564 
if gear^.Timer = 0 then gear^.Timer:= 7500 
6581  565 
end; 
566 
gtSwitcher: begin 

567 
gear^.Z:= cCurrHHZ 

568 
end; 

569 
gtTarget: begin 

570 
gear^.ImpactSound:= sndGrenadeImpact; 

571 
gear^.nImpactSounds:= 1; 

572 
gear^.Radius:= 10; 

573 
gear^.Elasticity:= _0_3; 

574 
end; 

575 
gtTardis: begin 

576 
gear^.Pos:= 1; 

577 
gear^.Z:= cCurrHHZ+1; 

578 
end; 

579 
gtMortar: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

580 
gear^.AdvBounce:= 1; 
6581  581 
gear^.Radius:= 4; 
582 
gear^.Elasticity:= _0_2; 

583 
gear^.Friction:= _0_08; 

584 
gear^.Density:= _1; 

585 
end; 

586 
gtWhip: gear^.Radius:= 20; 

587 
gtHammer: gear^.Radius:= 20; 

588 
gtKamikaze: begin 

589 
gear^.Health:= 2048; 

590 
gear^.Radius:= 20 

591 
end; 

592 
gtCake: begin 

593 
gear^.Health:= 2048; 

594 
gear^.Radius:= 7; 

595 
gear^.Z:= cOnHHZ; 

10875  596 
gear^.RenderTimer:= false; 
6581  597 
gear^.DirAngle:= 90 * hwSign(Gear^.dX); 
12641
f30b70976577
Fix cake taking >200s to explode when it's completely stuck and can't move (bug 194)
Wuzzy <almikes@aol.com>
parents:
12203
diff
changeset

598 
gear^.FlightTime:= 100; // (roughly) ticks spent dropping, used to skip getting up anim when stuck. 
f30b70976577
Fix cake taking >200s to explode when it's completely stuck and can't move (bug 194)
Wuzzy <almikes@aol.com>
parents:
12203
diff
changeset

599 
// Initially set to a high value so cake has at least one getting up anim. 
6581  600 
if not dX.isNegative then 
601 
gear^.Angle:= 1 

602 
else 

10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

603 
gear^.Angle:= 3; 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

604 
New(cakeData); 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

605 
gear^.Data:= Pointer(cakeData); 
6581  606 
end; 
607 
gtHellishBomb: begin 

608 
gear^.ImpactSound:= sndHellishImpact1; 

609 
gear^.nImpactSounds:= 4; 

610 
gear^.AdvBounce:= 1; 

611 
gear^.Radius:= 4; 

612 
gear^.Elasticity:= _0_5; 

613 
gear^.Friction:= _0_96; 

614 
gear^.Density:= _1_5; 

615 
gear^.RenderTimer:= true; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

616 
if gear^.Timer = 0 then gear^.Timer:= 5000 
6581  617 
end; 
618 
gtDrill: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

619 
gear^.AdvBounce:= 1; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

620 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

621 
gear^.Friction:= _0_8; 
6581  622 
if gear^.Timer = 0 then 
623 
gear^.Timer:= 5000; 

624 
// Tag for drill strike. if 1 then first impact occured already 

625 
gear^.Tag := 0; 

626 
gear^.Radius:= 4; 

627 
gear^.Density:= _1; 

628 
end; 

629 
gtBall: begin 

630 
gear^.ImpactSound:= sndGrenadeImpact; 

631 
gear^.nImpactSounds:= 1; 

632 
gear^.AdvBounce:= 1; 

633 
gear^.Radius:= 5; 

634 
gear^.Tag:= random(8); 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

635 
if gear^.Timer = 0 then gear^.Timer:= 5000; 
6581  636 
gear^.Elasticity:= _0_7; 
637 
gear^.Friction:= _0_995; 

638 
gear^.Density:= _1_5; 

639 
end; 

640 
gtBallgun: begin 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

641 
if gear^.Timer = 0 then gear^.Timer:= 5001; 
6581  642 
end; 
643 
gtRCPlane: begin 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

644 
if gear^.Timer = 0 then gear^.Timer:= 15000; 
6581  645 
gear^.Health:= 3; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

646 
gear^.Radius:= 8; 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

647 
gear^.Tint:= gear^.Hedgehog^.Team^.Clan^.Color shl 8 or $FF 
6581  648 
end; 
649 
gtJetpack: begin 

650 
gear^.Health:= 2000; 

8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8795
diff
changeset

651 
gear^.Damage:= 100; 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

652 
gear^.State:= Gear^.State or gstSubmersible 
6581  653 
end; 
654 
gtMolotov: begin 

9825  655 
gear^.AdvBounce:= 1; 
6581  656 
gear^.Radius:= 6; 
12664
943b258d5443
Fix molotov cocktails bouncing off vertically off rubber
Wuzzy <almikes@aol.com>
parents:
12641
diff
changeset

657 
gear^.Elasticity:= _0_8; 
943b258d5443
Fix molotov cocktails bouncing off vertically off rubber
Wuzzy <almikes@aol.com>
parents:
12641
diff
changeset

658 
gear^.Friction:= _0_8; 
9825  659 
gear^.Density:= _2 
6581  660 
end; 
661 
gtBirdy: begin 

662 
gear^.Radius:= 16; // todo: check 

663 
gear^.Health := 2000; 

9825  664 
gear^.FlightTime := 2 
6581  665 
end; 
666 
gtEgg: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

667 
gear^.AdvBounce:= 1; 
6581  668 
gear^.Radius:= 4; 
669 
gear^.Elasticity:= _0_6; 

670 
gear^.Friction:= _0_96; 

671 
gear^.Density:= _1; 

672 
if gear^.Timer = 0 then 

673 
gear^.Timer:= 3000 

674 
end; 

675 
gtPortal: begin 

676 
gear^.ImpactSound:= sndMelonImpact; 

677 
gear^.nImpactSounds:= 1; 

678 
gear^.Radius:= 17; 

679 
// set color 

680 
gear^.Tag:= 2 * gear^.Timer; 

681 
gear^.Timer:= 15000; 

682 
gear^.RenderTimer:= false; 

683 
gear^.Health:= 100; 

13610
f1b6070a6e14
Fix projectiles reacing incorrectly with land just behind the wrap world edge
Wuzzy <Wuzzy2@mail.ru>
parents:
13605
diff
changeset

684 
gear^.Sticky:= true; 
6581  685 
end; 
686 
gtPiano: begin 

687 
gear^.Radius:= 32; 

688 
gear^.Density:= _50; 

689 
end; 

690 
gtSineGunShot: begin 

691 
gear^.Radius:= 5; 

692 
gear^.Health:= 6000; 

693 
end; 

694 
gtFlamethrower: begin 

695 
gear^.Tag:= 10; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

696 
if gear^.Timer = 0 then gear^.Timer:= 10; 
6581  697 
gear^.Health:= 500; 
698 
gear^.Damage:= 100; 

699 
end; 

700 
gtLandGun: begin 

701 
gear^.Tag:= 10; 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

702 
if gear^.Timer = 0 then gear^.Timer:= 10; 
6581  703 
gear^.Health:= 1000; 
704 
gear^.Damage:= 100; 

705 
end; 

706 
gtPoisonCloud: begin 

9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

707 
if gear^.Timer = 0 then gear^.Timer:= 5000; 
6581  708 
gear^.dY:= int2hwfloat(4 + longint(getRandom(8))) / 1000; 
10032
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

709 
gear^.Tint:= $C0C000C0 
6581  710 
end; 
711 
gtResurrector: begin 

712 
gear^.Radius := 100; 

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

713 
gear^.Tag := 0; 
db65298717da
This adds idle hog tinting. Active hog tinting still needed.
nemo
parents:
9998
diff
changeset

714 
gear^.Tint:= $F5DB35FF 
6581  715 
end; 
716 
gtWaterUp: begin 

717 
gear^.Tag := 47; 

718 
end; 

719 
gtNapalmBomb: begin 

9721
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

720 
gear^.Elasticity:= _0_8; 
1833dadcebf0
Initial pass at bounciness. To try it out, or lfBouncy on girder in uLandGraphics (search for the word graphically)
nemo
parents:
9479
diff
changeset

721 
gear^.Friction:= _0_8; 
9195
e653e96b0ec3
Many of the gears treat non0 timer as overridden. Added that check in more places so that lua could use this a tiny bit more consistently. Also preserve state for jetpack.
nemo
parents:
9080
diff
changeset

722 
if gear^.Timer = 0 then gear^.Timer:= 1000; 
6581  723 
gear^.Radius:= 5; 
724 
gear^.Density:= _1_5; 

725 
end; 

8774
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGunspecific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset

726 
gtIceGun: begin 
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGunspecific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset

727 
gear^.Health:= 1000; 
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGunspecific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset

728 
gear^.Radius:= 8; 
13572
a71e6856ffab
Fix freeze ray not working through wrap world edge; add DrawLineWrapped
Wuzzy <Wuzzy2@mail.ru>
parents:
13464
diff
changeset

729 
gear^.Density:= _0; 
13984  730 
gear^.Tag:= 0; // sound state: 0 = no sound, 1 = ice beam sound, 2 = idle sound 
8774
39754516eee6
Try to document TGear a bit, so people know what is commonly overridden, and what stuff is used for. Remove gtIceGunspecific values from TGear and abuse a couple of commonly abused members instead.
nemo
parents:
8751
diff
changeset

731 
end; 
13851
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13850
diff
changeset

732 
gtCreeper: begin 
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13850
diff
changeset

733 
// TODO: Finish creeper initialization implementation 
13605
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

734 
gear^.Radius:= cHHRadius; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

735 
gear^.Elasticity:= _0_35; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

736 
gear^.Friction:= _0_93; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

737 
gear^.Density:= _5; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

738 

422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

739 
gear^.AdvBounce:= 1; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

740 
gear^.ImpactSound:= sndAirMineImpact; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

741 
gear^.nImpactSounds:= 1; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

742 
gear^.Health:= 30; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

743 
gear^.Radius:= 8; 
13851
f01798038c2e
Rename amDuck and related symbols to amCreeper, gtCreeper, etc.
Wuzzy <Wuzzy2@mail.ru>
parents:
13850
diff
changeset

744 
gear^.Angle:= 175; // Radius at which it will start "seeking". $FFFFFFFF = unlimited. check is skipped. 
13605
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

745 
gear^.Power:= cMaxWindSpeed.QWordValue div 2; // hwFloat converted. 1/2 g default. defines the "seek" speed when a gear is in range. 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

746 
gear^.Pos:= cMaxWindSpeed.QWordValue * 3 div 2; // air friction. slows it down when not hitting stuff 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

747 
if gear^.Timer = 0 then 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

748 
gear^.Timer:= 5000; 
422d6062620a
hijack the duck for an attempted resurrection of the creeper. initial pass.
nemo
parents:
13572
diff
changeset

749 
gear^.WDTimer:= gear^.Timer 
12192  750 
end; 
13154
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

751 
gtMinigun: begin 
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

752 
// Timer. First, it's the timer before shooting. Then it will become the shooting timer and is set to Karma 
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

753 
if gear^.Timer = 0 then 
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

754 
gear^.Timer:= 601; 
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

755 
// minigun shooting time. 1 bullet is fired every 50ms 
44351ea57b71
Minigun: Move attack timer to Karma to make gear type more Luafriendly
Wuzzy <Wuzzy2@mail.ru>
parents:
13096
diff
changeset

756 
gear^.Karma:= 3451; 
12898  757 
end; 
758 
gtMinigunBullet: begin 

759 
gear^.Radius:= 1; 

760 
gear^.Health:= 2; 

761 
end; 

7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

762 
gtGenericFaller:begin 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

763 
gear^.AdvBounce:= 1; 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

764 
gear^.Radius:= 1; 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

765 
gear^.Elasticity:= _0_9; 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

766 
gear^.Friction:= _0_995; 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

767 
gear^.Density:= _1; 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

768 
end; 
6581  769 
end; 
770 

771 
InsertGearToList(gear); 

772 
AddGear:= gear; 

773 

774 
ScriptCall('onGearAdd', gear^.uid); 

775 
end; 

776 

10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

777 
procedure DeleteGear(Gear: PGear); 
6581  778 
var team: PTeam; 
779 
t,i: Longword; 

10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

780 
cakeData: PCakeData; 
11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

781 
iterator: PGear; 
6581  782 
begin 
783 

784 
ScriptCall('onGearDelete', gear^.uid); 

785 

786 
DeleteCI(Gear); 

14006
105793e575d6
make firepunch hit moving gears (airmines are not amused)
alfadur
parents:
13988
diff
changeset

787 
RemoveFromProximityCache(Gear); 
6581  788 

10634
35d059bd0932
Use FreeAndNil across the board. Even if we are immediately assigning after, probably avoids accidental mistakes. Also free neglected owner tex on shutdown, and delete hog gears using the normal deletion procedure if for any reason they still exist (EndGame call?).
nemo
parents:
10625
diff
changeset

789 
FreeAndNilTexture(Gear^.Tex); 
6581  790 

11043
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

791 
// remove potential links to this gear 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

792 
// currently relevant to: gears linked by hammer 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

793 
if (Gear^.Kind = gtHedgehog) or (Gear^.Kind = gtMine) or (Gear^.Kind = gtExplosives) then 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

794 
begin 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

795 
// check all gears for stuff to port through 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

796 
iterator := nil; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

797 
while true do 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

798 
begin 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

799 

79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

800 
// iterate through GearsList 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

801 
if iterator = nil then 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

802 
iterator := GearsList 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

803 
else 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

804 
iterator := iterator^.NextGear; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

805 

79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

806 
// end of list? 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

807 
if iterator = nil then 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

808 
break; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

809 

79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

810 
if iterator^.LinkedGear = Gear then 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

811 
iterator^.LinkedGear:= nil; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

812 
end; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

813 

79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

814 
end; 
79a77bef4c61
Hammer had been accessing dangling pointers under particular circumstances (e.g. when hitting a mine/barrel right when it exploded)
sheepluva
parents:
11036
diff
changeset

815 

6581  816 
// make sure that portals have their link removed before deletion 
817 
if (Gear^.Kind = gtPortal) then 

818 
begin 

7272
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset

819 
if (Gear^.LinkedGear <> nil) then 
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset

820 
if (Gear^.LinkedGear^.LinkedGear = Gear) then 
71df899c4163
Second part of the change. Make collision check use the new mask bit.
nemo
parents:
7176
diff
changeset

821 
Gear^.LinkedGear^.LinkedGear:= nil; 
6581  822 
end 
10874
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

823 
else if Gear^.Kind = gtCake then 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

824 
begin 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

825 
cakeData:= PCakeData(Gear^.Data); 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

826 
Dispose(cakeData); 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

827 
cakeData:= nil; 
059a6492176e
allow gear specific data (with gear type specific type). applied to cake
sheepluva
parents:
10848
diff
changeset

828 
end 
6581  829 
else if Gear^.Kind = gtHedgehog then 
830 
(* 

831 
This behaviour dates back to revision 4, and I accidentally encountered it with TARDIS. I don't think it must apply to any modern weapon, since if it was actually hit, the best the gear could do would be to destroy itself immediately, and you'd still end up with two graves. I believe it should be removed 

832 
if (CurAmmoGear <> nil) and (CurrentHedgehog^.Gear = Gear) then 

833 
begin 

834 
AttackBar:= 0; 

835 
Gear^.Message:= gmDestroy; 

836 
CurAmmoGear^.Message:= gmDestroy; 

837 
exit 

838 
end 

839 
else*) 

840 
begin 

10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

841 
if ((CurrentHedgehog = nil) or (Gear <> CurrentHedgehog^.Gear)) or (CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtKamikaze) then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

842 
Gear^.Hedgehog^.Team^.Clan^.Flawless:= false; 
10663
9bbb29d2bd68
remove a not that somehow magically appeared in a prior commit.
nemo
parents:
10646
diff
changeset

843 
if CheckCoordInWater(hwRound(Gear^.X), hwRound(Gear^.Y)) then 
6581  844 
begin 
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

845 
t:= max(Gear^.Damage, Gear^.Health); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

846 
Gear^.Damage:= t; 
13737
bbea77a8dff9
Fix damage not being displayed if hog drowns in water with 100% opacity (like in Compost theme)
Wuzzy <Wuzzy2@mail.ru>
parents:
13651
diff
changeset

847 
// Display hedgehog damage in water 
bbea77a8dff9
Fix damage not being displayed if hog drowns in water with 100% opacity (like in Compost theme)
Wuzzy <Wuzzy2@mail.ru>
parents:
13651
diff
changeset

848 
spawnHealthTagForHH(Gear, t); 
6581  849 
end; 
850 

10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

851 
team:= Gear^.Hedgehog^.Team; 
10636
aba9ae27ead0
meh. will persevere. DeleteGear can't call that much stuff...
nemo
parents:
10634
diff
changeset

852 
if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear = Gear) then 
6581  853 
begin 
854 
AttackBar:= 0; 

855 
FreeActionsList; // to avoid ThinkThread on drawned gear 

856 
if ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) <> 0) 

857 
and (CurrentHedgehog^.MultiShootAttacks > 0) then 

858 
OnUsedAmmo(CurrentHedgehog^); 

859 
end; 

860 

861 
Gear^.Hedgehog^.Gear:= nil; 

10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

862 

6581  863 
if Gear^.Hedgehog^.King then 
864 
begin 

14398
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

865 
Gear^.Hedgehog^.Team^.hasKing:= false; 
6581  866 
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do 
14398
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

867 
with team^.Clan^.Teams[i]^ do 
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

868 
for t:= 0 to cMaxHHIndex do 
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

869 
if Hedgehogs[t].Gear <> nil then 
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

870 
Hedgehogs[t].Gear^.Health:= 0 
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

871 
else if (Hedgehogs[t].GearHidden <> nil) then 
87562a68c41f
Fix some King Mode bugs causing minions not always being properly killed
Wuzzy <Wuzzy2@mail.ru>
parents:
14200
diff
changeset

872 
Hedgehogs[t].GearHidden^.Health:= 0 // hog is still hidden. if tardis should return though, lua, eh... 
6581  873 
end; 
10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

874 

14616
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

875 
// Update passive status of clan 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

876 
if (not Gear^.Hedgehog^.Team^.Clan^.Passive) then 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

877 
begin 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

878 
Gear^.Hedgehog^.Team^.Clan^.Passive:= true; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

879 
for i:= 0 to Pred(team^.Clan^.TeamsNumber) do 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

880 
begin 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

881 
with team^.Clan^.Teams[i]^ do 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

882 
if (not Passive) then 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

883 
for t:= 0 to cMaxHHIndex do 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

884 
if (Hedgehogs[t].Gear <> nil) or (Hedgehogs[t].GearHidden <> nil) then 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

885 
begin 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

886 
Gear^.Hedgehog^.Team^.Clan^.Passive:= false; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

887 
break; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

888 
end; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

889 
if (not Gear^.Hedgehog^.Team^.Clan^.Passive) then 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

890 
break; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

891 
end; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

892 
end; 
4638aa2ea8f2
Update clan passive status when team died / got resurrected
Wuzzy <Wuzzy2@mail.ru>
parents:
14398
diff
changeset

893 

10646
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

894 
// should be not CurrentHedgehog, but hedgehog of the last gear which caused damage to this hog 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

895 
// same stand for CheckHHDamage 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

896 
if (Gear^.LastDamage <> nil) and (CurrentHedgehog <> nil) then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

897 
uStats.HedgehogDamaged(Gear, Gear^.LastDamage, 0, true) 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

898 
else if CurrentHedgehog <> nil then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

899 
uStats.HedgehogDamaged(Gear, CurrentHedgehog, 0, true); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

900 

0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

901 
inc(KilledHHs); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

902 
RecountTeamHealth(team); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

903 
if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Effects[heResurrectable] <> 0) and 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

904 
//(Gear^.Hedgehog^.Effects[heResurrectable] = 0) then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

905 
(Gear^.Hedgehog^.Team^.Clan <> CurrentHedgehog^.Team^.Clan) then 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

906 
with CurrentHedgehog^ do 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

907 
begin 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

908 
inc(Team^.stats.AIKills); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

909 
FreeAndNilTexture(Team^.AIKillsTex); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

910 
Team^.AIKillsTex := RenderStringTex(ansistring(inttostr(Team^.stats.AIKills)), Team^.Clan^.Color, fnt16); 
0be6442946b1
put back the old uteams cleanup, leaks and all, to worry about postrelease since my attempt to use DeleteGear was running into the fact that that procedure does way more than just delete a gear. might need an explicit cleanup routine for both to call.
nemo
parents:
10645
diff
changeset

911 
end 
6581  912 
end; 
913 
with Gear^ do 

7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

914 
begin 
6581  915 
AddFileLog('Delete: #' + inttostr(uid) + ' (' + inttostr(hwRound(x)) + ',' + inttostr(hwRound(y)) + '), d(' + floattostr(dX) + ',' + floattostr(dY) + ') type = ' + EnumToStr(Kind)); 
7389
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

916 
AddRandomness(X.round xor X.frac xor dX.round xor dX.frac xor Y.round xor Y.frac xor dY.round xor dY.frac) 
15c3fb4882df
Sorry about the slight delay in pickup. You can blame a few lame cheaters. This is to make their cheating a bit harder.
nemo
parents:
7366
diff
changeset

917 
end; 
6581  918 
if CurAmmoGear = Gear then 
919 
CurAmmoGear:= nil; 

920 
if FollowGear = Gear then 

921 
FollowGear:= nil; 

922 
if lastGearByUID = Gear then 

923 
lastGearByUID := nil; 

10638  924 
if (Gear^.Hedgehog = nil) or (Gear^.Hedgehog^.GearHidden <> Gear) then // hidden hedgehogs shouldn't be in the list 
10639  925 
RemoveGearFromList(Gear) 
926 
else Gear^.Hedgehog^.GearHidden:= nil; 

10638  927 

6581  928 
Dispose(Gear) 
929 
end; 

930 

931 
end. 