author  nemo 
Thu, 04 Mar 2010 19:35:27 +0000  
changeset 2932  9bc0cf3c7ac1 
parent 2915  a02f276035e8 
child 2933  02af54eb7e1e 
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 

2745  30 
PlaySound(sndOops, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 
2647  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 

2745  36 
PlaySound(sndNooo, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 
2647  37 
else 
2745  38 
PlaySound(sndUhOh, PHedgehog(gi^.Hedgehog)^.Team^.voicepack); 
2647  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; 
2745  77 
PlaySound(sndSplash) 
1918  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); 

2848  91 
var 
92 
dmg: Longword; 

93 
i: LongInt; 

94 
particle: PVisualGear; 

4  95 
begin 
522  96 
if _0_4 < Gear^.dY then 
1123  97 
begin 
2730
f56592281526
Remove king invulnerability, disable everything but teleport instead.
nemo
parents:
2726
diff
changeset

98 
dmg:= ModifyDamage(1 + hwRound((hwAbs(Gear^.dY)  _0_4) * 70), Gear); 
f56592281526
Remove king invulnerability, disable everything but teleport instead.
nemo
parents:
2726
diff
changeset

99 
if dmg < 1 then exit; 
f56592281526
Remove king invulnerability, disable everything but teleport instead.
nemo
parents:
2726
diff
changeset

100 

2871
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

101 
for i:= min(12, (3 + dmg div 10)) downto 0 do begin 
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

102 
particle := AddVisualGear(hwRound(Gear^.X)  5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); 
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

103 
if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX / 5); 
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

104 
end; 
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

105 

eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

106 
if(Gear^.Invulnerable) then exit; 
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

107 

1123  108 
if _0_6 < Gear^.dY then 
2745  109 
PlaySound(sndOw4, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack) 
1123  110 
else 
2745  111 
PlaySound(sndOw1, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack); 
1123  112 

2871
eec42a0b7014
rearrange fall damage a bit so invulnerability still causes dust
nemo
parents:
2859
diff
changeset

113 
ApplyDamage(Gear, dmg); 
1123  114 
end 
4  115 
end; 
116 

117 
//////////////////////////////////////////////////////////////////////////////// 

118 
//////////////////////////////////////////////////////////////////////////////// 

119 
procedure CalcRotationDirAngle(Gear: PGear); 

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

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

122 
dAngle:= (hwAbs(Gear^.dX) + hwAbs(Gear^.dY)).QWordValue / $80000000; 
1133  123 
if not Gear^.dX.isNegative then 
124 
Gear^.DirAngle:= Gear^.DirAngle + dAngle 

125 
else 

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

127 

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

128 
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

129 
else if 360 < Gear^.DirAngle then Gear^.DirAngle:= Gear^.DirAngle  360 
4  130 
end; 
131 

132 
//////////////////////////////////////////////////////////////////////////////// 

133 
procedure doStepDrowningGear(Gear: PGear); 

134 
begin 

135 
AllInactive:= false; 

351  136 
Gear^.Y:= Gear^.Y + cDrownSpeed; 
2228  137 
Gear^.X:= Gear^.X + Gear^.dX * cDrownSpeed; 
2840
bb9117753fe4
Skip drawing some stuff if water is opaque. Affects simulation.
nemo
parents:
2828
diff
changeset

138 
if (cWaterOpacity > $FE) or (hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater) then DeleteGear(Gear); 
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

139 
// Create some bubbles (0.5% might be better but causes too few bubbles sometimes) 
2840
bb9117753fe4
Skip drawing some stuff if water is opaque. Affects simulation.
nemo
parents:
2828
diff
changeset

140 
if (cWaterOpacity < $FF) and ((GameTicks and $1F) = 0) then 
2376  141 
if (Gear^.Kind = gtHedgehog) and (Random(4) = 0) then 
2225  142 
AddVisualGear(hwRound(Gear^.X)  Gear^.Radius, hwRound(Gear^.Y)  Gear^.Radius, vgtBubble) 
143 
else if Random(12) = 0 then 

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

4  145 
end; 
146 

147 
//////////////////////////////////////////////////////////////////////////////// 

148 
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

149 
var isFalling: boolean; 
4  150 
begin 
503  151 
Gear^.State:= Gear^.State and not gstCollision; 
152 

153 
if Gear^.dY.isNegative then 

1133  154 
begin 
155 
isFalling:= true; 

156 
if TestCollisionYwithGear(Gear, 1) then 

157 
begin 

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

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

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

161 
end 

162 
end else 

163 
if TestCollisionYwithGear(Gear, 1) then 

164 
begin 

165 
isFalling:= false; 

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

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

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

169 
end else isFalling:= true; 

503  170 

351  171 
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then 
1133  172 
begin 
173 
Gear^.dX:=  Gear^.dX * Gear^.Elasticity; 

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

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

176 
end; 

503  177 

542  178 
if isFalling then Gear^.dY:= Gear^.dY + cGravity; 
503  179 

351  180 
Gear^.X:= Gear^.X + Gear^.dX; 
181 
Gear^.Y:= Gear^.Y + Gear^.dY; 

