(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2010 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 doStepPerPixel(Gear: PGear; step: TGearStepProcedure; onlyCheckIfChanged: boolean);

var

    dX, dY, sX, sY: hwFloat;

    i, steps: LongWord;

    caller: TGearStepProcedure;

begin

    dX:= Gear^.dX;

    dY:= Gear^.dY;

    steps:= max(abs(hwRound(Gear^.X+dX)-hwRound(Gear^.X)), abs(hwRound(Gear^.Y+dY)-hwRound(Gear^.Y)));

    // Gear is still on the same Pixel it was before

    if steps < 1 then

    begin

        if onlyCheckIfChanged then

        begin

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

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

            EXIT;

        end

        else

            steps := 1;

    end;

    if steps > 1 then

    begin

        sX:= dX / steps;

        sY:= dY / steps;

    end

    else

    begin

        sX:= dX;

        sY:= dY;

    end;

    caller:= Gear^.doStep;

    for i:= 1 to steps do

    begin

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

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

        step(Gear);

        if (Gear^.doStep <> caller)

        or ((Gear^.State and gstCollision) <> 0)

        or ((Gear^.State and gstMoving) = 0) then

            break;

    end;

end;

procedure makeHogsWorry(x, y: hwFloat; r: LongInt);

var 

    gi: PGear;

    d: LongInt;

begin

    gi := GearsList;

    while gi <> nil do

    begin

        if (gi^.Kind = gtHedgehog) then

        begin

            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 doStepDrowningGear(Gear: PGear);

forward;

function CheckGearDrowning(Gear: PGear): boolean;

var 

    skipSpeed, skipAngle, skipDecay: hwFloat;

    i, maxDrops: LongInt;

    particle: PVisualGear;

    isSubmersible: boolean;

begin

    isSubmersible:= (Gear = CurrentHedgehog^.Gear) and (CurAmmoGear <> nil) and (CurAmmoGear^.AmmoType = amJetpack);

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

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

    begin

        skipSpeed := _0_25;

        skipAngle := _1_9;

        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;

            PlaySound(sndSkip)

        end

        else

        begin

            if not isSubmersible then

            begin

                CheckGearDrowning := true;

                Gear^.State := gstDrowning;

                Gear^.RenderTimer := false;

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

                    if Gear^.Kind = gtHedgehog then 

                        begin

                        if Gear^.Hedgehog^.Effects[heResurrectable] then

                            ResurrectHedgehog(Gear)

                        else

                            begin

                            Gear^.doStep := @doStepDrowningGear;

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

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

                            end

                        end

                    else

                        Gear^.doStep := @doStepDrowningGear

            end;

            if ((not isSubmersible) and (hwRound(Gear^.Y) < cWaterLine + 64 + Gear^.Radius)) or

               (isSubmersible and (hwRound(Gear^.Y) < cWaterLine + 2 + Gear^.Radius) and ((CurAmmoGear^.Pos = 0) and (CurAmmoGear^.dY < _0_01))) then

                // don't play splash if they are already way past the surface

                PlaySound(sndSplash)

        end;

        if ((cReducedQuality and rqPlainSplash) = 0) and 

           (((not isSubmersible) and (hwRound(Gear^.Y) < cWaterLine + 64 + Gear^.Radius)) or

             (isSubmersible and (hwRound(Gear^.Y) < cWaterLine + 2 + Gear^.Radius) and ((CurAmmoGear^.Pos = 0) and (CurAmmoGear^.dY < _0_01)))) then

        begin

            AddVisualGear(hwRound(Gear^.X), cWaterLine, 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), cWaterLine, vgtDroplet);

                if particle <> nil then

                begin

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

                    particle^.dY := particle^.dY - (Gear^.dY.QWordValue / 21474836480)

                end

            end

        end;

        if isSubmersible and (CurAmmoGear^.Pos = 0) then CurAmmoGear^.Pos := 1000

    end

    else

        CheckGearDrowning := false;

end;

procedure CheckCollision(Gear: PGear); inline;

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

        PlaySound(sndBump);

        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.QWordValue / 21474836480);

        end;

        if (Gear^.Invulnerable) then exit;

        //if _0_6 < Gear^.dY then

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

        //else

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

        ApplyDamage(Gear, dmg, dsFall);

    end

