author  sheepluva 
Tue, 26 May 2015 23:29:53 +0200  
changeset 10970  7341e0c3f966 
parent 10942  5d7dd938dedc 
child 11046  47a8c19ecb60 
permissions  rwrr 
6581  1 
(* 
2 
* Hedgewars, a free turn based strategy game 

9998  3 
* Copyright (c) 20042014 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:
10105
diff
changeset

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

19 
{$INCLUDE "options.inc"} 

20 

21 
unit uGearsHedgehog; 

22 
interface 

10015  23 
uses uTypes, uGearsHandlersMess; 
6581  24 

25 
procedure doStepHedgehog(Gear: PGear); 

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

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

27 
procedure HedgehogStep(Gear: PGear); 
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

28 
procedure doStepHedgehogMoving(Gear: PGear); 
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

29 
procedure HedgehogChAngle(HHGear: PGear); 
6581  30 
procedure PickUp(HH, Gear: PGear); 
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:
7375
diff
changeset

31 
procedure AddPickup(HH: THedgehog; ammo: TAmmoType; cnt, X, Y: LongWord); 
8574  32 
procedure CheckIce(Gear: PGear); inline; 
6581  33 

34 
implementation 

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

35 
uses uConsts, uVariables, uFloat, uAmmos, uSound, uCaptions, 
9285  36 
uCommands, uLocale, uUtils, uStats, uIO, uScript, 
37 
uGearsList, uCollisions, uRandom, uStore, uTeams, 

9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

38 
uGearsUtils, uVisualGearsList, uChat; 
6581  39 

7028  40 
var GHStepTicks: LongWord = 0; 
41 

9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

42 
procedure AFKSkip; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

43 
var 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

44 
t: byte; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

45 
begin 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

46 
t:= 0; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

47 
while (TeamsArray[t] <> CurrentTeam) do inc(t); 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

48 

1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

49 
SendHogSpeech(#1 + char(t) + 'AFK'); 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

50 

1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

51 
ParseCommand('/skip', true) 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

52 
end; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

53 

6581  54 
// Shouldn't more of this ammo switching stuff be moved to uAmmos ? 
55 
function ChangeAmmo(HHGear: PGear): boolean; 

56 
var slot, i: Longword; 

57 
ammoidx: LongInt; 

7754  58 
prevAmmo: TAmmoType; 
6581  59 
begin 
60 
ChangeAmmo:= false; 

61 
slot:= HHGear^.MsgParam; 

62 

63 
with HHGear^.Hedgehog^ do 

64 
begin 

65 
HHGear^.Message:= HHGear^.Message and (not gmSlot); 

7754  66 
prevAmmo:= CurAmmoType; 
6581  67 
ammoidx:= 0; 
9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

68 
if (((HHGear^.State and (gstAttacking or gstAttacked)) <> 0) and (GameFlags and gfInfAttack = 0)) 
6581  69 
or ((HHGear^.State and gstHHDriven) = 0) then 
70 
exit; 

71 
ChangeAmmo:= true; 

72 

73 
while (ammoidx < cMaxSlotAmmoIndex) and (Ammo^[slot, ammoidx].AmmoType <> CurAmmoType) do 

74 
inc(ammoidx); 

75 

8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset

76 
if (MultiShootAttacks > 0) then 
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset

77 
begin 
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset

78 
if (CurAmmoType = amSniperRifle) and ((GameFlags and gfArtillery) = 0) then 
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset

79 
cArtillery := false; 
8631
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

80 
if (Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NoRoundEnd) = 0 then 
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

81 
begin 
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

82 
MultiShootAttacks:= Ammoz[CurAmmoType].Ammo.NumPerTurn; 
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

83 
AfterAttack 
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

84 
end 
796ed875aa95
Call act as if attack ended on last shot if switching while in mid multishoot. Thanks to AI for discovering this.
nemo
parents:
8616
diff
changeset

85 
else OnUsedAmmo(HHGear^.Hedgehog^) 
8553
a8e1cff496d8
Allow switching away from any weapon when during multishoot.
nemo
parents:
8494
diff
changeset

86 
end; 
6581  87 

88 
MultiShootAttacks:= 0; 

89 
HHGear^.Message:= HHGear^.Message and (not (gmLJump or gmHJump)); 

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

90 

6581  91 
if Ammoz[CurAmmoType].Slot = slot then 
92 
begin 

93 
i:= 0; 

94 
repeat 

95 
inc(ammoidx); 

96 
if (ammoidx > cMaxSlotAmmoIndex) then 

97 
begin 

98 
inc(i); 

99 
CurAmmoType:= amNothing; 

100 
ammoidx:= 1; 

101 
//TryDo(i < 2, 'Engine bug: no ammo in current slot', true) 

102 
end; 

103 
until (i = 1) or ((Ammo^[slot, ammoidx].Count > 0) 

104 
and (Team^.Clan^.TurnNumber > Ammoz[Ammo^[slot, ammoidx].AmmoType].SkipTurns)) 

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

105 

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

106 
end 
6581  107 
else 
108 
begin 

109 
i:= 0; 

110 
// check whether there is ammo in slot 

111 
while (i <= cMaxSlotAmmoIndex) and ((Ammo^[slot, i].Count = 0) 

112 
or (Team^.Clan^.TurnNumber <= Ammoz[Ammo^[slot, i].AmmoType].SkipTurns)) 

113 
do inc(i); 

114 

115 
if i <= cMaxSlotAmmoIndex then 

116 
ammoidx:= i 

117 
else ammoidx:= 1 

118 
end; 

119 
if ammoidx >= 0 then 

120 
CurAmmoType:= Ammo^[slot, ammoidx].AmmoType; 

8051
f26422ef0333
oftrequested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset

121 
// Try again in the next slot 
10015  122 
if (CurAmmoType = prevAmmo) and (slot < cMaxSlotIndex) then 
8051
f26422ef0333
oftrequested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset

123 
begin 
9664
1e528c58e41d
ok. this should avoid calling switch inappropriately. also, add skip to trophyrace and add the perteam achievement reporting.
nemo
parents:
9579
diff
changeset

124 
inc(slot); 
8051
f26422ef0333
oftrequested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset

125 
HHGear^.MsgParam:= slot; 
f26422ef0333
oftrequested, should make the shoppa guys happy, probably, but, knowing them, I'm sure someone will complain
nemo
parents:
8030
diff
changeset

126 
ChangeAmmo(HHGear) 
7754  127 
end 
6581  128 
end 
129 
end; 

130 

131 
procedure HHSetWeapon(HHGear: PGear); 

132 
var t: LongInt; 

133 
weap: TAmmoType; 

134 
Hedgehog: PHedgehog; 

135 
s: boolean; 

9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

136 
prevState, newState: LongWord; 
6581  137 
begin 
138 
s:= false; 

139 

140 
weap:= TAmmoType(HHGear^.MsgParam); 

141 
Hedgehog:= HHGear^.Hedgehog; 

142 

143 
if Hedgehog^.Team^.Clan^.TurnNumber <= Ammoz[weap].SkipTurns then 

144 
exit; // weapon is not activated yet 

145 

146 
HHGear^.MsgParam:= Ammoz[weap].Slot; 

147 

148 
t:= cMaxSlotAmmoIndex; 

149 

150 
HHGear^.Message:= HHGear^.Message and (not gmWeapon); 

151 

9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

152 
prevState:= HHGear^.State; 
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

153 
newState:= prevState; 
6581  154 
with Hedgehog^ do 
155 
while (CurAmmoType <> weap) and (t >= 0) do 

156 
begin 

157 
s:= ChangeAmmo(HHGear); 

9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

158 
if HHGear^.State <> prevState then // so we can keep gstAttacked out of consideration when looping 
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

159 
newState:= HHGear^.State; 
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

160 
HHGear^.State:= prevState; 
6581  161 
dec(t) 
162 
end; 

9732
a13afa6c5d21
don't abort changeammo on attacking/attacked in infattack mode, keep scrolling through slot after setweap even if a multishoot was aborted triggering gstattacked, to ensure proper ammo gets set for next turn
nemo
parents:
9731
diff
changeset

163 
HHGear^.State:= newState; 
6581  164 

165 
if s then 

166 
ApplyAmmoChanges(HHGear^.Hedgehog^) 

167 
end; 

168 

169 
procedure HHSetTimer(Gear: PGear); 

170 
var CurWeapon: PAmmo; 

171 
color: LongWord; 

172 
begin 

173 
Gear^.Message:= Gear^.Message and (not gmTimer); 

6924  174 
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); 
6581  175 
with Gear^.Hedgehog^ do 
176 
if ((Gear^.Message and gmPrecise) <> 0) and ((CurWeapon^.Propz and ammoprop_SetBounce) <> 0) then 

177 
begin 

178 
color:= Gear^.Hedgehog^.Team^.Clan^.Color; 

179 
case Gear^.MsgParam of 

180 
1: begin 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

181 
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce1]), color, capgrpAmmostate); 
6581  182 
CurWeapon^.Bounciness:= 350; 
183 
end; 

184 
2: begin 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

185 
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce2]), color, capgrpAmmostate); 
6581  186 
CurWeapon^.Bounciness:= 700; 
187 
end; 

188 
3: begin 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

189 
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce3]), color, capgrpAmmostate); 
6581  190 
CurWeapon^.Bounciness:= 1000; 
191 
end; 

192 
4: begin 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

193 
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce4]), color, capgrpAmmostate); 
6581  194 
CurWeapon^.Bounciness:= 2000; 
195 
end; 

