hedgewars: comparison hedgewars/GSHandlers.inc

equal deleted inserted replaced

-:803b277e4894
+:3f21a9dc93d0
 procedure makeHogsWorry(x, y: hwFloat; r: LongInt);
 var gi: PGear;
 d: LongInt;
 begin
-	gi:= GearsList;
+gi:= GearsList;
-	while gi <> nil do
+while gi <> nil do
-		begin
+begin
-		d:= r - hwRound(Distance(gi^.X - x, gi^.Y - y));
+d:= r - hwRound(Distance(gi^.X - x, gi^.Y - y));
-		if (d > 1) and (gi^.Kind = gtHedgehog) and not gi^.Invulnerable and (GetRandom(2) = 0) then
+if (d > 1) and (gi^.Kind = gtHedgehog) and not gi^.Invulnerable and (GetRandom(2) = 0) then
-			begin
+begin
-			if (CurrentHedgehog^.Gear = gi) then
+if (CurrentHedgehog^.Gear = gi) then
-				PlaySound(sndOops, PHedgehog(gi^.Hedgehog)^.Team^.voicepack)
+PlaySound(sndOops, PHedgehog(gi^.Hedgehog)^.Team^.voicepack)
-			else
+else
-				begin
+begin
-				if (gi^.State and gstMoving) = 0 then
+if (gi^.State and gstMoving) = 0 then
-					gi^.State:= gi^.State or gstLoser;
+gi^.State:= gi^.State or gstLoser;
-				if d > r div 2 then
+if d > r div 2 then
-					PlaySound(sndNooo, PHedgehog(gi^.Hedgehog)^.Team^.voicepack)
+PlaySound(sndNooo, PHedgehog(gi^.Hedgehog)^.Team^.voicepack)
-				else
+else
-					PlaySound(sndUhOh, PHedgehog(gi^.Hedgehog)^.Team^.voicepack);
+PlaySound(sndUhOh, PHedgehog(gi^.Hedgehog)^.Team^.voicepack);
-				end;
+end;
-			end;
+end;
-		gi:= gi^.NextGear
+gi:= gi^.NextGear
-		end;
+end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepDrowningGear(Gear: PGear); forward;
 function CheckGearDrowning(Gear: PGear): boolean;
 begin
 CheckGearDrowning:= true;
 Gear^.State:= gstDrowning;
 Gear^.RenderTimer:= false;
 Gear^.doStep:= @doStepDrowningGear;
-		if Gear^.Kind = gtHedgehog then
+if Gear^.Kind = gtHedgehog then
-			begin
+begin
-			Gear^.State:= Gear^.State and (not gstHHDriven);
+Gear^.State:= Gear^.State and (not gstHHDriven);
-			AddCaption(Format(GetEventString(eidDrowned), PHedgehog(Gear^.Hedgehog)^.Name), cWhiteColor, capgrpMessage);
+AddCaption(Format(GetEventString(eidDrowned), PHedgehog(Gear^.Hedgehog)^.Name), cWhiteColor, capgrpMessage);
-			end
+end
 end;
 PlaySound(sndSplash)
 end
 else
-	CheckGearDrowning:= false
+CheckGearDrowning:= false
 end;
 procedure CheckCollision(Gear: PGear);
 begin
 if TestCollisionXwithGear(Gear, hwSign(Gear^.X)) or TestCollisionYwithGear(Gear, hwSign(Gear^.Y))
-	then Gear^.State:= Gear^.State or      gstCollision
+then Gear^.State:= Gear^.State or      gstCollision
-	else Gear^.State:= Gear^.State and not gstCollision
+else Gear^.State:= Gear^.State and not gstCollision
 end;
 procedure CheckHHDamage(Gear: PGear);
 var
-	dmg: Longword;
+dmg: Longword;
-	i: LongInt;
+i: LongInt;
-	particle: PVisualGear;
+particle: PVisualGear;
 begin
 if _0_4 < Gear^.dY then
-	begin
+begin
-	dmg:= ModifyDamage(1 + hwRound((hwAbs(Gear^.dY) - _0_4) * 70), Gear);
+dmg:= ModifyDamage(1 + hwRound((hwAbs(Gear^.dY) - _0_4) * 70), Gear);
 if dmg < 1 then exit;
-	for i:= min(12, (3 + dmg div 10)) downto 0 do begin
+for i:= min(12, (3 + dmg div 10)) downto 0 do begin
-		particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
+particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
 if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX / 5);
-		end;
+end;
 if(Gear^.Invulnerable) then exit;
-	if _0_6 < Gear^.dY then
+if _0_6 < Gear^.dY then
-		PlaySound(sndOw4, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack)
+PlaySound(sndOw4, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack)
-	else
+else
-		PlaySound(sndOw1, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack);
+PlaySound(sndOw1, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack);
 ApplyDamage(Gear, dmg);
-	end
+end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 procedure CalcRotationDirAngle(Gear: PGear);
 var dAngle: real;
 begin
 dAngle:= (hwAbs(Gear^.dX) + hwAbs(Gear^.dY)).QWordValue / $80000000;
 if not Gear^.dX.isNegative then
-	Gear^.DirAngle:= Gear^.DirAngle + dAngle
+Gear^.DirAngle:= Gear^.DirAngle + dAngle
 else
-	Gear^.DirAngle:= Gear^.DirAngle - dAngle;
+Gear^.DirAngle:= Gear^.DirAngle - dAngle;
 if Gear^.DirAngle < 0 then Gear^.DirAngle:= Gear^.DirAngle + 360
 else if 360 < Gear^.DirAngle then Gear^.DirAngle:= Gear^.DirAngle - 360
 end;
 var isFalling: boolean;
 begin
 Gear^.State:= Gear^.State and not gstCollision;
 if Gear^.dY.isNegative then
-	begin
+begin
-	isFalling:= true;
+isFalling:= true;
-	if TestCollisionYwithGear(Gear, -1) then
+if TestCollisionYwithGear(Gear, -1) then
-		begin
+begin
-		Gear^.dX:=   Gear^.dX * Gear^.Friction;
+Gear^.dX:=   Gear^.dX * Gear^.Friction;
-		Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
+Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
-		Gear^.State:= Gear^.State or gstCollision
+Gear^.State:= Gear^.State or gstCollision
-		end
+end
-	end else
+end else
-	if TestCollisionYwithGear(Gear, 1) then
+if TestCollisionYwithGear(Gear, 1) then
-		begin
+begin
-		isFalling:= false;
+isFalling:= false;
-		Gear^.dX:=   Gear^.dX * Gear^.Friction;
+Gear^.dX:=   Gear^.dX * Gear^.Friction;
-		Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
+Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
-		Gear^.State:= Gear^.State or gstCollision
+Gear^.State:= Gear^.State or gstCollision
-		end else isFalling:= true;
+end else isFalling:= true;
 if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then
-	begin
+begin
-	Gear^.dX:= - Gear^.dX * Gear^.Elasticity;
+Gear^.dX:= - Gear^.dX * Gear^.Elasticity;
-	Gear^.dY:=   Gear^.dY * Gear^.Elasticity;
+Gear^.dY:=   Gear^.dY * Gear^.Elasticity;
-	Gear^.State:= Gear^.State or gstCollision
+Gear^.State:= Gear^.State or gstCollision
-	end;
+end;
 if isFalling then Gear^.dY:= Gear^.dY + cGravity;
 Gear^.X:= Gear^.X + Gear^.dX;
 Gear^.Y:= Gear^.Y + Gear^.dY;
 CheckGearDrowning(Gear);
 if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) < _0_0002) and
-	(not isFalling) then
+(not isFalling) then
-	Gear^.State:= Gear^.State and not gstMoving
+Gear^.State:= Gear^.State and not gstMoving
 else
-	Gear^.State:= Gear^.State or      gstMoving
+Gear^.State:= Gear^.State or      gstMoving
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBomb(Gear: PGear);
 var i: LongInt;
 doStepFallingGear(Gear);
 dec(Gear^.Timer);
 if Gear^.Timer = 1000 then // might need adjustments
-	case Gear^.Kind of
+case Gear^.Kind of
-		gtAmmo_Bomb: makeHogsWorry(Gear^.X, Gear^.Y, 50);
+gtAmmo_Bomb: makeHogsWorry(Gear^.X, Gear^.Y, 50);
-		gtClusterBomb: makeHogsWorry(Gear^.X, Gear^.Y, 20);
+gtClusterBomb: makeHogsWorry(Gear^.X, Gear^.Y, 20);
-		gtWatermelon: makeHogsWorry(Gear^.X, Gear^.Y, 75);
+gtWatermelon: makeHogsWorry(Gear^.X, Gear^.Y, 75);
-		gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90);
+gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90);
-	end;
+end;
 if Gear^.Timer = 0 then
-	begin
+begin
-	case Gear^.Kind of
+case Gear^.Kind of
-		gtAmmo_Bomb: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
+gtAmmo_Bomb: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
-		     gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound);
+gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound);
-		gtClusterBomb: begin
+gtClusterBomb: begin
-				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound);
-				for i:= 0 to 4 do
+for i:= 0 to 4 do
-					begin
+begin
-					dX:= rndSign(GetRandom * _0_1);
+dX:= rndSign(GetRandom * _0_1);
-					dY:= (GetRandom - _3) * _0_08;
+dY:= (GetRandom - _3) * _0_08;
-					AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25);
-					end
+end
-				end;
+end;
-		gtWatermelon: begin
+gtWatermelon: begin
-				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound);
-				for i:= 0 to 5 do
+for i:= 0 to 5 do
-					begin
+begin
-					dX:= rndSign(GetRandom * _0_1);
+dX:= rndSign(GetRandom * _0_1);
-					dY:= (GetRandom - _1_5) * _0_3;
+dY:= (GetRandom - _1_5) * _0_3;
-					AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60;
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60;
-					end
+end
-				end;
+end;
-		gtHellishBomb: begin
+gtHellishBomb: begin
-				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound);
-				for i:= 0 to 127 do
+for i:= 0 to 127 do
-					begin
+begin
-					dX:= AngleCos(i * 16) * _0_5 * (GetRandom + _1);
+dX:= AngleCos(i * 16) * _0_5 * (GetRandom + _1);
-					dY:= AngleSin(i * 16) * _0_5 * (GetRandom + _1);
+dY:= AngleSin(i * 16) * _0_5 * (GetRandom + _1);
 Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);
 if i mod 2 = 0 then Fire^.State:= Fire^.State or gsttmpFlag;
 Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);
 if i mod 2 <> 0 then Fire^.State:= Fire^.State or gsttmpFlag;
-					end
+end
-				end;
+end;
-		end;
+end;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 CalcRotationDirAngle(Gear);
 if Gear^.Kind = gtHellishBomb then
-	begin
+begin
-	if Gear^.Timer = 3000 then PlaySound(sndHellish);
+if Gear^.Timer = 3000 then PlaySound(sndHellish);
-	if (GameTicks and $3F) = 0 then
+if (GameTicks and $3F) = 0 then
-		if (Gear^.State and gstCollision) = 0 then
+if (Gear^.State and gstCollision) = 0 then
-			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0);
-	end;
+end;
 if (Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving) then
-	if (hwAbs(Gear^.dX) > _0_1) or
+if (hwAbs(Gear^.dX) > _0_1) or
-	   (hwAbs(Gear^.dY) > _0_1) then
+(hwAbs(Gear^.dY) > _0_1) then
-		PlaySound(sndGrenadeImpact)
+PlaySound(sndGrenadeImpact)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMolotov(Gear: PGear);
 var i: LongInt;
 dX, dY: hwFloat;
-	Fire: PGear;
+Fire: PGear;
 begin
-	AllInactive:= false;
+AllInactive:= false;
-	doStepFallingGear(Gear);
+doStepFallingGear(Gear);
-	CalcRotationDirAngle(Gear);
+CalcRotationDirAngle(Gear);
-	if (Gear^.State and gstCollision) <> 0 then begin
+if (Gear^.State and gstCollision) <> 0 then begin
-		PlaySound(sndMolotov);
+PlaySound(sndMolotov);
-		//doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 5, EXPLAutoSound);
+//doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 5, EXPLAutoSound);
-		for i:= 0 to 20 do begin
+for i:= 0 to 20 do begin
-				dX:= AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandom + _1);
+dX:= AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandom + _1);
-				dY:= AngleSin(i * 8) * _0_5 * (GetRandom + _1);
+dY:= AngleSin(i * 8) * _0_5 * (GetRandom + _1);
-				Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);
+Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);
-				Fire^.State:= Fire^.State or gsttmpFlag;
+Fire^.State:= Fire^.State or gsttmpFlag;
-				Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);
+Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);
-				Fire^.State:= Fire^.State or gsttmpFlag;
+Fire^.State:= Fire^.State or gsttmpFlag;
-				Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, dY, 0);
+Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, dY, 0);
-				Fire^.State:= Fire^.State or gsttmpFlag;
+Fire^.State:= Fire^.State or gsttmpFlag;
-				Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, -dY, 0);
+Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, -dY, 0);
-				Fire^.State:= Fire^.State or gsttmpFlag;
+Fire^.State:= Fire^.State or gsttmpFlag;
-		end;
+end;
-		DeleteGear(Gear);
+DeleteGear(Gear);
-		exit
+exit
-	end;
+end;
 end;
 procedure doStepWatermelon(Gear: PGear);
 begin
 AllInactive:= false;
 procedure doStepCluster(Gear: PGear);
 begin
 AllInactive:= false;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, EXPLAutoSound);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 if Gear^.Kind = gtMelonPiece then
-	CalcRotationDirAngle(Gear)
+CalcRotationDirAngle(Gear)
 else
