(*

 * Hedgewars, a free turn based strategy game

 * Copyright (c) 2004-2014 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 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, 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);

    //glEnable(GL_LINE_SMOOTH);

    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);

    //glDisable(GL_LINE_SMOOTH)

    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;

            if (SpeechHogNumber <> c) or ((RealTicks and 512) < 256) then

                begin

                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);

                end

            else

            end;

        until (i > cMaxHHIndex);

    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

    defaultPos, HatVisible: boolean;

    HH: PHedgehog;

    CurWeapon: PAmmo;

    iceOffset:Longint;

    r:TSDL_Rect;

    curhat: PTexture;

begin

    HH:= Gear^.Hedgehog;

    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 (not cArtillery) 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 //((Ammoz[CurAmmoGear^.AmmoType].Ammo.Propz and ammoprop_AltAttack) <> 0) 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 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;

                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;

                while ((ty and LAND_HEIGHT_MASK) = 0) and

                    ((tx and LAND_WIDTH_MASK) = 0) and

                    (Land[ty, tx] = 0) do // TODO: check for constant variable instead

                    begin

                    lx:= lx + ax;

                    ly:= ly + ay;

                    tx:= round(lx);

                    ty:= round(ly)

                    end;

                // reached edge of land. assume infinite beam. Extend it way out past camera

                if ((ty and LAND_HEIGHT_MASK) <> 0) or ((tx and LAND_WIDTH_MASK) <> 0) then

                    begin

                    tx:= round(lx + ax * (max(LAND_WIDTH,4096) div 2));

                    ty:= round(ly + ay * (max(LAND_WIDTH,4096) div 2));

                    end;

                //if (abs(lx-tx)>8) or (abs(ly-ty)>8) then

                    begin

                    DrawLine(hx, hy, tx, ty, 1.0, $FF, $00, $00, $C0);

                    end;

                end;

            // draw crosshair

            CrosshairX := Round(hwRound(Gear^.X) + dx * 80 + GetLaunchX(HH^.CurAmmoType, sign * m, Gear^.Angle));

            CrosshairY := Round(hwRound(Gear^.Y) + dy * 80 + GetLaunchY(HH^.CurAmmoType, Gear^.Angle));

            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;

        hx:= ox + 8 * sign;

        hy:= oy - 2;

        aangle:= Gear^.Angle * 180 / cMaxAngle - 90;

        if (CurAmmoGear <> nil) and (CurAmmoGear^.Kind <> gtTardis) then

        begin

            case CurAmmoGear^.Kind of

                gtShotgunShot: begin

                        if (CurAmmoGear^.State and gstAnimation <> 0) then

                            DrawSpriteRotated(sprShotgun, hx, hy, sign, aangle)

                        else

                            DrawSpriteRotated(sprHandShotgun, hx, hy, sign, aangle);

                    end;

                gtDEagleShot: DrawSpriteRotated(sprDEagle, hx, hy, sign, aangle);

                gtSniperRifleShot: begin

                        if (CurAmmoGear^.State and gstAnimation <> 0) then

                            DrawSpriteRotatedF(sprSniperRifle, hx, hy, 1, sign, aangle)

                        else

                            DrawSpriteRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle)

                    end;

                gtBallgun: DrawSpriteRotated(sprHandBallgun, hx, hy, sign, aangle);

                gtRCPlane: begin

                    DrawSpriteRotated(sprHandPlane, hx, hy, sign, 0);

                    defaultPos:= false

                    end;

                gtRope: begin

                    if Gear^.X < CurAmmoGear^.X then

                        begin

                        dAngle:= 0;

                        hAngle:= 180;

                        i:= 1

                        end

                    else

                        begin

                        dAngle:= 180;

                        hAngle:= 0;

                        i:= -1

                        end;

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

                        begin

                        DrawHedgehog(ox, oy,

                                i,

                                1,

                                0,

                                DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + dAngle);

                        with HH^ do

                            if (curhat <> nil) then

                                begin

                                DrawTextureRotatedF(curhat, 1.0, -1.0, -6.0, ox, oy, 0, i, 32, 32,

                                    i*DxDy2Angle(CurAmmoGear^.dY, CurAmmoGear^.dX) + hAngle);

                                if curhat^.w > 64 then

                                    begin

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

                                    DrawTextureRotatedF(curhat, 1.0, -1.0, -6.0, ox, oy, 32, i, 32, 32,