(*

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

interface

uses SDLh, uLandTemplates, uFloat, uConsts, uTypes, uAILandMarks;

procedure initModule;

procedure freeModule;

procedure DrawBottomBorder;

procedure GenMap;

procedure GenPreview(out Preview: TPreview);

procedure GenPreviewAlpha(out Preview: TPreviewAlpha);

implementation

uses uConsole, uStore, uRandom, uLandObjects, uIO, uLandTexture, SysUtils,

     uVariables, uUtils, uCommands, adler32, uDebug, uLandPainted, uTextures,

     uLandGenMaze, uLandOutline, uPhysFSLayer, uScript, uLandGenPerlin;

var digest: shortstring;

procedure ResizeLand(width, height: LongWord);

var potW, potH: LongInt;

begin

potW:= toPowerOf2(width);

potH:= toPowerOf2(height);

if (potW <> LAND_WIDTH) or (potH <> LAND_HEIGHT) then

    begin

    LAND_WIDTH:= potW;

    LAND_HEIGHT:= potH;

    LAND_WIDTH_MASK:= not(LAND_WIDTH-1);

    LAND_HEIGHT_MASK:= not(LAND_HEIGHT-1);

    cWaterLine:= LAND_HEIGHT;

    if (cReducedQuality and rqBlurryLand) = 0 then

        SetLength(LandPixels, LAND_HEIGHT, LAND_WIDTH)

    else

        SetLength(LandPixels, LAND_HEIGHT div 2, LAND_WIDTH div 2);

    SetLength(Land, LAND_HEIGHT, LAND_WIDTH);

    SetLength(LandDirty, (LAND_HEIGHT div 32), (LAND_WIDTH div 32));

    // 0.5 is already approaching on unplayable

    if (width div 4096 >= 2) or (height div 2048 >= 2) then cMaxZoomLevel:= 0.5;

    cMinMaxZoomLevelDelta:= cMaxZoomLevel - cMinZoomLevel

    end;

end;

procedure PrettifyLandAlpha();

begin

    if (cReducedQuality and rqBlurryLand) <> 0 then

        PrettifyAlpha2D(LandPixels, LAND_HEIGHT div 2, LAND_WIDTH div 2)

    else

        PrettifyAlpha2D(LandPixels, LAND_HEIGHT, LAND_WIDTH);

end;

procedure DrawBorderFromImage(Surface: PSDL_Surface);

var tmpsurf: PSDL_Surface;

    r, rr: TSDL_Rect;

    x, yd, yu: LongInt;

begin

    tmpsurf:= LoadDataImage(ptCurrTheme, 'Border', ifCritical or ifIgnoreCaps or ifTransparent);

    for x:= 0 to LAND_WIDTH - 1 do

    begin

        yd:= LAND_HEIGHT - 1;

        repeat

            while (yd > 0) and (Land[yd, x] =  0) do dec(yd);

            if (yd < 0) then

                yd:= 0;

            while (yd < LAND_HEIGHT) and (Land[yd, x] <> 0) do

                inc(yd);

            dec(yd);

            yu:= yd;

            while (yu > 0  ) and (Land[yu, x] <> 0) do dec(yu);

            while (yu < yd ) and (Land[yu, x] =  0) do inc(yu);

            if (yd < LAND_HEIGHT - 1) and ((yd - yu) >= 16) then

                begin

                rr.x:= x;

                rr.y:= yd - 15;

                r.x:= x mod tmpsurf^.w;

                r.y:= 16;

                r.w:= 1;

                r.h:= 16;

                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);

                end;

            if (yu > 0) then

                begin

                rr.x:= x;

                rr.y:= yu;

                r.x:= x mod tmpsurf^.w;

                r.y:= 0;

                r.w:= 1;

                r.h:= Min(16, yd - yu + 1);

                SDL_UpperBlit(tmpsurf, @r, Surface, @rr);

                end;

            yd:= yu - 1;

        until yd < 0;

    end;

    SDL_FreeSurface(tmpsurf);

end;

procedure DrawShoppaBorder;

var x, y, s, i: Longword;

    c1, c2, c: Longword;

