(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2011 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

 *)

{$INCLUDE "options.inc"}

unit uVisualGears;

(*

 * This unit defines the behavior and the appearance of visual gears.

 *

 * Visual gears are "things"/"objects" in the game that do not need to be

 * perfectly synchronized over all clients since their effect is only

 * of visual nature.

 *

 * E.g.: background flakes, visual effects: explosion, smoke trails, etc.

 *)

interface

uses uConsts, uFloat, GLunit, uTypes, uWorld;

procedure initModule;

procedure freeModule;

function  AddVisualGear(X, Y: LongInt; Kind: TVisualGearType; State: LongWord = 0; Critical: Boolean = false): PVisualGear;

procedure ProcessVisualGears(Steps: Longword);

procedure KickFlakes(Radius, X, Y: LongInt);

procedure DrawVisualGears(Layer: LongWord);

procedure DeleteVisualGear(Gear: PVisualGear);

function  VisualGearByUID(uid : Longword) : PVisualGear;

procedure AddClouds;

procedure ChangeToSDClouds;

procedure AddFlakes;

procedure ChangeToSDFlakes;

procedure AddDamageTag(X, Y, Damage, Color: LongWord);

implementation

uses uSound, uMobile, uVariables, uTextures, uRender, Math, uRenderUtils, uStore;

const cExplFrameTicks = 110;

// For better maintainability the step handlers of visual gears are stored

// in a separate file.

{$INCLUDE "VGSHandlers.inc"}

procedure AddDamageTag(X, Y, Damage, Color: LongWord);

var s: shortstring;

    Gear: PVisualGear;

begin

if cAltDamage then

    begin

    Gear:= AddVisualGear(X, Y, vgtSmallDamageTag);

    if Gear <> nil then

        with Gear^ do

            begin

            str(Damage, s);

            Tex:= RenderStringTex(s, Color, fntSmall);

            end

    end

end;

// ==================================================================

// ==================================================================

const doStepHandlers: array[TVisualGearType] of TVGearStepProcedure =

        (

            @doStepFlake,

            @doStepCloud,

            @doStepExpl,

            @doStepExpl,

            @doStepFire,

            @doStepSmallDamage,

            @doStepTeamHealthSorter,

            @doStepSpeechBubble,

            @doStepBubble,

            @doStepSteam,

            @doStepAmmo,

            @doStepSmoke,

            @doStepSmoke,

            @doStepShell,

            @doStepDust,

            @doStepSplash,

            @doStepDroplet,

            @doStepSmokeRing,

            @doStepBeeTrace,

            @doStepEgg,

            @doStepFeather,

            @doStepHealthTag,

            @doStepSmokeTrace,

            @doStepSmokeTrace,

            @doStepExplosion,

            @doStepBigExplosion,

            @doStepChunk,

            @doStepNote,

            @doStepLineTrail,

            @doStepBulletHit,

            @doStepCircle,

            @doStepSmoothWindBar,

            @doStepStraightShot

        );

function  AddVisualGear(X, Y: LongInt; Kind: TVisualGearType; State: LongWord = 0; Critical: Boolean = false): PVisualGear;

const VGCounter: Longword = 0;

var gear: PVisualGear;

    t: Longword;

    sp: real;

begin

AddVisualGear:= nil;

if ((GameType = gmtSave) or (fastUntilLag and (GameType = gmtNet))) and // we are scrolling now

   ((Kind <> vgtCloud) and not Critical) then exit;

if ((cReducedQuality and rqAntiBoom) <> 0) and

   not Critical and

   not (Kind in

   [vgtTeamHealthSorter,

    vgtSmallDamageTag,

    vgtSpeechBubble,

    vgtHealthTag,

    vgtExplosion,

    vgtSmokeTrace,

    vgtEvilTrace,

    vgtNote,

    vgtSmoothWindBar]) then exit;

inc(VGCounter);

New(gear);

FillChar(gear^, sizeof(TVisualGear), 0);

gear^.X:= real(X);

