author  nemo 
Sat, 06 Mar 2010 21:32:04 +0000  
changeset 2963  0f0789204802 
parent 2955  fb361d137524 
child 2965  2a8c76b23e2c 
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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

23 
gi:= GearsList; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

24 
while gi <> nil do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

25 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

26 
d:= r  hwRound(Distance(gi^.X  x, gi^.Y  y)); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

27 
if (d > 1) and (gi^.Kind = gtHedgehog) and not gi^.Invulnerable and (GetRandom(2) = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

28 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

29 
if (CurrentHedgehog^.Gear = gi) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

30 
PlaySound(sndOops, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

31 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

32 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

33 
if (gi^.State and gstMoving) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

34 
gi^.State:= gi^.State or gstLoser; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

35 
if d > r div 2 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

36 
PlaySound(sndNooo, PHedgehog(gi^.Hedgehog)^.Team^.voicepack) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

37 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

38 
PlaySound(sndUhOh, PHedgehog(gi^.Hedgehog)^.Team^.voicepack); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

39 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

40 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

41 
gi:= gi^.NextGear 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

42 
end; 
2647  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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

71 
if Gear^.Kind = gtHedgehog then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

72 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

73 
Gear^.State:= Gear^.State and (not gstHHDriven); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

74 
AddCaption(Format(GetEventString(eidDrowned), PHedgehog(Gear^.Hedgehog)^.Name), cWhiteColor, capgrpMessage); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

75 
end 
1918  76 
end; 
2745  77 
PlaySound(sndSplash) 
1918  78 
end 
79 
else 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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)) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

86 
then Gear^.State:= Gear^.State or gstCollision 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

87 
else Gear^.State:= Gear^.State and not gstCollision 
4  88 
end; 
89 

90 
procedure CheckHHDamage(Gear: PGear); 

2848  91 
var 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

92 
dmg: Longword; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

93 
i: LongInt; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

94 
particle: PVisualGear; 
4  95 
begin 
522  96 
if _0_4 < Gear^.dY then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

97 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

98 
dmg:= ModifyDamage(1 + hwRound((hwAbs(Gear^.dY)  _0_4) * 70), Gear); 
2730
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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

101 
for i:= min(12, (3 + dmg div 10)) downto 0 do begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

102 
particle := AddVisualGear(hwRound(Gear^.X)  5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); 
2871
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); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

104 
end; 
2871
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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

108 
if _0_6 < Gear^.dY then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