end;

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

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

procedure CalcRotationDirAngle(Gear: PGear);

var 

    dAngle: real;

begin

    dAngle := (Gear^.dX.QWordValue + 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);

var 

    isFalling: boolean;

    //tmp: QWord;

    tdX, tdY: hwFloat;

    collV, collH: LongInt;

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^.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 Gear^.dY.isNegative then

    begin

        isFalling := true;

        if TestCollisionYwithGear(Gear, -1) then

        begin

            collV := -1;

            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) then collV := 1;

    end

    else if TestCollisionYwithGear(Gear, 1) then

        begin

            collV := 1;

            isFalling := false;

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

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

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

        end

    else

    begin

        isFalling := true;

        if (Gear^.AdvBounce=1) and not Gear^.dY.isNegative and TestCollisionYwithGear(Gear, -1) then

            collV := -1;

    end;

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

    begin

        collH := hwSign(Gear^.dX);

        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;

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

        begin

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

        if (GameFlags and gfMoreWind) <> 0 then Gear^.dX := Gear^.dX + cWindSpeed * _16 / max(12,sqr(Gear^.Radius))

        end;

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

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

    CheckGearDrowning(Gear);

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

    if ((Gear^.dX.QWordValue + Gear^.dY.QWordValue) < _0_02.QWordValue) and

       (not isFalling) then

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

    else

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

    if (Gear^.nImpactSounds > 0) then

        if ((Gear^.Damage <> 0) or ((Gear^.State and (gstCollision or gstMoving)) = (gstCollision or

           gstMoving))) 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: hwFloat;

    Fire: PGear;

    vg: PVisualGear;

begin

    AllInactive := false;

    doStepFallingGear(Gear);

    dec(Gear^.Timer);

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

        case Gear^.Kind of 

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

        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, 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 

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

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

            gtClusterBomb: 

                begin

                    x := hwRound(Gear^.X);

                    y := hwRound(Gear^.Y);

                    doMakeExplosion(x, y, 20, EXPLAutoSound);

                    for i:= 0 to 4 do

                        begin

                        dX := rndSign(GetRandom * _0_1) + Gear^.dX / 5;

                        dY := (GetRandom - _3) * _0_08;

                        AddGear(x, y, gtCluster, 0, dX, dY, 25);

                        end

                end;

            gtWatermelon: 

                begin

                x := hwRound(Gear^.X);

                y := hwRound(Gear^.Y);

                doMakeExplosion(x, y, 75, EXPLAutoSound);

                for i:= 0 to 5 do

                    begin

                    dX := rndSign(GetRandom * _0_1) + Gear^.dX / 5;

                    dY := (GetRandom - _1_5) * _0_3;

                    AddGear(x, y, gtMelonPiece, 0, dX, dY, 75)^.DirAngle := i * 60;

                    end

                end;

            gtHellishBomb: 

                begin

                x := hwRound(Gear^.X);

                y := hwRound(Gear^.Y);

                doMakeExplosion(x, 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(x, y, gtFlame, 0, dX, dY, 0);

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

                    Fire := AddGear(x, y, gtFlame, 0, dX, -dY, 0);

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

                    end

                end;

            gtGasBomb:

                begin

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

                for i:= 0 to 2 do

                    begin

                    x:= GetRandom(60);

                    y:= GetRandom(40);

                    AddGear(hwRound(Gear^.X) - 30 + x, hwRound(Gear^.Y) - 20 + y, gtPoisonCloud, 0, _0, _0, 0);

                    end

                end;

        end;

    DeleteGear(Gear);

    exit

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 

    i, gX, gY: LongInt;

    dX, dY: hwFloat;

    Fire: PGear;

begin

    AllInactive := false;

    doStepFallingGear(Gear);

    CalcRotationDirAngle(Gear);

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

    begin

        PlaySound(sndMolotov);

        gX := hwRound(Gear^.X);

        gY := hwRound(Gear^.Y);

        //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(gX, gY, gtFlame, 0, dX, dY, 0);

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

            Fire := AddGear(gX, gY, gtFlame, 0, dX, -dY, 0);

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

            Fire := AddGear(gX, gY, gtFlame, 0, -dX, dY, 0);

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

            Fire := AddGear(gX, gY, gtFlame, 0, -dX, -dY, 0);