(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2009 Andrey Korotaev <unC0Rr@gmail.com>

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; version 2 of the License

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA

 *)

procedure doStepDrowningGear(Gear: PGear); forward;

function CheckGearDrowning(Gear: PGear): boolean;

var skipSpeed, skipAngle, skipDecay: hwFloat;

begin

// probably needs tweaking. might need to be in a case statement based upon gear type

//(not Gear^.dY.isNegative) and  this should not be necessary

if cWaterLine < hwRound(Gear^.Y) + Gear^.Radius then

    begin

    skipSpeed:= _0_25;  // was 0.36 - couldn't manage baseball bat. Tiy's build is 0.36...

    skipAngle:= _1 + _0_9;  // these should perhaps also be constants, once work out what proper values are

    skipDecay:= _0_87;  // this could perhaps be a tiny bit higher.

    if  (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > skipSpeed) and

        (hwAbs(Gear^.dX) > skipAngle * hwAbs(Gear^.dY)) then

       begin

       Gear^.dY.isNegative:= true;

       Gear^.dY:= Gear^.dY * skipDecay;

       Gear^.dX:= Gear^.dX * skipDecay;

       CheckGearDrowning:= false

       end

    else

        begin

        CheckGearDrowning:= true;

        Gear^.State:= gstDrowning;

        Gear^.doStep:= @doStepDrowningGear;

        end;

    PlaySound(sndSplash, false, nil)

    end

    else

	CheckGearDrowning:= false

end;

procedure CheckCollision(Gear: PGear);

begin

if TestCollisionXwithGear(Gear, hwSign(Gear^.X)) or TestCollisionYwithGear(Gear, hwSign(Gear^.Y))

	then Gear^.State:= Gear^.State or      gstCollision

	else Gear^.State:= Gear^.State and not gstCollision

end;

procedure CheckHHDamage(Gear: PGear);

var dmg: Longword;

begin

if(Gear^.Invulnerable) then exit;

if _0_4 < Gear^.dY then

	begin

	if _0_6 < Gear^.dY then

		PlaySound(sndOw4, false, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack)

	else

		PlaySound(sndOw1, false, PHedgehog(Gear^.Hedgehog)^.Team^.voicepack);

	dmg:= modifyDamage(1 + hwRound((hwAbs(Gear^.dY) - _0_4) * 70));

    ApplyDamage(Gear, dmg);

	end

end;

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

procedure CalcRotationDirAngle(Gear: PGear);

var dAngle: real;

begin

dAngle:= (hwAbs(Gear^.dX) + hwAbs(Gear^.dY)).QWordValue / $80000000;

if not Gear^.dX.isNegative then

	Gear^.DirAngle:= Gear^.DirAngle + dAngle

else

	Gear^.DirAngle:= Gear^.DirAngle - dAngle;

if Gear^.DirAngle < 0 then Gear^.DirAngle:= Gear^.DirAngle + 360

else if 360 < Gear^.DirAngle then Gear^.DirAngle:= Gear^.DirAngle - 360

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepDrowningGear(Gear: PGear);

begin

AllInactive:= false;

Gear^.Y:= Gear^.Y + cDrownSpeed;

if hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater then DeleteGear(Gear)

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepFallingGear(Gear: PGear);

var isFalling: boolean;

begin

Gear^.State:= Gear^.State and not gstCollision;

if Gear^.dY.isNegative then

	begin

	isFalling:= true;

	if TestCollisionYwithGear(Gear, -1) then

		begin

		Gear^.dX:=   Gear^.dX * Gear^.Friction;

		Gear^.dY:= - Gear^.dY * Gear^.Elasticity;

		Gear^.State:= Gear^.State or gstCollision

		end

	end else

	if TestCollisionYwithGear(Gear, 1) then

		begin

		isFalling:= false;

		Gear^.dX:=   Gear^.dX * Gear^.Friction;

		Gear^.dY:= - Gear^.dY * Gear^.Elasticity;

		Gear^.State:= Gear^.State or gstCollision

		end else isFalling:= true;

if TestCollisionXwithGear(Gear, hwSign(Gear^.dX)) then

	begin

	Gear^.dX:= - Gear^.dX * Gear^.Elasticity;

	Gear^.dY:=   Gear^.dY * Gear^.Elasticity;

	Gear^.State:= Gear^.State or gstCollision

	end;

if isFalling then Gear^.dY:= Gear^.dY + cGravity;

Gear^.X:= Gear^.X + Gear^.dX;

Gear^.Y:= Gear^.Y + Gear^.dY;

CheckGearDrowning(Gear);

if (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) < _0_0002) and

	(not isFalling) then

	Gear^.State:= Gear^.State and not gstMoving

