sheepy-clone: comparison hedgewars/GSHandlers.inc

equal deleted inserted replaced

-:43e106417a05
+:b5b79a8f9354
 if steps > 1 then
 begin
 sX:= dX / steps;
 sY:= dY / steps;
 end
 else
 begin
 sX:= dX;
 sY:= dY;
 end;
 break;
 end;
 end;
 procedure makeHogsWorry(x, y: hwFloat; r: LongInt);
 var
 gi: PGear;
 d: LongInt;
 begin
 gi := GearsList;
 while gi <> nil do
 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
 PlaySoundV(sndOops, gi^.Hedgehog^.Team^.voicepack)
 else
 begin
 if ((gi^.State and gstMoving) = 0) and (gi^.Hedgehog^.Effects[heFrozen] = 0) then
 begin
 gi^.dX.isNegative:= X<gi^.X;
 gi^.State := gi^.State or gstLoser;
 end;
 if d > r div 2 then
 PlaySoundV(sndNooo, gi^.Hedgehog^.Team^.voicepack)
 else
 PlaySoundV(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 lastGearByUID = HH^.Gear then
 lastGearByUID := nil;
 HH^.Gear^.Message:= HH^.Gear^.Message or gmRemoveFromList;
 with HH^.Gear^ do
 begin
 Z := cHHZ;
 HH^.Gear^.Active:= false;
 DeleteGear(Gear);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFallingGear(Gear: PGear);
 var
 isFalling: boolean;
 //tmp: QWord;
 tdX, tdY: hwFloat;
 collV, collH: LongInt;
 land: word;
 Gear^.State := Gear^.State or gstCollision
 end
 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
 begin
 collV := 1;
 isFalling := false;
 if land and lfIce <> 0 then
 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
 Gear^.dX := - Gear^.dX * Gear^.Elasticity;
 Gear^.dY :=   Gear^.dY * Gear^.Elasticity;
 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 + tdY.QWordValue) > _0_2.QWordValue)) then
 begin
 Gear^.dX := tdY*Gear^.Elasticity*Gear^.Friction;
 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;
 if (Gear^.nImpactSounds > 0) and
 (Gear^.State and gstCollision <> 0) and
 (((Gear^.Kind <> gtMine) and (Gear^.Damage <> 0)) or (Gear^.State and gstMoving <> 0)) and
 (((Gear^.Radius < 3) and (Gear^.dY < -_0_1)) or
 ((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);
 var
 i, x, y: LongInt;
 dX, dY, gdX: hwFloat;
 vg: PVisualGear;
 begin
 AllInactive := false;
 doStepFallingGear(Gear);
 dec(Gear^.Timer);
 if Gear^.Timer = 1000 then // might need adjustments
 case Gear^.Kind of
 gtGrenade: makeHogsWorry(Gear^.X, Gear^.Y, 50);
 gtClusterBomb: makeHogsWorry(Gear^.X, Gear^.Y, 20);
 gtWatermelon: makeHogsWorry(Gear^.X, Gear^.Y, 75);
 gtHellishBomb: makeHogsWorry(Gear^.X, Gear^.Y, 90);
 gtGasBomb: makeHogsWorry(Gear^.X, Gear^.Y, 50);
 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);
 gdX:= Gear^.dX;
 doMakeExplosion(x, y, 20, Gear^.Hedgehog, EXPLAutoSound);
 dX := rndSign(GetRandomf * _0_1) + gdX / 5;
 dY := (GetRandomf - _3) * _0_08;
 FollowGear := AddGear(x, y, gtCluster, 0, dX, dY, 25)
 end
 end;
 gtWatermelon:
 begin
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 gdX:= Gear^.dX;
 doMakeExplosion(x, y, 75, Gear^.Hedgehog, EXPLAutoSound);
 dY := (GetRandomf - _1_5) * _0_3;
 FollowGear:= AddGear(x, y, gtMelonPiece, 0, dX, dY, 75);
 FollowGear^.DirAngle := i * 60
 end
 end;
 gtHellishBomb:
 begin
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 doMakeExplosion(x, y, 90, Gear^.Hedgehog, EXPLAutoSound);
 begin
 AddGear(x, y, gtFlame, gstTmpFlag, dX, dY, 0);
 AddGear(x, y, gtFlame, 0, dX, -dY, 0)
 end
 else
 begin
 AddGear(x, y, gtFlame, 0, dX, dY, 0);
 AddGear(x, y, gtFlame, gstTmpFlag, dX, -dY, 0)
 end;
 end
 end;
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMolotov(Gear: PGear);
 var
 s: Longword;
 i, gX, gY: LongInt;
 dX, dY: hwFloat;
 smoke, glass: PVisualGear;
 begin
 // adjust angle to match the texture
 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;
 end;
 end
 else allpx:= false
 end;
 p:= @(p^[s^.pitch shr 2])
 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), true)
 else
 begin
 UpdateLandTexture(
 Gear^.dY := Gear^.dY + cGravity
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBeeWork(Gear: PGear);
 var
 t: hwFloat;
 gX,gY,i: LongInt;
 uw, nuw: boolean;
 flower: PVisualGear;
 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
 AfterAttack
 end
 end;
 procedure doStepShotgunShot(Gear: PGear);
 var
 i: LongWord;
 shell: PVisualGear;
 begin
 AllInactive := false;
 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^.Timer := 200;
 end;
 end;
 procedure doStepBulletWork(Gear: PGear);
 var
 i, x, y: LongWord;
 oX, oY: hwFloat;
 VGear: PVisualGear;
 begin
 AllInactive := false;
 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);
 // let's interrupt before a collision to give portals a chance to catch the bullet
 if (Gear^.Damage = 1) and (Gear^.Tag = 0) and not(CheckLandValue(x, y, lfLandMask)) then
 begin
 if Gear^.AmmoType = amDEagle then
 AmmoShove(Gear, 7, 20)
 else
 AmmoShove(Gear, Gear^.Timer, 20);
 CheckGearDrowning(Gear);
 dec(i)
 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);
 begin
 if (Gear^.Kind = gtSniperRifleShot) and ((GameFlags and gfLaserSight) = 0) then
 cLaserSighting := false;
 if (Ammoz[Gear^.AmmoType].Ammo.NumPerTurn <= CurrentHedgehog^.MultiShootAttacks) and ((GameFlags and gfArtillery) = 0) then
 cArtillery := false;
 // Bullet Hit
 if (hwRound(Gear^.X) and LAND_WIDTH_MASK = 0) and (hwRound(Gear^.Y) and LAND_HEIGHT_MASK = 0) then
 begin
 VGear := AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtBulletHit);
 if VGear <> nil then
 begin
 VGear^.Angle := DxDy2Angle(-Gear^.dX, Gear^.dY);
 end;
 end;
 spawnBulletTrail(Gear);
 Gear^.doStep := @doStepShotIdle
 end;
 end;
 Gear^.Y := Gear^.Y + Gear^.dY * 3;
 Gear^.doStep := @doStepBulletWork
 end;
 procedure doStepSniperRifleShot(Gear: PGear);
 var
 HHGear: PGear;
 shell: PVisualGear;
 begin
 cArtillery := true;
 HHGear := Gear^.Hedgehog^.Gear;
 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
 ////////////////////////////////////////////////////////////////////////////////
 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;
 DeleteGear(Gear)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepPickHammerWork(Gear: PGear);
 var
 i, ei, x, y: LongInt;
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 Gear^.dX := _0_3
 else Gear^.dX := _0;
 end;
 procedure doStepPickHammer(Gear: PGear);
 var
 i, y: LongInt;
 ar: TRangeArray;
 HHGear: PGear;
 begin
 i := 0;
 doStepPickHammerWork(Gear);
 Gear^.doStep := @doStepPickHammerWork
 end;
 ////////////////////////////////////////////////////////////////////////////////
 var
 BTPrevAngle, BTSteps: LongInt;
 procedure doStepBlowTorchWork(Gear: PGear);
 var
 HHGear: PGear;
 b: boolean;
 prevX: LongInt;
 begin
 AllInactive := false;
 dec(Gear^.Timer);
 if ((GameFlags and gfInfAttack) <> 0) and (TurnTimeLeft > 0) then
 dec(TurnTimeLeft);
 HHGear := Gear^.Hedgehog^.Gear;
 HedgehogChAngle(HHGear);
 b := false;
 AfterAttack
 end
 end;
 procedure doStepBlowTorch(Gear: PGear);
 var
 HHGear: PGear;
 begin
 BTPrevAngle := High(LongInt);
 BTSteps := 0;
 HHGear := Gear^.Hedgehog^.Gear;
 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
 ////////////////////////////////////////////////////////////////////////////////
 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 (not isZero(Gear^.dX)) or (not isZero(Gear^.dY)) then
 begin
 PlaySound(sndRopeAttach);
 TODO
 Increase damage as barrel smokes?
 Try tweaking friction some more
 *)
 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);
 Gear^.State := Gear^.State or gstAnimation;
 if ((Gear^.dX.QWordValue <> 0)
 or (Gear^.dY.QWordValue <> 0))  then
 begin
 DeleteCI(Gear);
 AllInactive := false;
 particle^.dX := particle^.dX + (Gear^.dX.QWordValue / 21474836480)
 end
 end
 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));
 doStepFallingGear(Gear);
 CalcRotationDirAngle(Gear);
 // Hand off to doStepCase for the explosion
 end;
 procedure doStepCase(Gear: PGear);
 var
 i, x, y: LongInt;
 k: TGearType;
 exBoom: boolean;
 dX, dY: HWFloat;
 hog: PHedgehog;
 Gear^.Damage := 0;
 if Gear^.Health <= 0 then
 exBoom := true;
 end
 else
 begin
 if (Gear^.Pos <> posCaseHealth) and (GameTicks and $1FFF = 0) then // stir 'em up periodically
 begin
 gi := GearsList;
 while gi <> nil do
 begin
 if sparkles <> nil then
 begin
 sparkles^.dX:= 0;
 sparkles^.dY:= 0;
 sparkles^.Angle:= 270;
 if Gear^.Tag = 1 then
 sparkles^.Tint:= $3744D7FF
 else sparkles^.Tint:= $FAB22CFF
 end;
 end;
 if Gear^.Timer < 1000 then
 begin
 AllInactive:= false;
 exit
 end
 end;
 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);
 Gear^.dY := - Gear^.dY * Gear^.Elasticity;
 if Gear^.dY > - _0_001 then
 Gear^.dY := _0
 else if Gear^.dY < - _0_03 then
 PlaySound(Gear^.ImpactSound);
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepShover(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.State := HHGear^.State or gstNoDamage;
 DeleteCI(HHGear);
 Gear^.doStep := @doStepIdle
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepWhip(Gear: PGear);
 var
 HHGear: PGear;
 i: LongInt;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.State := HHGear^.State or gstNoDamage;
 Gear^.doStep := @doStepIdle
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFlame(Gear: PGear);
 var
 gX,gY,i: LongInt;
 sticky: Boolean;
 vgt: PVisualGear;
 tdX,tdY: HWFloat;
 begin
 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 sticky then Gear^.X := Gear^.X + Gear^.dX else
 Gear^.X := Gear^.X + Gear^.dX + cWindSpeed * 640;
 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);
 //DrawExplosion(gX, gY, 4);
 if ((GameTicks and $7) = 0) and (Random(2) = 0) then
 for i:= Random(2) downto 0 do
 AddVisualGear(gX - 3 + Random(6), gY - 2, vgtSmoke);
 if Gear^.Health > 0 then
 dec(Gear^.Health);
 Gear^.Timer := 450 - Gear^.Tag * 8
 end
 else
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFirePunchWork(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 if ((Gear^.Message and gmDestroy) <> 0) then
 begin
 lfIndestructible) then
 HHGear^.Y := HHGear^.Y + HHGear^.dY
 end;
 procedure doStepFirePunch(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 DeleteCI(HHGear);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepParachuteWork(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 inc(Gear^.Timer);
 HHGear^.X := HHGear^.X + cWindSpeed * 200;
 if (Gear^.Message and gmLeft) <> 0 then
 HHGear^.X := HHGear^.X - cMaxWindSpeed * 80
 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
 Gear^.X := HHGear^.X;
 Gear^.Y := HHGear^.Y
 end;
 procedure doStepParachute(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 DeleteCI(HHGear);
 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 * Gear^.Tag, _0, 0);
 1: FollowGear := AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMine,    0, cBombsSpeed * Gear^.Tag, _0, 0);
 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^.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)
 if (Gear^.State = 2) then
 Gear^.dX := Gear^.dX - cBombsSpeed * Gear^.Tag * 900
 // calcs for regular falling gears
 else if (int2hwFloat(Gear^.Target.Y) - Gear^.Y > _0) then
 Gear^.dX := Gear^.dX - cBombsSpeed * hwSqrt((int2hwFloat(Gear^.Target.Y) - Gear^.Y) * 2 /
 cGravity) * Gear^.Tag;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepGirder(Gear: PGear);
 var
 HHGear: PGear;
 x, y, tx, ty: hwFloat;
 begin
 AllInactive := false;
 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^.Message := HHGear^.Message and (not gmAttack);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepTeleportAfter(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 doStepHedgehogMoving(HHGear);
 // if not infattack mode wait for hedgehog finish falling to collect cases
 Gear^.doStep := @doStepTeleportAfter
 end;
 end;
 procedure doStepTeleport(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 Gear^.Target.X:= NoPointX
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSwitcherWork(Gear: PGear);
 var
 HHGear: PGear;
 hedgehog: PHedgehog;
 State: Longword;
 begin
 AllInactive := false;
 PlaySound(sndSwitchHog);
 repeat
 CurrentTeam^.CurrHedgehog := Succ(CurrentTeam^.CurrHedgehog) mod (CurrentTeam^.HedgehogsNumber);
 until (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear <> nil) and
 (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Gear^.Damage = 0) and
 (CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog].Effects[heFrozen]=0);
 SwitchCurrentHedgehog(@CurrentTeam^.Hedgehogs[CurrentTeam^.CurrHedgehog]);
 AmmoMenuInvalidated:= true;
 HHGear := CurrentHedgehog^.Gear;
 HHGear^.State := State;
 HHGear^.Active := true;
 FollowGear := HHGear;
 Gear^.Y := HHGear^.Y
 end;
 end;
 procedure doStepSwitcher(Gear: PGear);
 var
 HHGear: PGear;
 begin
 Gear^.doStep := @doStepSwitcherWork;
 HHGear := Gear^.Hedgehog^.Gear;
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepMortar(Gear: PGear);
 var
 dX, dY, gdX, gdY: hwFloat;
 i: LongInt;
 dxn, dyn: boolean;
 begin
 AllInactive := false;
 AddVisualGear(hwRound(Gear^.X), hwRound(Gear^.Y), vgtSmokeTrace)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepKamikazeWork(Gear: PGear);
 var
 i: LongWord;
 HHGear: PGear;
 sparkles: PVisualGear;
 hasWishes: boolean;
 begin
 end
 end;
 i := 2;
 repeat
 Gear^.X := Gear^.X + HHGear^.dX;
 Gear^.Y := Gear^.Y + HHGear^.dY;
 HHGear^.X := Gear^.X;
 HHGear^.Y := Gear^.Y;
 Gear^.doStep := @doStepKamikazeWork
 end
 end;
 procedure doStepKamikaze(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 const cakeh =   27;
 var
 CakePoints: array[0..Pred(cakeh)] of record
 x, y: hwFloat;
 end;
 CakeI: Longword;
 AfterAttack;
 DeleteGear(Gear)
 end;
 procedure doStepCakeDown(Gear: PGear);
 var
 gi: PGear;
 dmg, dmgBase: LongInt;
 fX, fY, tdX, tdY: hwFloat;
 begin
 AllInactive := false;
 Gear^.DirAngle := DxDy2Angle(tdx, tdy);
 end;
 end;
 procedure doStepCakeUp(Gear: PGear);
 var
 i: Longword;
 begin
 AllInactive := false;
 inc(Gear^.Tag);
 AfterAttack
 end
 end;
 procedure doStepCake(Gear: PGear);
 var
 HHGear: PGear;
 begin
 AllInactive := false;
 HHGear := Gear^.Hedgehog^.Gear;
 Gear^.doStep := @doStepSeductionWear
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepWaterUp(Gear: PGear);
 var
 i: LongWord;
 begin
 if (Gear^.Tag = 0)
 or (cWaterLine = 0) then
 begin
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepDrill(Gear: PGear);
 forward;
 procedure doStepDrillDrilling(Gear: PGear);
 var
 t: PGearArray;
 tempColl: Word;
 begin
 AllInactive := false;
 if (Gear^.Timer > 0) and ((Gear^.Timer mod 10) = 0) then
 if (TestCollisionYWithGear(Gear, hwSign(Gear^.dY)) <> 0) or TestCollisionXWithGear(Gear, hwSign(Gear^.dX)) or (GameTicks > Gear^.FlightTime) then
 t := CheckGearsCollision(Gear)
 else t := nil;
 Gear^.CollisionMask:= tempColl;
 //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 (TestCollisionYWithGear(Gear, hwSign(Gear^.dY)) = 0) 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
 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
 StopSoundChan(Gear^.SoundChannel);
 Gear^.Tag := 1;
 Gear^.doStep := @doStepDrill
 dec(Gear^.Timer);
 end;
 procedure doStepDrill(Gear: PGear);
 var
 t: PGearArray;
 oldDx, oldDy: hwFloat;
 t2: hwFloat;
 begin
 AllInactive := false;
 begin
 //hit
 Gear^.dX := oldDx;
 Gear^.dY := oldDy;
 if GameTicks > Gear^.FlightTime then
 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;
 if Gear^.Timer > 0 then dec(Gear^.Timer)
 end
 else if ((Gear^.State and gsttmpFlag) <> 0) and (Gear^.Tag <> 0) then
 begin
 if Gear^.Timer > 0 then
 dec(Gear^.Timer)
 else
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 30, Gear^.Hedgehog, EXPLAutoSound);
 DeleteGear(Gear);
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepBallgunWork(Gear: PGear);
 var
 HHGear, ball: PGear;
 rx, ry: hwFloat;
 gX, gY: LongInt;
 begin
 AllInactive := false;
 AfterAttack
 end
 end;
 procedure doStepBallgun(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmDown));
 HHGear^.State := HHGear^.State or gstNotKickable;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepRCPlaneWork(Gear: PGear);
 const cAngleSpeed =   3;
 var
 HHGear: PGear;
 i: LongInt;
 dX, dY: hwFloat;
 fChanged: boolean;
 trueAngle: Longword;
 CurAmmoGear := nil;
 if (GameFlags and gfInfAttack) = 0 then
 begin
 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;
 begin
 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;
 Gear^.doStep := @doStepRCPlaneWork
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepJetpackWork(Gear: PGear);
 var
 HHGear: PGear;
 fuel, i: LongInt;
 move: hwFloat;
 isUnderwater: Boolean;
 bubble: PVisualGear;
 Gear^.MsgParam := 0
 end;
 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) + '%', 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;
 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)
 //AddCaption(trmsg[sidFuel]+': '+inttostr(round(Gear^.Health/20))+'%', cWhiteColor, capgrpAmmostate);
 end
 end;
 procedure doStepJetpack(Gear: PGear);
 var
 HHGear: PGear;
 begin
 Gear^.Pos:= 0;
 Gear^.doStep := @doStepJetpackWork;
 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
 DeleteGear(Gear);
 end;
 end;
 procedure doStepBirdyFly(Gear: PGear);
 var
 HHGear: PGear;
 fuel, i: LongInt;
 move: hwFloat;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 if HHGear = nil then
 begin
 DeleteGear(Gear);
 exit
 end;
 if (HHGear^.Message and gmUp) <> 0 then
 begin
 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 ((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);
 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
 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;
 end
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepEggWork(Gear: PGear);
 var
 vg: PVisualGear;
 i: LongInt;
 begin
 AllInactive := false;
 Gear^.dX := Gear^.dX;
 if (CurrentHedgehog <> nil) and (CurrentHedgehog^.Gear <> nil) and ((CurrentHedgehog^.Gear^.Message and gmSwitch) <> 0) then
 with CurrentHedgehog^ do
 if (CurAmmoType = amPortalGun) then
 begin
 CurrentHedgehog^.Gear^.Message := CurrentHedgehog^.Gear^.Message and (not gmSwitch);
 CurWeapon:= GetCurAmmoEntry(CurrentHedgehog^);
 if CurWeapon^.Pos <> 0 then
 CurWeapon^.Pos := 0
 else
 CurWeapon^.Pos := 1;
 end;
 end;
 procedure doStepPortal(Gear: PGear);
 var
 iterator, conPortal: PGear;
 s, r, nx, ny, ox, oy, poffs, noffs, pspeed, nspeed,
 resetx, resety, resetdx, resetdy: hwFloat;
 sx, sy, rh, resetr: LongInt;
 hasdxy, isbullet, iscake, isCollision: Boolean;
 resety.QWordValue:= 4294967296 * 112;
 resetx.isNegative:= false;
 resetx.QWordValue:= 4294967296 * 35;
 resetdx.isNegative:= false;
 resetdx.QWordValue:= 4294967296 * 1152;
 resetdy:=hwAbs(iterator^.dX*4);
 resetdy:= resetdy + hwPow(resetdy,3)/_6 + _3 * hwPow(resetdy,5) / _40 + _5 * hwPow(resetdy,7) / resety + resetx * hwPow(resetdy,9) / resetdx;
 iterator^.Angle:= hwRound(resetdy*_2048 / _PI);
 if not iterator^.dY.isNegative then iterator^.Angle:= 2048-iterator^.Angle;
 if iterator^.dX.isNegative then iterator^.Angle:= 4096-iterator^.Angle;
 and (iterator = CurrentHedgehog^.Gear)
 and (CurAmmoGear <> nil)
 and (CurAmmoGear^.Kind =gtRope) then
 CurAmmoGear^.PortalCounter:= 1;
 if not isbullet and (iterator^.State and gstInvisible = 0)
 and (iterator^.Kind <> gtFlake) then
 FollowGear := iterator;
 // store X/Y values of exit for net bullet trail
 if isbullet then
 if destroyGear then
 oldPortal^.Timer:= 0;
 end;
 procedure doStepMovingPortal_real(Gear: PGear);
 var
 x, y, tx, ty: LongInt;
 s: hwFloat;
 begin
 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] > 255) then
 begin
 Gear^.State := Gear^.State or gstCollision;
 Gear^.State := Gear^.State and (not gstMoving);
 if (Land[y, x] and lfBouncy <> 0)
 or (not CalcSlopeTangent(Gear, x, y, tx, ty, 255))
 or (DistanceI(tx,ty) < _12) then // reject shots at too irregular terrain
 begin
 loadNewPortalBall(Gear, true);
 Gear^.doStep := @doStepPortal;
 end
 else
 loadNewPortalBall(Gear, true);
 end
 else if (y > cWaterLine)
 or (y < -max(LAND_WIDTH,4096))
 or (x > 2*max(LAND_WIDTH,4096))
 or (x < -max(LAND_WIDTH,4096)) then
 loadNewPortalBall(Gear, true);
 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;
 s: hwFloat;
 CurWeapon: PAmmo;
 begin
 s:= Distance (newPortal^.dX, newPortal^.dY);
 newPortal^.doStep := @doStepMovingPortal;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepPiano(Gear: PGear);
 var
 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);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepSineGunShotWork(Gear: PGear);
 var
 x, y, rX, rY, t, tmp, initHealth: LongInt;
 oX, oY, ldX, ldY, sdX, sdY, sine, lx, ly, amp: hwFloat;
 justCollided: boolean;
 begin
 AllInactive := false;
 AddGear(x - Gear^.Radius + tmp, y - GetRandom(Gear^.Radius + 1), gtFlame, gsttmpFlag, _0, _0, 0)
 end
 end;
 if random(100) = 0 then
 AddVisualGear(x, y, vgtSmokeTrace);
 end
 else dec(Gear^.Health, 5); // if underwater get additional damage
 end;
 dec(Gear^.Health);
 procedure doStepSineGunShot(Gear: PGear);
 var
 HHGear: PGear;
 begin
 PlaySound(sndSineGun);
 // push the shooting Hedgehog back
 HHGear := CurrentHedgehog^.Gear;
 Gear^.dX.isNegative := not Gear^.dX.isNegative;
 Gear^.dY.isNegative := not Gear^.dY.isNegative;
 performRumble(kSystemSoundID_Vibrate);
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepFlamethrowerWork(Gear: PGear);
 var
 HHGear, flame: PGear;
 rx, ry, speed: hwFloat;
 i, gX, gY: LongInt;
 begin
 AllInactive := false;
 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 (GameTicks and $FF) = 0 then
 begin
 if (HHGear^.Message and gmRight) <> 0 then
 begin
 if HHGear^.dX.isNegative and (Gear^.Tag < 20) then
 end
 else if (HHGear^.Message and gmLeft) <> 0 then
 begin
 if HHGear^.dX.isNegative and (Gear^.Tag > 5) then
 dec(Gear^.Tag)
 else if Gear^.Tag < 20 then
 inc(Gear^.Tag);
 end
 end;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 begin
 dec(Gear^.Health);
 if (Gear^.Health mod 5) = 0 then
 begin
 rx := rndSign(getRandomf * _0_1);
 ry := rndSign(getRandomf * _0_1);
 speed := _0_5 * (_10 / Gear^.Tag);
 flame:= AddGear(gx, gy, gtFlame, gstTmpFlag,
 SignAs(AngleSin(HHGear^.Angle) * speed, HHGear^.dX) + rx,
 AngleCos(HHGear^.Angle) * ( - speed) + ry, 0);
 flame^.CollisionMask:= lfNotCurrentMask;
 if (Gear^.Health mod 30) = 0 then
 begin
 flame:= AddGear(gx, gy, gtFlame, 0,
 SignAs(AngleSin(HHGear^.Angle) * speed, HHGear^.dX) + rx,
 AngleCos(HHGear^.Angle) * ( - speed) + ry, 0);
 end
 end
 end;
 procedure doStepFlamethrower(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmDown or gmLeft or gmRight));
 HHGear^.State := HHGear^.State or gstNotKickable;
 Gear^.doStep := @doStepFlamethrowerWork
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepLandGunWork(Gear: PGear);
 var
 HHGear, land: PGear;
 rx, ry, speed: hwFloat;
 i, gX, gY: LongInt;
 begin
 AllInactive := false;
 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 (GameTicks and $FF) = 0 then
 begin
 if (HHGear^.Message and gmRight) <> 0 then
 begin
 if HHGear^.dX.isNegative and (Gear^.Tag < 20) then
 dec(Gear^.Tag)
 else if Gear^.Tag < 20 then
 inc(Gear^.Tag);
 end
 end;
 dec(Gear^.Timer);
 if Gear^.Timer = 0 then
 begin
 dec(Gear^.Health);
 rx := rndSign(getRandomf * _0_1);
 ry := rndSign(getRandomf * _0_1);
 speed := (_3 / Gear^.Tag);
 land:= AddGear(gx, gy, gtFlake, gstTmpFlag,
 SignAs(AngleSin(HHGear^.Angle) * speed, HHGear^.dX) + rx,
 AngleCos(HHGear^.Angle) * ( - speed) + ry, 0);
 land^.CollisionMask:= lfNotCurrentMask;
 Gear^.Timer:= Gear^.Tag
 end;
 if (Gear^.Health = 0) or ((HHGear^.State and gstHHDriven) = 0) or ((HHGear^.Message and gmAttack) <> 0) then
 begin
 end
 end
 end;
 procedure doStepLandGun(Gear: PGear);
 var
 HHGear: PGear;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
 HHGear^.Message := HHGear^.Message and (not (gmUp or gmDown or gmLeft or gmRight or gmAttack));
 HHGear^.State := HHGear^.State or gstNotKickable;
 Gear^.Timer:= 250;
 Gear^.doStep:= @doStepIdle
 end;
 procedure doStepHammerHitWork(Gear: PGear);
 var
 i, j, ei: LongInt;
 HitGear: PGear;
 begin
 AllInactive := false;
 HitGear := Gear^.LinkedGear;
 SetLittle(HitGear^.dY);
 HitGear^.Active:= true;
 end;
 procedure doStepHammerHit(Gear: PGear);
 var
 i, y: LongInt;
 ar: TRangeArray;
 HHGear: PGear;
 begin
 i := 0;
 if ((Gear^.Message and gmUp) <> 0) then
 begin
 if (GameTicks and $F) <> 0 then
 exit;
 end
 else if (GameTicks and $1FF) <> 0 then
 exit;
 if Gear^.Power < 45 then
 begin
 if hh^.Gear^.Health > 0 then begin
 dec(hh^.Gear^.Health);
 inc(graves[i]^.Health);
 end;
 end; -}
 end
 else
 begin
 // now really resurrect the hogs with the hp saved in the graves
 for i:= 0 to graves.size - 1 do
 if graves.ar^[i]^.Health > 0 then
 begin
 hh^.Gear^.Damage:= 1;
 RenderHealth(hh^);
 RecountTeamHealth(hh^.Team);
 inc(graves.ar^[Gear^.Tag]^.Health);
 inc(Gear^.Tag)
 end
 end
 else
 begin
 StopSoundChan(Gear^.SoundChannel);
 Gear^.Timer := 250;
 Gear^.doStep := @doStepIdle;
 end
 doStepFallingGear(Gear);
 if (Gear^.Timer > 0) and ((Gear^.State and gstCollision) <> 0) then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 10, Gear^.Hedgehog, EXPLAutoSound);
 gX := hwRound(Gear^.X);
 gY := hwRound(Gear^.Y);
 for i:= 0 to 10 do
 begin
 dX := AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandomf + _1);
 dY := AngleSin(i * 8) * _0_5 * (GetRandomf + _1);
 AddGear(gX, gY, gtFlame, 0, dX, dY, 0);
 dec(Gear^.Timer)
 end;
 ////////////////////////////////////////////////////////////////////////////////
 procedure doStepStructure(Gear: PGear);
 var
 x, y: LongInt;
 HH: PHedgehog;
 t: PGear;
 begin
 HH:= Gear^.Hedgehog;
 Gear^.State:= Gear^.State and (not gstMoving);
 end;
 dec(Gear^.Health, Gear^.Damage);
 Gear^.Damage:= 0;
 if Gear^.Pos = 1 then
 begin
 AddGearCI(Gear);
 AfterAttack;
 if Gear = CurAmmoGear then
 CurAmmoGear:= nil;
 if HH^.Gear <> nil then
 HideHog(HH);
 Gear^.Pos:= 2
 end;
 if Gear^.Pos = 2 then
 begin
 if ((GameTicks mod 100) = 0) and (Gear^.Timer < 1000) then
 begin
 if (Gear^.Timer mod 10) = 0 then
 inc(Gear^.Timer);
 end;
 if Gear^.Tag <= TotalRounds then
 Gear^.Pos:= 3;
 end;
 if Gear^.Pos = 3 then
 if Gear^.Timer < 1000 then
 begin
 if (Gear^.Timer mod 10) = 0 then
 begin
 begin
 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
 begin
 t:= GearsList;
 while t <> nil do
 if (t^.Kind = gtHedgehog) and (t^.Hedgehog^.Team^.Clan = HH^.Team^.Clan) then
 t^.Invulnerable:= true;
 t:= t^.NextGear;
 end;
 end;
 if Gear^.Health <= 0 then
 begin
 if HH^.GearHidden <> nil then
 RestoreHog(HH);
 x := hwRound(Gear^.X);
 y := hwRound(Gear^.Y);
 DeleteCI(Gear);
 DeleteGear(Gear);
 end;
 end;
 ////////////////////////////////////////////////////////////////////////////////
 (*
 TARDIS needs
 Warp in.  Pos = 1
 Pause.    Pos = 2
 Hide gear  (TARDIS hedgehog was nil)
 Warp out. Pos = 3
 ... idle active for some time period ...  Pos = 4
 begin
 if (HH^.Gear <> nil) and (HH^.Gear^.State and gstInvisible = 0) then
 begin
 AfterAttack;
 if Gear = CurAmmoGear then CurAmmoGear := nil;
 if (HH^.Gear^.Damage = 0) and  (HH^.Gear^.Health > 0) and
 ((Gear^.State and (gstMoving or gstHHDeath or gstHHGone)) = 0) then
 HideHog(HH)
 end
 //else if (HH^.Gear <> nil) and (HH^.Gear^.State and gstInvisible <> 0) then
 else if (HH^.GearHidden <> nil) then// and (HH^.Gear^.State and gstInvisible <> 0) then
 end;
 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;
 inc(cnt);
 if (cnt = 0) or SuddenDeathDmg or (Gear^.Timer = 0) then
 begin
 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;
 end;
 (*
 WIP. The ice gun will have the following effects.  It has been proposed by sheepluva that it take the appearance of a large freezer
 spewing ice cubes.  The cubes will be visual gears only.  The scatter from them and the impact snow dust should help hide imprecisions in things like the GearsNear effect.
 For now we assume a "ray" like a deagle projected out from the gun.
 All these effects assume the ray's angle is not changed and that the target type was unchanged over a number of ticks.  This is a simplifying assumption for "gun was applying freezing effect to the same target".
 * When fired at water a layer of ice textured land is added above the water.
 * When fired at non-ice land (land and lfLandMask and not lfIce) the land is overlaid with a thin layer of ice textured land around that point (say, 1 or 2px into land, 1px above). For attractiveness, a slope would probably be needed.
 * When fired at a hog (land and $00FF <> 0), while the hog is targetted, the hog's state is set to frozen.  As long as the gun is on the hog, a frozen hog sprite creeps up from the feet to the head.  If the effect is interrupted before reaching the top, the freezing state is cleared.
 A frozen hog will animate differently.  To be decided, but possibly in a similar fashion to a grave when it comes to explosions.  The hog might (possibly) not be damaged by explosions.  This might make freezing potentially useful for friendlies in a bad position.  It might be better to allow damage though.
 A frozen hog stays frozen for a certain number of turns. Each turn the frozen overlay becomes fainter, until it fades and the hog animates normally again.
 *)
 procedure updateFuel(Gear: PGear);
 var
 t:LongInt;
 begin
 t:= Gear^.Health div 10;
 if (t <> Gear^.Damage) and ((GameTicks and $3F) = 0) then
 begin
 //unfreeze all semifrozen hogs - make this generic hog cleanup
 (*
 iter := GearsList;
 while iter <> nil do
 begin
 if (iter^.Kind = gtHedgehog) and
 (iter^.Hedgehog^.Effects[heFrozen] and $FF = 0) then
 iter^.Hedgehog^.Effects[heFrozen]:= 0;
 iter:= iter^.NextGear
 end
 *)
 end;
 end;
 procedure doStepIceGun(Gear: PGear);
 const iceWaitCollision:Longint = 0;
 const iceCollideWithGround:Longint = 1;
 //const iceWaitNextTarget:Longint = 2;
 ndX, ndY: hwFloat;
 i, t, gX, gY: LongInt;
 hogs: PGearArrayS;
 begin
 HHGear := Gear^.Hedgehog^.Gear;
-if (Gear^.Message and gmAttack <> 0) or (Gear^.Health = 0) or (HHGear = nil) or (HHGear^.Damage <> 0) then
+if (Gear^.Message and gmAttack <> 0) or (HHGear = nil) or (HHGear^.Damage <> 0) then
 begin
 DeleteGear(Gear);
 AfterAttack;
 exit
 end
 with Gear^ do
 begin
 HedgehogChAngle(HHGear);
 ndX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX) * _4;
 ndY:= -AngleCos(HHGear^.Angle) * _4;
 if (ndX <> dX) or (ndY <> dY) or
 ((Target.X <> NoPointX) and (Target.X and LAND_WIDTH_MASK = 0) and
 (Target.Y and LAND_HEIGHT_MASK = 0) and ((Land[Target.Y, Target.X] = 0))) then
 begin
 updateTarget(Gear, ndX, ndY);
