(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2015 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 *)

(*

 * This file contains the step handlers for gears.

 *

 * Important: Since gears change the course of the game, calculations that

 *            lead to different results for different clients/players/machines

 *            should NOT occur!

 *            Use safe functions and data types! (e.g. GetRandom() and hwFloat)

 *)

 {$INCLUDE "options.inc"}

unit uGearsHandlersMess;

interface

uses uTypes, uFloat;

procedure doStepPerPixel(Gear: PGear; step: TGearStepProcedure; onlyCheckIfChanged: boolean);

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

procedure HideHog(HH: PHedgehog);

procedure doStepDrowningGear(Gear: PGear);

procedure doStepFallingGear(Gear: PGear);

procedure doStepBomb(Gear: PGear);

procedure doStepMolotov(Gear: PGear);

procedure doStepCluster(Gear: PGear);

procedure doStepShell(Gear: PGear);

procedure doStepSnowball(Gear: PGear);

procedure doStepSnowflake(Gear: PGear);

procedure doStepGrave(Gear: PGear);

procedure doStepBeeWork(Gear: PGear);

procedure doStepBee(Gear: PGear);

procedure doStepShotIdle(Gear: PGear);

procedure doStepShotgunShot(Gear: PGear);

procedure spawnBulletTrail(Bullet: PGear; bulletX, bulletY: hwFloat; fadeIn: Boolean);

procedure doStepBulletWork(Gear: PGear);

procedure doStepDEagleShot(Gear: PGear);

procedure doStepSniperRifleShot(Gear: PGear);

procedure doStepActionTimer(Gear: PGear);

procedure doStepPickHammerWork(Gear: PGear);

procedure doStepPickHammer(Gear: PGear);

procedure doStepBlowTorchWork(Gear: PGear);

procedure doStepBlowTorch(Gear: PGear);

procedure doStepMine(Gear: PGear);

procedure doStepAirMine(Gear: PGear);

procedure doStepSMine(Gear: PGear);

procedure doStepDynamite(Gear: PGear);

procedure doStepRollingBarrel(Gear: PGear);

procedure doStepCase(Gear: PGear);

procedure doStepTarget(Gear: PGear);

procedure doStepIdle(Gear: PGear);

procedure doStepShover(Gear: PGear);

procedure doStepWhip(Gear: PGear);

procedure doStepFlame(Gear: PGear);

procedure doStepFirePunchWork(Gear: PGear);

procedure doStepFirePunch(Gear: PGear);

procedure doStepParachuteWork(Gear: PGear);

procedure doStepParachute(Gear: PGear);

procedure doStepAirAttackWork(Gear: PGear);

procedure doStepAirAttack(Gear: PGear);

procedure doStepAirBomb(Gear: PGear);

procedure doStepGirder(Gear: PGear);

procedure doStepTeleportAfter(Gear: PGear);

procedure doStepTeleportAnim(Gear: PGear);

procedure doStepTeleport(Gear: PGear);

procedure doStepSwitcherWork(Gear: PGear);

procedure doStepSwitcher(Gear: PGear);

procedure doStepMortar(Gear: PGear);

procedure doStepKamikazeWork(Gear: PGear);

procedure doStepKamikazeIdle(Gear: PGear);

procedure doStepKamikaze(Gear: PGear);

procedure doStepCakeExpl(Gear: PGear);

procedure doStepCakeDown(Gear: PGear);

procedure doStepCakeWalk(Gear: PGear);

procedure doStepCakeUp(Gear: PGear);

procedure doStepCakeFall(Gear: PGear);

procedure doStepCake(Gear: PGear);

procedure doStepSeductionWork(Gear: PGear);

procedure doStepSeductionWear(Gear: PGear);

procedure doStepSeduction(Gear: PGear);

procedure doStepWaterUp(Gear: PGear);

procedure doStepDrillDrilling(Gear: PGear);

procedure doStepDrill(Gear: PGear);

procedure doStepBallgunWork(Gear: PGear);

procedure doStepBallgun(Gear: PGear);

procedure doStepRCPlaneWork(Gear: PGear);

procedure doStepRCPlane(Gear: PGear);

procedure doStepJetpackWork(Gear: PGear);

procedure doStepJetpack(Gear: PGear);

procedure doStepBirdyDisappear(Gear: PGear);

procedure doStepBirdyFly(Gear: PGear);

procedure doStepBirdyDescend(Gear: PGear);

procedure doStepBirdyAppear(Gear: PGear);

procedure doStepBirdy(Gear: PGear);

procedure doStepEggWork(Gear: PGear);

procedure doPortalColorSwitch();

procedure doStepPortal(Gear: PGear);

procedure loadNewPortalBall(oldPortal: PGear; destroyGear: Boolean);

procedure doStepMovingPortal_real(Gear: PGear);

procedure doStepMovingPortal(Gear: PGear);

procedure doStepPortalShot(newPortal: PGear);

procedure doStepPiano(Gear: PGear);