196 
5: begin 

10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

197 
AddCaption(FormatA(trmsg[sidBounce], trmsg[sidBounce5]), color, capgrpAmmostate); 
6581  198 
CurWeapon^.Bounciness:= 4000; 
199 
end 

200 
end 

201 
end 

202 
else if (CurWeapon^.Propz and ammoprop_Timerable) <> 0 then 

203 
begin 

204 
CurWeapon^.Timer:= 1000 * Gear^.MsgParam; 

205 
with CurrentTeam^ do 

206 
ApplyAmmoChanges(Hedgehogs[CurrHedgehog]); 

207 
end; 

208 
end; 

209 

210 

211 
procedure Attack(Gear: PGear); 

212 
var xx, yy, newDx, newDy, lx, ly: hwFloat; 

213 
speech: PVisualGear; 

214 
newGear: PGear; 

215 
CurWeapon: PAmmo; 

10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset

216 
usedAmmoType: TAmmoType; 
6581  217 
altUse: boolean; 
218 
elastic: hwFloat; 

219 
begin 

220 
newGear:= nil; 

221 
bShowFinger:= false; 

6924  222 
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); 
6581  223 
with Gear^, 
224 
Gear^.Hedgehog^ do 

225 
begin 

10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset

226 
usedAmmoType:= CurAmmoType; 
10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset

227 
if ((State and gstHHDriven) <> 0) and ((State and (gstAttacked or gstChooseTarget)) = 0) and (((State and gstMoving) = 0) 
6581  228 
or (Power > 0) 
229 
or (CurAmmoType = amTeleport) 

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

230 
or 
6581  231 
// Allow attacks while moving on ammo with AltAttack 
232 
((CurAmmoGear <> nil) and ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0)) 

233 
or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AttackInMove) <> 0)) 

234 
and ((TargetPoint.X <> NoPointX) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NeedTarget) = 0)) then 

235 
begin 

236 
State:= State or gstAttacking; 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

237 
if (Power = cMaxPower) or ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) = 0) then 
6581  238 
Message:= Message and (not gmAttack) 
239 
else 

240 
begin 

241 
if Power = 0 then 

242 
begin 

243 
AttackBar:= CurrentTeam^.AttackBar; 

244 
PlaySound(sndThrowPowerUp) 

245 
end; 

246 
inc(Power) 

247 
end; 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

248 
if ((Message and gmAttack) <> 0) then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

249 
exit; 
6581  250 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

251 
if (Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) <> 0 then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

252 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

253 
StopSound(sndThrowPowerUp); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

254 
PlaySound(sndThrowRelease); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

255 
end; 
6581  256 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

257 
xx:= SignAs(AngleSin(Angle), dX); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

258 
yy:= AngleCos(Angle); 
6581  259 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

260 
lx:= X + int2hwfloat(round(GetLaunchX(CurAmmoType, hwSign(dX), Angle))); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

261 
ly:= Y + int2hwfloat(round(GetLaunchY(CurAmmoType, Angle))); 
6581  262 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

263 
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

264 
xx:=  xx; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

265 
if Ammoz[CurAmmoType].Ammo.AttackVoice <> sndNone then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

266 
AddVoice(Ammoz[CurAmmoType].Ammo.AttackVoice, CurrentTeam^.voicepack); 
6581  267 

268 
// Initiating alt attack 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

269 
if (CurAmmoGear <> nil) 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

270 
and ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

271 
and ((Gear^.Message and gmLJump) <> 0) 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

272 
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

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

274 
if (CurAmmoGear^.AmmoType = amJetpack) and (Gear^.Message and gmPrecise <> 0) then 
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset

275 
begin 
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset

276 
newDx:= xx*cMaxPower/cPowerDivisor; 
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset

277 
newDy:= yy*cMaxPower/cPowerDivisor 
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset

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

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

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

281 
newDx:= dX; 
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset

282 
newDy:= dY 
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset

283 
end; 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

284 
altUse:= true 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

285 
end 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

286 
else 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

287 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

288 
newDx:= xx*Power/cPowerDivisor; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

289 
newDy:= yy*Power/cPowerDivisor; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

290 
altUse:= false 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

291 
end; 
6581  292 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

293 
case CurAmmoType of 
6581  294 
amGrenade: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGrenade, 0, newDx, newDy, CurWeapon^.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:
10714
diff
changeset

295 
amAirMine: newGear:= AddGear(hwRound(lx), hwRound(ly), gtAirMine, 0, newDx, newDy, 0); 
6581  296 
amMolotov: newGear:= AddGear(hwRound(lx), hwRound(ly), gtMolotov, 0, newDx, newDy, 0); 
297 
amClusterBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtClusterBomb, 0, newDx, newDy, CurWeapon^.Timer); 

298 
amGasBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtGasBomb, 0, newDx, newDy, CurWeapon^.Timer); 

299 
amBazooka: newGear:= AddGear(hwRound(lx), hwRound(ly), gtShell, 0, newDx, newDy, 0); 

300 
amSnowball: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSnowball, 0, newDx, newDy, 0); 

301 
amBee: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBee, 0, newDx, newDy, 0); 

302 
amShotgun: begin 

303 
PlaySound(sndShotgunReload); 

304 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtShotgunShot, 0, xx * _0_5, yy * _0_5, 0); 

305 
end; 

306 
amPickHammer: newGear:= AddGear(hwRound(lx), hwRound(ly) + cHHRadius, gtPickHammer, 0, _0, _0, 0); 

307 
amSkip: ParseCommand('/skip', true); 

308 
amRope: newGear:= AddGear(hwRound(lx), hwRound(ly), gtRope, 0, xx, yy, 0); 

10942
5d7dd938dedc
This probably fixes bug #839  mine time was hardcoded to 3000 in Attack, instead of using the "0 as undefined" input that other places were using. When re653e96b0ec3 started paying attention to the input parameter, this previously ignored value became a problem.
nemo
parents:
10895
diff
changeset

309 
amMine: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtMine, gstWait, SignAs(_0_02, dX), _0, 0); 
6581  310 
amSMine: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSMine, 0, xx*Power/cPowerDivisor, yy*Power/cPowerDivisor, 0); 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

311 
amKnife: begin 
7754  312 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtKnife, 0, xx*Power/cPowerDivisor, yy*Power/cPowerDivisor, 0); 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

313 
newGear^.State:= newGear^.State or gstMoving; 
8494
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset

314 
newGear^.Radius:= 4 // temporarily shrink so it doesn't instantly embed in the ground 
7754  315 
end; 
6581  316 
amDEagle: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtDEagleShot, 0, xx * _0_5, yy * _0_5, 0); 
317 
amSineGun: newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSineGunShot, 0, xx * _0_5, yy * _0_5, 0); 

318 
amPortalGun: begin 

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

319 
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtPortal, 0, xx * _0_6, yy * _0_6, 
6581  320 
// set selected color 
321 
CurWeapon^.Pos); 

322 
end; 

323 
amSniperRifle: begin 

324 
PlaySound(sndSniperReload); 

325 
newGear:= AddGear(hwRound(lx + xx * cHHRadius), hwRound(ly + yy * cHHRadius), gtSniperRifleShot, 0, xx * _0_5, yy * _0_5, 0); 

326 
end; 

327 
amDynamite: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtDynamite, 0, SignAs(_0_03, dX), _0, 5000); 

328 
amFirePunch: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtFirePunch, 0, xx, _0, 0); 

329 
amWhip: begin 

330 
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtWhip, 0, SignAs(_1, dX),  _0_8, 0); 

331 
PlaySound(sndWhipCrack) 

332 
end; 

333 
amHammer: begin 

334 
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtHammer, 0, SignAs(_1, dX),  _0_8, 0); 

335 
PlaySound(sndWhack) 

336 
end; 

337 
amBaseballBat: begin 

338 
newGear:= AddGear(hwRound(lx) + hwSign(dX) * 10, hwRound(ly), gtShover, gsttmpFlag, xx * _0_5, yy * _0_5, 0); 

339 
PlaySound(sndBaseballBat) // TODO: Only play if something is hit? 

340 
end; 

341 
amParachute: begin 

342 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtParachute, 0, _0, _0, 0); 

343 
PlaySound(sndParachute) 

344 
end; 

345 
// we save CurWeapon^.Pos (in this case: cursor direction) by using it as (otherwise irrelevant) X value of the new gear. 

346 
amAirAttack: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 0, _0, _0, 0); 

347 
amMineStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 1, _0, _0, 0); 

348 
amDrillStrike: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 3, _0, _0, CurWeapon^.Timer); 

349 
amNapalm: newGear:= AddGear(CurWeapon^.Pos, 0, gtAirAttack, 2, _0, _0, 0); 

350 
amBlowTorch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtBlowTorch, 0, SignAs(_0_5, dX), _0, 0); 

351 
amGirder: newGear:= AddGear(0, 0, gtGirder, CurWeapon^.Pos, _0, _0, 0); 

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

352 
amRubber: begin 
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset

353 
newGear:= AddGear(0, 0, gtGirder, CurWeapon^.Pos, _0, _0, 0); 
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset

354 
newGear^.AmmoType:= amRubber 
08799c901a42
Add rubber utility. Graphics are still incomplete. Also flag snow/ice in theme config.
nemo
parents:
9732
diff
changeset

355 
end; 
6581  356 
amTeleport: newGear:= AddGear(CurWeapon^.Pos, 0, gtTeleport, 0, _0, _0, 0); 
357 
amSwitch: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSwitcher, 0, _0, _0, 0); 