gear^.Y:= real(Y);

gear^.Kind := Kind;

gear^.doStep:= doStepHandlers[Kind];

gear^.State:= 0;

gear^.Tint:= $FFFFFFFF;

gear^.uid:= VGCounter;

gear^.Layer:= 0;

with gear^ do

    case Kind of

    vgtFlake: begin

                Timer:= 0;

                tdX:= 0;

                tdY:= 0;

                if SuddenDeathDmg then

                    begin

                    FrameTicks:= random(vobSDFrameTicks);

                    Frame:= random(vobSDFramesCount);

                    end

                else

                    begin

                    FrameTicks:= random(vobFrameTicks);

                    Frame:= random(vobFramesCount);

                    end;

                Angle:= random * 360;

                dx:= 0.0000038654705 * random(10000);

                dy:= 0.000003506096 * random(7000);

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

                if SuddenDeathDmg then dAngle:= (random(2) * 2 - 1) * (1 + random) * vobSDVelocity / 1000

                else dAngle:= (random(2) * 2 - 1) * (1 + random) * vobVelocity / 1000

                end;

    vgtCloud: begin

                Frame:= random(4);

                dx:= 0.5 + 0.1 * random(5); // how much the cloud will be affected by wind

                timer:= random(4096);

                end;

    vgtExplPart,

    vgtExplPart2: begin

                t:= random(1024);

                sp:= 0.001 * (random(95) + 70);

                dx:= hwFloat2Float(AngleSin(t)) * sp;

                dy:= hwFloat2Float(AngleCos(t)) * sp;

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

                if random(2) = 0 then dy := -dy;

                Frame:= 7 - random(3);

                FrameTicks:= cExplFrameTicks

                end;

        vgtFire: begin

                t:= random(1024);

                sp:= 0.001 * (random(85) + 95);

                dx:= hwFloat2Float(AngleSin(t)) * sp;

                dy:= hwFloat2Float(AngleCos(t)) * sp;

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

                if random(2) = 0 then dy := -dy;

                FrameTicks:= 650 + random(250);

                Frame:= random(8)

                end;

         vgtEgg: begin

                t:= random(1024);

                sp:= 0.001 * (random(85) + 95);

                dx:= hwFloat2Float(AngleSin(t)) * sp;

                dy:= hwFloat2Float(AngleCos(t)) * sp;

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

                if random(2) = 0 then dy := -dy;

                FrameTicks:= 650 + random(250);

                Frame:= 1

                end;

        vgtShell: FrameTicks:= 500;

    vgtSmallDamageTag: begin

                gear^.FrameTicks:= 1100

                end;

    vgtBubble: begin

                dx:= 0.0000038654705 * random(10000);

                dy:= 0;

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

                FrameTicks:= 250 + random(1751);

                Frame:= random(5)

                end;

    vgtSteam: begin

                dx:= 0.0000038654705 * random(10000);

                dy:= 0.001 * (random(85) + 95);

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

                Frame:= 7 - random(3);

                FrameTicks:= cExplFrameTicks * 2;

                end;

    vgtAmmo: begin

                alpha:= 1.0;

                scale:= 1.0

                end;

  vgtSmokeWhite,

  vgtSmoke: begin

                Scale:= 1.0;

                dx:= 0.0002 * (random(45) + 10);

                dy:= 0.0002 * (random(45) + 10);

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

                Frame:= 7 - random(2);

                FrameTicks:= cExplFrameTicks * 2;

                end;

  vgtDust: begin

                dx:= 0.005 * (random(15) + 10);

                dy:= 0.001 * (random(40) + 20);

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

                Frame:= 7 - random(2);

                FrameTicks:= random(20) + 15;

                end;

  vgtSplash: begin

                dx:= 0;

                dy:= 0;

                FrameTicks:= 740;

                Frame:= 19;

                end;

    vgtDroplet: begin

                dx:= 0.001 * (random(75) + 15);

                dy:= -0.001 * (random(80) + 120);

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

                FrameTicks:= 250 + random(1751);

                Frame:= random(3)

                end;

   vgtBeeTrace: begin

                FrameTicks:= 1000;

                Frame:= random(16);

                end;

    vgtSmokeRing: begin

                dx:= 0;

                dy:= 0;

                FrameTicks:= 600;

                Timer:= 0;

                Frame:= 0;

                scale:= 0.6;

                alpha:= 1;

                angle:= random(360);

                end;

     vgtFeather: begin

                t:= random(1024);

                sp:= 0.001 * (random(85) + 95);

                dx:= hwFloat2Float(AngleSin(t)) * sp;

                dy:= hwFloat2Float(AngleCos(t)) * sp;

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

                if random(2) = 0 then dy := -dy;

                FrameTicks:= 650 + random(250);

                Frame:= 1

                end;

  vgtHealthTag: begin

                Frame:= 0;

                Timer:= 1500;

                dY:= -0.08;

                dX:= 0;

                //gear^.Z:= 2002;

                end;

  vgtSmokeTrace,

  vgtEvilTrace: begin

                gear^.X:= gear^.X - 16;

                gear^.Y:= gear^.Y - 16;

                gear^.State:= 8;

                //gear^.Z:= cSmokeZ

                end;

