author  unc0rr 
Sun, 29 Nov 2009 16:56:04 +0000  
changeset 2647  0e1208e92dfe 
parent 2634  d7531d08caa2 
child 2713  71250942e95b 
permissions  rwrr 
4  1 
(* 
1066  2 
* Hedgewars, a free turn based strategy game 
1689  3 
* Copyright (c) 20042009 Andrey Korotaev <unC0Rr@gmail.com> 
4  4 
* 
183  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 

4  8 
* 
183  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. 

4  13 
* 
183  14 
* You should have received a copy of the GNU General Public License 
15 
* along with this program; if not, write to the Free Software 

16 
* Foundation, Inc., 59 Temple Place  Suite 330, Boston, MA 021111307, USA 

4  17 
*) 
18 

2647  19 
procedure makeHogsWorry(x, y: hwFloat; r: LongInt); 
20 
var gi: PGear; 

21 
d: LongInt; 

22 
begin 

23 
gi:= GearsList; 

24 
while gi <> nil do 

25 
begin 

26 
d:= r  hwRound(Distance(gi^.X  x, gi^.Y  y)); 

27 
if (d > 1) and (gi^.Kind = gtHedgehog) and not gi^.Invulnerable and (GetRandom(2) = 0) then 

28 
begin 

29 
if (CurrentHedgehog^.Gear = gi) then 

30 
PlaySound(sndOops, false, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 

31 
else 

32 
begin 

33 
if (gi^.State and gstMoving) = 0 then 

34 
gi^.State:= gi^.State or gstLoser; 

35 
if d > r div 2 then 

36 
PlaySound(sndNooo, false, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 

37 
else 

38 
PlaySound(sndUhOh, false, PHedgehog(gi^.Hedgehog)^.Team^.voicepack); 

39 
end; 

40 
end; 

41 
gi:= gi^.NextGear 

42 
end; 

43 
end; 

44 
//////////////////////////////////////////////////////////////////////////////// 

4  45 
procedure doStepDrowningGear(Gear: PGear); forward; 
46 

47 
function CheckGearDrowning(Gear: PGear): boolean; 

1918  48 
var skipSpeed, skipAngle, skipDecay: hwFloat; 
4  49 
begin 
1918  50 
// probably needs tweaking. might need to be in a case statement based upon gear type 
51 
//(not Gear^.dY.isNegative) and this should not be necessary 

498  52 
if cWaterLine < hwRound(Gear^.Y) + Gear^.Radius then 
1918  53 
begin 
54 
skipSpeed:= _0_25; // was 0.36  couldn't manage baseball bat. Tiy's build is 0.36... 

55 
skipAngle:= _1 + _0_9; // these should perhaps also be constants, once work out what proper values are 

56 
skipDecay:= _0_87; // this could perhaps be a tiny bit higher. 

1919  57 
if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > skipSpeed) and 
1920  58 
(hwAbs(Gear^.dX) > skipAngle * hwAbs(Gear^.dY)) then 
1918  59 
begin 
60 
Gear^.dY.isNegative:= true; 

1919  61 
Gear^.dY:= Gear^.dY * skipDecay; 
62 
Gear^.dX:= Gear^.dX * skipDecay; 

1918  63 
CheckGearDrowning:= false 
64 
end 

65 
else 

66 
begin 

67 
CheckGearDrowning:= true; 

68 
Gear^.State:= gstDrowning; 

2429  69 
Gear^.RenderTimer:= false; 
1918  70 
Gear^.doStep:= @doStepDrowningGear; 
2367
86c9aadea817
Remove gstHHDriven flag when hedgehog get into the water. Fixes some odd cases.
unc0rr
parents:
2365
diff
changeset

71 
if Gear^.Kind = gtHedgehog then 
86c9aadea817
Remove gstHHDriven flag when hedgehog get into the water. Fixes some odd cases.
unc0rr
parents:
2365
diff
changeset

72 
begin 
86c9aadea817
Remove gstHHDriven flag when hedgehog get into the water. Fixes some odd cases.
unc0rr
parents:
2365
diff
changeset

73 
Gear^.State:= Gear^.State and (not gstHHDriven); 
2619  74 
AddCaption(Format(GetEventString(eidDrowned), PHedgehog(Gear^.Hedgehog)^.Name), cWhiteColor, capgrpMessage); 
2367
86c9aadea817
Remove gstHHDriven flag when hedgehog get into the water. Fixes some odd cases.
unc0rr
parents:
2365
diff
changeset

75 
end 
1918  76 
end; 
77 
PlaySound(sndSplash, false, nil) 

78 
end 

79 
else 

1133  80 
CheckGearDrowning:= false 
4  81 
end; 
82 

83 
procedure CheckCollision(Gear: PGear); 

84 
begin 

351  85 
if TestCollisionXwithGear(Gear, hwSign(Gear^.X)) or TestCollisionYwithGear(Gear, hwSign(Gear^.Y)) 
1133  86 
then Gear^.State:= Gear^.State or gstCollision 
87 
else Gear^.State:= Gear^.State and not gstCollision 

4  88 
end; 
89 

90 
procedure CheckHHDamage(Gear: PGear); 

522  91 
var dmg: Longword; 
4  92 
begin 
1849  93 
if(Gear^.Invulnerable) then exit; 
522  94 
if _0_4 < Gear^.dY then 
1123  95 
begin 
96 
if _0_6 < Gear^.dY then 

1669  97 
PlaySound(sndOw4, false, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack) 
1123  98 
else 
1669  99 
PlaySound(sndOw1, false, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack); 
1123  100 

1861  101 
dmg:= modifyDamage(1 + hwRound((hwAbs(Gear^.dY)  _0_4) * 70)); 
2017  102 
ApplyDamage(Gear, dmg); 
1123  103 
end 
4  104 
end; 
105 

106 
//////////////////////////////////////////////////////////////////////////////// 

107 
//////////////////////////////////////////////////////////////////////////////// 

108 
procedure CalcRotationDirAngle(Gear: PGear); 

776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
764
diff
changeset

109 
var dAngle: real; 
4  110 
begin 
776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
764
diff
changeset

111 
dAngle:= (hwAbs(Gear^.dX) + hwAbs(Gear^.dY)).QWordValue / $80000000; 
1133  112 
if not Gear^.dX.isNegative then 
113 
Gear^.DirAngle:= Gear^.DirAngle + dAngle 

114 
else 

115 
Gear^.DirAngle:= Gear^.DirAngle  dAngle; 

116 

776
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
764
diff
changeset

117 
if Gear^.DirAngle < 0 then Gear^.DirAngle:= Gear^.DirAngle + 360 
8fc7e59d9cb4
Convert the rest of rotated sprites to be rotated by OpenGL
unc0rr
parents:
764
diff
changeset

118 
else if 360 < Gear^.DirAngle then Gear^.DirAngle:= Gear^.DirAngle  360 
4  119 
end; 
120 

121 
//////////////////////////////////////////////////////////////////////////////// 

122 
procedure doStepDrowningGear(Gear: PGear); 

123 
begin 

124 
AllInactive:= false; 

351  125 
Gear^.Y:= Gear^.Y + cDrownSpeed; 
2228  126 
Gear^.X:= Gear^.X + Gear^.dX * cDrownSpeed; 
2143
ad05f6b2d1c0
New baseball bat sound, steam when fire lands on water (needs new hiss sound), bubbles when hedgehog drowns, more messages on
nemo
parents:
2142
diff
changeset

127 
if hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater then DeleteGear(Gear); 
ad05f6b2d1c0
New baseball bat sound, steam when fire lands on water (needs new hiss sound), bubbles when hedgehog drowns, more messages on
nemo
parents:
2142
diff
changeset

128 
// Create some bubbles (0.5% might be better but causes too few bubbles sometimes) 
2225  129 
if (GameTicks and $1F) = 0 then 
2376  130 
if (Gear^.Kind = gtHedgehog) and (Random(4) = 0) then 
2225  131 
AddVisualGear(hwRound(Gear^.X)  Gear^.Radius, hwRound(Gear^.Y)  Gear^.Radius, vgtBubble) 
132 
else if Random(12) = 0 then 

133 
AddVisualGear(hwRound(Gear^.X)  Gear^.Radius, hwRound(Gear^.Y)  Gear^.Radius, vgtBubble) 

4  134 
end; 
135 

136 
//////////////////////////////////////////////////////////////////////////////// 

137 
procedure doStepFallingGear(Gear: PGear); 

2455
cc54dd148cc2
Remove sheepluva's simple 45 deg bouncing from r2472, add various flame sizes for Tiy
nemo
parents:
2440
diff
changeset

138 
var isFalling: boolean; 
4  139 
begin 
503  140 
Gear^.State:= Gear^.State and not gstCollision; 
141 

142 
if Gear^.dY.isNegative then 

1133  143 
begin 
144 
isFalling:= true; 

145 
if TestCollisionYwithGear(Gear, 1) then 

146 
begin 

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

148 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 

149 
Gear^.State:= Gear^.State or gstCollision 

150 
end 

151 
end else 

152 
if TestCollisionYwithGear(Gear, 1) then 

153 
begin 

154 
isFalling:= false; 

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

156 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 

157 
Gear^.State:= Gear^.State or gstCollision 

158 
end else isFalling:= true; 

503  159 

351  160 
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then 
1133  161 
begin 
162 
Gear^.dX:=  Gear^.dX * Gear^.Elasticity; 

163 
Gear^.dY:= Gear^.dY * Gear^.Elasticity; 

164 
Gear^.State:= Gear^.State or gstCollision 

165 
end; 

503  166 

542  167 
if isFalling then Gear^.dY:= Gear^.dY + cGravity; 
503  168 

351  169 
Gear^.X:= Gear^.X + Gear^.dX; 
170 
Gear^.Y:= Gear^.Y + Gear^.dY; 

4  171 
CheckGearDrowning(Gear); 
503  172 
if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) < _0_0002) and 
1133  173 
(not isFalling) then 
174 
Gear^.State:= Gear^.State and not gstMoving 

