hedgewars: comparison hedgewars/GSHandlers.inc

equal deleted inserted replaced

-:fc52f7c22c9b
+:6155187bf599
 if steps > 1 then
 begin
 sX:= dX / steps;
 sY:= dY / steps;
 end
 else
 begin
 sX:= dX;
 sY:= dY;
 end;
 d := r - hwRound(Distance(gi^.X - x, gi^.Y - y));
 if (d > 1) and (not gi^.Invulnerable) and (GetRandom(2) = 0) then
 begin
 if (CurrentHedgehog^.Gear = gi) then
 PlaySound(sndOops, gi^.Hedgehog^.Team^.voicepack)
 else
 begin
 if (gi^.State and gstMoving) = 0 then
 gi^.State := gi^.State or gstLoser;
 if d > r div 2 then
 PlaySound(sndNooo, gi^.Hedgehog^.Team^.voicepack)
 else
 PlaySound(sndUhOh, gi^.Hedgehog^.Team^.voicepack);
 end;
 end;
 end;
 gi := gi^.NextGear
 end;
 end;
 procedure HideHog(HH: PHedgehog);
 begin
 ScriptCall('onHogHide', HH^.Gear^.Uid);
 DeleteCI(HH^.Gear);
-if FollowGear = HH^.Gear then FollowGear:= nil;
+if FollowGear = HH^.Gear then
-if lastGearByUID = HH^.Gear then lastGearByUID := nil;
+FollowGear:= nil;
-RemoveGearFromList(HH^.Gear);
-with HH^.Gear^ do
+if lastGearByUID = HH^.Gear then
+lastGearByUID := nil;
+RemoveGearFromList(HH^.Gear);
+with HH^.Gear^ do
+begin
+Z := cHHZ;
+Active := false;
+State:= State and (not (gstHHDriven or gstAttacking or gstAttacked));
+Message := Message and (not gmAttack);
+end;
+HH^.GearHidden:= HH^.Gear;
+HH^.Gear:= nil
+end;
+procedure RestoreHog(HH: PHedgehog);
+begin
+HH^.Gear:=HH^.GearHidden;
+HH^.GearHidden:= nil;
+InsertGearToList(HH^.Gear);
+HH^.Gear^.State:= (HH^.Gear^.State and (not (gstHHDriven or gstInvisible or gstAttacking))) or gstAttacked;
+AddGearCI(HH^.Gear);
+HH^.Gear^.Active:= true;
+ScriptCall('onHogRestore', HH^.Gear^.Uid)
+end;
+////////////////////////////////////////////////////////////////////////////////
+procedure CheckCollision(Gear: PGear); inline;
+begin
+if TestCollisionXwithGear(Gear, hwSign(Gear^.dX))
+or (TestCollisionYwithGear(Gear, hwSign(Gear^.dY)) <> 0) then
+Gear^.State := Gear^.State or gstCollision
+else
+Gear^.State := Gear^.State and (not gstCollision)
+end;
+procedure CheckCollisionWithLand(Gear: PGear); inline;
+begin
+if TestCollisionX(Gear, hwSign(Gear^.dX))
+or TestCollisionY(Gear, hwSign(Gear^.dY)) then
+Gear^.State := Gear^.State or gstCollision
+else
+Gear^.State := Gear^.State and (not gstCollision)
+end;
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+procedure doStepDrowningGear(Gear: PGear);
 begin
-Z := cHHZ;
-Active := false;
-State:= State and (not (gstHHDriven or gstAttacking or gstAttacked));
-Message := Message and (not gmAttack);
-end;
-HH^.GearHidden:= HH^.Gear;
-HH^.Gear:= nil
-end;
-procedure RestoreHog(HH: PHedgehog);
-begin
-HH^.Gear:=HH^.GearHidden;
-HH^.GearHidden:= nil;
-InsertGearToList(HH^.Gear);
-HH^.Gear^.State:= (HH^.Gear^.State and (not (gstHHDriven or gstInvisible or gstAttacking))) or gstAttacked;
-AddGearCI(HH^.Gear);
-HH^.Gear^.Active:= true;
-ScriptCall('onHogRestore', HH^.Gear^.Uid)
-end;
-////////////////////////////////////////////////////////////////////////////////
-procedure CheckCollision(Gear: PGear); inline;
-begin
-if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) or (TestCollisionYwithGear(Gear, hwSign(Gear^.dY)) <> 0) then
-Gear^.State := Gear^.State or gstCollision
-else Gear^.State := Gear^.State and (not gstCollision)
-end;
-procedure CheckCollisionWithLand(Gear: PGear); inline;
-begin
-if TestCollisionX(Gear, hwSign(Gear^.dX)) or TestCollisionY(Gear, hwSign(Gear^.dY)
-)
-then Gear^.State := Gear^.State or      gstCollision
-else Gear^.State := Gear^.State and (not gstCollision)
-end;
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-procedure doStepDrowningGear(Gear: PGear);
-begin
 AllInactive := false;
 Gear^.Y := Gear^.Y + cDrownSpeed;
 Gear^.X := Gear^.X + Gear^.dX * cDrownSpeed;
 // Create some bubbles (0.5% might be better but causes too few bubbles sometimes)
-if ((not SuddenDeathDmg and (cWaterOpacity < $FF)) or (SuddenDeathDmg and (cSDWaterOpacity < $FF))) and ((GameTicks and $1F) = 0) then
+if ((not SuddenDeathDmg and (cWaterOpacity < $FF))
+or (SuddenDeathDmg and (cSDWaterOpacity < $FF))) and ((GameTicks and $1F) = 0) then
 if (Gear^.Kind = gtHedgehog) and (Random(4) = 0) then
 AddVisualGear(hwRound(Gear^.X) - Gear^.Radius, hwRound(Gear^.Y) - Gear^.Radius, vgtBubble)
 else if Random(12) = 0 then
 AddVisualGear(hwRound(Gear^.X) - Gear^.Radius, hwRound(Gear^.Y) - Gear^.Radius, vgtBubble);
-if (not SuddenDeathDmg and (cWaterOpacity > $FE)) or (SuddenDeathDmg and (cSDWaterOpacity > $FE)) or (hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater) then
+if (not SuddenDeathDmg and (cWaterOpacity > $FE))
+or (SuddenDeathDmg and (cSDWaterOpacity > $FE))
+or (hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater) then
 DeleteGear(Gear);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFallingGear(Gear: PGear);
 var
 isFalling: boolean;
 tdX, tdY: hwFloat;
 collV, collH: LongInt;
 land: word;
 begin
 // clip velocity at 1.9 - over 1 per pixel, but really shouldn't cause many actual problems.
-if Gear^.dX.QWordValue > 8160437862 then Gear^.dX.QWordValue:= 8160437862;
+if Gear^.dX.QWordValue > 8160437862 then
-if Gear^.dY.QWordValue > 8160437862 then Gear^.dY.QWordValue:= 8160437862;
+Gear^.dX.QWordValue:= 8160437862;
+if Gear^.dY.QWordValue > 8160437862 then
+Gear^.dY.QWordValue:= 8160437862;
 Gear^.State := Gear^.State and (not gstCollision);
 collV := 0;
 collH := 0;
 tdX := Gear^.dX;
 tdY := Gear^.dY;
 // might need some testing/adjustments - just to avoid projectiles to fly forever (accelerated by wind/skips)
-if (hwRound(Gear^.X) < LAND_WIDTH div -2) or (hwRound(Gear^.X) > LAND_WIDTH * 3 div 2) then Gear^.State := Gear^.State or gstCollision;
+if (hwRound(Gear^.X) < LAND_WIDTH div -2)
+or (hwRound(Gear^.X) > LAND_WIDTH * 3 div 2) then
+Gear^.State := Gear^.State or gstCollision;
 if Gear^.dY.isNegative then
 begin
 isFalling := true;
 land:= TestCollisionYwithGear(Gear, -1);
 if land <> 0 then
 begin
 collV := -1;
-if land and lfIce <> 0 then Gear^.dX := Gear^.dX * (_0_9 + Gear^.Friction * _0_1)
+if land and lfIce <> 0 then
-else Gear^.dX := Gear^.dX * Gear^.Friction;
+Gear^.dX := Gear^.dX * (_0_9 + Gear^.Friction * _0_1)
+else
+Gear^.dX := Gear^.dX * Gear^.Friction;
 Gear^.dY := - Gear^.dY * Gear^.Elasticity;
 Gear^.State := Gear^.State or gstCollision
 end
-else if (Gear^.AdvBounce=1) and (TestCollisionYwithGear(Gear, 1) <> 0) then collV := 1;
+else if (Gear^.AdvBounce=1) and (TestCollisionYwithGear(Gear, 1) <> 0) then
+collV := 1;
 end
 else
 begin // Gear^.dY.isNegative is false
 land:= TestCollisionYwithGear(Gear, 1);
 if land <> 0 then
 Gear^.State := Gear^.State or gstCollision
 end
 else if (Gear^.AdvBounce=1) and TestCollisionXwithGear(Gear, -hwSign(Gear^.dX)) then
 collH := -hwSign(Gear^.dX);
 //if Gear^.AdvBounce and (collV <>0) and (collH <> 0) and (hwSqr(tdX) + hwSqr(tdY) > _0_08) then
-if (Gear^.AdvBounce=1) and (collV <>0) and (collH <> 0) and ((collV=-1) or ((tdX.QWordValue +
+if (Gear^.AdvBounce=1) and (collV <>0) and (collH <> 0) and ((collV=-1)
-tdY.QWordValue) > _0_2.QWordValue)) then
+or ((tdX.QWordValue + tdY.QWordValue) > _0_2.QWordValue)) then
 begin
 Gear^.dX := tdY*Gear^.Elasticity*Gear^.Friction;
 Gear^.dY := tdX*Gear^.Elasticity;
 //*Gear^.Friction;
 Gear^.dY.isNegative := not tdY.isNegative;
 isFalling := false;
 Gear^.AdvBounce := 10;
 end;
-if Gear^.AdvBounce > 1 then dec(Gear^.AdvBounce);
+if Gear^.AdvBounce > 1 then
+dec(Gear^.AdvBounce);
 if isFalling then
 begin
 Gear^.dY := Gear^.dY + cGravity;
-if (GameFlags and gfMoreWind) <> 0 then Gear^.dX := Gear^.dX + cWindSpeed / Gear^.Density
+if (GameFlags and gfMoreWind) <> 0 then
-end;
+Gear^.dX := Gear^.dX + cWindSpeed / Gear^.Density
+end;
 Gear^.X := Gear^.X + Gear^.dX;
 Gear^.Y := Gear^.Y + Gear^.dY;
 if Gear^.Kind <> gtBee then
 CheckGearDrowning(Gear);
 //if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) < _0_0002) and
 if (not isFalling) and ((Gear^.dX.QWordValue + Gear^.dY.QWordValue) < _0_02.QWordValue) then
 Gear^.State := Gear^.State and (not gstMoving)
 else
-Gear^.State := Gear^.State or      gstMoving;
+Gear^.State := Gear^.State or gstMoving;
-if (Gear^.nImpactSounds > 0) and
+if (Gear^.nImpactSounds > 0) and (((Gear^.Kind <> gtMine) and (Gear^.Damage <> 0))
-(((Gear^.Kind <> gtMine) and (Gear^.Damage <> 0)) or
+or ((Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving))) and(((Gear^.Radius < 3) and (Gear^.dY < -_0_1))
-((Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving))) and
+or ((Gear^.Radius >= 3) and ((Gear^.dX.QWordValue > _0_1.QWordValue)
-(((Gear^.Radius < 3) and (Gear^.dY < -_0_1)) or
+or (Gear^.dY.QWordValue > _0_1.QWordValue)))) then
-((Gear^.Radius >= 3) and ((Gear^.dX.QWordValue > _0_1.QWordValue) or
-(Gear^.dY.QWordValue > _0_1.QWordValue)))) then
 PlaySound(TSound(ord(Gear^.ImpactSound) + LongInt(GetRandom(Gear^.nImpactSounds))), true);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBomb(Gear: PGear);
 gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90);
 gtGasBomb: makeHogsWorry(Gear^.X, Gear^.Y, 50);
 end;
 if (Gear^.Kind = gtBall) and ((Gear^.State and gstTmpFlag) <> 0) then
 begin
 CheckCollision(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, Gear^.Hedgehog, EXPLDontDraw or EXPLNoGfx);
 end;
 if (Gear^.Kind = gtGasBomb) and ((GameTicks mod 200) = 0) then
 begin
 vg:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeWhite);
 if vg <> nil then
 vg^.Tint:= $FFC0C000;
 end;
 if Gear^.Timer = 0 then
 begin
 case Gear^.Kind of
 gtGrenade: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, Gear^.Hedgehog, EXPLAutoSound);
 gtClusterBomb:
 begin
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 doMakeExplosion(x, y, 20, Gear^.Hedgehog, EXPLAutoSound);
 for i:= 0 to 4 do
 begin
 dX := rndSign(GetRandom * _0_1) + Gear^.dX / 5;
 dY := (GetRandom - _3) * _0_08;
 FollowGear := AddGear(x, y, gtCluster, 0, dX, dY, 25)
 end
 end;
 gtWatermelon:
 begin
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 end;
 CalcRotationDirAngle(Gear);
 if Gear^.Kind = gtHellishBomb then
 begin
 if Gear^.Timer = 3000 then
 begin
 Gear^.nImpactSounds := 0;
 PlaySound(sndHellish);
 end;
 if (GameTicks and $3F) = 0 then
 if (Gear^.State and gstCollision) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtEvilTrace);
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMolotov(Gear: PGear);
 var
 // let's add some smoke depending on speed
 s:= max(32,152 - hwRound(Distance(Gear^.dX,Gear^.dY)*120))+random(10);
 if (GameTicks mod s) = 0 then
 begin
 // adjust angle to match the texture
-if Gear^.dX.isNegative then i:= 130 else i:= 50;
+if Gear^.dX.isNegative then
+i:= 130
+else
+i:= 50;
 smoke:= AddVisualGear(hwRound(Gear^.X)-round(cos((Gear^.DirAngle+i) * pi / 180)*20), hwRound(Gear^.Y)-round(sin((Gear^.DirAngle+i) * pi / 180)*20), vgtSmoke);
-if smoke <> nil then smoke^.Scale:= 0.75;
+if smoke <> nil then
+smoke^.Scale:= 0.75;
 end;
 if (Gear^.State and gstCollision) <> 0 then
 begin
 PlaySound(sndMolotov);
 gX := hwRound(Gear^.X);
 gY := hwRound(Gear^.Y);
 for i:= 0 to 4 do
 begin
 Frame:= 2;
 Tint:= $41B83ED0 - i * $10081000;
 Angle:= random * 360;
 dx:= 0.0000001;
 dy:= 0;
-if random(2) = 0 then dx := -dx;
+if random(2) = 0 then
+dx := -dx;
 FrameTicks:= 750;
 State:= ord(sprEgg)
 end;
 end;
 for i:= 0 to 24 do
 AddGear(gX, gY, gtFlame, gstTmpFlag,-dX, dY, 0);
 AddGear(gX, gY, gtFlame, gstTmpFlag,-dX,-dY, 0);
 end;
 DeleteGear(Gear);
 exit
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepCluster(Gear: PGear);
 begin
 AllInactive := false;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Timer, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 exit
 end;