4  182 
CheckGearDrowning(Gear); 
503  183 
if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) < _0_0002) and 
1133  184 
(not isFalling) then 
185 
Gear^.State:= Gear^.State and not gstMoving 

186 
else 

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

4  188 
end; 
189 

190 
//////////////////////////////////////////////////////////////////////////////// 

191 
procedure doStepBomb(Gear: PGear); 

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

194 
Fire: PGear; 
4  195 
begin 
196 
AllInactive:= false; 

1263  197 

4  198 
doStepFallingGear(Gear); 
1263  199 

351  200 
dec(Gear^.Timer); 
2647  201 
if Gear^.Timer = 1000 then // might need adjustments 
202 
case Gear^.Kind of 

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

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

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

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

207 
end; 

351  208 
if Gear^.Timer = 0 then 
1133  209 
begin 
210 
case Gear^.Kind of 

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

1603  212 
gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound); 
1133  213 
gtClusterBomb: begin 
214 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound); 

215 
for i:= 0 to 4 do 

216 
begin 

217 
dX:= rndSign(GetRandom * _0_1); 

218 
dY:= (GetRandom  _3) * _0_08; 

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

221 
end; 

222 
gtWatermelon: begin 

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

224 
for i:= 0 to 5 do 

225 
begin 

226 
dX:= rndSign(GetRandom * _0_1); 

1496  227 
dY:= (GetRandom  _1_5) * _0_3; 
1262  228 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60; 
1133  229 
end 
1263  230 
end; 
1555  231 
gtHellishBomb: begin 
232 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound); 

233 
for i:= 0 to 127 do 

234 
begin 

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

236 
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

237 
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

238 
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

239 
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

240 
if i mod 2 <> 0 then Fire^.State:= Fire^.State or gsttmpFlag; 
1555  241 
end 
242 
end; 

1133  243 
end; 
244 
DeleteGear(Gear); 

245 
exit 

246 
end; 

1263  247 

4  248 
CalcRotationDirAngle(Gear); 
1263  249 

250 
if Gear^.Kind = gtHellishBomb then 

1279  251 
begin 
2745  252 
if Gear^.Timer = 3000 then PlaySound(sndHellish); 
1279  253 

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

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

1279  257 
end; 
1263  258 

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

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

2745  262 
PlaySound(sndGrenadeImpact) 
4  263 
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

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

265 
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

266 
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

267 
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

268 
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

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

270 
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

271 

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

272 
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

273 
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

274 

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

275 
if (Gear^.State and gstCollision) <> 0 then begin 
2745  276 
PlaySound(sndMolotov); 
2470  277 
//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

278 
for i:= 0 to 20 do begin 
2512  279 
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

280 
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

281 
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

282 
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

283 
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

284 
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

285 
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

286 
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

287 
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

288 
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

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

290 
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

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

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

293 
end; 
4  294 

1279  295 
procedure doStepWatermelon(Gear: PGear); 
296 
begin 

297 
AllInactive:= false; 

298 
Gear^.doStep:= @doStepBomb 

299 
end; 

300 

78  301 
procedure doStepCluster(Gear: PGear); 
302 
begin 

303 
AllInactive:= false; 

304 
doStepFallingGear(Gear); 

351  305 
if (Gear^.State and gstCollision) <> 0 then 
1133  306 
begin 
1261  307 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, EXPLAutoSound); 
1133  308 
DeleteGear(Gear); 
309 
exit 

310 
end; 

1262  311 

312 
if Gear^.Kind = gtMelonPiece then 

313 
CalcRotationDirAngle(Gear) 

314 
else 

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

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

78  317 
end; 
318 

4  319 
//////////////////////////////////////////////////////////////////////////////// 
320 
procedure doStepGrenade(Gear: PGear); 

321 
begin 

322 
AllInactive:= false; 

351  323 
Gear^.dX:= Gear^.dX + cWindSpeed; 
4  324 
doStepFallingGear(Gear); 
351  325 
if (Gear^.State and gstCollision) <> 0 then 
1133  326 
begin 
327 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 

328 
DeleteGear(Gear); 

329 
exit 

330 
end; 

4  331 
if (GameTicks and $3F) = 0 then 
1133  332 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0) 
4  333 
end; 
334 

335 
//////////////////////////////////////////////////////////////////////////////// 

95  336 
procedure doStepHealthTagWork(Gear: PGear); 
4  337 
begin 
522  338 
if Gear^.Kind = gtHealthTag then 
1505  339 
AllInactive:= false; 
340 

351  341 
dec(Gear^.Timer); 
522  342 
Gear^.Y:= Gear^.Y + Gear^.dY; 
1505  343 

351  344 
if Gear^.Timer = 0 then 
1133  345 
begin 
2017  346 
if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then 
1133  347 
PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die 
348 
DeleteGear(Gear) 

349 
end 

4  350 
end; 
351 

263  352 
procedure doStepHealthTagWorkUnderWater(Gear: PGear); 
353 
begin 

1505  354 
AllInactive:= false; 
1495  355 

351  356 
Gear^.Y:= Gear^.Y  _0_08; 
1495  357 