175 
else 

176 
Gear^.State:= Gear^.State or gstMoving 

4  177 
end; 
178 

179 
//////////////////////////////////////////////////////////////////////////////// 

180 
procedure doStepBomb(Gear: PGear); 

371  181 
var i: LongInt; 
919  182 
dX, dY: hwFloat; 
2538
661079b00177
Just checking this in so prg can try it. May back it out
nemo
parents:
2524
diff
changeset

183 
Fire: PGear; 
4  184 
begin 
185 
AllInactive:= false; 

1263  186 

4  187 
doStepFallingGear(Gear); 
1263  188 

351  189 
dec(Gear^.Timer); 
2647  190 
if Gear^.Timer = 1000 then // might need adjustments 
191 
case Gear^.Kind of 

192 
gtAmmo_Bomb: makeHogsWorry(Gear^.X, Gear^.Y, 50); 

193 
gtClusterBomb: makeHogsWorry(Gear^.X, Gear^.Y, 20); 

194 
gtWatermelon: makeHogsWorry(Gear^.X, Gear^.Y, 75); 

195 
gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90); 

196 
end; 

351  197 
if Gear^.Timer = 0 then 
1133  198 
begin 
199 
case Gear^.Kind of 

200 
gtAmmo_Bomb: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 

1603  201 
gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound); 
1133  202 
gtClusterBomb: begin 
203 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound); 

204 
for i:= 0 to 4 do 

205 
begin 

206 
dX:= rndSign(GetRandom * _0_1); 

207 
dY:= (GetRandom  _3) * _0_08; 

1261  208 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25); 
209 
end 

210 
end; 

211 
gtWatermelon: begin 

212 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound); 

213 
for i:= 0 to 5 do 

214 
begin 

215 
dX:= rndSign(GetRandom * _0_1); 

1496  216 
dY:= (GetRandom  _1_5) * _0_3; 
1262  217 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60; 
1133  218 
end 
1263  219 
end; 
1555  220 
gtHellishBomb: begin 
221 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound); 

222 
for i:= 0 to 127 do 

223 
begin 

224 
dX:= AngleCos(i * 16) * _0_5 * (GetRandom + _1); 

225 
dY:= AngleSin(i * 16) * _0_5 * (GetRandom + _1); 

2538
661079b00177
Just checking this in so prg can try it. May back it out
nemo
parents:
2524
diff
changeset

226 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
661079b00177
Just checking this in so prg can try it. May back it out
nemo
parents:
2524
diff
changeset

227 
if i mod 2 = 0 then Fire^.State:= Fire^.State or gsttmpFlag; 
661079b00177
Just checking this in so prg can try it. May back it out
nemo
parents:
2524
diff
changeset

228 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
661079b00177
Just checking this in so prg can try it. May back it out
nemo
parents:
2524
diff
changeset

229 
if i mod 2 <> 0 then Fire^.State:= Fire^.State or gsttmpFlag; 
1555  230 
end 
231 
end; 

1133  232 
end; 
233 
DeleteGear(Gear); 

234 
exit 

235 
end; 

1263  236 

4  237 
CalcRotationDirAngle(Gear); 
1263  238 

239 
if Gear^.Kind = gtHellishBomb then 

1279  240 
begin 
1669  241 
if Gear^.Timer = 3000 then PlaySound(sndHellish, false, nil); 
1279  242 

1263  243 
if (GameTicks and $3F) = 0 then 
244 
if (Gear^.State and gstCollision) = 0 then 

245 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0); 

1279  246 
end; 
1263  247 

1158  248 
if (Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving) then 
249 
if (hwAbs(Gear^.dX) > _0_1) or 

250 
(hwAbs(Gear^.dY) > _0_1) then 

1669  251 
PlaySound(sndGrenadeImpact, false, nil) 
4  252 
end; 
2457
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

253 
//////////////////////////////////////////////////////////////////////////////// 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

254 
procedure doStepMolotov(Gear: PGear); 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

255 
var i: LongInt; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

256 
dX, dY: hwFloat; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

257 
Fire: PGear; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

258 
begin 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

259 
AllInactive:= false; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

260 

ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

261 
doStepFallingGear(Gear); 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

262 
CalcRotationDirAngle(Gear); 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

263 

ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

264 
if (Gear^.State and gstCollision) <> 0 then begin 
2470  265 
PlaySound(sndMolotov, false, nil); 
266 
//doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 5, EXPLAutoSound); 

2492
9e80b7fc4017
Tweak of molotov based on burp's play, a little bit more specificity in homerun.
nemo
parents:
2480
diff
changeset

267 
for i:= 0 to 20 do begin 
2512  268 
dX:= AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandom + _1); 
2468
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

269 
dY:= AngleSin(i * 8) * _0_5 * (GetRandom + _1); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

270 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

271 
Fire^.State:= Fire^.State or gsttmpFlag; 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

272 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

273 
Fire^.State:= Fire^.State or gsttmpFlag; 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

274 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

275 
Fire^.State:= Fire^.State or gsttmpFlag; 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

276 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

277 
Fire^.State:= Fire^.State or gsttmpFlag; 
2457
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

278 
end; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

279 
DeleteGear(Gear); 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

280 
exit 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

281 
end; 
ecf0c7e7995b
Initial molotov cocktail. Still needs graphics, tweaking of fire behaviour. Also changed probabilities for default weapon sets
nemo
parents:
2455
diff
changeset

282 
end; 
4  283 

1279  284 
procedure doStepWatermelon(Gear: PGear); 
285 
begin 

286 
AllInactive:= false; 

287 
Gear^.doStep:= @doStepBomb 

288 
end; 

289 

78  290 
procedure doStepCluster(Gear: PGear); 
291 
begin 

292 
AllInactive:= false; 

293 
doStepFallingGear(Gear); 

351  294 
if (Gear^.State and gstCollision) <> 0 then 
1133  295 
begin 
1261  296 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, EXPLAutoSound); 
1133  297 
DeleteGear(Gear); 
298 
exit 

299 
end; 

1262  300 

301 
if Gear^.Kind = gtMelonPiece then 

302 
CalcRotationDirAngle(Gear) 

303 
else 

304 
if (GameTicks and $1F) = 0 then 

305 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0) 

78  306 
end; 
307 

4  308 
//////////////////////////////////////////////////////////////////////////////// 
309 
procedure doStepGrenade(Gear: PGear); 

310 
begin 

311 
AllInactive:= false; 

351  312 
Gear^.dX:= Gear^.dX + cWindSpeed; 
4  313 
doStepFallingGear(Gear); 
351  314 
if (Gear^.State and gstCollision) <> 0 then 
1133  315 
begin 
316 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 

317 
DeleteGear(Gear); 

318 
exit 

319 
end; 

4  320 
if (GameTicks and $3F) = 0 then 
1133  321 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0) 
4  322 
end; 
323 

324 
//////////////////////////////////////////////////////////////////////////////// 

95  325 
procedure doStepHealthTagWork(Gear: PGear); 
4  326 
begin 
522  327 
if Gear^.Kind = gtHealthTag then 
1505  328 
AllInactive:= false; 
329 

351  330 
dec(Gear^.Timer); 
522  331 
Gear^.Y:= Gear^.Y + Gear^.dY; 
1505  332 

