(*

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

interface

uses uFloat, uConsts, uTypes, Math, uRenderUtils;

type

    fillType = (nullPixel, backgroundPixel, ebcPixel, icePixel, addNotHHObj, removeNotHHObj, addHH, removeHH, setCurrentHog, removeCurrentHog);

type TRangeArray = array[0..31] of record

                                   Left, Right: LongInt;

                                   end;

     PRangeArray = ^TRangeArray;

TLandCircleProcedure = procedure (landX, landY, pixelX, pixelY: Longint);

function  addBgColor(OldColor, NewColor: LongWord): LongWord;

function  SweepDirty: boolean;

function  Despeckle(X, Y: LongInt): Boolean;

procedure Smooth(X, Y: LongInt);

function  CheckLandValue(X, Y: LongInt; LandFlag: Word): boolean;

function  DrawExplosion(X, Y, Radius: LongInt): Longword;

procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);

procedure DrawTunnel(X, Y, dX, dY: hwFloat; ticks, HalfWidth: LongInt);

function FillRoundInLand(X, Y, Radius: LongInt; Value: Longword): Longword;

function FillRoundInLandFT(X, Y, Radius: LongInt; fill: fillType): Longword;

procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent, isHH: boolean);

function  LandBackPixel(x, y: LongInt): LongWord;

procedure DrawLine(X1, Y1, X2, Y2: LongInt; Color: Longword);

function  DrawThickLine(X1, Y1, X2, Y2, radius: LongInt; color: Longword): Longword;

procedure DumpLandToLog(x, y, r: LongInt);

procedure DrawIceBreak(x, y, iceRadius, iceHeight: Longint);

function TryPlaceOnLandSimple(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace, indestructible: boolean): boolean;

function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace: boolean; LandFlags: Word): boolean;

function ForcePlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; LandFlags: Word; Tint: LongWord; Behind, flipHoriz, flipVert: boolean): boolean;

function TryPlaceOnLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; doPlace, outOfMap, force, behind, flipHoriz, flipVert: boolean; LandFlags: Word; Tint: LongWord): boolean;

procedure EraseLandRectRaw(X, Y, width, height: LongWord);

procedure EraseLand(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt; LandFlags: Word; eraseOnLFMatch, onlyEraseLF, flipHoriz, flipVert: boolean);

function GetPlaceCollisionTex(cpX, cpY: LongInt; Obj: TSprite; Frame: LongInt): PTexture;

implementation

uses SDLh, uLandTexture, uTextures, uVariables, uUtils, uDebug, uScript, uLandUtils;

procedure calculatePixelsCoordinates(landX, landY: Longint; var pixelX, pixelY: Longint);

begin

if (cReducedQuality and rqBlurryLand) = 0 then

    begin

    pixelX := landX;

    pixelY := landY;

    end

else

    begin

    pixelX := LandX div 2;

    pixelY := LandY div 2;

    end;

end;

function drawPixelBG(landX, landY, pixelX, pixelY: Longint): Longword;

begin

drawPixelBG := 0;

if (LandGet(LandY, landX) and lfIndestructible) = 0 then

    begin

        if ((LandGet(landY, landX) and lfBasic) <> 0) and (((LandPixelGet(pixelY, pixelX) and AMask) shr AShift) = 255) and (not disableLandBack) then

        begin

            LandPixelSet(pixelY, pixelX, LandBackPixel(landX, landY));

            inc(drawPixelBG);

        end

        else if ((LandGet(landY, landX) and lfObject) <> 0) or (((LandPixelGet(pixelY, pixelX) and AMask) shr AShift) < 255) then

            LandPixelSet(pixelY, pixelX, ExplosionBorderColorNoA)

    end;

end;

procedure drawPixelEBC(landX, landY, pixelX, pixelY: Longint);

begin

if (LandGet(landY, landX) and lfIndestructible = 0) and

    (((LandGet(landY, landX) and lfBasic) <> 0) or ((LandGet(landY, landX) and lfObject) <> 0)) then

    begin

    LandPixelSet(pixelY, pixelX, ExplosionBorderColor);

    LandSet(landY, landX, (LandGet(landY, landX) or lfDamaged) and (not lfIce));

    LandDirty[landY div 32, landX div 32]:= 1;

    end;