498  358 
if hwRound(Gear^.Y) < cWaterLine + 10 then 
1505  359 
DeleteGear(Gear) 
263  360 
end; 
361 

95  362 
procedure doStepHealthTag(Gear: PGear); 
363 
var s: shortstring; 

364 
begin 

1505  365 
AllInactive:= false; 
366 
Gear^.dY:= _0_08; 

522  367 

351  368 
str(Gear^.State, s); 
1505  369 
Gear^.Tex:= RenderStringTex(s, PHedgehog(Gear^.Hedgehog)^.Team^.Clan^.Color, fnt16); 
370 

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

372 
Gear^.doStep:= @doStepHealthTagWork 

373 
else 

374 
Gear^.doStep:= @doStepHealthTagWorkUnderWater; 

375 

762  376 
Gear^.Y:= Gear^.Y  int2hwFloat(Gear^.Tex^.h) 
95  377 
end; 
378 

4  379 
//////////////////////////////////////////////////////////////////////////////// 
380 
procedure doStepGrave(Gear: PGear); 

381 
begin 

382 
AllInactive:= false; 

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

4  385 

351  386 
if not Gear^.dY.isNegative then 
68  387 
if TestCollisionY(Gear, 1) then 
4  388 
begin 
351  389 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 
390 
if Gear^.dY >  _1div1024 then 

4  391 
begin 
351  392 
Gear^.Active:= false; 
4  393 
exit 
2745  394 
end else if Gear^.dY <  _0_03 then PlaySound(sndGraveImpact) 
4  395 
end; 
1505  396 

351  397 
Gear^.Y:= Gear^.Y + Gear^.dY; 
4  398 
CheckGearDrowning(Gear); 
351  399 
Gear^.dY:= Gear^.dY + cGravity 
4  400 
end; 
401 

402 
//////////////////////////////////////////////////////////////////////////////// 

403 
procedure doStepUFOWork(Gear: PGear); 

351  404 
var t: hwFloat; 
374  405 
y: LongInt; 
4  406 
begin 
407 
AllInactive:= false; 

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

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

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

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

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

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

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

374  416 

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

418 
begin 

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

420 
if y + Gear^.Radius < cWaterLine then 

498  421 
AddGear(hwRound(Gear^.X), y, gtSmokeTrace, 0, _0, _0, 0); 
374  422 
end; 
423 

4  424 
CheckCollision(Gear); 
351  425 
dec(Gear^.Timer); 
426 
if ((Gear^.State and gstCollision) <> 0) or (Gear^.Timer = 0) then 

4  427 
begin 
2745  428 
StopSound(Gear^.SoundChannel); 
351  429 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
4  430 
DeleteGear(Gear); 
431 
end; 

432 
end; 

433 

434 
procedure doStepUFO(Gear: PGear); 

435 
begin 

436 
AllInactive:= false; 

351  437 
Gear^.X:= Gear^.X + Gear^.dX; 
438 
Gear^.Y:= Gear^.Y + Gear^.dY; 

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

4  440 
CheckCollision(Gear); 
351  441 
if (Gear^.State and gstCollision) <> 0 then 
4  442 
begin 
351  443 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
4  444 
DeleteGear(Gear); 
445 
exit 

446 
end; 

351  447 
dec(Gear^.Timer); 
448 
if Gear^.Timer = 0 then 

4  449 
begin 
2745  450 
Gear^.SoundChannel:= LoopSound(sndUFO); 
351  451 
Gear^.Timer:= 5000; 
452 
Gear^.doStep:= @doStepUFOWork 

4  453 
end; 
454 
end; 

455 

456 
//////////////////////////////////////////////////////////////////////////////// 

876  457 
procedure doStepShotIdle(Gear: PGear); 
458 
begin 

459 
AllInactive:= false; 

460 
inc(Gear^.Timer); 

461 
if Gear^.Timer > 75 then 

462 
begin 

463 
DeleteGear(Gear); 

464 
AfterAttack 

465 
end 

466 
end; 

467 

4  468 
procedure doStepShotgunShot(Gear: PGear); 
469 
var i: LongWord; 

2828  470 
shell: PVisualGear; 
4  471 
begin 
472 
AllInactive:= false; 

876  473 

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

475 
begin 

476 
dec(Gear^.Timer); 

477 
if Gear^.Timer = 0 then 

478 
begin 

2745  479 
PlaySound(sndShotgunFire); 
2828  480 
shell:= AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell); 
2858  481 
if shell <> nil then 
482 
begin 

483 
shell^.dX:= gear^.dX / 4; 

484 
shell^.dY:= gear^.dY / 4; 

485 
shell^.Frame:= 0 

486 
end; 

876  487 
Gear^.State:= Gear^.State or gstAnimation 
488 
end; 

489 
exit 

490 
end 

491 
else inc(Gear^.Timer); 

492 

4  493 
i:= 200; 
494 
repeat 

351  495 
Gear^.X:= Gear^.X + Gear^.dX; 
496 
Gear^.Y:= Gear^.Y + Gear^.dY; 