-if (Gear^.Kind = gtMelonPiece) or (Gear^.Kind = gtBall) then
+if (Gear^.Kind = gtMelonPiece)
+or (Gear^.Kind = gtBall) then
 CalcRotationDirAngle(Gear)
 else if (GameTicks and $1F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepShell(Gear: PGear);
 begin
 AllInactive := false;
-if (GameFlags and gfMoreWind) = 0 then Gear^.dX := Gear^.dX + cWindSpeed;
+if (GameFlags and gfMoreWind) = 0 then
+Gear^.dX := Gear^.dX + cWindSpeed;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 procedure doStepSnowball(Gear: PGear);
 var kick, i: LongInt;
 particle: PVisualGear;
 begin
 AllInactive := false;
-if (GameFlags and gfMoreWind) = 0 then Gear^.dX := Gear^.dX + cWindSpeed;
+if (GameFlags and gfMoreWind) = 0 then
+Gear^.dX := Gear^.dX + cWindSpeed;
 doStepFallingGear(Gear);
 CalcRotationDirAngle(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 kick:= hwRound((hwAbs(Gear^.dX)+hwAbs(Gear^.dY)) * _20);
 Gear^.dX.isNegative:= not Gear^.dX.isNegative;
 AmmoShove(Gear, 1, kick);
 for i:= 15 + kick div 10 downto 0 do
 begin
 particle := AddVisualGear(hwRound(Gear^.X) + Random(25), hwRound(Gear^.Y) + Random(25), vgtDust);
-if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
+if particle <> nil then
+particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
 end;
 DeleteGear(Gear);
 exit
 end;
 if ((GameTicks and $1F) = 0) and (Random(3) = 0) then
 begin
 particle:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtDust);
-if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
+if particle <> nil then
+particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSnowflake(Gear: PGear);
 if gun then
 begin
 Gear^.State:= Gear^.State and (not gstInvisible);
 doStepFallingGear(Gear);
 CheckCollision(Gear);
-if ((Gear^.State and gstCollision) <> 0) or ((Gear^.State and gstMoving) = 0) then draw:= true;
+if ((Gear^.State and gstCollision) <> 0) or ((Gear^.State and gstMoving) = 0) then
+draw:= true;
 xx:= hwRound(Gear^.X);
 yy:= hwRound(Gear^.Y);
 end
 else if GameTicks and $7 = 0 then
 begin
 xx:= hwRound(X);
 yy:= hwRound(Y);
 if vobVelocity <> 0 then
 begin
 DirAngle := DirAngle + (Angle / 1250000000);
-if DirAngle < 0 then DirAngle := DirAngle + 360
+if DirAngle < 0 then
-else if 360 < DirAngle then DirAngle := DirAngle - 360;
+DirAngle := DirAngle + 360
+else if 360 < DirAngle then
+DirAngle := DirAngle - 360;
 end;
 inc(Health, 8);
 if longword(Health) > vobFrameTicks then
 begin
 dec(Health, vobFrameTicks);
 inc(Timer);
-if Timer = vobFramesCount then Timer:= 0
+if Timer = vobFramesCount then
+Timer:= 0
 end;
 // move back to cloud layer
-if yy > cWaterLine then move:= true
+if yy > cWaterLine then
-else if ((yy and LAND_HEIGHT_MASK) <> 0) or (xx > LAND_WIDTH + 512) or (xx < -512) then move:=true
+move:= true
+else if ((yy and LAND_HEIGHT_MASK) <> 0)
+or (xx > LAND_WIDTH + 512) or (xx < -512) then
+move:=true
 // Solid pixel encountered
 else if ((xx and LAND_WIDTH_MASK) = 0) and (Land[yy, xx] <> 0) then
 begin
 lf:= Land[yy, xx] and (lfObject or lfBasic);
 // If there's room below keep falling
 if draw then
 with Gear^ do
 begin
 // we've collided with land. draw some stuff and get back into the clouds
 move:= true;
-if (Pos > 20) and ((CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtRope)) then
+if (Pos > 20) and ((CurAmmoGear = nil)
+or (CurAmmoGear^.Kind <> gtRope)) then
 begin
 ////////////////////////////////// TODO - ASK UNC0RR FOR A GOOD HOME FOR THIS ////////////////////////////////////
 if not gun then
 begin
 dec(yy,3);
 end;
 if Land[yy + py, xx + px] and $FF00 = 0 then
 if gun then
 begin
 LandDirty[yy div 32, xx div 32]:= 1;
-if LandPixels[ry, rx] = 0 then Land[ly, lx]:=  lfDamaged or lfObject
+if LandPixels[ry, rx] = 0 then
+Land[ly, lx]:=  lfDamaged or lfObject
 else Land[ly, lx]:=  lfDamaged or lfBasic
 end
 else Land[ly, lx]:= lf;
 if gun then
 LandPixels[ry, rx]:= (cExplosionBorderColor and (not AMask)) or (p^[px] and AMask)
 end;
 // Why is this here.  For one thing, there's no test on +1 being safe.
 //Land[py, px+1]:= lfBasic;
-if allpx then UpdateLandTexture(xx, Pred(s^.h), yy, Pred(s^.w))
+if allpx then
+UpdateLandTexture(xx, Pred(s^.h), yy, Pred(s^.w))
 else
 begin
 UpdateLandTexture(
 max(0, min(LAND_WIDTH, xx)),
 min(LAND_WIDTH - xx, Pred(s^.w)),
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepGrave(Gear: PGear);
 begin
 AllInactive := false;
 if Gear^.dY.isNegative then
-if TestCollisionY(Gear, -1) then Gear^.dY := _0;
+if TestCollisionY(Gear, -1) then
+Gear^.dY := _0;
 if not Gear^.dY.isNegative then
 if TestCollisionY(Gear, 1) then
 begin
 Gear^.dY := - Gear^.dY * Gear^.Elasticity;
 if Gear^.dY > - _1div1024 then
 begin
 Gear^.Active := false;
 exit
 end
-else if Gear^.dY < - _0_03 then PlaySound(Gear^.ImpactSound)
+else if Gear^.dY < - _0_03 then
+PlaySound(Gear^.ImpactSound)
 end;
 Gear^.Y := Gear^.Y + Gear^.dY;
 CheckGearDrowning(Gear);
 Gear^.dY := Gear^.dY + cGravity
 uw := (Gear^.Tag <> 0); // was bee underwater last tick?
 nuw := (cWaterLine < gy + Gear^.Radius); // is bee underwater now?
 // if water entered or left
 if nuw <> uw then
 begin
 AddVisualGear(gX, cWaterLine, vgtSplash);
 AddVisualGear(gX - 3 + Random(6), cWaterLine, vgtDroplet);
 AddVisualGear(gX - 3 + Random(6), cWaterLine, vgtDroplet);
 AddVisualGear(gX - 3 + Random(6), cWaterLine, vgtDroplet);
 AddVisualGear(gX - 3 + Random(6), cWaterLine, vgtDroplet);
 StopSound(Gear^.SoundChannel);
 if nuw then
 begin
 Gear^.SoundChannel := LoopSound(sndBeeWater);
 Gear^.Tag := 1;
 end
 else
 begin
 Gear^.SoundChannel := LoopSound(sndBee);
 Gear^.Tag := 0;
 end;
 end;
 if Gear^.Timer = 0 then
 Gear^.RenderTimer:= false
 else
 begin
 if (GameTicks and $F) = 0 then
 begin
 if (GameTicks and $30) = 0 then
 AddVisualGear(gX, gY, vgtBeeTrace);
 Gear^.dX := Gear^.Elasticity * (Gear^.dX + _0_000064 * (Gear^.Target.X - gX));
 Gear^.dY := Gear^.Elasticity * (Gear^.dY + _0_000064 * (Gear^.Target.Y - gY));
 // make sure new speed isn't higher than original one (which we stored in Friction variable)
 t := Gear^.Friction / Distance(Gear^.dX, Gear^.dY);
 Gear^.dX := Gear^.dX * t;
 Gear^.dY := Gear^.dY * t;
 end;
 Gear^.X := Gear^.X + Gear^.dX;
 Gear^.Y := Gear^.Y + Gear^.dY;
 end;
 CheckCollision(Gear);
 if ((Gear^.State and gstCollision) <> 0) then
 begin
 StopSound(Gear^.SoundChannel);
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 for i:= 0 to 31 do
 begin
 flower:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot);
 with flower^ do
 begin
 Scale:= 0.75;
 dx:= 0.001 * (random(200));
 dy:= 0.001 * (random(200));
-if random(2) = 0 then dx := -dx;
+if random(2) = 0 then
-if random(2) = 0 then dy := -dy;
+dx := -dx;
+if random(2) = 0 then
+dy := -dy;
 FrameTicks:= random(250) + 250;
 State:= ord(sprTargetBee);
 end;
 end;
 DeleteGear(Gear);
 end;
 if (Gear^.Timer > 0) then
 dec(Gear^.Timer)
 else
 begin
 if nuw then
 begin
 StopSound(Gear^.SoundChannel);
 CheckGearDrowning(Gear);
 end
 else
 doStepFallingGear(Gear);
 end;
 end;
 procedure doStepBee(Gear: PGear);
 begin
 AllInactive := false;
 Gear^.X := Gear^.X + Gear^.dX;
 Gear^.Y := Gear^.Y + Gear^.dY;
 Gear^.dY := Gear^.dY + cGravity;
 CheckCollision(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 exit
 end;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 begin
 Gear^.Hedgehog^.Gear^.Message:= Gear^.Hedgehog^.Gear^.Message and (not gmAttack);
 Gear^.Hedgehog^.Gear^.State:= Gear^.Hedgehog^.Gear^.State and (not gstAttacking);
 AttackBar:= 0;
 Gear^.SoundChannel := LoopSound(sndBee);
 Gear^.Timer := 5000;
 // save initial speed in otherwise unused Friction variable
 Gear^.Friction := Distance(Gear^.dX, Gear^.dY);
 Gear^.doStep := @doStepBeeWork
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepShotIdle(Gear: PGear);
 begin
 AllInactive := false;
 inc(Gear^.Timer);
 if Gear^.Timer > 75 then
 begin
 DeleteGear(Gear);
 AfterAttack
 end
 end;
 procedure doStepShotgunShot(Gear: PGear);
 var
 i: LongWord;
 shell: PVisualGear;
 begin
 AllInactive := false;
 if ((Gear^.State and gstAnimation) = 0) then
 begin
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 begin
 PlaySound(sndShotgunFire);
 shell := AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell);
 if shell <> nil then
 begin
 shell^.dX := gear^.dX.QWordValue / -17179869184;
 shell^.dY := gear^.dY.QWordValue / -17179869184;
 shell^.Frame := 0
 end;
 Gear^.State := Gear^.State or gstAnimation
 end;
 exit
 end
-else inc(Gear^.Timer);
+else
+inc(Gear^.Timer);
-i := 200;
+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
 Gear^.X := Gear^.X + Gear^.dX * 8;
 Gear^.Y := Gear^.Y + Gear^.dY * 8;
 ShotgunShot(Gear);
 Gear^.doStep := @doStepShotIdle;
 exit
 end;
 CheckGearDrowning(Gear);
 if (Gear^.State and gstDrowning) <> 0 then
 begin
 Gear^.doStep := @doStepShotIdle;
 exit
 end;
 dec(i)
 until i = 0;
-if (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0)
+if (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0) or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then
-then
 Gear^.doStep := @doStepShotIdle
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure spawnBulletTrail(Bullet: PGear);
 oy:= Bullet^.Friction;
 end;
 // Bullet trail
 VGear := AddVisualGear(hwRound(ox), hwRound(oy), vgtLineTrail);
 if VGear <> nil then
 begin
 VGear^.X:= hwFloat2Float(ox);
 VGear^.Y:= hwFloat2Float(oy);
 VGear^.dX:= hwFloat2Float(Bullet^.X);
 VGear^.dY:= hwFloat2Float(Bullet^.Y);
 // reached edge of land. assume infinite beam. Extend it way out past camera
 if (hwRound(Bullet^.X) and LAND_WIDTH_MASK <> 0)
 or (hwRound(Bullet^.Y) and LAND_HEIGHT_MASK <> 0) then
 // only extend if not under water
 if hwRound(Bullet^.Y) < cWaterLine then
 begin
 VGear^.dX := VGear^.dX + LAND_WIDTH * (VGear^.dX - VGear^.X);
 VGear^.dY := VGear^.dY + LAND_WIDTH * (VGear^.dY - VGear^.Y);
 repeat
 Gear^.X := Gear^.X + Gear^.dX;
 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)
-and (Land[y, x] <> 0) then inc(Gear^.Damage);
+if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) and (Land[y, x] <> 0) then
+inc(Gear^.Damage);
 // let's interrupt before a collision to give portals a chance to catch the bullet
 if (Gear^.Damage = 1) and (Gear^.Tag = 0) and (Land[y, x] > 255) then
 begin
 Gear^.Tag := 1;
 Gear^.Damage := 0;
 Gear^.X := Gear^.X - Gear^.dX;
 Gear^.Y := Gear^.Y - Gear^.dY;
 CheckGearDrowning(Gear);
 break;
 end
 else
 Gear^.Tag := 0;
 if Gear^.Damage > 5 then
 if Gear^.AmmoType = amDEagle then
 AmmoShove(Gear, 7, 20)
 else
 AmmoShove(Gear, Gear^.Timer, 20);
 CheckGearDrowning(Gear);
-dec(i)
+dec(i) until (i = 0) or (Gear^.Damage > Gear^.Health) or ((Gear^.State and gstDrowning) <> 0);
-until (i = 0) or (Gear^.Damage > Gear^.Health) or ((Gear^.State and gstDrowning) <> 0);
 if Gear^.Damage > 0 then
 begin
 DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 82 - i, 1);
 dec(Gear^.Health, Gear^.Damage);
 Gear^.Damage := 0
 end;
 if ((Gear^.State and gstDrowning) <> 0) and (Gear^.Damage < Gear^.Health) and ((not SuddenDeathDmg and (cWaterOpacity < $FF)) or (SuddenDeathDmg and (cSDWaterOpacity < $FF))) then
 begin
 for i:=(Gear^.Health - Gear^.Damage) * 4 downto 0 do
 begin
 if Random(6) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtBubble);
 Gear^.X := Gear^.X + Gear^.dX;
 Gear^.Y := Gear^.Y + Gear^.dY;
 end;
 end;
 if (Gear^.Health <= 0)
 or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0)
 or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then
 begin
 if (Gear^.Kind = gtSniperRifleShot) and ((GameFlags and gfLaserSight) = 0) then
 cLaserSighting := false;
-if (Ammoz[Gear^.AmmoType].Ammo.NumPerTurn <= CurrentHedgehog^.MultiShootAttacks) and
+if (Ammoz[Gear^.AmmoType].Ammo.NumPerTurn <= CurrentHedgehog^.MultiShootAttacks) and ((GameFlags and gfArtillery) = 0) then
-((GameFlags and gfArtillery) = 0) then cArtillery := false;
+cArtillery := false;
 // Bullet Hit
-if (hwRound(Gear^.X) and LAND_WIDTH_MASK = 0)
+if (hwRound(Gear^.X) and LAND_WIDTH_MASK = 0) and (hwRound(Gear^.Y) and LAND_HEIGHT_MASK = 0) then
-and (hwRound(Gear^.Y) and LAND_HEIGHT_MASK = 0) then
+begin
-begin
+VGear := AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtBulletHit);
-VGear := AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtBulletHit);
+if VGear <> nil then
-if VGear <> nil then
+begin
-begin
+VGear^.Angle := DxDy2Angle(-Gear^.dX, Gear^.dY);
-VGear^.Angle := DxDy2Angle(-Gear^.dX, Gear^.dY);
+end;
 end;
-end;
 spawnBulletTrail(Gear);
 Gear^.doStep := @doStepShotIdle
 end;
 end;
 procedure doStepDEagleShot(Gear: PGear);
 begin
 PlaySound(sndGun);
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.State := HHGear^.State or gstNotKickable;
 HedgehogChAngle(HHGear);
 if not cLaserSighting then
 // game does not have default laser sight. turn it on and give them a chance to aim
 begin
 cLaserSighting := true;
 HHGear^.Message := 0;
-if (HHGear^.Angle - 32 >= 0) then dec(HHGear^.Angle,32)
+if (HHGear^.Angle - 32 >= 0) then
-end;
+dec(HHGear^.Angle,32)
+end;
 if (HHGear^.Message and gmAttack) <> 0 then
 begin
 shell := AddVisualGear(hwRound(Gear^.x), hwRound(Gear^.y), vgtShell);
 if shell <> nil then
 begin
 shell^.dX := gear^.dX.QWordValue / -8589934592;
 shell^.dY := gear^.dY.QWordValue / -8589934592;
 shell^.Frame := 1
 end;
 Gear^.State := Gear^.State or gstAnimation;
 Gear^.dX := SignAs(AngleSin(HHGear^.Angle), HHGear^.dX) * _0_5;
 Gear^.dY := -AngleCos(HHGear^.Angle) * _0_5;
 PlaySound(sndGun);
 // add 3 initial steps to avoid problem with ammoshove related to calculation of radius + 1 radius as gear widths, and also just weird angles
 Gear^.X := Gear^.X + Gear^.dX * 3;
 Gear^.Y := Gear^.Y + Gear^.dY * 3;
 Gear^.doStep := @doStepBulletWork;
 end
 else
 if (GameTicks mod 32) = 0 then
 if (GameTicks mod 4096) < 2048 then
 begin
-if (HHGear^.Angle + 1 <= cMaxAngle) then inc(HHGear^.Angle)
+if (HHGear^.Angle + 1 <= cMaxAngle) then
-end
+inc(HHGear^.Angle)
+end
 else
