(*

 * 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

 *)

{$INCLUDE "options.inc"}

unit uGearsRender;

interface

uses uTypes, uConsts, GLunit, uFloat, SDLh;

type

   Tar = record

            X, Y: hwFloat;

            dLen: hwFloat;

            b : boolean;

         end;

   TRopePoints = record

            Count     : Longword;

            HookAngle : GLfloat;

            ar        : array[0..MAXROPEPOINTS] of Tar;

            rounded   : array[0..MAXROPEPOINTS + 2] of TVertex2f;

         end;

procedure RenderGear(Gear: PGear; x, y: LongInt);

procedure RenderGearTimer(Gear: PGear; x, y: LongInt);

procedure RenderGearHealth(Gear: PGear; x, y: LongInt);

procedure RenderHHGuiExtras(Gear: PGear; ox, oy: LongInt);

procedure DrawHHOrder();

var RopePoints: record

                Count: Longword;

                HookAngle: GLfloat;

                ar: array[0..MAXROPEPOINTS] of record

                                X, Y: hwFloat;

                                dLen: hwFloat;

                                b: boolean;

                                sx, sy, sb: boolean;

                                end;

                rounded: array[0..MAXROPEPOINTS + 2] of TVertex2f;

                end;

implementation

uses uRender, uRenderUtils, uGearsUtils, uUtils, uVariables, uAmmos, Math, uVisualGearsList;

procedure DrawRopeLinesRQ(Gear: PGear);

var n: LongInt;

begin

with RopePoints do

    begin

    rounded[Count].X:= hwRound(Gear^.X);

    rounded[Count].Y:= hwRound(Gear^.Y);

    rounded[Count + 1].X:= hwRound(Gear^.Hedgehog^.Gear^.X);

    rounded[Count + 1].Y:= hwRound(Gear^.Hedgehog^.Gear^.Y);

    end;

if (RopePoints.Count > 0) or (Gear^.Elasticity.QWordValue > 0) then

    begin

    EnableTexture(false);

    Tint(Gear^.Tint shr 24 div 3, Gear^.Tint shr 16 and $FF div 3, Gear^.Tint shr 8 and $FF div 3, Gear^.Tint and $FF);

    n:= RopePoints.Count + 2;

    SetVertexPointer(@RopePoints.rounded[0], n);

    openglPushMatrix();

    openglTranslatef(WorldDx, WorldDy, 0);

    glLineWidth(3.0 * cScaleFactor);

    glDrawArrays(GL_LINE_STRIP, 0, n);

    Tint(Gear^.Tint);

    glLineWidth(2.0 * cScaleFactor);

    glDrawArrays(GL_LINE_STRIP, 0, n);

    untint;

    openglPopMatrix();

    EnableTexture(true);

    end

end;

procedure DrawRopeLine(X1, Y1, X2, Y2: Real; LayerIndex: Longword; var linesLength, ropeLength: Real);

var dX, dY, angle, lineLength: Real;

    FrameIndex: LongWord;

begin

    if (X1 = X2) and (Y1 = Y2) then

        exit;

    dX:= X2 - X1;

    dY:= Y2 - Y1;

    lineLength:= sqrt(sqr(dX) + sqr(dY));

    angle:= arctan2(dY, dX) * 180 / PI - 90;

    dX:= dX / lineLength;

    dY:= dY / lineLength;

    while (ropeLength - linesLength) <= lineLength do

    begin

        FrameIndex:= round(ropeLength / cRopeNodeStep);

        if (FrameIndex mod cRopeLayers) = LayerIndex then

            DrawSpriteRotatedFReal(sprRopeNode,

                X1 + (ropeLength - linesLength) * dX,

                Y1 + (ropeLength - linesLength) * dY,

                FrameIndex, 1, angle);

        ropeLength:= ropeLength + cRopeNodeStep;

    end;

    linesLength:= linesLength + lineLength

end;

procedure DrawRopeLayer(Gear: PGear; LayerIndex: LongWord);

var i: LongInt;

    linesLength, ropeLength: Real;