end;

function isLandscapeEdge(weight:Longint):boolean;

begin

isLandscapeEdge := (weight < 8) and (weight >= 2);

end;

function getPixelWeight(x, y:Longint): Longint;

var

    i, j, r: Longint;

begin

r := 0;

for i := x - 1 to x + 1 do

    for j := y - 1 to y + 1 do

    begin

    if (i < 0) or

       (i > LAND_WIDTH - 1) or

       (j < 0) or

       (j > LAND_HEIGHT -1) then

       exit(9);

    if LandGet(j, i) and lfLandMask and (not lfIce) = 0 then

       inc(r)

    end;

    getPixelWeight:= r

end;

procedure fillPixelFromIceSprite(pixelX, pixelY:Longint);

var

    iceSurface: PSDL_Surface;

    icePixels: PLongwordArray;

    w: LongWord;

begin

    if cOnlyStats then exit;

    // So. 3 parameters here. Ice colour, Ice opacity, and a bias on the greyscaled pixel towards lightness

    iceSurface:= SpritesData[sprIceTexture].Surface;

    icePixels := iceSurface^.pixels;

    w:= LandPixelGet(pixelY, pixelX);

    if w > 0 then

        begin

        w:= round(((w shr RShift and $FF) * RGB_LUMINANCE_RED +

              (w shr BShift and $FF) * RGB_LUMINANCE_GREEN +

              (w shr GShift and $FF) * RGB_LUMINANCE_BLUE));

        if w < 128 then w:= w+128;

        if w > 255 then w:= 255;

        w:= (w shl RShift) or (w shl BShift) or (w shl GShift) or (LandPixelGet(pixelY, pixelX) and AMask);

        LandPixelSet(pixelY, pixelX, addBgColor(w, IceColor));

        LandPixelSet(pixelY, pixelX, addBgColor(LandPixelGet(pixelY, pixelX), icePixels^[iceSurface^.w * (pixelY mod iceSurface^.h) + (pixelX mod iceSurface^.w)]))

        end

    else

        begin

        LandPixelSet(pixelY, pixelX, IceColor and (not AMask) or $E8 shl AShift);

        LandPixelSet(pixelY, pixelX, addBgColor(LandPixelGet(pixelY, pixelX), icePixels^[iceSurface^.w * (pixelY mod iceSurface^.h) + (pixelX mod iceSurface^.w)]));

        // silly workaround to avoid having to make background erasure a tadb it smarter about sea ice

        if LandPixelGet(pixelY, pixelX) and AMask shr AShift = 255 then

            LandPixelSet(pixelY, pixelX, LandPixelGet(pixelY, pixelX) and (not AMask) or 254 shl AShift);

        end;

end;

procedure DrawPixelIce(landX, landY, pixelX, pixelY: Longint);

begin

if ((LandGet(landY, landX) and lfIce) <> 0) then exit;

if (pixelX < LeftX) or (pixelX > RightX) or (pixelY < TopY) then exit;

if isLandscapeEdge(getPixelWeight(landX, landY)) then

    begin

    if (LandPixelGet(pixelY, pixelX) and AMask < 255) and (LandPixelGet(pixelY, pixelX) and AMask > 0) then

        LandPixelSet(pixelY, pixelX, (IceEdgeColor and (not AMask)) or (LandPixelGet(pixelY, pixelX) and AMask))

    else if (LandPixelGet(pixelY, pixelX) and AMask < 255) or (LandGet(landY, landX) > 255) then

        LandPixelSet(pixelY, pixelX, IceEdgeColor)

    end

else if LandGet(landY, landX) > 255 then

    begin

        fillPixelFromIceSprite(pixelX, pixelY);

    end;

if LandGet(landY, landX) > 255 then LandSet(landY, landX, LandGet(landY, landX) or lfIce and (not lfDamaged));

end;

function FillLandCircleLineFT(y, fromPix, toPix: LongInt; fill : fillType): Longword;

var px, py, i: LongInt;