-if (HHGear^.Angle - 1 >= 0) then dec(HHGear^.Angle);
+if (HHGear^.Angle - 1 >= 0) then
+dec(HHGear^.Angle);
 if (TurnTimeLeft > 0) then
 dec(TurnTimeLeft)
 else
 begin
 DeleteGear(Gear);
 AfterAttack
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepActionTimer(Gear: PGear);
 begin
 dec(Gear^.Timer);
 case Gear^.Kind of
 gtATStartGame:
 begin
 AllInactive := false;
 if Gear^.Timer = 0 then
 begin
 AddCaption(trmsg[sidStartFight], cWhiteColor, capgrpGameState);
 end
 end;
 gtATFinishGame:
 begin
 AllInactive := false;
 if Gear^.Timer = 1000 then
 begin
 ScreenFade := sfToBlack;
 ScreenFadeValue := 0;
 ScreenFadeSpeed := 1;
 end;
 if Gear^.Timer = 0 then
 begin
 SendIPC('N');
 SendIPC('q');
 GameState := gsExit
 end
 end;
 end;
-if Gear^.Timer = 0 then DeleteGear(Gear)
+if Gear^.Timer = 0 then
+DeleteGear(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepPickHammerWork(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 dec(Gear^.Timer);
-if ((GameFlags and gfInfAttack) <> 0) and (TurnTimeLeft > 0) then dec(TurnTimeLeft);
+if ((GameFlags and gfInfAttack) <> 0) and (TurnTimeLeft > 0) then
-if (TurnTimeLeft = 0) or (Gear^.Timer = 0)or((Gear^.Message and gmDestroy) <> 0)or((HHGear^.State and gstHHDriven) =
+dec(TurnTimeLeft);
-0) then
+if (TurnTimeLeft = 0) or (Gear^.Timer = 0)
+or((Gear^.Message and gmDestroy) <> 0)
+or((HHGear^.State and gstHHDriven) =0) then
 begin
 StopSound(Gear^.SoundChannel);
 DeleteGear(Gear);
 AfterAttack;
 doStepHedgehogMoving(HHGear);  // for gfInfAttack
 if CheckLandValue(hwRound(Gear^.X), hwRound(Gear^.Y + Gear^.dY + cGravity), $FF00) then
 begin
 Gear^.dY := Gear^.dY + cGravity;
 Gear^.Y := Gear^.Y + Gear^.dY
 end;
-if hwRound(Gear^.Y) > cWaterLine then Gear^.Timer := 1
+if hwRound(Gear^.Y) > cWaterLine then
+Gear^.Timer := 1
 end;
 Gear^.X := Gear^.X + HHGear^.dX;
 if CheckLandValue(hwRound(Gear^.X), hwRound(Gear^.Y)-cHHRadius, $FF00) then
 begin
 HHGear^.X := Gear^.X;
 HHGear^.Y := Gear^.Y - int2hwFloat(cHHRadius)
 end;
 if (Gear^.Message and gmAttack) <> 0 then
-if (Gear^.State and gsttmpFlag) <> 0 then Gear^.Timer := 1
+if (Gear^.State and gsttmpFlag) <> 0 then
+Gear^.Timer := 1
+else //there would be a mistake.
 else
+if (Gear^.State and gsttmpFlag) = 0 then
+Gear^.State := Gear^.State or gsttmpFlag;
+if ((Gear^.Message and gmLeft) <> 0) then
+Gear^.dX := - _0_3
 else
-if (Gear^.State and gsttmpFlag) = 0 then Gear^.State := Gear^.State or gsttmpFlag;
+if ((Gear^.Message and gmRight) <> 0) then
-if ((Gear^.Message and gmLeft) <> 0) then Gear^.dX := - _0_3
+Gear^.dX := _0_3
-else
-if ((Gear^.Message and gmRight) <> 0) then Gear^.dX := _0_3
 else Gear^.dX := _0;
 end;
 procedure doStepPickHammer(Gear: PGear);
 var
 i := 0;
 HHGear := Gear^.Hedgehog^.Gear;
 y := hwRound(Gear^.Y) - cHHRadius * 2;
 while y < hwRound(Gear^.Y) do
 begin
 ar[i].Left := hwRound(Gear^.X) - Gear^.Radius - LongInt(GetRandom(2));
 ar[i].Right := hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2));
 inc(y, 2);
 inc(i)
 end;
 DrawHLinesExplosions(@ar, 3, hwRound(Gear^.Y) - cHHRadius * 2, 2, Pred(i));
 Gear^.dY := HHGear^.dY;
 DeleteCI(HHGear);
 b: boolean;
 prevX: LongInt;
 begin
 AllInactive := false;
 dec(Gear^.Timer);
-if ((GameFlags and gfInfAttack) <> 0) and (TurnTimeLeft > 0) then dec(TurnTimeLeft);
+if ((GameFlags and gfInfAttack) <> 0) and (TurnTimeLeft > 0) then
+dec(TurnTimeLeft);
 HHGear := Gear^.Hedgehog^.Gear;
 HedgehogChAngle(HHGear);
 end;
 if ((HHGear^.State and gstMoving) <> 0) then
 begin
 doStepHedgehogMoving(HHGear);
-if (HHGear^.State and gstHHDriven) = 0 then Gear^.Timer := 0
+if (HHGear^.State and gstHHDriven) = 0 then
+Gear^.Timer := 0
 end;
 if Gear^.Timer mod cHHStepTicks = 0 then
 begin
 b := true;
 inc(BTSteps);
 if BTSteps = 7 then
 begin
 BTSteps := 0;
-if CheckLandValue(hwRound(HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC) + SignAs(_6,
+if CheckLandValue(hwRound(HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC) + SignAs(_6,Gear^.dX)), hwRound(HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC)),lfIndestructible) then
-Gear^.dX)), hwRound(HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC)),
-lfIndestructible) then
 begin
 Gear^.X := HHGear^.X + Gear^.dX * (cHHRadius + cBlowTorchC);
 Gear^.Y := HHGear^.Y + Gear^.dY * (cHHRadius + cBlowTorchC);
 end;
 HHGear^.State := HHGear^.State or gstNoDamage;
 ((hwAbs(Gear^.dX) / (hwAbs(Gear^.dX) + hwAbs(Gear^.dY))) * _0_5 * 7),
 Gear^.dX, Gear^.dY,
 cHHStepTicks, cHHRadius * 2 + 7);
 end;
-if (TurnTimeLeft = 0) or (Gear^.Timer = 0) or ((HHGear^.Message and gmAttack) <> 0) then
+if (TurnTimeLeft = 0) or (Gear^.Timer = 0)
+or ((HHGear^.Message and gmAttack) <> 0) then
 begin
 HHGear^.Message := 0;
 HHGear^.State := HHGear^.State and (not gstNotKickable);
 DeleteGear(Gear);
 AfterAttack
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 if ((HHGear^.State and gstHHDriven) = 0)
 or (CheckGearDrowning(HHGear))
 or (TestCollisionYwithGear(HHGear, 1) <> 0) then
 begin
 DeleteGear(Gear);
 isCursorVisible := false;
 ApplyAmmoChanges(HHGear^.Hedgehog^);
 exit
 end;
 HedgehogChAngle(HHGear);
-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) <> 0) then HHGear^.dY := _0;
+if HHGear^.dY.isNegative and (TestCollisionYwithGear(HHGear, -1) <> 0) then
+HHGear^.dY := _0;
 HHGear^.X := HHGear^.X + HHGear^.dX;
 HHGear^.Y := HHGear^.Y + HHGear^.dY;
 HHGear^.dY := HHGear^.dY + cGravity;
-if (GameFlags and gfMoreWind) <> 0 then HHGear^.dX := HHGear^.dX + cWindSpeed / HHGear^.Density;
+if (GameFlags and gfMoreWind) <> 0 then
+HHGear^.dX := HHGear^.dX + cWindSpeed / HHGear^.Density;
 if (Gear^.Message and gmAttack) <> 0 then
 begin
 Gear^.X := HHGear^.X;
 Gear^.Y := HHGear^.Y;
 end;
 procedure RopeDeleteMe(Gear, HHGear: PGear);
 begin
 with HHGear^ do
 begin
 Message := Message and (not gmAttack);
 State := (State or gstMoving) and (not gstWinner);
 end;
 DeleteGear(Gear)
 end;
 procedure RopeWaitCollision(Gear, HHGear: PGear);
 begin
 with HHGear^ do
 begin
 Message := Message and (not gmAttack);
 State := State or gstMoving;
 end;
 RopePoints.Count := 0;
 Gear^.Elasticity := _0;
 Gear^.doStep := @doStepRopeAfterAttack
 end;
 tx := HHGear^.X;
 ty := HHGear^.Y;
 if ((Gear^.Message and gmDown) <> 0) and (Gear^.Elasticity < Gear^.Friction) then
 if not (TestCollisionXwithGear(HHGear, hwSign(ropeDx))
 or (TestCollisionYwithGear(HHGear, hwSign(ropeDy)) <> 0)) then
 Gear^.Elasticity := Gear^.Elasticity + _0_3;
 if ((Gear^.Message and gmUp) <> 0) and (Gear^.Elasticity > _30) then
 if not (TestCollisionXwithGear(HHGear, -hwSign(ropeDx))
 or (TestCollisionYwithGear(HHGear, -hwSign(ropeDy)) <> 0)) then
 Gear^.Elasticity := Gear^.Elasticity - _0_3;
 HHGear^.X := Gear^.X + mdX * Gear^.Elasticity;
 HHGear^.Y := Gear^.Y + mdY * Gear^.Elasticity;
 with RopePoints.ar[RopePoints.Count] do
 begin
 X := Gear^.X;
 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);
 dLen := len
 end;
 with RopePoints.rounded[RopePoints.Count] do
 begin
 X := hwRound(Gear^.X);
 Y := hwRound(Gear^.Y);
 end;
 begin
 HHGear^.dY := -_0_6 * HHGear^.dY;
 haveCollision := true
 end;
-if haveCollision
+if haveCollision and (Gear^.Message and (gmLeft or gmRight) <> 0) and (Gear^.Message and (gmUp or gmDown) <> 0) then
-and (Gear^.Message and (gmLeft or gmRight) <> 0)
-and (Gear^.Message and (gmUp or gmDown) <> 0) then
 begin
 HHGear^.dX := SignAs(hwAbs(HHGear^.dX) + _0_2, HHGear^.dX);
 HHGear^.dY := SignAs(hwAbs(HHGear^.dY) + _0_2, HHGear^.dY)
 end;
 end;
 procedure RopeRemoveFromAmmo(Gear, HHGear: PGear);
 begin
 if (Gear^.State and gstAttacked) = 0 then
 begin
 OnUsedAmmo(HHGear^.Hedgehog^);
 Gear^.State := Gear^.State or gstAttacked
 end;
 ApplyAmmoChanges(HHGear^.Hedgehog^)
 end;
 procedure doStepRopeAttach(Gear: PGear);
 var
 HHGear := Gear^.Hedgehog^.Gear;
 DeleteCI(HHGear);
 if (HHGear^.State and gstMoving) <> 0 then
 begin
-if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then SetLittle(HHGear^.dX);
+if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then
-if HHGear^.dY.isNegative and (TestCollisionYwithGear(HHGear, -1) <> 0) then HHGear^.dY := _0;
+SetLittle(HHGear^.dX);
+if HHGear^.dY.isNegative and (TestCollisionYwithGear(HHGear, -1) <> 0) then
+HHGear^.dY := _0;
 HHGear^.X := HHGear^.X + HHGear^.dX;
 Gear^.X := Gear^.X + HHGear^.dX;
 if TestCollisionYwithGear(HHGear, 1) <> 0 then
 else
 begin
 HHGear^.Y := HHGear^.Y + HHGear^.dY;
 Gear^.Y := Gear^.Y + HHGear^.dY;
 HHGear^.dY := HHGear^.dY + cGravity;
-if (GameFlags and gfMoreWind) <> 0 then HHGear^.dX := HHGear^.dX + cWindSpeed / HHGear^.Density
+if (GameFlags and gfMoreWind) <> 0 then
+HHGear^.dX := HHGear^.dX + cWindSpeed / HHGear^.Density
 end;
 tt := Gear^.Elasticity;
 tx := _0;
 ty := _0;
 exit
 end;
 if (Gear^.Elasticity > Gear^.Friction)
 or ((Gear^.Message and gmAttack) = 0)
 or ((HHGear^.State and gstHHDriven) = 0)
 or (HHGear^.Damage > 0) then
 begin
 with Gear^.Hedgehog^.Gear^ do
 begin
 State := State and (not gstAttacking);
 Message := Message and (not gmAttack)
 end;
 DeleteGear(Gear)
 end;
 CheckGearDrowning(HHGear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMine(Gear: PGear);
 var vg: PVisualGear;
 begin
 if (Gear^.State and gstMoving) <> 0 then
 begin
 DeleteCI(Gear);
 doStepFallingGear(Gear);
 if (Gear^.State and gstMoving) = 0 then
 begin
 AddGearCI(Gear);
 Gear^.dX := _0;
 Gear^.dY := _0
 end;
 CalcRotationDirAngle(Gear);
 AllInactive := false
 end
 else
 if ((GameTicks and $3F) = 25) then
 doStepFallingGear(Gear);
 if (Gear^.Health = 0) then
 begin
 if not Gear^.dY.isNegative and (Gear^.dY > _0_2) and (TestCollisionYwithGear(Gear, 1) <> 0) then
 inc(Gear^.Damage, hwRound(Gear^.dY * _70))
 else if not Gear^.dX.isNegative and (Gear^.dX > _0_2) and TestCollisionXwithGear(Gear, 1) then
 inc(Gear^.Damage, hwRound(Gear^.dX * _70))
 else if Gear^.dY.isNegative and (Gear^.dY < -_0_2) and (TestCollisionYwithGear(Gear, -1) <> 0) then
 inc(Gear^.Damage, hwRound(Gear^.dY * -_70))
 else if Gear^.dX.isNegative and (Gear^.dX < -_0_2) and TestCollisionXwithGear(Gear, -1) then
 inc(Gear^.Damage, hwRound(Gear^.dX * -_70));
 if ((GameTicks and $FF) = 0) and (Gear^.Damage > random(30)) then
 begin
 vg:= AddVisualGear(hwRound(Gear^.X) - 4  + Random(8), hwRound(Gear^.Y) - 4 - Random(4), vgtSmoke);
-if vg <> nil then vg^.Scale:= 0.5
+if vg <> nil then
-end;
+vg^.Scale:= 0.5
+end;
 if (Gear^.Damage > 35) then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Health <> 0) then
 if ((Gear^.State and gstAttacking) = 0) then
 begin
 if ((GameTicks and $1F) = 0) then
-if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State := Gear^.State or
+if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then
-gstAttacking
+Gear^.State := Gear^.State or gstAttacking
 end
 else // gstAttacking <> 0
 begin
 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
 begin
-if ((Gear^.State and gstWait) <> 0) or
+if ((Gear^.State and gstWait) <> 0)
-(cMineDudPercent = 0) or
+or (cMineDudPercent = 0)
-(getRandom(100) > cMineDudPercent) then
+or (getRandom(100) > cMineDudPercent) then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear)
 end
 else
 begin
 vg:= AddVisualGear(hwRound(Gear^.X) - 4  + Random(8), hwRound(Gear^.Y) - 4 - Random(4), vgtSmoke);
-if vg <> nil then vg^.Scale:= 0.5;
+if vg <> nil then
+vg^.Scale:= 0.5;
 PlaySound(sndVaporize);
 Gear^.Health := 0;
 Gear^.Damage := 0;
 Gear^.State := Gear^.State and (not gstAttacking)
 end;
 exit
 end;
 dec(Gear^.Timer);
 end
 else // gsttmpFlag = 0
-if (TurnTimeLeft = 0) or ((GameFlags and gfInfAttack <> 0) and (GameTicks > Gear^.FlightTime)) or (Gear^.Hedgehog^.Gear = nil) then Gear^.State := Gear^.State or gsttmpFlag;
+if (TurnTimeLeft = 0)
+or ((GameFlags and gfInfAttack <> 0) and (GameTicks > Gear^.FlightTime))
+or (Gear^.Hedgehog^.Gear = nil) then
+Gear^.State := Gear^.State or gsttmpFlag;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSMine(Gear: PGear);
 begin
 // TODO: do real calculation?
 if TestCollisionXwithGear(Gear, 2)
 or (TestCollisionYwithGear(Gear, -2) <> 0)
 or TestCollisionXwithGear(Gear, -2)
 or (TestCollisionYwithGear(Gear, 2) <> 0) then
 begin
 if (hwAbs(Gear^.dX) > _0) or (hwAbs(Gear^.dY) > _0) then
 begin
 PlaySound(sndRopeAttach);
 Gear^.dX:= _0;
 Gear^.dY:= _0;
 AddGearCI(Gear);
 end;
 end
 else
 begin
 DeleteCI(Gear);
 doStepFallingGear(Gear);
 AllInactive := false;
 CalcRotationDirAngle(Gear);
 end;
 if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Health <> 0) then
 begin
 if ((Gear^.State and gstAttacking) = 0) then
 begin
 if ((GameTicks and $1F) = 0) then