358 
amMortar: begin 

359 
playSound(sndMortar); 

360 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtMortar, 0, xx*cMaxPower/cPowerDivisor, yy*cMaxPower/cPowerDivisor, 0); 

361 
end; 

362 
amRCPlane: begin 

363 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtRCPlane, 0, xx * cMaxPower / cPowerDivisor / 4, yy * cMaxPower / cPowerDivisor / 4, 0); 

7053  364 
newGear^.SoundChannel:= LoopSound(sndRCPlane) 
6581  365 
end; 
366 
amKamikaze: newGear:= AddGear(hwRound(lx), hwRound(ly), gtKamikaze, 0, xx * _0_5, yy * _0_5, 0); 

7832  367 
amCake: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 3, hwRound(ly), gtCake, 0, SignAs(cLittle, xx), _0, 0); 
6581  368 
amSeduction: newGear:= AddGear(hwRound(lx), hwRound(ly), gtSeduction, 0, _0, _0, 0); 
369 
amWatermelon: newGear:= AddGear(hwRound(lx), hwRound(ly), gtWatermelon, 0, newDx, newDy, CurWeapon^.Timer); 

370 
amHellishBomb: newGear:= AddGear(hwRound(lx), hwRound(ly), gtHellishBomb, 0, newDx, newDy, 0); 

371 
amDrill: newGear:= AddGear(hwRound(lx), hwRound(ly), gtDrill, 0, newDx, newDy, 0); 

372 
amBallgun: newGear:= AddGear(hwRound(X), hwRound(Y), gtBallgun, 0, xx * _0_5, yy * _0_5, 0); 

373 
amJetpack: newGear:= AddGear(hwRound(lx), hwRound(ly), gtJetpack, 0, _0, _0, 0); 

374 
amBirdy: begin 

375 
PlaySound(sndWhistle); 

376 
newGear:= AddGear(hwRound(lx), hwRound(ly)  32, gtBirdy, 0, _0, _0, 0); 

377 
end; 

378 
amLowGravity: begin 

379 
PlaySound(sndLowGravity); 

380 
cGravity:= cMaxWindSpeed; 

381 
cGravityf:= 0.00025 

382 
end; 

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

383 
amExtraDamage: begin 
6581  384 
PlaySound(sndHellishImpact4); 
385 
cDamageModifier:= _1_5 

386 
end; 

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

387 
amInvulnerable: Effects[heInvulnerable]:= 1; 
6581  388 
amExtraTime: begin 
389 
PlaySound(sndSwitchHog); 

390 
TurnTimeLeft:= TurnTimeLeft + 30000 

391 
end; 

392 
amLaserSight: cLaserSighting:= true; 

393 
amVampiric: begin 

7053  394 
PlaySoundV(sndOw1, Team^.voicepack); 
6581  395 
cVampiric:= true; 
396 
end; 

397 
amPiano: begin 

398 
// Tuck the hedgehog away until the piano attack is completed 

399 
Unplaced:= true; 

400 
X:= _0; 

401 
Y:= _0; 

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

402 
newGear:= AddGear(TargetPoint.X, 1024, gtPiano, 0, _0, _0, 0); 
6581  403 
PauseMusic 
404 
end; 

405 
amFlamethrower: newGear:= AddGear(hwRound(X), hwRound(Y), gtFlamethrower, 0, xx * _0_5, yy * _0_5, 0); 

406 
amLandGun: newGear:= AddGear(hwRound(X), hwRound(Y), gtLandGun, 0, xx * _0_5, yy * _0_5, 0); 

407 
amResurrector: begin 

408 
newGear:= AddGear(hwRound(lx), hwRound(ly), gtResurrector, 0, _0, _0, 0); 

409 
newGear^.SoundChannel := LoopSound(sndResurrector); 

410 
end; 

8161  411 
//amStructure: newGear:= AddGear(hwRound(lx) + hwSign(dX) * 7, hwRound(ly), gtStructure, gstWait, SignAs(_0_02, dX), _0, 3000); 
9675
295636ec930a
cleanup of timer accidentally exposed prob w/ timebox
nemo
parents:
9672
diff
changeset

412 
amTardis: newGear:= AddGear(hwRound(X), hwRound(Y), gtTardis, 0, _0, _0, 0); 
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:
8753
diff
changeset

413 
amIceGun: newGear:= AddGear(hwRound(X), hwRound(Y), gtIceGun, 0, _0, _0, 0); 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

414 
end; 
10015  415 
if altUse and (newGear <> nil) and 
8987
47cf32305d99
some saucer thing for firing weps underwater and aiming and such. bit drunk and sleepy so testing I guess
nemo
parents:
8947
diff
changeset

416 
((CurAmmoGear = nil) or (CurAmmoGear^.AmmoType <> amJetpack) or (Gear^.Message and gmPrecise = 0)) then 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

417 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

418 
newGear^.dX:= newDx / newGear^.Density; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

419 
newGear^.dY:= newDY / newGear^.Density 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

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

421 
if (CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack) and 
10354  422 
(Gear^.Message and gmPrecise <> 0) and CheckCoordInWater(hwRound(X), hwRound(Y)) then 
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset

423 
newGear^.State:= newGear^.State or gstSubmersible; 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

424 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

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

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

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

428 
amBazooka, amSnowball, 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

429 
amBee, amSMine, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

430 
amMortar, amWatermelon, 
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:
10714
diff
changeset

431 
amHellishBomb, amDrill, 
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:
10714
diff
changeset

432 
amAirMine: FollowGear:= newGear; 
6581  433 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

434 
amShotgun, amPickHammer, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

435 
amRope, amDEagle, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

436 
amSineGun, amSniperRifle, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

437 
amFirePunch, amWhip, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

438 
amHammer, amBaseballBat, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

439 
amParachute, amBlowTorch, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

440 
amGirder, amTeleport, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

441 
amSwitch, amRCPlane, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

442 
amKamikaze, amCake, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

443 
amSeduction, amBallgun, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

444 
amJetpack, amBirdy, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

445 
amFlamethrower, amLandGun, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

446 
amResurrector, //amStructure, 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

447 
amTardis, amPiano, 
9776  448 
amIceGun, amRubber: CurAmmoGear:= newGear; 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

449 
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:
10714
diff
changeset

450 
if CurAmmoType = amCake then FollowGear:= newGear; 
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:
10714
diff
changeset

451 
if CurAmmoType = amAirMine then newGear^.Hedgehog:= nil; 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

452 

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

453 
if ((CurAmmoType = amMine) or (CurAmmoType = amSMine) or (CurAmmoType = amAirMine)) and (GameFlags and gfInfAttack <> 0) then 
6581  454 
newGear^.FlightTime:= GameTicks + 1000 
455 
else if CurAmmoType = amDrill then 

456 
newGear^.FlightTime:= GameTicks + 250; 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

457 
if Ammoz[CurAmmoType].Ammo.Propz and ammoprop_NeedTarget <> 0 then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

458 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

459 
newGear^.Target.X:= TargetPoint.X; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

460 
newGear^.Target.Y:= TargetPoint.Y 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

461 
end; 
8744  462 
if (newGear <> nil) and (newGear^.CollisionMask and lfCurrentHog <> 0) then newGear^.CollisionMask:= newGear^.CollisionMask and (not lfCurrentHog); 
6581  463 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

464 
// Clear FollowGear if using on a rope/parachute/saucer etc so focus stays with the hog's movement 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

465 
if altUse then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

466 
FollowGear:= nil; 
6581  467 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

468 
if (newGear <> nil) and ((Ammoz[newGear^.AmmoType].Ammo.Propz and ammoprop_SetBounce) <> 0) then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

469 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

470 
elastic:= int2hwfloat(CurWeapon^.Bounciness) / _1000; 
6581  471 

472 
if elastic < _1 then 

473 
newGear^.Elasticity:= newGear^.Elasticity * elastic 

474 
else if elastic > _1 then 

475 
newGear^.Elasticity:= _1  ((_1newGear^.Elasticity) / elastic); 

8330  476 
(* Experimented with friction modifier. Didn't seem helpful 
6581  477 
fric:= int2hwfloat(CurWeapon^.Bounciness) / _250; 
478 
if fric < _1 then newGear^.Friction:= newGear^.Friction * fric 

479 
else if fric > _1 then newGear^.Friction:= _1  ((_1newGear^.Friction) / fric)*) 

480 
end; 

481 

482 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

483 
uStats.AmmoUsed(CurAmmoType); 
6581  484 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

485 
if not (SpeechText = '') then 
6581  486 
begin 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

487 
speech:= AddVisualGear(0, 0, vgtSpeechBubble); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

488 
if speech <> nil then 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

489 
begin 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

490 
speech^.Text:= SpeechText; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

491 
speech^.Hedgehog:= Gear^.Hedgehog; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

492 
speech^.FrameTicks:= SpeechType; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

493 
end; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

494 
SpeechText:= '' 
6581  495 
end; 
496 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

497 
Power:= 0; 
8833  498 
if (CurAmmoGear <> nil) and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) = 0){check for dropping ammo from rope} then 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

499 
begin 
8833  500 
if CurAmmoType in [amRope,amResurrector] then 
501 
Message:= Message or gmAttack; 

8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

502 
CurAmmoGear^.Message:= Message 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

503 
end 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

504 
else 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

