Limit adjuster

    // Initializes limit adjuster.
    void CLimitAdjusterForGame::InitLimitAdjuster()
    {
        const char* iniFilename;

        if(bUseDevelopmentIni)
            iniFilename = "fastman92limitAdjuster_GTASA_dev.ini";
        else
            iniFilename = "fastman92limitAdjuster_GTASA.ini";

        this -> OpenIniFile(iniFilename);

        #if TRUE
        {
            CPatch::AddForbiddenMemoryRegion(0x4C9970, 0x4CDDE0);
            CPatch::AddForbiddenMemoryRegion(0x598000, 0x598010);
            CPatch::AddForbiddenMemoryRegion(0x5C26B0, 0x5D0240);
            CPatch::AddForbiddenMemoryRegion(0x748F20, 0x77F0BB);
            CPatch::AddForbiddenMemoryRegion(0x7C45E0, 0x7CF600);
            CPatch::AddForbiddenMemoryRegion(0x7EC760, 0x837170);
            CPatch::AddForbiddenMemoryRegion(0xCB1000, 0x1560930);
        }
        #endif

        CCodeMover::Init(150000, true);

        ModelIDlimit::Initialize();

        {
            GetPrivateProfileStringA("ID LIMITS", "Apply ID limit patch", NULL, cTmp, sizeof(cTmp), cPath);
            ModelIDlimit::EnableIDlimitsPatch(strlen(cTmp) && atoi(cTmp));
        }

        // Map limits
        {
            MapLimits::InitChanges();

            GetPrivateProfileStringA("MAP LIMITS", "Apply paths limit patch", NULL, cTmp, sizeof(cTmp), cPath);

            if (strlen(cTmp) && atoi(cTmp))
                MapLimits::EnablePathsLimitPatch(true);

            GetPrivateProfileStringA("MAP LIMITS", "Paths map size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetPathsMapSize(atoi(cTmp));
        }

        /////// ID LIMITS //////
        if (ModelIDlimit::IsIDlimitsPatchEnabled())
        {
            GetPrivateProfileStringA("ID LIMITS", "I want to increase the IPL limit and I know it may cause bugs", NULL, cTmp, sizeof(cTmp), cPath);

            if (strlen(cTmp) && atoi(cTmp))
                ModelIDlimit::SwitchIPLcheck(false);

            // Read possibly different values
            for (eFileType type = FILE_TYPE_DFF; type != FILE_TYPE_COUNT; type++)
            {
                const char* sType = tFileTypeNameMgr::GetEnumNameByMember(type);

                GetPrivateProfileStringA("ID LIMITS", sType, NULL, cTmp, sizeof(cTmp), cPath);

                if(strlen(cTmp))
                {
                    if(type == FILE_TYPE_DAT)
                    {
                        printf_MessageBox(
                            "FILE_TYPE_DAT is no longer valid entry for ID limits.\n"
                            "If you need, set the ([MAP LIMITS] Paths map size) instead."
                            );
                        CLimitAdjusterForGame::TerminateProcess();
                    }
                    else
                        ModelIDlimit::SetFileIDlimit(type, atoi(cTmp));
                }
            }

            ModelIDlimit::PatchFileIDlimits();
        }

        // Count of killable model IDs
        GetPrivateProfileStringA("ID LIMITS", "Count of killable model IDs", NULL, cTmp, sizeof(cTmp), cPath);

        if (strlen(cTmp))
            ModelIDlimit::PatchCountOfKillableModelIDs(atoi(cTmp));


        // Car generators
        {
            GetPrivateProfileStringA("CAR STREAMING", "Car generators", NULL, cTmp, sizeof(cTmp), cPath);

            int numberOfCarGenerators = 500;

            bool isCarGeneratorLimitSetFromIni = strlen(cTmp) != 0;

            if (isCarGeneratorLimitSetFromIni)
                numberOfCarGenerators = atoi(cTmp);

            // extended format?
            bool isExtendedFormat = CarGeneratorLimit::IsFormatExtendedNeccessary();

            if(!isExtendedFormat)
            {
                GetPrivateProfileStringA("CAR STREAMING", "Use extended format for car generators", NULL, cTmp, sizeof(cTmp), cPath);

                if (strlen(cTmp) && atoi(cTmp))
                    isExtendedFormat = true;
            }

            // patch the limit
            if (isCarGeneratorLimitSetFromIni || isExtendedFormat)
                CarGeneratorLimit::PatchCarGeneratorsLimit(numberOfCarGenerators, isExtendedFormat);

            // counter passes
            GetPrivateProfileStringA("CAR STREAMING", "Number of process counter passes for car generators", NULL, cTmp, sizeof(cTmp), cPath);

            if(strlen(cTmp))
                CarGeneratorLimit::PatchNumberOfProcessCounterPasses(atoi(cTmp));

            // Accept any ID for car generator
            GetPrivateProfileStringA("CAR STREAMING", "Accept any ID for car generator", NULL, cTmp, sizeof(cTmp), cPath);
            if (atoi(cTmp))
                CarGeneratorLimit::AcceptAnyIDforCarGenerator();
        }

        ///////////////////////////////////////////////////

        ////// save game loading functions //////

        // Patches a loading function, the savefile of any length may be considered as valid savefile.

        // IPL and model flags from savefile.
        ModelIDlimit::PatchSaveBlockLoadingFunctions();

        // Car generators
        CarGeneratorLimit::PatchCarGeneratorSaveBlockLoadingFunction();

        // Save game of unlimited length
        SaveOfVariableLength::PatchLoadingFunction();

        //////                             //////

        // Map limits
        #if TRUE
        {
            GetPrivateProfileStringA("MAP LIMITS", "Radar map size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetRadarSize(atoi(cTmp));

            GetPrivateProfileStringA("MAP LIMITS", "Water map size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetWaterMapSize(atoi(cTmp));

            GetPrivateProfileStringA("MAP LIMITS", "World map size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetWorldMapSize(atoi(cTmp));

            GetPrivateProfileStringA("MAP LIMITS", "World sector size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetWorldSectorSize(atoi(cTmp));

            GetPrivateProfileStringA("MAP LIMITS", "World LOD sector size", NULL, cTmp, sizeof(cTmp), cPath);
            if (strlen(cTmp))
                MapLimits::SetLODSectorSize(atoi(cTmp));

            MapLimits::CommitChanges();
        }
        #endif

        // handling.cfg limits
        GetPrivateProfileStringA("HANDLING.CFG LIMITS", "Apply handling.cfg patch", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp) && atoi(cTmp))
        {
            struct {
                const char* property;
                void (* method)(unsigned int iValue);
            } handlingLimits[] =
            {
                { "Number of standard lines", HandlingCfgLimits::SetStandardLinesLimit },
                { "Number of bike lines", HandlingCfgLimits::SetBikeLinesLimit },
                { "Number of flying lines", HandlingCfgLimits::SetFlyingLinesLimit },
                { "Number of boat lines", HandlingCfgLimits::SetBoatLinesLimit },
                { "Number of animation group lines", HandlingCfgLimits::SetAnimationGroupLinesLimit }
            };

            for (int i = 0; i < _countof(handlingLimits); i++)
            {
                GetPrivateProfileStringA("HANDLING.CFG LIMITS", handlingLimits[i].property, NULL, cTmp, sizeof(cTmp), cPath);

                // printf_MessageBox("option: %s %s %d\n", handlingLimits[i].property, cTmp, atoi(cTmp));

                if (strlen(cTmp))
                    handlingLimits[i].method(atoi(cTmp));
            }

            HandlingCfgLimits::PatchHandlingCfgLimit();
        }

        // VehicleStructs
        GetPrivateProfileStringA("DYNAMIC LIMITS", "VehicleStructs", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            DynamicLimits::SetVehicleStructs(atoi(cTmp));

        // rwObjectInstances
        GetPrivateProfileStringA("DYNAMIC LIMITS", "rwObjectInstances", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            DynamicLimits::SetRwObjectInstances(atoi(cTmp));

        // Matrices
        GetPrivateProfileStringA("DYNAMIC LIMITS", "Matrices", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            DynamicLimits::SetMatrices(atoi(cTmp));

        // IPL: inst
        GetPrivateProfileStringA("IPL", "Buildings", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetIplBuildings(atoi(cTmp));

        // IPL: inst entries per file
        GetPrivateProfileStringA("IPL", "Inst entries per file", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetInstLimitPerFile(atoi(cTmp));

        // IPL: map zones
        GetPrivateProfileStringA("IPL", "Map zones", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetMapZones(atoi(cTmp));

        // IPL: navigation zones
        GetPrivateProfileStringA("IPL", "Navigation zones", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetNavigationZones(atoi(cTmp));

        // IPL: occl for interiors
        GetPrivateProfileStringA("IPL", "Interior occluders", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetInteriorOccluders(atoi(cTmp));

        // ; IPL: occl for map (1000)
        GetPrivateProfileStringA("IPL", "Occluders", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IPLsectionLimits::SetOccluders(atoi(cTmp));

        // ColModels
        GetPrivateProfileStringA("DYNAMIC LIMITS", "ColModels", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            DynamicLimits::SetColModels(atoi(cTmp));

        // IDE: objs
        GetPrivateProfileStringA("IDE LIMITS", "IDE Objects Type 1", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetIDEobjsType1(atoi(cTmp));

        // IDE: objs
        GetPrivateProfileStringA("IDE LIMITS", "IDE Objects Type 2", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetIDEobjsType2(atoi(cTmp));

        // IDE: tobjs
        GetPrivateProfileStringA("IDE LIMITS", "Hier Objects", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetHierObjects(atoi(cTmp));

        // IDE: tobjs
        GetPrivateProfileStringA("IDE LIMITS", "Timed Objects", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetTimedObjects(atoi(cTmp));

        // IDE : cars
        GetPrivateProfileStringA("IDE LIMITS", "Vehicle Models", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetVehicleModels(atoi(cTmp));

        // IDE : peds
        GetPrivateProfileStringA("IDE LIMITS", "Ped Models", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetPedModels(atoi(cTmp));

        // IDE : peds
        GetPrivateProfileStringA("IDE LIMITS", "Weapon Models", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            IDEsectionLimits::SetWeaponModels(atoi(cTmp));

        //// IMG limits ////
        GetPrivateProfileStringA("IMG LIMITS", "Max number of IMG archives", NULL, cTmp, sizeof(cTmp), cPath);

        if (strlen(cTmp))
            IMGlimits::SetLimitOfIMGarchives(atoi(cTmp));


        // Cargrp cars per group
        GetPrivateProfileStringA("CAR STREAMING", "Cargrp cars per group", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            CargrpLimit::SetCargrpLimit(34, atoi(cTmp));

        // Car streaming : DesiredNumberOfVehiclesLoaded
        GetPrivateProfileStringA("CAR STREAMING", "Streaming_DesiredNumberOfVehiclesLoaded", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            StreamingLimits::SetStreamingDesiredNumberOfVehiclesLoaded(atoi(cTmp));

        // Car streaming
        GetPrivateProfileStringA("STREAMING", "Memory available", NULL, cTmp, sizeof(cTmp), cPath);
        if (strlen(cTmp))
            StreamingLimits::SetMemoryAvailable(atoi(cTmp) * 1024 * 1024);

        // SCM limits
        {
            GetPrivateProfileStringA("SCM LIMITS", "Max size of MAIN segment", NULL, cTmp, sizeof(cTmp), cPath);

            if (strlen(cTmp))
                SCMlimits::SetMaxMAINsegmentSize(atoi(cTmp));

            GetPrivateProfileStringA("SCM LIMITS", "Max mission size", NULL, cTmp, sizeof(cTmp), cPath);

            if (strlen(cTmp))
                SCMlimits::SetMaxMissionSize(atoi(cTmp));

            SCMlimits::PatchScriptLimits();
        }

        // SPECIAL : MakeHelicoptersLandOnWater
        GetPrivateProfileStringA("SPECIAL", "Make helicopters land on water when cars on water cheat enabled", NULL, cTmp, sizeof(cTmp), cPath);
        if (atoi(cTmp))
            SpecialLimits::MakeHelicoptersLandOnWater();

        // SPECIAL : Disable plane speed limit
        GetPrivateProfileStringA("SPECIAL", "Disable plane speed limit", NULL, cTmp, sizeof(cTmp), cPath);
        if (atoi(cTmp))
            SpecialLimits::DisablePlaneSpeedLimit();

        // Patcher
        GetPrivateProfileStringA("PLUGIN PATCHES", "Enable plugin patches", NULL, cTmp, sizeof(cTmp), cPath);
        if (atoi(cTmp))
            CThePluginPatches::RegisterPatcher();
    }
}