109 
PlaySound(sndOw4, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

110 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

124 
Gear^.DirAngle:= Gear^.DirAngle + dAngle 
1133  125 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

126 
Gear^.DirAngle:= Gear^.DirAngle  dAngle; 
1133  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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

154 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

155 
isFalling:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

156 
if TestCollisionYwithGear(Gear, 1) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

157 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

158 
Gear^.dX:= Gear^.dX * Gear^.Friction; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

159 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

160 
Gear^.State:= Gear^.State or gstCollision 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

161 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

162 
end else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

163 
if TestCollisionYwithGear(Gear, 1) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

164 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

165 
isFalling:= false; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

166 
Gear^.dX:= Gear^.dX * Gear^.Friction; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

167 
Gear^.dY:=  Gear^.dY * Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

168 
Gear^.State:= Gear^.State or gstCollision 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

169 
end else isFalling:= true; 
503  170 

351  171 
if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

172 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

173 
Gear^.dX:=  Gear^.dX * Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

174 
Gear^.dY:= Gear^.dY * Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

175 
Gear^.State:= Gear^.State or gstCollision 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

184 
(not isFalling) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

185 
Gear^.State:= Gear^.State and not gstMoving 
1133  186 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

202 
case Gear^.Kind of 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

203 
gtAmmo_Bomb: makeHogsWorry(Gear^.X, Gear^.Y, 50); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

204 
gtClusterBomb: makeHogsWorry(Gear^.X, Gear^.Y, 20); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

205 
gtWatermelon: makeHogsWorry(Gear^.X, Gear^.Y, 75); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

206 
gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

207 
end; 
351  208 
if Gear^.Timer = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

209 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

210 
case Gear^.Kind of 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

211 
gtAmmo_Bomb: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

212 
gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

213 
gtClusterBomb: begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

214 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

215 
for i:= 0 to 4 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

216 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

217 
dX:= rndSign(GetRandom * _0_1); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

218 
dY:= (GetRandom  _3) * _0_08; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

219 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

220 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

221 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

222 
gtWatermelon: begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

223 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

224 
for i:= 0 to 5 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

225 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

226 
dX:= rndSign(GetRandom * _0_1); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

227 
dY:= (GetRandom  _1_5) * _0_3; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

228 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

229 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

230 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

231 
gtHellishBomb: begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

232 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

233 
for i:= 0 to 127 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

234 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

235 
dX:= AngleCos(i * 16) * _0_5 * (GetRandom + _1); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

241 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

242 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

243 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

244 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

245 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

246 
end; 
1263  247 

4  248 
CalcRotationDirAngle(Gear); 
1263  249 

250 
if Gear^.Kind = gtHellishBomb then 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

251 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

254 
if (GameTicks and $3F) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

255 
if (Gear^.State and gstCollision) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

256 
AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

257 
end; 
1263  258 

1158  259 
if (Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

260 
if (hwAbs(Gear^.dX) > _0_1) or 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

261 
(hwAbs(Gear^.dY) > _0_1) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

268 
Fire: PGear; 
2457
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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

270 
AllInactive:= false; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

271 

3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

272 
doStepFallingGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

274 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

275 
if (Gear^.State and gstCollision) <> 0 then begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

276 
PlaySound(sndMolotov); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

277 
//doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 5, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

278 
for i:= 0 to 20 do begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

279 
dX:= AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandom + _1); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

280 
dY:= AngleSin(i * 8) * _0_5 * (GetRandom + _1); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

281 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

282 
Fire^.State:= Fire^.State or gsttmpFlag; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

283 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

284 
Fire^.State:= Fire^.State or gsttmpFlag; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

285 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

286 
Fire^.State:= Fire^.State or gsttmpFlag; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

287 
Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

288 
Fire^.State:= Fire^.State or gsttmpFlag; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

289 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

290 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

291 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

292 
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

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

306 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

307 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

308 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

309 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

310 
end; 
1262  311 

312 
if Gear^.Kind = gtMelonPiece then 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

313 
CalcRotationDirAngle(Gear) 
1262  314 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

315 
if (GameTicks and $1F) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

326 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

327 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

328 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

329 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

330 
end; 
4  331 
if (GameTicks and $3F) = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

339 
AllInactive:= false; 
1505  340 

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

351  344 
if Gear^.Timer = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

345 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

346 
if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

347 
PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

348 
DeleteGear(Gear) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

372 
Gear^.doStep:= @doStepHealthTagWork 
1505  373 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

374 
Gear^.doStep:= @doStepHealthTagWorkUnderWater; 
1505  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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

462 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

463 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

464 
AfterAttack 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

465 
end 
876  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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

475 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

476 
dec(Gear^.Timer); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

477 
if Gear^.Timer = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

478 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

479 
PlaySound(sndShotgunFire); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

487 
Gear^.State:= Gear^.State or gstAnimation 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

488 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

489 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

490 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

491 
else inc(Gear^.Timer); 
876  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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

499 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

500 
Gear^.X:= Gear^.X + Gear^.dX * 8; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

501 
Gear^.Y:= Gear^.Y + Gear^.dY * 8; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

502 
ShotgunShot(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

503 
Gear^.doStep:= @doStepShotIdle; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

504 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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) 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

544 
or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

603 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

648 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

649 
StopSound(Gear^.SoundChannel); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

650 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

651 
AfterAttack; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

652 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

653 
end; 
845  654 

422  655 
if (Gear^.Timer mod 33) = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

656 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

657 
HHGear^.State:= HHGear^.State or gstNoDamage; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

658 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y) + 7, 6, EXPLDontDraw); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

659 
HHGear^.State:= HHGear^.State and not gstNoDamage 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

660 
end; 
422  661 

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

663 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

664 
i:= hwRound(Gear^.X)  Gear^.Radius  LongInt(GetRandom(2)); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

