unit uFLSchemes;
interface
uses uFLTypes;

function getSchemesList: PPChar; cdecl;
procedure freeSchemesList;

function schemeByName(s: shortstring): PScheme;
procedure sendSchemeConfig(var scheme: TScheme);

implementation
uses uFLUtils, uFLIPC, uPhysFSLayer, uFLThemes;

const MAX_SCHEME_NAMES = 64;
type
    TSchemeArray = array [0..0] of TScheme;
    PSchemeArray = ^TSchemeArray;
var
    schemesList: PScheme;
    schemesNumber: LongInt;
    listOfSchemeNames: array[0..MAX_SCHEME_NAMES] of PChar;
    tmpScheme: TScheme;

const ints: array[0 .. 17] of record
            name: shortstring;
            param: ^LongInt;
        end = (
              (name: 'damagefactor'; param: @tmpScheme.damagefactor)
            , (name: 'turntime'; param: @tmpScheme.turntime)
            , (name: 'health'; param: @tmpScheme.health)
            , (name: 'suddendeath'; param: @tmpScheme.suddendeath)
            , (name: 'caseprobability'; param: @tmpScheme.caseprobability)
            , (name: 'minestime'; param: @tmpScheme.minestime)
            , (name: 'landadds'; param: @tmpScheme.landadds)
            , (name: 'minedudpct'; param: @tmpScheme.minedudpct)
            , (name: 'explosives'; param: @tmpScheme.explosives)
            , (name: 'minesnum'; param: @tmpScheme.minesnum)
            , (name: 'healthprobability'; param: @tmpScheme.healthprobability)
            , (name: 'healthcaseamount'; param: @tmpScheme.healthcaseamount)
            , (name: 'waterrise'; param: @tmpScheme.waterrise)
            , (name: 'healthdecrease'; param: @tmpScheme.healthdecrease)
            , (name: 'ropepct'; param: @tmpScheme.ropepct)
            , (name: 'getawaytime'; param: @tmpScheme.getawaytime)
            , (name: 'worldedge'; param: @tmpScheme.worldedge)
            , (name: 'airmines'; param: @tmpScheme.airmines)
              );
const bools: array[0 .. 24] of record
            name: shortstring;
            param: ^boolean;
            flag: Longword;
        end = (
              (name: 'fortsmode'; param: @tmpScheme.fortsmode; flag: $00001000)
            , (name: 'divteams'; param: @tmpScheme.divteams; flag: $00000010)
            , (name: 'solidland'; param: @tmpScheme.solidland; flag: $00000004)
            , (name: 'border'; param: @tmpScheme.border; flag: $00000008)
            , (name: 'lowgrav'; param: @tmpScheme.lowgrav; flag: $00000020)
            , (name: 'laser'; param: @tmpScheme.laser; flag: $00000040)
            , (name: 'invulnerability'; param: @tmpScheme.invulnerability; flag: $00000080)
            , (name: 'resethealth'; param: @tmpScheme.resethealth; flag: $00000100)
            , (name: 'vampiric'; param: @tmpScheme.vampiric; flag: $00000200)
            , (name: 'karma'; param: @tmpScheme.karma; flag: $00000400)
            , (name: 'artillery'; param: @tmpScheme.artillery; flag: $00000800)
            , (name: 'randomorder'; param: @tmpScheme.randomorder; flag: $00002000)
            , (name: 'king'; param: @tmpScheme.king; flag: $00004000)
            , (name: 'placehog'; param: @tmpScheme.placehog; flag: $00008000)
            , (name: 'sharedammo'; param: @tmpScheme.sharedammo; flag: $00010000)
            , (name: 'disablegirders'; param: @tmpScheme.disablegirders; flag: $00020000)
            , (name: 'disablewind'; param: @tmpScheme.disablewind; flag: $00800000)
            , (name: 'morewind'; param: @tmpScheme.morewind; flag: $01000000)
            , (name: 'tagteam'; param: @tmpScheme.tagteam; flag: $02000000)
            , (name: 'bottomborder'; param: @tmpScheme.bottomborder; flag: $04000000)
            , (name: 'disablelandobjects'; param: @tmpScheme.disablelandobjects; flag: $00040000)
            , (name: 'aisurvival'; param: @tmpScheme.aisurvival; flag: $00080000)
            , (name: 'infattack'; param: @tmpScheme.infattack; flag: $00100000)
            , (name: 'resetweps'; param: @tmpScheme.resetweps; flag: $00200000)
            , (name: 'perhogammo'; param: @tmpScheme.perhogammo; flag: $00400000)
              );

procedure loadSchemes;
var f: PFSFile;
    schemes: PSchemeArray;
    s: shortstring;
    l, i, ii: Longword;
    isFound: boolean;
