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

var i, t: LongInt;

    amt: TAmmoType;

    sign, hx, hy, cx, cy, 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;

    VertexBuffer: array [0..1] of TVertex2f;

    HH: PHedgehog;

    CurWeapon: PAmmo;

begin

HH:= PHedgehog(Gear^.Hedgehog);

if HH^.Unplaced then exit;

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

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

    Tint($FF, $FF, $FF, $FF);

    exit

    end

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

    begin

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

    exit

    end;

defaultPos:= true;

HatVisible:= false;

if HH^.Effects[hePoisoned] then

    begin

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

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

    Tint($FF, $FF, $FF, $FF)

    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) = 0) and

       (ShowCrosshair  or ((CurAmmoGear <> nil) and (CurAmmoGear^.Kind = gtRope))) and

       ((Gear^.State and (gstAttacked or gstAnimation)) = 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

            // 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 * (LAND_WIDTH div 4));

                ty:= round(ly + ay * (LAND_WIDTH div 4));

                end;

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

                begin

                glDisable(GL_TEXTURE_2D);

                glEnable(GL_LINE_SMOOTH);

                glLineWidth(1.0);

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

                VertexBuffer[0].X:= hx + WorldDx;

                VertexBuffer[0].Y:= hy + WorldDy;

                VertexBuffer[1].X:= tx + WorldDx;

                VertexBuffer[1].Y:= ty + WorldDy;

                glVertexPointer(2, GL_FLOAT, 0, @VertexBuffer[0]);

                glDrawArrays(GL_LINES, 0, Length(VertexBuffer));

                Tint($FF, $FF, $FF, $FF);

                glEnable(GL_TEXTURE_2D);

                glDisable(GL_LINE_SMOOTH);

                end;

            end;

        // draw crosshair

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

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

        DrawRotatedTex(HH^.Team^.CrosshairTex,

                12, 12, cx + WorldDx, cy + WorldDy, 0,

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

        end;

    hx:= ox + 8 * sign;

    hy:= oy - 2;

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

    if CurAmmoGear <> nil then

    begin

        case CurAmmoGear^.Kind of

            gtShotgunShot: begin

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

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

                    else

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

                end;

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

            gtSniperRifleShot: begin

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

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

                    else

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

                end;

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

            gtRCPlane: begin

                DrawRotated(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 (HatTex <> nil) then

                           begin

                           DrawRotatedTextureF(HatTex, 1.0, -1.0, -6.0, ox, oy, 0, i, 32, 32,

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

                           if HatTex^.w > 64 then

                               begin

                               Tint(HH^.Team^.Clan^.Color);

                               DrawRotatedTextureF(HatTex, 1.0, -1.0, -6.0, ox, oy, 32, i, 32, 32,

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

                               Tint($FF, $FF, $FF, $FF)

                               end

                           end

                   end;

                DrawAltWeapon(Gear, ox, oy);

                defaultPos:= false

                end;

            gtBlowTorch: begin

                DrawRotated(sprBlowTorch, hx, hy, sign, aangle);

                DrawHedgehog(sx, sy,

                        sign,

                        3,

                        HH^.visStepPos div 2,

                        0);

                with HH^ do

                    if (HatTex <> nil) then

                        begin

                        DrawTextureF(HatTex,

                            1,

                            sx,

                            sy - 5,

                            0,

                            sign,

                            32,

                            32);

                        if HatTex^.w > 64 then

                            begin

                            Tint(HH^.Team^.Clan^.Color);

                            DrawTextureF(HatTex,

                                1,

                                sx,

                                sy - 5,

                                32,

                                sign,

                                32,

                                32);

                            Tint($FF, $FF, $FF, $FF)

                            end

                        end;

                defaultPos:= false

                end;

            gtShover: DrawRotated(sprHandBaseball, hx, hy, sign, aangle + 180);

            gtFirePunch: begin

                DrawHedgehog(sx, sy,

                        sign,

                        1,

                        4,

                        0);

                defaultPos:= false

                end;

            gtPickHammer: begin

                defaultPos:= false;

                dec(sy,20);

                end;

            gtTeleport: defaultPos:= false;

            gtWhip: begin

                DrawRotatedF(sprWhip,

                        sx,

                        sy,

                        1,

                        sign,

                        0);

                defaultPos:= false

                end;

            gtHammer: begin

                DrawRotatedF(sprHammer,

                        sx,

                        sy,

                        1,

                        sign,

                        0);

                defaultPos:= false

                end;

            gtResurrector: begin

                DrawRotated(sprHandResurrector, sx, sy, 0, 0); 

                defaultPos:= false

                end;

            gtKamikaze: begin

                if CurAmmoGear^.Pos = 0 then

                    DrawHedgehog(sx, sy,

                            sign,

                            1,

                            6,

                            0)

                else

                    DrawRotatedF(sprKamikaze,

                            ox, oy,

                            CurAmmoGear^.Pos - 1,

                            sign,

                            aangle);

                defaultPos:= false

                end;

            gtSeduction: begin

                if CurAmmoGear^.Pos >= 6 then

                    DrawHedgehog(sx, sy,

                            sign,

                            2,

                            2,

                            0)

                else

                    begin

                    DrawRotatedF(sprDress,

                            ox, oy,

                            CurAmmoGear^.Pos,

                            sign,

                            0);

                    DrawSprite(sprCensored, ox - 32, oy - 20, 0)

                    end;

                defaultPos:= false

                end;

            gtFlamethrower: begin

                DrawRotatedF(sprHandFlamethrower, hx, hy, (RealTicks div 125) mod 4, sign, aangle);

                if CurAmmoGear^.Tex <> nil then DrawCentered(sx, sy - 40, CurAmmoGear^.Tex)

                end;

        end;

        case CurAmmoGear^.Kind of

            gtShotgunShot,

            gtDEagleShot,

            gtSniperRifleShot,

            gtShover: begin

                DrawHedgehog(sx, sy,

                        sign,

                        0,

                        4,

                        0);

                defaultPos:= false;

                HatVisible:= true

            end

        end

    end else

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

    begin

    DrawHedgehog(sx, sy,

        sign*m,

        1,

        1,

        0);

    HatVisible:= true;

    defaultPos:= false

    end else

    if (Gear^.Message and (gmLeft or gmRight) <> 0) and (not isCursorVisible) then

        begin

        DrawHedgehog(sx, sy,

            sign,

            0,

            HH^.visStepPos div 2,

            0);

        defaultPos:= false;

        HatVisible:= true

        end

    else

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

        begin

        if (TWave(Gear^.Tag) < Low(TWave)) or (TWave(Gear^.Tag) > High(TWave)) then

            begin

            Gear^.State:= Gear^.State and not gstAnimation;

            end

        else

            begin

            DrawRotatedF(Wavez[TWave(Gear^.Tag)].Sprite,

                    sx,

                    sy,

                    Gear^.Pos,

                    sign,

                    0.0);

            defaultPos:= false

            end

        end

    else

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

        begin

        if HH^.Timer > 0 then

            begin

            // There must be a tidier way to do this. Anyone?

            if aangle <= 90 then aangle:= aangle+360;

            if Gear^.dX > _0 then aangle:= aangle-((aangle-240)*HH^.Timer/10)

            else aangle:= aangle+((240-aangle)*HH^.Timer/10);

            dec(HH^.Timer)

            end;

        amt:= CurrentHedgehog^.CurAmmoType;

        CurWeapon:= GetAmmoEntry(HH^);

        case amt of

            amBazooka: DrawRotated(sprHandBazooka, hx, hy, sign, aangle);

            amMortar: DrawRotated(sprHandMortar, hx, hy, sign, aangle);

            amMolotov: DrawRotated(sprHandMolotov, hx, hy, sign, aangle);

            amBallgun: DrawRotated(sprHandBallgun, hx, hy, sign, aangle);

            amDrill: DrawRotated(sprHandDrill, hx, hy, sign, aangle);

            amRope: DrawRotated(sprHandRope, hx, hy, sign, aangle);

            amShotgun: DrawRotated(sprHandShotgun, hx, hy, sign, aangle);

            amDEagle: DrawRotated(sprHandDEagle, hx, hy, sign, aangle);

            amSineGun: DrawRotated(sprHandShotgun, hx, hy, sign, aangle);

            amPortalGun: if (CurWeapon^.Timer and 2) <> 0 then // Add a new Hedgehog value instead of abusing timer?

                            DrawRotatedF(sprPortalGun, hx, hy, 0, sign, aangle)

                      else

                            DrawRotatedF(sprPortalGun, hx, hy, 1+(CurWeapon^.Timer and 1), sign, aangle);

            amSniperRifle: DrawRotatedF(sprSniperRifle, hx, hy, 0, sign, aangle);

            amBlowTorch: DrawRotated(sprHandBlowTorch, hx, hy, sign, aangle);

            amCake: DrawRotated(sprHandCake, hx, hy, sign, aangle);

            amGrenade: DrawRotated(sprHandGrenade, hx, hy, sign, aangle);

            amWatermelon: DrawRotated(sprHandMelon, hx, hy, sign, aangle);

            amSkip: DrawRotated(sprHandSkip, hx, hy, sign, aangle);

            amClusterBomb: DrawRotated(sprHandCluster, hx, hy, sign, aangle);

            amDynamite: DrawRotated(sprHandDynamite, hx, hy, sign, aangle);

            amHellishBomb: DrawRotated(sprHandHellish, hx, hy, sign, aangle);

            amGasBomb: DrawRotated(sprHandCheese, hx, hy, sign, aangle);

            amMine: DrawRotated(sprHandMine, hx, hy, sign, aangle);

            amSMine: DrawRotated(sprHandSMine, hx, hy, sign, aangle);

            amSeduction: DrawRotated(sprHandSeduction, hx, hy, sign, aangle);

            amVampiric: DrawRotatedF(sprHandVamp, hx, hy, (RealTicks div 125) mod 4, sign, aangle);

            amRCPlane: begin

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

                defaultPos:= false

                end;

            amGirder: begin

                DrawRotated(sprHandConstruction, hx, hy, sign, aangle);

                DrawSpriteClipped(sprGirder,

                                  ox-256,

                                  oy-256,

                                  LongInt(topY)+WorldDy,

                                  LongInt(rightX)+WorldDx,

                                  cWaterLine+WorldDy,

                                  LongInt(leftX)+WorldDx)

                end;

            amBee: DrawRotatedF(sprHandBee, hx, hy, (RealTicks div 125) mod 4, sign, aangle);

            amFlamethrower: DrawRotatedF(sprHandFlamethrower, hx, hy, (RealTicks div 125) mod 4, sign, aangle);

            amResurrector: begin

                DrawCircle(ox, oy, 100, 1.5, 0, 0,

                        $FF, $FF); // I'd rather not like to hardcode 100 here

            end;

        end;

        case amt of

            amAirAttack,

            amMineStrike: DrawRotated(sprHandAirAttack, sx, oy, sign, 0);

            amPickHammer: DrawHedgehog(sx, sy,

                        sign,

                        1,

                        2,

                        0);

            amTeleport: DrawRotatedF(sprTeleport, sx, sy, 0, sign, 0);

            amKamikaze: DrawHedgehog(sx, sy,

                        sign,

                        1,

                        5,

                        0);

            amWhip: DrawRotatedF(sprWhip,

                        sx,

                        sy,

                        0,

                        sign,

                        0);

            amHammer: DrawRotatedF(sprHammer,

                        sx,

                        sy,

                        0,

                        sign,

                        0);

        else

            DrawHedgehog(sx, sy,

                sign,

                0,

                4,

                0);

            HatVisible:= true;

            (* with HH^ do

                if (HatTex <> nil)

                and (HatVisibility > 0) then

                    DrawTextureF(HatTex,

                        HatVisibility,

                        sx,

                        sy - 5,

                        0,

                        sign,

                        32,

                        32); *)

        end;

        case amt of

            amBaseballBat: DrawRotated(sprHandBaseball,

                    sx - 4 * sign,

                    sy + 9, sign, aangle);

        end;

        defaultPos:= false

    end;

end else // not gstHHDriven

    begin

    if (Gear^.Damage > 0)

    and (hwSqr(Gear^.dX) + hwSqr(Gear^.dY) > _0_003) then

        begin

        DrawHedgehog(sx, sy,

            sign,