begin

    linesLength:= 0;

    ropeLength:= cRopeNodeStep;

    if RopePoints.Count > 0 then

    begin

        i:= 0;

        while i < Pred(RopePoints.Count) do

        begin

            DrawRopeLine(hwFloat2Float(RopePoints.ar[i].X) + WorldDx, hwFloat2Float(RopePoints.ar[i].Y) + WorldDy,

                         hwFloat2Float(RopePoints.ar[Succ(i)].X) + WorldDx, hwFloat2Float(RopePoints.ar[Succ(i)].Y) + WorldDy,

                         LayerIndex, linesLength, ropeLength);

            inc(i)

        end;

        DrawRopeLine(hwFloat2Float(RopePoints.ar[i].X) + WorldDx, hwFloat2Float(RopePoints.ar[i].Y) + WorldDy,

                     hwFloat2Float(Gear^.X) + WorldDx, hwFloat2Float(Gear^.Y) + WorldDy,

                     LayerIndex, linesLength, ropeLength);

        DrawRopeLine(hwFloat2Float(Gear^.X) + WorldDx, hwFloat2Float(Gear^.Y) + WorldDy,

                     hwFloat2Float(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwFloat2Float(Gear^.Hedgehog^.Gear^.Y) + WorldDy,

                     LayerIndex, linesLength, ropeLength);

    end

    else

        if Gear^.Elasticity.QWordValue > 0 then

            DrawRopeLine(hwFloat2Float(Gear^.X) + WorldDx, hwFloat2Float(Gear^.Y) + WorldDy,

                         hwFloat2Float(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwFloat2Float(Gear^.Hedgehog^.Gear^.Y) + WorldDy,

                         LayerIndex, linesLength, ropeLength);

end;

procedure DrawRope(Gear: PGear);

var i: LongInt;

begin

    if Gear^.Hedgehog^.Gear = nil then exit;

    if (Gear^.Tag = 1) or ((cReducedQuality and rqSimpleRope) <> 0) then

        DrawRopeLinesRQ(Gear)

    else

        for i := 0 to cRopeLayers - 1 do

            DrawRopeLayer(Gear, i);

if RopePoints.Count > 0 then

    DrawSpriteRotated(sprRopeHook, hwRound(RopePoints.ar[0].X) + WorldDx, hwRound(RopePoints.ar[0].Y) + WorldDy, 1, RopePoints.HookAngle)

else

    if Gear^.Elasticity.QWordValue > 0 then

        DrawSpriteRotated(sprRopeHook, hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, 0, DxDy2Angle(Gear^.dY, Gear^.dX));

end;

procedure DrawSelectedWeapon(Gear: PGear; sx, sy: LongInt; isAltWeapon: boolean);

begin

with Gear^.Hedgehog^ do

    begin

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

        exit;

    if (isAltWeapon and ((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) = 0)) then

        exit;

    if (not isAltWeapon) and (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_ShowSelIcon) = 0) or (

            (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AttackInMove) = 0) and ((Gear^.State and gstMoving) <> 0)))) then

        exit;

    if (not isAltWeapon) then

        begin

        sy:= sy - 64;

        if (IsHogFacingLeft(Gear)) then

            sx:= sx - 61;

        end;

    DrawTexture(sx + 16, sy + 16, ropeIconTex);

    DrawTextureF(SpritesData[sprAMAmmos].Texture, 0.75, sx + 30, sy + 30, ord(CurAmmoType) - 1, 1, 32, 32);

    end;

end;

procedure DrawHHOrder();

var HHGear: PGear;

    hh: PHedgehog;

    c, i, t, x, y, sprH, sprW, fSprOff: LongInt;

begin

t:= LocalTeam;

if not CurrentTeam^.ExtDriven then

    for i:= 0 to Pred(TeamsCount) do

        if (TeamsArray[i] = CurrentTeam) then

            t:= i;

if t < 0 then

    exit;

if TeamsArray[t] <> nil then

    begin

    sprH:= SpritesData[sprBigDigit].Height;

    sprW:= SpritesData[sprBigDigit].Width;

    fSprOff:= sprW div 4 + SpritesData[sprFrame].Width div 4 - 1; // - 1 for overlap to avoid artifacts

    i:= 0;

    c:= 0;

        repeat

        hh:= @TeamsArray[t]^.Hedgehogs[i];

        inc(i);

        if (hh <> nil) and (hh^.Gear <> nil) and (not hh^.Unplaced) then

            begin

            inc(c);

            HHGear:= hh^.Gear;

            x:= hwRound(HHGear^.X) + WorldDx;

            y:= hwRound(HHGear^.Y) + WorldDy - 2;

            DrawTextureF(SpritesData[sprFrame].Texture, 0.5, x - fSprOff, y, 0, 1, SpritesData[sprFrame].Width, SpritesData[sprFrame].Height);

            DrawTextureF(SpritesData[sprFrame].Texture, 0.5, x + fSprOff, y, 1, 1, SpritesData[sprFrame].Width, SpritesData[sprFrame].Height);

            DrawTextureF(SpritesData[sprBigDigit].Texture, 0.5, x, y, c, 1, sprW, sprH);

            if SpeechHogNumber = c then

                DrawCircle(x, y, 20, 3, 0, $FF, $FF, $80);

            end;

        until (i > cMaxHHIndex);

    end

end;

// Render some informational GUI next to hedgehog, like fuel and alternate weapon

procedure RenderHHGuiExtras(Gear: PGear; ox, oy: LongInt);

var HH: PHedgehog;

    sx, sy, tx, ty, t, hogLR: LongInt;

    dAngle: real;