-	if (GameTicks and $1F) = 0 then
+if (GameTicks and $1F) = 0 then
-		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepGrenade(Gear: PGear);
 begin
 AllInactive:= false;
 Gear^.dX:= Gear^.dX + cWindSpeed;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 if (GameTicks and $3F) = 0 then
-	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepHealthTagWork(Gear: PGear);
 begin
 if Gear^.Kind = gtHealthTag then
-	AllInactive:= false;
+AllInactive:= false;
 dec(Gear^.Timer);
 Gear^.Y:= Gear^.Y + Gear^.dY;
 if Gear^.Timer = 0 then
-	begin
+begin
-	if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then
+if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then
-		PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die
+PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die
-	DeleteGear(Gear)
+DeleteGear(Gear)
-	end
+end
 end;
 procedure doStepHealthTagWorkUnderWater(Gear: PGear);
 begin
 AllInactive:= false;
 Gear^.Y:= Gear^.Y - _0_08;
 if hwRound(Gear^.Y) < cWaterLine + 10 then
-	DeleteGear(Gear)
+DeleteGear(Gear)
 end;
 procedure doStepHealthTag(Gear: PGear);
 var s: shortstring;
 begin
 str(Gear^.State, s);
 Gear^.Tex:= RenderStringTex(s, PHedgehog(Gear^.Hedgehog)^.Team^.Clan^.Color, fnt16);
 if hwRound(Gear^.Y) < cWaterLine then
-	Gear^.doStep:= @doStepHealthTagWork
+Gear^.doStep:= @doStepHealthTagWork
 else
-	Gear^.doStep:= @doStepHealthTagWorkUnderWater;
+Gear^.doStep:= @doStepHealthTagWorkUnderWater;
 Gear^.Y:= Gear^.Y - int2hwFloat(Gear^.Tex^.h)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepShotIdle(Gear: PGear);
 begin
 AllInactive:= false;
 inc(Gear^.Timer);
 if Gear^.Timer > 75 then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack
+AfterAttack
-	end
+end
 end;
 procedure doStepShotgunShot(Gear: PGear);
 var i: LongWord;
 shell: PVisualGear;
 begin
 AllInactive:= false;
 if ((Gear^.State and gstAnimation) = 0) then
-	begin
+begin
-	dec(Gear^.Timer);
+dec(Gear^.Timer);
-	if Gear^.Timer = 0 then
+if Gear^.Timer = 0 then
-		begin
+begin
-		PlaySound(sndShotgunFire);
+PlaySound(sndShotgunFire);
-		shell:= AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell);
+shell:= AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell);
 if shell <> nil then
 begin
 shell^.dX:= gear^.dX / -4;
 shell^.dY:= gear^.dY / -4;
 shell^.Frame:= 0
 end;
-		Gear^.State:= Gear^.State or gstAnimation
+Gear^.State:= Gear^.State or gstAnimation
-		end;
+end;
-	exit
+exit
-	end
+end
-	else inc(Gear^.Timer);
+else inc(Gear^.Timer);
 i:= 200;
 repeat
 Gear^.X:= Gear^.X + Gear^.dX;
 Gear^.Y:= Gear^.Y + Gear^.dY;
 CheckCollision(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	begin
+begin
-	Gear^.X:= Gear^.X + Gear^.dX * 8;
+Gear^.X:= Gear^.X + Gear^.dX * 8;
-	Gear^.Y:= Gear^.Y + Gear^.dY * 8;
+Gear^.Y:= Gear^.Y + Gear^.dY * 8;
-	ShotgunShot(Gear);
+ShotgunShot(Gear);
-	Gear^.doStep:= @doStepShotIdle;
+Gear^.doStep:= @doStepShotIdle;
-	exit
+exit
-	end;
+end;
 dec(i)
 until i = 0;
 if (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then
-	Gear^.doStep:= @doStepShotIdle
+Gear^.doStep:= @doStepShotIdle
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBulletWork(Gear: PGear);
 var i, x, y: LongWord;
 dec(Gear^.Health, Gear^.Damage);
 Gear^.Damage:= 0
 end;
 if (Gear^.Health <= 0)
-	or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0)
+or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0)
-	or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then
+or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then
 begin
 if (Gear^.Kind = gtSniperRifleShot) and ((GameFlags and gfLaserSight) = 0) then cLaserSighting:= false;
 if (Gear^.Ammo^.NumPerTurn <= CurrentHedgehog^.MultiShootAttacks) and
 ((GameFlags and gfArtillery) = 0) then cArtillery:= false;
-	Gear^.doStep:= @doStepShotIdle
+Gear^.doStep:= @doStepShotIdle
 end;
 end;
 procedure doStepDEagleShot(Gear: PGear);
 begin
 if (TurnTimeLeft > 0) then
 dec(TurnTimeLeft)
 else
 begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack
+AfterAttack
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepActionTimer(Gear: PGear);
 begin
 AllInactive:= false;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 dec(Gear^.Timer);
 if (Gear^.Timer = 0)or((Gear^.Message and gm_Destroy) <> 0)or((HHGear^.State and gstHHDriven) = 0) then
-	begin
+begin
-	StopSound(Gear^.SoundChannel);
+StopSound(Gear^.SoundChannel);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack;
+AfterAttack;
-	exit
+exit
-	end;
+end;
 if (Gear^.Timer mod 33) = 0 then
-	begin
+begin
-	HHGear^.State:= HHGear^.State or gstNoDamage;
+HHGear^.State:= HHGear^.State or gstNoDamage;
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y) + 7, 6, EXPLDontDraw);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y) + 7, 6, EXPLDontDraw);
-	HHGear^.State:= HHGear^.State and not gstNoDamage
+HHGear^.State:= HHGear^.State and not gstNoDamage
-	end;
+end;
 if (Gear^.Timer mod 47) = 0 then
-	begin
+begin
-	i:= hwRound(Gear^.X) - Gear^.Radius - LongInt(GetRandom(2));
+i:= hwRound(Gear^.X) - Gear^.Radius - LongInt(GetRandom(2));
-	ei:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2));
+ei:= hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2));
-	while i <= ei do
+while i <= ei do
-		begin
+begin
-		DrawExplosion(i, hwRound(Gear^.Y) + 3, 3);
+DrawExplosion(i, hwRound(Gear^.Y) + 3, 3);
-		inc(i, 1)
+inc(i, 1)
-		end;
+end;
 if CheckLandValue(hwRound(Gear^.X + Gear^.dX + SignAs(_6,Gear^.dX)), hwRound(Gear^.Y + _1_9), COLOR_INDESTRUCTIBLE) then
 begin
 Gear^.X:= Gear^.X + Gear^.dX;
 Gear^.Y:= Gear^.Y + _1_9;
 end;
-	SetAllHHToActive;
+SetAllHHToActive;
-	end;
+end;
 if TestCollisionYwithGear(Gear, 1) then
-	begin
+begin
-	Gear^.dY:= _0;
+Gear^.dY:= _0;
-	SetLittle(HHGear^.dX);
+SetLittle(HHGear^.dX);
-	HHGear^.dY:= _0;
+HHGear^.dY:= _0;
-	end else
+end else
-	begin
+begin
-	Gear^.dY:= Gear^.dY + cGravity;
+Gear^.dY:= Gear^.dY + cGravity;
-	Gear^.Y:= Gear^.Y + Gear^.dY;
+Gear^.Y:= Gear^.Y + Gear^.dY;
-	if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer:= 1
+if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer:= 1
-	end;
+end;
 Gear^.X:= Gear^.X + HHGear^.dX;
 HHGear^.X:= Gear^.X;
 HHGear^.Y:= Gear^.Y - int2hwFloat(cHHRadius);
 ////////////////////////////////////////////////////////////////////////////////
 var BTPrevAngle, BTSteps: LongInt;
 procedure doStepBlowTorchWork(Gear: PGear);
 var HHGear: PGear;
-	b: boolean;
+b: boolean;
-	prevX: LongInt;
+prevX: LongInt;
 begin
 AllInactive:= false;
 dec(Gear^.Timer);
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 HedgehogChAngle(HHGear);
 b:= false;
 if abs(LongInt(HHGear^.Angle) - BTPrevAngle) > 7  then
-	begin
+begin
-	Gear^.dX:= SignAs(AngleSin(HHGear^.Angle) * _0_5, HHGear^.dX);
+Gear^.dX:= SignAs(AngleSin(HHGear^.Angle) * _0_5, HHGear^.dX);
-	Gear^.dY:= AngleCos(HHGear^.Angle) * ( - _0_5);
+Gear^.dY:= AngleCos(HHGear^.Angle) * ( - _0_5);
-	BTPrevAngle:= HHGear^.Angle;
+BTPrevAngle:= HHGear^.Angle;
-	b:= true
+b:= true
-	end;
+end;
 if ((HHGear^.State and gstMoving) <> 0) then
-	begin
+begin
-	doStepHedgehogMoving(HHGear);
+doStepHedgehogMoving(HHGear);
-	if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer:= 0
+if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer:= 0
-	end;
+end;
 if Gear^.Timer mod cHHStepTicks = 0 then
-	begin
+begin
-	b:= true;
+b:= true;
-	if Gear^.dX.isNegative then
+if Gear^.dX.isNegative then
-		HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Left
+HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Left
-	else
+else
-		HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Right;
+HHGear^.Message:= (HHGear^.Message and (gm_Attack or gm_Up or gm_Down)) or gm_Right;
-	if ((HHGear^.State and gstMoving) = 0) then
+if ((HHGear^.State and gstMoving) = 0) then
-		begin
+begin
-		HHGear^.State:= HHGear^.State and not gstAttacking;
+HHGear^.State:= HHGear^.State and not gstAttacking;
-		prevX:= hwRound(HHGear^.X);
+prevX:= hwRound(HHGear^.X);
 // why the call to HedgehogStep then a further increment of X?
 if (prevX = hwRound(HHGear^.X)) and
 CheckLandValue(hwRound(HHGear^.X + SignAs(_6, HHGear^.dX)), hwRound(HHGear^.Y), COLOR_INDESTRUCTIBLE) then HedgehogStep(HHGear);
 if (prevX = hwRound(HHGear^.X)) and
 CheckLandValue(hwRound(HHGear^.X + SignAs(_6, HHGear^.dX)), hwRound(HHGear^.Y), COLOR_INDESTRUCTIBLE) then HHGear^.X:= HHGear^.X + SignAs(_1, HHGear^.dX);
-		HHGear^.State:= HHGear^.State or gstAttacking
+HHGear^.State:= HHGear^.State or gstAttacking
-		end;
+end;
-	inc(BTSteps);
+inc(BTSteps);
-	if BTSteps = 7 then
+if BTSteps = 7 then
-		begin
+begin
-		BTSteps:= 0;
+BTSteps:= 0;
 if CheckLandValue(hwRound(HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC) + SignAs(_6,Gear^.dX)), hwRound(HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC)), COLOR_INDESTRUCTIBLE) then
 begin
-		    Gear^.X:= HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC);
+Gear^.X:= HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC);
-		    Gear^.Y:= HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC);
+Gear^.Y:= HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC);
 end;
-		HHGear^.State:= HHGear^.State or gstNoDamage;
+HHGear^.State:= HHGear^.State or gstNoDamage;
-		AmmoShove(Gear, 2, 15);
+AmmoShove(Gear, 2, 15);
-		HHGear^.State:= HHGear^.State and not gstNoDamage
+HHGear^.State:= HHGear^.State and not gstNoDamage
-		end;
+end;
-	end;
+end;
 if b then
 DrawTunnel(HHGear^.X - Gear^.dX * cHHRadius, HHGear^.Y - _4 - Gear^.dY * cHHRadius + hwAbs(Gear^.dY) * 7,
 Gear^.dX, Gear^.dY,
 cHHRadius * 5, cHHRadius * 2 + 7);
 if (Gear^.Timer = 0) or ((HHGear^.Message and gm_Attack) <> 0) then
-	begin
+begin
-	HHGear^.Message:= 0;
+HHGear^.Message:= 0;
-	HHGear^.State:= HHGear^.State and (not gstNotKickable);
+HHGear^.State:= HHGear^.State and (not gstNotKickable);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack
+AfterAttack
-	end
+end
 end;
 procedure doStepBlowTorch(Gear: PGear);
 var HHGear: PGear;
 begin
 procedure doStepRopeAfterAttack(Gear: PGear);
 var HHGear: PGear;
 begin
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 if ((HHGear^.State and gstHHDriven) = 0)
-	or (CheckGearDrowning(HHGear))
+or (CheckGearDrowning(HHGear))
-	or TestCollisionYwithGear(HHGear, 1) then
+or TestCollisionYwithGear(HHGear, 1) then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	isCursorVisible:= false;
+isCursorVisible:= false;
-	exit
+exit
-	end;
+end;
 HedgehogChAngle(HHGear);
 if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX);
 HHGear^.X:= HHGear^.X + HHGear^.dX;
 HHGear^.Y:= HHGear^.Y + HHGear^.dY;
 HHGear^.dY:= HHGear^.dY + cGravity;
 if (Gear^.Message and gm_Attack) <> 0 then
-	begin
+begin
-	Gear^.X:= HHGear^.X;
+Gear^.X:= HHGear^.X;
-	Gear^.Y:= HHGear^.Y;
+Gear^.Y:= HHGear^.Y;
-	ApplyAngleBounds(PHedgehog(Gear^.Hedgehog)^, amRope);
+ApplyAngleBounds(PHedgehog(Gear^.Hedgehog)^, amRope);
-	Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX);
+Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX);
-	Gear^.dY:= -AngleCos(HHGear^.Angle);
+Gear^.dY:= -AngleCos(HHGear^.Angle);
-	Gear^.Friction:= _450;
+Gear^.Friction:= _450;
-	Gear^.Elasticity:= _0;
+Gear^.Elasticity:= _0;
-	Gear^.State:= Gear^.State and not gsttmpflag;
+Gear^.State:= Gear^.State and not gsttmpflag;
-	Gear^.doStep:= @doStepRope
+Gear^.doStep:= @doStepRope
-	end
+end
 end;
 procedure doStepRopeWork(Gear: PGear);
 var HHGear: PGear;