-if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then Gear^.State := Gear^.State or
+if CheckGearNear(Gear, gtHedgehog, 46, 32) <> nil then
-gstAttacking
+Gear^.State := Gear^.State or gstAttacking
 end
 else // gstAttacking <> 0
 begin
 AllInactive := false;
 if Gear^.Timer = 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 exit
 end else
-if (Gear^.Timer and $FF) = 0 then PlaySound(sndMineTick);
+if (Gear^.Timer and $FF) = 0 then
+PlaySound(sndMineTick);
 dec(Gear^.Timer);
+end
 end
-end
 else // gsttmpFlag = 0
-if (TurnTimeLeft = 0) or ((GameFlags and gfInfAttack <> 0) and (GameTicks > Gear^.FlightTime)) or (Gear^.Hedgehog^.Gear = nil) then Gear^.State := Gear^.State or gsttmpFlag;
+if (TurnTimeLeft = 0)
+or ((GameFlags and gfInfAttack <> 0) and (GameTicks > Gear^.FlightTime))
+or (Gear^.Hedgehog^.Gear = nil) 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 mod 166 = 0 then
+inc(Gear^.Tag);
 if Gear^.Timer = 1000 then // might need better timing
 makeHogsWorry(Gear^.X, Gear^.Y, 75);
 if Gear^.Timer = 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 exit
 end;
 dec(Gear^.Timer);
 end;
 ///////////////////////////////////////////////////////////////////////////////
 procedure doStepRollingBarrel(Gear: PGear);
 var
 i: LongInt;
 particle: PVisualGear;
 begin
-if (Gear^.dY.QWordValue = 0) and (Gear^.dY.QWordValue = 0) and (TestCollisionYwithGear(Gear, 1) = 0) then SetLittle(Gear^.dY);
+if (Gear^.dY.QWordValue = 0) and (Gear^.dY.QWordValue = 0) and (TestCollisionYwithGear(Gear, 1) = 0) then
+SetLittle(Gear^.dY);
 Gear^.State := Gear^.State or gstAnimation;
-if ((Gear^.dX.QWordValue <> 0) or (Gear^.dY.QWordValue <> 0))  then
-begin
+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_2) and (TestCollisionYwithGear(Gear, 1) <> 0) then
 begin
 Gear^.State := Gear^.State or gsttmpFlag;
 inc(Gear^.Damage, hwRound(Gear^.dY * _70));
 for i:= min(12, hwRound(Gear^.dY*_10)) downto 0 do
 begin
-particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12,
+particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12,vgtDust);
-vgtDust);
+if particle <> nil then
-if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
+particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
+end
 end
-end
+else if not Gear^.dX.isNegative and (Gear^.dX > _0_2) and TestCollisionXwithGear(Gear, 1) then
-else if not Gear^.dX.isNegative and (Gear^.dX > _0_2) and TestCollisionXwithGear(Gear, 1)
+inc(Gear^.Damage, hwRound(Gear^.dX * _70))
-then
-inc(Gear^.Damage, hwRound(Gear^.dX * _70))
+else if Gear^.dY.isNegative and (Gear^.dY < -_0_2) and (TestCollisionYwithGear(Gear, -1) <> 0) then
-else if Gear^.dY.isNegative and (Gear^.dY < -_0_2) and (TestCollisionYwithGear(Gear, -1) <> 0)
+inc(Gear^.Damage, hwRound(Gear^.dY * -_70))
-then
-inc(Gear^.Damage, hwRound(Gear^.dY * -_70))
+else if Gear^.dX.isNegative and (Gear^.dX < -_0_2) and TestCollisionXwithGear(Gear, -1) then
-else if Gear^.dX.isNegative and (Gear^.dX < -_0_2) and TestCollisionXwithGear(Gear, -1)
+inc(Gear^.Damage, hwRound(Gear^.dX * -_70));
-then
-inc(Gear^.Damage, hwRound(Gear^.dX * -_70));
 doStepFallingGear(Gear);
 CalcRotationDirAngle(Gear);
 //CheckGearDrowning(Gear)
 end
 else
 begin
 Gear^.State := Gear^.State or gsttmpFlag;
 AddGearCI(Gear)
 end;
 (*
 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);
 Gear^.dX:= _0_08;
 end;
 if Gear^.dX.QWordValue = 0 then AddGearCI(Gear)
 end; *)
-if not Gear^.dY.isNegative and (Gear^.dY < _0_001) and (TestCollisionYwithGear(Gear, 1) <> 0) then Gear
+if not Gear^.dY.isNegative and (Gear^.dY < _0_001) and (TestCollisionYwithGear(Gear, 1) <> 0) then
-^.dY := _0;
+Gear^.dY := _0;
-if hwAbs(Gear^.dX) < _0_001 then Gear^.dX := _0;
+if hwAbs(Gear^.dX) < _0_001 then
+Gear^.dX := _0;
 if (Gear^.Health > 0) and ((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);
 Gear^.Damage := 0;
-if Gear^.Health <= 0 then Gear^.doStep := @doStepCase;
+if Gear^.Health <= 0 then
+Gear^.doStep := @doStepCase;
 // Hand off to doStepCase for the explosion
 end;
 procedure doStepCase(Gear: PGear);
 begin
 k := Gear^.Kind;
 exBoom := false;
 if (Gear^.Message and gmDestroy) > 0 then
 begin
 DeleteGear(Gear);
 FreeActionsList;
 SetAllToActive;
 // something (hh, mine, etc...) could be on top of the case
 with CurrentHedgehog^ do
-if Gear <> nil then Gear^.Message := Gear^.Message and (not (gmLJump or gmHJump));
+if Gear <> nil then
+Gear^.Message := Gear^.Message and (not (gmLJump or gmHJump));
 exit
 end;
 if k = gtExplosives then
 begin
 //if V > _0_03 then Gear^.State:= Gear^.State or gstAnimation;
-if (hwAbs(Gear^.dX) > _0_15) or ((hwAbs(Gear^.dY) > _0_15) and (hwAbs(Gear^.dX) > _0_02))
+if (hwAbs(Gear^.dX) > _0_15) or ((hwAbs(Gear^.dY) > _0_15) and (hwAbs(Gear^.dX) > _0_02)) then
-then Gear^.doStep := @doStepRollingBarrel;
+Gear^.doStep := @doStepRollingBarrel;
 if (Gear^.Health > 0) and ((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);
 Gear^.Damage := 0;
 if Gear^.Health <= 0 then
 exBoom := true;
 end;
 if (Gear^.Damage > 0) or exBoom then
 begin
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 hog:= Gear^.Hedgehog;
 DeleteGear(Gear);
 // <-- delete gear!
 if k = gtCase then
 begin
 doMakeExplosion(x, y, 25, hog, EXPLAutoSound);
 for i:= 0 to 63 do
 AddGear(x, y, gtFlame, 0, _0, _0, 0);
 end
 else if k = gtExplosives then
 begin
 doMakeExplosion(x, y, 75, hog, EXPLAutoSound);
 for i:= 0 to 31 do
 begin
 dX := AngleCos(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, gstTmpFlag, -dX, -dY, 0);
 end
 end;
 exit
 end;
-if (Gear^.dY.QWordValue <> 0) or (TestCollisionYwithGear(Gear, 1) = 0) then
+if (Gear^.dY.QWordValue <> 0)
-begin
+or (TestCollisionYwithGear(Gear, 1) = 0) then
+begin
 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 (not Gear^.dY.isNegative) and (Gear^.dY > _0_001) then
-if (Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, -1) <> 0) then Gear^.dY := _0;
+SetAllHHToActive;
+if (Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, -1) <> 0) then
+Gear^.dY := _0;
 if (not Gear^.dY.isNegative) and (TestCollisionYwithGear(Gear, 1) <> 0) then
 begin
 if (Gear^.dY > _0_2) and (k = gtExplosives) then
 inc(Gear^.Damage, hwRound(Gear^.dY * _70));
 if Gear^.dY > _0_2 then
 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;
-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(Gear^.ImpactSound);
 end;
 //if Gear^.dY > - _0_001 then Gear^.dY:= _0
 CheckGearDrowning(Gear);
 end;
-if (Gear^.dY.QWordValue = 0) then AddGearCI(Gear)
+if (Gear^.dY.QWordValue = 0) then
-else if (Gear^.dY.QWordValue <> 0) then DeleteCI(Gear)
+AddGearCI(Gear)
+else if (Gear^.dY.QWordValue <> 0) then
+DeleteCI(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepTarget(Gear: PGear);
 if (Gear^.Tag = 0) and (Gear^.Timer < 1000) then
 inc(Gear^.Timer)
 else if Gear^.Tag = 1 then
 Gear^.Tag := 2
 else if Gear^.Tag = 2 then
 if Gear^.Timer > 0 then
 dec(Gear^.Timer)
 else
 begin
 DeleteGear(Gear);
 exit;
 end;
 doStepCase(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepIdle(Gear: PGear);
 begin
 AllInactive := false;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 begin
 DeleteGear(Gear);
 AfterAttack
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepShover(Gear: PGear);
 var
 begin
 sticky:= (Gear^.State and gsttmpFlag) <> 0;
 if not sticky then AllInactive := false;
 if TestCollisionYwithGear(Gear, 1) = 0 then
 begin
 AllInactive := false;
 if ((GameTicks mod 100) = 0) then
 begin
 vgt:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtFire, gstTmpFlag);
 end;
 if Gear^.dX.QWordValue > _0_01.QWordValue then
 Gear^.dX := Gear^.dX * _0_995;
 Gear^.dY := Gear^.dY + cGravity;
 // if sticky then Gear^.dY := Gear^.dY + cGravity;
-if Gear^.dY.QWordValue > _0_2.QWordValue then Gear^.dY := Gear^.dY * _0_995;
+if Gear^.dY.QWordValue > _0_2.QWordValue then
+Gear^.dY := Gear^.dY * _0_995;
 //if sticky then Gear^.X := Gear^.X + Gear^.dX else
 Gear^.X := Gear^.X + Gear^.dX + cWindSpeed * 640;
 Gear^.Y := Gear^.Y + Gear^.dY;
 if (hwRound(Gear^.Y) > cWaterLine) then
 begin
 gX := hwRound(Gear^.X);
 for i:= 0 to 3 do
 AddVisualGear(gX - 16 + Random(32), cWaterLine - 16 + Random(16), vgtSteam);
 PlaySound(sndVaporize);
 DeleteGear(Gear);
 exit
+end
 end
-end
 else
 begin
 if sticky then
 begin
 Gear^.Radius := 7;
 tdX:= Gear^.dX;
 tdY:= Gear^.dY;
 begin
 dec(Gear^.Timer);
 inc(Gear^.Damage)
 end
 else
 begin
 gX := hwRound(Gear^.X);
 gY := hwRound(Gear^.Y);
 // Standard fire
 if not sticky then
 begin
 AmmoShove(Gear, 6, 100);
 Gear^.dX:= tdX;
 Gear^.dY:= tdY;
 Gear^.Radius := 1;
 end
-else if ((GameTicks and $3) = 3) then doMakeExplosion(gX, gY, 8, Gear^.Hedgehog, 0);//, EXPLNoDamage);
+else if ((GameTicks and $3) = 3) then
+doMakeExplosion(gX, gY, 8, Gear^.Hedgehog, 0);//, EXPLNoDamage);
 //DrawExplosion(gX, gY, 4);
 if ((GameTicks and $7) = 0) and (Random(2) = 0) then
 for i:= 1 to Random(2)+1 do
 AddVisualGear(gX - 3 + Random(6), gY - 2, vgtSmoke);
-if Gear^.Health > 0 then dec(Gear^.Health);
+if Gear^.Health > 0 then
+dec(Gear^.Health);
 Gear^.Timer := 450 - Gear^.Tag * 8
 end
 else
 begin
 // Modified fire
 AddVisualGear(gX - 3 + Random(6), gY - 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;
-if (Gear^.Damage > 3000+Gear^.Tag*1500) then Gear^.Health := 0
+if (Gear^.Damage > 3000+Gear^.Tag*1500) then
+Gear^.Health := 0
+end
 end
-end
+end;
-end;
 if Gear^.Health = 0 then
 begin
 gX := hwRound(Gear^.X);
 gY := hwRound(Gear^.Y);
 if not sticky then
 begin
 if ((GameTicks and $3) = 0) and (Random(1) = 0) then
 begin
 for i:= 1 to Random(2)+1 do
 begin
 AddVisualGear(gX - 3 + Random(6), gY - 2, vgtSmoke);
+end;
 end;
-end;
+end
-end
 else
 begin
 for i:= 0 to Random(3) do
 begin
 AddVisualGear(gX - 3 + Random(6), gY - 2, vgtSmoke);
 end;
 end;
 DeleteGear(Gear)
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFirePunchWork(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 if ((Gear^.Message and gmDestroy) <> 0) then
 begin
 DeleteGear(Gear);
 AfterAttack;
 exit
 end;
 HHGear := Gear^.Hedgehog^.Gear;
 if hwRound(HHGear^.Y) <= Gear^.Tag - 2 then
 begin
 Gear^.Tag := hwRound(HHGear^.Y);
 DrawTunnel(HHGear^.X - int2hwFloat(cHHRadius), HHGear^.Y - _1, _0_5, _0, cHHRadius * 4, 2);
 HHGear^.State := HHGear^.State or gstNoDamage;
 Gear^.Y := HHGear^.Y;
 AmmoShove(Gear, 30, 40);
 HHGear^.State := HHGear^.State and (not gstNoDamage)
 end;
 HHGear^.dY := HHGear^.dY + cGravity;
 if not (HHGear^.dY.isNegative) then
 begin
 HHGear^.State := HHGear^.State or gstMoving;
 DeleteGear(Gear);
 AfterAttack;
 exit
 end;
 if CheckLandValue(hwRound(HHGear^.X), hwRound(HHGear^.Y + HHGear^.dY + SignAs(_6,Gear^.dY)),
 lfIndestructible) then
 HHGear^.Y := HHGear^.Y + HHGear^.dY
 end;
 procedure doStepFirePunch(Gear: PGear);
 var
 HHGear: PGear;
 HHGear := Gear^.Hedgehog^.Gear;
 inc(Gear^.Timer);
 if (TestCollisionYwithGear(HHGear, 1) <> 0)
 or ((HHGear^.State and gstHHDriven) = 0)
 or CheckGearDrowning(HHGear)
 or ((Gear^.Message and gmAttack) <> 0) then
 begin
 with HHGear^ do
 begin
 Message := 0;
 SetLittle(dX);
 dY := _0;
 State := State or gstMoving;
 end;
 DeleteGear(Gear);
 isCursorVisible := false;
 ApplyAmmoChanges(HHGear^.Hedgehog^);
 exit
 end;
 HHGear^.X := HHGear^.X + cWindSpeed * 200;
-if (Gear^.Message and gmLeft) <> 0 then HHGear^.X := HHGear^.X - cMaxWindSpeed * 80
+if (Gear^.Message and gmLeft) <> 0 then
-else if (Gear^.Message and gmRight) <> 0 then HHGear^.X := HHGear^.X + cMaxWindSpeed * 80;
+HHGear^.X := HHGear^.X - cMaxWindSpeed * 80
-if (Gear^.Message and gmUp) <> 0 then HHGear^.Y := HHGear^.Y - cGravity * 40
-else if (Gear^.Message and gmDown) <> 0 then HHGear^.Y := HHGear^.Y + cGravity * 40;
+else if (Gear^.Message and gmRight) <> 0 then
+HHGear^.X := HHGear^.X + cMaxWindSpeed * 80;
+if (Gear^.Message and gmUp) <> 0 then
+HHGear^.Y := HHGear^.Y - cGravity * 40
+else if (Gear^.Message and gmDown) <> 0 then
+HHGear^.Y := HHGear^.Y + cGravity * 40;
 // don't drift into obstacles
 if TestCollisionXwithGear(HHGear, hwSign(HHGear^.dX)) then
 HHGear^.X := HHGear^.X - int2hwFloat(hwSign(HHGear^.dX));
 HHGear^.Y := HHGear^.Y + cGravity * 100;
 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
 dec(Gear^.Health);
 case Gear^.State of
-0: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, cBombsSpeed *
+0: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, cBombsSpeed * Gear^.Tag, _0, 0);
-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 *
+2: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtNapalmBomb, 0, cBombsSpeed * Gear^.Tag, _0, 0);
-Gear^.Tag, _0, 0);
+3: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtDrill, gsttmpFlag, cBombsSpeed * Gear^.Tag, _0, Gear^.Timer + 1);
-2: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtNapalmBomb, 0, cBombsSpeed *
-Gear^.Tag, _0, 0);
-3: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtDrill, gsttmpFlag, cBombsSpeed *
-Gear^.Tag, _0, Gear^.Timer + 1);
 //4: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtWaterMelon, 0, cBombsSpeed *
 //                 Gear^.Tag, _0, 5000);
 end;
 Gear^.dX := Gear^.dX + int2hwFloat(30 * Gear^.Tag);
 StopSound(Gear^.SoundChannel, 4000);
 if (GameTicks and $3F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace);
 if (hwRound(Gear^.X) > (LAND_WIDTH+2048)) or (hwRound(Gear^.X) < -2048) then
 begin
 // avoid to play forever (is this necessary?)
 StopSound(Gear^.SoundChannel);
 DeleteGear(Gear)
 end;
 end;
 procedure doStepAirAttack(Gear: PGear);
 begin
 AllInactive := false;
 if Gear^.X.QWordValue = 0 then
 begin
 Gear^.Tag :=  1;
 Gear^.X := -_2048;
 end
 else
 begin
 Gear^.Tag := -1;
 Gear^.X := int2hwFloat(LAND_WIDTH + 2048);
 end;
 Gear^.Y := int2hwFloat(topY-300);
 Gear^.dX := int2hwFloat(Gear^.Target.X - 5 * Gear^.Tag * 15);
 // calcs for Napalm Strike, so that it will hit the target (without wind at least :P)
 procedure doStepAirBomb(Gear: PGear);
 begin
 AllInactive := false;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 performRumble();
 exit
 end;
 if (GameTicks and $3F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 tx := int2hwFloat(Gear^.Target.X);
 ty := int2hwFloat(Gear^.Target.Y);
 x := HHGear^.X;
 y := HHGear^.Y;
-if (Distance(tx - x, ty - y) > _256) or
+if (Distance(tx - x, ty - y) > _256)
-(not TryPlaceOnLand(Gear^.Target.X - SpritesData[sprAmGirder].Width div 2,
+or (not TryPlaceOnLand(Gear^.Target.X - SpritesData[sprAmGirder].Width div 2, Gear^.Target.Y - SpritesData[sprAmGirder].Height div 2, sprAmGirder, Gear^.State, true, false)) then
-Gear^.Target.Y - SpritesData[sprAmGirder].Height div 2,
+begin
-sprAmGirder, Gear^.State, true, false)) then
-begin
 PlaySound(sndDenied);
 HHGear^.Message := HHGear^.Message and (not gmAttack);
 HHGear^.State := HHGear^.State and (not gstAttacking);
 HHGear^.State := HHGear^.State or gstHHChooseTarget;
 isCursorVisible := true;
 DeleteGear(Gear)
 end
 else
 begin
 PlaySound(sndPlaced);
 DeleteGear(Gear);
 AfterAttack;
 end;
 HHGear^.State := HHGear^.State and (not (gstAttacking or gstAttacked));
 HHGear^.Message := HHGear^.Message and (not gmAttack);
 end;
 HHGear^.Y := HHGear^.Y + HHGear^.dY;
 HHGear^.X := HHGear^.X + HHGear^.dX;
 // hedgehog falling to collect cases
 HHGear^.dY := HHGear^.dY + cGravity;
 if (TestCollisionYwithGear(HHGear, 1) <> 0)
 or CheckGearDrowning(HHGear) then
 begin
 DeleteGear(Gear);
 AfterAttack
 end
 end;
 procedure doStepTeleportAnim(Gear: PGear);
 begin
 inc(Gear^.Timer);
 if Gear^.Timer = 65 then
 begin
 Gear^.Timer := 0;
 inc(Gear^.Pos);
 if Gear^.Pos = 11 then
 Gear^.doStep := @doStepTeleportAfter
 end;
 end;
 procedure doStepTeleport(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 if not TryPlaceOnLand(Gear^.Target.X - SpritesData[sprHHTelepMask].Width div 2,
 Gear^.Target.Y - SpritesData[sprHHTelepMask].Height div 2,
 sprHHTelepMask, 0, false, false) then
 begin
 HHGear^.Message := HHGear^.Message and (not gmAttack);
 HHGear^.State := HHGear^.State and (not gstAttacking);
 HHGear^.State := HHGear^.State or gstHHChooseTarget;
 DeleteGear(Gear);
 isCursorVisible := true;
 PlaySound(sndDenied)
 end
 else
 begin
 DeleteCI(HHGear);
 SetAllHHToActive;
 Gear^.doStep := @doStepTeleportAnim;
 // copy old HH position and direction to Gear (because we need them for drawing the vanishing hog)
 Gear^.Y := HHGear^.Y;
 HHGear^.X := int2hwFloat(Gear^.Target.X);
 HHGear^.Y := int2hwFloat(Gear^.Target.Y);
 HHGear^.State := HHGear^.State or gstMoving;
 playSound(sndWarp)
 end;
 Gear^.Target.X:= NoPointX
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSwitcherWork(Gear: PGear);
 Msg, State: Longword;
 begin
 AllInactive := false;
 if ((Gear^.Message and (not gmSwitch)) <> 0) or (TurnTimeLeft = 0) then
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 //Msg := Gear^.Message and (not gmSwitch);
 DeleteGear(Gear);
 ApplyAmmoChanges(HHGear^.Hedgehog^);
 HHGear := CurrentHedgehog^.Gear;
 ApplyAmmoChanges(HHGear^.Hedgehog^);
 //HHGear^.Message := Msg;
 exit
 end;
 if (Gear^.Message and gmSwitch) <> 0 then
 begin
 HHGear := CurrentHedgehog^.Gear;
 HHGear^.Message := HHGear^.Message and (not gmSwitch);
 Gear^.Message := Gear^.Message and (not gmSwitch);
 State := HHGear^.State;
 HHGear^.State := 0;
 InsertGearToList(HHGear);
 PlaySound(sndSwitchHog);
 repeat
-CurrentTeam^.CurrHedgehog := Succ(CurrentTeam^.CurrHedgehog) mod (CurrentTeam^.
+CurrentTeam^.CurrHedgehog := Succ(CurrentTeam^.CurrHedgehog) mod (CurrentTeam^.HedgehogsNumber);
-HedgehogsNumber);
 until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil) and (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear^.Damage = 0);
 CurrentHedgehog := @CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog];
 HHGear := CurrentHedgehog^.Gear;
 HHGear^.Z := cCurrHHZ;
 RemoveGearFromList(HHGear);
 InsertGearToList(HHGear);
 Gear^.X := HHGear^.X;
 Gear^.Y := HHGear^.Y
 end;
 end;
 procedure doStepSwitcher(Gear: PGear);
 var
 HHGear: PGear;
 Gear^.doStep := @doStepSwitcherWork;
 HHGear := Gear^.Hedgehog^.Gear;
 OnUsedAmmo(HHGear^.Hedgehog^);
 with HHGear^ do
 begin
 State := State and (not gstAttacking);
 Message := Message and (not gmAttack)
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMortar(Gear: PGear);
 var
 dxn := Gear^.dX.isNegative;
 dyn := Gear^.dY.isNegative;
 doStepFallingGear(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, Gear^.Hedgehog, EXPLAutoSound);
 Gear^.dX.isNegative := not dxn;
 Gear^.dY.isNegative := not dyn;
 for i:= 0 to 4 do
 begin
 dX := Gear^.dX + (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);
 end;
 DeleteGear(Gear);
 exit
 end;
 if (GameTicks and $3F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace)
 end;
 sparkles: PVisualGear;
 hasWishes: boolean;
 begin
 AllInactive := false;
 hasWishes:= ((Gear^.Message and (gmPrecise or gmSwitch)) = (gmPrecise or gmSwitch));