4  497 
CheckCollision(Gear); 
351  498 
if (Gear^.State and gstCollision) <> 0 then 
876  499 
begin 
500 
Gear^.X:= Gear^.X + Gear^.dX * 8; 

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

502 
ShotgunShot(Gear); 

503 
Gear^.doStep:= @doStepShotIdle; 

504 
exit 

505 
end; 

4  506 
dec(i) 
507 
until i = 0; 

1760  508 
if (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then 
876  509 
Gear^.doStep:= @doStepShotIdle 
4  510 
end; 
511 

512 
//////////////////////////////////////////////////////////////////////////////// 

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

513 
procedure doStepBulletWork(Gear: PGear); 
38  514 
var i, x, y: LongWord; 
351  515 
oX, oY: hwFloat; 
38  516 
begin 
517 
AllInactive:= false; 

876  518 
inc(Gear^.Timer); 
37  519 
i:= 80; 
351  520 
oX:= Gear^.X; 
521 
oY:= Gear^.Y; 

37  522 
repeat 
351  523 
Gear^.X:= Gear^.X + Gear^.dX; 
524 
Gear^.Y:= Gear^.Y + Gear^.dY; 

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

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

1753  527 
if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) 
351  528 
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

529 
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

530 
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

531 
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

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

533 
AmmoShove(Gear, Gear^.Timer, 20); 
38  534 
dec(i) 
351  535 
until (i = 0) or (Gear^.Damage > Gear^.Health); 
536 
if Gear^.Damage > 0 then 

37  537 
begin 
351  538 
DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 82  i, 1); 
539 
dec(Gear^.Health, Gear^.Damage); 

540 
Gear^.Damage:= 0 

37  541 
end; 
1760  542 

543 
if (Gear^.Health <= 0) 

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

545 
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

546 
begin 
2087  547 
if (Gear^.Kind = gtSniperRifleShot) and ((GameFlags and gfLaserSight) = 0) then cLaserSighting:= false; 
2608  548 
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

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

551 
end; 
37  552 
end; 
553 

559  554 
procedure doStepDEagleShot(Gear: PGear); 
555 
begin 

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

557 
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

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

559 

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

560 
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

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

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

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

565 
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

566 
HHGear^.State:= HHGear^.State or gstNotKickable; 
2033  567 
HedgehogChAngle(HHGear); 
2220  568 
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

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

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

571 
HHGear^.Message:= 0; 
2052  572 
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

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

574 

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

575 
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

576 
begin 
2828  577 
shell:= AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell); 
2859  578 
if shell <> nil then 
579 
begin 

580 
shell^.dX:= gear^.dX / 2; 

581 
shell^.dY:= gear^.dY / 2; 

582 
shell^.Frame:= 1 

583 
end; 

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

585 
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

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

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

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

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

591 
if (GameTicks mod 32) = 0 then 
2376  592 
if (GameTicks mod 4096) < 2048 then 
2052  593 
begin 
594 
if(HHGear^.Angle + 1 <= cMaxAngle) then inc(HHGear^.Angle) 

595 
end 

596 
else 

597 
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

598 

2376  599 
if (TurnTimeLeft > 0) then 
2058  600 
dec(TurnTimeLeft) 
601 
else 

602 
begin 

603 
DeleteGear(Gear); 

2608  604 
AfterAttack 
2058  605 
end; 
559  606 
end; 
607 

37  608 
//////////////////////////////////////////////////////////////////////////////// 
4  609 
procedure doStepActionTimer(Gear: PGear); 
610 
begin 

351  611 
dec(Gear^.Timer); 
612 
case Gear^.Kind of 

83  613 
gtATStartGame: begin 
4  614 
AllInactive:= false; 
351  615 
if Gear^.Timer = 0 then 
2619  616 
AddCaption(trmsg[sidStartFight], cWhiteColor, capgrpGameState); 
4  617 
end; 
83  618 
gtATSmoothWindCh: begin 
351  619 
if Gear^.Timer = 0 then 
6  620 
begin 
351  621 
if WindBarWidth < Gear^.Tag then inc(WindBarWidth) 
622 
else if WindBarWidth > Gear^.Tag then dec(WindBarWidth); 

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

83  624 
end 
625 
end; 

626 
gtATFinishGame: begin 

627 
AllInactive:= false; 

351  628 
if Gear^.Timer = 0 then 
113  629 
begin 
630 
SendIPC('N'); 

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

631 
SendIPC('q'); 
83  632 
GameState:= gsExit 
113  633 
end 
6  634 
end; 
4  635 
end; 
351  636 
if Gear^.Timer = 0 then DeleteGear(Gear) 
4  637 
end; 
638 

639 
//////////////////////////////////////////////////////////////////////////////// 

640 
procedure doStepPickHammerWork(Gear: PGear); 

371  641 
var i, ei: LongInt; 
4  642 
HHGear: PGear; 
643 
begin 

70  644 
AllInactive:= false; 
351  645 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
646 
dec(Gear^.Timer); 

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

1200  648 
begin 
2745  649 
StopSound(Gear^.SoundChannel); 
1200  650 
DeleteGear(Gear); 
651 
AfterAttack; 

652 
exit 