351  333 
if Gear^.Timer = 0 then 
1133  334 
begin 
2017  335 
if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then 
1133  336 
PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die 
337 
DeleteGear(Gear) 

338 
end 

4  339 
end; 
340 

263  341 
procedure doStepHealthTagWorkUnderWater(Gear: PGear); 
342 
begin 

1505  343 
AllInactive:= false; 
1495  344 

351  345 
Gear^.Y:= Gear^.Y  _0_08; 
1495  346 

498  347 
if hwRound(Gear^.Y) < cWaterLine + 10 then 
1505  348 
DeleteGear(Gear) 
263  349 
end; 
350 

95  351 
procedure doStepHealthTag(Gear: PGear); 
352 
var s: shortstring; 

353 
begin 

1505  354 
AllInactive:= false; 
355 
Gear^.dY:= _0_08; 

522  356 

351  357 
str(Gear^.State, s); 
1505  358 
Gear^.Tex:= RenderStringTex(s, PHedgehog(Gear^.Hedgehog)^.Team^.Clan^.Color, fnt16); 
359 

360 
if hwRound(Gear^.Y) < cWaterLine then 

361 
Gear^.doStep:= @doStepHealthTagWork 

362 
else 

363 
Gear^.doStep:= @doStepHealthTagWorkUnderWater; 

364 

762  365 
Gear^.Y:= Gear^.Y  int2hwFloat(Gear^.Tex^.h) 
95  366 
end; 
367 

4  368 
//////////////////////////////////////////////////////////////////////////////// 
369 
procedure doStepGrave(Gear: PGear); 

370 
begin 

371 
AllInactive:= false; 

498  372 
if Gear^.dY.isNegative then 
373 
if TestCollisionY(Gear, 1) then Gear^.dY:= _0; 

4  374 

351  375 
if not Gear^.dY.isNegative then 
68  376 
if TestCollisionY(Gear, 1) then 
4  377 
begin 
351  378 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 
379 
if Gear^.dY >  _1div1024 then 

4  380 
begin 
351  381 
Gear^.Active:= false; 
4  382 
exit 
1669  383 
end else if Gear^.dY <  _0_03 then PlaySound(sndGraveImpact, false, nil) 
4  384 
end; 
1505  385 

351  386 
Gear^.Y:= Gear^.Y + Gear^.dY; 
4  387 
CheckGearDrowning(Gear); 
351  388 
Gear^.dY:= Gear^.dY + cGravity 
4  389 
end; 
390 

391 
//////////////////////////////////////////////////////////////////////////////// 

392 
procedure doStepUFOWork(Gear: PGear); 

351  393 
var t: hwFloat; 
374  394 
y: LongInt; 
4  395 
begin 
396 
AllInactive:= false; 

351  397 
t:= Distance(Gear^.dX, Gear^.dY); 
398 
Gear^.dX:= Gear^.Elasticity * (Gear^.dX + _0_000004 * (TargetPoint.X  hwRound(Gear^.X))); 

399 
Gear^.dY:= Gear^.Elasticity * (Gear^.dY + _0_000004 * (TargetPoint.Y  hwRound(Gear^.Y))); 

400 
t:= t / Distance(Gear^.dX, Gear^.dY); 

401 
Gear^.dX:= Gear^.dX * t; 

402 
Gear^.dY:= Gear^.dY * t; 

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

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

374  405 

406 
if (GameTicks and $3F) = 0 then 

407 
begin 

408 
y:= hwRound(Gear^.Y); 

409 
if y + Gear^.Radius < cWaterLine then 

498  410 
AddGear(hwRound(Gear^.X), y, gtSmokeTrace, 0, _0, _0, 0); 
374  411 
end; 
412 

4  413 
CheckCollision(Gear); 
351  414 
dec(Gear^.Timer); 
415 
if ((Gear^.State and gstCollision) <> 0) or (Gear^.Timer = 0) then 

4  416 
begin 
560  417 
StopSound(sndUFO); 
351  418 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
4  419 
DeleteGear(Gear); 
420 
end; 

421 
end; 

422 

423 
procedure doStepUFO(Gear: PGear); 

424 
begin 

425 
AllInactive:= false; 

351  426 
Gear^.X:= Gear^.X + Gear^.dX; 
427 
Gear^.Y:= Gear^.Y + Gear^.dY; 

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

4  429 
CheckCollision(Gear); 
351  430 
if (Gear^.State and gstCollision) <> 0 then 
4  431 
begin 
351  432 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
4  433 
DeleteGear(Gear); 
434 
exit 

435 
end; 

351  436 
dec(Gear^.Timer); 
437 
if Gear^.Timer = 0 then 

4  438 
begin 
1669  439 
PlaySound(sndUFO, true, nil); 
351  440 
Gear^.Timer:= 5000; 
441 
Gear^.doStep:= @doStepUFOWork 

4  442 
end; 
443 
end; 

444 

445 
//////////////////////////////////////////////////////////////////////////////// 

876  446 
procedure doStepShotIdle(Gear: PGear); 
447 
begin 

448 
AllInactive:= false; 

449 
inc(Gear^.Timer); 

450 
if Gear^.Timer > 75 then 

451 
begin 

452 
DeleteGear(Gear); 

453 
AfterAttack 

454 
end 

455 
end; 

456 

4  457 
procedure doStepShotgunShot(Gear: PGear); 
458 
var i: LongWord; 

459 
begin 

460 
AllInactive:= false; 

876  461 

462 
if ((Gear^.State and gstAnimation) = 0) then 

463 
begin 

464 
dec(Gear^.Timer); 

465 
if Gear^.Timer = 0 then 

466 
begin 

1669  467 
PlaySound(sndShotgunFire, false, nil); 
876  468 
Gear^.State:= Gear^.State or gstAnimation 
469 
end; 

470 
exit 

471 
end 

472 
else inc(Gear^.Timer); 

473 

4  474 
i:= 200; 
475 
repeat 

351  476 
Gear^.X:= Gear^.X + Gear^.dX; 
477 
Gear^.Y:= Gear^.Y + Gear^.dY; 

4  478 
CheckCollision(Gear); 
351  479 
if (Gear^.State and gstCollision) <> 0 then 
876  480 
begin 
481 
Gear^.X:= Gear^.X + Gear^.dX * 8; 

482 
Gear^.Y:= Gear^.Y + Gear^.dY * 8; 

483 
ShotgunShot(Gear); 

484 
Gear^.doStep:= @doStepShotIdle; 

485 
exit 

486 
end; 

4  487 
dec(i) 
488 
until i = 0; 

1760  489 
if (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then 
876  490 
Gear^.doStep:= @doStepShotIdle 
4  491 
end; 
492 

493 
//////////////////////////////////////////////////////////////////////////////// 

2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

494 
procedure doStepBulletWork(Gear: PGear); 
38  495 
var i, x, y: LongWord; 
351  496 
oX, oY: hwFloat; 
38  497 
begin 
498 
AllInactive:= false; 

876  499 
inc(Gear^.Timer); 
37  500 
i:= 80; 
351  501 
oX:= Gear^.X; 
502 
oY:= Gear^.Y; 

37  503 
repeat 
351  504 
Gear^.X:= Gear^.X + Gear^.dX; 
505 
Gear^.Y:= Gear^.Y + Gear^.dY; 

506 
x:= hwRound(Gear^.X); 

507 
y:= hwRound(Gear^.Y); 

1753  508 
if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) 
351  509 
and (Land[y, x] <> 0) then inc(Gear^.Damage); 
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

510 
if Gear^.Damage > 5 then 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

511 
if Gear^.Ammo^.AmmoType = amDEagle then 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

512 
AmmoShove(Gear, 7, 20) 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

513 
else 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

514 
AmmoShove(Gear, Gear^.Timer, 20); 
38  515 
dec(i) 
351  516 
until (i = 0) or (Gear^.Damage > Gear^.Health); 
517 
if Gear^.Damage > 0 then 

37  518 
begin 
351  519 
DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 82  i, 1); 
520 
dec(Gear^.Health, Gear^.Damage); 

521 
Gear^.Damage:= 0 

37  522 
end; 
1760  523 

524 
if (Gear^.Health <= 0) 

525 
or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) 

526 
or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then 

2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

527 
begin 
2087  528 
if (Gear^.Kind = gtSniperRifleShot) and ((GameFlags and gfLaserSight) = 0) then cLaserSighting:= false; 
2608  529 
if (Gear^.Ammo^.NumPerTurn <= CurrentHedgehog^.MultiShootAttacks) and 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

530 
((GameFlags and gfArtillery) = 0) then cArtillery:= false; 
876  531 
Gear^.doStep:= @doStepShotIdle 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

532 
end; 
37  533 
end; 
534 