665 
ei:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2)); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

666 
while i <= ei do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

667 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

668 
DrawExplosion(i, hwRound(Gear^.Y) + 3, 3); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

669 
inc(i, 1) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

677 
SetAllHHToActive; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

678 
end; 
4  679 
if TestCollisionYwithGear(Gear, 1) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

680 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

681 
Gear^.dY:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

682 
SetLittle(HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

683 
HHGear^.dY:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

684 
end else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

685 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

686 
Gear^.dY:= Gear^.dY + cGravity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

687 
Gear^.Y:= Gear^.Y + Gear^.dY; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

688 
if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer:= 1 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

734 
b: boolean; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

746 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

747 
Gear^.dX:= SignAs(AngleSin(HHGear^.Angle) * _0_5, HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

748 
Gear^.dY:= AngleCos(HHGear^.Angle) * (  _0_5); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

749 
BTPrevAngle:= HHGear^.Angle; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

750 
b:= true 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

751 
end; 
1528  752 

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

754 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

755 
doStepHedgehogMoving(HHGear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

756 
if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer:= 0 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

757 
end; 
305  758 

351  759 
if Gear^.Timer mod cHHStepTicks = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

760 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

761 
b:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

762 
if Gear^.dX.isNegative then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

763 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Left 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

764 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

765 
HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Right; 
305  766 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

767 
if ((HHGear^.State and gstMoving) = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

768 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

769 
HHGear^.State:= HHGear^.State and not gstAttacking; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

778 
HHGear^.State:= HHGear^.State or gstAttacking 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

779 
end; 
305  780 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

781 
inc(BTSteps); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

782 
if BTSteps = 7 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

783 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

787 
Gear^.X:= HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
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; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

790 
HHGear^.State:= HHGear^.State or gstNoDamage; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

791 
AmmoShove(Gear, 2, 15); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

792 
HHGear^.State:= HHGear^.State and not gstNoDamage 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

793 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

802 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

803 
HHGear^.Message:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

804 
HHGear^.State:= HHGear^.State and (not gstNotKickable); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

805 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

806 
AfterAttack 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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) 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

830 
or (CheckGearDrowning(HHGear)) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

831 
or TestCollisionYwithGear(HHGear, 1) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

832 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

833 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

834 
isCursorVisible:= false; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

835 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

836 
end; 
1781  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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

848 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

849 
Gear^.X:= HHGear^.X; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

854 
Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

855 
Gear^.dY:= AngleCos(HHGear^.Angle); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

856 
Gear^.Friction:= _450; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

857 
Gear^.Elasticity:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

858 
Gear^.State:= Gear^.State and not gsttmpflag; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

859 
Gear^.doStep:= @doStepRope 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

860 
end 
1781  861 
end; 
862 

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

865 
len, tx, ty, nx, ny, ropeDx, ropeDy, mdX, mdY: hwFloat; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

866 
lx, ly: LongInt; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

867 
haveCollision, 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

868 
haveDivided: boolean; 
4  869 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

870 
procedure DeleteMe; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

871 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

872 
with HHGear^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

873 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

874 
Message:= Message and not gm_Attack; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

875 
State:= (State or gstMoving) and not gstWinner; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

876 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

877 
DeleteGear(Gear) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

878 
end; 
4  879 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

880 
procedure WaitCollision; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

881 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

882 
with HHGear^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

883 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

884 
Message:= Message and not gm_Attack; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

885 
State:= State or gstMoving; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

886 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

887 
RopePoints.Count:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

888 
Gear^.Elasticity:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

889 
Gear^.doStep:= @doStepRopeAfterAttack 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

890 
end; 
1781  891 

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

351  895 
if ((HHGear^.State and gstHHDriven) = 0) 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

896 
or (CheckGearDrowning(HHGear)) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

897 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

898 
DeleteMe; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

899 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

920 
tx:= HHGear^.X; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

921 
ty:= HHGear^.Y; 
4  922 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

923 
if ((Gear^.Message and gm_Down) <> 0) and (Gear^.Elasticity < Gear^.Friction) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

924 
if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx)) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

925 
or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

928 
if ((Gear^.Message and gm_Up) <> 0) and (Gear^.Elasticity > _30) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

929 
if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx)) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