-	len, tx, ty, nx, ny, ropeDx, ropeDy, mdX, mdY: hwFloat;
+len, tx, ty, nx, ny, ropeDx, ropeDy, mdX, mdY: hwFloat;
-	lx, ly: LongInt;
+lx, ly: LongInt;
-	haveCollision,
+haveCollision,
-	haveDivided: boolean;
+haveDivided: boolean;
-	procedure DeleteMe;
+procedure DeleteMe;
-	begin
+begin
-	with HHGear^ do
+with HHGear^ do
-		begin
+begin
-		Message:= Message and not gm_Attack;
+Message:= Message and not gm_Attack;
-		State:= (State or gstMoving) and not gstWinner;
+State:= (State or gstMoving) and not gstWinner;
-		end;
+end;
-	DeleteGear(Gear)
+DeleteGear(Gear)
-	end;
+end;
-	procedure WaitCollision;
+procedure WaitCollision;
-	begin
+begin
-	with HHGear^ do
+with HHGear^ do
-		begin
+begin
-		Message:= Message and not gm_Attack;
+Message:= Message and not gm_Attack;
-		State:= State or gstMoving;
+State:= State or gstMoving;
-		end;
+end;
-	RopePoints.Count:= 0;
+RopePoints.Count:= 0;
-	Gear^.Elasticity:= _0;
+Gear^.Elasticity:= _0;
-	Gear^.doStep:= @doStepRopeAfterAttack
+Gear^.doStep:= @doStepRopeAfterAttack
-	end;
+end;
 begin
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 if ((HHGear^.State and gstHHDriven) = 0)
-	or (CheckGearDrowning(HHGear)) then
+or (CheckGearDrowning(HHGear)) then
-	begin
+begin
-	DeleteMe;
+DeleteMe;
-	exit
+exit
-	end;
+end;
 if (Gear^.Message and gm_Left  <> 0) then HHGear^.dX:= HHGear^.dX - _0_0002 else
 if (Gear^.Message and gm_Right <> 0) then HHGear^.dX:= HHGear^.dX + _0_0002;
 if not TestCollisionYwithGear(HHGear, 1) then HHGear^.dY:= HHGear^.dY + cGravity;
 Gear^.dX:= mdX; // for visual purposes only
 Gear^.dY:= mdY;
 /////
-	tx:= HHGear^.X;
+tx:= HHGear^.X;
-	ty:= HHGear^.Y;
+ty:= HHGear^.Y;
-	if ((Gear^.Message and gm_Down) <> 0) and (Gear^.Elasticity < Gear^.Friction) then
+if ((Gear^.Message and gm_Down) <> 0) and (Gear^.Elasticity < Gear^.Friction) then
-		if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx))
+if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx))
-				or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then
+or TestCollisionYwithGear(HHGear, hwSign(ropeDy))) then
-					Gear^.Elasticity:= Gear^.Elasticity + _0_3;
+Gear^.Elasticity:= Gear^.Elasticity + _0_3;
-	if ((Gear^.Message and gm_Up) <> 0) and (Gear^.Elasticity > _30) then
+if ((Gear^.Message and gm_Up) <> 0) and (Gear^.Elasticity > _30) then
-		if not (TestCollisionXwithGear(HHGear, -hwSign(ropeDx))
+if not (TestCollisionXwithGear(HHGear, -hwSign(ropeDx))
-				or TestCollisionYwithGear(HHGear, -hwSign(ropeDy))) then
+or TestCollisionYwithGear(HHGear, -hwSign(ropeDy))) then
-					Gear^.Elasticity:= Gear^.Elasticity - _0_3;
+Gear^.Elasticity:= Gear^.Elasticity - _0_3;
-	HHGear^.X:= Gear^.X + mdX * Gear^.Elasticity;
+HHGear^.X:= Gear^.X + mdX * Gear^.Elasticity;
-	HHGear^.Y:= Gear^.Y + mdY * Gear^.Elasticity;
+HHGear^.Y:= Gear^.Y + mdY * Gear^.Elasticity;
-	HHGear^.dX:= HHGear^.X - tx;
+HHGear^.dX:= HHGear^.X - tx;
-	HHGear^.dY:= HHGear^.Y - ty;
+HHGear^.dY:= HHGear^.Y - ty;
 ////
-	haveDivided:= false;
+haveDivided:= false;
-	// check whether rope needs dividing
+// check whether rope needs dividing
-	len:= _1 / Distance(ropeDx, ropeDy); // old rope pos
+len:= _1 / Distance(ropeDx, ropeDy); // old rope pos
-	nx:= ropeDx * len;
+nx:= ropeDx * len;
-	ny:= ropeDy * len;
+ny:= ropeDy * len;
-	len:= Gear^.Elasticity - _0_3x70;
+len:= Gear^.Elasticity - _0_3x70;
-	while len > _3 do
+while len > _3 do
-			begin
+begin
-			lx:= hwRound(Gear^.X + mdX * len);
+lx:= hwRound(Gear^.X + mdX * len);
-			ly:= hwRound(Gear^.Y + mdY * len);
+ly:= hwRound(Gear^.Y + mdY * len);
-			if ((ly and LAND_HEIGHT_MASK) = 0) and ((lx and LAND_WIDTH_MASK) = 0) and (Land[ly, lx] <> 0) then
+if ((ly and LAND_HEIGHT_MASK) = 0) and ((lx and LAND_WIDTH_MASK) = 0) and (Land[ly, lx] <> 0) then
-				begin
+begin
-				with RopePoints.ar[RopePoints.Count] do
+with RopePoints.ar[RopePoints.Count] do
-					begin
+begin
-					X:= Gear^.X;
+X:= Gear^.X;
-					Y:= Gear^.Y;
+Y:= Gear^.Y;
-					if RopePoints.Count = 0 then RopePoints.HookAngle:= DxDy2Angle(Gear^.dY, Gear^.dX);
+if RopePoints.Count = 0 then RopePoints.HookAngle:= DxDy2Angle(Gear^.dY, Gear^.dX);
-					b:= (nx * HHGear^.dY) > (ny * HHGear^.dX);
+b:= (nx * HHGear^.dY) > (ny * HHGear^.dX);
-					dLen:= len
+dLen:= len
-					end;
+end;
-				with RopePoints.rounded[RopePoints.Count] do
+with RopePoints.rounded[RopePoints.Count] do
-					begin
+begin
-					X:= hwRound(Gear^.X);
+X:= hwRound(Gear^.X);
-					Y:= hwRound(Gear^.Y);
+Y:= hwRound(Gear^.Y);
-					end;
+end;
-				Gear^.X:= Gear^.X + nx * len;
+Gear^.X:= Gear^.X + nx * len;
-				Gear^.Y:= Gear^.Y + ny * len;
+Gear^.Y:= Gear^.Y + ny * len;
-				inc(RopePoints.Count);
+inc(RopePoints.Count);
-				TryDo(RopePoints.Count <= MAXROPEPOINTS, 'Rope points overflow', true);
+TryDo(RopePoints.Count <= MAXROPEPOINTS, 'Rope points overflow', true);
-				Gear^.Elasticity:= Gear^.Elasticity - len;
+Gear^.Elasticity:= Gear^.Elasticity - len;
-				Gear^.Friction:= Gear^.Friction - len;
+Gear^.Friction:= Gear^.Friction - len;
-				haveDivided:= true;
+haveDivided:= true;
-				break
+break
-				end;
+end;
-			len:= len - _0_3 // should be the same as increase step
+len:= len - _0_3 // should be the same as increase step
-			end;
+end;
 if not haveDivided then
-	if RopePoints.Count > 0 then // check whether the last dividing point could be removed
+if RopePoints.Count > 0 then // check whether the last dividing point could be removed
-		begin
+begin
-		tx:= RopePoints.ar[Pred(RopePoints.Count)].X;
+tx:= RopePoints.ar[Pred(RopePoints.Count)].X;
-		ty:= RopePoints.ar[Pred(RopePoints.Count)].Y;
+ty:= RopePoints.ar[Pred(RopePoints.Count)].Y;
-		if RopePoints.ar[Pred(RopePoints.Count)].b xor ((tx - Gear^.X) * (ty - HHGear^.Y) > (tx - HHGear^.X) * (ty - Gear^.Y)) then
+if RopePoints.ar[Pred(RopePoints.Count)].b xor ((tx - Gear^.X) * (ty - HHGear^.Y) > (tx - HHGear^.X) * (ty - Gear^.Y)) then
-			begin
+begin
-			dec(RopePoints.Count);
+dec(RopePoints.Count);
-			Gear^.X:= RopePoints.ar[RopePoints.Count].X;
+Gear^.X:= RopePoints.ar[RopePoints.Count].X;
-			Gear^.Y:= RopePoints.ar[RopePoints.Count].Y;
+Gear^.Y:= RopePoints.ar[RopePoints.Count].Y;
-			Gear^.Elasticity:= Gear^.Elasticity + RopePoints.ar[RopePoints.Count].dLen;
+Gear^.Elasticity:= Gear^.Elasticity + RopePoints.ar[RopePoints.Count].dLen;
-			Gear^.Friction:= Gear^.Friction + RopePoints.ar[RopePoints.Count].dLen
+Gear^.Friction:= Gear^.Friction + RopePoints.ar[RopePoints.Count].dLen
-			end
+end
-		end;
+end;
 haveCollision:= false;
 if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then
-	begin
+begin
-	HHGear^.dX:= -_0_6 * HHGear^.dX;
+HHGear^.dX:= -_0_6 * HHGear^.dX;
-	haveCollision:= true
+haveCollision:= true
-	end;
+end;
 if TestCollisionYwithGear(HHGear, hwSign(HHGear^.dY)) then
-	begin
+begin
-	HHGear^.dY:= -_0_6 * HHGear^.dY;
+HHGear^.dY:= -_0_6 * HHGear^.dY;
-	haveCollision:= true
+haveCollision:= true
-	end;
+end;
 if haveCollision
-	and (Gear^.Message and (gm_Left or gm_Right) <> 0)
+and (Gear^.Message and (gm_Left or gm_Right) <> 0)
-	and (Gear^.Message and (gm_Up or gm_Down) <> 0) then
+and (Gear^.Message and (gm_Up or gm_Down) <> 0) then
-	begin
+begin
-	HHGear^.dX:= SignAs(hwAbs(HHGear^.dX) + _0_2, HHGear^.dX);
+HHGear^.dX:= SignAs(hwAbs(HHGear^.dX) + _0_2, HHGear^.dX);
-	HHGear^.dY:= SignAs(hwAbs(HHGear^.dY) + _0_2, HHGear^.dY)
+HHGear^.dY:= SignAs(hwAbs(HHGear^.dY) + _0_2, HHGear^.dY)
-	end;
+end;
 len:= Distance(HHGear^.dX, HHGear^.dY);
 if len > _0_8 then
-	begin
+begin
-	len:= _0_8 / len;
+len:= _0_8 / len;
-	HHGear^.dX:= HHGear^.dX * len;
+HHGear^.dX:= HHGear^.dX * len;
-	HHGear^.dY:= HHGear^.dY * len;
+HHGear^.dY:= HHGear^.dY * len;
-	end;
+end;
 if (Gear^.Message and gm_Attack) <> 0 then
-	if (Gear^.State and gsttmpFlag) <> 0 then
+if (Gear^.State and gsttmpFlag) <> 0 then
-		with PHedgehog(Gear^.Hedgehog)^ do
+with PHedgehog(Gear^.Hedgehog)^ do
-			if Ammo^[CurSlot, CurAmmo].AmmoType <> amParachute then
+if Ammo^[CurSlot, CurAmmo].AmmoType <> amParachute then
-				WaitCollision
+WaitCollision
-			else
+else
-				DeleteMe
+DeleteMe
-	else
+else
 else
-	if (Gear^.State and gsttmpFlag) = 0 then
+if (Gear^.State and gsttmpFlag) = 0 then
-		Gear^.State:= Gear^.State or gsttmpFlag;
+Gear^.State:= Gear^.State or gsttmpFlag;
 end;
 procedure doStepRopeAttach(Gear: PGear);
 var HHGear: PGear;
-	tx, ty, tt: hwFloat;
+tx, ty, tt: hwFloat;
-	procedure RemoveFromAmmo;
+procedure RemoveFromAmmo;
-	begin
+begin
-	if (Gear^.State and gstAttacked) = 0 then
+if (Gear^.State and gstAttacked) = 0 then
-		begin
+begin
-		OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
+OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
-		Gear^.State:= Gear^.State or gstAttacked
+Gear^.State:= Gear^.State or gstAttacked
-		end;
+end;
-	ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^)
+ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^)
-	end;
+end;
 begin
 Gear^.X:= Gear^.X - Gear^.dX;
 Gear^.Y:= Gear^.Y - Gear^.dY;
 Gear^.Elasticity:= Gear^.Elasticity + _1;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 DeleteCI(HHGear);
 if (HHGear^.State and gstMoving) <> 0 then