559  535 
procedure doStepDEagleShot(Gear: PGear); 
536 
begin 

1669  537 
PlaySound(sndGun, false, nil); 
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

538 
Gear^.doStep:= @doStepBulletWork 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

539 
end; 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

540 

41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

541 
procedure doStepSniperRifleShot(Gear: PGear); 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

542 
var HHGear: PGear; 
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

543 
begin 
2024
2985f3bd18b7
Disable long jump in artillery mode, make snipre rifle single shot
nemo
parents:
2023
diff
changeset

544 
cArtillery:= true; 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

545 
HHGear:=PHedgehog(Gear^.Hedgehog)^.Gear; 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

546 
HHGear^.State:= HHGear^.State or gstNotKickable; 
2033  547 
HedgehogChAngle(HHGear); 
2220  548 
if not cLaserSighting then // game does not have default laser sight. turn it on and give them a chance to aim 
2023
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

549 
begin 
41d3afaa20c7
Artillery mode, sniper rifle, speech bubble tweaks, fix of rope bug introduced by enabling hats in jump
nemo
parents:
2017
diff
changeset

550 
cLaserSighting:= true; 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

551 
HHGear^.Message:= 0; 
2052  552 
if(HHGear^.Angle  32 >= 0) then dec(HHGear^.Angle,32) 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

553 
end; 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

554 

b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

555 
if (HHGear^.Message and gm_Attack) <> 0 then 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

556 
begin 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

557 
Gear^.State:= Gear^.State or gstAnimation; 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

558 
Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX) * _0_5; 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

559 
Gear^.dY:= AngleCos(HHGear^.Angle) * _0_5; 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

560 
PlaySound(sndGun, false, nil); 
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

561 
Gear^.doStep:= @doStepBulletWork; 
2024
2985f3bd18b7
Disable long jump in artillery mode, make snipre rifle single shot
nemo
parents:
2023
diff
changeset

562 
end 
2985f3bd18b7
Disable long jump in artillery mode, make snipre rifle single shot
nemo
parents:
2023
diff
changeset

563 
else 
2031
b6f3e56fb100
david_ac's game scheme options for mine delay/quantity, tweaks to sniper rifle
nemo
parents:
2029
diff
changeset

564 
if (GameTicks mod 32) = 0 then 
2376  565 
if (GameTicks mod 4096) < 2048 then 
2052  566 
begin 
567 
if(HHGear^.Angle + 1 <= cMaxAngle) then inc(HHGear^.Angle) 

568 
end 

569 
else 

570 
if(HHGear^.Angle  1 >= 0) then dec(HHGear^.Angle); 

2024
2985f3bd18b7
Disable long jump in artillery mode, make snipre rifle single shot
nemo
parents:
2023
diff
changeset

571 

2376  572 
if (TurnTimeLeft > 0) then 
2058  573 
dec(TurnTimeLeft) 
574 
else 

575 
begin 

576 
DeleteGear(Gear); 

2608  577 
AfterAttack 
2058  578 
end; 
559  579 
end; 
580 

37  581 
//////////////////////////////////////////////////////////////////////////////// 
4  582 
procedure doStepActionTimer(Gear: PGear); 
583 
begin 

351  584 
dec(Gear^.Timer); 
585 
case Gear^.Kind of 

83  586 
gtATStartGame: begin 
4  587 
AllInactive:= false; 
351  588 
if Gear^.Timer = 0 then 
2619  589 
AddCaption(trmsg[sidStartFight], cWhiteColor, capgrpGameState); 
4  590 
end; 
83  591 
gtATSmoothWindCh: begin 
351  592 
if Gear^.Timer = 0 then 
6  593 
begin 
351  594 
if WindBarWidth < Gear^.Tag then inc(WindBarWidth) 
595 
else if WindBarWidth > Gear^.Tag then dec(WindBarWidth); 

596 
if WindBarWidth <> Gear^.Tag then Gear^.Timer:= 10; 

83  597 
end 
598 
end; 

599 
gtATFinishGame: begin 

600 
AllInactive:= false; 

351  601 
if Gear^.Timer = 0 then 
113  602 
begin 
603 
SendIPC('N'); 

324
f4c109c82a0c
Don't show game stats in case of interrupted by command '/quit' game
unc0rr
parents:
306
diff
changeset

604 
SendIPC('q'); 
83  605 
GameState:= gsExit 
113  606 
end 
6  607 
end; 
4  608 
end; 
351  609 
if Gear^.Timer = 0 then DeleteGear(Gear) 
4  610 
end; 
611 

612 
//////////////////////////////////////////////////////////////////////////////// 

613 
procedure doStepPickHammerWork(Gear: PGear); 

371  614 
var i, ei: LongInt; 
4  615 
HHGear: PGear; 
616 
begin 

70  617 
AllInactive:= false; 
351  618 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
619 
dec(Gear^.Timer); 

620 
if (Gear^.Timer = 0)or((Gear^.Message and gm_Destroy) <> 0)or((HHGear^.State and gstHHDriven) = 0) then 

1200  621 
begin 
622 
StopSound(sndPickhammer); 

623 
DeleteGear(Gear); 

624 
AfterAttack; 

625 
exit 

626 
end; 

845  627 

422  628 
if (Gear^.Timer mod 33) = 0 then 
1200  629 
begin 
630 
HHGear^.State:= HHGear^.State or gstNoDamage; 

631 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y) + 7, 6, EXPLDontDraw); 

632 
HHGear^.State:= HHGear^.State and not gstNoDamage 

633 
end; 

422  634 

635 
if (Gear^.Timer mod 47) = 0 then 

1200  636 
begin 
637 
i:= hwRound(Gear^.X)  Gear^.Radius  LongInt(GetRandom(2)); 

638 
ei:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2)); 

639 
while i <= ei do 

640 
begin 

641 
DrawExplosion(i, hwRound(Gear^.Y) + 3, 3); 

642 
inc(i, 1) 

643 
end; 

2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

644 

e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

645 
if CheckLandValue(hwRound(Gear^.X + Gear^.dX + SignAs(_6,Gear^.dX)), hwRound(Gear^.Y + _1_9), COLOR_INDESTRUCTIBLE) then 
2090
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

646 
begin 
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

647 
Gear^.X:= Gear^.X + Gear^.dX; 
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

648 
Gear^.Y:= Gear^.Y + _1_9; 
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

649 
end; 
1200  650 
SetAllHHToActive; 
651 
end; 

4  652 
if TestCollisionYwithGear(Gear, 1) then 
1200  653 
begin 
654 
Gear^.dY:= _0; 

655 
SetLittle(HHGear^.dX); 

656 
HHGear^.dY:= _0; 

657 
end else 

658 
begin 

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

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

1417  661 
if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer:= 1 
1200  662 
end; 
4  663 

351  664 
Gear^.X:= Gear^.X + HHGear^.dX; 
665 
HHGear^.X:= Gear^.X; 

498  666 
HHGear^.Y:= Gear^.Y  int2hwFloat(cHHRadius); 
4  667 

351  668 
if (Gear^.Message and gm_Attack) <> 0 then 
669 
if (Gear^.State and gsttmpFlag) <> 0 then Gear^.Timer:= 1 else else 

670 
if (Gear^.State and gsttmpFlag) = 0 then Gear^.State:= Gear^.State or gsttmpFlag; 

671 
if ((Gear^.Message and gm_Left) <> 0) then Gear^.dX:=  _0_3 else 

672 
if ((Gear^.Message and gm_Right) <> 0) then Gear^.dX:= _0_3 

498  673 
else Gear^.dX:= _0; 
4  674 
end; 
675 

676 
procedure doStepPickHammer(Gear: PGear); 

371  677 
var i, y: LongInt; 
4  678 
ar: TRangeArray; 
911
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

679 
HHGear: PGear; 
4  680 
begin 
681 
i:= 0; 

911
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

682 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

683 

498  684 
y:= hwRound(Gear^.Y)  cHHRadius * 2; 
351  685 
while y < hwRound(Gear^.Y) do 
4  686 
begin 
371  687 
ar[i].Left := hwRound(Gear^.X)  Gear^.Radius  LongInt(GetRandom(2)); 
688 
ar[i].Right:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2)); 

4  689 
inc(y, 2); 
690 
inc(i) 

691 
end; 

911
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

692 

498  693 
DrawHLinesExplosions(@ar, 3, hwRound(Gear^.Y)  cHHRadius * 2, 2, Pred(i)); 
911
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

694 
Gear^.dY:= HHGear^.dY; 
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

695 
DeleteCI(HHGear); 
b709fe13ed69
Fix issue with hedgehog on top of the hedgehog with pickhammer
unc0rr
parents:
883
diff
changeset