begin

//get rid of compiler warning

    px := 0;

    py := 0;

    FillLandCircleLineFT := 0;

    case fill of

    backgroundPixel:

        for i:= fromPix to toPix do

            begin

            calculatePixelsCoordinates(i, y, px, py);

            inc(FillLandCircleLineFT, drawPixelBG(i, y, px, py));

            end;

    ebcPixel:

        for i:= fromPix to toPix do

            begin

            calculatePixelsCoordinates(i, y, px, py);

            drawPixelEBC(i, y, px, py);

            end;

    nullPixel:

        for i:= fromPix to toPix do

            begin

            calculatePixelsCoordinates(i, y, px, py);

            if ((LandGet(y, i) and lfIndestructible) = 0) and (not disableLandBack or (LandGet(y, i) > 255))  then

                LandPixelSet(py, px, ExplosionBorderColorNoA);

            end;

    icePixel:

        for i:= fromPix to toPix do

            begin

            calculatePixelsCoordinates(i, y, px, py);

            DrawPixelIce(i, y, px, py);

            end;

    addNotHHObj:

        for i:= fromPix to toPix do

            begin

            if LandGet(y, i) and lfNotHHObjMask shr lfNotHHObjShift < lfNotHHObjSize then

                LandSet(y, i, (LandGet(y, i) and (not lfNotHHObjMask)) or ((LandGet(y, i) and lfNotHHObjMask shr lfNotHHObjShift + 1) shl lfNotHHObjShift));

            end;

    removeNotHHObj:

        for i:= fromPix to toPix do

            begin

            if LandGet(y, i) and lfNotHHObjMask <> 0 then

                LandSet(y, i, (LandGet(y, i) and (not lfNotHHObjMask)) or ((LandGet(y, i) and lfNotHHObjMask shr lfNotHHObjShift - 1) shl lfNotHHObjShift));

            end;

    addHH:

        for i:= fromPix to toPix do

            begin

            if LandGet(y, i) and lfHHMask < lfHHMask then

                LandSet(y, i, LandGet(y, i) + 1)

            end;

    removeHH:

        for i:= fromPix to toPix do

            begin

            if LandGet(y, i) and lfHHMask > 0 then

                LandSet(y, i, LandGet(y, i) - 1);

            end;

    setCurrentHog:

        for i:= fromPix to toPix do

            begin

            LandSet(y, i, LandGet(y, i) or lfCurHogCrate)

            end;

    removeCurrentHog:

        for i:= fromPix to toPix do

            begin

            LandSet(y, i, LandGet(y, i) and lfNotCurHogCrate);

            end;

    end;

end;

function FillLandCircleSegmentFT(x, y, dx, dy: LongInt; fill : fillType): Longword;

begin

    FillLandCircleSegmentFT := 0;

if ((y + dy) and LAND_HEIGHT_MASK) = 0 then

    inc(FillLandCircleSegmentFT, FillLandCircleLineFT(y + dy, Max(x - dx, 0), Min(x + dx, LAND_WIDTH - 1), fill));

if ((y - dy) and LAND_HEIGHT_MASK) = 0 then

    inc(FillLandCircleSegmentFT, FillLandCircleLineFT(y - dy, Max(x - dx, 0), Min(x + dx, LAND_WIDTH - 1), fill));

if ((y + dx) and LAND_HEIGHT_MASK) = 0 then

    inc(FillLandCircleSegmentFT, FillLandCircleLineFT(y + dx, Max(x - dy, 0), Min(x + dy, LAND_WIDTH - 1), fill));

if ((y - dx) and LAND_HEIGHT_MASK) = 0 then

    inc(FillLandCircleSegmentFT, FillLandCircleLineFT(y - dx, Max(x - dy, 0), Min(x + dy, LAND_WIDTH - 1), fill));

end;

function FillRoundInLandFT(X, Y, Radius: LongInt; fill: fillType): Longword;

var dx, dy, d: LongInt;

begin

dx:= 0;

dy:= Radius;

d:= 3 - 2 * Radius;

FillRoundInLandFT := 0;