653 
end; 

845  654 

422  655 
if (Gear^.Timer mod 33) = 0 then 
1200  656 
begin 
657 
HHGear^.State:= HHGear^.State or gstNoDamage; 

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

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

660 
end; 

422  661 

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

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

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

666 
while i <= ei do 

667 
begin 

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

669 
inc(i, 1) 

670 
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

671 

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

672 
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

673 
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

674 
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

675 
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

676 
end; 
1200  677 
SetAllHHToActive; 
678 
end; 

4  679 
if TestCollisionYwithGear(Gear, 1) then 
1200  680 
begin 
681 
Gear^.dY:= _0; 

682 
SetLittle(HHGear^.dX); 

683 
HHGear^.dY:= _0; 

684 
end else 

685 
begin 

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

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

1417  688 
if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer:= 1 
1200  689 
end; 
4  690 

351  691 
Gear^.X:= Gear^.X + HHGear^.dX; 
692 
HHGear^.X:= Gear^.X; 

498  693 
HHGear^.Y:= Gear^.Y  int2hwFloat(cHHRadius); 
4  694 

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

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

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

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

498  700 
else Gear^.dX:= _0; 
4  701 
end; 
702 

703 
procedure doStepPickHammer(Gear: PGear); 

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

706 
HHGear: PGear; 
4  707 
begin 
708 
i:= 0; 

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

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

710 

498  711 
y:= hwRound(Gear^.Y)  cHHRadius * 2; 
351  712 
while y < hwRound(Gear^.Y) do 
4  713 
begin 
371  714 
ar[i].Left := hwRound(Gear^.X)  Gear^.Radius  LongInt(GetRandom(2)); 
715 
ar[i].Right:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2)); 

4  716 
inc(y, 2); 
717 
inc(i) 

718 
end; 

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

719 

498  720 
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

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

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

723 

2745  724 
Gear^.SoundChannel:= LoopSound(sndPickhammer); 
4  725 
doStepPickHammerWork(Gear); 
351  726 
Gear^.doStep:= @doStepPickHammerWork 
4  727 
end; 
728 

729 
//////////////////////////////////////////////////////////////////////////////// 

371  730 
var BTPrevAngle, BTSteps: LongInt; 
302  731 

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

732 
procedure doStepBlowTorchWork(Gear: PGear); 
302  733 
var HHGear: PGear; 
1528  734 
b: boolean; 
735 
prevX: LongInt; 

302  736 
begin 
737 
AllInactive:= false; 

351  738 
dec(Gear^.Timer); 
739 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 

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

740 

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

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

742 

305  743 
b:= false; 
744 

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

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

749 
BTPrevAngle:= HHGear^.Angle; 

750 
b:= true 

751 
end; 

752 

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

754 
begin 

755 
doStepHedgehogMoving(HHGear); 

1736  756 
if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer:= 0 
1528  757 
end; 
305  758 

351  759 
if Gear^.Timer mod cHHStepTicks = 0 then 
1528  760 
begin 
761 
b:= true; 

762 
if Gear^.dX.isNegative then 

1547  763 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Left 
1528  764 
else 
1547  765 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Right; 
305  766 

1528  767 
if ((HHGear^.State and gstMoving) = 0) then 
768 
begin 

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

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

2376  771 

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

773 
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

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

776 
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

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

305  780 

1528  781 
inc(BTSteps); 
782 
if BTSteps = 7 then 

783 
begin 

784 
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

785 
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

786 
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

787 
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

788 
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

789 
end; 
1528  790 
HHGear^.State:= HHGear^.State or gstNoDamage; 
1643  791 
AmmoShove(Gear, 2, 15); 
1528  792 
HHGear^.State:= HHGear^.State and not gstNoDamage 
793 
end; 

794 
end; 

305  795 

796 
if b then 

498  797 
DrawTunnel(HHGear^.X  Gear^.dX * cHHRadius, HHGear^.Y  _4  Gear^.dY * cHHRadius + hwAbs(Gear^.dY) * 7, 
351  798 
Gear^.dX, Gear^.dY, 
1501  799 
cHHRadius * 5, cHHRadius * 2 + 7); 
305  800 

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

801 
if (Gear^.Timer = 0) or ((HHGear^.Message and gm_Attack) <> 0) then 
1528  802 
begin 
803 
HHGear^.Message:= 0; 

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

805 
DeleteGear(Gear); 

806 
AfterAttack 

807 
end 

302  808 
end; 
809 

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

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

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

812 
begin 
371  813 
BTPrevAngle:= High(LongInt); 
305  814 
BTSteps:= 0; 
351  815 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
816 
HHGear^.Message:= 0; 

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

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

820 

302  821 
//////////////////////////////////////////////////////////////////////////////// 
822 

1781  823 
procedure doStepRope(Gear: PGear); forward; 
824 

825 
procedure doStepRopeAfterAttack(Gear: PGear); 

826 
var HHGear: PGear; 

827 
begin 

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

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

830 
or (CheckGearDrowning(HHGear)) 

831 
or TestCollisionYwithGear(HHGear, 1) then 

832 
begin 

833 
DeleteGear(Gear); 

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