696 

1669  697 
PlaySound(sndPickhammer, true, nil); 
4  698 
doStepPickHammerWork(Gear); 
351  699 
Gear^.doStep:= @doStepPickHammerWork 
4  700 
end; 
701 

702 
//////////////////////////////////////////////////////////////////////////////// 

371  703 
var BTPrevAngle, BTSteps: LongInt; 
302  704 

303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

705 
procedure doStepBlowTorchWork(Gear: PGear); 
302  706 
var HHGear: PGear; 
1528  707 
b: boolean; 
708 
prevX: LongInt; 

302  709 
begin 
710 
AllInactive:= false; 

351  711 
dec(Gear^.Timer); 
712 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 

303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

713 

1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

714 
HedgehogChAngle(HHGear); 
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

715 

305  716 
b:= false; 
717 

371  718 
if abs(LongInt(HHGear^.Angle)  BTPrevAngle) > 7 then 
1528  719 
begin 
720 
Gear^.dX:= SignAs(AngleSin(HHGear^.Angle) * _0_5, HHGear^.dX); 

721 
Gear^.dY:= AngleCos(HHGear^.Angle) * (  _0_5); 

722 
BTPrevAngle:= HHGear^.Angle; 

723 
b:= true 

724 
end; 

725 

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

727 
begin 

728 
doStepHedgehogMoving(HHGear); 

1736  729 
if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer:= 0 
1528  730 
end; 
305  731 

351  732 
if Gear^.Timer mod cHHStepTicks = 0 then 
1528  733 
begin 
734 
b:= true; 

735 
if Gear^.dX.isNegative then 

1547  736 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Left 
1528  737 
else 
1547  738 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Right; 
305  739 

1528  740 
if ((HHGear^.State and gstMoving) = 0) then 
741 
begin 

742 
HHGear^.State:= HHGear^.State and not gstAttacking; 

743 
prevX:= hwRound(HHGear^.X); 

2376  744 

745 
// why the call to HedgehogStep then a further increment of X? 

746 
if (prevX = hwRound(HHGear^.X)) and 

2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

747 
CheckLandValue(hwRound(HHGear^.X + SignAs(_6, HHGear^.dX)), hwRound(HHGear^.Y), COLOR_INDESTRUCTIBLE) then HedgehogStep(HHGear); 
2376  748 

749 
if (prevX = hwRound(HHGear^.X)) and 

2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

750 
CheckLandValue(hwRound(HHGear^.X + SignAs(_6, HHGear^.dX)), hwRound(HHGear^.Y), COLOR_INDESTRUCTIBLE) then HHGear^.X:= HHGear^.X + SignAs(_1, HHGear^.dX); 
1528  751 
HHGear^.State:= HHGear^.State or gstAttacking 
752 
end; 

305  753 

1528  754 
inc(BTSteps); 
755 
if BTSteps = 7 then 

756 
begin 

757 
BTSteps:= 0; 

2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

758 
if CheckLandValue(hwRound(HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC) + SignAs(_6,Gear^.dX)), hwRound(HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC)), COLOR_INDESTRUCTIBLE) then 
2090
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

759 
begin 
2331
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

760 
Gear^.X:= HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC); 
e4941a7986d6
Another try at keeping blowtorch/firepunch/jackhammer from going through indestructible stuff. Shame these routines don't use hedgehog movement
nemo
parents:
2329
diff
changeset

761 
Gear^.Y:= HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC); 
2090
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

762 
end; 
1528  763 
HHGear^.State:= HHGear^.State or gstNoDamage; 
1643  764 
AmmoShove(Gear, 2, 15); 
1528  765 
HHGear^.State:= HHGear^.State and not gstNoDamage 
766 
end; 

767 
end; 

305  768 

769 
if b then 

498  770 
DrawTunnel(HHGear^.X  Gear^.dX * cHHRadius, HHGear^.Y  _4  Gear^.dY * cHHRadius + hwAbs(Gear^.dY) * 7, 
351  771 
Gear^.dX, Gear^.dY, 
1501  772 
cHHRadius * 5, cHHRadius * 2 + 7); 
305  773 

2090
4edb0d49a42d
prevent unc0rr from getting clever with jackhammer too. bring blowtorch into line with the other  should be more fun anyway
nemo
parents:
2089
diff
changeset

774 
if (Gear^.Timer = 0) or ((HHGear^.Message and gm_Attack) <> 0) then 
1528  775 
begin 
776 
HHGear^.Message:= 0; 

777 
HHGear^.State:= HHGear^.State and (not gstNotKickable); 

778 
DeleteGear(Gear); 

779 
AfterAttack 

780 
end 

302  781 
end; 
782 

303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

783 
procedure doStepBlowTorch(Gear: PGear); 
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

784 
var HHGear: PGear; 
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

785 
begin 
371  786 
BTPrevAngle:= High(LongInt); 
305  787 
BTSteps:= 0; 
351  788 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
789 
HHGear^.Message:= 0; 

1528  790 
HHGear^.State:= HHGear^.State or gstNotKickable; 
351  791 
Gear^.doStep:= @doStepBlowTorchWork 
303
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

792 
end; 
1659c4aad5ab
Now blow torch angle can be changed during blowing :)
unc0rr
parents:
302
diff
changeset

793 

302  794 
//////////////////////////////////////////////////////////////////////////////// 
795 

1781  796 
procedure doStepRope(Gear: PGear); forward; 
797 

798 
procedure doStepRopeAfterAttack(Gear: PGear); 

799 
var HHGear: PGear; 

800 
begin 

801 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 

802 
if ((HHGear^.State and gstHHDriven) = 0) 

803 
or (CheckGearDrowning(HHGear)) 

804 
or TestCollisionYwithGear(HHGear, 1) then 

805 
begin 

806 
DeleteGear(Gear); 

2060
3e9e5e1be6f5
fix crash in parachute/rope if drowning with active girder/teleport
nemo
parents:
2059
diff
changeset

807 
isCursorVisible:= false; 
1781  808 
exit 
809 
end; 

810 

1785  811 
HedgehogChAngle(HHGear); 
812 

2283  813 
if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX); 
2029  814 

1781  815 
if HHGear^.dY.isNegative and TestCollisionYwithGear(HHGear, 1) then HHGear^.dY:= _0; 
816 
HHGear^.X:= HHGear^.X + HHGear^.dX; 

817 
HHGear^.Y:= HHGear^.Y + HHGear^.dY; 

818 
HHGear^.dY:= HHGear^.dY + cGravity; 

819 

820 
if (Gear^.Message and gm_Attack) <> 0 then 

821 
begin 

822 
Gear^.X:= HHGear^.X; 

823 
Gear^.Y:= HHGear^.Y; 

1964  824 

825 
ApplyAngleBounds(PHedgehog(Gear^.Hedgehog)^, amRope); 

2376  826 

1781  827 
Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX); 
828 
Gear^.dY:= AngleCos(HHGear^.Angle); 

829 
Gear^.Friction:= _450; 

830 
Gear^.Elasticity:= _0; 

831 
Gear^.State:= Gear^.State and not gsttmpflag; 

832 
Gear^.doStep:= @doStepRope 

833 
end 

834 
end; 

835 

4  836 
procedure doStepRopeWork(Gear: PGear); 
837 
var HHGear: PGear; 

1669  838 
len, tx, ty, nx, ny, ropeDx, ropeDy, mdX, mdY: hwFloat; 
1504  839 
lx, ly: LongInt; 
1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

840 
haveCollision, 
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

841 
haveDivided: boolean; 
4  842 

1504  843 
procedure DeleteMe; 
844 
begin 

845 
with HHGear^ do 

846 
begin 

847 
Message:= Message and not gm_Attack; 

2025
692308790912
Adjust routines impacted by DrawRotatedF modification, clear gstHHHJump in rope to avoid crosshair/hat drawing bug.
nemo
parents:
2024
diff
changeset

848 
State:= (State or gstMoving) and not gstWinner; 
1504  849 
end; 
850 
DeleteGear(Gear) 

851 
end; 

4  852 

1781  853 
procedure WaitCollision; 
854 
begin 

855 
with HHGear^ do 

856 
begin 

857 
Message:= Message and not gm_Attack; 

858 
State:= State or gstMoving; 

859 
end; 

860 
RopePoints.Count:= 0; 

861 
Gear^.Elasticity:= _0; 

862 
Gear^.doStep:= @doStepRopeAfterAttack 

863 
end; 

864 

4  865 
begin 
351  866 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
108  867 

351  868 
if ((HHGear^.State and gstHHDriven) = 0) 
1504  869 
or (CheckGearDrowning(HHGear)) then 
870 
begin 