else

	Gear^.State:= Gear^.State or      gstMoving

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepBomb(Gear: PGear);

var i: LongInt;

    dX, dY: hwFloat;

begin

AllInactive:= false;

doStepFallingGear(Gear);

dec(Gear^.Timer);

if Gear^.Timer = 0 then

	begin

	case Gear^.Kind of

		gtAmmo_Bomb: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);

		     gtBall: doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 40, EXPLAutoSound);

		gtClusterBomb: begin

				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 20, EXPLAutoSound);

				for i:= 0 to 4 do

					begin

					dX:= rndSign(GetRandom * _0_1);

					dY:= (GetRandom - _3) * _0_08;

					AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtCluster, 0, dX, dY, 25);

					end

				end;

		gtWatermelon: begin

				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 75, EXPLAutoSound);

				for i:= 0 to 5 do

					begin

					dX:= rndSign(GetRandom * _0_1);

					dY:= (GetRandom - _1_5) * _0_3;

					AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtMelonPiece, 0, dX, dY, 75)^.DirAngle:= i * 60;

					end

				end;

		gtHellishBomb: begin

				doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 90, EXPLAutoSound);

				for i:= 0 to 127 do

					begin

					dX:= AngleCos(i * 16) * _0_5 * (GetRandom + _1);

					dY:= AngleSin(i * 16) * _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

				end;

		end;

	DeleteGear(Gear);

	exit

	end;

CalcRotationDirAngle(Gear);

if Gear^.Kind = gtHellishBomb then

	begin

	if Gear^.Timer = 3000 then PlaySound(sndHellish, false, nil);

	if (GameTicks and $3F) = 0 then

		if (Gear^.State and gstCollision) = 0 then

			AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtEvilTrace, 0, _0, _0, 0);

	end;

if (Gear^.State and (gstCollision or gstMoving)) = (gstCollision or gstMoving) then

	if (hwAbs(Gear^.dX) > _0_1) or

	   (hwAbs(Gear^.dY) > _0_1) then

		PlaySound(sndGrenadeImpact, false, nil)

end;

procedure doStepWatermelon(Gear: PGear);

begin

AllInactive:= false;

PlaySound(sndMelon, false, nil);

Gear^.doStep:= @doStepBomb

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, EXPLAutoSound);

	DeleteGear(Gear);

	exit

	end;

if Gear^.Kind = gtMelonPiece then

	CalcRotationDirAngle(Gear)

else

	if (GameTicks and $1F) = 0 then

		AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepGrenade(Gear: PGear);

begin

AllInactive:= false;

Gear^.dX:= Gear^.dX + cWindSpeed;

doStepFallingGear(Gear);

if (Gear^.State and gstCollision) <> 0 then

	begin

	doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);

	DeleteGear(Gear);

	exit

	end;

if (GameTicks and $3F) = 0 then

	AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtSmokeTrace, 0, _0, _0, 0)

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepHealthTagWork(Gear: PGear);

begin

if Gear^.Kind = gtHealthTag then

	AllInactive:= false;

dec(Gear^.Timer);

Gear^.Y:= Gear^.Y + Gear^.dY;

if Gear^.Timer = 0 then

	begin

	if (Gear^.Kind = gtHealthTag) and (PHedgehog(Gear^.Hedgehog)^.Gear <> nil) then

		PHedgehog(Gear^.Hedgehog)^.Gear^.Active:= true; // to let current hh die

	DeleteGear(Gear)

	end

end;

procedure doStepHealthTagWorkUnderWater(Gear: PGear);

begin

AllInactive:= false;

Gear^.Y:= Gear^.Y - _0_08;

if hwRound(Gear^.Y) < cWaterLine + 10 then

	DeleteGear(Gear)

end;

procedure doStepHealthTag(Gear: PGear);

var s: shortstring;

begin

AllInactive:= false;

Gear^.dY:= -_0_08;

str(Gear^.State, s);

Gear^.Tex:= RenderStringTex(s, PHedgehog(Gear^.Hedgehog)^.Team^.Clan^.Color, fnt16);

if hwRound(Gear^.Y) < cWaterLine then

	Gear^.doStep:= @doStepHealthTagWork

else

	Gear^.doStep:= @doStepHealthTagWorkUnderWater;

Gear^.Y:= Gear^.Y - int2hwFloat(Gear^.Tex^.h)

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepGrave(Gear: PGear);

begin

AllInactive:= false;

if Gear^.dY.isNegative then

   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(sndGraveImpact, false, nil)

      end;

Gear^.Y:= Gear^.Y + Gear^.dY;

CheckGearDrowning(Gear);

Gear^.dY:= Gear^.dY + cGravity

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepUFOWork(Gear: PGear);

var t: hwFloat;

    y: LongInt;

begin

