(*

 * 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 visual gears.

 *

 * Since the effects of visual gears do not affect the course of the game,

 * no "synchronization" between players is required.

 * => The usage of safe functions or data types (e.g. GetRandom() or hwFloat)

 * is usually not necessary and therefore undesirable.

 *)

{$INCLUDE "options.inc"}

unit uVisualGearsHandlers;

interface

uses uTypes, uGears;

var doStepVGHandlers: array[TVisualGearType] of TVGearStepProcedure;

procedure doStepFlake(Gear: PVisualGear; Steps: Longword);

procedure doStepBeeTrace(Gear: PVisualGear; Steps: Longword);

procedure doStepCloud(Gear: PVisualGear; Steps: Longword);

procedure doStepExpl(Gear: PVisualGear; Steps: Longword);

procedure doStepNote(Gear: PVisualGear; Steps: Longword);

procedure doStepLineTrail(Gear: PVisualGear; Steps: Longword);

procedure doStepEgg(Gear: PVisualGear; Steps: Longword);

procedure doStepFire(Gear: PVisualGear; Steps: Longword);

procedure doStepShell(Gear: PVisualGear; Steps: Longword);

procedure doStepSmallDamage(Gear: PVisualGear; Steps: Longword);

procedure doStepBubble(Gear: PVisualGear; Steps: Longword);

procedure doStepSteam(Gear: PVisualGear; Steps: Longword);

procedure doStepAmmo(Gear: PVisualGear; Steps: Longword);

procedure doStepSmoke(Gear: PVisualGear; Steps: Longword);

procedure doStepDust(Gear: PVisualGear; Steps: Longword);

procedure doStepSplash(Gear: PVisualGear; Steps: Longword);

procedure doStepDroplet(Gear: PVisualGear; Steps: Longword);

procedure doStepSmokeRing(Gear: PVisualGear; Steps: Longword);

procedure doStepFeather(Gear: PVisualGear; Steps: Longword);

procedure doStepTeamHealthSorterWork(Gear: PVisualGear; Steps: Longword);

procedure doStepTeamHealthSorter(Gear: PVisualGear; Steps: Longword);

procedure doStepSpeechBubbleWork(Gear: PVisualGear; Steps: Longword);

procedure doStepSpeechBubble(Gear: PVisualGear; Steps: Longword);

procedure doStepHealthTagWork(Gear: PVisualGear; Steps: Longword);

procedure doStepHealthTagWorkUnderWater(Gear: PVisualGear; Steps: Longword);

procedure doStepHealthTag(Gear: PVisualGear; Steps: Longword);

procedure doStepSmokeTrace(Gear: PVisualGear; Steps: Longword);

procedure doStepExplosionWork(Gear: PVisualGear; Steps: Longword);

procedure doStepExplosion(Gear: PVisualGear; Steps: Longword);

procedure doStepBigExplosionWork(Gear: PVisualGear; Steps: Longword);

procedure doStepBigExplosion(Gear: PVisualGear; Steps: Longword);

procedure doStepChunk(Gear: PVisualGear; Steps: Longword);

procedure doStepBulletHit(Gear: PVisualGear; Steps: Longword);

procedure doStepCircle(Gear: PVisualGear; Steps: Longword);

procedure doStepSmoothWindBar(Gear: PVisualGear; Steps: Longword);

procedure doStepStraightShot(Gear: PVisualGear; Steps: Longword);

function isSorterActive: boolean; inline;

procedure initModule;

implementation

uses uCollisions, uVariables, Math, uConsts, uVisualGearsList, uFloat, uSound, uRenderUtils, uWorld, uUtils;

procedure doStepFlake(Gear: PVisualGear; Steps: Longword);

var sign: real;

    moved, rising, outside: boolean;

    vfc, vft: LongWord;

    spawnMargin: LongInt;

const

    randMargin = 50;

begin