-	begin
+begin
-	if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX);
+if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX);
-	if HHGear^.dY.isNegative and TestCollisionYwithGear(HHGear, -1) then HHGear^.dY:= _0;
+if HHGear^.dY.isNegative and TestCollisionYwithGear(HHGear, -1) then HHGear^.dY:= _0;
-	HHGear^.X:= HHGear^.X + HHGear^.dX;
+HHGear^.X:= HHGear^.X + HHGear^.dX;
-	Gear^.X:= Gear^.X + HHGear^.dX;
+Gear^.X:= Gear^.X + HHGear^.dX;
-	if TestCollisionYwithGear(HHGear, 1) then
+if TestCollisionYwithGear(HHGear, 1) then
-		begin
+begin
-		CheckHHDamage(HHGear);
+CheckHHDamage(HHGear);
-		HHGear^.dY:= _0;
+HHGear^.dY:= _0;
-		//HHGear^.State:= HHGear^.State and not (gstHHJumping or gstHHHJump);
+//HHGear^.State:= HHGear^.State and not (gstHHJumping or gstHHHJump);
-		end else
+end else
-		begin
+begin
-		HHGear^.Y:= HHGear^.Y + HHGear^.dY;
+HHGear^.Y:= HHGear^.Y + HHGear^.dY;
-		Gear^.Y:= Gear^.Y + HHGear^.dY;
+Gear^.Y:= Gear^.Y + HHGear^.dY;
-		HHGear^.dY:= HHGear^.dY + cGravity;
+HHGear^.dY:= HHGear^.dY + cGravity;
-		end;
+end;
-	tt:= Gear^.Elasticity;
+tt:= Gear^.Elasticity;
-	tx:= _0;
+tx:= _0;
-	ty:= _0;
+ty:= _0;
-	while tt > _20 do
+while tt > _20 do
-		begin
+begin
-		if  TestCollisionXwithXYShift(Gear, tx, hwRound(ty), -hwSign(Gear^.dX))
+if  TestCollisionXwithXYShift(Gear, tx, hwRound(ty), -hwSign(Gear^.dX))
-		or TestCollisionYwithXYShift(Gear, hwRound(tx), hwRound(ty), -hwSign(Gear^.dY)) then
+or TestCollisionYwithXYShift(Gear, hwRound(tx), hwRound(ty), -hwSign(Gear^.dY)) then
-			begin
+begin
-			Gear^.X:= Gear^.X + tx;
+Gear^.X:= Gear^.X + tx;
-			Gear^.Y:= Gear^.Y + ty;
+Gear^.Y:= Gear^.Y + ty;
-			Gear^.Elasticity:= tt;
+Gear^.Elasticity:= tt;
-			Gear^.doStep:= @doStepRopeWork;
+Gear^.doStep:= @doStepRopeWork;
-			with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump);
+with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump);
-			RemoveFromAmmo;
+RemoveFromAmmo;
-			tt:= _0;
+tt:= _0;
-			exit
+exit
-			end;
+end;
-		tx:= tx + Gear^.dX + Gear^.dX;
+tx:= tx + Gear^.dX + Gear^.dX;
-		ty:= ty + Gear^.dY + Gear^.dY;
+ty:= ty + Gear^.dY + Gear^.dY;
-		tt:= tt - _2;
+tt:= tt - _2;
-		end;
+end;
-	end;
+end;
 CheckCollision(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	if Gear^.Elasticity < _10 then
+if Gear^.Elasticity < _10 then
-		Gear^.Elasticity:= _10000
+Gear^.Elasticity:= _10000
-	else
+else
-		begin
+begin
-		Gear^.doStep:= @doStepRopeWork;
+Gear^.doStep:= @doStepRopeWork;
-		with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump);
+with HHGear^ do State:= State and not (gstAttacking or gstHHJumping or gstHHHJump);
-		RemoveFromAmmo;
+RemoveFromAmmo;
-		exit
+exit
-		end;
+end;
 if (Gear^.Elasticity > Gear^.Friction)
 or ((Gear^.Message and gm_Attack) = 0)
 or ((HHGear^.State and gstHHDriven) = 0)
 or (HHGear^.Damage > 0) then
-	begin
+begin
-	with PHedgehog(Gear^.Hedgehog)^.Gear^ do
+with PHedgehog(Gear^.Hedgehog)^.Gear^ do
-		begin
+begin
-		State:= State and not gstAttacking;
+State:= State and not gstAttacking;
-		Message:= Message and not gm_Attack
+Message:= Message and not gm_Attack
-		end;
+end;
-	DeleteGear(Gear)
+DeleteGear(Gear)
-	end
+end
 end;
 procedure doStepRope(Gear: PGear);
 begin
 Gear^.dX:= - Gear^.dX;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSmokeTrace(Gear: PGear);
 begin
 inc(Gear^.Timer);
 if Gear^.Timer > 64 then
-	begin
+begin
-	Gear^.Timer:= 0;
+Gear^.Timer:= 0;
-	dec(Gear^.State)
+dec(Gear^.State)
-	end;
+end;
 Gear^.dX:= Gear^.dX + cWindSpeed;
 Gear^.X:= Gear^.X + Gear^.dX;
 if Gear^.State = 0 then DeleteGear(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepExplosionWork(Gear: PGear);
 begin
 inc(Gear^.Timer);
 if Gear^.Timer > 75 then
-	begin
+begin
-	inc(Gear^.State);
+inc(Gear^.State);
-	Gear^.Timer:= 0;
+Gear^.Timer:= 0;
-	if Gear^.State > 5 then DeleteGear(Gear)
+if Gear^.State > 5 then DeleteGear(Gear)
-	end;
+end;
 end;
 procedure doStepExplosion(Gear: PGear);
 var i: LongWord;
 begin
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMine(Gear: PGear);
 begin
 if (Gear^.State and gstMoving) <> 0 then
-	begin
+begin
-	DeleteCI(Gear);
+DeleteCI(Gear);
-	doStepFallingGear(Gear);
+doStepFallingGear(Gear);
-	if (Gear^.State and gstMoving) = 0 then
+if (Gear^.State and gstMoving) = 0 then
-		begin
+begin
-		AddGearCI(Gear);
+AddGearCI(Gear);
-		Gear^.dX:= _0;
+Gear^.dX:= _0;
-		Gear^.dY:= _0
+Gear^.dY:= _0
-		end;
+end;
-	CalcRotationDirAngle(Gear);
+CalcRotationDirAngle(Gear);
-	AllInactive:= false
+AllInactive:= false
-	end else
+end else
-	if ((GameTicks and $3F) = 25) then
+if ((GameTicks and $3F) = 25) then
-		doStepFallingGear(Gear);
+doStepFallingGear(Gear);
 if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Health <> 0) then
-	if ((Gear^.State and gstAttacking) = 0) then
+if ((Gear^.State and gstAttacking) = 0) then
-		begin
+begin
-		if ((GameTicks and $1F) = 0) then
+if ((GameTicks and $1F) = 0) then
-			if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State:= Gear^.State or gstAttacking
+if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State:= Gear^.State or gstAttacking
-		end else // gstAttacking <> 0
+end else // gstAttacking <> 0
-		begin
+begin
-		AllInactive:= false;
+AllInactive:= false;
-		if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick);
+if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick);
-		if Gear^.Timer = 0 then
+if Gear^.Timer = 0 then
-			begin
+begin
 if ((Gear^.State and gstWait) <> 0) or
 (cMineDudPercent = 0) or
-		       (getRandom(100) > cMineDudPercent) then
+(getRandom(100) > cMineDudPercent) then
 begin
-			   doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
-			   DeleteGear(Gear)
+DeleteGear(Gear)
 end
 else
 begin
-			   AddVisualGear(hwRound(Gear^.X) - 4  + Random(8), hwRound(Gear^.Y) - 4 - Random(4), vgtSmoke);
+AddVisualGear(hwRound(Gear^.X) - 4  + Random(8), hwRound(Gear^.Y) - 4 - Random(4), vgtSmoke);
-		       PlaySound(sndVaporize);
+PlaySound(sndVaporize);
 Gear^.Health:= 0;
 end;
-			exit
+exit
-			end;
+end;
-		dec(Gear^.Timer);
+dec(Gear^.Timer);
-		end else // gsttmpFlag = 0
+end else // gsttmpFlag = 0
-	if TurnTimeLeft = 0 then Gear^.State:= Gear^.State or gsttmpFlag;
+if TurnTimeLeft = 0 then Gear^.State:= Gear^.State or gsttmpFlag;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepDynamite(Gear: PGear);
 begin
 doStepFallingGear(Gear);
 AllInactive:= false;
 if Gear^.Timer mod 166 = 0 then inc(Gear^.Tag);
 if Gear^.Timer = 1000 then // might need better timing
-	makeHogsWorry(Gear^.X, Gear^.Y, 75);
+makeHogsWorry(Gear^.X, Gear^.Y, 75);
 if Gear^.Timer = 0 then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 dec(Gear^.Timer);
 end;
 ///////////////////////////////////////////////////////////////////////////////
 Increase damage as barrel smokes?
 Try tweaking friction some more
 *)
 procedure doStepRollingBarrel(Gear: PGear);
 var i: LongInt;
-	particle: PVisualGear;
+particle: PVisualGear;
 begin
 Gear^.State:= Gear^.State or gstAnimation;
 if ((Gear^.dX.QWordValue <> 0) or (Gear^.dY.QWordValue <> 0))  then
 begin
 DeleteCI(Gear);
 AllInactive:= false;
 if not Gear^.dY.isNegative and (Gear^.dY > _0_03) and TestCollisionYwithGear(Gear, 1) then
 begin
 inc(Gear^.Damage, hwRound(Gear^.dY * _30));
-	    for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do
+for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do
 begin
-		    particle:= AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
+particle:= AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
 if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX / 5)
 end
 end
 else if not Gear^.dX.isNegative and (Gear^.dX > _0_03) and TestCollisionXwithGear(Gear, 1) then
 inc(Gear^.Damage, hwRound(Gear^.dX * _30))
 else if Gear^.dX.isNegative and (Gear^.dX < -_0_03) and TestCollisionXwithGear(Gear, -1) then
 inc(Gear^.Damage, hwRound(Gear^.dX * -_30));
 if Gear^.Damage <> 0 then PlaySound(sndGraveImpact);
 doStepFallingGear(Gear);
 CalcRotationDirAngle(Gear);