begin

    HH:= Gear^.Hedgehog;

    sx:= ox + 1; // this offset is very common

    sy:= oy - 3;

    if HH^.Unplaced then

        exit;

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

        exit;

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

        exit;

    if (CinematicScript) then

        exit;

    // render finger (pointing arrow)

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

        begin

        ty := oy - 32;

        // move finger higher up if tags are above hog

        if (cTagsMask and htTeamName) <> 0 then

            ty := ty - HH^.Team^.NameTagTex^.h - 2;

        if (cTagsMask and htName) <> 0 then

            ty := ty - HH^.NameTagTex^.h - 2;

        if (cTagsMask and htHealth) <> 0 then

            ty := ty - HH^.HealthTagTex^.h - 2;

        tx := ox;

        // don't go offscreen

        t:= 32;

        tx := min(max(tx, ViewLeftX + t), ViewRightX - t);

        ty := min(ty, ViewBottomY - 96);

        // don't overlap with HH or HH tags

        if ty < ViewTopY + t then

            begin

            if abs(tx - ox) < abs(ty - oy)  then

                ty:= max(ViewTopY + t, oy + t)

            else

                ty:= max(ViewTopY + t, ty);

            end;

        dAngle := DxDy2Angle(int2hwfloat(ty - oy), int2hwfloat(tx - ox)) + 90;

        if (IsTooDarkToRead(HH^.Team^.Clan^.Color)) then

            DrawSpriteRotatedF(sprFingerBackInv, tx, ty, RealTicks div 32 mod 16, 1, dAngle)

        else

            DrawSpriteRotatedF(sprFingerBack, tx, ty, RealTicks div 32 mod 16, 1, dAngle);

        Tint(HH^.Team^.Clan^.Color shl 8 or $FF);

        DrawSpriteRotatedF(sprFinger, tx, ty, RealTicks div 32 mod 16, 1, dAngle);

        untint;

        end;

    // render crosshair

    if (CrosshairGear <> nil) and (Gear = CrosshairGear) then

        begin

        hogLR:= 1;

        if IsHogFacingLeft(Gear) then

            hogLR:= -1;

        setTintAdd(true);

        Tint(HH^.Team^.Clan^.Color shl 8 or $FF);

        DrawTextureRotated(CrosshairTexture,

                12, 12, CrosshairX + WorldDx, CrosshairY + WorldDy, 0,

                hogLR * (Gear^.Angle * 180.0) / cMaxAngle);

        untint;

        setTintAdd(false);

        end;

    // render gear-related extras: alt weapon, fuel, other

    if ((Gear^.State and gstHHDriven) <> 0) and (CurAmmoGear <> nil) then

        begin

        case CurAmmoGear^.Kind of

            gtJetpack:      begin

                            // render jetpack contour if underwater

                            if (((not SuddenDeathDmg) and (WaterOpacity > 179)) or (SuddenDeathDmg and (SDWaterOpacity > 179))) and

                                    ((cWaterLine < (hwRound(Gear^.Y) + Gear^.Radius - 16)) or

                                    ((WorldEdge = weSea) and ((hwRound(Gear^.X) < LeftX) or (hwRound(Gear^.X) > RightX)))) then

                                DrawSprite(sprJetpack, sx-32, sy-32, 4);

                            if CurAmmoGear^.Tex <> nil then

                                DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex);

                            DrawSelectedWeapon(Gear, sx, sy, true);

                            end;

            gtRope:         DrawSelectedWeapon(Gear, sx, sy, true);

            gtParachute:    DrawSelectedWeapon(Gear, sx, sy, true);

            gtLandGun:      if CurAmmoGear^.Tex <> nil then

                                DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex);

            gtFlamethrower: if CurAmmoGear^.Tex <> nil then

                                DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex);

            gtIceGun:       if CurAmmoGear^.Tex <> nil then

                                DrawTextureCentered(sx, sy - 40, CurAmmoGear^.Tex);

        end;

        end

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

        begin

        DrawSelectedWeapon(Gear, sx, sy, false);

        end

end;

procedure DrawHH(Gear: PGear; ox, oy: LongInt);

var i, t: LongInt;

    amt: TAmmoType;

    sign, hx, hy, tx, ty, sx, sy, hogLR: LongInt;  // hedgehog, crosshair, temp, sprite, direction

    dx, dy, ax, ay, aAngle, dAngle, hAngle, lx, ly: real;  // laser, change

    wraps: LongWord; // numbe of wraps for laser in world wrap

    defaultPos, HatVisible, inWorldBounds: boolean;

    HH: PHedgehog;

    CurWeapon: PAmmo;

    iceOffset:Longint;

    r:TSDL_Rect;

    curhat: PTexture;