505 
begin 
8833  506 
if (not CurrentTeam^.ExtDriven) and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_Power) <> 0) then 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

507 
SendIPC(_S'a'); 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

508 
AfterAttack; 
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

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

511 
else 
8492
67d2ad3b3ce9
Allow moving after firing cleaver. This changes multishoot behaviour quite a bit. Needs a lot of testing.
nemo
parents:
8414
diff
changeset

512 
Message:= Message and (not gmAttack); 
10669
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset

513 

10970
7341e0c3f966
LuaAPI: fix OnHogAttack the incorrect AmmoType (amNothing) under certain conditions. Thanks for CheezeMonkey for reporting this
sheepluva
parents:
10942
diff
changeset

514 
ScriptCall('onHogAttack', ord(usedAmmoType)); 
10669
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset

515 
end; // of with Gear^, Gear^.Hedgehog^ do 
4c78eafe76ac
Issue 755: Lua API: Add ammo type parameter for onHogAttack
sheepluva
parents:
10579
diff
changeset

516 

6581  517 
TargetPoint.X := NoPointX; 
518 
end; 

519 

520 
procedure AfterAttack; 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

521 
var s: ansistring; 
6581  522 
a: TAmmoType; 
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset

523 
HHGear: PGear; 
6581  524 
begin 
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset

525 
with CurrentHedgehog^ do 
6581  526 
begin 
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset

527 
HHGear:= Gear; 
6581  528 
a:= CurAmmoType; 
7459
8511a3f899d3
Allow AfterAttack to proceed even if the Hedgehog is dead. They could be resurrected after all.
nemo
parents:
7426
diff
changeset

529 
if HHGear <> nil then HHGear^.State:= HHGear^.State and (not gstAttacking); 
6581  530 
if (Ammoz[a].Ammo.Propz and ammoprop_Effect) = 0 then 
531 
begin 

532 
Inc(MultiShootAttacks); 

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

533 

6581  534 
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) then 
535 
begin 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

536 
s:= ansistring(inttostr(Ammoz[a].Ammo.NumPerTurn  MultiShootAttacks + 1)); 
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

537 
AddCaption(formatA(trmsg[sidRemaining], s), cWhiteColor, capgrpAmmostate); 
6581  538 
end; 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

539 

6581  540 
if (Ammoz[a].Ammo.NumPerTurn >= MultiShootAttacks) 
541 
or ((GameFlags and gfMultiWeapon) <> 0) then 

542 
begin 

543 
isInMultiShoot:= true 

544 
end 

545 
else 

546 
begin 

547 
OnUsedAmmo(CurrentHedgehog^); 

548 
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (((GameFlags and gfInfAttack) = 0) or PlacingHogs) then 

549 
begin 

550 
if TagTurnTimeLeft = 0 then 

551 
TagTurnTimeLeft:= TurnTimeLeft; 

10354  552 
if (CurAmmoGear <> nil) and (CurAmmoGear^.State and gstSubmersible <> 0) and CheckCoordInWater(hwRound(CurAmmoGear^.X), hwRound(CurAmmoGear^.Y)) then 
8992
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset

553 
TurnTimeLeft:=(Ammoz[a].TimeAfterTurn * cGetAwayTime) div 25 
5b0be812dcdb
Rename submersible state, increase getaway time for attack underwater, slow down gear dx/dy underwater to simulate water resistance
nemo
parents:
8987
diff
changeset

554 
else TurnTimeLeft:=(Ammoz[a].TimeAfterTurn * cGetAwayTime) div 100; 
6581  555 
end; 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

556 
if ((Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) = 0) and (HHGear <> nil) then 
7462  557 
HHGear^.State:= HHGear^.State or gstAttacked; 
6581  558 
if (Ammoz[a].Ammo.Propz and ammoprop_NoRoundEnd) <> 0 then 
559 
ApplyAmmoChanges(CurrentHedgehog^) 

560 
end; 

561 
end 

562 
else 

563 
begin 

564 
OnUsedAmmo(CurrentHedgehog^); 

565 
ApplyAmmoChanges(CurrentHedgehog^); 

566 
end; 

567 
AttackBar:= 0 

568 
end 

569 
end; 

570 

571 
//////////////////////////////////////////////////////////////////////////////// 

572 
procedure doStepHedgehogDead(Gear: PGear); 

573 
const frametime = 200; 

574 
timertime = frametime * 6; 

575 
begin 

576 
if Gear^.Hedgehog^.Unplaced then 

577 
exit; 

578 
if Gear^.Timer > 1 then 

579 
begin 

580 
AllInactive:= false; 

581 
dec(Gear^.Timer); 

582 
if (Gear^.Timer mod frametime) = 0 then 

583 
inc(Gear^.Pos) 

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

584 
end 
6581  585 
else if Gear^.Timer = 1 then 
586 
begin 

9064  587 
Gear^.Hedgehog^.Effects[heFrozen]:= 0; 
6581  588 
Gear^.State:= Gear^.State or gstNoDamage; 
589 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, CurrentHedgehog, EXPLAutoSound); 

590 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtGrave, 0, _0, _0, 0)^.Hedgehog:= Gear^.Hedgehog; 

591 
DeleteGear(Gear); 

592 
SetAllToActive 

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

593 
end 
6581  594 
else // Gear^.Timer = 0 
595 
begin 

596 
AllInactive:= false; 

597 
Gear^.Z:= cCurrHHZ; 

598 
RemoveGearFromList(Gear); 

599 
InsertGearToList(Gear); 

7053  600 
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); 
6581  601 
Gear^.Pos:= 0; 
602 
Gear^.Timer:= timertime 

603 
end 

604 
end; 

605 

606 
//////////////////////////////////////////////////////////////////////////////// 

607 
procedure doStepHedgehogGone(Gear: PGear); 

608 
const frametime = 65; 

609 
timertime = frametime * 11; 

10178
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

610 
var i: LongInt; 
6581  611 
begin 
612 
if Gear^.Hedgehog^.Unplaced then 

613 
exit; 

614 
if Gear^.Timer > 1 then 

615 
begin 

616 
AllInactive:= false; 

617 
dec(Gear^.Timer); 

618 
if (Gear^.Timer mod frametime) = 0 then 

619 
inc(Gear^.Pos) 

620 
end 

621 
else 

622 
if Gear^.Timer = 1 then 

623 
begin 

624 
DeleteGear(Gear); 

625 
SetAllToActive 

626 
end 

627 
else // Gear^.Timer = 0 

628 
begin 

629 
AllInactive:= false; 

630 
Gear^.Z:= cCurrHHZ; 

631 
RemoveGearFromList(Gear); 

632 
InsertGearToList(Gear); 

10178
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

633 
// only play sound for one alive hedgehog 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

634 
with Gear^.Hedgehog^.Team^ do 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

635 
for i:= 0 to cMaxHHIndex do 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

636 
begin 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

637 
if (Hedgehogs[i].Gear <> nil) then 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

638 
begin 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

639 
if (Hedgehogs[i].Gear = Gear) then 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

640 
begin 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

641 
PlaySoundV(sndByeBye, Gear^.Hedgehog^.Team^.voicepack); 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

642 
PlaySound(sndWarp); 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

643 
end; 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

644 
break; 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

645 
end; 
949b51ca18c6
don't stack bye/teleport sounds of hogs (when a team is gone)
sheepluva
parents:
10147
diff
changeset

646 
end; 
6581  647 
Gear^.Pos:= 0; 
648 
Gear^.Timer:= timertime 

649 
end 

650 
end; 

651 

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

652 
procedure AddPickup(HH: THedgehog; ammo: TAmmoType; cnt, X, Y: LongWord); 
10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

653 
var s: ansistring; 
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:
7375
diff
changeset

654 
vga: PVisualGear; 
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:
7375
diff
changeset

655 
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:
7375
diff
changeset

656 
if cnt <> 0 then AddAmmo(HH, ammo, cnt) 
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:
7375
diff
changeset

657 
else AddAmmo(HH, ammo); 
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:
7375
diff
changeset

658 

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

659 
if (not (HH.Team^.ExtDriven 
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:
7375
diff
changeset

660 
or (HH.BotLevel > 0))) 
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:
7375
diff
changeset

661 
or (HH.Team^.Clan^.ClanIndex = LocalClan) 
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:
7375
diff
changeset

662 
or (GameType = gmtDemo) then 
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:
7375
diff
changeset

663 
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:
7375
diff
changeset

664 
if cnt <> 0 then 
10123  665 
s:= trammo[Ammoz[ammo].NameId] + ansistring(' (+' + IntToStr(cnt) + ')') 
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:
7375
diff
changeset

666 
else 
10123  667 
s:= trammo[Ammoz[ammo].NameId] + ansistring(' (+' + IntToStr(Ammoz[ammo].NumberInCase) + ')'); 
10116
dd27562b6f21
rolling back my PChar stuff, because unC0Rr improves string handling pas2c instead <3
sheepluva
parents:
10108
diff
changeset

668 
AddCaption(s, HH.Team^.Clan^.Color, capgrpAmmoinfo); 
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:
7375
diff
changeset

669 

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

670 
// show ammo icon 
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:
7375
diff
changeset

671 
vga:= AddVisualGear(X, Y, vgtAmmo); 
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:
7375
diff
changeset

672 
if vga <> nil then 
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:
7375
diff
changeset

673 
vga^.Frame:= Longword(ammo); 
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:
7375
diff
changeset

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

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

676 

6581  677 
//////////////////////////////////////////////////////////////////////////////// 
678 
procedure PickUp(HH, Gear: PGear); 