AllInactive:= false;

t:= Distance(Gear^.dX, Gear^.dY);

Gear^.dX:= Gear^.Elasticity * (Gear^.dX + _0_000004 * (TargetPoint.X - hwRound(Gear^.X)));

Gear^.dY:= Gear^.Elasticity * (Gear^.dY + _0_000004 * (TargetPoint.Y - hwRound(Gear^.Y)));

t:= t / Distance(Gear^.dX, Gear^.dY);

Gear^.dX:= Gear^.dX * t;

Gear^.dY:= Gear^.dY * t;

Gear^.X:= Gear^.X + Gear^.dX;

Gear^.Y:= Gear^.Y + Gear^.dY;

if (GameTicks and $3F) = 0 then

   begin

   y:= hwRound(Gear^.Y);

   if y + Gear^.Radius < cWaterLine then

      AddGear(hwRound(Gear^.X), y, gtSmokeTrace, 0, _0, _0, 0);

   end;

CheckCollision(Gear);

dec(Gear^.Timer);

if ((Gear^.State and gstCollision) <> 0) or (Gear^.Timer = 0) then

   begin

   StopSound(sndUFO);

   doMakeExplosion(hwRound(Gear^.X), hwRound(Gear^.Y), 50, EXPLAutoSound);

   DeleteGear(Gear);

   end;

end;

procedure doStepUFO(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, EXPLAutoSound);

   DeleteGear(Gear);

   exit

   end;

dec(Gear^.Timer);

if Gear^.Timer = 0 then

   begin

   PlaySound(sndUFO, true, nil);

   Gear^.Timer:= 5000;

   Gear^.doStep:= @doStepUFOWork

   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;

begin

AllInactive:= false;

if ((Gear^.State and gstAnimation) = 0) then

	begin

	dec(Gear^.Timer);

	if Gear^.Timer = 0 then

		begin

		PlaySound(sndShotgunFire, false, nil);

		Gear^.State:= Gear^.State or gstAnimation

		end;

	exit

	end

	else inc(Gear^.Timer);

i:= 200;

repeat

Gear^.X:= Gear^.X + Gear^.dX;

Gear^.Y:= Gear^.Y + Gear^.dY;

CheckCollision(Gear);

if (Gear^.State and gstCollision) <> 0 then

	begin

	Gear^.X:= Gear^.X + Gear^.dX * 8;

	Gear^.Y:= Gear^.Y + Gear^.dY * 8;

	ShotgunShot(Gear);

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

	Gear^.doStep:= @doStepShotIdle

end;

////////////////////////////////////////////////////////////////////////////////

procedure doStepBulletWork(Gear: PGear);

var i, x, y: LongWord;

    oX, oY: hwFloat;

begin

AllInactive:= false;

inc(Gear^.Timer);

i:= 80;

oX:= Gear^.X;

oY:= Gear^.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 Gear^.Damage > 5 then

      if Gear^.Ammo^.AmmoType = amDEagle then

          AmmoShove(Gear, 7, 20)

      else

          AmmoShove(Gear, Gear^.Timer, 20);

  dec(i)

until (i = 0) or (Gear^.Damage > Gear^.Health);

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^.Health <= 0)

	or (hwRound(Gear^.X) and LAND_WIDTH_MASK <> 0)

	or (hwRound(Gear^.Y) and LAND_HEIGHT_MASK <> 0) then

    begin

    if (GameFlags and gfLaserSight) = 0 then cLaserSighting:= false;

    if (Gear^.Ammo^.NumPerTurn <= CurrentHedgehog^.AttacksNum) and

       ((GameFlags and gfArtillery) = 0) then cArtillery:= false;

	Gear^.doStep:= @doStepShotIdle

    end;

end;

procedure doStepDEagleShot(Gear: PGear);

begin

PlaySound(sndGun, false, nil);

Gear^.doStep:= @doStepBulletWork

end;

procedure doStepSniperRifleShot(Gear: PGear);

var HHGear: PGear;

begin

cArtillery:= true;

HHGear:=PHedgehog(Gear^.Hedgehog)^.Gear;

HHGear^.State:= HHGear^.State or gstNotKickable;

HedgehogChAngle(HHGear);

if not cLaserSighting then // game doesn't have default laser sight. turn it on and give them a chance to aim

    begin

    cLaserSighting:= true;

    HHGear^.Message:= 0;

    dec(HHGear^.Angle,32)

    end;

if (HHGear^.Message and gm_Attack) <> 0 then

    begin

	Gear^.State:= Gear^.State or gstAnimation;

    Gear^.dX:= SignAs(AngleSin(HHGear^.Angle), HHGear^.dX) * _0_5;

    Gear^.dY:= -AngleCos(HHGear^.Angle) * _0_5;