-IceState := iceWaitCollision;
+Health := iceWaitCollision;
 end
 else
 begin
 X:= X + dX;
 Y:= Y + dY;
 gX:= hwRound(X);
 gY:= hwRound(Y);
 if Target.X = NoPointX then
 begin
 t:= hwRound(hwSqr(X-HHGear^.X)+hwSqr(Y-HHGear^.Y));
 end;
 if Target.X <> NoPointX then
 begin
 CheckCollisionWithLand(Gear);
 if (State and gstCollision) <> 0 then
 begin
-if IceState = iceWaitCollision then
+if Health = iceWaitCollision then
 begin
-IceState := iceCollideWithGround;
+Health := iceCollideWithGround;
-IceTime := GameTicks;
+Power := GameTicks;
 end
 end
 else if (target.y >= cWaterLine) then
 begin
-if IceState = iceWaitCollision then
+if Health = iceWaitCollision then
 begin
-IceState := iceCollideWithWater;
+Health := iceCollideWithWater;
-IceTime := GameTicks;
+Power := GameTicks;
 end;
 end;
 if (abs(gX-Target.X) < 2) and (abs(gY-Target.Y) < 2) then
 begin
 X:= HHGear^.X;
 Y:= HHGear^.Y
 end;
-if (IceState = iceCollideWithGround) and ((GameTicks - IceTime) > groundFreezingTime) then
+if (Health = iceCollideWithGround) and ((GameTicks - Power) > groundFreezingTime) then
 begin
 FillRoundInLand(target.x, target.y, iceRadius, icePixel);
 landRect.x := min(max(target.x - iceRadius, 0), LAND_WIDTH - 1);
 landRect.y := min(max(target.y - iceRadius, 0), LAND_HEIGHT - 1);
 landRect.w := min(2*iceRadius, LAND_WIDTH - landRect.x - 1);
 landRect.h := min(2*iceRadius, LAND_HEIGHT - landRect.y - 1);
 UpdateLandTexture(landRect.x, landRect.w, landRect.y, landRect.h, true);
 // FillRoundInLandWithIce(Target.X, Target.Y, iceRadius);
 SetAllHHToActive;