679 
var s: shortstring; 

7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

680 
i: LongInt; 
6581  681 
vga: PVisualGear; 
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

682 
ag, gi: PGear; 
6581  683 
begin 
684 
Gear^.Message:= gmDestroy; 

685 
if (Gear^.Pos and posCaseExplode) <> 0 then 

686 
if (Gear^.Pos and posCasePoison) <> 0 then 

687 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned) 

688 
else 

689 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound) 

690 
else if (Gear^.Pos and posCasePoison) <> 0 then 

691 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, HH^.Hedgehog, EXPLAutoSound + EXPLPoisoned + EXPLNoDamage) 

692 
else 

693 
case Gear^.Pos of 

694 
posCaseUtility, 

695 
posCaseAmmo: begin 

7597
1ef520fea21c
make cheating a bit easier (mikade insisted). Also, try flipping dust for a bit more variety.
nemo
parents:
7462
diff
changeset

696 
PlaySound(sndShotgunReload); 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

697 
if Gear^.AmmoType <> amNothing then 
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:
7375
diff
changeset

698 
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:
7375
diff
changeset

699 
AddPickup(HH^.Hedgehog^, Gear^.AmmoType, Gear^.Power, hwRound(Gear^.X), hwRound(Gear^.Y)); 
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:
7375
diff
changeset

700 
end 
6581  701 
else 
702 
begin 

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

703 
// Add spawning here... 
7409  704 
AddRandomness(GameTicks); 
8795
b5b79a8f9354
merge correction, also what's with all those trailing whitespaces?
koda
parents:
8774
diff
changeset

705 

7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

706 
gi := GearsList; 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

707 
while gi <> nil do 
7391
588eabb4b384
Apparently order of multiple getrandom in params is undefined. Also remove broken and pointless getrandom call.
nemo
parents:
7389
diff
changeset

708 
begin 
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8003
diff
changeset

709 
if (gi^.Kind = gtGenericFaller) and (gi^.State and gstInvisible <> 0) then 
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

710 
begin 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

711 
gi^.Active:= true; 
8030
165aeaaaf445
Call fallers less often. Should hopefully still be about as effective at the intended purpose. Should help loads quite a bit.
nemo
parents:
8003
diff
changeset

712 
gi^.State:= gi^.State or gstTmpFlag; 
7406
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

713 
gi^.X:= int2hwFloat(GetRandom(rightXleftX)+leftX); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

714 
gi^.Y:= int2hwFloat(GetRandom(LAND_HEIGHTtopY)+topY); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

715 
gi^.dX:= _90(GetRandomf*_360); 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

716 
gi^.dY:= _90(GetRandomf*_360) 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

717 
end; 
1fe2c821f9bf
Try avoiding spamming the log by retaining the gears. untested.
nemo
parents:
7391
diff
changeset

718 
gi := gi^.NextGear 
7391
588eabb4b384
Apparently order of multiple getrandom in params is undefined. Also remove broken and pointless getrandom call.
nemo
parents:
7389
diff
changeset

719 
end; 
7598  720 
ag:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAddAmmo, gstInvisible, _0, _0, GetRandom(125)+25); 
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:
7375
diff
changeset

721 
ag^.Pos:= Gear^.Pos; 
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:
7375
diff
changeset

722 
ag^.Power:= Gear^.Power 
6581  723 
end; 
724 
end; 

725 
posCaseHealth: begin 

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

726 
PlaySound(sndShotgunReload); 
6581  727 
inc(HH^.Health, Gear^.Health); 
7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset

728 
HH^.Hedgehog^.Effects[hePoisoned] := 0; 
6581  729 
str(Gear^.Health, s); 
730 
s:= '+' + s; 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

731 
AddCaption(ansistring(s), HH^.Hedgehog^.Team^.Clan^.Color, capgrpAmmoinfo); 
6581  732 
RenderHealth(HH^.Hedgehog^); 
733 
RecountTeamHealth(HH^.Hedgehog^.Team); 

734 

735 
i:= 0; 

736 
while i < Gear^.Health do 

737 
begin 

738 
vga:= AddVisualGear(hwRound(HH^.X), hwRound(HH^.Y), vgtStraightShot); 

739 
if vga <> nil then 

740 
with vga^ do 

741 
begin 

742 
Tint:= $00FF00FF; 

743 
State:= ord(sprHealth) 

744 
end; 

745 
inc(i, 5); 

746 
end; 

747 
end; 

748 
end 

749 
end; 

750 

751 
procedure HedgehogStep(Gear: PGear); 

752 
var PrevdX: LongInt; 

753 
CurWeapon: PAmmo; 

10435
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

754 
portals: PGearArrayS; 
6581  755 
begin 
6924  756 
CurWeapon:= GetCurAmmoEntry(Gear^.Hedgehog^); 
6581  757 
if ((Gear^.State and (gstAttacking or gstMoving)) = 0) then 
758 
begin 

759 
if isCursorVisible then 

760 
with Gear^.Hedgehog^ do 

761 
with CurWeapon^ do 

762 
begin 

763 
if (Gear^.Message and gmLeft ) <> 0 then 

764 
Pos:= (Pos  1 + Ammoz[AmmoType].PosCount) mod Ammoz[AmmoType].PosCount 

765 
else 

766 
if (Gear^.Message and gmRight ) <> 0 then 

767 
Pos:= (Pos + 1) mod Ammoz[AmmoType].PosCount 

768 
else 

769 
exit; 

7028  770 
GHStepTicks:= 200; 
6581  771 
exit 
772 
end; 

773 

774 
if ((Gear^.Message and gmAnimate) <> 0) then 

775 
begin 

776 
Gear^.Message:= 0; 

777 
Gear^.State:= Gear^.State or gstAnimation; 

778 
Gear^.Tag:= Gear^.MsgParam; 

779 
Gear^.Timer:= 0; 

780 
Gear^.Pos:= 0 

781 
end; 

782 

783 
if ((Gear^.Message and gmLJump ) <> 0) then 

784 
begin 

785 
Gear^.Message:= Gear^.Message and (not gmLJump); 

786 
DeleteCI(Gear); 

787 
if TestCollisionYwithGear(Gear, 1) = 0 then 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

788 
if TestCollisionXwithXYShift(Gear, _0, 2, hwSign(Gear^.dX)) = 0 then 
6581  789 
Gear^.Y:= Gear^.Y  _2 
790 
else 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

791 
if TestCollisionXwithXYShift(Gear, _0, 1, hwSign(Gear^.dX)) = 0 then 
6581  792 
Gear^.Y:= Gear^.Y  _1; 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

793 
if (TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

794 
(TestCollisionYwithGear(Gear, 1) = 0) then 
6581  795 
begin 
796 
Gear^.dY:= _0_15; 

797 
if not cArtillery then 

798 
Gear^.dX:= SignAs(_0_15, Gear^.dX); 

799 
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; 

7053  800 
PlaySoundV(sndJump1, Gear^.Hedgehog^.Team^.voicepack); 
6581  801 
exit 
802 
end; 

803 
end; 

804 

805 
if ((Gear^.Message and gmHJump ) <> 0) then 

806 
begin 

807 
DeleteCI(Gear); 

808 
Gear^.Message:= Gear^.Message and (not gmHJump); 

809 

810 
Gear^.dY:= _0_2; 

811 
SetLittle(Gear^.dX); 

812 
Gear^.State:= Gear^.State or gstMoving or gstHHJumping; 

7053  813 
PlaySoundV(sndJump3, Gear^.Hedgehog^.Team^.voicepack); 
6581  814 
exit 
815 
end; 

816 

10435
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

817 
if (Gear^.Message and (gmLeft or gmRight) <> 0) and (Gear^.State and gstMoving = 0) then 
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

818 
begin 
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

819 
// slightly inefficient since it doesn't halt after one portal, maybe could add a param to GearsNear for number desired. 
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

820 
portals:= GearsNear(Gear^.X, Gear^.Y, gtPortal, 26); 
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

821 
if portals.size = 0 then Gear^.PortalCounter:= 0 
4c8fc3aa9432
allow hogs to repeatedly enter portals placed on the ground
nemo
parents:
10354
diff
changeset

822 
end; 
6581  823 
PrevdX:= hwSign(Gear^.dX); 
824 
if (Gear^.Message and gmLeft )<>0 then 

825 
Gear^.dX:= cLittle else 

826 
if (Gear^.Message and gmRight )<>0 then 

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

827 
Gear^.dX:= cLittle 
7187
aff30d80bd7b
 Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset

828 
else exit; 
6581  829 

7187
aff30d80bd7b
 Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset

830 
StepSoundTimer:= cHHStepTicks; 
7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset

831 

7028  832 
GHStepTicks:= cHHStepTicks; 
6581  833 
if PrevdX <> hwSign(Gear^.dX) then 
834 
begin 

835 
FollowGear:= Gear; 

836 
exit 

837 
end; 

838 
DeleteCI(Gear); // must be after exit!! (see previous line) 

839 

840 
Gear^.Hedgehog^.visStepPos:= (Gear^.Hedgehog^.visStepPos + 1) and 7; 

7164
fad64b97947e
Some brainfucking code which greatly reduces number of TestCollision* calls in hedgehog walk routine. Especially helpful to AI optimization. Also fixes some edge cases.
unc0rr
parents:
7069
diff
changeset

841 

10714  842 
if (not cArtillery or 
843 
((CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtBlowTorch))) and 

844 
((Gear^.Message and gmPrecise) = 0) then 

7719
eeae1cb6b6bf
Move hedgehog's step routine into separate function, use it in both hedgehog and ai code
unc0rr
parents:
7671
diff
changeset

845 
MakeHedgehogsStep(Gear); 
6581  846 

8576
286ebfcb3d97
workaround for frequent AllHH active call in hedgehog step
nemo
parents:
8574
diff
changeset

847 
SetAllHHToActive(false); 
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

848 
AddCI(Gear) 
6581  849 
end 
850 
end; 

851 

852 
procedure HedgehogChAngle(HHGear: PGear); 

853 
var da: LongWord; 

854 
begin 

855 
with HHGear^.Hedgehog^ do 

10015  856 
if (((CurAmmoType = amRope) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amRope))) and 
9139
2ae44c4381cd
Restore CurAmmoType check as well, that was removed in r8f317ba10675 when trying to fix aiming during alt attack.
nemo
parents:
9080
diff
changeset

