(*

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

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;

function DrawRopeLine(X1, Y1, X2, Y2, roplen: LongInt): LongInt;

var  eX, eY, dX, dY: LongInt;

    i, sX, sY, x, y, d: LongInt;

    b: boolean;

begin

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

        begin

        //OutError('WARNING: zero length rope line!', false);

        DrawRopeLine:= 0;

        exit

        end;

    eX:= 0;

    eY:= 0;

    dX:= X2 - X1;

    dY:= Y2 - Y1;

    if (dX > 0) then

        sX:= 1

    else

        if (dX < 0) then

            begin

            sX:= -1;

            dX:= -dX

            end

        else sX:= dX;

    if (dY > 0) then

        sY:= 1

    else

        if (dY < 0) then

            begin

            sY:= -1;

            dY:= -dY

            end

        else

            sY:= dY;

    if (dX > dY) then

        d:= dX

    else

        d:= dY;

    x:= X1;

    y:= Y1;

    for i:= 0 to d do

        begin

        inc(eX, dX);

        inc(eY, dY);

        b:= false;

        if (eX > d) then

            begin

            dec(eX, d);

            inc(x, sX);

            b:= true

            end;

        if (eY > d) then

            begin

            dec(eY, d);

            inc(y, sY);

            b:= true

            end;

        if b then

            begin

            inc(roplen);

            if (roplen mod 4) = 0 then

                DrawSprite(sprRopeNode, x - 2, y - 2, 0)

            end

    end;

    DrawRopeLine:= roplen;

end;

procedure DrawRope(Gear: PGear);

var roplen, i: LongInt;

begin

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

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

        DrawRopeLinesRQ(Gear)

    else

        begin

        roplen:= 0;

        if RopePoints.Count > 0 then

            begin

            i:= 0;

            while i < Pred(RopePoints.Count) do

                    begin

                    roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy,

                                hwRound(RopePoints.ar[Succ(i)].X) + WorldDx, hwRound(RopePoints.ar[Succ(i)].Y) + WorldDy, roplen);

                    inc(i)

                    end;

            roplen:= DrawRopeLine(hwRound(RopePoints.ar[i].X) + WorldDx, hwRound(RopePoints.ar[i].Y) + WorldDy,

                        hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy, roplen);

            roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy,

                        hwRound(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwRound(Gear^.Hedgehog^.Gear^.Y) + WorldDy, roplen);

            end

        else

            if Gear^.Elasticity.QWordValue > 0 then

            roplen:= DrawRopeLine(hwRound(Gear^.X) + WorldDx, hwRound(Gear^.Y) + WorldDy,

                        hwRound(Gear^.Hedgehog^.Gear^.X) + WorldDx, hwRound(Gear^.Hedgehog^.Gear^.Y) + WorldDy, roplen);

        end;

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 DrawAltWeapon(Gear: PGear; sx, sy: LongInt);

begin

with Gear^.Hedgehog^ do

    begin

    if not (((Ammoz[CurAmmoType].Ammo.Propz and ammoprop_AltUse) <> 0) and ((Gear^.State and gstAttacked) = 0)) then

        exit;

    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) 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, sign, m: 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;

        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

        sign:= hwSign(Gear^.dX);

        m:= 1;

        if ((Gear^.State and gstHHHJump) <> 0) and (HH^.Effects[heArtillery] = 0) then

            m:= -1;

        setTintAdd(true);

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

        DrawTextureRotated(CrosshairTexture,

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

                sign * m * (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);

                            DrawAltWeapon(Gear, sx, sy);

                            end;

            gtRope:         DrawAltWeapon(Gear, sx, sy);

            gtParachute:    DrawAltWeapon(Gear, sx, sy);

            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;

end;

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

var i, t: LongInt;

    amt: TAmmoType;

    sign, hx, hy, tx, ty, sx, sy, m: 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;

    m:= 1;

    if ((Gear^.State and gstHHHJump) <> 0) and (HH^.Effects[heArtillery] = 0) then

        m:= -1;

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

    sy:= oy - 3;

    sign:= hwSign(Gear^.dX);

    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:= sign * m * Sin(Gear^.Angle * pi / cMaxAngle);

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

            if cLaserSighting or cLaserSightingSniper then

                begin

                lx:= GetLaunchX(HH^.CurAmmoType, sign * m, 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;