871 
DeleteMe; 

872 
exit 

873 
end; 

928
b9064b48b001
Some preparation work for attacking from rope, parachute and etc.
unc0rr
parents:
925
diff
changeset

874 

351  875 
if (Gear^.Message and gm_Left <> 0) then HHGear^.dX:= HHGear^.dX  _0_0002 else 
876 
if (Gear^.Message and gm_Right <> 0) then HHGear^.dX:= HHGear^.dX + _0_0002; 

4  877 

351  878 
if not TestCollisionYwithGear(HHGear, 1) then HHGear^.dY:= HHGear^.dY + cGravity; 
4  879 

1652  880 
ropeDx:= HHGear^.X  Gear^.X; // vector between hedgehog and rope attaching point 
881 
ropeDy:= HHGear^.Y  Gear^.Y; 

882 

883 
mdX:= ropeDx + HHGear^.dX; 

884 
mdY:= ropeDy + HHGear^.dY; 

885 
len:= _1 / Distance(mdX, mdY); 

886 
mdX:= mdX * len; // rope vector plus hedgehog direction vector normalized 

887 
mdY:= mdY * len; 

888 

889 
Gear^.dX:= mdX; // for visual purposes only 

890 
Gear^.dY:= mdY; 

891 

892 
///// 

893 
tx:= HHGear^.X; 

894 
ty:= HHGear^.Y; 

4  895 

1652  896 
if ((Gear^.Message and gm_Down) <> 0) and (Gear^.Elasticity < Gear^.Friction) then 
897 
if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx)) 

898 
or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then 

899 
Gear^.Elasticity:= Gear^.Elasticity + _0_3; 

900 

901 
if ((Gear^.Message and gm_Up) <> 0) and (Gear^.Elasticity > _30) then 

902 
if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx)) 

903 
or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then 

904 
Gear^.Elasticity:= Gear^.Elasticity  _0_3; 

905 

906 
HHGear^.X:= Gear^.X + mdX * Gear^.Elasticity; 

907 
HHGear^.Y:= Gear^.Y + mdY * Gear^.Elasticity; 

908 

909 
HHGear^.dX:= HHGear^.X  tx; 

910 
HHGear^.dY:= HHGear^.Y  ty; 

911 
//// 

912 

1554  913 

1922  914 
haveDivided:= false; 
1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

915 
// check whether rope needs dividing 
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

916 
len:= _1 / Distance(ropeDx, ropeDy); // old rope pos 
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

917 
nx:= ropeDx * len; 
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

918 
ny:= ropeDy * len; 
2376  919 

1652  920 
len:= Gear^.Elasticity  _0_3x70; 
2365  921 
while len > _3 do 
1504  922 
begin 
1652  923 
lx:= hwRound(Gear^.X + mdX * len); 
924 
ly:= hwRound(Gear^.Y + mdY * len); 

1753  925 
if ((ly and LAND_HEIGHT_MASK) = 0) and ((lx and LAND_WIDTH_MASK) = 0) and (Land[ly, lx] <> 0) then 
1504  926 
begin 
927 
with RopePoints.ar[RopePoints.Count] do 

928 
begin 

929 
X:= Gear^.X; 

930 
Y:= Gear^.Y; 

1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

931 
if RopePoints.Count = 0 then RopePoints.HookAngle:= DxDy2Angle(Gear^.dY, Gear^.dX); 
1652  932 
b:= (nx * HHGear^.dY) > (ny * HHGear^.dX); 
1504  933 
dLen:= len 
934 
end; 

2365  935 
with RopePoints.rounded[RopePoints.Count] do 
936 
begin 

937 
X:= hwRound(Gear^.X); 

938 
Y:= hwRound(Gear^.Y); 

939 
end; 

2376  940 

1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

941 
Gear^.X:= Gear^.X + nx * len; 
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

942 
Gear^.Y:= Gear^.Y + ny * len; 
1504  943 
inc(RopePoints.Count); 
944 
TryDo(RopePoints.Count <= MAXROPEPOINTS, 'Rope points overflow', true); 

945 
Gear^.Elasticity:= Gear^.Elasticity  len; 

946 
Gear^.Friction:= Gear^.Friction  len; 

1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

947 
haveDivided:= true; 
1504  948 
break 
949 
end; 

1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

950 
len:= len  _0_3 // should be the same as increase step 
1504  951 
end; 
1553
77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

952 

77f326c7f0ef
The best final fix for rope stucking in the ground bug
unc0rr
parents:
1552
diff
changeset

953 
if not haveDivided then 
1504  954 
if RopePoints.Count > 0 then // check whether the last dividing point could be removed 
955 
begin 

956 
tx:= RopePoints.ar[Pred(RopePoints.Count)].X; 

957 
ty:= RopePoints.ar[Pred(RopePoints.Count)].Y; 

958 
if RopePoints.ar[Pred(RopePoints.Count)].b xor ((tx  Gear^.X) * (ty  HHGear^.Y) > (tx  HHGear^.X) * (ty  Gear^.Y)) then 

959 
begin 

960 
dec(RopePoints.Count); 

1652  961 
Gear^.X:= RopePoints.ar[RopePoints.Count].X; 
962 
Gear^.Y:= RopePoints.ar[RopePoints.Count].Y; 

1504  963 
Gear^.Elasticity:= Gear^.Elasticity + RopePoints.ar[RopePoints.Count].dLen; 
964 
Gear^.Friction:= Gear^.Friction + RopePoints.ar[RopePoints.Count].dLen 

965 
end 

966 
end; 

4  967 

1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

968 
haveCollision:= false; 
351  969 
if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

970 
begin 
1504  971 
HHGear^.dX:= _0_6 * HHGear^.dX; 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

972 
haveCollision:= true 
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

973 
end; 
351  974 
if TestCollisionYwithGear(HHGear, hwSign(HHGear^.dY)) then 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

975 
begin 
1504  976 
HHGear^.dY:= _0_6 * HHGear^.dY; 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

977 
haveCollision:= true 
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

978 
end; 
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

979 

1579
2f581b1f289e
More bouncy rope, but you need to press vertical arrow and horizontal keys at once to bounce
unc0rr
parents:
1573
diff
changeset

980 
if haveCollision 
2f581b1f289e
More bouncy rope, but you need to press vertical arrow and horizontal keys at once to bounce
unc0rr
parents:
1573
diff
changeset

981 
and (Gear^.Message and (gm_Left or gm_Right) <> 0) 
2f581b1f289e
More bouncy rope, but you need to press vertical arrow and horizontal keys at once to bounce
unc0rr
parents:
1573
diff
changeset

982 
and (Gear^.Message and (gm_Up or gm_Down) <> 0) then 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

983 
begin 
1579
2f581b1f289e
More bouncy rope, but you need to press vertical arrow and horizontal keys at once to bounce
unc0rr
parents:
1573
diff
changeset

984 
HHGear^.dX:= SignAs(hwAbs(HHGear^.dX) + _0_2, HHGear^.dX); 
2f581b1f289e
More bouncy rope, but you need to press vertical arrow and horizontal keys at once to bounce
unc0rr
parents:
1573
diff
changeset

985 
HHGear^.dY:= SignAs(hwAbs(HHGear^.dY) + _0_2, HHGear^.dY) 
1551
c747e69f98f3
Add some speed to hedgehog on rope when colliding with land and pressing left or right arrow key
unc0rr
parents:
1548
diff
changeset

986 
end; 
4  987 

789  988 
len:= Distance(HHGear^.dX, HHGear^.dY); 
940  989 
if len > _0_8 then 
1504  990 
begin 
991 
len:= _0_8 / len; 

992 
HHGear^.dX:= HHGear^.dX * len; 

993 
HHGear^.dY:= HHGear^.dY * len; 

994 
end; 

789  995 

351  996 
if (Gear^.Message and gm_Attack) <> 0 then 
1504  997 
if (Gear^.State and gsttmpFlag) <> 0 then 
1922  998 
with PHedgehog(Gear^.Hedgehog)^ do 
1964  999 
if Ammo^[CurSlot, CurAmmo].AmmoType <> amParachute then 
1922  1000 
WaitCollision 
1001 
else 

1002 
DeleteMe 

1504  1003 
else 
1004 
else 

1005 
if (Gear^.State and gsttmpFlag) = 0 then 

1006 
Gear^.State:= Gear^.State or gsttmpFlag; 

4  1007 
end; 
1008 

1009 
procedure doStepRopeAttach(Gear: PGear); 

1010 
var HHGear: PGear; 

1781  1011 
tx, ty, tt: hwFloat; 
1012 

1013 
procedure RemoveFromAmmo; 

1014 
begin 

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