procedure doStepPianoWork(Gear: PGear);

procedure doStepSineGunShotWork(Gear: PGear);

procedure doStepSineGunShot(Gear: PGear);

procedure doStepFlamethrowerWork(Gear: PGear);

procedure doStepFlamethrower(Gear: PGear);

procedure doStepLandGunWork(Gear: PGear);

procedure doStepLandGun(Gear: PGear);

procedure doStepPoisonCloud(Gear: PGear);

procedure doStepHammer(Gear: PGear);

procedure doStepHammerHitWork(Gear: PGear);

procedure doStepHammerHit(Gear: PGear);

procedure doStepResurrectorWork(Gear: PGear);

procedure doStepResurrector(Gear: PGear);

procedure doStepNapalmBomb(Gear: PGear);

procedure doStepTardisWarp(Gear: PGear);

procedure doStepTardis(Gear: PGear);

procedure updateFuel(Gear: PGear);

procedure updateTarget(Gear:PGear; newX, newY:HWFloat);

procedure doStepIceGun(Gear: PGear);

procedure doStepAddAmmo(Gear: PGear);

procedure doStepGenericFaller(Gear: PGear);

procedure doStepCreeper(Gear: PGear);

procedure doStepKnife(Gear: PGear);

procedure doStepMinigunWork(Gear: PGear);

procedure doStepMinigun(Gear: PGear);

procedure doStepMinigunBullet(Gear: PGear);

procedure ResetSentryState(Gear: PGear; state, timer: LongInt);

procedure doStepSentryDeploy(Gear: PGear);

var

    upd: Longword;

    snowLeft,snowRight: LongInt;

implementation

uses uConsts, uVariables, uVisualGearsList, uRandom, uCollisions, uGearsList, uUtils, uSound

    , SDLh, uScript, uGearsHedgehog, uGearsUtils, uIO, uCaptions, uLandGraphics

    , uGearsHandlers, uTextures, uRenderUtils, uAmmos, uTeams, uLandTexture

    , uStore, uAI, uStats, uLocale;

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; gearType: TGearType);

var

    gi: PGear;

    d: LongInt;

    grenadeTaunt: boolean;

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 (gi^.Hedgehog^.Effects[heInvulnerable] = 0) and (GetRandom(2) = 0) then

                begin

                if (CurrentHedgehog^.Gear = gi) then

                    if (CurrentHedgehog^.Gear^.FlightTime = 0) then

                        case random(4) of

                        0: PlaySoundV(sndWhatThe, gi^.Hedgehog^.Team^.voicepack);

                        1: PlaySoundV(sndOops, gi^.Hedgehog^.Team^.voicepack);

                        2: PlaySoundV(sndRunAway, gi^.Hedgehog^.Team^.voicepack);

                        3: PlaySoundV(sndRunAway, gi^.Hedgehog^.Team^.voicepack);

                        end

                    else

                        if random(4) = 0 then

                           PlaySoundV(sndWhatThe, gi^.Hedgehog^.Team^.voicepack)

                        else

                           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;

                    grenadeTaunt:= false;

                    if (gearType = gtGrenade) then

                        grenadeTaunt:= random(2) = 0;

                    if grenadeTaunt then

                        PlaySoundV(sndGrenade, gi^.Hedgehog^.Team^.voicepack)

                    else

                        if d > r div 2 then

                            if random(3) = 0 then

                                PlaySoundV(sndWhatThe, gi^.Hedgehog^.Team^.voicepack)

                            else

                                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;

        State:= State and (not (gstHHDriven or gstAttacking or gstAttacked));

        Message := Message and (not gmAttack);

    end;

    HH^.GearHidden:= HH^.Gear;

    HH^.Gear:= nil;

    AddVisualGear(0, 0, vgtTeamHealthSorter);

end;

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

procedure doStepDrowningGear(Gear: PGear);

var i, d, bubbleX, bubbleY: LongInt;

    bubble: PVisualGear;

begin

if Gear^.Timer = 0 then

    begin

    d:= 2 * Gear^.Radius;

    for i:= (Gear^.Radius * Gear^.Radius) div 4 downto 0 do

        begin

        bubble := AddVisualGear(hwRound(Gear^.X) - Gear^.Radius + random(d), hwRound(Gear^.Y) - Gear^.Radius + random(d), vgtBubble);

        if bubble <> nil then

            bubble^.dY:= 0.1 + random(20)/10;

        end;

    DeleteGear(Gear);

    exit;

    end;

AllInactive := false;

dec(Gear^.Timer);

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

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

    begin

    if leftX + Gear^.Radius > hwRound(Gear^.X) then

        Gear^.X := Gear^.X - cDrownSpeed

    else

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

    end

else

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

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

if (Gear^.Kind = gtHedgehog) and (Gear^.dX.isNegative) then

    bubbleX:= hwRound(Gear^.X) - Gear^.Radius

else

    bubbleX:= hwRound(Gear^.X) + Gear^.Radius;

