author  unc0rr 
Sat, 06 Mar 2010 10:59:20 +0000  
changeset 2948  3f21a9dc93d0 
parent 2944  e8a891bf6660 
child 2955  fb361d137524 
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 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

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

1260 
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

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

1262 
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

1263 
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

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

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

1266 
else if not Gear^.dX.isNegative and (Gear^.dX > _0_03) and TestCollisionXwithGear(Gear, 1) then 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

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

1268 
else if Gear^.dY.isNegative and (Gear^.dY < _0_03) and TestCollisionYwithGear(Gear, 1) then 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

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

1270 
else if Gear^.dX.isNegative and (Gear^.dX < _0_03) and TestCollisionXwithGear(Gear, 1) then 
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

1271 
inc(Gear^.Damage, hwRound(Gear^.dX * _30)); 
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

1272 
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

1273 
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

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

1275 
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

1276 
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

1277 
else AddGearCI(Gear); 
2944
e8a891bf6660
Adjust fall damage again, zero out X/Y to avoid sinking/shivering barrels.
nemo
parents:
2941
diff
changeset

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

1279 
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

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

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

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

1283 
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

1284 
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

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

1286 
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

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

1288 
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

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

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

1291 
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

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

1293 

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

1294 
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

1295 
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

1296 

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

1297 
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

1298 
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

1299 
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

1300 
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

1301 
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

1302 
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

1303 
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

1304 
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

1305 

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

1307 

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

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

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

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

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

1313 
begin 
2933  1314 
k:= Gear^.Kind; 
2911  1315 
exBoom:= false; 
1316 

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

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

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

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

1321 
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

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

1323 
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

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

1325 
end; 
15  1326 

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

1328 
begin 
2936  1329 
//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

1330 
if hwAbs(Gear^.dX) > _0_15 then Gear^.doStep:= @doStepRollingBarrel; 
2933 