-	CheckGearDrowning(Gear)
+CheckGearDrowning(Gear)
 end
 else AddGearCI(Gear);
 (*
 Attempt to make a barrel knock itself over an edge.  Would need more checks to avoid issues like burn damage
 begin
 x:= hwRound(Gear^.X);
 y:= hwRound(Gear^.Y);
 if (((y+1) and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) then
-	    if (Land[y+1, x] = 0) then
+if (Land[y+1, x] = 0) then
 begin
 if (((y+1) and LAND_HEIGHT_MASK) = 0) and (((x+Gear^.Radius-2) and LAND_WIDTH_MASK) = 0) and (Land[y+1, x+Gear^.Radius-2] = 0) then
 Gear^.dX:= -_0_08
 else if (((y+1 and LAND_HEIGHT_MASK)) = 0) and (((x-(Gear^.Radius-2)) and LAND_WIDTH_MASK) = 0) and (Land[y+1, x-(Gear^.Radius-2)] = 0) then
 Gear^.dX:= _0_08;
 end;
 procedure doStepCase(Gear: PGear);
 var i, x, y: LongInt;
-	k: TGearType;
+k: TGearType;
-	exBoom: boolean;
+exBoom: boolean;
-	dX, dY: HWFloat;
+dX, dY: HWFloat;
 begin
 k:= Gear^.Kind;
 exBoom:= false;
 if (Gear^.Message and gm_Destroy) > 0 then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	FreeActionsList;
+FreeActionsList;
-	SetAllToActive; // something (hh, mine, etc...) could be on top of the case
+SetAllToActive; // something (hh, mine, etc...) could be on top of the case
-	with CurrentHedgehog^ do
+with CurrentHedgehog^ do
-		if Gear <> nil then Gear^.Message:= Gear^.Message and not (gm_LJump or gm_HJump);
+if Gear <> nil then Gear^.Message:= Gear^.Message and not (gm_LJump or gm_HJump);
-	exit
+exit
-	end;
+end;
 if k = gtExplosives then
-	begin
+begin
 //if V > _0_03 then Gear^.State:= Gear^.State or gstAnimation;
 if hwAbs(Gear^.dX) > _0_15 then Gear^.doStep:= @doStepRollingBarrel;
 if ((Gear^.Health * 100 div cBarrelHealth) < random(90)) and ((GameTicks and $FF) = 0) then
 if (cBarrelHealth div Gear^.Health) > 2 then
 AddVisualGear(hwRound(Gear^.X) - 16 + Random(32), hwRound(Gear^.Y) - 2, vgtSmoke)
 else
 AddVisualGear(hwRound(Gear^.X) - 16 + Random(32), hwRound(Gear^.Y) - 2, vgtSmokeWhite);
-	dec(Gear^.Health, Gear^.Damage);
+dec(Gear^.Health, Gear^.Damage);
-	Gear^.Damage:= 0;
+Gear^.Damage:= 0;
-	if Gear^.Health <= 0 then
+if Gear^.Health <= 0 then
-		exBoom:= true;
+exBoom:= true;
-	end;
+end;
 if (Gear^.Damage > 0) or exBoom then
-	begin
+begin
-	x:= hwRound(Gear^.X);
+x:= hwRound(Gear^.X);
-	y:= hwRound(Gear^.Y);
+y:= hwRound(Gear^.Y);
-	DeleteGear(Gear); // <-- delete gear!
+DeleteGear(Gear); // <-- delete gear!
-	if k = gtCase then
+if k = gtCase then
-		begin
+begin
-		doMakeExplosion(x, y, 25, EXPLAutoSound);
+doMakeExplosion(x, y, 25, EXPLAutoSound);
-		for i:= 0 to 63 do
+for i:= 0 to 63 do
-			AddGear(x, y, gtFlame, 0, _0, _0, 0);
+AddGear(x, y, gtFlame, 0, _0, _0, 0);
-		end
+end
-	else if k = gtExplosives then
+else if k = gtExplosives then
-		begin
+begin
-		doMakeExplosion(x, y, 75, EXPLAutoSound);
+doMakeExplosion(x, y, 75, EXPLAutoSound);
-		for i:= 0 to 31 do
+for i:= 0 to 31 do
-			begin
+begin
-			dX:= AngleCos(i * 64) * _0_5 * (getrandom + _1);
+dX:= AngleCos(i * 64) * _0_5 * (getrandom + _1);
-			dY:= AngleSin(i * 64) * _0_5 * (getrandom + _1);
+dY:= AngleSin(i * 64) * _0_5 * (getrandom + _1);
-			AddGear(x, y, gtFlame, 0, dX, dY, 0);
+AddGear(x, y, gtFlame, 0, dX, dY, 0);
-			AddGear(x, y, gtFlame, 0, -dX, -dY, 0)^.State:= gsttmpFlag;
+AddGear(x, y, gtFlame, 0, -dX, -dY, 0)^.State:= gsttmpFlag;
-			end
+end
-		end;
+end;
-	exit
+exit
-	end;
+end;
 if (Gear^.dY.QWordValue <> 0) or (not TestCollisionYwithGear(Gear, 1)) then
-	begin
+begin
-	AllInactive:= false;
+AllInactive:= false;
 Gear^.dY:= Gear^.dY + cGravity;
 Gear^.Y:= Gear^.Y + Gear^.dY;
 if (not Gear^.dY.isNegative) and (Gear^.dY > _0_001) then SetAllHHToActive;
-	if (Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, -1) then Gear^.dY:= _0;
+if (Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, -1) then Gear^.dY:= _0;
-	if (not Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then
+if (not Gear^.dY.isNegative) and TestCollisionYwithGear(Gear, 1) then
-		begin
+begin
 if (Gear^.dY > _0_02) and (k = gtExplosives) then
 inc(Gear^.Damage, hwRound(Gear^.dY * _30));
-		if Gear^.dY > _0_2 then
+if Gear^.dY > _0_2 then
-	        for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do
+for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do
-		        AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
+AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);
-		Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
+Gear^.dY:= - Gear^.dY * Gear^.Elasticity;
-		if Gear^.dY > - _0_001 then Gear^.dY:= _0
+if Gear^.dY > - _0_001 then Gear^.dY:= _0
-			else if Gear^.dY < - _0_03 then PlaySound(sndGraveImpact)
+else if Gear^.dY < - _0_03 then PlaySound(sndGraveImpact)
-		end;
+end;
-	//if Gear^.dY > - _0_001 then Gear^.dY:= _0
+//if Gear^.dY > - _0_001 then Gear^.dY:= _0
-	CheckGearDrowning(Gear);
+CheckGearDrowning(Gear);
-	end;
+end;
 if (Gear^.dY.QWordValue = 0) then AddGearCI(Gear)
 else if (Gear^.dY.QWordValue <> 0) then DeleteCI(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepTarget(Gear: PGear);
 begin
 if (Gear^.Timer = 0) and (Gear^.Tag = 0) then
-	PlaySound(sndWarp);
+PlaySound(sndWarp);
 if (Gear^.Tag = 0) and (Gear^.Timer < 1000) then
-	inc(Gear^.Timer)
+inc(Gear^.Timer)
 else if Gear^.Tag = 1 then
-	begin
+begin
-		Gear^.Tag:= 2;
+Gear^.Tag:= 2;
-		if (TrainingFlags and tfTimeTrial) <> 0 then
+if (TrainingFlags and tfTimeTrial) <> 0 then
-			begin
+begin
-			inc(TurnTimeLeft, TrainingTimeInc);
+inc(TurnTimeLeft, TrainingTimeInc);
-			if TrainingTimeInc > TrainingTimeInM then
+if TrainingTimeInc > TrainingTimeInM then
-				dec(TrainingTimeInc, TrainingTimeInD);
+dec(TrainingTimeInc, TrainingTimeInD);
-			if TurnTimeLeft > TrainingTimeMax then
+if TurnTimeLeft > TrainingTimeMax then
-				TurnTimeLeft:= TrainingTimeMax;
+TurnTimeLeft:= TrainingTimeMax;
-			end;
+end;
-	end
+end
 else if Gear^.Tag = 2 then
-	if Gear^.Timer > 0 then
+if Gear^.Timer > 0 then
-		dec(Gear^.Timer)
+dec(Gear^.Timer)
-	else
+else
-		begin
+begin
-			if (TrainingFlags and tfTargetRespawn) <> 0 then
+if (TrainingFlags and tfTargetRespawn) <> 0 then
-				begin
+begin
-				TrainingTargetGear:= AddGear(0, 0, gtTarget, 0, _0, _0, 0);
+TrainingTargetGear:= AddGear(0, 0, gtTarget, 0, _0, _0, 0);
-				FindPlace(TrainingTargetGear, false, 0, LAND_WIDTH);
+FindPlace(TrainingTargetGear, false, 0, LAND_WIDTH);
-				end;
+end;
-			DeleteGear(Gear);
+DeleteGear(Gear);
-			exit;
+exit;
-		end;
+end;
 doStepCase(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepIdle(Gear: PGear);
 begin
 AllInactive:= false;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack
+AfterAttack
-	end
+end
 end;
 procedure doStepShover(Gear: PGear);
 var HHGear: PGear;
 begin
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 HHGear^.State:= HHGear^.State or gstNoDamage;
 DeleteCI(HHGear);
 for i:= 0 to 3 do
-	begin
+begin
-	AmmoShove(Gear, 30, 25);
+AmmoShove(Gear, 30, 25);
-	Gear^.X:= Gear^.X + Gear^.dX * 5
+Gear^.X:= Gear^.X + Gear^.dX * 5
-	end;
+end;
 HHGear^.State:= HHGear^.State and not gstNoDamage;
 Gear^.Timer:= 250;
 Gear^.doStep:= @doStepIdle
 end;
 var i: Integer;
 begin
 if (Gear^.State and gsttmpFlag) = 0 then AllInactive:= false;
 if not TestCollisionYwithGear(Gear, 1) then
-	begin
+begin
 AllInactive:= false;
-	if hwAbs(Gear^.dX) > _0_01 then
+if hwAbs(Gear^.dX) > _0_01 then
-		Gear^.dX:= Gear^.dX * _0_995;
+Gear^.dX:= Gear^.dX * _0_995;
-	 if (Gear^.State and gsttmpFlag) <> 0 then Gear^.dY:= Gear^.dY + _2*cGravity else
+if (Gear^.State and gsttmpFlag) <> 0 then Gear^.dY:= Gear^.dY + _2*cGravity else
-	Gear^.dY:= Gear^.dY + cGravity;
+Gear^.dY:= Gear^.dY + cGravity;
-	if hwAbs(Gear^.dY) > _0_2 then Gear^.dY:= Gear^.dY * _0_995;
+if hwAbs(Gear^.dY) > _0_2 then Gear^.dY:= Gear^.dY * _0_995;
-	if (Gear^.State and gsttmpFlag) <> 0 then Gear^.X:= Gear^.X + Gear^.dX else
+if (Gear^.State and gsttmpFlag) <> 0 then Gear^.X:= Gear^.X + Gear^.dX else
-	Gear^.X:= Gear^.X + Gear^.dX + cWindSpeed * 640;
+Gear^.X:= Gear^.X + Gear^.dX + cWindSpeed * 640;
-	Gear^.Y:= Gear^.Y + Gear^.dY;
+Gear^.Y:= Gear^.Y + Gear^.dY;
-	if (hwRound(Gear^.Y) > cWaterLine) then
+if (hwRound(Gear^.Y) > cWaterLine) then
-		begin
+begin
-		for i:= 0 to 3 do
+for i:= 0 to 3 do
-			AddVisualGear(hwRound(Gear^.X) - 16 + Random(32), hwRound(Gear^.Y) - 16 + Random(16), vgtSteam);
+AddVisualGear(hwRound(Gear^.X) - 16 + Random(32), hwRound(Gear^.Y) - 16 + Random(16), vgtSteam);
-		PlaySound(sndVaporize);
+PlaySound(sndVaporize);
-		DeleteGear(Gear);
+DeleteGear(Gear);
-		exit
+exit
-		end
+end
 end else begin
 if (Gear^.State and gsttmpFlag) <> 0 then
 begin
 Gear^.Radius:= 9;
 AmmoShove(Gear, 2, 30);
 Gear^.Radius:= 1
 end;
-	    if Gear^.Timer > 0 then
+if Gear^.Timer > 0 then
 begin
 dec(Gear^.Timer);
 inc(Gear^.Damage)
 end
 else begin
 for i:= 0 to Random(3) do
 AddVisualGear(hwRound(Gear^.X) - 3 + Random(6), hwRound(Gear^.Y) - 2, vgtSmoke);
 end;
 // This one is interesting.  I think I understand the purpose, but I wonder if a bit more fuzzy of kicking could be done with getrandom.
-	    Gear^.Timer:= 100 - Gear^.Tag * 3;
+Gear^.Timer:= 100 - Gear^.Tag * 3;
 if (Gear^.Damage > 3000+Gear^.Tag*1500) then Gear^.Health:= 0
 end
 end
 end;
 if Gear^.Health = 0 then begin
 procedure doStepFirePunchWork(Gear: PGear);
 var HHGear: PGear;
 begin
 AllInactive:= false;
 if ((Gear^.Message and gm_Destroy) <> 0) then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack;
+AfterAttack;
-	exit
+exit
-	end;
+end;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 if hwRound(HHGear^.Y) <= Gear^.Tag - 2 then
-	begin
+begin
-	Gear^.Tag:= hwRound(HHGear^.Y);
+Gear^.Tag:= hwRound(HHGear^.Y);
-	DrawTunnel(HHGear^.X - int2hwFloat(cHHRadius), HHGear^.Y - _1, _0_5, _0, cHHRadius * 4, 2);
+DrawTunnel(HHGear^.X - int2hwFloat(cHHRadius), HHGear^.Y - _1, _0_5, _0, cHHRadius * 4, 2);
-	HHGear^.State:= HHGear^.State or gstNoDamage;
+HHGear^.State:= HHGear^.State or gstNoDamage;
-	Gear^.Y:= HHGear^.Y;
+Gear^.Y:= HHGear^.Y;
-	AmmoShove(Gear, 30, 40);
+AmmoShove(Gear, 30, 40);
-	HHGear^.State:= HHGear^.State and not gstNoDamage
+HHGear^.State:= HHGear^.State and not gstNoDamage
-	end;
+end;
 HHGear^.dY:= HHGear^.dY + cGravity;
 if not (HHGear^.dY.isNegative) then
-	begin
+begin
-	HHGear^.State:= HHGear^.State or gstMoving;
+HHGear^.State:= HHGear^.State or gstMoving;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack;
+AfterAttack;
-	exit
+exit
-	end;
+end;
 if CheckLandValue(hwRound(HHGear^.X), hwRound(HHGear^.Y + HHGear^.dY + SignAs(_6,Gear^.dY)), COLOR_INDESTRUCTIBLE) then
 HHGear^.Y:= HHGear^.Y + HHGear^.dY
 end;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 inc(Gear^.Timer);
 if TestCollisionYwithGear(HHGear, 1)
-	or ((HHGear^.State and gstHHDriven) = 0)
+or ((HHGear^.State and gstHHDriven) = 0)
-	or CheckGearDrowning(HHGear)
+or CheckGearDrowning(HHGear)
-	or ((Gear^.Message and gm_Attack) <> 0) then
+or ((Gear^.Message and gm_Attack) <> 0) then
-	begin
+begin
-	with HHGear^ do
+with HHGear^ do
-		begin
+begin
-		Message:= 0;
+Message:= 0;
-		SetLittle(dX);
+SetLittle(dX);
-		dY:= _0;
+dY:= _0;
-		State:= State or gstMoving;
+State:= State or gstMoving;
-		end;
+end;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	isCursorVisible:= false;
+isCursorVisible:= false;
-	exit
+exit
-	end;
+end;
 if not TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then
-	HHGear^.X:= HHGear^.X + cWindSpeed * 200;
+HHGear^.X:= HHGear^.X + cWindSpeed * 200;
 if (Gear^.Message and gm_Left) <> 0 then HHGear^.X:= HHGear^.X - cMaxWindSpeed * 40
 else if (Gear^.Message and gm_Right) <> 0 then HHGear^.X:= HHGear^.X + cMaxWindSpeed * 40;
 if (Gear^.Message and gm_Up) <> 0 then HHGear^.Y:= HHGear^.Y - cGravity * 40
 else if (Gear^.Message and gm_Down) <> 0 then HHGear^.Y:= HHGear^.Y + cGravity * 40;
 begin
 AllInactive:= false;
 Gear^.X:= Gear^.X + cAirPlaneSpeed * Gear^.Tag;
 if (Gear^.Health > 0)and(not (Gear^.X < Gear^.dX))and(Gear^.X < Gear^.dX + cAirPlaneSpeed) then
-	begin
+begin
-	dec(Gear^.Health);
+dec(Gear^.Health);
-	case Gear^.State of
+case Gear^.State of
-			0: FollowGear:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, cBombsSpeed * Gear^.Tag, _0, 0);
+0: FollowGear:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, cBombsSpeed * Gear^.Tag, _0, 0);
-			1: FollowGear:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMine,    0, cBombsSpeed * Gear^.Tag, _0, 0);
+1: FollowGear:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMine,    0, cBombsSpeed * Gear^.Tag, _0, 0);
-			2: for i:= -19 to 19 do
+2: for i:= -19 to 19 do
-				FollowGear:= AddGear(hwRound(Gear^.X) + i div 3, hwRound(Gear^.Y), gtFlame, 0, _0_001 * i, _0, 0);
+FollowGear:= AddGear(hwRound(Gear^.X) + i div 3, hwRound(Gear^.Y), gtFlame, 0, _0_001 * i, _0, 0);
-			end;
+end;
-	Gear^.dX:= Gear^.dX + int2hwFloat(30 * Gear^.Tag)
+Gear^.dX:= Gear^.dX + int2hwFloat(30 * Gear^.Tag)
-	end;
+end;
 if (GameTicks and $3F) = 0 then