834 
isCursorVisible:= false; 
1781  835 
exit 
836 
end; 

837 

1785  838 
HedgehogChAngle(HHGear); 
839 

2283  840 
if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX); 
2029  841 

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

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

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

846 

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

848 
begin 

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

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

1964  851 

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

2376  853 

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

856 
Gear^.Friction:= _450; 

857 
Gear^.Elasticity:= _0; 

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

859 
Gear^.doStep:= @doStepRope 

860 
end 

861 
end; 

862 

4  863 
procedure doStepRopeWork(Gear: PGear); 
864 
var HHGear: PGear; 

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

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

868 
haveDivided: boolean; 
4  869 

1504  870 
procedure DeleteMe; 
871 
begin 

872 
with HHGear^ do 

873 
begin 

874 
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

875 
State:= (State or gstMoving) and not gstWinner; 
1504  876 
end; 
877 
DeleteGear(Gear) 

878 
end; 

4  879 

1781  880 
procedure WaitCollision; 
881 
begin 

882 
with HHGear^ do 

883 
begin 

884 
Message:= Message and not gm_Attack; 

885 
State:= State or gstMoving; 

886 
end; 

887 
RopePoints.Count:= 0; 

888 
Gear^.Elasticity:= _0; 

889 
Gear^.doStep:= @doStepRopeAfterAttack 

890 
end; 

891 

4  892 
begin 
351  893 
HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear; 
108  894 

351  895 
if ((HHGear^.State and gstHHDriven) = 0) 
1504  896 
or (CheckGearDrowning(HHGear)) then 
897 
begin 

898 
DeleteMe; 

899 
exit 

900 
end; 

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

901 

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

4  904 

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

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

909 

910 
mdX:= ropeDx + HHGear^.dX; 

911 
mdY:= ropeDy + HHGear^.dY; 

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

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

914 
mdY:= mdY * len; 

915 

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

917 
Gear^.dY:= mdY; 

918 

919 
///// 

920 
tx:= HHGear^.X; 

921 
ty:= HHGear^.Y; 

4  922 

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

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

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

927 

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

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

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

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

932 

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

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

935 

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

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

938 
//// 

939 

1554  940 

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

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

943 
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

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

945 
ny:= ropeDy * len; 
2376  946 

1652  947 
len:= Gear^.Elasticity  _0_3x70; 
2365  948 
while len > _3 do 
1504  949 
begin 
1652  950 
lx:= hwRound(Gear^.X + mdX * len); 
951 
ly:= hwRound(Gear^.Y + mdY * len); 

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

955 
begin 

956 
X:= Gear^.X; 

957 
Y:= Gear^.Y; 

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

958 
if RopePoints.Count = 0 then RopePoints.HookAngle:= DxDy2Angle(Gear^.dY, Gear^.dX); 
1652  959 
b:= (nx * HHGear^.dY) > (ny * HHGear^.dX); 
1504  960 
dLen:= len 
961 
end; 

2365  962 
with RopePoints.rounded[RopePoints.Count] do 
963 
begin 

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

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

966 
end; 

2376  967 

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

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

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

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

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

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

974 
haveDivided:= true; 
1504  975 
break 
976 
end; 

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

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

979 

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

980 
if not haveDivided then 
1504  981 
if RopePoints.Count > 0 then // check whether the last dividing point could be removed 
982 
begin 

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

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

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

986 
begin 

987 
dec(RopePoints.Count); 

1652  988 
Gear^.X:= RopePoints.ar[RopePoints.Count].X; 
989 
Gear^.Y:= RopePoints.ar[RopePoints.Count].Y; 

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

992 
end 

993 
end; 

4  994 

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

995 
haveCollision:= false; 
351  996 
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

997 
begin 
1504  998 
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

999 
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

1000 
end; 
351  1001 
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

1002 
begin 
1504  1003 
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

1004 
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

1005 
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

1006 

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

1007 
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

1008 
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

1009 
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

1010 
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

1011 
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

1012 
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

1013 
end; 
4  1014 

789  1015 
len:= Distance(HHGear^.dX, HHGear^.dY); 
940  1016 
if len > _0_8 then 
1504  1017 
begin 
1018 
len:= _0_8 / len; 

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

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

1021 
end; 

789  1022 

351  1023 
if (Gear^.Message and gm_Attack) <> 0 then 
1504  1024 
if (Gear^.State and gsttmpFlag) <> 0 then 
1922  1025 
with PHedgehog(Gear^.Hedgehog)^ do 
1964  1026 
if Ammo^[CurSlot, CurAmmo].AmmoType <> amParachute then 
1922  1027 
WaitCollision 
1028 
else 

1029 
DeleteMe 

1504  1030 
else 
1031 
else 

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

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

4  1034 
end; 
1035 

1036 
procedure doStepRopeAttach(Gear: PGear); 

1037 
var HHGear: PGear; 

1781  1038 
tx, ty, tt: hwFloat; 
1039 

1040 
procedure RemoveFromAmmo; 

1041 
begin 

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

1043 
begin 

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

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

1964  1046 
end; 
1047 
ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^) 