if SuddenDeathDmg then

    begin

    if (vobSDCount = 0) then exit;

    end

else

    if (vobCount = 0) then exit;

sign:= 1;

with Gear^ do

    begin

    X:= X + (cWindSpeedf * 400 + dX + tdX) * Steps * Gear^.Scale;

    if SuddenDeathDmg then

        begin

        Y:= Y + (dY + tdY + cGravityf * vobSDFallSpeed) * Steps * Gear^.Scale;

        vfc:= vobSDFramesCount;

        vft:= vobSDFrameTicks;

        end

    else

        begin

        Y:= Y + (dY + tdY + cGravityf * vobFallSpeed) * Steps * Gear^.Scale;

        vfc:= vobFramesCount;

        vft:= vobFrameTicks;

        end;

    if vft > 0 then

        begin

        inc(FrameTicks, Steps);

        if FrameTicks > vft then

            begin

            dec(FrameTicks, vft);

            inc(Frame);

            if Frame = vfc then

                Frame:= 0

            end;

        end;

    Angle:= Angle + dAngle * Steps;

    if Angle > 360 then

        Angle:= Angle - 360

    else

        if Angle < - 360 then

            Angle:= Angle + 360;

    if (round(X) >= cLeftScreenBorder)

    and (round(X) <= cRightScreenBorder)

    and (round(Y) - 250 <= LAND_HEIGHT)

    and (Timer > 0) and (Timer-Steps > 0) then

        begin

        if tdX > 0 then

            sign := 1

        else

            sign:= -1;

        tdX:= tdX - 0.005*Steps*sign;

        if ((sign < 0) and (tdX > 0)) or ((sign > 0) and (tdX < 0)) then

            tdX:= 0;

        if tdX > 0 then

            sign := 1

        else

            sign:= -1;

        tdY:= tdY - 0.005*Steps*sign;

        if ((sign < 0) and (tdY > 0)) or ((sign > 0) and (tdY < 0)) then

            tdY:= 0;

        dec(Timer, Steps)

        end

    else

        begin

        moved:= false;

        if round(X) < cLeftScreenBorder then

            begin

            X:= X + cScreenSpace;

            moved:= true

            end

        else if round(X) > cRightScreenBorder then

            begin

            X:= X - cScreenSpace;

            moved:= true

            end;

        // it's possible for flakes to move upwards

        if SuddenDeathDmg then

            rising:= (cGravityf * vobSDFallSpeed) < 0

        else

            rising:= (cGravityf * vobFallSpeed) < 0;

        if gear^.layer = 2 then

            spawnMargin:= 400

        else

            spawnMargin:= 200;

        // flake fell far below map?

        outside:= (not rising) and (round(Y) - spawnMargin + randMargin > LAND_HEIGHT);

        // if not, did it rise far above map?

        outside:= outside or (rising and (round(Y) < LAND_HEIGHT - 1024 - spawnMargin - randMargin));

        // if flake left acceptable vertical area, respawn it opposite side

        if outside then

            begin

            X:= cLeftScreenBorder + random(cScreenSpace);

            if rising then

                Y:= Y + (1024 + spawnMargin + random(50))

            else

                Y:= Y - (1024 + spawnMargin + random(50));

            moved:= true;

            end;

        if moved then

            begin

            Angle:= random(360);

            dx:= 0.0000038654705 * random(10000);

            dy:= 0.000003506096 * random(7000);

            if random(2) = 0 then dx := -dx

            end;

        Timer:= 0;

        tdX:= 0;

        tdY:= 0

        end;

    end;

end;

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

procedure doStepBeeTrace(Gear: PVisualGear; Steps: Longword);

begin

if Gear^.FrameTicks > Steps then

    dec(Gear^.FrameTicks, Steps)

else

    DeleteVisualGear(Gear);

end;

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

procedure doStepCloud(Gear: PVisualGear; Steps: Longword);

var s: Longword;

    t: real;

begin