-	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
 if (hwRound(Gear^.X) > (LAND_WIDTH+1024)) or (hwRound(Gear^.X) < -1024) then DeleteGear(Gear)
 end;
 procedure doStepAirAttack(Gear: PGear);
 begin
 AllInactive:= false;
 if Gear^.X.QWordValue = 0 then
-	begin
+begin
-	Gear^.Tag:=  1;
+Gear^.Tag:=  1;
-	Gear^.X:= -_1024;
+Gear^.X:= -_1024;
-	end
+end
 else
-	begin
+begin
-	Gear^.Tag:= -1;
+Gear^.Tag:= -1;
-	Gear^.X:= int2hwFloat(LAND_WIDTH + 1024);
+Gear^.X:= int2hwFloat(LAND_WIDTH + 1024);
-	end;
+end;
 Gear^.Y:= int2hwFloat(topY-300);
 Gear^.dX:= int2hwFloat(TargetPoint.X - 5 * Gear^.Tag * 15);
 if (int2hwFloat(TargetPoint.Y) - Gear^.Y > _0) and (Gear^.State <> 2) then
-	    Gear^.dX:= Gear^.dX - cBombsSpeed * hwSqrt((int2hwFloat(TargetPoint.Y) - Gear^.Y) * 2 / cGravity) * Gear^.Tag;
+Gear^.dX:= Gear^.dX - cBombsSpeed * hwSqrt((int2hwFloat(TargetPoint.Y) - Gear^.Y) * 2 / cGravity) * Gear^.Tag;
 Gear^.Health:= 6;
 Gear^.doStep:= @doStepAirAttackWork;
 end;
 procedure doStepAirBomb(Gear: PGear);
 begin
 AllInactive:= false;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, EXPLAutoSound);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 if (GameTicks and $3F) = 0 then
-	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepGirder(Gear: PGear);
 if (Distance(tx - x, ty - y) > _256) or
 not TryPlaceOnLand(TargetPoint.X - SpritesData[sprAmGirder].Width div 2,
 TargetPoint.Y - SpritesData[sprAmGirder].Height div 2,
 sprAmGirder, Gear^.State, true) then
-	begin
+begin
 PlaySound(sndDenied);
-	HHGear^.Message:= HHGear^.Message and not gm_Attack;
+HHGear^.Message:= HHGear^.Message and not gm_Attack;
-	HHGear^.State:= HHGear^.State and not gstAttacking;
+HHGear^.State:= HHGear^.State and not gstAttacking;
-	HHGear^.State:= HHGear^.State or gstHHChooseTarget;
+HHGear^.State:= HHGear^.State or gstHHChooseTarget;
-	isCursorVisible:= true;
+isCursorVisible:= true;
-	DeleteGear(Gear)
+DeleteGear(Gear)
-	end
+end
 else begin
 PlaySound(sndPlaced);
-	DeleteGear(Gear);
+DeleteGear(Gear);
 OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
 ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^)
-	end;
+end;
 HHGear^.State:= HHGear^.State and not (gstAttacking or gstAttacked);
 HHGear^.Message:= HHGear^.Message and not gm_Attack;
 TargetPoint.X:= NoPointX
 end;
 PHedgehog(Gear^.Hedgehog)^.Unplaced:= false;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 HHGear^.Y:= HHGear^.Y + HHGear^.dY; // hedgehog falling to collect cases
 HHGear^.dY:= HHGear^.dY + cGravity;
 if TestCollisionYwithGear(HHGear, 1)
-	or CheckGearDrowning(HHGear) then
+or CheckGearDrowning(HHGear) then
-	begin
+begin
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	AfterAttack
+AfterAttack
-	end
+end
 end;
 procedure doStepTeleportAnim(Gear: PGear);
 begin
 inc(Gear^.Timer);
 if Gear^.Timer = 65 then
-	begin
+begin
-	Gear^.Timer:= 0;
+Gear^.Timer:= 0;
-	inc(Gear^.Pos);
+inc(Gear^.Pos);
-	if Gear^.Pos = 11 then
+if Gear^.Pos = 11 then
-		Gear^.doStep:= @doStepTeleportAfter
+Gear^.doStep:= @doStepTeleportAfter
-	end;
+end;
 end;
 procedure doStepTeleport(Gear: PGear);
 var HHGear: PGear;
 begin
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 if not TryPlaceOnLand(TargetPoint.X - SpritesData[sprHHTelepMask].Width div 2,
 TargetPoint.Y - SpritesData[sprHHTelepMask].Height div 2,
 sprHHTelepMask, 0, false) then
-		begin
+begin
-		HHGear^.Message:= HHGear^.Message and not gm_Attack;
+HHGear^.Message:= HHGear^.Message and not gm_Attack;
-		HHGear^.State:= HHGear^.State and not gstAttacking;
+HHGear^.State:= HHGear^.State and not gstAttacking;
-		HHGear^.State:= HHGear^.State or gstHHChooseTarget;
+HHGear^.State:= HHGear^.State or gstHHChooseTarget;
-		DeleteGear(Gear);
+DeleteGear(Gear);
-		isCursorVisible:= true;
+isCursorVisible:= true;
-		PlaySound(sndDenied)
+PlaySound(sndDenied)
-		end
+end
-	else begin
+else begin
-		DeleteCI(HHGear);
+DeleteCI(HHGear);
-		SetAllHHToActive;
+SetAllHHToActive;
-		Gear^.doStep:= @doStepTeleportAnim;
+Gear^.doStep:= @doStepTeleportAnim;
-		Gear^.X:= HHGear^.X;
+Gear^.X:= HHGear^.X;
-		Gear^.Y:= HHGear^.Y;
+Gear^.Y:= HHGear^.Y;
-		HHGear^.X:= int2hwFloat(TargetPoint.X);
+HHGear^.X:= int2hwFloat(TargetPoint.X);
-		HHGear^.Y:= int2hwFloat(TargetPoint.Y);
+HHGear^.Y:= int2hwFloat(TargetPoint.Y);
-		HHGear^.State:= HHGear^.State or gstMoving;
+HHGear^.State:= HHGear^.State or gstMoving;
-		playSound(sndWarp)
+playSound(sndWarp)
-		end;
+end;
 TargetPoint.X:= NoPointX;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 Msg, State: Longword;
 begin
 AllInactive:= false;
 if ((Gear^.Message and not gm_Switch) <> 0) or (TurnTimeLeft = 0) then
-	begin
+begin
-	HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
+HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
-	Msg:= Gear^.Message and not gm_Switch;
+Msg:= Gear^.Message and not gm_Switch;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
+OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
-	ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^);
+ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^);
-	HHGear:= CurrentHedgehog^.Gear;
+HHGear:= CurrentHedgehog^.Gear;
-	ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^);
+ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^);
-	HHGear^.Message:= Msg;
+HHGear^.Message:= Msg;
-	exit
+exit
-	end;
+end;
 if (Gear^.Message and gm_Switch) <> 0 then
-	begin
+begin
-	HHGear:= CurrentHedgehog^.Gear;
+HHGear:= CurrentHedgehog^.Gear;
-	HHGear^.Message:= HHGear^.Message and not gm_Switch;
+HHGear^.Message:= HHGear^.Message and not gm_Switch;
-	Gear^.Message:= Gear^.Message and not gm_Switch;
+Gear^.Message:= Gear^.Message and not gm_Switch;
-	State:= HHGear^.State;
+State:= HHGear^.State;
-	HHGear^.State:= 0;
+HHGear^.State:= 0;
-	HHGear^.Active:= false;
+HHGear^.Active:= false;
-	HHGear^.Z:= cHHZ;
+HHGear^.Z:= cHHZ;
-	RemoveGearFromList(HHGear);
+RemoveGearFromList(HHGear);
-	InsertGearToList(HHGear);
+InsertGearToList(HHGear);
-	PlaySound(sndSwitchHog);
+PlaySound(sndSwitchHog);
-	repeat
+repeat
-		CurrentTeam^.CurrHedgehog:= Succ(CurrentTeam^.CurrHedgehog) mod (CurrentTeam^.HedgehogsNumber);
+CurrentTeam^.CurrHedgehog:= Succ(CurrentTeam^.CurrHedgehog) mod (CurrentTeam^.HedgehogsNumber);
-	until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil);
+until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil);
-	CurrentHedgehog:= @CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog];
+CurrentHedgehog:= @CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog];
-	HHGear:= CurrentHedgehog^.Gear;
+HHGear:= CurrentHedgehog^.Gear;
-	HHGear^.State:= State;
+HHGear^.State:= State;
-	HHGear^.Active:= true;
+HHGear^.Active:= true;
-	FollowGear:= HHGear;
+FollowGear:= HHGear;
-	HHGear^.Z:= cCurrHHZ;
+HHGear^.Z:= cCurrHHZ;
-	RemoveGearFromList(HHGear);
+RemoveGearFromList(HHGear);
-	InsertGearToList(HHGear);
+InsertGearToList(HHGear);
-	Gear^.X:= HHGear^.X;
+Gear^.X:= HHGear^.X;
-	Gear^.Y:= HHGear^.Y
+Gear^.Y:= HHGear^.Y
-	end;
+end;
 end;
 procedure doStepSwitcher(Gear: PGear);
 var HHGear: PGear;
 begin
 Gear^.doStep:= @doStepSwitcherWork;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 with HHGear^ do
-	begin
+begin
-	State:= State and not gstAttacking;
+State:= State and not gstAttacking;
-	Message:= Message and not gm_Attack
+Message:= Message and not gm_Attack
-	end
+end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMortar(Gear: PGear);
 var dX, dY: hwFloat;
 dxn:= Gear^.dX.isNegative;
 dyn:= Gear^.dY.isNegative;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound);
-	Gear^.dX.isNegative:= not dxn;
+Gear^.dX.isNegative:= not dxn;
-	Gear^.dY.isNegative:= not dyn;
+Gear^.dY.isNegative:= not dyn;
-	for i:= 0 to 4 do
+for i:= 0 to 4 do
-		begin
+begin
-		dX:= Gear^.dX + (GetRandom - _0_5) * _0_03;
+dX:= Gear^.dX + (GetRandom - _0_5) * _0_03;
-		dY:= Gear^.dY + (GetRandom - _0_5) * _0_03;
+dY:= Gear^.dY + (GetRandom - _0_5) * _0_03;
-		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25);
-		end;
+end;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 if (GameTicks and $3F) = 0 then
-	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepKamikazeWork(Gear: PGear);
 const upd: Longword = 0;
 HHGear^.State:= HHGear^.State or gstNoDamage;
 DeleteCI(HHGear);
 i:= 2;
 repeat
-	Gear^.X:= Gear^.X + HHGear^.dX;
+Gear^.X:= Gear^.X + HHGear^.dX;
-	Gear^.Y:= Gear^.Y + HHGear^.dY;
+Gear^.Y:= Gear^.Y + HHGear^.dY;
-	HHGear^.X:= Gear^.X;
+HHGear^.X:= Gear^.X;
-	HHGear^.Y:= Gear^.Y;
+HHGear^.Y:= Gear^.Y;
-	inc(Gear^.Damage, 2);
+inc(Gear^.Damage, 2);
-//	if TestCollisionXwithGear(HHGear, hwSign(Gear^.dX))
+//  if TestCollisionXwithGear(HHGear, hwSign(Gear^.dX))
-//		or TestCollisionYwithGear(HHGear, hwSign(Gear^.dY)) then inc(Gear^.Damage, 3);
+//      or TestCollisionYwithGear(HHGear, hwSign(Gear^.dY)) then inc(Gear^.Damage, 3);
-	dec(i)
+dec(i)
 until (i = 0) or (Gear^.Damage > Gear^.Health);
 inc(upd);
 if upd > 3 then
-	begin
+begin
-	if Gear^.Health < 1500 then Gear^.Pos:= 2;
+if Gear^.Health < 1500 then Gear^.Pos:= 2;
-	AmmoShove(Gear, 30, 40);
+AmmoShove(Gear, 30, 40);
-	DrawTunnel(HHGear^.X - HHGear^.dX * 10,
+DrawTunnel(HHGear^.X - HHGear^.dX * 10,
-			HHGear^.Y - _2 - HHGear^.dY * 10 + hwAbs(HHGear^.dY) * 2,
+HHGear^.Y - _2 - HHGear^.dY * 10 + hwAbs(HHGear^.dY) * 2,
-			HHGear^.dX,
+HHGear^.dX,
-			HHGear^.dY,
+HHGear^.dY,
-			20 + cHHRadius * 2,
+20 + cHHRadius * 2,
-			cHHRadius * 2 + 6);
+cHHRadius * 2 + 6);
-	upd:= 0
+upd:= 0
-	end;
+end;
 if Gear^.Health < Gear^.Damage then
-	begin
+begin
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, EXPLAutoSound);
-	AfterAttack;
+AfterAttack;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	DeleteGear(HHGear);
+DeleteGear(HHGear);
-	end else
+end else
-	begin
+begin
-	dec(Gear^.Health, Gear^.Damage);
+dec(Gear^.Health, Gear^.Damage);
-	Gear^.Damage:= 0
+Gear^.Damage:= 0
-	end
+end
 end;
 procedure doStepKamikazeIdle(Gear: PGear);
 begin
 AllInactive:= false;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