begin

    c1:= AMask;

    c2:= AMask or RMask or GMask;

    // vertical

    s:= LAND_HEIGHT;

    for x:= 0 to LAND_WIDTH - 1 do

        for y:= 0 to LAND_HEIGHT - 1 do

            if Land[y, x] = 0 then

                if s < y then

                    begin

                    for i:= max(s, y - 8) to y - 1 do

                        begin

                        if ((x + i) and 16) = 0 then c:= c1 else c:= c2;

                        if (cReducedQuality and rqBlurryLand) = 0 then

                            LandPixels[i, x]:= c

                        else

                            LandPixels[i div 2, x div 2]:= c

                        end;

                    s:= LAND_HEIGHT

                    end

                else

            else

                begin

                if s > y then s:= y;

                if s + 8 > y then

                    begin

                    if ((x + y) and 16) = 0 then c:= c1 else c:= c2;

                    if (cReducedQuality and rqBlurryLand) = 0 then

                        LandPixels[y, x]:= c

                    else

                        LandPixels[y div 2, x div 2]:= c

                    end;

                end;

    // horizontal

    s:= LAND_WIDTH;

    for y:= 0 to LAND_HEIGHT - 1 do

        for x:= 0 to LAND_WIDTH - 1 do

            if Land[y, x] = 0 then

                if s < x then

                    begin

                    for i:= max(s, x - 8) to x - 1 do

                        begin

                        if ((y + i) and 16) = 0 then c:= c1 else c:= c2;

                        if (cReducedQuality and rqBlurryLand) = 0 then

                            LandPixels[y, i]:= c

                        else

                            LandPixels[y div 2, i div 2]:= c

                        end;

                    s:= LAND_WIDTH

                    end

                else

            else

                begin

                if s > x then s:= x;

                if s + 8 > x then

                    begin

                    if ((x + y) and 16) = 0 then c:= c1 else c:= c2;

                    if (cReducedQuality and rqBlurryLand) = 0 then

                        LandPixels[y, x]:= c

                    else

                        LandPixels[y div 2, x div 2]:= c

                    end;

                end

end;

procedure ColorizeLand(Surface: PSDL_Surface);

var tmpsurf: PSDL_Surface;

    r: TSDL_Rect;

    y: LongWord; // stupid SDL 1.2 uses stupid SmallInt for y which limits us to 32767.  But is even worse if LandTex is large, can overflow on 32767 map.

begin

    tmpsurf:= LoadDataImage(ptCurrTheme, 'LandTex', ifCritical or ifIgnoreCaps);

    r.y:= 0;

    y:= 0;

    while y < LAND_HEIGHT do

        begin

        r.x:= 0;

        while r.x < LAND_WIDTH do

            begin

            SDL_UpperBlit(tmpsurf, nil, Surface, @r);

            inc(r.x, tmpsurf^.w)

            end;

        inc(y, tmpsurf^.h);

        r.y:= y

        end;

    SDL_FreeSurface(tmpsurf);

    // freed in freeModule() below

    LandBackSurface:= LoadDataImage(ptCurrTheme, 'LandBackTex', ifIgnoreCaps or ifTransparent);

    if (LandBackSurface <> nil) and GrayScale then Surface2GrayScale(LandBackSurface);

end;

procedure SetPoints(var Template: TEdgeTemplate; var pa: TPixAr; fps: PPointArray);

var i: LongInt;

begin

with Template do

    begin

    pa.Count:= BasePointsCount;

    for i:= 0 to pred(pa.Count) do

        begin

        pa.ar[i].x:= BasePoints^[i].x + LongInt(GetRandom(BasePoints^[i].w));

        if pa.ar[i].x <> NTPX then

           pa.ar[i].x:= pa.ar[i].x + ((LAND_WIDTH - Template.TemplateWidth) div 2);

        pa.ar[i].y:= BasePoints^[i].y + LongInt(GetRandom(BasePoints^[i].h)) + LAND_HEIGHT - LongInt(Template.TemplateHeight)

        end;

    if canMirror then

        if getrandom(2) = 0 then

            begin

            for i:= 0 to pred(BasePointsCount) do

               if pa.ar[i].x <> NTPX then

                   pa.ar[i].x:= LAND_WIDTH - 1 - pa.ar[i].x;

            for i:= 0 to pred(FillPointsCount) do

                fps^[i].x:= LAND_WIDTH - 1 - fps^[i].x;

            end;

(*  Experiment in making this option more useful

     if ((not isNegative) and (cTemplateFilter = 4)) or

        (canFlip and (getrandom(2) = 0)) then

           begin

           for i:= 0 to pred(BasePointsCount) do

               begin

               pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y + (LAND_HEIGHT - TemplateHeight) * 2;

               if pa.ar[i].y > LAND_HEIGHT - 1 then

                   pa.ar[i].y:= LAND_HEIGHT - 1;

               end;

           for i:= 0 to pred(FillPointsCount) do

               begin

               FillPoints^[i].y:= LAND_HEIGHT - 1 - FillPoints^[i].y + (LAND_HEIGHT - TemplateHeight) * 2;

               if FillPoints^[i].y > LAND_HEIGHT - 1 then

                   FillPoints^[i].y:= LAND_HEIGHT - 1;

               end;

           end;

     end

*)