1016 
begin 

1017 
OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^); 

1018 
Gear^.State:= Gear^.State or gstAttacked 

1964  1019 
end; 
1020 
ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^) 

1781  1021 
end; 
2376  1022 

4  1023 
begin 
351  1024 
Gear^.X:= Gear^.X  Gear^.dX; 
1025 
Gear^.Y:= Gear^.Y  Gear^.dY; 

498  1026 
Gear^.Elasticity:= Gear^.Elasticity + _1; 
2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1027 

351  1028 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
517  1029 
DeleteCI(HHGear); 
2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1030 

542  1031 
if (HHGear^.State and gstMoving) <> 0 then 
1433  1032 
begin 
2282  1033 
if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX); 
2329
1cfb7d184ee1
Fix bug with hedgehog getting into ground while throwing rope (http://hedgewars.org/node/1722)
unc0rr
parents:
2301
diff
changeset

1034 
if HHGear^.dY.isNegative and TestCollisionYwithGear(HHGear, 1) then HHGear^.dY:= _0; 
2376  1035 

1433  1036 
HHGear^.X:= HHGear^.X + HHGear^.dX; 
1037 
Gear^.X:= Gear^.X + HHGear^.dX; 

2281
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1038 

3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1039 
if TestCollisionYwithGear(HHGear, 1) then 
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1040 
begin 
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1041 
CheckHHDamage(HHGear); 
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1042 
HHGear^.dY:= _0; 
2339  1043 
//HHGear^.State:= HHGear^.State and not (gstHHJumping or gstHHHJump); 
2281
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1044 
end else 
1433  1045 
begin 
2281
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1046 
HHGear^.Y:= HHGear^.Y + HHGear^.dY; 
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1047 
Gear^.Y:= Gear^.Y + HHGear^.dY; 
3217f0d8c420
Fix hedgehog stopping to slide when throwing rope (not tested)
unc0rr
parents:
2280
diff
changeset

1048 
HHGear^.dY:= HHGear^.dY + cGravity; 
2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1049 
end; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1050 

0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1051 
tt:= Gear^.Elasticity; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1052 
tx:= _0; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1053 
ty:= _0; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1054 
while tt > _20 do 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1055 
begin 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1056 
if TestCollisionXwithXYShift(Gear, tx, hwRound(ty), hwSign(Gear^.dX)) 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1057 
or TestCollisionYwithXYShift(Gear, hwRound(tx), hwRound(ty), hwSign(Gear^.dY)) then 
1433  1058 
begin 
2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1059 
Gear^.X:= Gear^.X + tx; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1060 
Gear^.Y:= Gear^.Y + ty; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1061 
Gear^.Elasticity:= tt; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1062 
Gear^.doStep:= @doStepRopeWork; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1063 
with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump); 
2376  1064 

2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1065 
RemoveFromAmmo; 
2376  1066 

2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1067 
tt:= _0; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1068 
exit 
1433  1069 
end; 
2524
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1070 
tx:= tx + Gear^.dX + Gear^.dX; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1071 
ty:= ty + Gear^.dY + Gear^.dY; 
0b075d38fee5
Fix bug when rope goes through land when hedgehog is sliding
unc0rr
parents:
2515
diff
changeset

1072 
tt:= tt  _2; 
1433  1073 
end; 
1074 
end; 

929
9456e1e77369
 Continue preparation for implementing attack from rope and parachute
unc0rr
parents:
928
diff
changeset

1075 

4  1076 
CheckCollision(Gear); 
929
9456e1e77369
 Continue preparation for implementing attack from rope and parachute
unc0rr
parents:
928
diff
changeset

1077 

351  1078 
if (Gear^.State and gstCollision) <> 0 then 
2068  1079 
if Gear^.Elasticity < _10 then 
1080 
Gear^.Elasticity:= _10000 

1081 
else 

1082 
begin 

1083 
Gear^.doStep:= @doStepRopeWork; 

2339  1084 
with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump); 
929
9456e1e77369
 Continue preparation for implementing attack from rope and parachute
unc0rr
parents:
928
diff
changeset

1085 

2068  1086 
RemoveFromAmmo; 
2376  1087 

2068  1088 
exit 
1089 
end; 

4  1090 

1634
486a89f0e843
Fix rope bug which allowed hedgehog to go into land
unc0rr
parents:
1633
diff
changeset

1091 
if (Gear^.Elasticity > Gear^.Friction) 
486a89f0e843
Fix rope bug which allowed hedgehog to go into land
unc0rr
parents:
1633
diff
changeset

1092 
or ((Gear^.Message and gm_Attack) = 0) 
2280  1093 
or ((HHGear^.State and gstHHDriven) = 0) 
1634
486a89f0e843
Fix rope bug which allowed hedgehog to go into land
unc0rr
parents:
1633
diff
changeset

1094 
or (HHGear^.Damage > 0) then 
1433  1095 
begin 
1096 
with PHedgehog(Gear^.Hedgehog)^.Gear^ do 

1097 
begin 

1098 
State:= State and not gstAttacking; 

1099 
Message:= Message and not gm_Attack 

1100 
end; 

1101 
DeleteGear(Gear) 

1102 
end 

4  1103 
end; 
1104 

1105 
procedure doStepRope(Gear: PGear); 

1106 
begin 

351  1107 
Gear^.dX:=  Gear^.dX; 
1108 
Gear^.dY:=  Gear^.dY; 

1109 
Gear^.doStep:= @doStepRopeAttach 

4  1110 
end; 
1111 

1112 
//////////////////////////////////////////////////////////////////////////////// 

1113 
procedure doStepSmokeTrace(Gear: PGear); 

1114 
begin 

351  1115 
inc(Gear^.Timer); 
1116 
if Gear^.Timer > 64 then 

1133  1117 
begin 
1118 
Gear^.Timer:= 0; 

1119 
dec(Gear^.State) 

1120 
end; 

351  1121 
Gear^.dX:= Gear^.dX + cWindSpeed; 
1122 
Gear^.X:= Gear^.X + Gear^.dX; 

1123 
if Gear^.State = 0 then DeleteGear(Gear) 

4  1124 
end; 
9  1125 

1126 
//////////////////////////////////////////////////////////////////////////////// 

1045  1127 
procedure doStepExplosionWork(Gear: PGear); 
9  1128 
begin 
351  1129 
inc(Gear^.Timer); 
1130 
if Gear^.Timer > 75 then 

1133  1131 
begin 
1132 
inc(Gear^.State); 

1133 
Gear^.Timer:= 0; 

1134 
if Gear^.State > 5 then DeleteGear(Gear) 

1135 
end; 

9  1136 
end; 
10  1137 

1045  1138 
procedure doStepExplosion(Gear: PGear); 
1139 
var i: LongWord; 

1140 
begin 

1047  1141 
for i:= 0 to 31 do AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtFire); 
1142 
for i:= 0 to 8 do AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtExplPart); 

1143 
for i:= 0 to 8 do AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtExplPart2); 

1045  1144 
Gear^.doStep:= @doStepExplosionWork 
1145 
end; 

1146 

10  1147 
//////////////////////////////////////////////////////////////////////////////// 
1148 
procedure doStepMine(Gear: PGear); 

1149 
begin 

542  1150 
if (Gear^.State and gstMoving) <> 0 then 
914  1151 
begin 
1152 
DeleteCI(Gear); 

1153 
doStepFallingGear(Gear); 

1154 
if (Gear^.State and gstMoving) = 0 then 

1155 
begin 

1156 
AddGearCI(Gear); 

1157 
Gear^.dX:= _0; 

1158 
Gear^.dY:= _0 

1159 
end; 

1160 
CalcRotationDirAngle(Gear); 

1161 
AllInactive:= false 

1162 
end else 

1163 
if ((GameTicks and $3F) = 25) then 

1164 
doStepFallingGear(Gear); 

351  1165 

1166 
if ((Gear^.State and gsttmpFlag) <> 0) then 

1133  1167 
if ((Gear^.State and gstAttacking) = 0) then 
1168 
begin 

1169 
if ((GameTicks and $1F) = 0) then 

1170 
if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State:= Gear^.State or gstAttacking 

1171 
end else // gstAttacking <> 0 

1172 
begin 

1173 
AllInactive:= false; 

1669  1174 
if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick, false, nil); 
1133  1175 
if Gear^.Timer = 0 then 
1176 
begin 

1177 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 

1178 
DeleteGear(Gear); 

1179 
exit 

1180 
end; 

1181 
dec(Gear^.Timer); 

1182 
end else // gsttmpFlag = 0 

1183 
if TurnTimeLeft = 0 then Gear^.State:= Gear^.State or gsttmpFlag; 