Gear^.X:= Gear^.X + (cWindSpeedf * 750 * Gear^.dX * Gear^.Scale) * Steps;

// up-and-down-bounce magic

s := (GameTicks + Gear^.Timer) mod 4096;

t := 8 * Gear^.Scale * hwFloat2Float(AngleSin(s mod 2048));

if (s < 2048) then t := -t;

Gear^.Y := LAND_HEIGHT - 1184 + LongInt(Gear^.Timer mod 8) + t;

if round(Gear^.X) < cLeftScreenBorder then

    Gear^.X:= Gear^.X + cScreenSpace

else

    if round(Gear^.X) > cRightScreenBorder then

        Gear^.X:= Gear^.X - cScreenSpace

end;

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

procedure doStepExpl(Gear: PVisualGear; Steps: Longword);

var s: LongInt;

begin

s:= min(Steps, cExplFrameTicks);

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

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

if Gear^.FrameTicks <= Steps then

    if Gear^.Frame = 0 then

        DeleteVisualGear(Gear)

    else

        begin

        dec(Gear^.Frame);

        Gear^.FrameTicks:= cExplFrameTicks

        end

    else dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepNote(Gear: PVisualGear; Steps: Longword);

begin

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

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

Gear^.dY:= Gear^.dY + cGravityf * Steps / 2;

Gear^.Angle:= Gear^.Angle + (Gear^.Frame + 1) * Steps / 10;

while Gear^.Angle > cMaxAngle do

    Gear^.Angle:= Gear^.Angle - cMaxAngle;

if Gear^.FrameTicks <= Steps then

    DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepLineTrail(Gear: PVisualGear; Steps: Longword);

begin

{$IFNDEF PAS2C}

Steps := Steps;

{$ENDIF}

if Gear^.Timer <= Steps then

    DeleteVisualGear(Gear)

else

    dec(Gear^.Timer, Steps)

end;

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

procedure doStepEgg(Gear: PVisualGear; Steps: Longword);

begin

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

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

Gear^.dY:= Gear^.dY + cGravityf * Steps;

Gear^.Angle:= round(Gear^.Angle + Steps) mod cMaxAngle;

if Gear^.FrameTicks <= Steps then

    begin

    DeleteVisualGear(Gear);

    exit

    end

else

    dec(Gear^.FrameTicks, Steps);

if Gear^.FrameTicks < $FF then

   Gear^.Tint:= (Gear^.Tint and $FFFFFF00) or Gear^.FrameTicks

end;

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

procedure doStepFire(Gear: PVisualGear; Steps: Longword);

var vgt: PVisualGear;

begin

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

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

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

    begin

    Gear^.dY:= Gear^.dY + cGravityf * Steps;

    if ((GameTicks mod 200) < Steps + 1) then

        begin

        vgt:= AddVisualGear(round(Gear^.X), round(Gear^.Y), vgtFire);

        if vgt <> nil then

            begin

            vgt^.dx:= 0;

            vgt^.dy:= 0;

            vgt^.State:= gstTmpFlag;

            end;

        end

    end

else

    inc(Steps, Steps);

if Gear^.FrameTicks <= Steps then

       DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepShell(Gear: PVisualGear; Steps: Longword);

begin

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

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

Gear^.dY:= Gear^.dY + cGravityf * Steps;

Gear^.Angle:= round(Gear^.Angle + Steps) mod cMaxAngle;

if Gear^.FrameTicks <= Steps then

    DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps)

end;

procedure doStepSmallDamage(Gear: PVisualGear; Steps: Longword);

begin

Gear^.Y:= Gear^.Y - 0.02 * Steps;

if Gear^.FrameTicks <= Steps then

    DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepBubble(Gear: PVisualGear; Steps: Longword);

begin

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

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

Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;

Gear^.dX := Gear^.dX / (1.001 * Steps);

Gear^.dY := Gear^.dY / (1.001 * Steps);