begin
    f:= pfsOpenRead('/Config/schemes.ini');
    schemesNumber:= 0;

    if f <> nil then
    begin
        while (not pfsEOF(f)) and (schemesNumber = 0) do
        begin
            pfsReadLn(f, s);

            if copy(s, 1, 5) = 'size=' then
                schemesNumber:= strToInt(midStr(s, 6));
        end;

        //inc(schemesNumber); // add some default schemes

        schemesList:= GetMem(sizeof(schemesList^) * (schemesNumber + 1));
        schemes:= PSchemeArray(schemesList);

        while (not pfsEOF(f)) do
        begin
            pfsReadLn(f, s);

            i:= 1;
            while(i <= length(s)) and (s[i] <> '\') do inc(i);

            if i < length(s) then
            begin
                l:= strToInt(copy(s, 1, i - 1));
                delete(s, 1, i);

                if (l <= schemesNumber) and (l > 0) then
                begin
                    if copy(s, 1, 5) = 'name=' then
                        schemes^[l - 1].schemeName:= midStr(s, 6)
                    else if copy(s, 1, 12) = 'scriptparam=' then
                        schemes^[l - 1].scriptparam:= midStr(s, 13) else
                    begin
                        ii:= 0;
                        repeat
                            isFound:= readInt(ints[ii].name, s, PLongInt(ints[ii].param - @tmpScheme + @schemes^[l - 1])^);
                            inc(ii)
                        until isFound or (ii > High(ints));

                        if not isFound then
                            begin
                                ii:= 0;
                                repeat
                                    isFound:= readBool(bools[ii].name, s, PBoolean(bools[ii].param - @tmpScheme + @schemes^[l - 1])^);
                                    inc(ii)
                                until isFound or (ii > High(bools));
                            end;
                    end;
                end;
            end;
        end;

        pfsClose(f)
    end;
end;


function getSchemesList: PPChar; cdecl;
var i, t, l: Longword;
    scheme: PScheme;
begin
    if schemesList = nil then
        loadSchemes;

    t:= schemesNumber;
    if t >= MAX_SCHEME_NAMES then 
        t:= MAX_SCHEME_NAMES;

    scheme:= schemesList;
    for i:= 0 to Pred(t) do
    begin
        l:= length(scheme^.schemeName);
        if l >= 255 then l:= 254;
        scheme^.schemeName[l + 1]:= #0;
        listOfSchemeNames[i]:= @scheme^.schemeName[1];
        inc(scheme)
    end;

    listOfSchemeNames[t]:= nil;

    getSchemesList:= listOfSchemeNames
end;

function schemeByName(s: shortstring): PScheme;
var i: Longword;
    scheme: PScheme;
begin
    scheme:= schemesList;
    i:= 0;
    while (i < schemesNumber) and (scheme^.schemeName <> s) do
    begin
        inc(scheme);
        inc(i)
    end;

    if i < schemesNumber then schemeByName:= scheme else schemeByName:= nil
end;

procedure freeSchemesList;
begin
    if schemesList <> nil then
        FreeMem(schemesList, sizeof(schemesList^) * (schemesNumber + 1))
end;


procedure sendSchemeConfig(var scheme: TScheme);
var i: Longword;
    gf: Longword;
begin
    with scheme do
    begin
        if turntime <> 45 then
            ipcToEngine('e$turntime ' + inttostr(turntime * 1000));
        if minesnum <> 4 then
            ipcToEngine('e$minesnum ' + inttostr(minesnum));
        if damagefactor <> 100 then
            ipcToEngine('e$damagepct ' + inttostr(damagefactor));
        if worldedge > 0 then
            ipcToEngine('e$worldedge ' + inttostr(worldedge));
        if length(scriptparam) > 0 then
            ipcToEngine('e$scriptparam ' + scriptparam);
        if suddendeath <> 15 then
            ipcToEngine('e$sd_turns ' + inttostr(suddendeath));
        if waterrise <> 47 then
            ipcToEngine('e$waterrise ' + inttostr(waterrise));
        if ropepct <> 100 then
            ipcToEngine('e$ropepct ' + inttostr(ropepct));
        if getawaytime <> 100 then
            ipcToEngine('e$getawaytime ' + inttostr(getawaytime));
        if caseprobability <> 5 then
            ipcToEngine('e$casefreq ' + inttostr(caseprobability));
        if healthprobability <> 35 then
            ipcToEngine('e$healthprob ' + inttostr(healthprobability));
        if minestime <> 3 then
            ipcToEngine('e$minestime ' + inttostr(minestime * 1000));
        if minedudpct <> 0 then
            ipcToEngine('e$minedudpct ' + inttostr(minedudpct));
        if explosives <> 2 then
            ipcToEngine('e$explosives ' + inttostr(explosives));
        if airmines <> 0 then
            ipcToEngine('e$airmines ' + inttostr(airmines));
        if healthcaseamount <> 25 then
            ipcToEngine('e$hcaseamount ' + inttostr(healthcaseamount));
        if healthdecrease <> 5 then
            ipcToEngine('e$healthdec ' + inttostr(healthdecrease));

        gf:= 0;

        for i:= Low(bools) to High(bools) do
            if PBoolean(bools[i].param - @tmpScheme + @scheme)^ then
                gf:= gf or bools[i].flag;

        ipcToEngine('e$gmflags ' + inttostr(gf));
    end
end;

end.