while (dx < dy) do

    begin

    inc(FillRoundInLandFT, FillLandCircleSegmentFT(x, y, dx, dy, fill));

    if (d < 0) then

        d:= d + 4 * dx + 6

    else

        begin

        d:= d + 4 * (dx - dy) + 10;

        dec(dy)

        end;

    inc(dx)

    end;

if (dx = dy) then

    inc (FillRoundInLandFT, FillLandCircleSegmentFT(x, y, dx, dy, fill));

end;

function addBgColor(OldColor, NewColor: LongWord): LongWord;

// Factor ranges from 0 to 100% NewColor

var

    oRed, oBlue, oGreen, oAlpha, nRed, nBlue, nGreen, nAlpha: byte;

begin

    oAlpha := (OldColor shr AShift);

    nAlpha := (NewColor shr AShift);

    // shortcircuit

    if (oAlpha = 0) or (nAlpha = $FF) then

        begin

        addBgColor:= NewColor;

        exit

        end;

    // Get colors

    oRed   := (OldColor shr RShift);

    oGreen := (OldColor shr GShift);

    oBlue  := (OldColor shr BShift);

    nRed   := (NewColor shr RShift);

    nGreen := (NewColor shr GShift);

    nBlue  := (NewColor shr BShift);

    // Mix colors

    nRed   := min(255,((nRed*nAlpha) div 255) + ((oRed*oAlpha*byte(255-nAlpha)) div 65025));

    nGreen := min(255,((nGreen*nAlpha) div 255) + ((oGreen*oAlpha*byte(255-nAlpha)) div 65025));

    nBlue  := min(255,((nBlue*nAlpha) div 255) + ((oBlue*oAlpha*byte(255-nAlpha)) div 65025));

    nAlpha := min(255, oAlpha + nAlpha);

    addBgColor := (nAlpha shl AShift) or (nRed shl RShift) or (nGreen shl GShift) or (nBlue shl BShift);

end;

function FillCircleLines(x, y, dx, dy: LongInt; Value: Longword): Longword;

var i: LongInt;

begin

    FillCircleLines:= 0;

    if ((y + dy) and LAND_HEIGHT_MASK) = 0 then

        for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do

            if (LandGet(y + dy, i) and lfIndestructible) = 0 then

            begin

                if LandGet(y + dy, i) <> Value then inc(FillCircleLines);

                LandSet(y + dy, i, Value);

            end;

    if ((y - dy) and LAND_HEIGHT_MASK) = 0 then

        for i:= Max(x - dx, 0) to Min(x + dx, LAND_WIDTH - 1) do

            if (LandGet(y - dy, i) and lfIndestructible) = 0 then

            begin

                if LandGet(y - dy, i) <> Value then inc(FillCircleLines);

                LandSet(y - dy, i, Value);

            end;

    if ((y + dx) and LAND_HEIGHT_MASK) = 0 then

        for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do

            if (LandGet(y + dx, i) and lfIndestructible) = 0 then

            begin

                if LandGet(y + dx, i) <> Value then inc(FillCircleLines);

                LandSet(y + dx, i, Value);

            end;

    if ((y - dx) and LAND_HEIGHT_MASK) = 0 then

        for i:= Max(x - dy, 0) to Min(x + dy, LAND_WIDTH - 1) do

            if (LandGet(y - dx, i) and lfIndestructible) = 0 then

            begin

                if LandGet(y - dx, i) <> Value then inc(FillCircleLines);

                LandSet(y - dx, i, Value);

            end;

end;

function FillRoundInLand(X, Y, Radius: LongInt; Value: Longword): Longword;

var dx, dy, d: LongInt;

begin

FillRoundInLand:= 0;

dx:= 0;

dy:= Radius;

d:= 3 - 2 * Radius;

while (dx < dy) do

    begin

    inc(FillRoundInLand, FillCircleLines(x, y, dx, dy, Value));

    if (d < 0) then

        d:= d + 4 * dx + 6

    else

        begin

        d:= d + 4 * (dx - dy) + 10;

        dec(dy)

        end;

    inc(dx)

    end;

if (dx = dy) then

    inc(FillRoundInLand, FillCircleLines(x, y, dx, dy, Value));