857 
((HHGear^.State and (gstMoving or gstHHJumping)) = gstMoving)) 
6581  858 
or ((CurAmmoType = amPortalGun) and ((HHGear^.State and gstMoving) <> 0)) then 
859 
da:= 2 

860 
else da:= 1; 

861 

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

862 
if ((HHGear^.Message and gmPrecise = 0) or ((CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack))) or (GameTicks mod 5 = 1) then 
6581  863 
if ((HHGear^.Message and gmUp) <> 0) and (HHGear^.Angle >= CurMinAngle + da) then 
864 
dec(HHGear^.Angle, da) 

865 
else 

866 
if ((HHGear^.Message and gmDown) <> 0) and (HHGear^.Angle + da <= CurMaxAngle) then 

867 
inc(HHGear^.Angle, da) 

868 
end; 

869 

870 

871 
//////////////////////////////////////////////////////////////////////////////// 

872 
procedure doStepHedgehogMoving(Gear: PGear); 

873 
var isFalling, isUnderwater: boolean; 

874 
land: Word; 

875 
begin 

10577
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

876 
if Gear^.Hedgehog^.Unplaced then 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

877 
begin 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

878 
Gear^.dY:= _0; 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

879 
Gear^.dX:= _0; 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

880 
Gear^.State:= Gear^.State and (not gstMoving); 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

881 
exit 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

882 
end; 
5e075da5e0a4
don't drown unplaced hedgehogs. thanks to zimmux and Wohlstand for reporting
sheepluva
parents:
10443
diff
changeset

883 

6581  884 
land:= 0; 
10354  885 
isUnderwater:= CheckCoordInWater(hwRound(Gear^.X), hwRound(Gear^.Y) + Gear^.Radius); 
6581  886 
if Gear^.dX.QWordValue > 8160437862 then 
887 
Gear^.dX.QWordValue:= 8160437862; 

888 
if Gear^.dY.QWordValue > 8160437862 then 

889 
Gear^.dY.QWordValue:= 8160437862; 

890 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

891 
isFalling:= (Gear^.dY.isNegative) or (TestCollisionYKick(Gear, 1) = 0); 
6581  892 
if isFalling then 
893 
begin 

9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

894 
land:= TestCollisionYKick(Gear, 1); 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

895 
if (Gear^.dY.isNegative) and (land <> 0) then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

896 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

897 
if land and lfBouncy <> 0 then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

898 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

899 
doStepFallingGear(Gear); 
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset

900 
Gear^.AdvBounce:= 1; 
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

901 
Gear^.dX:= Gear^.dX * _0_8 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

902 
end; 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

903 
if (land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0) then 
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset

904 
Gear^.dY:= _0; 
9954  905 
Gear^.State:= Gear^.State and (not gstCollision) 
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

906 
end; 
6581  907 
Gear^.State:= Gear^.State or gstMoving; 
9971  908 
if (Gear^.State and gstHHDriven <> 0) and 
9499  909 
(not CurrentTeam^.ExtDriven) and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then 
6581  910 
begin 
7187
aff30d80bd7b
 Allow camera movement while current hedgehog is falling
unc0rr
parents:
7164
diff
changeset

911 
// TODO: why so aggressive at setting FollowGear when falling? 
9499  912 
// because hog was being yanked out of frame by other stuff when doing a complicated jump/chute/saucer/roping. 
913 
// added a couple more conditions to make it a bit less aggressive, at cost of possibly spectator failing to follow a maneuver 

6581  914 
FollowGear:= Gear; 
915 
end; 

916 
if isUnderwater then 

917 
Gear^.dY:= Gear^.dY + cGravity / _2 

918 
else 

919 
begin 

920 
Gear^.dY:= Gear^.dY + cGravity; 

921 
// this set of circumstances could be less complex if jumping was more clearly identified 

922 
if ((GameFlags and gfMoreWind) <> 0) and (((Gear^.Damage <> 0) 

923 
or ((CurAmmoGear <> nil) and ((CurAmmoGear^.AmmoType = amJetpack) or (CurAmmoGear^.AmmoType = amBirdy))) 

924 
or ((Gear^.dY.QWordValue + Gear^.dX.QWordValue) > _0_55.QWordValue))) then 

925 
Gear^.dX := Gear^.dX + cWindSpeed / Gear^.Density 

926 
end 

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

927 
end 
6581  928 
else 
929 
begin 

930 
land:= TestCollisionYwithGear(Gear, 1); 

10015  931 
if ((Gear^.dX.QWordValue + Gear^.dY.QWordValue) < _0_55.QWordValue) and ((land and lfIce) = 0) 
932 
and ((land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0)) 

6581  933 
and ((Gear^.State and gstHHJumping) <> 0) then 
934 
SetLittle(Gear^.dX); 

935 

936 
if not Gear^.dY.isNegative then 

937 
begin 

9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

938 
if land and lfBouncy <> 0 then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

939 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

940 
doStepFallingGear(Gear); 
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset

941 
Gear^.AdvBounce:= 1; 
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

942 
// hogs for some reason have very low friction. slippery little buggers 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

943 
Gear^.dX:= Gear^.dX * _0_8 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

944 
end; 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

945 

6581  946 
CheckHHDamage(Gear); 
947 

9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

948 
if (land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0) then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

949 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

950 
if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

951 
and (Gear^.dX.QWordValue < _0_02.QWordValue) then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

952 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

953 
if land and lfBouncy <> 0 then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

954 
Gear^.dY:= _0; 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

955 
Gear^.dX.isNegative:= not Gear^.dX.isNegative // landing after high jump 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

956 
end; 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

957 
Gear^.State:= Gear^.State and (not (gstHHJumping or gstHHHJump)); 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

958 
if (land and lfBouncy = 0) or (Gear^.dX.QWordValue < _0_02.QWordValue) then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

959 
Gear^.dY:= _0 
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset

960 
end; 
9954  961 
Gear^.State:= Gear^.State and (not gstCollision) 
6581  962 
end 
963 
else 

964 
Gear^.dY:= Gear^.dY + cGravity; 

965 

966 
if ((Gear^.State and gstMoving) <> 0) then 

967 
begin 

968 
if land and lfIce <> 0 then 

969 
begin 

970 
Gear^.dX:= Gear^.dX * (_1  (_1  Gear^.Friction) / _2) 

971 
end 

972 
else 

973 
Gear^.dX:= Gear^.dX * Gear^.Friction; 

974 
end 

975 
end; 

976 

10146
1fb6d8cc4626
Should never use State like this, since some states aren't synced (thinking state for example)
unc0rr
parents:
10124
diff
changeset

977 
if (Gear^.State and (gstMoving or gstHHJumping or gstHHHJump)) <> 0 then 
6581  978 
DeleteCI(Gear); 
979 

980 
if isUnderwater then 

981 
begin 

982 
Gear^.dY:= Gear^.dY * _0_999; 

983 
Gear^.dX:= Gear^.dX * _0_999; 

984 
end; 

985 

986 
if (Gear^.State and gstMoving) <> 0 then 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

987 
if TestCollisionXKick(Gear, hwSign(Gear^.dX)) <> 0 then 
6581  988 
if not isFalling then 
989 
if hwAbs(Gear^.dX) > _0_01 then 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

990 
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX))  Gear^.dX, 1, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

991 
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX)  hwRound(Gear^.dX), 1, 1) = 0) then 
6581  992 
begin 
993 
Gear^.X:= Gear^.X + Gear^.dX; 

994 
Gear^.dX:= Gear^.dX * _0_96; 

995 
Gear^.Y:= Gear^.Y  _1 

996 
end 

997 
else 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

998 
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX))  Gear^.dX, 2, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

999 
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX)  hwRound(Gear^.dX), 1, 1) = 0) then 
6581  1000 
begin 
1001 
Gear^.X:= Gear^.X + Gear^.dX; 

1002 
Gear^.dX:= Gear^.dX * _0_93; 

1003 
Gear^.Y:= Gear^.Y  _2 

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

1004 
end 
6581  1005 
else 
9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1006 
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX))  Gear^.dX, 3, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1007 
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX)  hwRound(Gear^.dX), 1, 1) = 0) then 
6581  1008 
begin 
1009 
Gear^.X:= Gear^.X + Gear^.dX; 

1010 
Gear^.dX:= Gear^.dX * _0_9 ; 

1011 
Gear^.Y:= Gear^.Y  _3 

1012 
end 