bubbleY:= hwRound(Gear^.Y) - Gear^.Radius;

if ((not SuddenDeathDmg and (WaterOpacity < $FF))

or (SuddenDeathDmg and (SDWaterOpacity < $FF))) and ((GameTicks and $1F) = 0) then

    if (Gear^.Kind = gtHedgehog) and (Random(4) = 0) then

        AddVisualGear(bubbleX, bubbleY, vgtBubble)

else if Random(12) = 0 then

        AddVisualGear(bubbleX, bubbleY, vgtBubble);

// Insta-delete gear and skip drowning animation if water is 100% opaque

if (not SuddenDeathDmg and (WaterOpacity > $FE))

or (SuddenDeathDmg and (SDWaterOpacity > $FE)) then

    begin

    // Teleport gear to a suitable position for the damage tag in the water

    if (WorldEdge = weSea) and (hwRound(Gear^.X) - Gear^.Radius < leftX) then

        begin

        if (hwRound(Gear^.X) - Gear^.Radius > leftX - 90) then

            Gear^.X := Gear^.X - _90

        end

    else if (WorldEdge = weSea) and (hwRound(Gear^.X) + Gear^.Radius > rightX) then

        begin

        if (hwRound(Gear^.X) - Gear^.Radius < rightX + 90) then

            Gear^.X := Gear^.X + _90

        end

    else

        Gear^.Y := int2hwFloat(Gear^.Radius + cWaterLine + cVisibleWater);

    DeleteGear(Gear);

    exit;

    end;

// Delete gear normally if it is outside of visible range.

// But first determine size tolerance for big gears to make sure the gear is REALLY out of range.

if Gear^.Kind = gtPiano then

    d:= SpritesData[sprPiano].height

else if Gear^.Kind = gtRCPlane then

    d:= SpritesData[sprPlane].width

else if Gear^.Kind = gtKnife then

    d:= SpritesData[sprKnife].height

else if Gear^.Kind = gtDynamite then

    d:= SpritesData[sprDynamite].height

else if Gear^.Kind = gtSnowball then

    d:= SpritesData[sprSnowball].height

else

    d:= Gear^.Radius * 2;

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

    DeleteGear(Gear);

end;

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

procedure doStepFallingGear(Gear: PGear);

var

    isFalling: boolean;

    tX, tdX, tdY: hwFloat;

    collV, collH, gX, gY: LongInt;

    land, xland: word;

begin

    tX:= Gear^.X;

    gX:= hwRound(Gear^.X);

    gY:= hwRound(Gear^.Y);

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

    // World wrap

    if (Gear^.Kind <> gtGenericFaller) and WorldWrap(Gear) and (WorldEdge = weWrap) and

      ((TestCollisionXwithGear(Gear, 1) <> 0) or (TestCollisionXwithGear(Gear, -1) <> 0))  then

        begin

        // Collision with land that *just* behind the other side of the world wrap edge

        if (not Gear^.Sticky) then

            begin

            Gear^.X:= tX;

            Gear^.dX.isNegative:= (gX > leftX + Gear^.Radius*2);

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

            end;

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

        end;

    // clip velocity at 2 - 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;

    if (Gear^.State and gstSubmersible <> 0) and CheckCoordInWater(gX, gY) then

        begin

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

        Gear^.dY:= Gear^.dY * _0_999

        end;

    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 (gX < min(LAND_WIDTH div -2, -2048))

    or (gX > max(LAND_WIDTH * 3 div 2, 6144)) then

        Gear^.Message := Gear^.Message or gmDestroy;

    if Gear^.dY.isNegative then

        begin

        land:= TestCollisionYwithGear(Gear, -1);

        isFalling := land = 0;

        if land <> 0 then

            begin

            collV := -1;

            if land and lfIce <> 0 then

                 Gear^.dX := Gear^.dX * (_0_9 + Gear^.Friction * _0_1)

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

            if (Gear^.AdvBounce = 0) or (land and lfBouncy = 0) then

                 begin

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

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

                 end

            else Gear^.dY := - Gear^.dY * cElastic

            end

        else if Gear^.AdvBounce = 1 then

            begin

            land:= TestCollisionYwithGear(Gear, 1);

            if land <> 0 then collV := 1

            end

        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;

            if (Gear^.AdvBounce = 0) or (land and lfBouncy = 0) then

                 begin

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

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

                 end

            else Gear^.dY := - Gear^.dY * cElastic

            end

        else

            begin

            isFalling := true;

            if Gear^.AdvBounce = 1 then

                begin

                land:= TestCollisionYwithGear(Gear, -1);

                if land <> 0 then collV := -1

                end

            end

        end;

    xland:= TestCollisionXwithGear(Gear, hwSign(Gear^.dX));

    if xland <> 0 then

        begin

        collH := hwSign(Gear^.dX);

        if (Gear^.AdvBounce = 0) or (xland and lfBouncy = 0) then

            begin

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

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

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