10  1184 
end; 
57  1185 

39  1186 
//////////////////////////////////////////////////////////////////////////////// 
1187 
procedure doStepDynamite(Gear: PGear); 

1188 
begin 

43  1189 
doStepFallingGear(Gear); 
1190 
AllInactive:= false; 

351  1191 
if Gear^.Timer mod 166 = 0 then inc(Gear^.Tag); 
2647  1192 
if Gear^.Timer = 1000 then // might need better timing 
1193 
makeHogsWorry(Gear^.X, Gear^.Y, 75); 

351  1194 
if Gear^.Timer = 0 then 
1133  1195 
begin 
1196 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound); 

1197 
DeleteGear(Gear); 

1198 
exit 

1199 
end; 

351  1200 
dec(Gear^.Timer); 
39  1201 
end; 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1202 

351  1203 
/////////////////////////////////////////////////////////////////////////////// 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1204 
procedure doStepCase(Gear: PGear); 
371  1205 
var i, x, y: LongInt; 
1436  1206 
k: TGearType; 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1207 
begin 
351  1208 
if (Gear^.Message and gm_Destroy) > 0 then 
1133  1209 
begin 
1210 
DeleteGear(Gear); 

1211 
FreeActionsList; 

1212 
SetAllToActive; // something (hh, mine, etc...) could be on top of the case 

1213 
with CurrentHedgehog^ do 

1214 
if Gear <> nil then Gear^.Message:= Gear^.Message and not (gm_LJump or gm_HJump); 

1215 
exit 

1216 
end; 

15  1217 

351  1218 
if Gear^.Damage > 0 then 
1133  1219 
begin 
1220 
x:= hwRound(Gear^.X); 

1221 
y:= hwRound(Gear^.Y); 

1436  1222 
k:= Gear^.Kind; 
1223 
DeleteGear(Gear); // < delete gear! 

2376  1224 

1436  1225 
if k = gtCase then 
1133  1226 
begin 
1227 
doMakeExplosion(x, y, 25, EXPLAutoSound); 

1228 
for i:= 0 to 63 do 

1229 
AddGear(x, y, gtFlame, 0, _0, _0, 0); 

1230 
end; 

1231 
exit 

1232 
end; 

79  1233 

351  1234 
if (Gear^.dY.QWordValue <> 0) or (not TestCollisionYwithGear(Gear, 1)) then 
1133  1235 
begin 
1236 
AllInactive:= false; 

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

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

1239 
if (Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then Gear^.dY:= _0 else 

1240 
if (not Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then 

1241 
begin 

1242 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 

1243 
if Gear^.dY >  _0_001 then Gear^.dY:= _0 

1669  1244 
else if Gear^.dY <  _0_03 then PlaySound(sndGraveImpact, false, nil); 
1133  1245 
end; 
1246 
CheckGearDrowning(Gear); 

1247 
end; 

14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1248 

511  1249 
if (Gear^.dY.QWordValue = 0) then AddGearCI(Gear) 
1133  1250 
else if (Gear^.dY.QWordValue <> 0) then DeleteCI(Gear) 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1251 
end; 
49  1252 

1253 
//////////////////////////////////////////////////////////////////////////////// 

2460  1254 

1255 
procedure doStepTarget(Gear: PGear); 

1256 
begin 

1257 
if (Gear^.Timer = 0) and (Gear^.Tag = 0) then 

1258 
PlaySound(sndWarp, false, nil); 

1259 

1260 
if (Gear^.Tag = 0) and (Gear^.Timer < 1000) then 

1261 
inc(Gear^.Timer) 

1262 
else if Gear^.Tag = 1 then 

2468
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1263 
begin 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1264 
Gear^.Tag:= 2; 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1265 
if (TrainingFlags and tfTimeTrial) <> 0 then 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1266 
begin 
2460  1267 
inc(TurnTimeLeft, TrainingTimeInc); 
1268 

1269 
if TrainingTimeInc > TrainingTimeInM then 

1270 
dec(TrainingTimeInc, TrainingTimeInD); 

1271 
if TurnTimeLeft > TrainingTimeMax then 

1272 
TurnTimeLeft:= TrainingTimeMax; 

2468
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1273 
end; 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1274 
end 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1275 
else if Gear^.Tag = 2 then 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1276 
if Gear^.Timer > 0 then 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1277 
dec(Gear^.Timer) 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1278 
else 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1279 
begin 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1280 
if (TrainingFlags and tfTargetRespawn) <> 0 then 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1281 
begin 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1282 
TrainingTargetGear:= AddGear(0, 0, gtTarget, 0, _0, _0, 0); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1283 
FindPlace(TrainingTargetGear, false, 0, LAND_WIDTH); 
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1284 
end; 
2460  1285 
DeleteGear(Gear); 
1286 
exit; 

1287 
end; 

1288 

1289 
doStepCase(Gear) 

1290 
end; 

1291 

1292 
//////////////////////////////////////////////////////////////////////////////// 

854  1293 
procedure doStepIdle(Gear: PGear); 
1294 
begin 

1295 
AllInactive:= false; 

925  1296 
dec(Gear^.Timer); 
854  1297 
if Gear^.Timer = 0 then 
1298 
begin 

1299 
DeleteGear(Gear); 

1300 
AfterAttack 

1301 
end 

1302 
end; 

1303 

79  1304 
procedure doStepShover(Gear: PGear); 
1305 
var HHGear: PGear; 

1306 
begin 

351  1307 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
1308 
HHGear^.State:= HHGear^.State or gstNoDamage; 

980
20128e98988b
Don't push attacking hedgehog when using whip or baseball
unc0rr
parents:
979
diff
changeset

1309 
DeleteCI(HHGear); 
20128e98988b
Don't push attacking hedgehog when using whip or baseball
unc0rr
parents:
979
diff
changeset

1310 

79  1311 
AmmoShove(Gear, 30, 115); 
980
20128e98988b
Don't push attacking hedgehog when using whip or baseball
unc0rr
parents:
979
diff
changeset

1312 

351  1313 
HHGear^.State:= HHGear^.State and not gstNoDamage; 
854  1314 
Gear^.Timer:= 250; 
1315 
Gear^.doStep:= @doStepIdle 

79  1316 
end; 
1317 

1318 
//////////////////////////////////////////////////////////////////////////////// 

925  1319 
procedure doStepWhip(Gear: PGear); 
1320 
var HHGear: PGear; 

1321 
i: LongInt; 

1322 
begin 

1323 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 

1324 
HHGear^.State:= HHGear^.State or gstNoDamage; 

980
20128e98988b
Don't push attacking hedgehog when using whip or baseball
unc0rr
parents:
979
diff
changeset

1325 
DeleteCI(HHGear); 
925  1326 

1327 
for i:= 0 to 3 do 

1328 
begin 

1329 
AmmoShove(Gear, 30, 25); 

1330 
Gear^.X:= Gear^.X + Gear^.dX * 5 

1331 
end; 

1332 

1333 
HHGear^.State:= HHGear^.State and not gstNoDamage; 

1334 
Gear^.Timer:= 250; 

1335 
Gear^.doStep:= @doStepIdle 

1336 
end; 

1337 

1338 
//////////////////////////////////////////////////////////////////////////////// 

79  1339 
procedure doStepFlame(Gear: PGear); 
2143
ad05f6b2d1c0
New baseball bat sound, steam when fire lands on water (needs new hiss sound), bubbles when hedgehog drowns, more messages on
nemo
parents:
2142
diff
changeset

1340 
var i: Integer; 
79  1341 
begin 
2424
b52344de23ae
In progress, trying to make a fire for molotov cocktail. Normal fire should still work fairly normally.
nemo
parents:
2376
diff
changeset

1342 
if (Gear^.State and gsttmpFlag) = 0 then AllInactive:= false; 
1433  1343 

79  1344 
if not TestCollisionYwithGear(Gear, 1) then 
1133  1345 
begin 
2634  1346 
AllInactive:= false; 
1586  1347 
if hwAbs(Gear^.dX) > _0_01 then 
1348 
Gear^.dX:= Gear^.dX * _0_995; 

2468
0b62498c201a
openal fix, training map selection and rcplane adjustments from Smaxx (untested, but look reasonable). Bunch of new graphics from Tiy, new translation for ptpt from inu_
nemo
parents:
2462
diff
changeset

1349 
if (Gear^.State and gsttmpFlag) <> 0 then Gear^.dY:= Gear^.dY + _2*cGravity else 
1133  1350 
Gear^.dY:= Gear^.dY + cGravity; 
1830  1351 
if hwAbs(Gear^.dY) > _0_2 then Gear^.dY:= Gear^.dY * _0_995; 
2376  1352 

2468 