1781  1048 
end; 
2376  1049 

4  1050 
begin 
351  1051 
Gear^.X:= Gear^.X  Gear^.dX; 
1052 
Gear^.Y:= Gear^.Y  Gear^.dY; 

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

1054 

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

1057 

542  1058 
if (HHGear^.State and gstMoving) <> 0 then 
1433  1059 
begin 
2282  1060 
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

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

1433  1063 
HHGear^.X:= HHGear^.X + HHGear^.dX; 
1064 
Gear^.X:= Gear^.X + HHGear^.dX; 

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

1065 

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

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

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

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

1069 
HHGear^.dY:= _0; 
2339  1070 
//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

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

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

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

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

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

1077 

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

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

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

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

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

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

1083 
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

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

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

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

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

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

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

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

1092 
RemoveFromAmmo; 
2376  1093 

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

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

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

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

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

1099 
tt:= tt  _2; 
1433  1100 
end; 
1101 
end; 

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

1102 

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

1104 

351  1105 
if (Gear^.State and gstCollision) <> 0 then 
2068  1106 
if Gear^.Elasticity < _10 then 
1107 
Gear^.Elasticity:= _10000 

1108 
else 

1109 
begin 

1110 
Gear^.doStep:= @doStepRopeWork; 

2339  1111 
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

1112 

2068  1113 
RemoveFromAmmo; 
2376  1114 

2068  1115 
exit 
1116 
end; 

4  1117 

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

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

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

1121 
or (HHGear^.Damage > 0) then 
1433  1122 
begin 
1123 
with PHedgehog(Gear^.Hedgehog)^.Gear^ do 

1124 
begin 

1125 
State:= State and not gstAttacking; 

1126 
Message:= Message and not gm_Attack 

1127 
end; 

1128 
DeleteGear(Gear) 

1129 
end 

4  1130 
end; 
1131 

1132 
procedure doStepRope(Gear: PGear); 

1133 
begin 

351  1134 
Gear^.dX:=  Gear^.dX; 
1135 
Gear^.dY:=  Gear^.dY; 

1136 
Gear^.doStep:= @doStepRopeAttach 

4  1137 
end; 
1138 

1139 
//////////////////////////////////////////////////////////////////////////////// 

1140 
procedure doStepSmokeTrace(Gear: PGear); 

1141 
begin 

351  1142 
inc(Gear^.Timer); 
1143 
if Gear^.Timer > 64 then 

1133  1144 
begin 
1145 
Gear^.Timer:= 0; 

1146 
dec(Gear^.State) 

1147 
end; 

351  1148 
Gear^.dX:= Gear^.dX + cWindSpeed; 
1149 
Gear^.X:= Gear^.X + Gear^.dX; 

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

4  1151 
end; 
9  1152 

1153 
//////////////////////////////////////////////////////////////////////////////// 

1045  1154 
procedure doStepExplosionWork(Gear: PGear); 
9  1155 
begin 
351  1156 
inc(Gear^.Timer); 
1157 
if Gear^.Timer > 75 then 

1133  1158 
begin 
1159 
inc(Gear^.State); 

1160 
Gear^.Timer:= 0; 

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

1162 
end; 

9  1163 
end; 
10  1164 

1045  1165 
procedure doStepExplosion(Gear: PGear); 
1166 
var i: LongWord; 

1167 
begin 

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

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

1045  1171 
Gear^.doStep:= @doStepExplosionWork 
1172 
end; 

1173 

10  1174 
//////////////////////////////////////////////////////////////////////////////// 
1175 
procedure doStepMine(Gear: PGear); 

1176 
begin 

542  1177 
if (Gear^.State and gstMoving) <> 0 then 
914  1178 
begin 
1179 
DeleteCI(Gear); 

1180 
doStepFallingGear(Gear); 

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

1182 
begin 

1183 
AddGearCI(Gear); 

1184 
Gear^.dX:= _0; 

1185 
Gear^.dY:= _0 

1186 
end; 

1187 
CalcRotationDirAngle(Gear); 

1188 
AllInactive:= false 

1189 
end else 

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

1191 
doStepFallingGear(Gear); 

351  1192 

2882  1193 
if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Health <> 0) then 
1133  1194 
if ((Gear^.State and gstAttacking) = 0) then 
1195 
begin 

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

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

1198 
end else // gstAttacking <> 0 

1199 
begin 

1200 
AllInactive:= false; 

2745  1201 
if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick); 
1133  1202 
if Gear^.Timer = 0 then 
1203 
begin 

2882  1204 
if ((Gear^.State and gstWait) <> 0) or 
1205 
(cMineDudPercent = 0) or 

1206 
(getRandom(100) > cMineDudPercent) then 

1207 
begin 

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

1209 
DeleteGear(Gear) 

1210 
end 

2886  1211 
else 
1212 
begin 

2887  1213 
AddVisualGear(hwRound(Gear^.X)  4 + Random(8), hwRound(Gear^.Y)  4  Random(4), vgtSmoke); 
2886  1214 
PlaySound(sndVaporize); 
1215 
Gear^.Health:= 0; 

1216 
end; 