if (Gear^.FrameTicks <= Steps) or (not CheckCoordInWater(round(Gear^.X), round(Gear^.Y))) then

    DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepSteam(Gear: PVisualGear; Steps: Longword);

begin

if ((cWindSpeedf > 0) and ( leftX > Gear^.X))

or ((cWindSpeedf < 0) and (rightX < Gear^.X)) then

    Gear^.X:= Gear^.X + (cWindSpeedf * 100 + Gear^.dX) * Steps;

Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;

if Gear^.FrameTicks <= Steps then

    if Gear^.Frame = 0 then

        DeleteVisualGear(Gear)

    else

        begin

        if Random(2) = 0 then

            dec(Gear^.Frame);

        Gear^.FrameTicks:= cExplFrameTicks

        end

else dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepAmmo(Gear: PVisualGear; Steps: Longword);

begin

Gear^.Y:= Gear^.Y - cDrownSpeedf * Steps;

Gear^.scale:= Gear^.scale + 0.0025 * Steps;

Gear^.alpha:= Gear^.alpha - 0.0015 * Steps;

if Gear^.alpha < 0 then

    DeleteVisualGear(Gear)

end;

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

procedure doStepSmoke(Gear: PVisualGear; Steps: Longword);

begin

Gear^.X:= Gear^.X + (cWindSpeedf + Gear^.dX) * Steps;

Gear^.Y:= Gear^.Y - (cDrownSpeedf + Gear^.dY) * Steps;

Gear^.dX := Gear^.dX + (cWindSpeedf * 0.3 * Steps);

if Gear^.FrameTicks <= Steps then

    if Gear^.Frame = 0 then

        DeleteVisualGear(Gear)

    else

        begin

        if Random(2) = 0 then

            dec(Gear^.Frame);

        Gear^.FrameTicks:= cExplFrameTicks

        end

    else dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepDust(Gear: PVisualGear; Steps: Longword);

begin

Gear^.X:= Gear^.X + (cWindSpeedf + (cWindSpeedf * 0.03 * Steps) + Gear^.dX) * Steps;

Gear^.Y:= Gear^.Y - (Gear^.dY) * Steps;

Gear^.dX := Gear^.dX - (Gear^.dX * 0.005 * Steps);

Gear^.dY := Gear^.dY - (cDrownSpeedf * 0.001 * Steps);

if Gear^.FrameTicks <= Steps then

    if Gear^.Frame = 0 then

            DeleteVisualGear(Gear)

    else

        begin

        dec(Gear^.Frame);

        Gear^.FrameTicks:= cExplFrameTicks

        end

    else dec(Gear^.FrameTicks, Steps)

end;

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

procedure doStepSplash(Gear: PVisualGear; Steps: Longword);

begin

if Gear^.FrameTicks <= Steps then

    DeleteVisualGear(Gear)

else

    dec(Gear^.FrameTicks, Steps);

end;

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

procedure doStepDroplet(Gear: PVisualGear; Steps: Longword);

begin

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

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

Gear^.dY:= Gear^.dY + cGravityf * Steps;

if round(Gear^.Y) > cWaterLine then

    begin

    DeleteVisualGear(Gear);

    PlaySound(TSound(ord(sndDroplet1) + Random(3)));

    end;

end;

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

procedure doStepSmokeRing(Gear: PVisualGear; Steps: Longword);

begin

inc(Gear^.Timer, Steps);

if Gear^.Timer >= Gear^.FrameTicks then

    DeleteVisualGear(Gear)

else

    begin

    Gear^.scale := 1.25 * (-power(2, -10 * Int(Gear^.Timer)/Gear^.FrameTicks) + 1) + 0.4;

    Gear^.alpha := 1 - power(Gear^.Timer / 350, 4);

    if Gear^.alpha < 0 then

        Gear^.alpha:= 0;

    end;

end;

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

procedure doStepFeather(Gear: PVisualGear; Steps: Longword);