(*

 * 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 makeHogsWorry(x, y: hwFloat; r: LongInt);

var gi: PGear;

     d: LongInt;

begin

    gi:= GearsList;

    while gi <> nil do

        begin

        d:= r - hwRound(Distance(gi^.X - x, gi^.Y - y));

        if (d > 1) and (gi^.Kind = gtHedgehog) and not gi^.Invulnerable and (GetRandom(2) = 0) then

            begin

            if (CurrentHedgehog^.Gear = gi) then

                PlaySound(sndOops, PHedgehog(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, PHedgehog(gi^.Hedgehog)^.Team^.voicepack)

                else

                    PlaySound(sndUhOh, PHedgehog(gi^.Hedgehog)^.Team^.voicepack);

                end;

            end;

        gi:= gi^.NextGear

        end;

end;

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

procedure doStepDrowningGear(Gear: PGear); forward;

function CheckGearDrowning(Gear: PGear): boolean;

var skipSpeed, skipAngle, skipDecay: hwFloat;

    i, maxDrops: LongInt;

    particle: PVisualGear;

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^.RenderTimer:= false;

        if (Gear^.Kind <> gtSniperRifleShot) and (Gear^.Kind <> gtShotgunShot) and (Gear^.Kind <> gtDEagleShot) then

          Gear^.doStep:= @doStepDrowningGear;

        if Gear^.Kind = gtHedgehog then

            begin

            Gear^.State:= Gear^.State and (not gstHHDriven);

            AddCaption(Format(GetEventString(eidDrowned), PHedgehog(Gear^.Hedgehog)^.Name), cWhiteColor, capgrpMessage);

            end

        end;

    PlaySound(sndSplash);

    if not cReducedQuality then 

        begin

        AddVisualGear(hwRound(Gear^.X), LAND_HEIGHT, vgtSplash);

        maxDrops := (Gear^.Radius div 2) + hwRound(Gear^.dX * Gear^.Radius * 2) + hwRound(Gear^.dY * Gear^.Radius * 2);

        for i:= max(maxDrops div 3, min(32, Random(maxDrops))) downto 0 do 

            begin

            particle := AddVisualGear(hwRound(Gear^.X) - 3 + Random(6), LAND_HEIGHT, vgtDroplet);

            if particle <> nil then

                begin

                particle^.dX := particle^.dX - (Gear^.dX / 10);

                particle^.dY := particle^.dY - (Gear^.dY / 5)

                end

            end

        end;

    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;

    i: LongInt;

    particle: PVisualGear;

begin

if _0_4 < Gear^.dY then

    begin

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

    if dmg < 1 then exit;

    for i:= min(12, (3 + dmg div 10)) downto 0 do begin

        particle := AddVisualGear(hwRound(Gear^.X) - 5 + Random(10), hwRound(Gear^.Y) + 12, vgtDust);

        if particle <> nil then particle^.dX := particle^.dX + (Gear^.dX / 5);

        end;

    if(Gear^.Invulnerable) then exit;

    if _0_6 < Gear^.dY then

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

    else

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

    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;

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

if (cWaterOpacity > $FE) or (hwRound(Gear^.Y) > Gear^.Radius + cWaterLine + cVisibleWater) then DeleteGear(Gear);

// Create some bubbles (0.5% might be better but causes too few bubbles sometimes)

if (cWaterOpacity < $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)

end;

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

procedure doStepFallingGear(Gear: PGear);

    tmp: QWord;

    tdX, tdY: hwFloat;

begin

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

tdX:= Gear^.dX;

tdY:= Gear^.dY;

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;

    Fire: PGear;

begin

AllInactive:= false;

doStepFallingGear(Gear);

dec(Gear^.Timer);

if Gear^.Timer = 1000 then // might need adjustments

    case Gear^.Kind of

        gtAmmo_Bomb: 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);

    end;

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

                    Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);

                    if i mod 2 = 0 then Fire^.State:= Fire^.State or gsttmpFlag;

                    Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);

                    if i mod 2 <> 0 then Fire^.State:= Fire^.State or gsttmpFlag;

                    end

                end;

        end;

    DeleteGear(Gear);

    exit

    end;

CalcRotationDirAngle(Gear);

if Gear^.Kind = gtHellishBomb then

    begin

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

    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)

end;

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

procedure doStepMolotov(Gear: PGear);

var i: LongInt;

    dX, dY: hwFloat;

    Fire: PGear;

begin

    AllInactive:= false;

    doStepFallingGear(Gear);

    CalcRotationDirAngle(Gear);

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

        PlaySound(sndMolotov);

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

        for i:= 0 to 20 do begin

                dX:= AngleCos(i * 2) * ((_0_1*(i div 5))) * (GetRandom + _1);

                dY:= AngleSin(i * 8) * _0_5 * (GetRandom + _1);

                Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, dY, 0);

                Fire^.State:= Fire^.State or gsttmpFlag;

                Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, dX, -dY, 0);

                Fire^.State:= Fire^.State or gsttmpFlag;

                Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, dY, 0);

                Fire^.State:= Fire^.State or gsttmpFlag;

                Fire:= AddGear(hwRound(Gear^.X), hwRound(Gear^.Y), gtFlame, 0, -dX, -dY, 0);

                Fire^.State:= Fire^.State or gsttmpFlag;

        end;

        DeleteGear(Gear);

        exit

    end;

end;

procedure doStepWatermelon(Gear: PGear);

begin

AllInactive:= false;

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)

      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(Gear^.SoundChannel);

   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;