-IceState := iceWaitCollision;
+Health := iceWaitCollision;
 end;
-if (IceState = iceCollideWithWater) and ((GameTicks - IceTime) > groundFreezingTime) then
+if (Health = iceCollideWithWater) and ((GameTicks - Power) > groundFreezingTime) then
 begin
 DrawIceBreak(Target.X, cWaterLine - iceHeight, iceRadius, iceHeight);
 SetAllHHToActive;
-IceState := iceWaitCollision;
+Health := iceWaitCollision;
 end;
 // freeze nearby hogs
 hogs := GearsNear(int2hwFloat(Target.X), int2hwFloat(Target.Y), gtHedgehog, Gear^.Radius*2);
 if hogs.size > 0 then
 for i:= 0 to hogs.size - 1 do
 if hogs.ar^[i] <> HHGear then
 if GameTicks mod 5 = 0 then
 begin
 hogs.ar^[i]^.Active:= true;
 if hogs.ar^[i]^.Hedgehog^.Effects[heFrozen] < 256 then
 hogs.ar^[i]^.Hedgehog^.Effects[heFrozen] := hogs.ar^[i]^.Hedgehog^.Effects[heFrozen] + 1
 else if hogs.ar^[i]^.Hedgehog^.Effects[heFrozen] = 256 then
 begin
 doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 300, CurrentHedgehog, EXPLAutoSound);
 DeleteGear(Gear)
 end;
 // ssssss he essssscaped
 if (Gear^.Timer > 250) and ((HHGear = nil) or
 (((abs(HHGear^.X.Round-Gear^.X.Round) + abs(HHGear^.Y.Round-Gear^.Y.Round) + 2) >  180) and
 (Distance(HHGear^.X-Gear^.X,HHGear^.Y-Gear^.Y) > _180))) then
 begin
 Gear^.State:= Gear^.State and (not gstTmpFlag);
 Gear^.Timer:= 0
 end;
 exit
 end;
 // Search out a new target, as target seek time has expired, target is dead, target is out of range, or we did not have a target
 if (HHGear = nil) or (Gear^.Timer = 0) or
 (((abs(HHGear^.X.Round-Gear^.X.Round) + abs(HHGear^.Y.Round-Gear^.Y.Round) + 2) >  Gear^.Angle) and
 (Distance(HHGear^.X-Gear^.X,HHGear^.Y-Gear^.Y) > int2hwFloat(Gear^.Angle)))
 then
 begin
 hogs := GearsNear(Gear^.X, Gear^.Y, gtHedgehog, Gear^.Angle);
 end;
 (*
 This didn't end up getting used, but, who knows, might be reasonable for javellin or something
 // Make the knife initial angle based on the hog attack angle, or is that too hard?
 procedure doStepKnife(Gear: PGear);
 var t,
 gx, gy, ga,  // gear x,y,angle
 lx, ly, la, // land x,y,angle
 ox, oy, // x,y offset
 w, h,   // wXh of clip area
 tx, ty  // tip position in sprite
 if Gear^.State and gstDrowning <> 0 then exit;
 with Gear^ do
 begin
 if CheckLandValue(gx, gy, lfLandMask) then
 begin
 t:= Angle + hwRound((hwAbs(dX)+hwAbs(dY)) * _10);
 if t < 0 then inc(t, 4096)
 else if 4095 < t then dec(t, 4096);
 Angle:= t;
 tx:=   0; ty:= 14
 end;
 4:  begin
 ox:= 29; oy:=  8;
 w:= 19;  h:= 19;
 tx:=  0; ty:= 17
 end;
 5:  begin
 ox:= 29; oy:=  32;
 w:= 15;  h:=  21;
 tx:=  0; ty:=  20
 end;
 6:  begin
 ox:= 51; oy:=   3;
 w:= 11;  h:=  23;
 tx:=  0; ty:=  22
 end;
 7:  begin
 ox:= 51; oy:=  34;
 w:=  7;  h:=  24;
 tx:=  0; ty:=  23
 end
 end;
 surf:= SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, RMask, GMask, BMask, AMask);
 copyToXYFromRect(SpritesData[sprKnife].Surface, surf, ox, oy, w, h, 0, 0);
 // try to make the knife hit point first
 lx := 0;
 ly := 0;
 else if Angle < 2048 then inc(Angle, 2048)
 end;
 AddFileLog('la: '+inttostr(la)+' ga: '+inttostr(ga)+' Angle: '+inttostr(Angle))
 end;
 case Angle div 1024 of
 0:  begin
 flipSurface(surf, true);
 flipSurface(surf, true);
 BlitImageAndGenerateCollisionInfo(gx-(w-tx), gy-(h-ty), w, surf)
 end;
 1:  begin

changeset 8795	b5b79a8f9354
parent 8793	43e106417a05
parent 8774	39754516eee6
child 8812	fdac638c6f9a