begin

    HH:= Gear^.Hedgehog;

    CrosshairGear:= nil;

    if HH^.Unplaced then

        exit;

    if (HH^.CurAmmoType = amKnife) and (HH = CurrentHedgehog) then

         curhat:= ChefHatTexture

    else curhat:= HH^.HatTex;

    sx:= ox + 1; // this offset is very common

    sy:= oy - 3;

    sign:= hwSign(Gear^.dX);

    if IsHogFacingLeft(Gear) then

        hogLR:= -1

    else

        hogLR:= 1;

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

        begin

        DrawSprite(sprHHDeath, ox - 16, oy - 26, Gear^.Pos);

        Tint(HH^.Team^.Clan^.Color shl 8 or $FF);

        DrawSprite(sprHHDeath, ox - 16, oy - 26, Gear^.Pos + 8);

        untint;

        exit

        end

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

        begin

        DrawSpriteRotatedF(sprTeleport, sx, sy, Gear^.Pos, sign, 0);

        exit

        end;

    defaultPos:= true;

    HatVisible:= false;

    if HH^.Effects[heFrozen] > 0 then

        if HH^.Effects[heFrozen] < 150000 then

            begin

            DrawHedgehog(sx, sy,

                    sign,

                    0,

                    0,

                    0);

            defaultPos:= false;

            if HH^.Effects[heFrozen] < 256 then

                 HatVisible:= true

            else HatVisible:= false

            end

        else

            begin

            DrawHedgehog(sx, sy,

                    sign,

                    2,

                    4,

                    0);

            defaultPos:= false;

            HatVisible:= false

            end;

    if HH^.Effects[hePoisoned] <> 0 then

        begin

        Tint($00, $FF, $40, $40);

        DrawTextureRotatedF(SpritesData[sprSmokeWhite].texture, 2, 0, 0, sx, sy, 0, 1, 22, 22, (RealTicks shr 4) mod 360);

        untint

        end;

    if ((Gear^.State and gstWinner) <> 0) and

    ((CurAmmoGear = nil) or (CurAmmoGear^.Kind <> gtPickHammer)) then

        begin

        DrawHedgehog(sx, sy,

                sign,

                2,

                0,

                0);

        defaultPos:= false

        end;

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

        begin

        DrawHedgehog(sx, sy,

                sign,

                1,

                7,

                0);

        defaultPos:= false

        end else

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

        begin

        DrawHedgehog(sx, sy,

                sign,

                2,

                3,

                0);

        defaultPos:= false

        end else

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

        begin

        if ((Gear^.State and (gstHHThinking or gstAnimation)) = 0) and

/// If current ammo is active, and current ammo has alt attack and uses a crosshair  (rope, basically, right now, with no crosshair for parachute/saucer

            (((CurAmmoGear <> nil) and

            // don't render crosshair/laser during kamikaze

            ((CurAmmoGear^.AmmoType <> amKamikaze) or ((Gear^.State and gstAttacking) = 0)) and

             ((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_NoCrossHair) = 0)) or

/// If no current ammo is active, and the selected ammo uses a crosshair

            ((CurAmmoGear = nil) and ((Ammoz[HH^.CurAmmoType].Ammo.Propz and ammoprop_NoCrosshair) = 0) and ((Gear^.State and gstAttacked) = 0))) then

            begin

    (* These calculations are a little complex for a few reasons:

    1: I need to draw the laser from weapon origin to nearest land

    2: I need to start the beam outside the hedgie for attractiveness.

    3: I need to extend the beam beyond land.

    This routine perhaps should be pushed into uStore or somesuch instead of continuuing the increase in size of this function.

    *)

            dx:= hogLR * Sin(Gear^.Angle * pi / cMaxAngle);

            dy:= -Cos(Gear^.Angle * pi / cMaxAngle);

            if cLaserSighting or cLaserSightingSniper then

                begin

                lx:= GetLaunchX(HH^.CurAmmoType, hogLR, Gear^.Angle);

                ly:= GetLaunchY(HH^.CurAmmoType, Gear^.Angle);

                // ensure we start outside the hedgehog (he's solid after all)

                while abs(lx * lx + ly * ly) < (Gear^.radius * Gear^.radius) do

                    begin

                    lx:= lx + dx;

                    ly:= ly + dy

                    end;

                // add hog's position

                lx:= lx + ox - WorldDx;

                ly:= ly + oy - WorldDy;

                // decrease number of iterations required

                ax:= dx * 4;

                ay:= dy * 4;

                tx:= round(lx);

                ty:= round(ly);

                hx:= tx;

                hy:= ty;

                wraps:= 0;

                inWorldBounds := ((ty and LAND_HEIGHT_MASK) or (tx and LAND_WIDTH_MASK)) = 0;

                while (inWorldBounds and ((Land[ty, tx] and lfAll) = 0)) or (not inWorldBounds) do

                    begin