vgtBigExplosion: begin

                gear^.Angle:= random(360);

                end;

      vgtChunk: begin

                gear^.Frame:= random(4);

                t:= random(1024);

                sp:= 0.001 * (random(85) + 47);

                dx:= hwFloat2Float(AngleSin(t)) * sp;

                dy:= hwFloat2Float(AngleCos(t)) * sp * -2;

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

                end;

      vgtNote: begin

                dx:= 0.005 * (random(15) + 10);

                dy:= -0.001 * (random(40) + 20);

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

                Frame:= random(4);

                FrameTicks:= random(2000) + 1500;

                end;

  vgtBulletHit: begin

                dx:= 0;

                dy:= 0;

                FrameTicks:= 350;

                Frame:= 7;

                Angle:= 0;

                end;

vgtSmoothWindBar: Tag:= hwRound(cWindSpeed * 72 / cMaxWindSpeed);

 vgtStraightShot: begin

                Angle:= 0;

                Scale:= 1.0;

                dx:= 0.001 * random(45);

                dy:= 0.001 * (random(20) + 25);

                State:= ord(sprHealth);

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

                Frame:= 0;

                FrameTicks:= random(750) + 1250;

                State:= ord(sprSnowDust);

                end;

        end;

if State <> 0 then gear^.State:= State;

case Gear^.Kind of

    vgtFlake: if cFlattenFlakes then gear^.Layer:= 0

              else if random(3) = 0 then gear^.Layer:= 0   // 33% - far back

              else if random(3) = 0 then gear^.Layer:= 4   // 22% - mid-distance

              else if random(3) <> 0 then gear^.Layer:= 5  // 30% - just behind land

              else if random(2) = 0 then gear^.Layer:= 6   // 7% - just in front of land

              else gear^.Layer:= 2;  // 7% - close up

    vgtCloud: if cFlattenClouds then gear^.Layer:= 5

              else if random(3) = 0 then gear^.Layer:= 0

              else gear^.Layer:= random(2) + 4;

    // 0: this layer is very distant in the background when in stereo

    vgtTeamHealthSorter,

    vgtSmoothWindBar: gear^.Layer:= 0;

    // 1: this layer is on the land level (which is close but behind the screen plane) when stereo

    vgtSmokeTrace,

    vgtEvilTrace,

    vgtLineTrail,

    vgtSmoke,

    vgtSmokeWhite,

    vgtDust,

    vgtFire,

    vgtSplash,

    vgtDroplet,

    vgtBubble: gear^.Layer:= 1;

    // 3: this layer is on the screen plane (depth = 0) when stereo

    vgtSpeechBubble,

    vgtSmallDamageTag,

    vgtHealthTag,

    vgtStraightShot,

    vgtChunk: gear^.Layer:= 3;

    // 2: this layer is outside the screen when stereo

    vgtExplosion,

    vgtBigExplosion,

    vgtExplPart,

    vgtExplPart2,

    vgtSteam,

    vgtAmmo,

    vgtShell,

    vgtFeather,

    vgtEgg,

    vgtBeeTrace,

    vgtSmokeRing,

    vgtNote,

    vgtBulletHit,

    vgtCircle: gear^.Layer:= 2