// template recycling.  Pull these off the floor a bit

    if (not isNegative) and (cTemplateFilter = 4) then

        begin

        for i:= 0 to pred(BasePointsCount) do

            begin

            dec(pa.ar[i].y, 100);

            if pa.ar[i].y < 0 then

                pa.ar[i].y:= 0;

            end;

        for i:= 0 to pred(FillPointsCount) do

            begin

            dec(fps^[i].y, 100);

            if fps^[i].y < 0 then

                fps^[i].y:= 0;

            end;

        end;

    if (canFlip and (getrandom(2) = 0)) then

        begin

        for i:= 0 to pred(BasePointsCount) do

            pa.ar[i].y:= LAND_HEIGHT - 1 - pa.ar[i].y;

        for i:= 0 to pred(FillPointsCount) do

            fps^[i].y:= LAND_HEIGHT - 1 - fps^[i].y;

        end;

    end

end;

procedure GenBlank(var Template: TEdgeTemplate);

var pa: TPixAr;

    i: Longword;

    y, x: Longword;

    fps: TPointArray;

begin

    fps:=Template.FillPoints^;

    ResizeLand(Template.TemplateWidth, Template.TemplateHeight);

    for y:= 0 to LAND_HEIGHT - 1 do

        for x:= 0 to LAND_WIDTH - 1 do

            Land[y, x]:= lfBasic;

    {$HINTS OFF}

    SetPoints(Template, pa, @fps);

    {$HINTS ON}

    for i:= 1 to Template.BezierizeCount do

        begin

        BezierizeEdge(pa, _0_5);

        RandomizePoints(pa);

        RandomizePoints(pa)

        end;

    for i:= 1 to Template.RandPassesCount do

        RandomizePoints(pa);

    BezierizeEdge(pa, _0_1);

    DrawEdge(pa, 0);

    with Template do

        for i:= 0 to pred(FillPointsCount) do

            with fps[i] do

    DrawEdge(pa, lfBasic);

    MaxHedgehogs:= Template.MaxHedgehogs;

    hasGirders:= Template.hasGirders;

    playHeight:= Template.TemplateHeight;

    playWidth:= Template.TemplateWidth;

    leftX:= ((LAND_WIDTH - playWidth) div 2);

    rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;

    topY:= LAND_HEIGHT - playHeight;

    // HACK: force to only cavern even if a cavern map is invertable if cTemplateFilter = 4 ?

    if (cTemplateFilter = 4)

    or (Template.canInvert and (getrandom(2) = 0))

    or (not Template.canInvert and Template.isNegative) then

        begin

        hasBorder:= true;

        for y:= 0 to LAND_HEIGHT - 1 do

            for x:= 0 to LAND_WIDTH - 1 do

                if (y < topY) or (x < leftX) or (x > rightX) then

                    Land[y, x]:= 0

                else

                    begin

                    if Land[y, x] = 0 then

                        Land[y, x]:= lfBasic

                    else if Land[y, x] = lfBasic then

                        Land[y, x]:= 0;

                    end;

        end;

end;

procedure GenDrawnMap;

begin

    ResizeLand(4096, 2048);

    uLandPainted.Draw;

    MaxHedgehogs:= 48;

    hasGirders:= true;

    playHeight:= 2048;

    playWidth:= 4096;

    leftX:= ((LAND_WIDTH - playWidth) div 2);

    rightX:= (playWidth + ((LAND_WIDTH - playWidth) div 2)) - 1;

    topY:= LAND_HEIGHT - playHeight;

end;

function SelectTemplate: LongInt;

var l: LongInt;

begin

    if (cReducedQuality and rqLowRes) <> 0 then

        SelectTemplate:= SmallTemplates[getrandom(Succ(High(SmallTemplates)))]

    else

    begin

        if cTemplateFilter = 0 then

            begin

            l:= getRandom(GroupedTemplatesCount);

            repeat

                inc(cTemplateFilter);

                dec(l, TemplateCounts[cTemplateFilter]);

            until l < 0;

            end else getRandom(1);

        case cTemplateFilter of

        0: OutError('Ask unC0Rr about what you did wrong', true);

        1: SelectTemplate:= SmallTemplates[getrandom(TemplateCounts[cTemplateFilter])];

        2: SelectTemplate:= MediumTemplates[getrandom(TemplateCounts[cTemplateFilter])];

        3: SelectTemplate:= LargeTemplates[getrandom(TemplateCounts[cTemplateFilter])];

        4: SelectTemplate:= CavernTemplates[getrandom(TemplateCounts[cTemplateFilter])];

        5: SelectTemplate:= WackyTemplates[getrandom(TemplateCounts[cTemplateFilter])];