-if hasWishes then Gear^.AdvBounce:= 1;
+if hasWishes then
+Gear^.AdvBounce:= 1;
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.State := HHGear^.State or gstNoDamage;
 DeleteCI(HHGear);
 //  if TestCollisionXwithGear(HHGear, hwSign(Gear^.dX))
 //      or TestCollisionYwithGear(HHGear, hwSign(Gear^.dY)) then inc(Gear^.Damage, 3);
 dec(i)
-until (i = 0) or (Gear^.Damage > Gear^.Health);
+until (i = 0)
+or (Gear^.Damage > Gear^.Health);
 inc(upd);
 if upd > 3 then
 begin
 if Gear^.Health < 1500 then
 begin
 if Gear^.AdvBounce <> 0 then
 Gear^.Pos := 3
 else
 Gear^.Pos := 2;
 end;
 AmmoShove(Gear, 30, 40);
 DrawTunnel(HHGear^.X - HHGear^.dX * 10,
 HHGear^.Y - _2 - HHGear^.dY * 10 + hwAbs(HHGear^.dY) * 2,
 HHGear^.dX,
 HHGear^.dY,
 20 + cHHRadius * 2,
 cHHRadius * 2 + 7);
 upd := 0
 end;
 if Gear^.Health < Gear^.Damage then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound);
 if hasWishes then
 for i:= 0 to 31 do
 begin
 sparkles:= AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtStraightShot);
 begin
 Tint:= ((random(210)+45) shl 24) or ((random(210)+45) shl 16) or ((random(210)+45) shl 8) or $FF;
 Angle:= random * 360;
 dx:= 0.001 * (random(200));
 dy:= 0.001 * (random(200));
-if random(2) = 0 then dx := -dx;
+if random(2) = 0 then
-if random(2) = 0 then dy := -dy;
+dx := -dx;
+if random(2) = 0 then
+dy := -dy;
 FrameTicks:= random(400) + 250
 end
 end;
 AfterAttack;
 DeleteGear(Gear);
 DeleteGear(HHGear);
 end
 else
 begin
 dec(Gear^.Health, Gear^.Damage);
 Gear^.Damage := 0
 end
 end;
 procedure doStepKamikazeIdle(Gear: PGear);
 begin
 AllInactive := false;
 procedure doStepCakeExpl(Gear: PGear);
 begin
 AllInactive := false;
 inc(Gear^.Tag);
-if Gear^.Tag < 2250 then exit;
+if Gear^.Tag < 2250 then
+exit;
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), cakeDmg, Gear^.Hedgehog, EXPLAutoSound);
 AfterAttack;
 DeleteGear(Gear)
 end;
 dmg: LongInt;
 begin
 AllInactive := false;
 inc(Gear^.Tag);
-if Gear^.Tag < 100 then exit;
+if Gear^.Tag < 100 then
+exit;
 Gear^.Tag := 0;
 if Gear^.Pos = 0 then
 begin
 gi := GearsList;
 while gi <> nil do
 begin
 dmg := cakeDmg * 2 - hwRound(Distance(gi^.X - Gear^.X, gi^.Y - Gear^.Y));
 if (dmg > 1) and (gi^.Kind = gtHedgehog) then
 if (CurrentHedgehog^.Gear = gi) and (not gi^.Invulnerable) then
 gi^.State := gi^.State or gstLoser
 else
 gi^.State := gi^.State or gstWinner;
 gi := gi^.NextGear
 end;
 Gear^.doStep := @doStepCakeExpl;
 PlaySound(sndCake)
 end
 else dec(Gear^.Pos)
 end;
 procedure PrevAngle(Gear: PGear; dA: LongInt);
 tdx, tdy: hwFloat;
 begin
 AllInactive := false;
 inc(Gear^.Tag);
-if Gear^.Tag < 7 then exit;
+if Gear^.Tag < 7 then
+exit;
 dA := hwSign(Gear^.dX);
 xx := dirs[Gear^.Angle].x;
 yy := dirs[Gear^.Angle].y;
 xxn := dirs[(LongInt(Gear^.Angle) + 4 + dA) mod 4].x;
 if (xx = 0) then
 if TestCollisionYwithGear(Gear, yy) <> 0 then
 PrevAngle(Gear, dA)
 else
 begin
 Gear^.Tag := 0;
 Gear^.Y := Gear^.Y + int2hwFloat(yy);
 if not TestCollisionXwithGear(Gear, xxn) then
 begin
 Gear^.X := Gear^.X + int2hwFloat(xxn);
 NextAngle(Gear, dA)
 end;
 end;
 if (yy = 0) then
 if TestCollisionXwithGear(Gear, xx) then
 PrevAngle(Gear, dA)
 else
 begin
 Gear^.Tag := 0;
 Gear^.X := Gear^.X + int2hwFloat(xx);
 if not TestCollisionY(Gear, yyn) then
 begin
 Gear^.Y := Gear^.Y + int2hwFloat(yyn);
 NextAngle(Gear, dA)
 end;
 end;
 if Gear^.Tag = 0 then
 begin
 CakeI := (CakeI + 1) mod cakeh;
 tdx := CakePoints[CakeI].x - Gear^.X;
 tdy := - CakePoints[CakeI].y + Gear^.Y;
 CakePoints[CakeI].x := Gear^.X;
 CakePoints[CakeI].y := Gear^.Y;
 Gear^.DirAngle := DxDy2Angle(tdx, tdy);
 end;
 dec(Gear^.Health);
 Gear^.Timer := Gear^.Health*10;
-if Gear^.Health mod 100 = 0 then Gear^.PortalCounter:= 0;
+if Gear^.Health mod 100 = 0 then
+Gear^.PortalCounter:= 0;
 // This is not seconds, but at least it is *some* feedback
 if (Gear^.Health = 0) or ((Gear^.Message and gmAttack) <> 0) then
 begin
 FollowGear := Gear;
 Gear^.RenderTimer := false;
 Gear^.doStep := @doStepCakeDown
 end
 end;
 procedure doStepCakeUp(Gear: PGear);
 var
 i: Longword;
 begin
 AllInactive := false;
 inc(Gear^.Tag);
-if Gear^.Tag < 100 then exit;
+if Gear^.Tag < 100 then
+exit;
 Gear^.Tag := 0;
 if Gear^.Pos = 6 then
 begin
 for i:= 0 to Pred(cakeh) do
 begin
 CakePoints[i].x := Gear^.X;
 CakePoints[i].y := Gear^.Y
 end;
 CakeI := 0;
 Gear^.doStep := @doStepCakeWork
 end
-else inc(Gear^.Pos)
+else
+inc(Gear^.Pos)
 end;
 procedure doStepCakeFall(Gear: PGear);
 begin
 AllInactive := false;
 Gear^.dY := Gear^.dY + cGravity;
-if TestCollisionYwithGear(Gear, 1) <> 0 then Gear^.doStep := @doStepCakeUp
+if TestCollisionYwithGear(Gear, 1) <> 0 then
+Gear^.doStep := @doStepCakeUp
 else
 begin
 Gear^.Y := Gear^.Y + Gear^.dY;
-if CheckGearDrowning(Gear) then AfterAttack
+if CheckGearDrowning(Gear) then
+AfterAttack
 end
 end;
 procedure doStepCake(Gear: PGear);
 var
 if heart <> nil then
 with heart^ do
 begin
 dx:= 0.001 * (random(200));
 dy:= 0.001 * (random(200));
-if random(2) = 0 then dx := -dx;
+if random(2) = 0 then
-if random(2) = 0 then dy := -dy;
+dx := -dx;
+if random(2) = 0 then
+dy := -dy;
 FrameTicks:= random(750) + 1000;
 State:= ord(sprSeduction)
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepWaterUp(Gear: PGear);
 var
 i: LongWord;
 begin
-if (Gear^.Tag = 0) or (cWaterLine = 0) then
+if (Gear^.Tag = 0)
-begin
+or (cWaterLine = 0) then
-DeleteGear(Gear);
+begin
-exit
+DeleteGear(Gear);
+exit
 end;
 AllInactive := false;
 inc(Gear^.Timer);
 Gear^.Timer := 0
 else
 exit;
 if cWaterLine > 0 then
 begin
 dec(cWaterLine);
 for i:= 0 to LAND_WIDTH - 1 do
 Land[cWaterLine, i] := 0;
 SetAllToActive
 end;
 dec(Gear^.Tag);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 Gear^.Y := Gear^.Y + Gear^.dY;
 DrawTunnel(oX, oY, Gear^.dX, Gear^.dY, 2, 6);
 if (Gear^.Timer mod 30) = 0 then
 AddVisualGear(hwRound(Gear^.X + _20 * Gear^.dX), hwRound(Gear^.Y + _20 * Gear^.dY), vgtDust);
 if (CheckGearDrowning(Gear)) then
 begin
 StopSound(Gear^.SoundChannel);
 exit
 end
 end;
-if GameTicks > Gear^.FlightTime then t := CheckGearsCollision(Gear)
+if GameTicks > Gear^.FlightTime then
+t := CheckGearsCollision(Gear)
 else t := nil;
 //fixes drill not exploding when touching HH bug