1013 
else 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1014 
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX))  Gear^.dX, 4, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1015 
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX)  hwRound(Gear^.dX), 1, 1) = 0) then 
6581  1016 
begin 
1017 
Gear^.X:= Gear^.X + Gear^.dX; 

1018 
Gear^.dX:= Gear^.dX * _0_87; 

1019 
Gear^.Y:= Gear^.Y  _4 

1020 
end 

1021 
else 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1022 
if (TestCollisionXwithXYShift(Gear, int2hwFloat(hwSign(Gear^.dX))  Gear^.dX, 5, hwSign(Gear^.dX)) = 0) and 
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1023 
(TestCollisionYwithXYShift(Gear, hwSign(Gear^.dX)  hwRound(Gear^.dX), 1, 1) = 0) then 
6581  1024 
begin 
1025 
Gear^.X:= Gear^.X + Gear^.dX; 

1026 
Gear^.dX:= Gear^.dX * _0_84; 

1027 
Gear^.Y:= Gear^.Y  _5 

1028 
end 

1029 
else 

1030 
if hwAbs(Gear^.dX) > _0_02 then 

1031 
Gear^.dX:= Gear^.Elasticity * Gear^.dX 

1032 
else 

1033 
begin 

1034 
Gear^.State:= Gear^.State and (not gstMoving); 

1035 
while TestCollisionYWithGear(Gear,1) = 0 do 

1036 
Gear^.Y:= Gear^.Y+_1; 

1037 
SetLittle(Gear^.dX) 

1038 
end 

1039 
else 

1040 
begin 

1041 
Gear^.State:= Gear^.State and (not gstMoving); 

1042 
while TestCollisionYWithGear(Gear,1) = 0 do 

1043 
Gear^.Y:= Gear^.Y+_1; 

1044 
SetLittle(Gear^.dX) 

1045 
end 

1046 
else if (hwAbs(Gear^.dX) > cLittle) 

1047 
and ((Gear^.State and gstHHJumping) = 0) then 

1048 
Gear^.dX:= Gear^.Elasticity * Gear^.dX 

1049 
else 

1050 
SetLittle(Gear^.dX); 

1051 

1052 
if (not isFalling) 

7362
53bcfc714cb3
Fix rare condition when hog's gear stucks in an infinite loop which adds 1 to its Y coordinate not checking for drowning
unc0rr
parents:
7339
diff
changeset

1053 
and (hwAbs(Gear^.dX) + hwAbs(Gear^.dY) < _0_03) then 
6581  1054 
begin 
1055 
Gear^.State:= Gear^.State and (not gstWinner); 

1056 
Gear^.State:= Gear^.State and (not gstMoving); 

9914  1057 
while (not CheckGearDrowning(Gear)) and (Gear <> nil) and (TestCollisionYWithGear(Gear,1) = 0) do 
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1058 
Gear^.Y:= Gear^.Y + _1; 
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1059 

e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1060 
// could become nil in CheckGearDrowning if ai's hog fails to respawn in ai survival 
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1061 
if Gear = nil then exit; 
6581  1062 
SetLittle(Gear^.dX); 
1063 
Gear^.dY:= _0 

1064 
end 

1065 
else 

1066 
Gear^.State:= Gear^.State or gstMoving; 

1067 

1068 
if (Gear^.State and gstMoving) <> 0 then 

1069 
begin 

1070 
Gear^.State:= Gear^.State and (not gstAnimation); 

1071 
// ARTILLERY but not being moved by explosions 

1072 
Gear^.X:= Gear^.X + Gear^.dX; 

1073 
Gear^.Y:= Gear^.Y + Gear^.dY; 

9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1074 
if (not Gear^.dY.isNegative) and (TestCollisionYKick(Gear, 1) = 0) then 
6581  1075 
begin 
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1076 
land:= TestCollisionYwithXYShift(Gear, 0, 1, 1); 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1077 
if land and lfBouncy <> 0 then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1078 
doStepFallingGear(Gear); 
10895
bce67defd804
Make bouncing a bit less wtf for various gears tested (hog, 'zooka, saucer hog, drill strike). Less hacky is another matter.
nemo
parents:
10818
diff
changeset

1079 
Gear^.AdvBounce:= 1; 
9731
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1080 

953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1081 
if (land <> 0) and ((land and lfBouncy = 0) or (Gear^.State and gstCollision <> 0)) then 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1082 
begin 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1083 
CheckHHDamage(Gear); 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1084 
Gear^.dY:= _0; 
953197ac43d8
Make sticky mine respect lfBouncy, make hogs do same, kinda... make uCollisions return land w/ mask, restrict bouncy to advbounce gears only, which means piano doesn't bounce anymore
nemo
parents:
9706
diff
changeset

1085 
Gear^.Y:= Gear^.Y + _1 
9795
487e5675061f
clear gstCollision from doStepFallingGear once I'm done with it. hog "physics" doesn't use it, and was screwing up labels
nemo
parents:
9776
diff
changeset

1086 
end; 
9954  1087 
Gear^.State:= Gear^.State and (not gstCollision) 
6581  1088 
end; 
8947
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1089 

e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1090 
// could become nil if ai's hog fails to respawn in ai survival 
e906ebd59612
CheckGearDrowning could delete hedgehogs gear! (CheckGearDrowning > ResurrectHedgehog > FindPlace). Fixes bug 620.
unc0rr
parents:
8818
diff
changeset

1091 
if Gear = nil then exit; 
6581  1092 
// hide target cursor if current hog is drowning 
1093 
if (Gear^.State and gstDrowning) <> 0 then 

1094 
if (CurrentHedgehog^.Gear = Gear) then 

1095 
isCursorVisible:= false 

1096 
end; 

7623
addc5b262617
isZero appears to be never used. Use it in a few obvious cases and add web variant.
nemo
parents:
7615
diff
changeset

1097 
if (not isZero(Gear^.dY)) and (Gear^.FlightTime > 0) and ((GameFlags and gfLowGravity) = 0) then 
6581  1098 
begin 
1099 
inc(Gear^.FlightTime); 

8003  1100 
if (Gear^.FlightTime > 1500) and ((hwRound(Gear^.X) < LongInt(leftX)250) or (hwRound(Gear^.X) > LongInt(rightX)+250)) then 
6581  1101 
begin 
7763  1102 
Gear^.FlightTime:= 0; 
6581  1103 
AddCaption(GetEventString(eidHomerun), cWhiteColor, capgrpMessage); 
1104 
PlaySound(sndHomerun) 

1105 
end; 

1106 
end 

1107 
else 

1108 
begin 

1109 
uStats.hedgehogFlight(Gear, Gear^.FlightTime); 

1110 
Gear^.FlightTime:= 0; 

1111 
end; 

1112 

1113 
end; 

1114 

1115 
procedure doStepHedgehogDriven(HHGear: PGear); 

1116 
var t: PGear; 

1117 
wasJumping: boolean; 

1118 
Hedgehog: PHedgehog; 

1119 
begin 

1120 
Hedgehog:= HHGear^.Hedgehog; 

8658  1121 
if not isInMultiShoot then 
1122 
AllInactive:= false 

1123 
else if Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle] then 

1124 
HHGear^.Message:= 0; 

6581  1125 

8330  1126 
if ((Ammoz[CurrentHedgehog^.CurAmmoType].Ammo.Propz and ammoprop_Utility) <> 0) and isInMultiShoot then 
6581  1127 
AllInactive:= true 
7786
23a075cf4837
*sigh* revert the multishoot thingy. worked fine in my tests w/ smine and cleaver, screwed up deagle. need to find out why, but sleepy. for later
nemo
parents:
7783
diff
changeset

1128 
else if not isInMultiShoot then 
6581  1129 
AllInactive:= false; 
1130 

1131 
if (TurnTimeLeft = 0) or (HHGear^.Damage > 0) then 

1132 
begin 

8494
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset

1133 
if (Hedgehog^.CurAmmoType = amKnife) then 
53b91a602955
Cleaver tweaks based on feedback. Nerf damage, shrink radius. This means cleaver will embed into ground quite a bit further.
nemo
parents:
8493
diff
changeset

1134 
LoadHedgehogHat(Hedgehog^, Hedgehog^.Hat); 
6581  1135 
if TagTurnTimeLeft = 0 then 
1136 
TagTurnTimeLeft:= TurnTimeLeft; 

1137 
TurnTimeLeft:= 0; 

1138 
isCursorVisible:= false; 

1139 
HHGear^.State:= HHGear^.State and (not (gstHHDriven or gstAnimation or gstAttacking)); 

1140 
AttackBar:= 0; 

1141 
if HHGear^.Damage > 0 then 

1142 
HHGear^.State:= HHGear^.State and (not (gstHHJumping or gstHHHJump)); 

1143 
exit 

1144 
end; 

1145 

9670
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1146 
if isAFK and (not CurrentTeam^.ExtDriven) and (CurrentHedgehog^.BotLevel = 0) then 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1147 
begin 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1148 
AFKSkip; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1149 
exit 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1150 
end; 
1954f692e8c6
Quick and simple implementation of afk mode (toggled by /pause)
unc0rr
parents:
9664
diff
changeset

1151 

6581  1152 
if (HHGear^.State and gstAnimation) <> 0 then 
1153 
begin 

1154 
HHGear^.Message:= 0; 

1155 
if (HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].VoiceDelay) and (HHGear^.Timer = 0) then 

7053  1156 
PlaySoundV(Wavez[TWave(HHGear^.Tag)].Voice, Hedgehog^.Team^.voicepack); 
6581  1157 
inc(HHGear^.Timer); 
1158 
if HHGear^.Timer = Wavez[TWave(HHGear^.Tag)].Interval then 

