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, uFLData;

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 .. 25] of record
            name: shortstring;
            param: ^boolean;
        end = (
              (name: 'fortsmode'; param: @tmpScheme.fortsmode)
            , (name: 'divteams'; param: @tmpScheme.divteams)
            , (name: 'solidland'; param: @tmpScheme.solidland)
            , (name: 'border'; param: @tmpScheme.border)
            , (name: 'lowgrav'; param: @tmpScheme.lowgrav)
            , (name: 'laser'; param: @tmpScheme.laser)
            , (name: 'invulnerability'; param: @tmpScheme.invulnerability)
            , (name: 'mines'; param: @tmpScheme.mines)
            , (name: 'vampiric'; param: @tmpScheme.vampiric)
            , (name: 'karma'; param: @tmpScheme.karma)
            , (name: 'artillery'; param: @tmpScheme.artillery)
            , (name: 'randomorder'; param: @tmpScheme.randomorder)
            , (name: 'king'; param: @tmpScheme.king)
            , (name: 'placehog'; param: @tmpScheme.placehog)
            , (name: 'sharedammo'; param: @tmpScheme.sharedammo)
            , (name: 'disablegirders'; param: @tmpScheme.disablegirders)
            , (name: 'disablewind'; param: @tmpScheme.disablewind)
            , (name: 'morewind'; param: @tmpScheme.morewind)
            , (name: 'tagteam'; param: @tmpScheme.tagteam)
            , (name: 'bottomborder'; param: @tmpScheme.bottomborder)
            , (name: 'resethealth'; param: @tmpScheme.resethealth)
            , (name: 'disablelandobjects'; param: @tmpScheme.disablelandobjects)
            , (name: 'aisurvival'; param: @tmpScheme.aisurvival)
            , (name: 'infattack'; param: @tmpScheme.infattack)
            , (name: 'resetweps'; param: @tmpScheme.resetweps)
            , (name: 'perhogammo'; param: @tmpScheme.perhogammo)
              );


procedure loadSchemes;
var f: PFSFile;
    scheme: PScheme;
    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;
begin
    with scheme do
    begin
        if scheme.turntime <> 45 then
            ipcToEngine('e$turntime ' + inttostr(scheme.turntime * 1000));
        if scheme.minesnum <> 4 then
            ipcToEngine('e$minesnum ' + inttostr(scheme.minesnum));
    end
end;

end.