-if (Gear^.Timer = 0) or ((t <> nil) and (t^.Count <> 0)) or
-( ((Gear^.State and gsttmpFlag) = 0) and
+if (Gear^.Timer = 0) or ((t <> nil) and (t^.Count <> 0))
-(TestCollisionYWithGear(Gear, hwSign(Gear^.dY)) = 0)
+or ( ((Gear^.State and gsttmpFlag) = 0) and (TestCollisionYWithGear(Gear, hwSign(Gear^.dY)) = 0) and (not TestCollisionXWithGear(Gear, hwSign(Gear^.dX))))
-and (not TestCollisionXWithGear(Gear, hwSign(Gear^.dX))))
 // CheckLandValue returns true if the type isn't matched
 or (not CheckLandValue(hwRound(Gear^.X), hwRound(Gear^.Y), lfIndestructible)) then
 begin
 //out of time or exited ground
 StopSound(Gear^.SoundChannel);
 if (Gear^.State and gsttmpFlag) <> 0 then
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound)
 else
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 exit
 end
 else if (TestCollisionYWithGear(Gear, hwSign(Gear^.dY)) = 0) and (not TestCollisionXWithGear(Gear, hwSign(Gear^.dX))) then
 begin
 StopSound(Gear^.SoundChannel);
 Gear^.Tag := 1;
 Gear^.doStep := @doStepDrill
 if (GameTicks and $3F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace);
 if ((Gear^.State and gstCollision) <> 0) then
 begin
 //hit
 Gear^.dX := oldDx;
 Gear^.dY := oldDy;
-if GameTicks > Gear^.FlightTime then t := CheckGearsCollision(Gear)
+if GameTicks > Gear^.FlightTime then
-else t := nil;
+t := CheckGearsCollision(Gear)
+else
+t := nil;
 if (t = nil) or (t^.Count = 0) then
 begin
 //hit the ground not the HH
 t2 := _0_5 / Distance(Gear^.dX, Gear^.dY);
 Gear^.dX := Gear^.dX * t2;
 Gear^.dY := Gear^.dY * t2;
 end
 else if (t <> nil) then
 begin
 //explode right on contact with HH
 if (Gear^.State and gsttmpFlag) <> 0 then
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound)
 exit;
 end;
 Gear^.SoundChannel := LoopSound(sndDrillRocket);
 Gear^.doStep := @doStepDrillDrilling;
 if (Gear^.State and gsttmpFlag) <> 0 then
 gear^.RenderTimer:= true;
 dec(Gear^.Timer)
 end
-else if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Tag <> 0) then
-begin
+else if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Tag <> 0) then
+begin
 if Gear^.Timer = 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 end
 else
 dec(Gear^.Timer);
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBallgunWork(Gear: PGear);
 var
 HHGear := Gear^.Hedgehog^.Gear;
 HedgehogChAngle(HHGear);
 gX := hwRound(Gear^.X) + GetLaunchX(amBallgun, hwSign(HHGear^.dX), HHGear^.Angle);
 gY := hwRound(Gear^.Y) + GetLaunchY(amBallgun, HHGear^.Angle);
 if (Gear^.Timer mod 100) = 0 then
 begin
 rx := rndSign(getRandom * _0_1);
 ry := rndSign(getRandom * _0_1);
-AddGear(gx, gy, gtBall, 0,
+AddGear(gx, gy, gtBall, 0, SignAs(AngleSin(HHGear^.Angle) * _0_8, HHGear^.dX) + rx, AngleCos(HHGear^.Angle) * ( - _0_8) + ry, 0);
-SignAs(AngleSin(HHGear^.Angle) * _0_8, HHGear^.dX) + rx,
-AngleCos(HHGear^.Angle) * ( - _0_8) + ry,
-0);
 PlaySound(sndGun);
 end;
 if (Gear^.Timer = 0) or (HHGear^.Damage <> 0) then
 begin
 DeleteGear(Gear);
 AfterAttack
 end
 end;
 procedure doStepBallgun(Gear: PGear);
 var
 HHGear: PGear;
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 FollowGear := Gear;
-if Gear^.Timer > 0 then dec(Gear^.Timer);
+if Gear^.Timer > 0 then
+dec(Gear^.Timer);
 fChanged := false;
 if ((HHGear^.State and gstHHDriven) = 0) or (Gear^.Timer = 0) then
 begin
 fChanged := true;
-if Gear^.Angle > 2048 then dec(Gear^.Angle)
+if Gear^.Angle > 2048 then
+dec(Gear^.Angle)
 else
-if Gear^.Angle < 2048 then inc(Gear^.Angle)
+if Gear^.Angle < 2048 then
-else fChanged := false
+inc(Gear^.Angle)
+else
+fChanged := false
 end
 else
 begin
 if ((Gear^.Message and gmLeft) <> 0) then
 begin
 fChanged := true;
 Gear^.Angle := (Gear^.Angle + (4096 - cAngleSpeed)) mod 4096
 end;
 if ((Gear^.Message and gmRight) <> 0) then
 begin
 fChanged := true;
 Gear^.Angle := (Gear^.Angle + cAngleSpeed) mod 4096
 end
 end;
 if fChanged then
 begin
 Gear^.dX.isNegative := (Gear^.Angle > 2048);
 if Gear^.dX.isNegative then
 trueAngle := 4096 - Gear^.Angle
 else
 trueAngle := Gear^.Angle;
 Gear^.dX := SignAs(AngleSin(trueAngle), Gear^.dX) * _0_25;
 Gear^.dY := AngleCos(trueAngle) * -_0_25;
 end;
 Gear^.X := Gear^.X + Gear^.dX;
 Gear^.Y := Gear^.Y + Gear^.dY;
 if (GameTicks and $FF) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtEvilTrace)
 else
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace);
 if ((HHGear^.Message and gmAttack) <> 0) and (Gear^.Health <> 0) then
 begin
 HHGear^.Message := HHGear^.Message and (not gmAttack);
 AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtAirBomb, 0, Gear^.dX * _0_5, Gear^.dY *
 _0_5, 0);
 dec(Gear^.Health)
 end;
-if ((HHGear^.Message and gmLJump) <> 0)
+if ((HHGear^.Message and gmLJump) <> 0) and ((Gear^.State and gsttmpFlag) = 0) then
-and ((Gear^.State and gsttmpFlag) = 0) then
+begin
-begin
 Gear^.State := Gear^.State or gsttmpFlag;
 PauseMusic;
 playSound(sndRideOfTheValkyries);
 end;
 // pickup bonuses
 t := CheckGearNear(Gear, gtCase, 36, 36);
 if t <> nil then
 PickUp(HHGear, t);
 CheckCollision(Gear);
 if ((Gear^.State and gstCollision) <> 0) or CheckGearDrowning(Gear) then
 begin
 StopSound(Gear^.SoundChannel);
 StopSound(sndRideOfTheValkyries);
 ResumeMusic;
 if ((Gear^.State and gstCollision) <> 0) then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 25, Gear^.Hedgehog, EXPLAutoSound);
 for i:= 0 to 15 do
 begin
 dX := AngleCos(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);
 end;
 DeleteGear(Gear)
 end;
 AfterAttack;
 CurAmmoGear := nil;
 if (GameFlags and gfInfAttack) = 0 then
 begin
-if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft;
+if TagTurnTimeLeft = 0 then
+TagTurnTimeLeft:= TurnTimeLeft;
 TurnTimeLeft:= 14 * 125;
 end;
 HHGear^.Message := 0;
 ParseCommand('/taunt ' + #1, true)
 end
 end;
 procedure doStepRCPlane(Gear: PGear);
 var
 HHGear: PGear;
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.Message := 0;
 HHGear^.State := HHGear^.State or gstNotKickable;
 Gear^.Angle := HHGear^.Angle;
 Gear^.Tag := hwSign(HHGear^.dX);
-if HHGear^.dX.isNegative then Gear^.Angle := 4096 - Gear^.Angle;
+if HHGear^.dX.isNegative then
+Gear^.Angle := 4096 - Gear^.Angle;
 Gear^.doStep := @doStepRCPlaneWork
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepJetpackWork(Gear: PGear);
 move: hwFloat;
 isUnderwater: Boolean;
 bubble: PVisualGear;
 begin
 isUnderwater:= cWaterLine < hwRound(Gear^.Y) + Gear^.Radius;
-if Gear^.Pos > 0 then dec(Gear^.Pos);
+if Gear^.Pos > 0 then
+dec(Gear^.Pos);
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 //dec(Gear^.Timer);
 move := _0_2;
 fuel := 50;
 begin
 HHGear^.dY := HHGear^.dY - (move * _0_7);
 for i:= random(10)+10 downto 0 do
 begin
 bubble := AddVisualGear(hwRound(HHGear^.X) - 8 + random(16), hwRound(HHGear^.Y) + 16 + random(8), vgtBubble);
-if bubble <> nil then bubble^.dY:= random(20)/10+0.1;
+if bubble <> nil then
+bubble^.dY:= random(20)/10+0.1;
 end
 end
 else HHGear^.dY := HHGear^.dY - move;
 end;
 dec(Gear^.Health, fuel);
 begin
 Gear^.Timer := 0;
 Gear^.MsgParam := 0
 end;
-if Gear^.Health < 0 then Gear^.Health := 0;
+if Gear^.Health < 0 then
+Gear^.Health := 0;
 i:= Gear^.Health div 20;
 if (i <> Gear^.Damage) and ((GameTicks and $3F) = 0) then
 begin
 Gear^.Damage:= i;
 //AddCaption('Fuel: '+inttostr(round(Gear^.Health/20))+'%', cWhiteColor, capgrpAmmostate);
 FreeTexture(Gear^.Tex);
-Gear^.Tex := RenderStringTex(trmsg[sidFuel] + ': ' + inttostr(i) +
+Gear^.Tex := RenderStringTex(trmsg[sidFuel] + ': ' + inttostr(i) + '%', cWhiteColor, fntSmall)
-'%', cWhiteColor, fntSmall)
 end;
 if HHGear^.Message and (gmAttack or gmUp or gmPrecise or gmLeft or gmRight) <> 0 then
 Gear^.State := Gear^.State and (not gsttmpFlag);
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmPrecise or gmLeft or gmRight));
 HHGear^.State := HHGear^.State or gstMoving;
 Gear^.X := HHGear^.X;
 Gear^.Y := HHGear^.Y;
 // For some reason I need to reapply followgear here, something else grabs it otherwise.
 // This is probably not needed anymore
-if not CurrentTeam^.ExtDriven then FollowGear := HHGear;
+if not CurrentTeam^.ExtDriven then
+FollowGear := HHGear;
-if not isUnderWater and hasBorder and ((HHGear^.X < _0) or (hwRound(HHGear^.X) > LAND_WIDTH)) then HHGear^.dY.isNegative:= false;
-if ((Gear^.State and gsttmpFlag) = 0) or (HHGear^.dY < _0) then doStepHedgehogMoving(HHGear);
+if not isUnderWater and hasBorder and ((HHGear^.X < _0)
+or (hwRound(HHGear^.X) > LAND_WIDTH)) then
+HHGear^.dY.isNegative:= false;
+if ((Gear^.State and gsttmpFlag) = 0)
+or (HHGear^.dY < _0) then
+doStepHedgehogMoving(HHGear);
 if // (Gear^.Health = 0)
 (HHGear^.Damage <> 0)
 //or CheckGearDrowning(HHGear)
 or (cWaterLine + 512 < hwRound(HHGear^.Y))
 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) <> 0))
 or ((Gear^.Message and gmAttack) <> 0) then
 begin
 with HHGear^ do
 begin
 Message := 0;
 Active := true;
 State := State or gstMoving
 end;
 DeleteGear(Gear);
 isCursorVisible := false;
 ApplyAmmoChanges(HHGear^.Hedgehog^);
 //    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;
 procedure doStepJetpack(Gear: PGear);
 var
 HHGear: PGear;
 HHGear := Gear^.Hedgehog^.Gear;
 FollowGear := HHGear;
 AfterAttack;
 with HHGear^ do
 begin
 State := State and (not gstAttacking);
 Message := Message and (not (gmAttack or gmUp or gmPrecise or gmLeft or gmRight));
 if (dY < _0_1) and (dY > -_0_1) then
 begin
 Gear^.State := Gear^.State or gsttmpFlag;
 dY := dY - _0_2
+end
 end
-end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBirdyDisappear(Gear: PGear);
 begin
 AllInactive := false;
 Gear^.Pos := 0;
 if Gear^.Timer < 2000 then
 inc(Gear^.Timer, 1)
 else
 begin
 DeleteGear(Gear);
 end;
 end;
 procedure doStepBirdyFly(Gear: PGear);
 var
 HHGear: PGear;
 fuel := 50;
 if Gear^.Pos > 0 then
 dec(Gear^.Pos, 1)
 else if (HHGear^.Message and (gmLeft or gmRight or gmUp)) <> 0 then
 Gear^.Pos := 500;
 if HHGear^.dX.isNegative then
 Gear^.Tag := -1
 else
 Gear^.Tag := 1;
 if (HHGear^.Message and gmUp) <> 0 then
 begin
-if (not HHGear^.dY.isNegative) or (HHGear^.Y > -_256) then
+if (not HHGear^.dY.isNegative)
+or (HHGear^.Y > -_256) then
 HHGear^.dY := HHGear^.dY - move;
 dec(Gear^.Health, fuel);
 Gear^.MsgParam := Gear^.MsgParam or gmUp;
 end;
 if (HHGear^.Message and gmLeft) <> 0 then move.isNegative := true;
 if (HHGear^.Message and (gmLeft or gmRight)) <> 0 then
 begin
 HHGear^.dX := HHGear^.dX + (move * _0_1);
 dec(Gear^.Health, fuel div 5);
 Gear^.MsgParam := Gear^.MsgParam or (HHGear^.Message and (gmLeft or gmRight));
 end;
-if Gear^.Health < 0 then Gear^.Health := 0;
+if Gear^.Health < 0 then
+Gear^.Health := 0;
 if ((GameTicks and $FF) = 0) and (Gear^.Health < 500) then
 for i:= ((500-Gear^.Health) div 250) downto 0 do
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtFeather);
 if (HHGear^.Message and gmAttack <> 0) then
 end;
 end;
 if HHGear^.Message and (gmUp or gmPrecise or gmLeft or gmRight) <> 0 then
 Gear^.State := Gear^.State and (not gsttmpFlag);
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmPrecise or gmLeft or gmRight));
 HHGear^.State := HHGear^.State or gstMoving;
 Gear^.X := HHGear^.X;
 Gear^.Y := HHGear^.Y - int2hwFloat(32);
 // For some reason I need to reapply followgear here, something else grabs it otherwise.
 // this is probably not needed anymore
 if not CurrentTeam^.ExtDriven then FollowGear := HHGear;
-if ((Gear^.State and gsttmpFlag) = 0) or (HHGear^.dY < _0) then doStepHedgehogMoving(HHGear);
+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 (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) <> 0))
 or ((Gear^.Message and gmAttack) <> 0) then
 begin
 with HHGear^ do
 begin
 Message := 0;
 Active := true;
 State := State or gstMoving
 end;
 Gear^.State := Gear^.State or gstAnimation or gstTmpFlag;
 if HHGear^.dY < _0 then
 begin
 Gear^.dX := HHGear^.dX;
 Gear^.dY := HHGear^.dY;
 end;
 Gear^.Timer := 0;
 Gear^.doStep := @doStepBirdyDisappear;
 CurAmmoGear := nil;
 isCursorVisible := false;
 AfterAttack;
 end
 end;
 procedure doStepBirdyDescend(Gear: PGear);
 var
 HHGear: PGear;
 begin
 if Gear^.Timer > 0 then
 dec(Gear^.Timer, 1)
 else if Gear^.Hedgehog^.Gear = nil then
 begin
 DeleteGear(Gear);
 AfterAttack;
 exit
 end;
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmPrecise or gmLeft or gmRight));
 if abs(hwRound(HHGear^.Y - Gear^.Y)) > 32 then
 begin
 if Gear^.Timer = 0 then
 Gear^.Y := Gear^.Y + _0_1
 end
 else if Gear^.Timer = 0 then
 begin
 Gear^.doStep := @doStepBirdyFly;
 HHGear^.dY := -_0_2
 end
 end;
 procedure doStepBirdyAppear(Gear: PGear);
 begin
 Gear^.Pos := 0;
 if Gear^.Timer < 2000 then
 inc(Gear^.Timer, 1)
 else
 begin
 Gear^.Timer := 500;
 Gear^.dX := _0;
 Gear^.dY := _0;
 Gear^.State :=  Gear^.State and (not gstAnimation);
 Gear^.doStep := @doStepBirdyDescend;
 end
 end;
 procedure doStepBirdy(Gear: PGear);
 var
 HHGear: PGear;
 begin
 gear^.State :=  gear^.State or gstAnimation and (not gstTmpFlag);
 Gear^.doStep := @doStepBirdyAppear;
 if CurrentHedgehog = nil then
 begin
 DeleteGear(Gear);
 exit
 end;
 HHGear := CurrentHedgehog^.Gear;
 if HHGear^.dX.isNegative then
 Gear^.Tag := -1
 doStepFallingGear(Gear);
 //    CheckGearDrowning(Gear); // already checked for in doStepFallingGear
 CalcRotationDirAngle(Gear);
 if (Gear^.State and gstCollision) <> 0 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 10, Gear^.Hedgehog, EXPLPoisoned, $C0E0FFE0);
 PlaySound(sndEggBreak);
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtEgg);
 vg := AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtEgg);