end;

if VisualGearLayers[gear^.Layer] <> nil then

    begin

    VisualGearLayers[gear^.Layer]^.PrevGear:= gear;

    gear^.NextGear:= VisualGearLayers[gear^.Layer]

    end;

VisualGearLayers[gear^.Layer]:= gear;

AddVisualGear:= gear;

end;

procedure DeleteVisualGear(Gear: PVisualGear);

begin

    FreeTexture(Gear^.Tex);

    Gear^.Tex:= nil;

    if Gear^.NextGear <> nil then Gear^.NextGear^.PrevGear:= Gear^.PrevGear;

    if Gear^.PrevGear <> nil then Gear^.PrevGear^.NextGear:= Gear^.NextGear

    else VisualGearLayers[Gear^.Layer]:= Gear^.NextGear;

    if lastVisualGearByUID = Gear then lastVisualGearByUID:= nil;

    Dispose(Gear);

end;

procedure ProcessVisualGears(Steps: Longword);

var Gear, t: PVisualGear;

    i: LongWord;

begin

if Steps = 0 then exit;

for i:= 0 to 6 do

    begin

    t:= VisualGearLayers[i];

    while t <> nil do

          begin

          Gear:= t;

          t:= Gear^.NextGear;

          Gear^.doStep(Gear, Steps)

          end;

    end

end;

procedure KickFlakes(Radius, X, Y: LongInt);

var Gear, t: PVisualGear;

    dmg, i: LongInt;

begin

if (vobCount = 0) or (vobCount > 200) then exit;

for i:= 2 to 6 do

    if i <> 3 then

        begin

        t:= VisualGearLayers[i];

        while t <> nil do

              begin

              Gear:= t;

              if Gear^.Kind = vgtFlake then

                  begin

                  // Damage calc from doMakeExplosion

                  dmg:= Min(101, Radius + cHHRadius div 2 - LongInt(abs(round(Gear^.X) - X) + abs(round(Gear^.Y) - Y)) div 5);

                  if dmg > 1 then

                      begin

                      Gear^.tdX:= 0.02 * dmg + 0.01;

                      if Gear^.X - X < 0 then Gear^.tdX := -Gear^.tdX;

                      Gear^.tdY:= 0.02 * dmg + 0.01;

                      if Gear^.Y - Y < 0 then Gear^.tdY := -Gear^.tdY;

                      Gear^.Timer:= 200

                      end

                  end;

              t:= Gear^.NextGear

              end

         end

end;

procedure DrawVisualGears(Layer: LongWord);

var Gear: PVisualGear;

    tinted: boolean;

    tmp: real;

    i: LongInt;

begin

case Layer of

    // this layer is very distant in the background when stereo

    0: begin

       Gear:= VisualGearLayers[0];

       while Gear <> nil do

           begin

           if Gear^.Tint <> $FFFFFFFF then Tint(Gear^.Tint);

           case Gear^.Kind of

              vgtCloud: if SuddenDeathDmg then

                             DrawTextureF(SpritesData[sprSDCloud].Texture, 0.25, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 2, SpritesData[sprCloud].Width, SpritesData[sprCloud].Height)

                         else

                            DrawTextureF(SpritesData[sprCloud].Texture, 0.25, round(Gear^.X) + WorldDx, round(Gear^.Y) + WorldDy + SkyOffset, Gear^.Frame, 2, SpritesData[sprCloud].Width, SpritesData[sprCloud].Height);

               vgtFlake: if cFlattenFlakes then

                             begin