// For lua only!

        6: begin

           SelectTemplate:= min(LuaTemplateNumber,High(EdgeTemplates));

           GetRandom(2) // burn 1

           end

        end

    end;

    WriteLnToConsole('Selected template #'+inttostr(SelectTemplate)+' using filter #'+inttostr(cTemplateFilter));

end;

procedure LandSurface2LandPixels(Surface: PSDL_Surface);

var x, y: LongInt;

    p: PLongwordArray;

begin

TryDo(Surface <> nil, 'Assert (LandSurface <> nil) failed', true);

if SDL_MustLock(Surface) then

    SDLTry(SDL_LockSurface(Surface) >= 0, true);

p:= Surface^.pixels;

for y:= 0 to LAND_HEIGHT - 1 do

    begin

    for x:= 0 to LAND_WIDTH - 1 do

    if Land[y, x] <> 0 then

        if (cReducedQuality and rqBlurryLand) = 0 then

            LandPixels[y, x]:= p^[x] or AMask

        else

            LandPixels[y div 2, x div 2]:= p^[x] or AMask;

    p:= PLongwordArray(@(p^[Surface^.pitch div 4]));

    end;

if SDL_MustLock(Surface) then

    SDL_UnlockSurface(Surface);

end;

procedure GenLandSurface;

var tmpsurf: PSDL_Surface;

    x,y: Longword;

begin

    AddProgress();

    tmpsurf:= SDL_CreateRGBSurface(SDL_SWSURFACE, LAND_WIDTH, LAND_HEIGHT, 32, RMask, GMask, BMask, 0);

    TryDo(tmpsurf <> nil, 'Error creating pre-land surface', true);

    ColorizeLand(tmpsurf);

    if gameFlags and gfShoppaBorder = 0 then DrawBorderFromImage(tmpsurf);

    AddOnLandObjects(tmpsurf);

    LandSurface2LandPixels(tmpsurf);

    SDL_FreeSurface(tmpsurf);

    if gameFlags and gfShoppaBorder <> 0 then DrawShoppaBorder;

    for x:= leftX+2 to rightX-2 do

        for y:= topY+2 to LAND_HEIGHT-3 do

            if (Land[y, x] = 0) and

               (((Land[y, x-1] = lfBasic) and ((Land[y+1,x] = lfBasic)) or (Land[y-1,x] = lfBasic)) or

               ((Land[y, x+1] = lfBasic) and ((Land[y-1,x] = lfBasic) or (Land[y+1,x] = lfBasic)))) then

            begin

                if (cReducedQuality and rqBlurryLand) = 0 then

                    begin

                    if (Land[y, x-1] = lfBasic) and (LandPixels[y, x-1] and AMask <> 0) then

                        LandPixels[y, x]:= LandPixels[y, x-1]

                    else if (Land[y, x+1] = lfBasic) and (LandPixels[y, x+1] and AMask <> 0) then

                        LandPixels[y, x]:= LandPixels[y, x+1]

                    else if (Land[y-1, x] = lfBasic) and (LandPixels[y-1, x] and AMask <> 0) then

                        LandPixels[y, x]:= LandPixels[y-1, x]

                    else if (Land[y+1, x] = lfBasic) and (LandPixels[y+1, x] and AMask <> 0) then

                        LandPixels[y, x]:= LandPixels[y+1, x];

                    if (((LandPixels[y,x] and AMask) shr AShift) > 10) then

                        LandPixels[y,x]:= (LandPixels[y,x] and (not AMask)) or (128 shl AShift)

                    end;

                Land[y,x]:= lfObject

            end

            else if (Land[y, x] = 0) and

                    (((Land[y, x-1] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y+2,x] = lfBasic)) or

                    ((Land[y, x-1] = lfBasic) and (Land[y-1,x-1] = lfBasic) and (Land[y-2,x] = lfBasic)) or

                    ((Land[y, x+1] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y+2,x] = lfBasic)) or

                    ((Land[y, x+1] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y-2,x] = lfBasic)) or

                    ((Land[y+1, x] = lfBasic) and (Land[y+1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or

                    ((Land[y-1, x] = lfBasic) and (Land[y-1,x+1] = lfBasic) and (Land[y,x+2] = lfBasic)) or

                    ((Land[y+1, x] = lfBasic) and (Land[y+1,x-1] = lfBasic) and (Land[y,x-2] = lfBasic)) or