-if vg <> nil then vg^.Frame := 2;
+if vg <> nil then
+vg^.Frame := 2;
 for i:= 10 downto 0 do
 begin
 vg := AddVisualGear(hwRound(Gear^.X) - 3 + Random(6), hwRound(Gear^.Y) - 3 + Random(6),
 vgtDust);
-if vg <> nil then vg^.dX := vg^.dX + (Gear^.dX.QWordValue / 21474836480);
+if vg <> nil then
-end;
+vg^.dX := vg^.dX + (Gear^.dX.QWordValue / 21474836480);
+end;
 DeleteGear(Gear);
 exit
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doPortalColorSwitch();
 var CurWeapon: PAmmo;
 begin
-if (CurrentHedgehog <> nil)
+if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and ((CurrentHedgehog^.Gear^.Message and gmSwitch) <> 0) then
-and (CurrentHedgehog^.Gear <> nil)
+with CurrentHedgehog^ do
-and ((CurrentHedgehog^.Gear^.Message and gmSwitch) <> 0) then
+if (CurAmmoType = amPortalGun) then
-with CurrentHedgehog^ do
+begin
-if (CurAmmoType = amPortalGun) then
+CurrentHedgehog^.Gear^.Message := CurrentHedgehog^.Gear^.Message and (not gmSwitch);
-begin
-CurrentHedgehog^.Gear^.Message := CurrentHedgehog^.Gear^.Message and (not gmSwitch);
 CurWeapon:= GetAmmoEntry(CurrentHedgehog^);
 if CurWeapon^.Pos <> 0 then
 CurWeapon^.Pos := 0
-else
+else
 CurWeapon^.Pos := 1;
 end;
 end;
 procedure doStepPortal(Gear: PGear);
 var
 iterator, conPortal: PGear;
 begin
 doPortalColorSwitch();
 // destroy portal if ground it was attached too is gone
 if ((Land[hwRound(Gear^.Y), hwRound(Gear^.X)] and $FF00) = 0)
 or (Gear^.Timer < 1)
 or (Gear^.Hedgehog^.Team <> CurrentHedgehog^.Team)
 or (hwRound(Gear^.Y) > cWaterLine) then
 begin
 deleteGear(Gear);
 EXIT;
 end;
 if (TurnTimeLeft < 1)
 or (Gear^.Health < 1) then
 dec(Gear^.Timer);
 if Gear^.Timer < 10000 then
 gear^.RenderTimer := true;
 if iterator = nil then
 break;
 // don't port portals or other gear that wouldn't make sense
 if (iterator^.Kind in [gtPortal, gtRope, gtRCPlane])
 or (iterator^.PortalCounter > 32) then
 continue;
 // don't port hogs on rope
 // TODO: this will also prevent hogs while falling after rope use from
 //       falling through portals... fix that!
 // this is the max range we accept incoming gears in
 r := Int2hwFloat(iterator^.Radius+Gear^.Radius);
 // too far away?
 if (iterator^.X < Gear^.X - r)
 or (iterator^.X > Gear^.X + r)
 or (iterator^.Y < Gear^.Y - r)
 or (iterator^.Y > Gear^.Y + r) then
 continue;
-hasdxy := (((iterator^.dX.QWordValue <> 0) or (iterator^.dY.QWordValue <> 0))
+hasdxy := (((iterator^.dX.QWordValue <> 0) or (iterator^.dY.QWordValue <> 0)) or ((iterator^.State or gstMoving) = 0));
-or ((iterator^.State or gstMoving) = 0));
 // in case the object is not moving, let's asume it's falling towards the portal
 if not hasdxy then
 begin
 if Gear^.Y < iterator^.Y then
 continue;
 ox:= Gear^.X - iterator^.X;
 oy:= Gear^.Y - iterator^.Y;
 end
 else
 begin
 ox:= iterator^.dX;
 oy:= iterator^.dY;
 end;
 // cake will need extra treatment... it's so delicious and moist!
 iscake:= (iterator^.Kind = gtCake);
 // won't port stuff that does not move towards the front/portal entrance
 if iscake then
 begin
 if not (((iterator^.X - Gear^.X)*ox + (iterator^.Y - Gear^.Y)*oy).isNegative) then
 continue;
 end
 else
 if not ((Gear^.dX*ox + Gear^.dY*oy).isNegative) then
 continue;
 isbullet:= (iterator^.Kind in [gtShotgunShot, gtDEagleShot, gtSniperRifleShot, gtSineGunShot]);
 r:= int2hwFloat(iterator^.Radius);
 if not (isbullet or iscake) then
 begin
 // wow! good candidate there, let's see if the distance and direction is okay!
 if hasdxy then
 begin
 s := r / Distance(iterator^.dX, iterator^.dY);
 ox:= iterator^.X + s * iterator^.dX;
 oy:= iterator^.Y + s * iterator^.dY;
 end
 else
 begin
 ox:= iterator^.X;
 oy:= iterator^.Y + r;
 end;
 if (hwRound(Distance(Gear^.X-ox,Gear^.Y-oy)) > Gear^.Radius + 1 ) then
 continue;
 end;
 // draw bullet trail
 if isbullet then
 spawnBulletTrail(iterator);
 if isBullet and (hwRound(hwAbs(noffs)) >= Gear^.Radius) then
 continue;
 // avoid gravity related loops of not really moving gear
-if not (iscake or isbullet) and (Gear^.dY.isNegative) and (conPortal^.dY.isNegative)
+if not (iscake or isbullet)
-and ((iterator^.dX.QWordValue + iterator^.dY.QWordValue) < _0_08.QWordValue)
+and (Gear^.dY.isNegative)
-and (iterator^.PortalCounter > 0) then
+and (conPortal^.dY.isNegative)
-continue;
+and ((iterator^.dX.QWordValue + iterator^.dY.QWordValue) < _0_08.QWordValue)
+and (iterator^.PortalCounter > 0) then
+continue;
 // calc gear speed along to the vector and the normal vector of the portal
 if hasdxy then
 begin
 pspeed:= (Gear^.dX * iterator^.dX + Gear^.dY * iterator^.dY);
 nspeed:= (nx * iterator^.dX + ny * iterator^.dY);
 end
 else
 begin
 pspeed:= hwAbs(cGravity * oy);
 nspeed:= _0;
 end;
 // creating normal vector of connected (exit) portal
 nx := conPortal^.dY;
 ny := conPortal^.dX;
 if conPortal^.Elasticity.isNegative then
 iterator^.dY := -pspeed * conPortal^.dY + nspeed * ny;
 // make the gear's exit position close to the portal while
 // still respecting the movement direction
 // determine the distance (in exit vector direction)
 // that we want the gear at
 if iscake then
 ox:= (r - _0_7)
 else
 ox:= (r * _1_5);
 s:= ox / poffs;
 poffs:= ox;
-if (nspeed.QWordValue <> 0) and (pspeed > _0) then
+if (nspeed.QWordValue <> 0)
-noffs:= noffs * s * (nspeed / pspeed);
+and (pspeed > _0) then
+noffs:= noffs * s * (nspeed / pspeed);
 // move stuff with high normal offset closer to the portal's center
 if not isbullet then
 begin
 s := hwAbs(noffs) + r - int2hwFloat(Gear^.Radius);
 if s > _0 then
 noffs:= noffs - SignAs(s,noffs)
 end;
 iterator^.X := conPortal^.X + poffs * conPortal^.dX + noffs * nx;
 iterator^.Y := conPortal^.Y + poffs * conPortal^.dY + noffs * ny;
 if not hasdxy and (not (conPortal^.dY.isNegative)) then
 begin
 iterator^.dY:= iterator^.dY + hwAbs(cGravity * (iterator^.Y - conPortal^.Y))
 end;
 // see if the space on the exit side actually is enough
 if not (isBullet or isCake) then
 begin
 // TestCollisionXwithXYShift requires a hwFloat for xShift
 ox.QWordValue := _1.QWordValue;
 ox.isNegative := not iterator^.dX.isNegative;
 sx := hwSign(iterator^.dX);
 // check front
 isCollision := TestCollisionY(iterator, sy)
 or TestCollisionX(iterator, sx);
 if not isCollision then
 begin
 // check center area (with half the radius so that the
 // the square check won't check more pixels than we want to)
 iterator^.Radius := 1 + resetr div 2;
 rh := resetr div 4;
 isCollision := TestCollisionYwithXYShift(iterator,       0, -sy * rh, sy, false)
 or TestCollisionXwithXYShift(iterator, ox * rh,        0, sx, false);
 end;
 iterator^.Radius := resetr;
 if isCollision then
 begin
 // collision! oh crap! go back!
 iterator^.X  := resetx;
 iterator^.Y  := resety;
 iterator^.dX := resetdx;
 iterator^.dY := resetdy;
 continue;
 end;
 end;
 //
 // You're now officially portaled!
 //
 // Until loops are reliably broken
-if iscake then iterator^.PortalCounter:= 33
+if iscake then
+iterator^.PortalCounter:= 33
 else
 begin
 inc(iterator^.PortalCounter);
 iterator^.State:= iterator^.State and (not gstHHHJump)
 end;
 if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil)
-and (iterator = CurrentHedgehog^.Gear) and (CurAmmoGear <> nil) and (CurAmmoGear^.Kind =
+and (iterator = CurrentHedgehog^.Gear)
-gtRope) then CurAmmoGear^.PortalCounter:= 1;
+and (CurAmmoGear <> nil)
+and (CurAmmoGear^.Kind =gtRope) then
-if not isbullet and (iterator^.Kind <> gtFlake) then
+CurAmmoGear^.PortalCounter:= 1;
+if not isbullet
+and (iterator^.Kind <> gtFlake) then
 FollowGear := iterator;
 // store X/Y values of exit for net bullet trail
 if isbullet then
 begin
 iterator^.Elasticity:= iterator^.X;
 iterator^.Friction  := iterator^.Y;
 end;
 // This jiggles gears, to ensure a portal connection just placed under a gear takes effect.
 iterator:= GearsList;
 while iterator <> nil do
 begin
-if (iterator^.Kind <> gtPortal) and
+if (iterator^.Kind <> gtPortal) and ((iterator^.Hedgehog <> CurrentHedgehog)
-((iterator^.Hedgehog <> CurrentHedgehog) or ((iterator^.Message and gmAllStoppable) = 0)) then
+or ((iterator^.Message and gmAllStoppable) = 0)) then
 begin
 iterator^.Active:= true;
-if iterator^.dY.QWordValue = _0.QWordValue then iterator^.dY.isNegative:= false;
+if iterator^.dY.QWordValue = _0.QWordValue then
-iterator^.State:= iterator^.State or gstMoving;
+iterator^.dY.isNegative:= false;
-DeleteCI(iterator);
+iterator^.State:= iterator^.State or gstMoving;
+DeleteCI(iterator);
 //inc(iterator^.dY.QWordValue,10);
 end;
 iterator:= iterator^.NextGear
 end;
-if Gear^.Health > 1 then dec(Gear^.Health);
+if Gear^.Health > 1 then
+dec(Gear^.Health);
 end;
 end;
 // make the ball visible
 CurWeapon^.Timer := 0;
 end
 end;
-if destroyGear then oldPortal^.Timer:= 0;
+if destroyGear then
+oldPortal^.Timer:= 0;
 end;
 procedure doStepMovingPortal_real(Gear: PGear);
 var
 x, y, tx, ty: LongInt;
 tx := 0;
 ty := 0;
 // avoid compiler hints
 if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0) and (Land[y, x] > 255) then
 begin
 Gear^.State := Gear^.State or gstCollision;
 Gear^.State := Gear^.State and (not gstMoving);
 if not CalcSlopeTangent(Gear, x, y, tx, ty, 255)
 or (DistanceI(tx,ty) < _12) then // reject shots at too irregular terrain
 begin
 loadNewPortalBall(Gear, true);
 EXIT;
 end;
 // making a normalized normal vector
 s := _1/DistanceI(tx,ty);
 Gear^.dX :=  s * ty;
 Gear^.dY := -s * tx;
 Gear^.DirAngle := DxDy2Angle(-Gear^.dY,Gear^.dX);
-if not Gear^.dX.isNegative then Gear^.DirAngle := 180-Gear^.DirAngle;
+if not Gear^.dX.isNegative then
+Gear^.DirAngle := 180-Gear^.DirAngle;
 if ((Gear^.IntersectGear = nil)
-or (hwRound(Distance(Gear^.X - Gear^.IntersectGear^.X,Gear^.Y-Gear^.IntersectGear^.Y)) >=
+or (hwRound(Distance(Gear^.X - Gear^.IntersectGear^.X,Gear^.Y-Gear^.IntersectGear^.Y)) >=Gear^.Radius*2)) then
-Gear^.Radius*2))
+begin
-then
-begin
 loadNewPortalBall(Gear, false);
 inc(Gear^.Tag);
 Gear^.doStep := @doStepPortal;
 end
 else
 loadNewPortalBall(Gear, true);
 end
-else if (y > cWaterLine) or (y < -LAND_WIDTH)
-or (x > 2*LAND_WIDTH) or (x < -LAND_WIDTH) then
+else if (y > cWaterLine)
-loadNewPortalBall(Gear, true);
+or (y < -LAND_WIDTH)
+or (x > 2*LAND_WIDTH)
+or (x < -LAND_WIDTH) then
+loadNewPortalBall(Gear, true);
 end;
 procedure doStepMovingPortal(Gear: PGear);
 begin
 doPortalColorSwitch();
 doStepPerPixel(Gear, @doStepMovingPortal_real, true);
 if (Gear^.Timer < 1)
 or (Gear^.Hedgehog^.Team <> CurrentHedgehog^.Team) then
 deleteGear(Gear);
 end;
 procedure doStepPortalShot(newPortal: PGear);
 var
 iterator: PGear;
 newPortal^.IntersectGear := nil;
 if CurrentHedgehog <> nil then
 with CurrentHedgehog^ do
 begin
 CurWeapon:= GetAmmoEntry(CurrentHedgehog^);
 // let's save the HH's dX's direction so we can decide where the "top" of the portal hole
 newPortal^.Elasticity.isNegative := CurrentHedgehog^.Gear^.dX.isNegative;
 // when doing a backjump the dx is the opposite of the facing direction
 if ((Gear^.State and gstHHHJump) <> 0) and (not cArtillery) then
 iterator := GearsList;
 while iterator <> nil do
 begin
 if (iterator^.Kind = gtPortal) then
 if (iterator <> newPortal) and (iterator^.Timer > 0) and (iterator^.Hedgehog = CurrentHedgehog) then
 begin
 if ((iterator^.Tag and 2) = (newPortal^.Tag and 2)) then
 begin
 iterator^.Timer:= 0;
 end
 else
 // link portals with each other
 newPortal^.IntersectGear := iterator;
 iterator^.IntersectGear := newPortal;
 iterator^.Health := newPortal^.Health;
 end;
 end;
 iterator^.PortalCounter:= 0;
 iterator := iterator^.NextGear
 end;
 end;
 newPortal^.State := newPortal^.State and (not gstCollision);
 newPortal^.State := newPortal^.State or gstMoving;
 newPortal^.doStep := @doStepMovingPortal;
 end;
 r0, r1: LongInt;
 odY: hwFloat;
 begin
 AllInactive := false;
 if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and
 ((CurrentHedgehog^.Gear^.Message and gmSlot) <> 0) then
 begin
 case CurrentHedgehog^.Gear^.MsgParam of
 0: PlaySound(sndPiano0);
 1: PlaySound(sndPiano1);
 2: PlaySound(sndPiano2);
 3: PlaySound(sndPiano3);
 4: PlaySound(sndPiano4);
 5: PlaySound(sndPiano5);
 6: PlaySound(sndPiano6);
 7: PlaySound(sndPiano7);
 else PlaySound(sndPiano8);
 end;
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtNote);
 CurrentHedgehog^.Gear^.MsgParam := 0;
 CurrentHedgehog^.Gear^.Message := CurrentHedgehog^.Gear^.Message and (not gmSlot);
 end;
 // Drown the hedgehog.  Could also just delete it, but hey, this gets a caption
 CurrentHedgehog^.Gear^.Active := true;
 CurrentHedgehog^.Gear^.X := Gear^.X;
 CurrentHedgehog^.Gear^.Y := int2hwFloat(cWaterLine+cVisibleWater)+_128;
 CurrentHedgehog^.Unplaced := false;