end;

procedure ChangeRoundInLand(X, Y, Radius: LongInt; doSet, isCurrent, isHH: boolean);

begin

if not doSet and isCurrent then

    FillRoundInLandFT(X, Y, Radius, removeCurrentHog)

else if (not doSet) and (not IsCurrent) and isHH then

    FillRoundInLandFT(X, Y, Radius, removeHH)

else if (not doSet) and (not IsCurrent) and (not isHH) then

    FillRoundInLandFT(X, Y, Radius, removeNotHHObj)

else if doSet and IsCurrent then

    FillRoundInLandFT(X, Y, Radius, setCurrentHog)

else if doSet and (not IsCurrent) and isHH then

    FillRoundInLandFT(X, Y, Radius, addHH)

else if doSet and (not IsCurrent) and (not isHH) then

    FillRoundInLandFT(X, Y, Radius, addNotHHObj);

end;

procedure DrawIceBreak(x, y, iceRadius, iceHeight: Longint);

var

    i, j, iceL, iceR, IceT, iceB: LongInt;

    landRect: TSDL_Rect;

begin

// figure out bottom/left/right/top coords of ice to draw

// determine absolute limits first

iceT:= 0;

iceB:= min(cWaterLine, LAND_HEIGHT - 1);

iceL:= 0;

iceR:= LAND_WIDTH - 1;

if WorldEdge <> weNone then

    begin

    iceL:= max(leftX,  iceL);

    iceR:= min(rightX, iceR);

    end;

// adjust based on location but without violating absolute limits

if y >= cWaterLine then

    begin

    iceL:= max(x - iceRadius, iceL);

    iceR:= min(x + iceRadius, iceR);

    iceT:= max(cWaterLine - iceHeight, iceT);

    end

else {if WorldEdge = weSea then}

    begin

    iceT:= max(y - iceRadius, iceT);

    iceB:= min(y + iceRadius, iceB);

    if x <= leftX then

        iceR:= min(leftX + iceHeight, iceR)

    else {if x >= rightX then}

        iceL:= max(rightX - iceHeight, iceL);

    end;

// don't continue if all ice is outside land array

if (iceL > iceR) or (iceT > iceB) then

    exit();

for i := iceL to iceR do

    begin

    for j := iceT to iceB do

        begin

        if LandGet(j, i) = 0 then

            begin

            LandSet(j, i, lfIce);

            if (cReducedQuality and rqBlurryLand) = 0 then

                fillPixelFromIceSprite(i, j)

            else

                fillPixelFromIceSprite(i div 2, j div 2);

            end;

        end;

    end;

landRect.x := iceL;

landRect.y := iceT;

landRect.w := iceR - IceL + 1;

landRect.h := iceB - iceT + 1;

UpdateLandTexture(landRect.x, landRect.w, landRect.y, landRect.h, true);

end;

function DrawExplosion(X, Y, Radius: LongInt): Longword;

var

    tx, ty, dx, dy: Longint;

begin

    DrawExplosion := FillRoundInLandFT(x, y, Radius, backgroundPixel);

    if Radius > 20 then

        FillRoundInLandFT(x, y, Radius - 15, nullPixel);

    FillRoundInLand(X, Y, Radius, 0);

    FillRoundInLandFT(x, y, Radius + 4, ebcPixel);

    tx:= Max(X - Radius - 5, 0);

    dx:= Min(X + Radius + 5, LAND_WIDTH) - tx;

    ty:= Max(Y - Radius - 5, 0);

    dy:= Min(Y + Radius + 5, LAND_HEIGHT) - ty;

    UpdateLandTexture(tx, dx, ty, dy, false);

end;

procedure DrawHLinesExplosions(ar: PRangeArray; Radius: LongInt; y, dY: LongInt; Count: Byte);

var tx, ty, by, bx,  i: LongInt;

begin

for i:= 0 to Pred(Count) do

    begin

    for ty:= Max(y - Radius, 0) to Min(y + Radius, TopY) do

        for tx:= Max(LeftX, ar^[i].Left - Radius) to Min(RightX, ar^[i].Right + Radius) do