1133  1217 
exit 
1218 
end; 

1219 
dec(Gear^.Timer); 

1220 
end else // gsttmpFlag = 0 

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

10  1222 
end; 
57  1223 

39  1224 
//////////////////////////////////////////////////////////////////////////////// 
1225 
procedure doStepDynamite(Gear: PGear); 

1226 
begin 

43  1227 
doStepFallingGear(Gear); 
1228 
AllInactive:= false; 

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

351  1232 
if Gear^.Timer = 0 then 
1133  1233 
begin 
1234 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound); 

1235 
DeleteGear(Gear); 

1236 
exit 

1237 
end; 

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

1240 

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

1242 
procedure doStepCase(Gear: PGear); 
371  1243 
var i, x, y: LongInt; 
1436  1244 
k: TGearType; 
2911  1245 
exBoom: boolean; 
1246 
dX, dY: HWFloat; 

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

1247 
begin 
2911  1248 
exBoom:= false; 
1249 

351  1250 
if (Gear^.Message and gm_Destroy) > 0 then 
1133  1251 
begin 
1252 
DeleteGear(Gear); 

1253 
FreeActionsList; 

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

1255 
with CurrentHedgehog^ do 

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

1257 
exit 

1258 
end; 

15  1259 

2911  1260 
if Gear^.Kind = gtExplosives then 
1261 
begin 

1262 
if ((Gear^.Health * 100 div cBarrelHealth) < random(90)) and ((GameTicks and $FF) = 0) then 

1263 
AddVisualGear(hwRound(Gear^.X)  16 + Random(32), hwRound(Gear^.Y)  2, vgtSmoke); 

1264 
dec(Gear^.Health, Gear^.Damage); 

1265 
Gear^.Damage:= 0; 

1266 
if Gear^.Health <= 0 then 

1267 
exBoom:= true; 

1268 
end; 

1269 

1270 
if (Gear^.Damage > 0) or exBoom then 

1133  1271 
begin 
1272 
x:= hwRound(Gear^.X); 

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

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

2376  1276 

1436  1277 
if k = gtCase then 
1133  1278 
begin 
1279 
doMakeExplosion(x, y, 25, EXPLAutoSound); 

1280 
for i:= 0 to 63 do 

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

2911  1282 
end 
1283 
else if k = gtExplosives then 

1284 
begin 

2915
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1285 
doMakeExplosion(x, y, 75, EXPLAutoSound); 
2911  1286 
for i:= 0 to 31 do 
1287 
begin 

1288 
dX:= AngleCos(i * 64) * _0_5 * (getrandom + _1); 

1289 
dY:= AngleSin(i * 64) * _0_5 * (getrandom + _1); 

1290 
AddGear(x, y, gtFlame, 0, dX, dY, 0); 

1291 
AddGear(x, y, gtFlame, 0, dX, dY, 0)^.State:= gsttmpFlag; 

1292 
end 

1133  1293 
end; 
1294 
exit 

1295 
end; 

79  1296 

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

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

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

2932
9bc0cf3c7ac1
Activate hedgehogs if explosives are falling. They could be sitting on top.
nemo
parents:
2915
diff
changeset

1302 
if (not Gear^.dY.isNegative) and (Gear^.Kind = gtExplosives) then SetAllHHToActive; 
1133  1303 
if (Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then Gear^.dY:= _0 else 
1304 
if (not Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then 

1305 
begin 

2915
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1306 
if Gear^.dY > _0_2 then 
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1307 
for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do 
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1308 
AddVisualGear(hwRound(Gear^.X)  5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); 
1133  1309 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 
1310 
if Gear^.dY >  _0_001 then Gear^.dY:= _0 

2915
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1311 
else if Gear^.dY <  _0_03 then PlaySound(sndGraveImpact) 
1133  1312 
end; 
2915
a02f276035e8
Add spinner for explosives, add dust on crate impact, crank up explosives a bit
nemo
parents:
2911
diff
changeset

1313 
//if Gear^.dY >  _0_001 then Gear^.dY:= _0 
1133  1314 
CheckGearDrowning(Gear); 
1315 
end; 

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

1316 

511  1317 
if (Gear^.dY.QWordValue = 0) then AddGearCI(Gear) 
1133  1318 
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

1319 
end; 
49  1320 

1321 
//////////////////////////////////////////////////////////////////////////////// 

2460  1322 

1323 
procedure doStepTarget(Gear: PGear); 

1324 
begin 

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

2745  1326 
PlaySound(sndWarp); 
2460  1327 

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

1329 
inc(Gear^.Timer) 

1330 
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

1331 
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

1332 
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

1333 
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

1334 
begin 
2460  1335 
inc(TurnTimeLeft, TrainingTimeInc); 
1336 

1337 
if TrainingTimeInc > TrainingTimeInM then 

1338 
dec(TrainingTimeInc, TrainingTimeInD); 

1339 
if TurnTimeLeft > TrainingTimeMax then 

1340 
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

1341 
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

1342 
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

1343 
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

1344 
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

1345 
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

1346 
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

1347 
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

1348 
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

1349 
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

1350 
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

1351 
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

1352 
end; 
2460 