-if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft;
+if TagTurnTimeLeft = 0 then
+TagTurnTimeLeft:= TurnTimeLeft;
 TurnTimeLeft:= 0
 end;
 ResumeMusic
 end;
 exit
 // Drown the hedgehog.  Could also just delete it, but hey, this gets a caption
 CurrentHedgehog^.Gear^.Active := true;
 CurrentHedgehog^.Gear^.X := Gear^.X;
 CurrentHedgehog^.Gear^.Y := int2hwFloat(cWaterLine+cVisibleWater)+_128;
 CurrentHedgehog^.Unplaced := false;
-if TagTurnTimeLeft = 0 then TagTurnTimeLeft:= TurnTimeLeft;
+if TagTurnTimeLeft = 0 then
+TagTurnTimeLeft:= TurnTimeLeft;
 TurnTimeLeft:= 0
 end;
 ResumeMusic
 end
 else if (Gear^.State and gstCollision) <> 0 then
 ldX := ldX * sdy;
 ldY := ldY * sdy;
 sdY := hwAbs(ldX) + hwAbs(ldY);
 sdX := _1 - hwAbs(ldX/sdY);
 sdY := _1 - hwAbs(ldY/sdY);
-if (ldX.isNegative = ldY.isNegative) then sdY := -sdY;
+if (ldX.isNegative = ldY.isNegative) then
+sdY := -sdY;
 // initial angle depends on current GameTicks
 t := GameTicks mod 4096;
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 // if borders are on, stop outside land array
 if hasBorder and (((x and LAND_WIDTH_MASK) <> 0) or ((y and LAND_HEIGHT_MASK) <> 0)) then
 begin
 Gear^.Damage := 0;
 Gear^.Health := 0;
 end
 else
 begin
 if (rY <= cWaterLine) or (y <= cWaterLine) then
 begin
 if ((y and LAND_HEIGHT_MASK) = 0) and ((x and LAND_WIDTH_MASK) = 0)
 and (Land[y, x] <> 0) then
 begin
 if justCollided then
 begin
 Gear^.Damage := 0;
 Gear^.Health := 0;
 end
 else
 begin
 inc(Gear^.Damage,3);
 justCollided := true;
 end;
 end
 else
 justCollided := false;
 // kick nearby hogs, dig tunnel and add some fire
 // if at least 5 collisions occured
 if Gear^.Damage > 0 then
 begin
 DrawExplosion(rX,rY,Gear^.Radius);
 // kick nearby hogs
 AmmoShove(Gear, 35, 50);
 // add some fire to the tunnel
 if getRandom(6) = 0 then
 AddGear(x - Gear^.Radius + LongInt(getRandom(2 * Gear^.Radius)), y -
 getRandom(Gear^.Radius + 1), gtFlame, gsttmpFlag, _0, _0, 0);
 end;
 if getRandom(100) = 0 then
 AddVisualGear(x, y, vgtSmokeTrace);
+end
+else dec(Gear^.Health, 5); // if underwater get additional damage
+end;
+dec(Gear^.Health);
+// decrease bullet size towards the end
+if (Gear^.Radius > 4) then
+begin
+if (Gear^.Health <= (initHealth div 3)) then
+dec(Gear^.Radius)
 end
-else dec(Gear^.Health, 5); // if underwater get additional damage
+else if (Gear^.Radius > 3) then
-end;
+begin
+if (Gear^.Health <= (initHealth div 4)) then
-dec(Gear^.Health);
+dec(Gear^.Radius)
+end
-// decrease bullet size towards the end
-if (Gear^.Radius > 4) then begin
-if (Gear^.Health <= (initHealth div 3)) then dec(Gear^.Radius) end
-else if (Gear^.Radius > 3) then begin
-if (Gear^.Health <= (initHealth div 4)) then dec(Gear^.Radius) end
 else if (Gear^.Radius > 2) then begin
-if (Gear^.Health <= (initHealth div 5)) then dec(Gear^.Radius) end
+if (Gear^.Health <= (initHealth div 5)) then
-else if (Gear^.Radius > 1) then begin
+dec(Gear^.Radius)
-if (Gear^.Health <= (initHealth div 6)) then dec(Gear^.Radius) end;
+end
+else if (Gear^.Radius > 1) then
+begin
+if (Gear^.Health <= (initHealth div 6)) then
+dec(Gear^.Radius)
+end;
 until (Gear^.Health <= 0);
 DeleteGear(Gear);
 AfterAttack;
 if (GameTicks and $FF) = 0 then
 begin
 if (HHGear^.Message and gmRight) <> 0 then
 begin
-if HHGear^.dX.isNegative and (Gear^.Tag < 20) then inc(Gear^.Tag)
+if HHGear^.dX.isNegative and (Gear^.Tag < 20) then
-else if Gear^.Tag > 5 then dec(Gear^.Tag);
+inc(Gear^.Tag)
+else if Gear^.Tag > 5 then
+dec(Gear^.Tag);
 end
 else if (HHGear^.Message and gmLeft) <> 0 then
 begin
-if HHGear^.dX.isNegative and (Gear^.Tag > 5) then dec(Gear^.Tag)
+if HHGear^.dX.isNegative and (Gear^.Tag > 5) then
-else if Gear^.Tag < 20 then inc(Gear^.Tag);
+dec(Gear^.Tag)
+else if Gear^.Tag < 20 then
+inc(Gear^.Tag);
 end
 end;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 if (GameTicks and $FF) = 0 then
 begin
 if (HHGear^.Message and gmRight) <> 0 then
 begin
-if HHGear^.dX.isNegative and (Gear^.Tag < 20) then inc(Gear^.Tag)
+if HHGear^.dX.isNegative and (Gear^.Tag < 20) then
-else if Gear^.Tag > 5 then dec(Gear^.Tag);
+inc(Gear^.Tag)
+else if Gear^.Tag > 5 then
+dec(Gear^.Tag);
 end
 else if (HHGear^.Message and gmLeft) <> 0 then
 begin
-if HHGear^.dX.isNegative and (Gear^.Tag > 5) then dec(Gear^.Tag)
+if HHGear^.dX.isNegative and (Gear^.Tag > 5) then
-else if Gear^.Tag < 20 then inc(Gear^.Tag);
+dec(Gear^.Tag)
+else if Gear^.Tag < 20 then
+inc(Gear^.Tag);
 end
 end;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepPoisonCloud(Gear: PGear);
 begin
 if Gear^.Timer = 0 then
 begin
 DeleteGear(Gear);
 exit
 end;
 dec(Gear^.Timer);
 Gear^.X:= Gear^.X + Gear^.dX;
 Gear^.Y:= Gear^.Y + Gear^.dY;
 Gear^.dX := Gear^.dX + cWindSpeed / 4;
 Gear^.dY := Gear^.dY + cGravity / 100;
 tmp:= t^.ar[i];
 if (tmp^.State and gstNoDamage) = 0 then
 if (tmp^.Kind = gtHedgehog) or (tmp^.Kind = gtMine) or (tmp^.Kind = gtExplosives) then
 begin
 //tmp^.State:= tmp^.State or gstFlatened;
-if not tmp^.Invulnerable then ApplyDamage(tmp, CurrentHedgehog, tmp^.Health div 3, dsUnknown);
+if not tmp^.Invulnerable then
+ApplyDamage(tmp, CurrentHedgehog, tmp^.Health div 3, dsUnknown);
 //DrawTunnel(tmp^.X, tmp^.Y - _1, _0, _0_5, cHHRadius * 6, cHHRadius * 3);
 tmp2:= AddGear(hwRound(tmp^.X), hwRound(tmp^.Y), gtHammerHit, 0, _0, _0, 0);
 tmp2^.IntersectGear:= tmp;
 SetAllToActive
 end
 end
 else
 begin
 Gear^.dY := Gear^.dY + cGravity;
 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;
 Gear^.X := Gear^.X + HitGear^.dX;
 HitGear^.X := Gear^.X;
 SetLittle(HitGear^.dY);
 i := 0;
 HHGear := Gear^.Hedgehog^.Gear;
 y := hwRound(Gear^.Y) - cHHRadius * 2;
 while y < hwRound(Gear^.Y) do
 begin
 ar[i].Left := hwRound(Gear^.X) - Gear^.Radius - LongInt(GetRandom(2));
 ar[i].Right := hwRound(Gear^.X) + Gear^.Radius + LongInt(GetRandom(2));
 inc(y, 2);
 inc(i)
 end;
 DrawHLinesExplosions(@ar, 3, hwRound(Gear^.Y) - cHHRadius * 2, 2, Pred(i));
 Gear^.dY := HHGear^.dY;
 DeleteCI(HHGear);
 (*DrawCircle(hwRound(Gear^.X), hwRound(Gear^.Y), Gear^.Radius, 1.5, 0, 0, $FF,
 $FF);*)
 if ((Gear^.Message and gmUp) <> 0) then
 begin
-if (GameTicks and $F) <> 0 then exit;
+if (GameTicks and $F) <> 0 then
+exit;
 end
-else if (GameTicks and $1FF) <> 0 then exit;
+else if (GameTicks and $1FF) <> 0 then
+exit;
 if Gear^.Power < 45 then
 begin
 inc(Gear^.Power);
-if TestCollisionYwithGear(hh^.Gear, -1) = 0 then hh^.Gear^.Y := hh^.Gear^.Y - _1;
+if TestCollisionYwithGear(hh^.Gear, -1) = 0 then
+hh^.Gear^.Y := hh^.Gear^.Y - _1;
 end;
 graves := GearsNear(Gear^.X, Gear^.Y, gtGrave, Gear^.Radius);
 if Length(graves) = 0 then
 begin
 // now really resurrect the hogs with the hp saved in the graves
 for i:= 0 to High(graves) do
 if graves[i]^.Health > 0 then
 begin
-resgear := AddGear(hwRound(graves[i]^.X), hwRound(graves[i]^.Y),
+resgear := AddGear(hwRound(graves[i]^.X), hwRound(graves[i]^.Y), gtHedgehog, gstWait, _0, _0, 0);
-gtHedgehog, gstWait, _0, _0, 0);
 resgear^.Hedgehog := graves[i]^.Hedgehog;
 resgear^.Health := graves[i]^.Health;
 PHedgehog(graves[i]^.Hedgehog)^.Gear := resgear;
 DeleteGear(graves[i]);
 RenderHealth(resgear^.Hedgehog^);
 RecountTeamHealth(resgear^.Hedgehog^.Team);
 resgear^.Hedgehog^.Effects[heResurrected]:= true;
 // only make hat-less hedgehogs look like zombies, preserve existing hats
 if resgear^.Hedgehog^.Hat = 'NoHat' then
 LoadHedgehogHat(resgear, 'Reserved/Zombie');
 end;
 hh^.Gear^.dY := _0;
 end;
 DeleteGear(Gear);
 exit
 end;
 if (Gear^.Timer = 0) then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 10, Gear^.Hedgehog, EXPLAutoSound);
 for i:= -19 to 19 do
 FollowGear := AddGear(hwRound(Gear^.X) + i div 3, hwRound(Gear^.Y), gtFlame, 0, _0_001 * i, _0, 0);
 DeleteGear(Gear);
 exit
 end;
 if (GameTicks and $3F) = 0 then
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace);
 dec(Gear^.Timer)
 end;
 if Gear^.Pos = 1 then
 begin
 AddGearCI(Gear);
 AfterAttack;
-if Gear = CurAmmoGear then CurAmmoGear:= nil;
+if Gear = CurAmmoGear then
-if HH^.Gear <> nil then HideHog(HH);
+CurAmmoGear:= nil;
+if HH^.Gear <> nil then
+HideHog(HH);
 Gear^.Pos:= 2
 end;
 if Gear^.Pos = 2 then
 begin
 Gear^.Y:= Gear^.Y - _0_5;
 AddGearCI(Gear);
 end;
 inc(Gear^.Timer);
 end;
-if Gear^.Tag <= TotalRounds then Gear^.Pos:= 3;
+if Gear^.Tag <= TotalRounds then
+Gear^.Pos:= 3;
 end;
 if Gear^.Pos = 3 then
 if Gear^.Timer < 1000 then
 begin
 end;
 inc(Gear^.Timer);
 end
 else
 begin
-if HH^.GearHidden <> nil then RestoreHog(HH);
+if HH^.GearHidden <> nil then
+RestoreHog(HH);
 Gear^.Pos:= 4;
 end;
 if Gear^.Pos = 4 then
 if ((GameTicks mod 1000) = 0) and ((GameFlags and gfInvulnerable) = 0) then
 end;
 end;
 if Gear^.Health <= 0 then
 begin
-if HH^.GearHidden <> nil then RestoreHog(HH);
+if HH^.GearHidden <> nil then
+RestoreHog(HH);
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 DeleteCI(Gear);
 if (Gear^.Pos = 1) and (GameTicks and $1F = 0) and (Gear^.Power < 255) then
 begin
 inc(Gear^.Power);
 if (Gear^.Power = 172) and (HH^.Gear <> nil) and
 (HH^.Gear^.Damage = 0) and (HH^.Gear^.Health > 0) and
 ((HH^.Gear^.State and (gstMoving or gstHHDeath or gstHHGone)) = 0) then
 with HH^.Gear^ do
 begin
 State:= State or gstAnimation;
 Tag:= 2;
 Timer:= 0;
 Pos:= 0
 end
 end;
-if (Gear^.Pos = 3) and (GameTicks and $1F = 0) and (Gear^.Power > 0) then dec(Gear^.Power);
+if (Gear^.Pos = 3) and (GameTicks and $1F = 0) and (Gear^.Power > 0) then
-if (Gear^.Pos = 1) and (Gear^.Power = 255) and ((GameTicks mod 2000) = 1000) then Gear^.Pos:= 2;
+dec(Gear^.Power);
+if (Gear^.Pos = 1) and (Gear^.Power = 255) and ((GameTicks mod 2000) = 1000) then
+Gear^.Pos:= 2;
 if (Gear^.Pos = 3) and (Gear^.Power = 0) then
 begin
 StopSound(Gear^.SoundChannel);
 if HH^.GearHidden = nil then
 begin
 if (Gear^.Pos = 4) then
 begin
 cnt:= 0;
 for j:= 0 to Pred(HH^.Team^.Clan^.TeamsNumber) do
 for i:= 0 to Pred(HH^.Team^.Clan^.Teams[j]^.HedgehogsNumber) do
-if (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear <> nil) and
+if (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear <> nil)
-((HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.State and gstDrowning) = 0) and
+and ((HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.State and gstDrowning) = 0)
-(HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Health >
+and (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Health > HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Damage) then
-HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Damage) then inc(cnt);
+inc(cnt);
 if (cnt = 0) or SuddenDeathDmg or (Gear^.Timer = 0) then
 begin
 Gear^.SoundChannel := LoopSound(sndTardis);
 Gear^.Pos:= 1;
 Gear^.Power:= 0;
 Gear^.Timer:= 0;
-if HH^.GearHidden <> nil then FindPlace(HH^.GearHidden, false, 0, LAND_WIDTH,true);
+if HH^.GearHidden <> nil then
+FindPlace(HH^.GearHidden, false, 0, LAND_WIDTH,true);
 if HH^.GearHidden <> nil then
 begin
 Gear^.X:= HH^.GearHidden^.X;
 Gear^.Y:= HH^.GearHidden^.Y;
 //HH^.Gear:=HH^.GearHidden;
 exit
 end;
 cnt:= 0;
 for j:= 0 to Pred(HH^.Team^.Clan^.TeamsNumber) do
 for i:= 0 to Pred(HH^.Team^.Clan^.Teams[j]^.HedgehogsNumber) do
-if (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear <> nil) and
+if (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear <> nil)
-((HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.State and gstDrowning) = 0) and
+and ((HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.State and gstDrowning) = 0)
-(HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Health >
+and (HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Health > HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Damage) then
-HH^.Team^.Clan^.Teams[j]^.Hedgehogs[i].Gear^.Damage) then inc(cnt);
+inc(cnt);
 if cnt < 2 then
 begin
 if HH^.Gear <> nil then
 begin
 HH^.Gear^.Message := HH^.Gear^.Message and (not gmAttack);

changeset 6580	6155187bf599
parent 6556	faa47a7e614a
child 6700	e04da46ee43c