1159 
begin 

1160 
HHGear^.Timer:= 0; 

1161 
inc(HHGear^.Pos); 

1162 
if HHGear^.Pos = Wavez[TWave(HHGear^.Tag)].FramesCount then 

1163 
HHGear^.State:= HHGear^.State and (not gstAnimation) 

1164 
end; 

1165 
exit 

1166 
end; 

1167 

1168 
if ((HHGear^.State and gstMoving) <> 0) 

7028  1169 
or (GHStepTicks = cHHStepTicks) 
6581  1170 
or (CurAmmoGear <> nil) then // we are moving 
1171 
begin 

1172 
with Hedgehog^ do 

1173 
if (CurAmmoGear = nil) 

1174 
and (HHGear^.dY > _0_39) 

1175 
and (CurAmmoType = amParachute) then 

1176 
HHGear^.Message:= HHGear^.Message or gmAttack; 

1177 
// check for case with ammo 

1178 
t:= CheckGearNear(HHGear, gtCase, 36, 36); 

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

1179 
if (t <> nil) and (t^.State and gstFrozen = 0) then 
6581  1180 
PickUp(HHGear, t) 
1181 
end; 

1182 

1183 
if (CurAmmoGear = nil) then 

1184 
if (((HHGear^.Message and gmAttack) <> 0) 

1185 
or ((HHGear^.State and gstAttacking) <> 0)) then 

1186 
Attack(HHGear) // should be before others to avoid desync with '/put' msg and changing weapon msgs 

1187 
else 

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

1188 
else 
6581  1189 
with Hedgehog^ do 
1190 
if ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) 

1191 
and ((HHGear^.Message and gmLJump) <> 0) 

1192 
and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) then 

1193 
begin 

1194 
Attack(HHGear); 

1195 
HHGear^.Message:= HHGear^.Message and (not gmLJump) 

1196 
end; 

1197 

1198 
if (CurAmmoGear = nil) 

7956
61da79e83330
Causes AI fail. Needs testing 'cause at some point, I thought this was needed for portal, I don't remember *why*
nemo
parents:
7832
diff
changeset

1199 
or ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) then 
6581  1200 
begin 
1201 
if ((HHGear^.Message and gmSlot) <> 0) then 

1202 
if ChangeAmmo(HHGear) then ApplyAmmoChanges(Hedgehog^); 

1203 

1204 
if ((HHGear^.Message and gmWeapon) <> 0) then 

1205 
HHSetWeapon(HHGear); 

1206 

1207 
if ((HHGear^.Message and gmTimer) <> 0) then 

1208 
HHSetTimer(HHGear); 

1209 
end; 

1210 

1211 
if CurAmmoGear <> nil then 

1212 
begin 

1213 
CurAmmoGear^.Message:= HHGear^.Message; 

1214 
exit 

1215 
end; 

1216 

1217 
HedgehogChAngle(HHGear); 

1218 

1219 
if (HHGear^.State and gstMoving) <> 0 then 

1220 
begin 

1221 
wasJumping:= ((HHGear^.State and gstHHJumping) <> 0); 

1222 

1223 
if ((HHGear^.Message and gmHJump) <> 0) and wasJumping and ((HHGear^.State and gstHHHJump) = 0) then 

1224 
if (not (hwAbs(HHGear^.dX) > cLittle)) and (HHGear^.dY < _0_02) then 

1225 
begin 

1226 
HHGear^.State:= HHGear^.State or gstHHHJump; 

1227 
HHGear^.dY:= _0_25; 

1228 
if not cArtillery then 

1229 
HHGear^.dX:= SignAs(_0_02, HHGear^.dX); 

7053  1230 
PlaySoundV(sndJump2, Hedgehog^.Team^.voicepack) 
6581  1231 
end; 
1232 

1233 
HHGear^.Message:= HHGear^.Message and (not (gmLJump or gmHJump)); 

1234 

9706
5178d2263521
return land word from uCollisions to make decisions based on it. Should be handy for trampoline.
nemo
parents:
9685
diff
changeset

1235 
if (not cArtillery) and wasJumping and (TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) <> 0) then 
6581  1236 
SetLittle(HHGear^.dX); 
1237 

1238 
if Hedgehog^.Gear <> nil then 

1239 
doStepHedgehogMoving(HHGear); 

1240 

1241 
if ((HHGear^.State and (gstMoving or gstDrowning)) = 0) then 

1242 
begin 

9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

1243 
AddCI(HHGear); 
6581  1244 
if wasJumping then 
7028  1245 
GHStepTicks:= 410 
6581  1246 
else 
7028  1247 
GHStepTicks:= 95 
6581  1248 
end; 
1249 
exit 

1250 
end; 

1251 

8562
d9d1cb650ff8
Restore freezing hedgehog for shotgun, sniper rifle and deagle to make unc0rr happy. You'll still be able to get away after throwing cleaver and sticky bomb tho.
nemo
parents:
8553
diff
changeset

1252 
if not(isInMultiShoot and (Hedgehog^.CurAmmoType in [amShotgun, amDEagle, amSniperRifle])) and (Hedgehog^.Gear <> nil) then 
6581  1253 
begin 
7028  1254 
if GHStepTicks > 0 then 
1255 
dec(GHStepTicks); 

1256 
if (GHStepTicks = 0) then 

6581  1257 
HedgehogStep(HHGear) 
1258 
end 

1259 
end; 

1260 

1261 
//////////////////////////////////////////////////////////////////////////////// 

1262 
procedure doStepHedgehogFree(Gear: PGear); 

1263 
var prevState: Longword; 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

1264 
s: ansistring; 
6581  1265 
begin 
1266 
prevState:= Gear^.State; 

1267 

1268 
doStepHedgehogMoving(Gear); 

1269 

1270 
if (Gear^.State and (gstMoving or gstDrowning)) <> 0 then 

1271 
begin 

1272 
if Gear^.Damage > 0 then 

1273 
CalcRotationDirAngle(Gear); 

1274 
AllInactive:= false; 

1275 
exit 

1276 
end; 

1277 

1278 
if (Gear^.Health = 0) then 

1279 
begin 

1280 
if PrvInactive or ((GameFlags and gfInfAttack) <> 0) then 

1281 
begin 

1282 
Gear^.Timer:= 0; 

1283 
FollowGear:= Gear; 

1284 
PrvInactive:= false; 

1285 
AllInactive:= false; 

1286 

1287 
if (Gear^.State and gstHHGone) = 0 then 

1288 
begin 

7010
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset

1289 
Gear^.Hedgehog^.Effects[hePoisoned] := 0; 
10a0a31804f3
Switch effects to longint for convenience of tracking ice states. I could add a new Hedgehog value, but since we have this effects list being all useless as booleans anyway...
nemo
parents:
6992
diff
changeset

1290 
if Gear^.Hedgehog^.Effects[heResurrectable] <> 0 then 
6581  1291 
begin 
1292 
ResurrectHedgehog(Gear); 

1293 
end 

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

1294 
else 
6581  1295 
begin 
1296 
Gear^.State:= (Gear^.State or gstHHDeath) and (not gstAnimation); 

1297 
Gear^.doStep:= @doStepHedgehogDead; 

1298 
// Death message 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

1299 
s:= ansistring(Gear^.Hedgehog^.Name); 
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

1300 
AddCaption(FormatA(GetEventString(eidDied), s), cWhiteColor, capgrpMessage); 
6581  1301 
end; 
1302 
end 

1303 
else 

1304 
begin 

1305 
Gear^.State:= Gear^.State and (not gstAnimation); 

1306 
Gear^.doStep:= @doStepHedgehogGone; 

1307 

1308 
// Gone message 

10124
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

1309 
s:= ansistring(Gear^.Hedgehog^.Name); 
aabd1b75d5a3
Even more explicit type conversions and other stuff to help pas2c use ansistrings
unc0rr
parents:
10123
diff
changeset

1310 
AddCaption(FormatA(GetEventString(eidGone), s), cWhiteColor, capgrpMessage); 
6581  1311 
end 
1312 
end; 

1313 
exit 

1314 
end; 

1315 

1316 
if ((Gear^.State and gstWait) = 0) and 

1317 
(prevState <> Gear^.State) then 

1318 
begin 

1319 
Gear^.State:= Gear^.State or gstWait; 

1320 
Gear^.Timer:= 150 

1321 
end 

1322 
else 

1323 
begin 

1324 
if Gear^.Timer = 0 then 

1325 
begin 

10818
f642a28cab0c
Add placement of airmines in engine outside of hog proximity. Has a bug, only protecting 1st team. Also fix a spelling error and rename gstHHChooseTarget to gstChooseTarget
nemo
parents:
10789
diff
changeset

1326 
Gear^.State:= Gear^.State and (not (gstWait or gstLoser or gstWinner or gstAttacked or gstNotKickable or gstChooseTarget)); 
8563
4d9d8287e601
Trying to improve rendering, sliding and thawing. Messing around w/ making fire thaw faster.
nemo
parents:
8560
diff
changeset

1327 
if Gear^.Hedgehog^.Effects[heFrozen] = 0 then Gear^.Active:= false; 
9291
15f7bb217b66
Make add/delete consistent (this has bugged me for so long)
nemo
parents:
9285
diff
changeset

1328 
AddCI(Gear); 
6581  1329 
exit 
1330 
end 

1331 
else dec(Gear^.Timer) 