-	begin
+begin
-	Gear^.Pos:= 1;
+Gear^.Pos:= 1;
-	PlaySound(sndKamikaze, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack);
+PlaySound(sndKamikaze, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack);
-	Gear^.doStep:= @doStepKamikazeWork
+Gear^.doStep:= @doStepKamikazeWork
-	end
+end
 end;
 procedure doStepKamikaze(Gear: PGear);
 var HHGear: PGear;
 begin
 ////////////////////////////////////////////////////////////////////////////////
 const cakeh = 27;
 cakeDmg = 75;
 var CakePoints: array[0..Pred(cakeh)] of record x, y: hwFloat; end;
-	CakeI: Longword;
+CakeI: Longword;
 procedure doStepCakeExpl(Gear: PGear);
 begin
 AllInactive:= false;
 DeleteGear(Gear)
 end;
 procedure doStepCakeDown(Gear: PGear);
 var gi: PGear;
-	dmg: LongInt;
+dmg: LongInt;
 begin
 AllInactive:= false;
 inc(Gear^.Tag);
 if Gear^.Tag < 100 then exit;
 Gear^.Tag:= 0;
 if Gear^.Pos = 0 then
-	begin
+begin
-	gi:= GearsList;
+gi:= GearsList;
-	while gi <> nil do
+while gi <> nil do
-		begin
+begin
-		dmg:= cakeDmg * 2 - hwRound(Distance(gi^.X - Gear^.X, gi^.Y - Gear^.Y));
+dmg:= cakeDmg * 2 - hwRound(Distance(gi^.X - Gear^.X, gi^.Y - Gear^.Y));
-		if (dmg > 1) and (gi^.Kind = gtHedgehog) then
+if (dmg > 1) and (gi^.Kind = gtHedgehog) then
 if (CurrentHedgehog^.Gear = gi) and (not gi^.Invulnerable) then
-			    gi^.State:= gi^.State or gstLoser
+gi^.State:= gi^.State or gstLoser
 else
-			    gi^.State:= gi^.State or gstWinner;
+gi^.State:= gi^.State or gstWinner;
-		gi:= gi^.NextGear
+gi:= gi^.NextGear
-		end;
+end;
-	Gear^.doStep:= @doStepCakeExpl;
+Gear^.doStep:= @doStepCakeExpl;
-	PlaySound(sndCake)
+PlaySound(sndCake)
-	end else dec(Gear^.Pos)
+end else dec(Gear^.Pos)
 end;
 procedure doStepCakeWork(Gear: PGear);
 const dirs: array[0..3] of TPoint = ((x: 0; y: -1), (x: 1; y: 0),(x: 0; y: 1),(x: -1; y: 0));
 var xx, yy, xxn, yyn: LongInt;
-	da: LongInt;
+da: LongInt;
-	tdx, tdy: hwFloat;
+tdx, tdy: hwFloat;
-	procedure PrevAngle;
+procedure PrevAngle;
-	begin
+begin
-	Gear^.Angle:= (LongInt(Gear^.Angle) + 4 - dA) mod 4
+Gear^.Angle:= (LongInt(Gear^.Angle) + 4 - dA) mod 4
-	end;
+end;
-	procedure NextAngle;
+procedure NextAngle;
-	begin
+begin
-	Gear^.Angle:= (LongInt(Gear^.Angle) + 4 + dA) mod 4
+Gear^.Angle:= (LongInt(Gear^.Angle) + 4 + dA) mod 4
-	end;
+end;
 begin
 AllInactive:= false;
 inc(Gear^.Tag);
 yy:= dirs[Gear^.Angle].y;
 xxn:= dirs[(LongInt(Gear^.Angle) + 4 + dA) mod 4].x;
 yyn:= dirs[(LongInt(Gear^.Angle) + 4 + dA) mod 4].y;
 if (xx = 0) then
-	if TestCollisionYwithGear(Gear, yy) then
+if TestCollisionYwithGear(Gear, yy) then
-		PrevAngle
+PrevAngle
-	else begin
+else begin
-		Gear^.Tag:= 0;
+Gear^.Tag:= 0;
-		Gear^.Y:= Gear^.Y + int2hwFloat(yy);
+Gear^.Y:= Gear^.Y + int2hwFloat(yy);
-		if not TestCollisionXwithGear(Gear, xxn) then
+if not TestCollisionXwithGear(Gear, xxn) then
-			begin
+begin
-			Gear^.X:= Gear^.X + int2hwFloat(xxn);
+Gear^.X:= Gear^.X + int2hwFloat(xxn);
-			NextAngle
+NextAngle
-			end;
+end;
-		end;
+end;
 if (yy = 0) then
-	if TestCollisionXwithGear(Gear, xx) then
+if TestCollisionXwithGear(Gear, xx) then
-		PrevAngle
+PrevAngle
-	else begin
+else begin
-		Gear^.Tag:= 0;
+Gear^.Tag:= 0;
-		Gear^.X:= Gear^.X + int2hwFloat(xx);
+Gear^.X:= Gear^.X + int2hwFloat(xx);
-		if not TestCollisionYwithGear(Gear, yyn) then
+if not TestCollisionYwithGear(Gear, yyn) then
-			begin
+begin
-			Gear^.Y:= Gear^.Y + int2hwFloat(yyn);
+Gear^.Y:= Gear^.Y + int2hwFloat(yyn);
-			NextAngle
+NextAngle
-			end;
+end;
-		end;
+end;
 if Gear^.Tag = 0 then
-	begin
+begin
-	CakeI:= (CakeI + 1) mod cakeh;
+CakeI:= (CakeI + 1) mod cakeh;
-	tdx:= CakePoints[CakeI].x - Gear^.X;
+tdx:= CakePoints[CakeI].x - Gear^.X;
-	tdy:= - CakePoints[CakeI].y + Gear^.Y;
+tdy:= - CakePoints[CakeI].y + Gear^.Y;
-	CakePoints[CakeI].x:= Gear^.X;
+CakePoints[CakeI].x:= Gear^.X;
-	CakePoints[CakeI].y:= Gear^.Y;
+CakePoints[CakeI].y:= Gear^.Y;
-	Gear^.DirAngle:= DxDy2Angle(tdx, tdy);
+Gear^.DirAngle:= DxDy2Angle(tdx, tdy);
-	end;
+end;
 dec(Gear^.Health);
 Gear^.Timer:= Gear^.Health*10; // This is not seconds, but at least it is *some* feedback
 if (Gear^.Health = 0) or ((Gear^.Message and gm_Attack) <> 0) then
-	begin
+begin
-	FollowGear:= Gear;
+FollowGear:= Gear;
 Gear^.RenderTimer:= false;
-	Gear^.doStep:= @doStepCakeDown
+Gear^.doStep:= @doStepCakeDown
-	end
+end
 end;
 procedure doStepCakeUp(Gear: PGear);
 var i: Longword;
 begin
 inc(Gear^.Tag);
 if Gear^.Tag < 100 then exit;
 Gear^.Tag:= 0;
 if Gear^.Pos = 6 then
-	begin
+begin
-	for i:= 0 to Pred(cakeh) do
+for i:= 0 to Pred(cakeh) do
-		begin
+begin
-		CakePoints[i].x:= Gear^.X;
+CakePoints[i].x:= Gear^.X;
-		CakePoints[i].y:= Gear^.Y
+CakePoints[i].y:= Gear^.Y
-		end;
+end;
-	CakeI:= 0;
+CakeI:= 0;
-	Gear^.doStep:= @doStepCakeWork
+Gear^.doStep:= @doStepCakeWork
-	end else inc(Gear^.Pos)
+end else inc(Gear^.Pos)
 end;
 procedure doStepCakeFall(Gear: PGear);
 begin
 AllInactive:= false;
 Gear^.dY:= Gear^.dY + cGravity;
 if TestCollisionYwithGear(Gear, 1) then
-	Gear^.doStep:= @doStepCakeUp
+Gear^.doStep:= @doStepCakeUp
 else
-	begin
+begin
-	Gear^.Y:= Gear^.Y + Gear^.dY;
+Gear^.Y:= Gear^.Y + Gear^.dY;
-	if CheckGearDrowning(Gear) then AfterAttack
+if CheckGearDrowning(Gear) then AfterAttack
-	end
+end
 end;
 procedure doStepCake(Gear: PGear);
 var HHGear: PGear;
 begin
 Gear^.Y:= Gear^.Y + Gear^.dY;
 x:= hwRound(Gear^.X);
 y:= hwRound(Gear^.Y);
 if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) then
-	if (Land[y, x] <> 0) then
+if (Land[y, x] <> 0) then
-		begin
+begin
-		Gear^.dX.isNegative:= not Gear^.dX.isNegative;
+Gear^.dX.isNegative:= not Gear^.dX.isNegative;
-		Gear^.dY.isNegative:= not Gear^.dY.isNegative;
+Gear^.dY.isNegative:= not Gear^.dY.isNegative;
-		Gear^.dX:= Gear^.dX * _1_5;
+Gear^.dX:= Gear^.dX * _1_5;
-		Gear^.dY:= Gear^.dY * _1_5 - _0_3;
+Gear^.dY:= Gear^.dY * _1_5 - _0_3;
-		AmmoShove(Gear, 0, 40);
+AmmoShove(Gear, 0, 40);
-		AfterAttack;
+AfterAttack;
-		DeleteGear(Gear)
+DeleteGear(Gear)
-		end
+end
-	else
+else
 else
-	begin
+begin
-	AfterAttack;
+AfterAttack;
-	DeleteGear(Gear)
+DeleteGear(Gear)
-	end
+end
 end;
 procedure doStepSeductionWear(Gear: PGear);
 begin
 AllInactive:= false;
 inc(Gear^.Timer);
 if Gear^.Timer > 250 then
-	begin
+begin
-	Gear^.Timer:= 0;
+Gear^.Timer:= 0;
-	inc(Gear^.Pos);
+inc(Gear^.Pos);
-	if Gear^.Pos = 5 then
+if Gear^.Pos = 5 then
-		PlaySound(sndYoohoo, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack)
+PlaySound(sndYoohoo, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack)
-	end;
+end;
 if Gear^.Pos = 14 then
-	Gear^.doStep:= @doStepSeductionWork
+Gear^.doStep:= @doStepSeductionWork
 end;
 procedure doStepSeduction(Gear: PGear);
 begin
 AllInactive:= false;
 begin
 AllInactive:= false;
 inc(Gear^.Timer);
 if Gear^.Timer = 17 then
-	Gear^.Timer:= 0
+Gear^.Timer:= 0
 else
-	exit;
+exit;
 if cWaterLine > 0 then
-	begin
+begin
-	dec(cWaterLine);
+dec(cWaterLine);
-	for i:= 0 to LAND_WIDTH - 1 do
+for i:= 0 to LAND_WIDTH - 1 do
-		Land[cWaterLine, i]:= 0;
+Land[cWaterLine, i]:= 0;
-	SetAllToActive
+SetAllToActive
-	end;
+end;
 inc(Gear^.Tag);
 if (Gear^.Tag = 47) or (cWaterLine = 0) then
-	DeleteGear(Gear)
+DeleteGear(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepDrillDrilling(Gear: PGear);
 var t: PGearArray;
-	ox, oy: hwFloat;
+ox, oy: hwFloat;
 begin
 AllInactive:= false;
 if (Gear^.Timer > 0) and ((Gear^.Timer mod 10) = 0) then
-	begin
+begin
-	ox:= Gear^.X;
+ox:= Gear^.X;
-	oy:= Gear^.Y;
+oy:= Gear^.Y;
-	Gear^.X:= Gear^.X + Gear^.dX;
+Gear^.X:= Gear^.X + Gear^.dX;
-	Gear^.Y:= Gear^.Y + Gear^.dY;
+Gear^.Y:= Gear^.Y + Gear^.dY;
-	DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 2, 6);
+DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 2, 6);
 if(CheckGearDrowning(Gear)) then
 begin
 StopSound(Gear^.SoundChannel);
-	    exit
+exit
 end
-	end;
+end;
 t:= CheckGearsCollision(Gear); //fixes drill not exploding when touching HH bug
 if (Gear^.Timer = 0)
 or (t^.Count <> 0)
 or (not TestCollisionYWithGear(Gear, hwSign(Gear^.dY))
 and not TestCollisionXWithGear(Gear, hwSign(Gear^.dX)))
 or (Land[hwRound(Gear^.Y), hwRound(Gear^.X)] = COLOR_INDESTRUCTIBLE) then
-	begin //out of time or exited ground
+begin //out of time or exited ground
 StopSound(Gear^.SoundChannel);
-	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	exit
+exit
-	end;
+end;
 dec(Gear^.Timer);
 end;
 procedure doStepDrill(Gear: PGear);
 var t: PGearArray;
-	oldDx, oldDy: hwFloat;
+oldDx, oldDy: hwFloat;
-	t2: hwFloat;
+t2: hwFloat;
 begin
 AllInactive:= false;
 Gear^.dX:= Gear^.dX + cWindSpeed;
 oldDx:= Gear^.dX;
 oldDy:= Gear^.dY;
 doStepFallingGear(Gear);
 if (GameTicks and $3F) = 0 then
-	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
 if ((Gear^.State and gstCollision) <> 0) then begin //hit