930 
or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

933 
HHGear^.X:= Gear^.X + mdX * Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

936 
HHGear^.dX:= HHGear^.X  tx; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

937 
HHGear^.dY:= HHGear^.Y  ty; 
1652  938 
//// 
939 

1554  940 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

941 
haveDivided:= false; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

942 
// check whether rope needs dividing 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

943 
len:= _1 / Distance(ropeDx, ropeDy); // old rope pos 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

944 
nx:= ropeDx * len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

945 
ny:= ropeDy * len; 
2376  946 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

947 
len:= Gear^.Elasticity  _0_3x70; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

948 
while len > _3 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

949 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

950 
lx:= hwRound(Gear^.X + mdX * len); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

951 
ly:= hwRound(Gear^.Y + mdY * len); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

952 
if ((ly and LAND_HEIGHT_MASK) = 0) and ((lx and LAND_WIDTH_MASK) = 0) and (Land[ly, lx] <> 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

953 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

954 
with RopePoints.ar[RopePoints.Count] do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

955 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

956 
X:= Gear^.X; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

957 
Y:= Gear^.Y; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

958 
if RopePoints.Count = 0 then RopePoints.HookAngle:= DxDy2Angle(Gear^.dY, Gear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

959 
b:= (nx * HHGear^.dY) > (ny * HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

960 
dLen:= len 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

961 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

962 
with RopePoints.rounded[RopePoints.Count] do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

963 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

964 
X:= hwRound(Gear^.X); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

965 
Y:= hwRound(Gear^.Y); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

966 
end; 
2376  967 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

968 
Gear^.X:= Gear^.X + nx * len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

969 
Gear^.Y:= Gear^.Y + ny * len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

970 
inc(RopePoints.Count); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

971 
TryDo(RopePoints.Count <= MAXROPEPOINTS, 'Rope points overflow', true); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

972 
Gear^.Elasticity:= Gear^.Elasticity  len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

973 
Gear^.Friction:= Gear^.Friction  len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

974 
haveDivided:= true; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

975 
break 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

976 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

977 
len:= len  _0_3 // should be the same as increase step 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

981 
if RopePoints.Count > 0 then // check whether the last dividing point could be removed 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

982 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

983 
tx:= RopePoints.ar[Pred(RopePoints.Count)].X; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

984 
ty:= RopePoints.ar[Pred(RopePoints.Count)].Y; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

985 
if RopePoints.ar[Pred(RopePoints.Count)].b xor ((tx  Gear^.X) * (ty  HHGear^.Y) > (tx  HHGear^.X) * (ty  Gear^.Y)) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

986 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

987 
dec(RopePoints.Count); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

988 
Gear^.X:= RopePoints.ar[RopePoints.Count].X; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

989 
Gear^.Y:= RopePoints.ar[RopePoints.Count].Y; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

990 
Gear^.Elasticity:= Gear^.Elasticity + RopePoints.ar[RopePoints.Count].dLen; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

991 
Gear^.Friction:= Gear^.Friction + RopePoints.ar[RopePoints.Count].dLen 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

992 
end 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

997 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

998 
HHGear^.dX:= _0_6 * HHGear^.dX; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

999 
haveCollision:= true 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1000 
end; 
351  1001 
if TestCollisionYwithGear(HHGear, hwSign(HHGear^.dY)) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1002 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1003 
HHGear^.dY:= _0_6 * HHGear^.dY; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1004 
haveCollision:= true 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1005 
end; 
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

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1008 
and (Gear^.Message and (gm_Left or gm_Right) <> 0) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1009 
and (Gear^.Message and (gm_Up or gm_Down) <> 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1010 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1011 
HHGear^.dX:= SignAs(hwAbs(HHGear^.dX) + _0_2, HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1012 
HHGear^.dY:= SignAs(hwAbs(HHGear^.dY) + _0_2, HHGear^.dY) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1013 
end; 
4  1014 

789  1015 
len:= Distance(HHGear^.dX, HHGear^.dY); 
940  1016 
if len > _0_8 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1017 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1018 
len:= _0_8 / len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1019 
HHGear^.dX:= HHGear^.dX * len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1020 
HHGear^.dY:= HHGear^.dY * len; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1021 
end; 
789  1022 

351  1023 
if (Gear^.Message and gm_Attack) <> 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1024 
if (Gear^.State and gsttmpFlag) <> 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1025 
with PHedgehog(Gear^.Hedgehog)^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1026 
if Ammo^[CurSlot, CurAmmo].AmmoType <> amParachute then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1027 
WaitCollision 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1028 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1029 
DeleteMe 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1030 
else 
1504  1031 
else 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1032 
if (Gear^.State and gsttmpFlag) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1033 
Gear^.State:= Gear^.State or gsttmpFlag; 
4  1034 
end; 
1035 

1036 
procedure doStepRopeAttach(Gear: PGear); 

1037 
var HHGear: PGear; 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1038 
tx, ty, tt: hwFloat; 
1781  1039 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1040 
procedure RemoveFromAmmo; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1041 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1042 
if (Gear^.State and gstAttacked) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1043 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1044 
OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1045 
Gear^.State:= Gear^.State or gstAttacked 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1046 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1047 
ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1059 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1060 
if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1063 
HHGear^.X:= HHGear^.X + HHGear^.dX; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1066 
if TestCollisionYwithGear(HHGear, 1) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1067 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1068 
CheckHHDamage(HHGear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1069 
HHGear^.dY:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1070 
//HHGear^.State:= HHGear^.State and not (gstHHJumping or gstHHHJump); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1071 
end else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1072 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1073 
HHGear^.Y:= HHGear^.Y + HHGear^.dY; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1074 
Gear^.Y:= Gear^.Y + HHGear^.dY; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1075 
HHGear^.dY:= HHGear^.dY + cGravity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1076 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1077 

3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1078 
tt:= Gear^.Elasticity; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1079 
tx:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1080 
ty:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1081 
while tt > _20 do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1082 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1083 
if TestCollisionXwithXYShift(Gear, tx, hwRound(ty), hwSign(Gear^.dX)) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1084 
or TestCollisionYwithXYShift(Gear, hwRound(tx), hwRound(ty), hwSign(Gear^.dY)) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1085 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1086 
Gear^.X:= Gear^.X + tx; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1087 
Gear^.Y:= Gear^.Y + ty; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1088 
Gear^.Elasticity:= tt; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1089 
Gear^.doStep:= @doStepRopeWork; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1092 
RemoveFromAmmo; 
2376  1093 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1094 
tt:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1095 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1096 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1097 
tx:= tx + Gear^.dX + Gear^.dX; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1098 
ty:= ty + Gear^.dY + Gear^.dY; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1099 
tt:= tt  _2; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1100 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1106 
if Gear^.Elasticity < _10 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1107 
Gear^.Elasticity:= _10000 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1108 
else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1109 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1110 
Gear^.doStep:= @doStepRopeWork; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1113 
RemoveFromAmmo; 
2376  1114 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1115 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1122 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1123 
with PHedgehog(Gear^.Hedgehog)^.Gear^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1124 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1125 
State:= State and not gstAttacking; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1126 
Message:= Message and not gm_Attack 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1127 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1128 
DeleteGear(Gear) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1144 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1145 
Gear^.Timer:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1146 
dec(Gear^.State) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1158 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1159 
inc(Gear^.State); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1160 
Gear^.Timer:= 0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1161 
if Gear^.State > 5 then DeleteGear(Gear) 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1178 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1179 
DeleteCI(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1180 
doStepFallingGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1181 
if (Gear^.State and gstMoving) = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1182 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1183 
AddGearCI(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1184 
Gear^.dX:= _0; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1185 
Gear^.dY:= _0 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1186 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1187 
CalcRotationDirAngle(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1188 
AllInactive:= false 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1189 
end else 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1190 
if ((GameTicks and $3F) = 25) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1191 
doStepFallingGear(Gear); 
351  1192 

2882  1193 
if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Health <> 0) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1194 
if ((Gear^.State and gstAttacking) = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1195 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1196 
if ((GameTicks and $1F) = 0) then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1197 
if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State:= Gear^.State or gstAttacking 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1198 
end else // gstAttacking <> 0 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1199 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1200 
AllInactive:= false; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1201 
if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1202 
if Gear^.Timer = 0 then 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1206 
(getRandom(100) > cMineDudPercent) then 
2882  1207 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1208 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1209 
DeleteGear(Gear) 
2882  1210 
end 
2886  1211 
else 
1212 
begin 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1213 
AddVisualGear(hwRound(Gear^.X)  4 + Random(8), hwRound(Gear^.Y)  4  Random(4), vgtSmoke); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1214 
PlaySound(sndVaporize); 
2886  1215 
Gear^.Health:= 0; 
1216 
end; 

2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1217 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1218 
end; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1219 
dec(Gear^.Timer); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1220 
end else // gsttmpFlag = 0 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1231 
makeHogsWorry(Gear^.X, Gear^.Y, 75); 
351  1232 
if Gear^.Timer = 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1233 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1234 
doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1235 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1236 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

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 
/////////////////////////////////////////////////////////////////////////////// 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1242 

566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1243 
(* 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1244 
TODO 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1245 
Increase damage as barrel smokes? 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1246 
Try tweaking friction some more 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1247 
*) 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1248 
procedure doStepRollingBarrel(Gear: PGear); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1249 
var i: LongInt; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1250 
particle: PVisualGear; 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1251 
begin 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1252 
Gear^.State:= Gear^.State or gstAnimation; 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1253 
if ((Gear^.dX.QWordValue <> 0) or (Gear^.dY.QWordValue <> 0)) then 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1254 
begin 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1255 
DeleteCI(Gear); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1256 
AllInactive:= false; 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1257 
if not Gear^.dY.isNegative and (Gear^.dY > _0_03) and TestCollisionYwithGear(Gear, 1) then 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1258 
begin 
2955
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset

1259 
Gear^.State:= Gear^.State or gsttmpFlag; 
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset

1260 
inc(Gear^.Damage, hwRound(Gear^.dY * _40)); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1261 
for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1262 
begin 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1263 
particle:= AddVisualGear(hwRound(Gear^.X)  5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust); 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1264 
if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX / 5) 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1265 
end 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1266 
end 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1267 
else if not Gear^.dX.isNegative and (Gear^.dX > _0_03) and TestCollisionXwithGear(Gear, 1) then 
2955
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset

1268 
inc(Gear^.Damage, hwRound(Gear^.dX * _40)) 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1269 
else if Gear^.dY.isNegative and (Gear^.dY < _0_03) and TestCollisionYwithGear(Gear, 1) then 
2955
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset

1270 
inc(Gear^.Damage, hwRound(Gear^.dY * _40)) 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1271 
else if Gear^.dX.isNegative and (Gear^.dX < _0_03) and TestCollisionXwithGear(Gear, 1) then 
2955
fb361d137524
Tweak to joke in french locale (everyone always fixes the spelling) updated explosive frames from Palewolf, increase explosive fall damage from 30 to 40
nemo
parents:
2948
diff
changeset

1272 
inc(Gear^.Damage, hwRound(Gear^.dX * _40)); 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1273 
if Gear^.Damage <> 0 then PlaySound(sndGraveImpact); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1274 
doStepFallingGear(Gear); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1275 
CalcRotationDirAngle(Gear); 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1276 
CheckGearDrowning(Gear) 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1277 
end 
2963
0f0789204802
This might be all it takes to prevent the desync. needs local/remote testing. Also toggle 2nd barrel state on 0 movement
nemo
parents:
2955
diff
changeset

1278 
else 
0f0789204802
This might be all it takes to prevent the desync. needs local/remote testing. Also toggle 2nd barrel state on 0 movement
nemo
parents:
2955
diff
changeset

1279 
begin 
0f0789204802
This might be all it takes to prevent the desync. needs local/remote testing. Also toggle 2nd barrel state on 0 movement
nemo
parents:
2955
diff
changeset

1280 
Gear^.State:= Gear^.State or gsttmpFlag; 
0f0789204802
This might be all it takes to prevent the desync. needs local/remote testing. Also toggle 2nd barrel state on 0 movement
nemo
parents:
2955
diff
changeset

1281 
AddGearCI(Gear) 
0f0789204802
This might be all it takes to prevent the desync. needs local/remote testing. Also toggle 2nd barrel state on 0 movement
nemo
parents:
2955
diff
changeset

1282 
end; 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1283 
(* 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1284 
Attempt to make a barrel knock itself over an edge. Would need more checks to avoid issues like burn damage 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1285 
begin 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1286 
x:= hwRound(Gear^.X); 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1287 
y:= hwRound(Gear^.Y); 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1288 
if (((y+1) and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1289 
if (Land[y+1, x] = 0) then 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1290 
begin 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1291 
if (((y+1) and LAND_HEIGHT_MASK) = 0) and (((x+Gear^.Radius2) and LAND_WIDTH_MASK) = 0) and (Land[y+1, x+Gear^.Radius2] = 0) then 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1292 
Gear^.dX:= _0_08 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1293 
else if (((y+1 and LAND_HEIGHT_MASK)) = 0) and (((x(Gear^.Radius2)) and LAND_WIDTH_MASK) = 0) and (Land[y+1, x(Gear^.Radius2)] = 0) then 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1294 
Gear^.dX:= _0_08; 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1295 
end; 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1296 
if Gear^.dX.QWordValue = 0 then AddGearCI(Gear) 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1297 
end; *) 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1298 

e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1299 
if not Gear^.dY.isNegative and (Gear^.dY < _0_001) and TestCollisionYwithGear(Gear, 1) then Gear^.dY:= _0; 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1300 
if hwAbs(Gear^.dX) < _0_001 then Gear^.dX:= _0; 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1301 

566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1302 
if ((Gear^.Health * 100 div cBarrelHealth) < random(90)) and ((GameTicks and $FF) = 0) then 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1303 
if (cBarrelHealth div Gear^.Health) > 2 then 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1304 
AddVisualGear(hwRound(Gear^.X)  16 + Random(32), hwRound(Gear^.Y)  2, vgtSmoke) 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1305 
else 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1306 
AddVisualGear(hwRound(Gear^.X)  16 + Random(32), hwRound(Gear^.Y)  2, vgtSmokeWhite); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1307 
dec(Gear^.Health, Gear^.Damage); 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1308 
Gear^.Damage:= 0; 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1309 
if Gear^.Health <= 0 then Gear^.doStep:= @doStepCase; // Hand off to doStepCase for the explosion 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1310 

566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1311 
end; 
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1312 

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

1313 
procedure doStepCase(Gear: PGear); 
371  1314 
var i, x, y: LongInt; 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1315 
k: TGearType; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1316 
exBoom: boolean; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1317 
dX, dY: HWFloat; 
14
81f125629b25
 Mine checks whether a hedgehog is near less frequently
unc0rr
parents:
13
diff
changeset

1318 
begin 
2933  1319 
k:= Gear^.Kind; 
2911  1320 
exBoom:= false; 
1321 

351  1322 
if (Gear^.Message and gm_Destroy) > 0 then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1323 
begin 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1324 
DeleteGear(Gear); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1325 
FreeActionsList; 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1326 
SetAllToActive; // something (hh, mine, etc...) could be on top of the case 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1327 
with CurrentHedgehog^ do 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1328 
if Gear <> nil then Gear^.Message:= Gear^.Message and not (gm_LJump or gm_HJump); 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1329 
exit 
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1330 
end; 
15  1331 

2933  1332 
if k = gtExplosives then 
2948
3f21a9dc93d0
Replace tabs with spaces using 'expand t 4' command
unc0rr
parents:
2944
diff
changeset

1333 
begin 
2936  1334 
//if V > _0_03 then Gear^.State:= Gear^.State or gstAnimation; 
2941
566f967ec22f
White/Black smoke, break out rolling barrel into its own routine, adjust rolling barrel impact damage. NEEDS TESTING
nemo
parents:
2939
diff
changeset

1335 
if hwAbs(Gear^.dX) > _0_15 then Gear^.doStep:= @ 