-	Gear^.dX:= oldDx;
+Gear^.dX:= oldDx;
-	Gear^.dY:= oldDy;
+Gear^.dY:= oldDy;
-	t:= CheckGearsCollision(Gear);
+t:= CheckGearsCollision(Gear);
-	if (t^.Count = 0) then begin //hit the ground not the HH
+if (t^.Count = 0) then begin //hit the ground not the HH
-		t2 := _0_5 / Distance(Gear^.dX, Gear^.dY);
+t2 := _0_5 / Distance(Gear^.dX, Gear^.dY);
-		Gear^.dX:= Gear^.dX * t2;
+Gear^.dX:= Gear^.dX * t2;
-		Gear^.dY:= Gear^.dY * t2;
+Gear^.dY:= Gear^.dY * t2;
-	end else begin //explode right on contact with HH
+end else begin //explode right on contact with HH
-		doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);
-		DeleteGear(Gear);
+DeleteGear(Gear);
-		exit;
+exit;
-		end;
+end;
 Gear^.SoundChannel:= LoopSound(sndPickhammer);
-	Gear^.doStep:= @doStepDrillDrilling;
+Gear^.doStep:= @doStepDrillDrilling;
-	dec(Gear^.Timer)
+dec(Gear^.Timer)
-	end
+end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBallgunWork(Gear: PGear);
 var HHGear: PGear;
-	rx, ry: hwFloat;
+rx, ry: hwFloat;
 begin
-	AllInactive:= false;
+AllInactive:= false;
-	dec(Gear^.Timer);
+dec(Gear^.Timer);
-	HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
+HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
-	HedgehogChAngle(HHGear);
+HedgehogChAngle(HHGear);
-	if (Gear^.Timer mod 100) = 0 then
+if (Gear^.Timer mod 100) = 0 then
-		begin
+begin
-		rx:= rndSign(getRandom * _0_1);
+rx:= rndSign(getRandom * _0_1);
-		ry:= rndSign(getRandom * _0_1);
+ry:= rndSign(getRandom * _0_1);
-		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtBall, 0,
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtBall, 0,
-				SignAs(AngleSin(HHGear^.Angle) * _0_8, HHGear^.dX) + rx,
+SignAs(AngleSin(HHGear^.Angle) * _0_8, HHGear^.dX) + rx,
-				AngleCos(HHGear^.Angle) * ( - _0_8) + ry,
+AngleCos(HHGear^.Angle) * ( - _0_8) + ry,
-				0);
+0);
-		PlaySound(sndGun);
+PlaySound(sndGun);
-		end;
+end;
-	if (Gear^.Timer = 0) or (HHGear^.Damage <> 0) then
+if (Gear^.Timer = 0) or (HHGear^.Damage <> 0) then
-		begin
+begin
-		DeleteGear(Gear);
+DeleteGear(Gear);
-		AfterAttack
+AfterAttack
-		end
+end
 end;
 procedure doStepBallgun(Gear: PGear);
 var HHGear: PGear;
 begin
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepRCPlaneWork(Gear: PGear);
 const cAngleSpeed = 3;
 var HHGear: PGear;
-	i: LongInt;
+i: LongInt;
-	dX, dY: hwFloat;
+dX, dY: hwFloat;
-	fChanged: boolean;
+fChanged: boolean;
-	trueAngle: Longword;
+trueAngle: Longword;
-	t: PGear;
+t: PGear;
 begin
 AllInactive:= false;
 if ((TrainingFlags and tfRCPlane) = 0) and (Gear^.Timer > 0) then dec(Gear^.Timer);
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 FollowGear:= Gear;
 fChanged:= false;
 if ((HHGear^.State and gstHHDriven) = 0) or (Gear^.Timer = 0) then
-	begin
+begin
-	fChanged:= true;
+fChanged:= true;
-	if Gear^.Angle > 2048 then dec(Gear^.Angle) else
+if Gear^.Angle > 2048 then dec(Gear^.Angle) else
-		if Gear^.Angle < 2048 then inc(Gear^.Angle) else fChanged:= false
+if Gear^.Angle < 2048 then inc(Gear^.Angle) else fChanged:= false
-	end
+end
 else
-	begin
+begin
-	if ((Gear^.Message and gm_Left) <> 0) then
+if ((Gear^.Message and gm_Left) <> 0) then
-		begin
+begin
-		fChanged:= true;
+fChanged:= true;
-		Gear^.Angle:= (Gear^.Angle + (4096 - cAngleSpeed)) mod 4096
+Gear^.Angle:= (Gear^.Angle + (4096 - cAngleSpeed)) mod 4096
-		end;
+end;
-	if ((Gear^.Message and gm_Right) <> 0) then
+if ((Gear^.Message and gm_Right) <> 0) then
-		begin
+begin
-		fChanged:= true;
+fChanged:= true;
-		Gear^.Angle:= (Gear^.Angle + cAngleSpeed) mod 4096
+Gear^.Angle:= (Gear^.Angle + cAngleSpeed) mod 4096
-		end
+end
-	end;
+end;
 if fChanged then
-	begin
+begin
-	Gear^.dX.isNegative:= (Gear^.Angle > 2048);
+Gear^.dX.isNegative:= (Gear^.Angle > 2048);
-	if Gear^.dX.isNegative then
+if Gear^.dX.isNegative then
-		trueAngle:= 4096 - Gear^.Angle
+trueAngle:= 4096 - Gear^.Angle
-	else
+else
-		trueAngle:= Gear^.Angle;
+trueAngle:= Gear^.Angle;
-	Gear^.dX:= SignAs(AngleSin(trueAngle), Gear^.dX) * _0_25;
+Gear^.dX:= SignAs(AngleSin(trueAngle), Gear^.dX) * _0_25;
-	Gear^.dY:= AngleCos(trueAngle) * -_0_25;
+Gear^.dY:= AngleCos(trueAngle) * -_0_25;
-	end;
+end;
 Gear^.X:= Gear^.X + Gear^.dX;
 Gear^.Y:= Gear^.Y + Gear^.dY;
 if (TrainingFlags and tfRCPlane) = 0 then
-	begin
+begin
-	if (GameTicks and $FF) = 0 then
+if (GameTicks and $FF) = 0 then
-		if Gear^.Timer < 3500 then
+if Gear^.Timer < 3500 then
-			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0)
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0)
-		else
+else
-			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
-	if ((HHGear^.Message and gm_Attack) <> 0) and (Gear^.Health <> 0) then
+if ((HHGear^.Message and gm_Attack) <> 0) and (Gear^.Health <> 0) then
-		begin
+begin
-		HHGear^.Message := HHGear^.Message and not gm_Attack;
+HHGear^.Message := HHGear^.Message and not gm_Attack;
-		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, Gear^.dX * _0_5, Gear^.dY * _0_5, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, Gear^.dX * _0_5, Gear^.dY * _0_5, 0);
-		dec(Gear^.Health)
+dec(Gear^.Health)
-		end;
+end;
-	if ((HHGear^.Message and gm_LJump) <> 0)
+if ((HHGear^.Message and gm_LJump) <> 0)
-		and ((Gear^.State and gsttmpFlag) = 0) then
+and ((Gear^.State and gsttmpFlag) = 0) then
-		begin
+begin
-		Gear^.State:= Gear^.State or gsttmpFlag;
+Gear^.State:= Gear^.State or gsttmpFlag;
-		PauseMusic;
+PauseMusic;
-		playSound(sndRideOfTheValkyries);
+playSound(sndRideOfTheValkyries);
-		end;
+end;
-	// pickup bonuses
+// pickup bonuses
-	t:= CheckGearNear(Gear, gtCase, 36, 36);
+t:= CheckGearNear(Gear, gtCase, 36, 36);
-	if t <> nil then
+if t <> nil then
-		PickUp(HHGear, t);
+PickUp(HHGear, t);
-	end
+end
 else
-	begin
+begin
-	if (GameTicks and $FF) = 0 then
+if (GameTicks and $FF) = 0 then
-		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0);
-	// pickup targets
+// pickup targets
-	t:= CheckGearNear(Gear, gtTarget, 36, 36);
+t:= CheckGearNear(Gear, gtTarget, 36, 36);
-	if t <> nil then
+if t <> nil then
-		begin
+begin
-		if t^.Tag <> 0 then // collect it only once
+if t^.Tag <> 0 then // collect it only once
-			exit;
+exit;
-		PlaySound(sndShotgunReload);
+PlaySound(sndShotgunReload);
-		t^.Tag:= 1;
+t^.Tag:= 1;
-		TrainingTargetGear:= nil; // remove target cursor
+TrainingTargetGear:= nil; // remove target cursor
-		exit;
+exit;
-		end;
+end;
-	if (TurnTimeLeft > 0) then
+if (TurnTimeLeft > 0) then
-		dec(TurnTimeLeft)
+dec(TurnTimeLeft)
-	end;
+end;
 CheckCollision(Gear);
 if ((Gear^.State and gstCollision) <> 0) or (((TrainingFlags and tfRCPlane) <> 0) and (TurnTimeLeft = 0))
-	or CheckGearDrowning(Gear) then
+or CheckGearDrowning(Gear) then
-	begin
+begin
-	if ((TrainingFlags and tfRCPlane) <> 0) and ((TrainingFlags and tfTimeTrial) <> 0 ) and (TimeTrialStopTime = 0) then TimeTrialStopTime:= RealTicks;
+if ((TrainingFlags and tfRCPlane) <> 0) and ((TrainingFlags and tfTimeTrial) <> 0 ) and (TimeTrialStopTime = 0) then TimeTrialStopTime:= RealTicks;
-	StopSound(Gear^.SoundChannel);
+StopSound(Gear^.SoundChannel);
-	StopSound(sndRideOfTheValkyries);
+StopSound(sndRideOfTheValkyries);
-	ResumeMusic;
+ResumeMusic;
-	if ((Gear^.State and gstCollision) <> 0) or (((TrainingFlags and tfRCPlane) <> 0) and (TurnTimeLeft = 0)) then
+if ((Gear^.State and gstCollision) <> 0) or (((TrainingFlags and tfRCPlane) <> 0) and (TurnTimeLeft = 0)) then
-		begin
+begin
-		doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, EXPLAutoSound);
+doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, EXPLAutoSound);
-		for i:= 0 to 32 do
+for i:= 0 to 32 do
-			begin
+begin
-			dX:= AngleCos(i * 64) * _0_5 * (GetRandom + _1);
+dX:= AngleCos(i * 64) * _0_5 * (GetRandom + _1);
-			dY:= AngleSin(i * 64) * _0_5 * (GetRandom + _1);
+dY:= AngleSin(i * 64) * _0_5 * (GetRandom + _1);
-			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);
-			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);
+AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);
-			end;
+end;
-		DeleteGear(Gear)
+DeleteGear(Gear)
-		end;
+end;
-	AfterAttack;
+AfterAttack;
-	CurAmmoGear:= nil;
+CurAmmoGear:= nil;
-	TurnTimeLeft:= 14 * 125;
+TurnTimeLeft:= 14 * 125;
-	if (TrainingFlags and tfRCPlane) <> 0 then
+if (TrainingFlags and tfRCPlane) <> 0 then
-		TurnTimeLeft:= 0; // HACK: RCPlane training allows unlimited plane starts in last 2 seconds
+TurnTimeLeft:= 0; // HACK: RCPlane training allows unlimited plane starts in last 2 seconds
-	HHGear^.Message:= 0;
+HHGear^.Message:= 0;
-	ParseCommand('/taunt '#1, true)
+ParseCommand('/taunt '#1, true)
-	end
+end
 end;
 procedure doStepRCPlane(Gear: PGear);
 var HHGear: PGear;
 begin
 if ((Gear^.State and gsttmpFlag) = 0) or (HHGear^.dY < _0) then doStepHedgehogMoving(HHGear);
 if  (Gear^.Health = 0)
 or (HHGear^.Damage <> 0)
-	or CheckGearDrowning(HHGear)
+or CheckGearDrowning(HHGear)
 or (TurnTimeLeft = 0)
 // allow brief ground touches - to be fair on this, might need another counter
 or (((GameTicks and $1FF) = 0) and (not HHGear^.dY.isNegative) and TestCollisionYwithGear(HHGear, 1))
-	or ((Gear^.Message and gm_Attack) <> 0) then
+or ((Gear^.Message and gm_Attack) <> 0) then
-	begin
+begin
-	with HHGear^ do
+with HHGear^ do
-		begin
+begin
-		Message:= 0;
+Message:= 0;
 Active:= true;
-		State:= State or gstMoving
+State:= State or gstMoving
-		end;
+end;
-	DeleteGear(Gear);
+DeleteGear(Gear);
-	isCursorVisible:= false;
+isCursorVisible:= false;
 //    if Gear^.Tex <> nil then FreeTexture(Gear^.Tex);
 //    Gear^.Tex:= RenderStringTex(trmsg[sidFuel] + ': ' + inttostr(round(Gear^.Health / 20)) + '%', cWhiteColor, fntSmall)
 //AddCaption(trmsg[sidFuel]+': '+inttostr(round(Gear^.Health/20))+'%', cWhiteColor, capgrpAmmostate);
-	end
+end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepJetpack(Gear: PGear);
 var HHGear: PGear;
 HHGear:= PHedgehog(Gear^.Hedgehog)^.Gear;
 FollowGear:= HHGear;
 OnUsedAmmo(PHedgehog(HHGear^.Hedgehog)^);
 ApplyAmmoChanges(PHedgehog(HHGear^.Hedgehog)^);
 with HHGear^ do
-	begin
+begin
-	State:= State and not gstAttacking;
+State:= State and not gstAttacking;
-	Message:= Message and not (gm_Attack or gm_Up or gm_Precise or gm_Left or gm_Right);
+Message:= Message and not (gm_Attack or gm_Up or gm_Precise or gm_Left or gm_Right);
 if (dY < _0_1) and (dY > -_0_1) then
 begin
 Gear^.State:= Gear^.State or gsttmpFlag;
 dY:= dY - _0_2
 end
-	end
+end
 end;

changeset 2948	3f21a9dc93d0
parent 2944	e8a891bf6660
child 2955	fb361d137524