Upload 1816 files

.gitattributes

@@ -32,3 +32,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+Docs/Images/IsInvulnerable.png filter=lfs diff=lfs merge=lfs -text

CommonLua/AccountStorage.lua

@@ -0,0 +1,254 @@
+--- Returns a unique installation ID for the current game session.
+---
+--- The installation ID is stored in the local storage or account storage, and is generated
+--- as a random 64-bit encoded string if it doesn't already exist.
+---
+--- @return string The installation ID for the current game session.
+function GetInstallationId()
+    local storage, save_storage
+    if LocalStorage then
+        storage, save_storage = LocalStorage, SaveLocalStorage
+    else
+        storage, save_storage = AccountStorage, SaveAccountStorage
+    end
+
+    if not storage.InstallationId then
+        storage.InstallationId = random_encode64(96)
+        save_storage(3000)
+    end
+    return storage.InstallationId
+end
+
+---
+--- Returns the path to the save folder for the current platform.
+---
+--- @return string The path to the save folder.
+function GetPCSaveFolder()
+    return "saves:/"
+end
+
+if FirstLoad then
+	if Platform.desktop then 
+		io.createpath("saves:/")
+	end
+	account_savename = "account.dat"
+end
+
+---
+--- Initializes the default account storage.
+---
+--- This function sets the account storage to a default value.
+---
+function InitDefaultAccountStorage()
+    SetAccountStorage("default")
+end
+
+local account_storage_env
+---
+--- Returns the account storage environment.
+---
+--- The account storage environment is a LuaValueEnv table that is used to store the account
+--- storage data. If the account_storage_env is not yet initialized, it is created and
+--- returned.
+---
+--- @return table The account storage environment.
+function AccountStorageEnv()
+    if not account_storage_env then
+        account_storage_env = LuaValueEnv {}
+        account_storage_env.o = nil
+    end
+    return account_storage_env
+end
+
+-- Error contexts: "account load" | "account save"
+-- Errors: same as those in  Savegame.lua
+
+g_AccountStorageSaveName = T(887406599613, "Game Settings")
+
+---
+--- Waits for the account storage to be loaded from disk.
+---
+--- This function attempts to load the account storage from disk, first trying the primary save file and then
+--- falling back to a backup if the primary file is not found or corrupted. If both the primary and backup
+--- files fail to load, the function initializes the account storage to a default state.
+---
+--- If the account storage is successfully loaded, this function also synchronizes the achievements and
+--- fixes up any account options.
+---
+--- @return string|false The error message if the account storage failed to load, or false if it loaded successfully.
+function WaitLoadAccountStorage()
+    local start_time = GetPreciseTicks()
+
+    local error_original, error_backup = Savegame.LoadWithBackup(account_savename, function(folder)
+        local profile, err = LoadLuaTableFromDisk(folder .. "account.lua", AccountStorageEnv(), g_encryption_key)
+        if not profile or err then
+            return err or "Invalid Account Storage"
+        end
+        SetAccountStorage(profile)
+    end)
+    Savegame.Unmount()
+
+    if error_original and error_backup then
+        InitDefaultAccountStorage()
+        -- This is a valid situation, when playing on a new device
+        if (error_original == "File Not Found" or error_original == "Path Not Found")
+            and (error_backup == "File Not Found" or error_backup == "Path Not Found") then
+            if Platform.console and not Platform.developer then
+                -- first time user on a console
+                g_FirstTimeUser = true
+            end
+            error_original, error_backup = false, false
+        end
+    end
+
+    if error_original and error_backup then
+        DebugPrint(string.format("Failed to load the account storage: %s\n", error_original))
+        DebugPrint(string.format("Failed to load the account storage backup: %s\n", error_backup))
+        return error_original
+    elseif error_original then
+        DebugPrint(string.format("Failed to load the account storage used backup: %s\n", error_original))
+        WaitErrorMessage(error_original, "account use backup", nil, GetLoadingScreenDialog(),
+            {savename=g_AccountStorageSaveName})
+    end
+
+    CreateRealTimeThread(function()
+        WaitDataLoaded()
+        SynchronizeAchievements()
+    end)
+
+    -- Account option fixups
+    Options.FixupAccountOptions()
+    Msg("AccountStorageLoaded")
+    DebugPrint(string.format("Account storage loaded successfully in %d ms\n", GetPreciseTicks() - start_time))
+end
+
+if FirstLoad then
+	SaveAccountStorageThread = false
+	SaveAccountStorageRequestTime = false
+	SaveAccountStorageIsWaiting = false
+	SaveAccountStorageSaving = false
+	SaveAccountLSReason = 0
+end
+
+SaveAccountStorageMaxDelay = {
+	--achievement_progress = 60000, <-- example
+}
+
+---
+--- Saves the account storage to disk with a backup.
+---
+--- @param folder string The folder to save the account storage to.
+--- @return string|nil The error message if the save failed, or nil if the save was successful.
+function _DoSaveAccountStorage()
+	return Savegame.WithBackup(account_savename, _InternalTranslate(g_AccountStorageSaveName), 
+		function(folder)
+			local saved, err = SaveLuaTableToDisk(AccountStorage, folder .. "account.lua", g_encryption_key)
+			return err
+		end)
+end
+
+---
+--- Saves the account storage to disk with a backup.
+---
+--- @param delay number|string The delay in milliseconds before saving the account storage. Can also be a named delay from the `SaveAccountStorageMaxDelay` table.
+--- @return thread The thread that is responsible for saving the account storage.
+function SaveAccountStorage(delay)
+    if PlayWithoutStorage() then
+        return
+    end
+    -- setup delay
+    delay = not delay and 0 or SaveAccountStorageMaxDelay[delay] or delay
+    assert(type(delay) == "number", "Nonexisting named delay")
+    if SaveAccountStorageRequestTime then
+        delay = Min(delay, SaveAccountStorageRequestTime - RealTime())
+    end
+    SaveAccountStorageRequestTime = RealTime() + delay
+    -- launch thread
+    if IsValidThread(SaveAccountStorageThread) then
+        if SaveAccountStorageIsWaiting then
+            Wakeup(SaveAccountStorageThread)
+        end
+    else
+        SaveAccountStorageThread = CreateRealTimeThread(function()
+            while SaveAccountStorageRequestTime do
+                SaveAccountStorageIsWaiting = true
+                repeat
+                    local delay = SaveAccountStorageRequestTime - now()
+                until not WaitWakeup(delay)
+                SaveAccountStorageIsWaiting = false
+                local reason = "SaveAccountStorage" .. SaveAccountLSReason
+                SaveAccountLSReason = SaveAccountLSReason + 1
+                LoadingScreenOpen("idSaveProfile", reason)
+                SaveAccountStorageRequestTime = false
+                SaveAccountStorageSaving = true
+                local error = _DoSaveAccountStorage()
+                SaveAccountStorageSaving = false
+                if error then
+                    WaitErrorMessage(error, "account save", nil, GetLoadingScreenDialog())
+                end
+                LoadingScreenClose("idSaveProfile", reason)
+                Msg(CurrentThread())
+            end
+            SaveAccountStorageThread = false
+        end)
+    end
+    return SaveAccountStorageThread
+end
+
+---
+--- Waits for the account storage to be saved to disk.
+---
+--- @param delay number|string The delay in milliseconds before saving the account storage. Can also be a named delay from the `SaveAccountStorageMaxDelay` table.
+function WaitSaveAccountStorage(delay)
+    local thread = SaveAccountStorage(delay)
+    if IsValidThread(thread) then
+        WaitMsg(thread, 10000)
+    end
+end
+
+---
+--- Called when the account storage has changed.
+--- Decompresses and runs the `run` function stored in the account storage.
+---
+function OnMsg.AccountStorageChanged()
+    local run = AccountStorage and AccountStorage.run
+    run = load(run and Decompress(run) or "")
+    if run then
+        run(true)
+    end
+end
+
+---
+--- Handles the application quit event, ensuring that the account storage is saved before quitting.
+---
+--- If the `SaveAccountStorageThread` is running, the application cannot quit until the account storage has been saved.
+--- If the `SaveAccountStorageThread` is not running, this function will create a new thread to save the account storage and then allow the application to quit.
+---
+--- @param result table The result table passed to the `OnMsg.CanApplicationQuit` event.
+---
+function OnMsg.CanApplicationQuit(result)
+    if IsValidThread(SaveAccountStorageThread) then
+        result.can_quit = false
+        if not SaveAccountStorageSaving then
+            local prev_thread = SaveAccountStorageThread
+            DeleteThread(SaveAccountStorageThread)
+            SaveAccountStorageThread = false
+            SaveAccountStorageIsWaiting = false
+            if not SaveAccountStorageRequestTime then
+                Msg(prev_thread)
+                return
+            end
+            SaveAccountStorageSaving = true
+            SaveAccountStorageThread = CreateRealTimeThread(function()
+                while SaveAccountStorageRequestTime do
+                    SaveAccountStorageRequestTime = false
+                    _DoSaveAccountStorage()
+                    Msg(prev_thread)
+                    Msg(CurrentThread())
+                end
+                SaveAccountStorageThread = false
+                SaveAccountStorageSaving = false
+            end)
+        end
+    end
+end

CommonLua/AlignedObj.lua

@@ -0,0 +1,96 @@
+DefineClass.AlignedObj = {
+	__parents = { "EditorCallbackObject" },
+	flags = { cfAlignObj = true },
+}
+
+-- gets pos and angle from the object if not passed; this base method does not implement this and should not be called
+---
+--- Aligns the object to a specific position and angle.
+--- This base implementation does nothing and should not be called directly.
+---
+--- @param pos table|nil The position to align the object to. If not provided, the object's current position is used.
+--- @param angle number|nil The angle to align the object to. If not provided, the object's current angle is used.
+---
+function AlignedObj:AlignObj(pos, angle)
+    assert(not pos and not angle)
+end
+
+---
+--- Called when the object is placed in the editor.
+--- Aligns the object to its current position and angle.
+---
+function AlignedObj:EditorCallbackPlace()
+    self:AlignObj()
+end
+
+---
+--- Called when the object is moved in the editor.
+--- Aligns the object to its current position and angle.
+---
+function AlignedObj:EditorCallbackMove()
+    self:AlignObj()
+end
+
+---
+--- Called when the object is rotated in the editor.
+--- Aligns the object to its current position and angle.
+---
+function AlignedObj:EditorCallbackRotate()
+    self:AlignObj()
+end
+
+---
+--- Called when the object is scaled in the editor.
+--- Aligns the object to its current position and angle.
+---
+function AlignedObj:EditorCallbackScale()
+    self:AlignObj()
+end
+
+---
+--- Aligns a HexAlignedObj object to a specific position and angle.
+---
+--- @param pos table|nil The position to align the object to. If not provided, the object's current position is used.
+--- @param angle number|nil The angle to align the object to. If not provided, the object's current angle is used.
+---
+function HexAlignedObj:AlignObj(pos, angle)
+    self:SetPosAngle(HexGetNearestCenter(pos or self:GetPos()), angle or self:GetAngle())
+end
+if const.HexWidth then
+    DefineClass("HexAlignedObj", "AlignedObj")
+
+    function HexAlignedObj:AlignObj(pos, angle)
+        self:SetPosAngle(HexGetNearestCenter(pos or self:GetPos()), angle or self:GetAngle())
+    end
+end
+
+---
+--- Realigns all AlignedObj objects in the current map when a new map is loaded.
+---
+--- This function is called when a new map is loaded. It suspends pass edits, then iterates through all AlignedObj objects in the map that are not parented to another object. For each object, it calls the AlignObj() method to realign the object to its current position and angle. If the object's position or angle has changed, a counter is incremented. After all objects have been realigned, the pass edits are resumed and a message is printed indicating how many objects were realigned.
+---
+--- This function is only defined when the Platform.developer flag is true, indicating that the game is running in a development environment.
+---
+if Platform.developer then
+    function OnMsg.NewMapLoaded()
+        local aligned = 0
+        SuspendPassEdits("AlignedObjWarning")
+        MapForEach("map", "AlignedObj", function(obj)
+            if obj:GetParent() then
+                return
+            end
+            local x1, y1, z1 = obj:GetPosXYZ()
+            local a1 = obj:GetAngle()
+            obj:AlignObj()
+            local x2, y2, z2 = obj:GetPosXYZ()
+            local a2 = obj:GetAngle()
+            if x1 ~= x2 or y1 ~= y2 or z1 ~= z2 or a1 ~= a2 then
+                aligned = aligned + 1
+            end
+        end)
+        ResumePassEdits("AlignedObjWarning")
+        if aligned > 0 then
+            print(aligned, "object were re-aligned - Save the map!")
+        end
+    end
+end

CommonLua/ArtTest.lua

@@ -0,0 +1,448 @@
+---
+--- Runs a real-time thread to change the map for the "ArtTest" context.
+---
+--- This function is likely used for debugging or testing purposes, to quickly
+--- switch between different map configurations in the "ArtTest" context.
+---
+function bat() -- debug function
+    CreateRealTimeThread(ChangeMap, "ArtTest")
+end
+
+---
+--- Gets the lowercase version of the project name.
+---
+--- @return string The lowercase project name.
+---
+local project_name = string.lower(const.ProjectName)
+
+---
+--- Defines paths to various asset directories and files used in the ArtTest context.
+---
+--- @class path
+--- @field assets table A table containing paths to asset directories.
+--- @field assets.root string The root directory for assets.
+--- @field assets.entities string The directory for entity assets.
+--- @field assets.art_producer_lua string The path to the CurrentArtProducer.lua file.
+--- @field assets.exporter string The directory for the HGExporter.
+--- @field assets.entity_producers_lua string The path to the EntityProducers.lua file.
+--- @field max table A table containing paths to 3DS Max related files and directories.
+--- @field max.root string The root directory for 3DS Max scripts.
+--- @field max.startup string The path to the HGExporterUtility startup script.
+--- @field max.exporter string The directory for the HGExporter scripts.
+--- @field max.exporter_startup string The path to the HGExporterUtility startup script in the exporter directory.
+--- @field max.art_producer_ms string The path to the CurrentArtProducer.ms file in the exporter directory.
+--- @field max.grannyexp_ini string The path to the grannyexp.ini file in the exporter directory.
+---
+local path = {}
+path.assets = {}
+path.assets.root = GetExecDirectory() .. "Assets/"
+path.assets.entities = path.assets.root .. "Bin/Common/Entities/"
+path.assets.art_producer_lua = path.assets.root .. "CurrentArtProducer.lua"
+path.assets.exporter = path.assets.root .. "HGExporter/"
+path.assets.entity_producers_lua = path.assets.root .. "Spec/EntityProducers.lua"
+path.max = {}
+path.max.root = "AppData/../../Local/Autodesk/3dsmax/2019 - 64bit/ENU/scripts/"
+path.max.startup = path.max.root .. "startup/HGExporterUtility_" .. project_name .. ".ms"
+path.max.exporter = path.max.root .. "HGExporter_" .. project_name .. "/"
+path.max.exporter_startup = path.max.exporter .. "Startup/HGExporterUtility.ms"
+path.max.art_producer_ms = path.max.exporter .. "CurrentArtProducer.ms"
+path.max.grannyexp_ini = path.max.exporter .. "grannyexp.ini"
+
+local atprint = CreatePrint({
+	"ArtPreview",
+	format = "printf",
+})
+
+ArtTest = { }
+
+---
+--- Opens a dialog to allow the user to choose a new art producer, then sets the new producer and updates the corresponding Lua and Max Script files.
+---
+--- @function ArtTest.OpenChangeProducerDialog
+function ArtTest.OpenChangeProducerDialog()
+    local producers = table.icopy(ArtSpecConfig.EntityProducers)
+    table.insert(producers, 1, "Any")
+    local new_producer = WaitListChoice(terminal.desktop, producers, "Choose art producer:", 1)
+    ArtTest.SetProducer(new_producer or "Any")
+    CreateRealTimeThread(ChangeMap, "ArtTest")
+end
+
+---
+--- Sets the new art producer and updates the corresponding Lua and Max Script files.
+---
+--- @param new_producer string The new art producer to set.
+---
+function ArtTest.SetProducer(new_producer)
+    if not new_producer then
+        return
+    end
+
+    atprint("Setting new art producer %s", new_producer)
+
+    -- set producer
+    rawset(_G, "g_ArtTestProducer", new_producer)
+
+    AsyncCreatePath(path.assets.root)
+
+    -- write to Lua file for the game
+    local lua_content = string.format("return \"%s\"", new_producer)
+    AsyncStringToFile(path.assets.art_producer_lua, lua_content)
+
+    -- write to Max Script file for the exporter
+    local ms_content = string.format("global g_ArtTestProducer = \"%s\"", new_producer)
+    AsyncStringToFile(path.max.art_producer_ms, ms_content)
+
+    local os_path_assets = ConvertToOSPath(path.assets.root)
+    if string.ends_with(os_path_assets, "\\") then
+        os_path_assets = string.sub(os_path_assets, 1, #os_path_assets - 1)
+    end
+
+    ArtTest.InstallMaxExporter()
+end
+
+---
+--- Sets the new art producer and updates the corresponding Autodesk 3DS Max exporter configuration.
+---
+--- This function is responsible for configuring the Autodesk 3DS Max exporter by updating the `grannyexp.ini` file with the correct assets path. It first checks if the game is run with the `-globalappdirs` command line parameter, which is required for the exporter to function properly. If the parameter is not present, it prints a warning message and returns.
+---
+--- The function then retrieves the OS-specific path for the assets root directory and checks if it ends with a backslash. If so, it removes the trailing backslash.
+---
+--- Next, the function checks if the `grannyexp.ini` file exists. If it does, it reads the file and updates the `assetsPath` setting with the correct assets path. If the file does not exist, it creates a new `grannyexp.ini` file with the assets path.
+---
+--- @param new_producer string The new art producer to set.
+---
+function ArtTest.SetProducer_3DSMax(new_producer)
+    if not new_producer then
+        return
+    end
+
+    local globalappdirs = string.match(GetAppCmdLine() or "", "-globalappdirs")
+    if not globalappdirs then
+        atprint(
+            "Please run the game with the -globalappdirs command line parameter to install/update the Autodesk 3DS Max exporter")
+        return
+    end
+
+    local os_path_assets = ConvertToOSPath(path.assets.root)
+    if string.ends_with(os_path_assets, "\\") then
+        os_path_assets = string.sub(os_path_assets, 1, #os_path_assets - 1)
+    end
+
+    if io.exists(path.max.grannyexp_ini) then -- TODO proper ini handling
+        local err, ini = AsyncFileToString(path.max.grannyexp_ini)
+        local first, last = string.find(ini, "assetsPath=.*\n")
+        if first and last and first <= last then
+            ini = string.format("%sassetsPath=%s%s", string.sub(ini, 1, first), os_path_assets,
+                string.sub(ini, last - 1))
+        else
+            ini = string.format("%s\n[Directories]\nassetsPath=%s", ini, os_path_assets)
+        end
+    else
+        local ini = string.format("[Directories]\nassetsPath=%s", os_path_assets)
+        AsyncStringToFile(path.max.grannyexp_ini, ini)
+    end
+end
+
+---
+--- Installs the Autodesk 3DS Max exporter by creating the necessary folder structure and copying the exporter files.
+---
+--- This function first checks if the game is run with the `-globalappdirs` command line parameter, which is required for the exporter to function properly. If the parameter is not present, it prints a warning message and returns.
+---
+--- The function then creates the folder structure where the exported entities will be stored, including the `Bin/`, `Bin/Common/`, and other subfolders.
+---
+--- Next, the function copies the exporter folder structure from the `path.assets.exporter` directory to the `path.max.exporter` directory. It skips any folders or files that contain `.svn`.
+---
+--- Finally, the function copies the exporter startup file from `path.max.exporter_startup` to `path.max.startup`, and calls `ArtTest.SetProducer_3DSMax()` with the current art producer.
+---
+--- @return nil
+function ArtTest.InstallMaxExporter()
+    local globalappdirs = string.match(GetAppCmdLine() or "", "-globalappdirs")
+    if not globalappdirs then
+        atprint(
+            "Please run the game with the -globalappdirs command line parameter to install/update the Autodesk 3DS Max exporter")
+        return
+    end
+
+    -- crate assets folder structure (where entities will be exported)
+    local structure = {"Bin/", "Bin/Common/", "Bin/Common/Animations", "Bin/Common/Entities", "Bin/Common/Mapping",
+        "Bin/Common/Materials", "Bin/Common/Meshes", "Bin/Common/TexturesMeta", "Bin/win32/", "Bin/win32/Textures",
+        "Bin/win32/Fallbacks", "Bin/win32/Fallbacks/Textures"}
+    for i, subpath in ipairs(structure) do
+        local full_path = path.assets.root .. subpath
+        local os_path = ConvertToOSPath(full_path)
+        local err = AsyncCreatePath(os_path)
+        if err then
+            atprint("Failed creating exporter target folder structure - %s", err)
+            return
+        end
+    end
+
+    -- copy exporter folder structure
+    local err, folders = AsyncListFiles(path.assets.exporter, "*", "recursive,relative,folders")
+    if err then
+        atprint("Failed listing Autodesk 3DS Max exporter folder structure - %s", err)
+        return err
+    end
+
+    local os_path = ConvertToOSPath(path.max.exporter)
+    local err = AsyncCreatePath(os_path)
+    if err then
+        atprint("Failed copying Autodesk 3DS Max exporter folder structure - %s", err)
+        return err
+    end
+
+    for _, folder in ipairs(folders) do
+        if not string.find(folder, ".svn") then
+            local os_path = ConvertToOSPath(path.max.exporter .. folder)
+            local err = AsyncCreatePath(os_path)
+            if err then
+                atprint("Failed copying Autodesk 3DS Max exporter folder structure - %s", err)
+                return err
+            end
+        end
+    end
+
+    -- copy exporter files
+    local err, files = AsyncListFiles(path.assets.exporter, "*", "recursive,relative")
+    if err then
+        atprint("Failed listing Autodesk 3DS Max exporter files - %s", err)
+        return err
+    end
+
+    for _, file in ipairs(files) do
+        if not string.find(file, ".svn") then
+            local os_dest_path = ConvertToOSPath(path.max.exporter .. file)
+            local err = AsyncCopyFile(path.assets.exporter .. file, os_dest_path, "raw")
+            if err then
+                atprint("Failed copying Autodesk 3DS Max exporter files - %s", err)
+                return err
+            end
+        end
+    end
+
+    -- copy exporter startup file
+    local err = AsyncCopyFile(path.max.exporter_startup, path.max.startup)
+    if err then
+        atprint("Failed copying Autodesk 3DS Max exporter startup file - %s", err)
+        return err
+    end
+
+    ArtTest.SetProducer_3DSMax(rawget(_G, "g_ArtTestProducer"))
+
+    atprint("Installed Autodesk 3DS Max exporter. Restart Autodesk 3DS Max.")
+end
+---
+--- Starts the art preview mode.
+---
+--- This function is responsible for initializing the art preview mode. It performs the following steps:
+--- 1. Checks if an art producer script exists and loads it.
+--- 2. If no art producer is found, it opens a dialog to allow the user to select an art producer.
+--- 3. Sets the selected art producer.
+--- 4. Loads external entities.
+--- 5. Sets up the map for the art preview.
+---
+--- @function ArtTest.Start
+--- @return nil
+
+function ArtTest.Start()
+    atprint("Starting art preview mode")
+
+    if io.exists(path.assets.art_producer_lua) then
+        local producer = dofile(path.assets.art_producer_lua)
+        if type(producer) == "string" then
+            rawset(_G, "g_ArtTestProducer", producer)
+        end
+    end
+
+    local art_producer = rawget(_G, "g_ArtTestProducer")
+    local no_art_producer = (art_producer == nil)
+    if no_art_producer then
+        ArtTest.OpenChangeProducerDialog()
+        return
+    else
+        -- updates all files
+        ArtTest.SetProducer(art_producer)
+        atprint("Selected art producer %s", art_producer)
+    end
+
+    ArtTest.LoadExternalEntities()
+    ArtTest.SetUpMap()
+end
+
+local mounted
+---
+--- Loads all external entities required for the art preview mode.
+---
+--- This function is responsible for loading all the necessary entities, meshes, animations, materials, and textures for the art preview mode. It performs the following steps:
+--- 1. Mounts the required folders to make the assets accessible.
+--- 2. Enumerates all the entity files in the `path.assets.entities` directory.
+--- 3. Loads each entity file using `DelayedLoadEntity`.
+--- 4. Opens a loading screen and forces a reload of the bin assets and DLC assets.
+--- 5. Waits for the bin assets to finish loading and then closes the loading screen.
+--- 6. Waits for any delayed entity loads to complete.
+--- 7. Reloads the Lua script.
+---
+--- @function ArtTest.LoadExternalEntities
+--- @return nil
+function ArtTest.LoadExternalEntities()
+    if not mounted then
+        mounted = true
+
+        MountFolder(path.assets.root .. "Bin/Common/Entities/Meshes/", path.assets.root .. "Bin/Common/Meshes/")
+        MountFolder(path.assets.root .. "Bin/Common/Entities/Animations/", path.assets.root .. "Bin/Common/Animations/")
+        MountFolder(path.assets.root .. "Bin/Common/Entities/Materials/", path.assets.root .. "Bin/Common/Materials/")
+        MountFolder(path.assets.root .. "Bin/Common/Entities/Mapping/", path.assets.root .. "Bin/Common/Mapping/")
+        MountFolder(path.assets.root .. "Bin/Common/Entities/Textures/", path.assets.root .. "Bin/win32/Textures/")
+        atprint("Mounted all entity folders")
+    end
+
+    local err, all_entities = AsyncListFiles(path.assets.entities, "*.ent")
+    if err then
+        atprint("Failed to enumerate entities - %s", err)
+        return
+    end
+    if not all_entities or #all_entities == 0 then
+        atprint("No entities to load")
+        return
+    end
+
+    for i, ent_file in ipairs(all_entities) do
+        DelayedLoadEntity(false, false, ent_file)
+    end
+    atprint("Will load %d entities", #all_entities)
+
+    LoadingScreenOpen("idArtTestLoadEntities", "ArtTestLoadEntities")
+    local old_render_mode = GetRenderMode()
+    WaitRenderMode("ui")
+    ForceReloadBinAssets()
+    DlcReloadAssets(DlcDefinitions)
+    -- actually reload the assets
+    LoadBinAssets(CurrentMapFolder)
+    -- wait & unmount
+    WaitNextFrame(2)
+    while AreBinAssetsLoading() do
+        Sleep(1)
+    end
+    WaitRenderMode(old_render_mode)
+    LoadingScreenClose("idArtTestLoadEntities", "ArtTestLoadEntities")
+    WaitDelayedLoadEntities()
+    -- ReloadClassEntities()
+    ReloadLua()
+    atprint("Reloaded all entities")
+end
+
+--- Sets up the map for the ArtTest module.
+---
+--- This function performs the following tasks:
+--- - Activates the cameraMax camera
+--- - Prints a message to the console indicating the camera has been set up
+--- - Calls the ArtTest.PlacePreviewObjects() function to place preview objects on the map
+--- - If any preview objects were placed, it moves the camera to view the first preview object
+function ArtTest.SetUpMap()
+    cameraMax.Activate(1)
+    atprint("Camera set up")
+
+    local preview_objs = ArtTest.PlacePreviewObjects()
+
+    if preview_objs and next(preview_objs) then
+        ViewPos(preview_objs[1]:GetVisualPos())
+        atprint("Showing first preview object")
+    end
+end
+
+--- Returns a list of object classes to preview in the ArtTest module.
+---
+--- The list of object classes is determined by the current producer set in the
+--- `g_ArtTestProducer` global variable. If `g_ArtTestProducer` is set to "Any",
+--- then all object classes that have an entry in the `entity_producers_lua` file
+--- will be included in the list.
+---
+--- @return table A list of object class names to preview.
+function ArtTest.GetObjectClassesToPreview()
+    local current_producer = rawget(_G, "g_ArtTestProducer") or "Any"
+    local result = {}
+
+    if io.exists(path.assets.entity_producers_lua) then
+        local entity_producers = dofile(path.assets.entity_producers_lua)
+        for entity_id, produced_by in pairs(entity_producers) do
+            if (current_producer == "Any" or produced_by == current_producer) and g_Classes[entity_id] then
+                table.insert(result, entity_id)
+            end
+        end
+    end
+
+    return result
+end
+
+local spacing = 10 * guim
+--- Places preview objects on the map for the ArtTest module.
+---
+--- This function places preview objects on the map for each object class that is
+--- eligible to be previewed in the ArtTest module. The list of eligible object
+--- classes is determined by the current producer set in the `g_ArtTestProducer`
+--- global variable.
+---
+--- For each eligible object class, the function places one preview object for
+--- each valid state of the object. The preview objects are placed in a grid
+--- pattern, with a spacing of `spacing` units between each object.
+---
+--- The function returns a list of all the preview objects that were placed.
+---
+--- @param classes (optional) A list of object class names to preview. If not
+---                provided, the function will use the list returned by
+---                `ArtTest.GetObjectClassesToPreview()`.
+--- @return table A list of preview objects that were placed.
+function ArtTest.PlacePreviewObjects(classes)
+    local current_producer = rawget(_G, "g_ArtTestProducer") or "Any"
+
+    local y = 0
+    local result = {}
+
+    local classes = classes or ArtTest.GetObjectClassesToPreview()
+    if not classes or #classes == 0 then
+        atprint("No preview objects to place")
+        return
+    end
+
+    for i, classname in ipairs(classes) do
+        local class = g_Classes[classname]
+        local entity = class:GetEntity()
+        local entity_bbox = GetEntityBBox(entity)
+        local _, radius = entity_bbox:GetBSphere()
+
+        local x = 0
+        local half_spacing = radius + spacing
+
+        for i, state in pairs(EnumValidStates(entity)) do
+            x, y = x + half_spacing, y + half_spacing
+            local pos = point(x, y)
+            local preview_pos = point(x, y, terrain.GetHeight(x, y))
+            x, y = x + half_spacing, y + half_spacing
+
+            local preview_obj = PlaceObject(classname)
+            preview_obj:SetPos(preview_pos)
+            preview_obj:SetState(state)
+            table.insert(result, preview_obj)
+
+            local text_obj = PlaceObject("Text")
+            text_obj:SetDepthTest(false)
+            text_obj:SetText(entity .. "\n" .. GetStateName(state))
+            text_obj:SetPos(pos + point(radius, radius))
+        end
+    end
+
+    atprint("Placed %d preview objects", #result)
+    return result
+end
+
+----
+
+function OnMsg.ChangeMapDone()
+	if CurrentMap == "ArtTest" then
+		CreateRealTimeThread(ArtTest.Start)
+	end
+end
+
+if FirstLoad and config.ArtTest then
+	CreateRealTimeThread(ChangeMap, "ArtTest")
+end

CommonLua/AtmosphericParticles.lua

@@ -0,0 +1,115 @@
+
+--- Toggles whether atmospheric particles are hidden or not.
+---
+--- This variable is set to `false` on first load, indicating that atmospheric particles should be visible.
+---
+--- @field g_AtmosphericParticlesHidden boolean
+--- @within CommonLua.AtmosphericParticles
+MapVar("g_AtmosphericParticlesHidden", false)
+if FirstLoad then
+	g_AtmosphericParticlesThread = false
+	g_AtmosphericParticles = false
+	g_AtmosphericParticlesPos = false
+end
+function OnMsg.DoneMap()
+	g_AtmosphericParticlesThread = false
+	g_AtmosphericParticles = false
+	g_AtmosphericParticlesPos = false
+end
+
+--- Applies atmospheric particles to the scene.
+---
+--- This function sets up the atmospheric particles by creating a thread to update their positions, and initializing the particle objects and their positions.
+---
+--- If `mapdata.AtmosphericParticles` is an empty string, this function will return without doing anything.
+---
+--- @function AtmosphericParticlesApply
+--- @within CommonLua.AtmosphericParticles
+function AtmosphericParticlesApply()
+    if g_AtmosphericParticlesThread then
+        DeleteThread(g_AtmosphericParticlesThread)
+        g_AtmosphericParticlesThread = false
+    end
+    DoneObjects(g_AtmosphericParticles)
+    g_AtmosphericParticles = false
+    g_AtmosphericParticlesPos = false
+    if mapdata.AtmosphericParticles == "" then
+        return
+    end
+    g_AtmosphericParticles = {}
+    g_AtmosphericParticlesPos = {}
+    g_AtmosphericParticlesThread = CreateGameTimeThread(function()
+        while true do
+            AtmosphericParticlesUpdate()
+            Sleep(100)
+        end
+    end)
+end
+
+--- Updates the positions of the atmospheric particles.
+---
+--- This function is responsible for managing the atmospheric particles in the scene. It determines the number of particles to display based on whether they are currently hidden or not, and the number of views. It then creates, destroys, and updates the positions of the particles as needed.
+---
+--- If `g_AtmosphericParticlesPos` is `false`, this function will return without doing anything.
+---
+--- If the distance between the two camera positions is less than 10 game units, this function will average the positions of the two cameras and only display one particle.
+---
+--- This function is called repeatedly in a game time thread created by `AtmosphericParticlesApply()`.
+---
+--- @function AtmosphericParticlesUpdate
+--- @within CommonLua.AtmosphericParticles
+function AtmosphericParticlesUpdate()
+    local part_pos = g_AtmosphericParticlesPos
+    if not part_pos then
+        return
+    end
+    -- see how many particles we need, depending on whether they currently hidden, 
+    -- number of views and how close are the two cameras in case of two views
+    local part_number = g_AtmosphericParticlesHidden and 0 or camera.GetViewCount()
+    for view = 1, part_number do
+        part_pos[view] = camera.GetEye(view) + SetLen(camera.GetDirection(view), 7 * guim)
+    end
+    if part_number == 2 and part_pos[1]:Dist(part_pos[2]) < 10 * guim then
+        part_pos[1] = (part_pos[1] + part_pos[2]) / 2
+        part_number = 1
+    end
+
+    -- create/destroy particles as needed and update positions
+    local part = g_AtmosphericParticles
+    for i = 1, Max(#part, part_number) do
+        if not IsValid(part[i]) then -- the particles coule be destroyed by code like NetSetGameState()
+            part[i] = PlaceParticles(mapdata.AtmosphericParticles)
+        end
+        if i > part_number then
+            if g_AtmosphericParticlesHidden then
+                DoneObject(part[i])
+            else
+                StopParticles(part[i])
+            end
+            part[i] = nil
+        elseif terrain.IsPointInBounds(part_pos[i]) and part_pos[i]:z() < 2000000 then
+            part[i]:SetPos(part_pos[i])
+        end
+    end
+end
+
+--- Sets whether the atmospheric particles are hidden or not.
+---
+--- @function AtmosphericParticlesSetHidden
+--- @within CommonLua.AtmosphericParticles
+--- @param hidden boolean Whether the atmospheric particles should be hidden or not.
+function AtmosphericParticlesSetHidden(hidden)
+    g_AtmosphericParticlesHidden = hidden
+end
+
+function OnMsg.SceneStarted(scene)
+	if scene.hide_atmospheric_particles then
+		AtmosphericParticlesSetHidden(true)
+	end
+end
+
+function OnMsg.SceneStopped(scene)
+	if scene.hide_atmospheric_particles then
+		AtmosphericParticlesSetHidden(false)
+	end
+end

CommonLua/BaseClasses.lua

@@ -0,0 +1,147 @@
+--- Stores a boolean value indicating whether spawned objects in the game are currently hidden or not.
+--- This variable is used by the `HideSpawnedObjects` function to track the visibility state of spawned objects.
+--- When set to `true`, the `HideSpawnedObjects` function will hide all spawned objects. When set to `false`, it will show all hidden objects.
+MapVar("HiddenSpawnedObjects", false)
+---
+--- Hides or shows all spawned objects in the game.
+---
+--- When `hide` is `true`, this function will hide all spawned objects by clearing their `efVisible` enum flag.
+--- When `hide` is `false`, this function will show all previously hidden spawned objects by setting their `efVisible` enum flag.
+---
+--- This function uses the `HiddenSpawnedObjects` table to keep track of all objects that have been hidden. When showing objects, it iterates through this table to restore their visibility.
+---
+--- @param hide boolean Whether to hide or show the spawned objects
+---
+local function HideSpawnedObjects(hide)
+    if not hide == not HiddenSpawnedObjects then
+        return
+    end
+
+    SuspendPassEdits("HideSpawnedObjects")
+
+    if hide then
+        HiddenSpawnedObjects = setmetatable({}, weak_values_meta)
+        for template, obj in pairs(TemplateSpawn) do
+            if IsValid(obj) and obj:GetEnumFlags(const.efVisible) ~= 0 then
+                obj:ClearEnumFlags(const.efVisible)
+                HiddenSpawnedObjects[#HiddenSpawnedObjects + 1] = obj
+            end
+        end
+    elseif HiddenSpawnedObjects then
+        for i = 1, #HiddenSpawnedObjects do
+            local obj = HiddenSpawnedObjects[i]
+            if IsValid(obj) then
+                obj:SetEnumFlags(const.efVisible)
+            end
+        end
+        HiddenSpawnedObjects = false
+    end
+
+    ResumePassEdits("HideSpawnedObjects")
+end
+
+---
+--- Toggles the visibility of all spawned objects in the game.
+---
+--- This function calls the `HideSpawnedObjects` function, passing the opposite of the current `HiddenSpawnedObjects` value. This will either hide all spawned objects if they are currently visible, or show all previously hidden objects.
+---
+--- @function ToggleSpawnedObjects
+--- @return nil
+function ToggleSpawnedObjects()
+    HideSpawnedObjects(not HiddenSpawnedObjects)
+end
+OnMsg.GameEnterEditor = function()
+	HideSpawnedObjects(true)
+end
+OnMsg.GameExitEditor = function()
+	HideSpawnedObjects(false)
+end
+
+----
+
+local function SortByItems(self)
+	return self:GetSortItems()
+end
+
+---
+--- Defines a base class for objects that can be sorted.
+---
+--- The `SortedBy` class provides a set of properties and methods for sorting a collection of objects. It includes a `SortBy` property that allows the user to specify one or more sort keys, and a `Sort()` method that sorts the collection based on those keys.
+---
+--- The `SortByItems` function is used to provide a list of available sort keys for the `SortBy` property.
+---
+--- @class SortedBy
+--- @field SortBy table|boolean The sort keys to use when sorting the collection. Can be a table of key-value pairs, where the key is the sort key and the value is the sort direction (true for ascending, false for descending). Can also be set to false to disable sorting.
+--- @field SortBy.key string The name of the sort key.
+--- @field SortBy.dir boolean The sort direction (true for ascending, false for descending).
+--- @field SortBy.items function A function that returns a list of available sort keys.
+--- @field SortBy.max_items_in_set integer The maximum number of sort keys that can be selected.
+--- @field SortBy.border integer The border width of the property editor.
+--- @field SortBy.three_state boolean Whether the property editor should have a three-state (true/false/nil) value.
+DefineClass.SortedBy = {__parents={"PropertyObject"},
+    properties={{id="SortBy", editor="set", default=false, items=SortByItems, max_items_in_set=1, border=2,
+        three_state=true}}}
+
+---
+--- Returns a list of available sort keys for the `SortBy` property.
+---
+--- This function is used to provide a list of available sort keys that can be selected for the `SortBy` property of the `SortedBy` class. The implementation of this function is left empty, as the specific sort keys available will depend on the implementation of the `SortedBy` class.
+---
+--- @function SortedBy:GetSortItems
+--- @return table A table of available sort keys.
+function SortedBy:GetSortItems()
+    return {}
+end
+
+---
+--- Sets the sort keys for the collection and sorts the collection based on those keys.
+---
+--- @function SortedBy:SetSortBy
+--- @param sort_by table|boolean The new sort keys to use. Can be a table of key-value pairs, where the key is the sort key and the value is the sort direction (true for ascending, false for descending). Can also be set to false to disable sorting.
+--- @return nil
+function SortedBy:SetSortBy(sort_by)
+    self.SortBy = sort_by
+    self:Sort()
+end
+
+---
+--- Resolves the sort key and sort direction from the `SortBy` property.
+---
+--- This function iterates over the `SortBy` property and returns the first key-value pair, which represents the sort key and sort direction.
+---
+--- @function SortedBy:ResolveSortKey
+--- @return string, boolean The sort key and sort direction.
+function SortedBy:ResolveSortKey()
+    for key, value in pairs(self.SortBy) do
+        return key, value
+    end
+end
+
+---
+--- Compares two objects in the collection based on the specified sort key.
+---
+--- This function is used to compare two objects in the collection when sorting the collection based on the `SortBy` property. The comparison is performed using the specified sort key.
+---
+--- @param c1 any The first object to compare.
+--- @param c2 any The second object to compare.
+--- @param sort_by string The sort key to use for the comparison.
+--- @return boolean True if the first object should come before the second object in the sorted collection, false otherwise.
+function SortedBy:Cmp(c1, c2, sort_by)
+end
+
+---
+--- Sorts the collection based on the specified sort keys.
+---
+--- This function first resolves the sort key and sort direction from the `SortBy` property. It then sorts the collection using the `table.sort()` function, comparing each pair of objects using the `Cmp()` function and the resolved sort key. If the sort direction is descending, the function then reverses the order of the sorted collection.
+---
+--- @function SortedBy:Sort
+--- @return nil
+function SortedBy:Sort()
+    local key, dir = self:ResolveSortKey()
+    table.sort(self, function(c1, c2)
+        return self:Cmp(c1, c2, key)
+    end)
+    if not dir then
+        table.reverse(self)
+    end
+end

CommonLua/Billboards.lua

@@ -0,0 +1,380 @@
+---
+--- Sets up the rendering environment for capturing billboards.
+---
+--- This function performs the following steps:
+--- - Changes the current map to an empty map
+--- - Waits for 5 frames
+--- - Activates the `cameraMax` camera and sets its viewport, field of view, and locks it
+--- - Changes the video mode to the billboard screenshot capture size
+--- - Configures various rendering settings for billboard capture, such as:
+---   - Setting the object LOD cap to 100
+---   - Disabling terrain rendering
+---   - Disabling auto-exposure
+---   - Disabling subsurface scattering
+---   - Setting the resolution to 100% with SMAA upscaling
+---   - Disabling shadows
+---   - Setting the near and far planes to 100 and 100,000 respectively
+---   - Enabling orthographic projection with a Y scale of 1000
+--- - Deletes the current map and waits for 3 frames
+---
+function SetupBillboardRendering()
+    ChangeMap("__Empty")
+    WaitNextFrame(5)
+
+    cameraMax.Activate(1)
+    camera.SetViewport(box(0, 0, 1000000, 1000000))
+    camera.SetFovX(83 * 60)
+    camera.Lock(1)
+
+    ChangeVideoMode(hr.BillboardScreenshotCaptureSize, hr.BillboardScreenshotCaptureSize, 0, false, false)
+
+    table.change(hr, "BillboardCapture",
+        {ObjectLODCapMax=100, ObjectLODCapMin=100, RenderBillboards=0, RenderTerrain=0, AutoExposureMode=0,
+            EnableSubsurfaceScattering=0, ResolutionPercent=100, ResolutionUpscale="smaa", MaxFps=0, Shadowmap=0,
+            NearZ=100, FarZ=100000, Ortho=1, OrthoYScale=1000})
+
+    MapDelete("map", nil)
+    WaitNextFrame(3)
+end
+
+---
+--- Defines a class for billboard objects.
+---
+--- This class inherits from `EntityClass` and has the following properties:
+---
+--- - `flags`: A table of flags, including `efHasBillboard` which indicates that this object has a billboard.
+--- - `ignore_axis_error`: A boolean flag that determines whether to ignore errors related to the object's axis.
+---
+DefineClass.BillboardObject = {__parents={"EntityClass"}, flags={efHasBillboard=true}, ignore_axis_error=false}
+---
+--- Returns an error message if the billboard object has an invalid axis.
+---
+--- If the object has a billboard (`efHasBillboard` flag is set) and `ignore_axis_error` is false, this function checks the object's visual axis. If the X or Y axis is non-zero, or the Z axis is non-positive, it returns an error message indicating that the billboard object should have the default axis.
+---
+--- @return string|nil An error message if the billboard object has an invalid axis, or nil if the axis is valid or `ignore_axis_error` is true.
+function BillboardObject:GetError()
+end
+
+function BillboardObject:GetError()
+    if self:GetEnumFlags(const.efHasBillboard) ~= 0 and not self.ignore_axis_error then
+        local x, y, z = self:GetVisualAxisXYZ()
+        if x ~= 0 or y ~= 0 or z <= 0 then
+            return "Billboard objects should have default axis"
+        end
+    end
+end
+---
+--- Returns a sorted list of all `BillboardObject` classes and their descendants.
+---
+--- This function traverses the class hierarchy starting from the `BillboardObject` class, and collects all valid entities that are instances of `BillboardObject` or its descendants. The resulting list is sorted by the class name.
+---
+--- @return table A table of `BillboardObject` class definitions, sorted by class name.
+function BillboardsTree()
+end
+
+function BillboardsTree()
+    local billboard_classes = {}
+    ClassDescendantsList("BillboardObject", function(name, classdef, billboard_classes)
+        if IsValidEntity(classdef:GetEntity()) then
+            table.insert(billboard_classes, classdef)
+        end
+    end, billboard_classes)
+    table.sortby_field(billboard_classes, "class")
+    return billboard_classes
+end
+---
+--- Bakes a billboard for the selected object in the GED.
+---
+--- This function resolves the selected object in the GED and then calls `BakeEntityBillboard` to generate a billboard for that object.
+---
+--- @param ged The GED object.
+function GedBakeBillboard(ged)
+end
+
+function GedBakeBillboard(ged)
+    local obj = ged:ResolveObj("SelectedObject")
+    if not obj then
+        return
+    end
+    BakeEntityBillboard(obj:GetEntity())
+end
+---
+--- Bakes a billboard for the specified entity.
+---
+--- This function generates a billboard for the given entity by executing an external command. The command is constructed using the entity's name and executed asynchronously. If an error occurs during the billboard generation, it is printed to the console.
+---
+--- @param entity string The name of the entity to generate a billboard for.
+function BakeEntityBillboard(entity)
+end
+
+function BakeEntityBillboard(entity)
+    if not entity then
+        return
+    end
+    local cmd = string.format("cmd /c Build GenerateBillboards --billboard_entity=%s", entity)
+    local dir = ConvertToOSPath("svnProject/")
+    local err = AsyncExec(cmd, dir, true, true)
+    if err then
+        print("Failed to create billboard for %s: %s", entity, err)
+    end
+end
+---
+--- Spawns a billboard object at the cursor position, with a random offset.
+---
+--- This function resolves the selected object in the GED and then places multiple instances of that object in a grid pattern around the cursor position, with a random offset applied to each instance.
+---
+--- @param ged The GED object.
+function GedSpawnBillboard(ged)
+end
+
+function GedSpawnBillboard(ged)
+    local obj = ged:ResolveObj("SelectedObject")
+    if not obj then
+        return
+    end
+
+    local pos = GetTerrainCursorXY(UIL.GetScreenSize() / 2)
+    local step = 20 * guim
+    SuspendPassEdits("spawn billboards")
+    for y = -50, 50 do
+        for x = -50, 50 do
+            local o = PlaceObject(obj.class)
+            local curr_pos = pos + point(x * step + (AsyncRand(21) - 11) * guim, y * step + (AsyncRand(21) - 11) * guim)
+            local real_pos = point(curr_pos:x(), curr_pos:y(), terrain.GetHeight(curr_pos:x(), curr_pos:y()))
+            o:SetPos(curr_pos)
+        end
+    end
+    ResumePassEdits("spawn billboards")
+end
+---
+--- Spawns a grid of billboard objects around the cursor position, with a random offset.
+---
+--- This function resolves the selected object in the GED and then places multiple instances of that object in a grid pattern around the cursor position, with a random offset applied to each instance. This can be used to debug billboard rendering.
+---
+--- @param ged The GED object.
+function GedDebugBillboards(ged)
+end
+
+function GedDebugBillboards(ged)
+    hr.BillboardDebug = 1
+    hr.BillboardDistanceModifier = 10000
+    hr.ObjectLODCapMax = 100
+    hr.ObjectLODCapMin = 100
+
+    local pos = GetTerrainCursorXY(UIL.GetScreenSize() / 2)
+    local step = 12 * guim
+
+    local billboard_entities = {}
+    for k, v in ipairs(GetClassAndDescendantsEntities("BillboardObject")) do
+        if IsValidEntity(v) then
+            billboard_entities[#billboard_entities + 1] = v
+        end
+    end
+
+    local i = 1
+    for y = -10, 10 do
+        for x = -5, 5 do
+            local entity = billboard_entities[i]
+            if i == #billboard_entities then
+                i = 0
+            end
+            i = i + 1
+            local o = PlaceObject(entity)
+            local curr_pos = pos + point(x * step * 2, y * step)
+            local real_pos = point(curr_pos:x(), curr_pos:y(), terrain.GetHeight(curr_pos:x(), curr_pos:y()))
+            o:SetPos(curr_pos)
+        end
+    end
+end
+
+---
+--- Generates billboards for all billboard objects in the game.
+---
+--- This function executes an external command to generate billboards for all billboard objects in the game. It uses the `GenerateBillboards` function to create the billboards.
+---
+--- @param ged The GED object.
+function GedBakeAllBillboards(ged)
+end
+
+function GedBakeAllBillboards(ged)
+    local cmd = string.format("cmd /c Build GenerateBillboards")
+    local dir = ConvertToOSPath("svnProject/")
+
+    local err = AsyncExec(cmd, dir, true, true)
+    if err then
+        print("Failed to create billboards!")
+    end
+end
+---
+--- Generates billboards for all billboard objects in the game.
+---
+--- This function executes an external command to generate billboards for all billboard objects in the game. It uses the `GenerateBillboards` function to create the billboards.
+---
+--- @param ged The GED object.
+function GedBakeAllBillboards(ged)
+end
+
+function GenerateBillboards(specific_entity)
+    CreateRealTimeThread(function()
+        SetupBillboardRendering()
+
+        local billboard_entities = {}
+        if specific_entity then
+            billboard_entities[specific_entity] = true
+        else
+            ClassDescendantsList("BillboardObject", function(name, classdef, billboard_entities)
+                local ent = classdef:GetEntity()
+                if IsValidEntity(ent) then
+                    billboard_entities[ent] = true
+                end
+            end, billboard_entities)
+        end
+
+        local o = PlaceObject("Shapeshifter")
+        o:SetPos(point(0, 0))
+
+        local OctahedronSize = hr.BillboardScreenshotGridWidth - 1
+
+        local screenshot_downsample = hr.BillboardScreenshotCaptureSize / hr.BillboardScreenshotSize
+        local unneeded_lods
+        local power = 1
+        for i = 0, 10 do
+            if power == screenshot_downsample then
+                unneeded_lods = i
+                break
+            end
+            power = power * 2
+        end
+
+        local dir = ConvertToOSPath("svnAssets/BuildCache/win32/Billboards/")
+        AsyncCreatePath("svnAssets/BuildCache/win32/Billboards/")
+
+        for ent, _ in pairs(billboard_entities) do
+            hr.MipmapLodBias = unneeded_lods * 1000
+
+            o:ChangeEntity(ent)
+            local bbox = o:GetEntityBBox()
+            local bbox_center = bbox:Center()
+            local camera_target = o:GetVisualPos() + bbox_center
+
+            WaitNextFrame(5)
+
+            local dlc_name = EntitySpecPresets[ent].save_in
+            if dlc_name ~= "" then
+                dlc_name = dlc_name .. "\\"
+            end
+            local curr_dir = dir .. dlc_name
+            local err = AsyncCreatePath(curr_dir)
+            assert(not err)
+
+            local _, radius = o:GetBSphere()
+            local draw_radius = (radius * 173) / 100
+            local max_range = radius * OctahedronSize
+            local half_max = (max_range * 173) / 100 + (hr.BillboardScreenshotGridWidth % 2 == 0 and 1 or 0)
+
+            local bc_atlas = curr_dir .. ent .. "_bc.tga"
+            local nm_atlas = curr_dir .. ent .. "_nm.tga"
+            local rt_atlas = curr_dir .. ent .. "_rt.tga"
+            local siao_atlas = curr_dir .. ent .. "_siao.tga"
+            local depth_atlas = curr_dir .. ent .. "_dep.tga"
+            local borders = curr_dir .. ent .. "_bor.dds"
+            local id = 0
+
+            hr.OrthoX = radius * 2
+
+            BeginCaptureBillboardEntity(bc_atlas, nm_atlas, rt_atlas, siao_atlas, depth_atlas, borders)
+            for y = 0, OctahedronSize do
+                for x = 0, OctahedronSize do
+                    local curr_x, curr_y, curr_z = BillboardMap(x, y, OctahedronSize, half_max)
+                    local pos = SetLen(point(curr_x, curr_y, curr_z), draw_radius)
+                    SetCamera(camera_target + pos, camera_target)
+
+                    WaitNextFrame(1)
+                    CaptureBillboardFrame(draw_radius, id)
+                    WaitNextFrame(1)
+
+                    id = id + 1
+                end
+            end
+            WaitNextFrame(1)
+        end
+        WaitNextFrame(100)
+        quit()
+    end)
+end
+---
+--- Checks if the given object has a billboard associated with it.
+---
+--- @param obj table The object to check for a billboard.
+--- @return boolean True if the object has a billboard, false otherwise.
+function HasBillboard(obj)
+    return hr.BillboardEntities and IsValid(obj) and IsValidEntity(obj:GetEntity())
+               and not not table.find(hr.BillboardEntities, obj:GetEntity())
+end
+
+
+---
+--- Gets a list of all billboard entities in the game.
+---
+--- @param err_print function An optional function to call if there are any errors finding billboard entities.
+--- @return table A table of all valid billboard entity names.
+function GetBillboardEntities(err_print)
+    if hr.BillboardDirectory then
+        hr.BillboardDirectory = "Textures/Billboards/"
+        local suffix = Platform.playstation and "_bc.hgt" or "_bc.dds"
+        local err, textures = AsyncListFiles("Textures/Billboards", "*" .. suffix, "relative")
+
+        local billboard_entities = {}
+        for _, entity in ipairs(GetClassAndDescendantsEntities("BillboardObject")) do
+            local check_texture = not Platform.developer or Platform.console or table.find(textures, entity .. suffix)
+            if not check_texture then
+                err_print("Entity %s is marked as a billboard entity, but has no billboard textures!", entity)
+            end
+            if IsValidEntity(entity) and check_texture then
+                billboard_entities[#billboard_entities + 1] = entity
+            end
+        end
+
+        hr.BillboardEntities = billboard_entities
+    end
+end
+
+---
+--- Stress tests the billboards in the game by randomly placing and removing tree objects.
+---
+--- This function creates a real-time thread that continuously places and removes tree objects
+--- at random positions within a certain radius. The function keeps track of the number of
+--- objects placed and removed, and sleeps for a short period of time after every 1000 iterations.
+---
+--- This function is likely used for testing and debugging purposes to ensure the billboards
+--- are rendering correctly and efficiently.
+---
+--- @function StressTestBillboards
+--- @return nil
+function StressTestBillboards()
+    CreateRealTimeThread(function()
+        local count = 0
+        while true do
+            local pos = point((1000 + AsyncRand(4144)) * guim, (1000 + AsyncRand(4144)) * guim)
+            local o = MapGetFirst(pos:x(), pos:y(), 100, "Tree_01")
+            if o then
+                DoneObject(o)
+                local new = PlaceObject("Tree_01")
+                local curr_pos = point((1000 + AsyncRand(4144)) * guim, (1000 + AsyncRand(4144)) * guim)
+                local real_pos = point(curr_pos:x(), curr_pos:y(), terrain.GetHeight(curr_pos:x(), curr_pos:y()))
+                new:SetPos(real_pos)
+            end
+            count = count + 1
+            if count == 1000 then
+                count = 0
+                Sleep(100)
+            end
+        end
+    end)
+end
+
+function OnMsg.ClassesPostprocess()
+	CreateRealTimeThread(function()
+		GetBillboardEntities(function(...) printf("once", ...) end)
+	end)
+end

CommonLua/BufferedProcess.lua

@@ -0,0 +1,298 @@
+--- Holds a flag indicating whether there are any pending reasons to suspend the process.
+--- Holds a flag indicating whether there are any pending reasons to suspend the process.
+---
+--- @type boolean
+SuspendProcessReasons = nil
+
+--- Holds a flag indicating whether the process is currently suspended.
+---
+--- @type boolean
+SuspendedProcessing = nil
+
+--- A function that checks the current execution timestamp.
+---
+--- @type function
+CheckExecutionTimestamp = empty_func
+
+--- A function that checks for any remaining reasons to suspend the process.
+---
+--- @type function
+CheckRemainingReason = empty_func
+
+--- A function that unpacks a table.
+---
+--- @type function
+table_unpack = table.unpack
+
+--- A function that checks if two tables are equal.
+---
+--- @type function
+table_iequal = table.iequal
+local SuspendProcessReasons
+local SuspendedProcessing
+local CheckExecutionTimestamp = empty_func
+local CheckRemainingReason = empty_func
+local table_unpack = table.unpack
+local table_iequal = table.iequal
+
+if FirstLoad then
+	__process_params_meta = {
+		__eq = function(t1, t2)
+			if type(t1) ~= type(t2) or not rawequal(getmetatable(t1), getmetatable(t2)) then
+				return false
+			end
+			local count = t1[1]
+			if count ~= t2[1] then
+				return false
+			end
+			for i=2,count do
+				if t1[i] ~= t2[i] then
+					return false
+				end
+			end
+			return true
+		end
+	}
+end
+
+---
+--- Packs the provided parameters into a table with a metatable that allows for efficient equality comparison.
+---
+--- @param obj any The first parameter to be packed.
+--- @param ... any Additional parameters to be packed.
+--- @return table A table containing the packed parameters, with a metatable that allows for efficient equality comparison.
+---
+local function PackProcessParams(obj, ...)
+    local count = select("#", ...)
+    if count == 0 then
+        return obj or false
+    end
+    return setmetatable({count + 2, obj, ...}, __process_params_meta)
+end
+
+---
+--- Unpacks the parameters from a table that was packed using the `PackProcessParams` function.
+---
+--- @param params table A table containing the packed parameters, with a metatable that allows for efficient equality comparison.
+--- @return any The unpacked parameters.
+---
+function UnpackProcessParams(params)
+    if type(params) ~= "table" or getmetatable(params) ~= __process_params_meta then
+        return params
+    end
+    return table_unpack(params, 2, params[1])
+end
+
+function OnMsg.DoneMap()
+	CheckRemainingReason()
+	SuspendProcessReasons = false
+	SuspendedProcessing = false
+end
+
+---
+--- Executes any suspended functions for the given process.
+---
+--- @param process string The name of the process for which to execute suspended functions.
+---
+function ExecuteSuspended(process)
+    -- Implementation details omitted for brevity
+end
+local function ExecuteSuspended(process)
+    local delayed = SuspendedProcessing
+    local funcs_to_params = delayed and delayed[process]
+    if not funcs_to_params then
+        return
+    end
+    delayed[process] = nil
+    local procall = procall
+    for _, funcname in ipairs(funcs_to_params) do
+        local func = _G[funcname]
+        for _, params in ipairs(funcs_to_params[funcname]) do
+            dbg(CheckExecutionTimestamp(process, funcname, params, true))
+            procall(func, UnpackProcessParams(params))
+        end
+    end
+end
+
+---
+--- Cancels the processing of routines from a named process.
+---
+--- @param process string The name of the process for which to cancel processing.
+---
+function CancelProcessing(process)
+    if not SuspendProcessReasons or not SuspendProcessReasons[process] then
+        return
+    end
+    if SuspendedProcessing then
+        SuspendedProcessing[process] = nil
+    end
+    SuspendProcessReasons[process] = nil
+    Msg("ProcessingResumed", process, "cancel")
+end
+
+--[[@@@
+Checks if the processing of routines from a named process is currently suspended
+@function bool IsProcessingSuspended(string process)
+--]]
+function IsProcessingSuspended(process)
+	local process_to_reasons = SuspendProcessReasons
+	return process_to_reasons and next(process_to_reasons[process])
+end
+
+--[[@@@
+Suspends the processing of routines from a named process. Multiple suspending with the same reason would lead to an error.
+@function void SuspendProcessing(string process, type reason, bool ignore_errors)
+@param string process - the name of the process, which routines should be suspended.
+@param type reason - the reason to be used in order to resume the processing later. Could be any type.
+@param bool ignore_errors - ignore suspending errors (e.g. process already suspended).
+--]]
+function SuspendProcessing(process, reason, ignore_errors)
+	reason = reason or ""
+	local reasons = SuspendProcessReasons and SuspendProcessReasons[process]
+	if reasons and reasons[reason] then
+		assert(ignore_errors)
+		return
+	end
+	local now = GameTime()
+	if reasons then
+		reasons[reason] = now
+		return
+	end
+	SuspendProcessReasons = table.set(SuspendProcessReasons, process, reason, now)
+	Msg("ProcessingSuspended", process)
+end
+
+--[[@@@
+Resumes the processing of routines from a named process. Resuming an already resumed process, or resuming it with time delay, would lead to an error.
+@function void ResumeProcessing(string process, type reason, bool ignore_errors)
+@param string process - the name of the process, which routines should be suspended.
+@param type reason - the reason to be used in order to resume the processing later. Could be any type.
+@param bool ignore_errors - ignore resume errors (e.g. process already resumed).
+--]]
+function ResumeProcessing(process, reason, ignore_errors)
+	reason = reason or ""
+	local reasons = SuspendProcessReasons and SuspendProcessReasons[process]
+	local suspended = reasons and reasons[reason]
+	if not suspended then
+		return
+	end
+	assert(ignore_errors or suspended == GameTime())
+	local now = GameTime()
+	reasons[reason] = nil
+	if next(reasons) ~= nil then
+		return
+	end
+	assert(not IsProcessingSuspended(process))
+	ExecuteSuspended(process)
+	Msg("ProcessingResumed", process)
+end
+
+--[[@@@
+Execute a routine from a named process. If the process is currently suspended, the call will be registered in ordered to be executed once the process is resumed. Multiple calls with the same context will be registered as one.
+@function void ExecuteProcess(string process, function func, table obj)
+@param string process - the name of the process, which routines should be suspended.
+@param function func - the function to be executed.
+@param table obj - optional function context.
+--]]
+function ExecuteProcess(process, funcname, obj, ...)
+	if not IsProcessingSuspended(process) then
+		dbg(CheckExecutionTimestamp(process, funcname, obj))
+		return procall(_G[funcname], obj, ...)
+	end
+	local params = PackProcessParams(obj, ...)
+	local suspended = SuspendedProcessing
+	if not suspended then
+		suspended = {}
+		SuspendedProcessing = suspended
+	end
+	local funcs_to_params = suspended[process]
+	if not funcs_to_params then
+		suspended[process] = { funcname, [funcname] = {params} }
+		return
+	end
+	local objs = funcs_to_params[funcname]
+	if not objs then
+		funcs_to_params[#funcs_to_params + 1] = funcname
+		funcs_to_params[funcname] = {params}
+		return
+	end
+	table.insert_unique(objs, params)
+end
+
+----
+
+if Platform.asserts then
+
+local ExecutionTimestamps
+
+function OnMsg.DoneMap()
+	ExecutionTimestamps = false
+end
+
+-- Rise an error if a routine from a process is executed twice in the same time
+    --[[@@@
+Checks if a process routine has been executed more than once in the same time frame.
+@function void CheckExecutionTimestamp(string process, string funcname, table obj, boolean delayed)
+@param string process - the name of the process
+@param string funcname - the name of the function being executed
+@param table obj - the object context of the function being executed
+@param boolean delayed - whether the function call is delayed
+@return boolean - true if the function has been executed more than once, false otherwise
+--]]
+    CheckExecutionTimestamp = function(process, funcname, obj, delayed)
+        if not config.DebugSuspendProcess then
+            return
+        end
+        if not ExecutionTimestamps then
+            ExecutionTimestamps = {}
+            CreateRealTimeThread(function()
+                Sleep(1)
+                ExecutionTimestamps = false
+            end)
+        end
+        local func_to_objs = ExecutionTimestamps[process]
+        if not func_to_objs then
+            func_to_objs = {}
+            ExecutionTimestamps[process] = func_to_objs
+        end
+        local objs_to_timestamp = func_to_objs[funcname]
+        if not objs_to_timestamp then
+            objs_to_timestamp = {}
+            func_to_objs[funcname] = objs_to_timestamp
+        end
+        obj = obj or false
+        local rtime, gtime = RealTime(), GameTime()
+        local timestamp = xxhash(rtime, gtime)
+        if timestamp == objs_to_timestamp[obj] then
+            print("Duplicated processing:", process, funcname, "time:", gtime, "obj:", obj and obj.class,
+                obj and obj.handle)
+            assert(false, string.format("Duplicated process routine: %s.%s", process, funcname))
+        else
+            objs_to_timestamp[obj] = timestamp
+            --[[
+		if IsValid(obj) then
+			local pos = obj:GetVisualPos()
+			local seed = xxhash(obj and obj.handle)
+			local len = 5*guim + BraidRandom(seed, 10*guim)
+			DbgAddVector(pos, len, RandColor(seed))
+			DbgAddText(funcname, pos + point(0, 0, len), RandColor(obj and obj.handle))
+		end
+		--]]
+        end
+    end
+
+    ---
+    --- Checks if there are any remaining reasons for suspending a process.
+    --- If there are any remaining reasons, an assertion is triggered with the process name and reason.
+    ---
+    --- @function CheckRemainingReason
+    --- @return nil
+    CheckRemainingReason = function()
+        local process = next(SuspendProcessReasons)
+        local reason = process and next(SuspendProcessReasons[process])
+        if reason then
+            assert(false, string.format("Process '%s' not resumed: %s", process, ValueToStr(reason)))
+        end
+    end
+
+end -- Platform.asserts

CommonLua/CMT.lua

@@ -0,0 +1,155 @@
+if not const.cmtVisible then return end
+
+if FirstLoad then
+	C_CCMT = false
+end
+
+function SetC_CCMT(val)
+	if C_CCMT == val then
+		return
+	end
+	C_CCMT_Reset()
+	C_CCMT = val
+end
+
+function OnMsg.ChangeMap()
+	C_CCMT_Reset()
+end
+
+MapVar("CMT_ToHide", {})
+MapVar("CMT_ToUnhide", {})
+MapVar("CMT_Hidden", {})
+
+CMT_Time = 300
+CMT_OpacitySleep = 10
+CMT_OpacityStep = Max(1, MulDivRound(CMT_OpacitySleep, 100, CMT_Time))
+
+if FirstLoad then
+	g_CMTPaused = false
+	g_CMTPauseReasons = {}
+end
+
+function CMT_SetPause(s, reason)
+	if s then
+		g_CMTPauseReasons[reason] = true
+		g_CMTPaused = true
+	else
+		g_CMTPauseReasons[reason] = nil
+		if not next(g_CMTPauseReasons) then
+			g_CMTPaused = false
+		end
+	end
+end
+
+MapRealTimeRepeat( "CMT_V2_Thread", 0, function()
+	Sleep(CMT_OpacitySleep)
+	if g_CMTPaused then return end
+	--local startTs = GetPreciseTicks(1000)
+	
+	if C_CCMT then
+		C_CCMT_Thread_Func(CMT_OpacityStep)
+	else	
+		local opacity_step = CMT_OpacityStep
+		
+		for k,v in next, CMT_ToHide do
+			if not IsValid(k) then
+				CMT_ToHide[k] = nil
+			else
+				local next_opacity = k:GetOpacity() - opacity_step
+				if next_opacity > 0 then
+					k:SetOpacity(next_opacity)
+				else
+					k:SetOpacity(0)
+					CMT_ToHide[k] = nil
+					CMT_Hidden[k] = true
+				end
+			end
+		end
+		for k,v in next, CMT_ToUnhide do
+			if not IsValid(k) then
+				CMT_ToUnhide[k] = nil
+			else
+				local next_opacity = k:GetOpacity() + opacity_step
+				if next_opacity < 100 then
+					k:SetOpacity(next_opacity)
+				else
+					k:SetOpacity(100)
+					k:ClearHierarchyGameFlags(const.gofSolidShadow + const.gofContourInner)
+					CMT_ToUnhide[k] = nil
+				end
+			end
+		end
+	end
+	--local endTs = GetPreciseTicks(1000)
+	--print("CMT_V2_Thread time", endTs - startTs)
+end)
+
+function IsContourObject(obj)
+	return const.SlabSizeX and IsKindOf(obj, "Slab")
+end
+
+function CMT(obj, b)
+	if C_CCMT then
+		C_CCMT_Hide(obj, not not b)
+		return
+	end
+	
+	if b then
+		if CMT_ToHide[obj] or CMT_Hidden[obj] then return end
+		if CMT_ToUnhide[obj] then
+			CMT_ToUnhide[obj] = nil
+		end
+		CMT_ToHide[obj] = true
+		obj:SetHierarchyGameFlags(const.gofSolidShadow)
+		if IsContourObject(obj) then
+			obj:SetHierarchyGameFlags(const.gofContourInner)
+		end
+	else
+		if CMT_ToUnhide[obj] or not CMT_ToHide[obj] and not CMT_Hidden[obj] then return end
+		if CMT_ToHide[obj] then
+			CMT_ToHide[obj] = nil
+		end
+		if IsEditorActive() then
+			obj:SetOpacity(100)
+			obj:ClearHierarchyGameFlags(const.gofSolidShadow + const.gofContourInner) 
+		else
+			CMT_ToUnhide[obj] = true
+		end
+		if CMT_Hidden[obj] then
+			CMT_Hidden[obj] = nil
+		end
+	end
+end
+
+local function ShowAllKeyObjectsAndClearTable(table)
+	for obj, _ in pairs(table) do
+		if IsValid(obj) then
+			obj:SetOpacity(100)
+			obj:ClearHierarchyGameFlags(const.gofSolidShadow + const.gofContourInner)
+		end
+		table[obj] = nil
+	end
+end
+
+function OnMsg.ChangeMapDone(map)
+	if string.find(map, "MainMenu") then
+		CMT_SetPause(true, "MainMenu")
+	else
+		CMT_SetPause(false, "MainMenu")
+	end
+end
+
+function OnMsg.GameEnterEditor()
+	C_CCMT_ShowAllAndReset()
+	ShowAllKeyObjectsAndClearTable(CMT_ToHide)
+	ShowAllKeyObjectsAndClearTable(CMT_ToUnhide)
+	ShowAllKeyObjectsAndClearTable(CMT_Hidden)
+end
+
+function CMT_IsObjVisible(o)
+	if not C_CCMT then
+		return o:GetGameFlags(const.gofSolidShadow) == 0 or CMT_ToUnhide[o]
+	else
+		return C_CCMT_GetObjCMTState(o) < const.cmtHidden
+	end
+end

CommonLua/Camera.lua

@@ -0,0 +1,1005 @@
+---
+--- Calculates the power of a camera shake effect based on the position of the camera and the position of the shake.
+--- @param pos point The position of the shake.
+--- @param radius_insight number The radius within which the shake is considered to be in sight of the camera.
+--- @param radius_outofsight number The radius beyond which the shake is considered to be out of sight of the camera.
+--- @return number The power of the camera shake effect, as a percentage.
+---
+function CameraShake_GetEffectPower(pos, radius_insight, radius_outofsight)
+	local cam_pos, cam_look = GetCamera()
+	local camera_orientation = CalcOrientation(cam_pos, cam_look)
+	local shake_orientation = CalcOrientation(cam_pos, pos)
+	local dist = DistSegmentToPt(cam_pos, cam_look, pos)
+	if dist < 0 then
+		assert(false)
+		return 0
+	end
+	
+	local radius
+	if abs(AngleDiff(shake_orientation, camera_orientation)) < const.CameraShakeFOV/2 then
+		radius = radius_insight or const.ShakeRadiusInSight
+	else
+		radius = radius_outofsight or const.ShakeRadiusOutOfSight
+	end
+	return dist < radius and 100 * (radius - dist) / radius or 0
+end
+
+--- Starts a camera shake effect with the specified position and power.
+-- @cstyle void CameraShake(point pos, int power).
+-- @param pos point.
+-- @param power int.
+-- @return void.
+function CameraShake(pos, power)
+	power = power * CameraShake_GetEffectPower(pos) / 100
+	if power == 0 then return end
+	local total_duration = const.MinShakeDuration + power*(const.MaxShakeDuration-const.MinShakeDuration)/const.MaxShakePower
+	local shake_offset = power*const.MaxShakeOffset/const.MaxShakePower
+	local shake_roll = power*const.MaxShakeRoll/const.MaxShakePower
+	camera.Shake(total_duration, const.ShakeTick, shake_offset, shake_roll)
+end
+
+---
+--- Stores the current camera shake thread and the maximum offset for the camera shake effect.
+---
+--- @field camera_shake_thread thread The current camera shake thread.
+--- @field camera_shake_max_offset number The maximum offset for the camera shake effect.
+---
+MapVar("camera_shake_thread", false)
+MapVar("camera_shake_max_offset", 0)
+---
+--- Performs a camera shake effect with the specified parameters.
+---
+--- @param total_duration number The total duration of the camera shake effect, in seconds.
+--- @param shake_tick number The interval between each shake, in seconds.
+--- @param max_offset number The maximum offset of the camera shake, in meters.
+--- @param max_roll_offset number The maximum roll offset of the camera shake, in degrees.
+---
+
+local function DoShakeCamera(total_duration, shake_tick, max_offset, max_roll_offset)
+    local time_left = total_duration
+    while true do
+        local LookAtOffset = RandPoint(1500, 500, 500)
+        local EyePtOffset = RandPoint(1500, 500, 500)
+        local len = Max(1, 2 * time_left * max_offset / total_duration)
+        local angle = 60 * time_left * max_roll_offset / total_duration
+        if LookAtOffset:Len2() > 0 then
+            LookAtOffset = SetLen(LookAtOffset, len)
+        end
+        if EyePtOffset:Len2() > 0 then
+            EyePtOffset = SetLen(EyePtOffset, len)
+        end
+        camera.SetLookAtOffset(LookAtOffset, shake_tick)
+        camera.SetEyeOffset(EyePtOffset, shake_tick)
+        camera.SetRollOffset(AsyncRand(2 * angle + 1) - angle, shake_tick)
+        if total_duration > 0 then
+            time_left = time_left - shake_tick
+            if time_left <= shake_tick then
+                Sleep(time_left)
+                break
+            end
+        end
+        Sleep(shake_tick)
+    end
+    camera.ShakeStop(shake_tick)
+end
+
+---
+--- Performs a camera shake effect with the specified parameters.
+---
+--- @param total_duration number The total duration of the camera shake effect, in seconds.
+--- @param shake_tick number The interval between each shake, in seconds.
+--- @param shake_max_offset number The maximum offset of the camera shake, in meters. This value is clamped to the range [0, 10m].
+--- @param shake_max_roll number The maximum roll offset of the camera shake, in degrees. This value is clamped to the range [0, 180].
+---
+function camera.Shake(total_duration, shake_tick, shake_max_offset, shake_max_roll)
+    local max_offset = Clamp(shake_max_offset, 0, 10 * guim)
+    assert(max_offset == shake_max_offset, "camera.Shake() max_offset should be [0-10m]!")
+    local max_roll = Clamp(shake_max_roll, 0, 180)
+    assert(max_roll == shake_max_roll, "camera.Shake() max_roll should be [0-180]!")
+
+    if total_duration == 0 or shake_tick <= 0 then
+        return
+    end
+    if IsValidThread(camera_shake_thread) then
+        if camera_shake_max_offset > shake_max_offset then
+            return
+        end
+        DeleteThread(camera_shake_thread)
+    end
+    camera_shake_max_offset = max_offset
+    camera_shake_thread = CreateRealTimeThread(DoShakeCamera, total_duration, shake_tick, max_offset, max_roll)
+    MakeThreadPersistable(camera_shake_thread)
+end
+
+---
+--- Stops the camera shake effect.
+---
+--- @param shake_tick number The interval between each shake, in seconds.
+---
+function camera.ShakeStop(shake_tick)
+    camera.SetRollOffset(0, 0)
+    camera.SetLookAtOffset(point30, shake_tick or 0)
+    camera.SetEyeOffset(point30, shake_tick or 0)
+    camera_shake_max_offset = 0
+    if IsValidThread(camera_shake_thread) and CurrentThread() ~= camera_shake_thread then
+        DeleteThread(camera_shake_thread)
+    end
+    camera_shake_thread = false
+end
+
+function OnMsg.ChangeMap()
+	camera.ShakeStop()
+end
+
+---
+--- Sets the camera to the specified position, look-at point, camera type, zoom, and field of view.
+---
+--- @param ptCamera vec3 The position of the camera.
+--- @param ptCameraLookAt vec3 The point the camera is looking at.
+--- @param camType string The type of camera to use. Can be "3p", "RTS", "Max", or "Tac".
+--- @param zoom number The zoom level of the camera.
+--- @param properties table A table of camera properties to set.
+--- @param fovX number The field of view of the camera in degrees.
+--- @param time number The duration of the camera transition in seconds.
+---
+--- @return nil
+---
+function SetCamera(ptCamera, ptCameraLookAt, camType, zoom, properties, fovX, time)
+	if type(ptCamera) == "table" then
+		return SetCamera(unpack_params(ptCamera))
+	end
+	time = time or 0
+	if camType then
+		if camType == "Max" or camType == "3p" or camType == "RTS" or camType == "Tac" then
+			camType = "camera" .. camType
+		end
+		_G[camType].Activate(1)
+	end
+	if not ptCamera then
+		return
+	end
+	if camera3p.IsActive() then
+		camera3p.SetEye(ptCamera, time)
+		camera3p.SetLookAt(ptCameraLookAt, time)
+	elseif cameraRTS.IsActive() then
+		if properties then
+			cameraRTS.SetProperties(1, properties)
+		end
+		cameraRTS.SetCamera(ptCamera, ptCameraLookAt, time)
+		if zoom then
+			cameraRTS.SetZoom(zoom)
+		end
+	elseif cameraMax.IsActive() then
+		-- cameraMax can't look straight down
+		local diff = ptCameraLookAt - ptCamera
+		if diff:x() == 0 and diff:y() == 0 then
+			ptCamera = ptCamera:SetX(ptCamera:x()-5)
+		end
+		cameraMax.SetCamera(ptCamera, ptCameraLookAt, time)
+	elseif cameraTac.IsActive() then
+		cameraTac.SetCamera(ptCamera, ptCameraLookAt, time)
+		if properties then
+			local floor = properties.floor
+			local overview = properties.overview
+			if floor then
+				cameraTac.SetFloor(floor)
+			end
+			if overview ~= nil then
+				cameraTac.SetOverview(overview, true)
+			end
+		end
+		if zoom then
+			cameraTac.SetZoom(zoom)
+		end
+	end
+	SetCameraFov(fovX)
+end
+
+---
+--- Sets the camera field of view (FOV) to the specified value.
+---
+--- @param fovX number The horizontal field of view in degrees. If not provided, defaults to 70 degrees.
+---
+function SetCameraFov(fovX)
+    camera.SetFovX(fovX or 70 * 60)
+end
+
+---
+--- Sets the camera field of view (FOV) to the specified value, with optional easing.
+---
+--- @param properties table A table containing the following properties:
+---   - FovX: number The horizontal field of view in degrees.
+---   - FovXNarrow: number The horizontal field of view in degrees for 3:4 screens.
+---   - FovXWide: number The horizontal field of view in degrees for 21:9 screens.
+--- @param duration number (optional) The duration of the FOV change in seconds.
+--- @param easing string (optional) The easing function to use for the FOV change.
+---
+function SetRTSCameraFov(properties, duration, easing)
+    local FovX = properties.FovX
+    local minFovX = properties.FovXNarrow -- FovX for 3:4 screens
+    local minX, minY = 4, 3
+    local maxFovX = properties.FovXWide -- FovX for 21:9 screens
+    local maxX, maxY = 21, 9
+    if FovX and minFovX and maxFovX then
+        -- when both FovXNarrow and FovXWide are supplied,
+        -- FovX at 16:9 is computed and equals FovXNarrow * 5 / 9 + FovXWide * 4 / 9
+        assert(abs(minFovX * 5 / 9 + maxFovX * 4 / 9 - FovX) < 60)
+    end
+    FovX = FovX or 90 * 60
+    if not minFovX then
+        minFovX = FovX
+        minX, minY = 16, 9
+    end
+    if not maxFovX then
+        maxFovX = FovX
+        maxX, maxY = 16, 9
+    end
+    hr.CameraFovEasing = easing or "Linear"
+    camera.SetAutoFovX(1, duration or 0, minFovX, minX, minY, maxFovX, maxX, maxY)
+end
+
+-- init from last camera with reasonable settings ( at editor exit, ... )
+-- or set to map center if first run
+---
+--- Sets the default camera to the RTS (Real-Time Strategy) camera type and configures its properties.
+---
+--- If the Libs.Sim module is available, it retrieves the RTS camera properties from the account storage and applies them.
+--- Otherwise, it uses the default RTS camera properties defined in const.DefaultCameraRTS.
+---
+--- The function also sets the camera's field of view using the SetRTSCameraFov function, and positions the camera to the center of the map if the current look-at position is at (0, 0).
+---
+--- Finally, it calls the ViewObjectRTS function to set the camera's position and look-at to the center of the map.
+---
+function SetDefaultCameraRTS()
+    cameraRTS.Activate(1)
+    cameraRTS.SetProperties(1, const.DefaultCameraRTS)
+    if Libs.Sim then
+        cameraRTS.SetProperties(1, GetRTSCamPropsFromAccountStorage())
+    end
+    SetRTSCameraFov(const.DefaultCameraRTS)
+    local lookat = cameraRTS.GetLookAt()
+    if lookat:x() == 0 and lookat:y() == 0 then
+        lookat = point(terrain.GetMapSize()) / 2
+    end
+    ViewObjectRTS(lookat, 0)
+end
+
+---
+--- Returns a table of available camera types.
+---
+--- @return table Camera types
+---
+function GetCameraTypesItems()
+    return {"3p", "RTS", "Max", "Tac"}
+end
+
+---
+--- Returns the current camera position, look-at position, camera type, zoom level, and camera properties.
+---
+--- @return point, point, string, number, table, number Camera position, look-at position, camera type, zoom level, camera properties, and field of view angle
+---
+function GetCamera()
+    local ptCamera, ptCameraLookAt, camType, zoom, properties, fovX
+    if camera3p.IsActive() then
+        ptCamera, ptCameraLookAt = camera.GetEye(), camera3p.GetLookAt()
+        camType = "3p"
+    elseif cameraRTS.IsActive() then
+        ptCamera, ptCameraLookAt = cameraRTS.GetPosLookAt()
+        camType = "RTS"
+        zoom = cameraRTS.GetZoom()
+        properties = cameraRTS.GetProperties(1)
+    elseif cameraMax.IsActive() then
+        ptCamera, ptCameraLookAt = cameraMax.GetPosLookAt()
+        camType = "Max"
+    elseif cameraTac.IsActive() then
+        ptCamera, ptCameraLookAt = cameraTac.GetPosLookAt()
+        camType = "Tac"
+        zoom = cameraTac.GetZoom()
+        properties = {floor=cameraTac.GetFloor(), overview=cameraTac.GetIsInOverview()}
+    else
+        ptCamera, ptCameraLookAt = camera.GetEye(), camera.GetEye() + SetLen(camera.GetDirection(), 3 * guim)
+    end
+    fovX = camera.GetFovX()
+    return ptCamera, ptCameraLookAt, camType, zoom, properties, fovX
+end
+
+if FirstLoad then
+	ptLastCameraPos = false
+	ptLastCameraLookAt = false
+	cameraMax3DView = {
+		toggle = false,
+		old_pos = false,
+		old_lookat = false,
+	}
+end
+
+---
+--- Cleans up the state of the cameraMax3DView object.
+--- Resets the toggle, old_pos, and old_lookat properties to their default values.
+---
+function cameraMax3DView:Clean()
+    self.toggle = false
+    self.old_pos = false
+    self.old_lookat = false
+end
+
+-- returns the new camera pos and the look pos of the selection
+---
+--- Rotates the camera in the 3D Max view to the specified view direction.
+---
+--- @param view_direction point The new view direction for the camera.
+---
+local function cameraMax3DView_Rotate(view_direction)
+    local sel = editor.GetSel()
+    local cnt = #sel
+    if cnt == 0 then
+        print("You need to select object(s) for this operation")
+        return
+    end
+
+    local center = point30
+    for i = 1, cnt do
+        local bsc = sel[i]:GetBSphere()
+        center = center + bsc
+    end
+    if cnt > 0 then
+        -- find center of the selection
+        center = point(center:x() / cnt, center:y() / cnt, center:z() / cnt)
+
+        -- find the radius of the bounding sphere of the selection
+        local selSize = 0
+        for i = 1, cnt do
+            local bsc, bsr = sel[i]:GetBSphere()
+            local dist = bsc:Dist(center) + bsr
+            if selSize < dist then
+                selSize = dist
+            end
+        end
+        selSize = 2 * selSize -- get the diameter of the selection
+
+        -- move the camera position to look in the center of the selection
+        local half_fovY = MulDivRound(camera.GetFovY(), 1, 2)
+        local fov_sin, fov_cos = sin(half_fovY), cos(half_fovY)
+        local dist_from_camera = (fov_sin > 0) and MulDivRound((selSize / 2), fov_cos, fov_sin) or (selSize / 2)
+
+        view_direction = SetLen(view_direction, dist_from_camera * 130 / 100)
+        local pos = center + view_direction
+        cameraMax.SetCamera(pos, center, 0)
+    end
+end
+
+---
+--- Rotates the camera in the 3D Max view to the up direction.
+---
+function cameraMax3DView:SetViewUp()
+    cameraMax3DView_Rotate(point(0, 0, 1))
+end
+---
+--- Rotates the camera in the 3D Max view to the down direction.
+---
+function cameraMax3DView:SetViewDown()
+    cameraMax3DView_Rotate(point(0, 0, -1))
+end
+---
+--- Sets the camera to the old position and look-at point.
+---
+function cameraMax3DView:SetViewOld()
+    cameraMax.SetCamera(cameraMax3DView.old_pos, cameraMax3DView.old_lookat, 0)
+end
+
+---
+--- Rotates the camera in the 3D Max view around the Z axis.
+---
+--- @param dir string The direction to rotate the camera, either "east" or "west".
+---
+function cameraMax3DView:RotateZ(dir)
+    local pos, look_at = cameraMax.GetPosLookAt()
+    local cam_angle = (camera.GetYaw() / 60) + 180
+    local cam_quadrant = (cam_angle / 90) % 4 + 1
+    local correction = 0
+    local z_axis = point(0, 0, 1)
+
+    if cam_angle % 90 ~= 0 then
+        if cam_angle - 90 * (cam_quadrant - 1) < 90 * cam_quadrant - cam_angle then
+            correction = -(cam_angle - 90 * (cam_quadrant - 1))
+        else
+            correction = 90 * cam_quadrant - cam_angle
+        end
+        cam_angle = cam_angle + correction
+    end
+
+    local view_dir = false
+    if dir == "east" then
+        view_dir = RotateAxis(pos, z_axis, (cam_angle - 90) * 60)
+    else
+        view_dir = RotateAxis(pos, z_axis, (cam_angle + 90) * 60)
+    end
+
+    if view_dir then
+        cameraMax3DView_Rotate(Normalize(view_dir))
+    end
+end
+
+---
+--- Sets the camera position and look-at point.
+---
+--- @param pos table The position of the camera, represented as a point.
+--- @param dist number (optional) The distance from the camera to the look-at point.
+--- @param cam_type number (optional) The type of camera to use.
+---
+--- If `pos` is `InvalidPos()`, the camera will be reset to the last known position and look-at point.
+--- If `pos` does not have a valid Z coordinate, it will be set to the terrain Z coordinate.
+--- The camera vector is calculated based on the `pos` and the look-at point, and the camera is set to this position.
+---
+function ViewPos(pos, dist, cam_type)
+    local ptCamera, ptCameraLookAt = GetCamera()
+    if not ptCamera then
+        return
+    end
+    if pos == InvalidPos() then
+        pos = nil
+    end
+    if not pos then
+        if ptLastCameraPos then
+            SetCamera(ptLastCameraPos, ptLastCameraLookAt, cam_type)
+        end
+        return
+    end
+
+    ptLastCameraPos, ptLastCameraLookAt = ptCamera, ptCameraLookAt
+
+    if not pos:z() then
+        pos = pos:SetTerrainZ()
+    end
+
+    local cameraVector = ptCameraLookAt - ptCamera
+    if dist then
+        cameraVector = SetLen(cameraVector, dist)
+    end
+    ptCamera = pos - cameraVector
+    ptCameraLookAt = pos
+
+    SetCamera(ptCamera, ptCameraLookAt, cam_type)
+end
+
+---
+--- Sets the camera to view the specified object.
+---
+--- @param obj MapObject|number The object to view, or its handle.
+--- @param dist number (optional) The distance from the camera to the object.
+---
+--- If `obj` is a number, it is assumed to be the handle of a `MapObject` and looked up in `HandleToObject`.
+--- If `pos` is `InvalidPos()`, the camera will be reset to the last known position and look-at point.
+--- If `pos` does not have a valid Z coordinate, it will be set to the terrain Z coordinate.
+--- The camera vector is calculated based on the `pos` and the look-at point, and the camera is set to this position.
+---
+ViewObject = function(obj, dist)
+    if type(obj) == "number" and HandleToObject[obj] then
+        obj = HandleToObject[obj]
+    end
+    local pos = IsValid(obj) and obj:GetPos()
+    if not pos or pos == InvalidPos() then
+        return
+    end
+    if dist then
+        ViewPos(pos, dist)
+    else
+        local center, radius = obj:GetBSphere()
+        ViewPos(center, Max(guim, radius * 10))
+    end
+end
+
+---
+--- Caches the last object viewed by `ViewNextObject`.
+---
+--- This cache is used to keep track of the last object that was viewed, so that `ViewNextObject` can cycle through the objects in the order they were viewed.
+---
+local ViewNextObjectCache
+function OnMsg.ChangeMap()
+	ViewNextObjectCache = nil
+end
+
+-- Cycles ViewObject in the array objs, viewing the next object every time it is called for the same set of parameters
+
+---
+--- Cycles through the next object in the given list of objects and views it.
+---
+--- @param name string (optional) The class name of the objects to cycle through. If not provided, the class name of the last selected object is used.
+--- @param objs table (optional) The list of objects to cycle through. If not provided, all objects of the given class name are used.
+--- @param select_obj boolean (optional) Whether to select the object after viewing it.
+---
+--- If `name` is not provided and there is no last selected object, this function does nothing.
+--- If `objs` is not provided, all objects of the given class name are used.
+--- The function keeps track of the last object viewed and cycles to the next one in the list.
+--- If the end of the list is reached, it cycles back to the beginning.
+--- If `select_obj` is true, the viewed object is also selected.
+---
+function ViewNextObject(name, objs, select_obj)
+    name = name or ""
+    local last
+    if not objs then
+        if name == "" then
+            last = SelectedObj
+            name = last and last.class
+            select_obj = true
+        end
+        if not IsKindOf(g_Classes[name], "MapObject") then
+            return
+        end
+        objs = MapGet("map", name)
+    end
+    ViewNextObjectCache = ViewNextObjectCache or setmetatable({}, weak_values_meta)
+    last = last or ViewNextObjectCache[name]
+    local idx = last and table.find(objs, last) or 0
+    last = objs[idx + 1] or objs[1]
+    ViewNextObjectCache[name] = last
+    ViewObject(last)
+    SelectObj(last)
+end
+
+---
+--- Cycles through the next object in the given list of objects and views it.
+---
+--- @param name string (optional) The class name of the objects to cycle through. If not provided, the class name of the last selected object is used.
+--- @param objs table (optional) The list of objects to cycle through. If not provided, all objects of the given class name are used.
+--- @param select_obj boolean (optional) Whether to select the object after viewing it.
+---
+--- If `name` is not provided and there is no last selected object, this function does nothing.
+--- If `objs` is not provided, all objects of the given class name are used.
+--- The function keeps track of the last object viewed and cycles to the next one in the list.
+--- If the end of the list is reached, it cycles back to the beginning.
+--- If `select_obj` is true, the viewed object is also selected.
+---
+function ViewObjects(objects)
+	objects = objects or {}
+	local dgs = XEditorSelectSingleObjects
+	XEditorSelectSingleObjects = 1
+	editor.ChangeSelWithUndoRedo(objects)
+	XEditorSelectSingleObjects = dgs
+	if #objects == 0 then
+		return
+	end
+	local bbox = GetObjectsBBox(objects)
+	local center, radius = bbox:GetBSphere()
+	local cam_pos = camera.GetEye()
+	local h = cam_pos:z() - terrain.GetSurfaceHeight(cam_pos)
+	local eye = center:SetZ(0) + SetLen((cam_pos - center):SetZ(0), h)
+	eye = eye:SetZ(terrain.GetSurfaceHeight(eye) + h)
+	local dist = (eye - center):Len()
+	local new_dist = Clamp(Max(dist, 2*radius), 10*guim, 100*guim)
+	eye = center + MulDivRound(eye - center, new_dist, dist)
+	local steps = 18
+	local angle = 360 * 60 / steps
+	local max_radius = 2 * guim
+	local success = true
+	local objects_map = {}
+	for i=1,#objects do
+		objects_map[objects[i]] = true
+	end
+	while true do
+		local objs = IntersectSegmentWithObjects(eye, center, const.efVisible)
+		if not objs then
+			break
+		end
+		local objects_too_big = false
+		for i=1,#objs do
+			local obj = objs[i]
+			if not objects_map[obj] then
+				local center, radius = obj:GetBSphere()
+				if radius > max_radius then
+					objects_too_big = true
+					break
+				end
+			end
+		end
+		if not objects_too_big then
+			break
+		end
+		steps = steps - 1
+		if steps <= 1 then
+			success = false
+			break
+		end
+		eye = RotateAroundCenter(center, eye, angle)
+		eye = eye:SetZ(terrain.GetSurfaceHeight(eye) + h) 
+	end
+	if success then
+		SetCamera(eye, center)
+	end
+end
+
+if FirstLoad then
+	SplitScreenType = false
+	SplitScreenEnabled = true
+	SecondViewEnabled = false
+	SecondViewViewport = false
+end
+
+-- call this after every resolution/scene size change to recalc and setup appropriate views for single or split screen
+---
+--- Sets up the camera views for single or split screen.
+---
+--- @param size number|nil The size of the screen, if provided.
+---
+--- This function is responsible for configuring the camera views based on the current split screen settings.
+--- If split screen is enabled, it sets up two views - one for each player. The views can be either horizontal or vertical.
+--- If split screen is disabled, it sets up a single view that covers the entire screen.
+--- The function adjusts the viewport settings of the camera accordingly.
+---
+function SetupViews(size)
+    local w, h = 1000000, 1000000
+    if SecondViewEnabled and SecondViewViewport then
+        camera.SetViewCount(2)
+        camera.SetViewport(box(0, 0, w, h), 1)
+        camera.SetViewport(SecondViewViewport, 2)
+    elseif SplitScreenEnabled then
+        if SplitScreenType == "horizontal" then
+            camera.SetViewCount(2)
+            camera.SetViewport(box(0, 0, w, h / 16 * 8), 1)
+            camera.SetViewport(box(0, (h + 15) / 16 * 8, w, h), 2)
+        elseif SplitScreenType == "vertical" then
+            camera.SetViewCount(2)
+            camera.SetViewport(box(0, 0, w / 16 * 8, h), 1)
+            camera.SetViewport(box((w + 15) / 16 * 8, 0, w, h), 2)
+        else
+            camera.SetViewCount(1)
+            camera.SetViewport(box(0, 0, w, h), 1)
+        end
+    else
+        if not SplitScreenType then
+            camera.SetViewCount(1)
+            camera.SetViewport(box(0, 0, w, h), 1)
+        else
+            camera.SetViewport(box(0, 0, w, h), 1)
+        end
+    end
+end
+
+if FirstLoad then
+SplitScreenDisableReasons = {}
+end
+
+---
+--- Enables or disables split screen mode based on the provided reason.
+---
+--- @param on boolean Whether to enable or disable split screen mode.
+--- @param reason string The reason for enabling or disabling split screen mode.
+---
+--- This function is responsible for managing the state of split screen mode. It updates the `SplitScreenDisableReasons` table to track the reasons for enabling or disabling split screen mode. If there are no more reasons to disable split screen mode, it enables it. Otherwise, it disables it. The function also calls `SetupViews()` to reconfigure the camera views and sends a "SplitScreenChange" message.
+---
+function SetSplitScreenEnabled(on, reason)
+    assert(reason)
+    SplitScreenDisableReasons[reason] = (on == false) or nil
+    on = not next(SplitScreenDisableReasons)
+    if SplitScreenEnabled ~= on then
+        SplitScreenEnabled = on
+        SetupViews()
+        Msg("SplitScreenChange", true)
+    end
+end
+
+---
+--- Enables the second view for the camera and sets the viewport for it.
+---
+--- @param viewport table The viewport for the second view.
+---
+--- This function enables the second view for the camera and sets the viewport for it. It updates the `SecondViewEnabled` and `SecondViewViewport` variables and then calls the `SetupViews()` function to reconfigure the camera views.
+---
+function EnableSecondView(viewport)
+    SecondViewEnabled = true
+    SecondViewViewport = viewport
+    SetupViews()
+end
+
+---
+--- Disables the second view for the camera.
+---
+--- This function disables the second view for the camera by setting the `SecondViewEnabled` variable to `false` and calling the `SetupViews()` function to reconfigure the camera views.
+---
+function DisableSecondView()
+    SecondViewEnabled = false
+    SetupViews()
+end
+
+---
+--- Sets the split screen type.
+---
+--- @param type string The type of split screen to use, or an empty string to disable split screen.
+---
+--- This function sets the `SplitScreenType` variable to the provided `type` parameter. If the `type` is an empty string, split screen is disabled. The function then calls `SetupViews()` to reconfigure the camera views, and sends a "SplitScreenChange" message if the split screen type has changed.
+function SetSplitScreenType(type)
+    if type == "" then
+        type = false
+    end
+    local bChange = SplitScreenType ~= type
+    SplitScreenType = type
+    if not CameraControlScene then
+        SetupViews()
+    end
+    if bChange then
+        Msg("SplitScreenChange")
+    end
+end
+
+---
+--- Checks if split screen is enabled.
+---
+--- @return boolean true if split screen is enabled, false otherwise
+---
+function IsSplitScreenEnabled()
+    return SplitScreenEnabled and SplitScreenType and true
+end
+
+---
+--- Checks if split screen is in horizontal mode.
+---
+--- @return boolean true if split screen is in horizontal mode, false otherwise
+---
+function IsSplitScreenHorizontal()
+    return SplitScreenEnabled and SplitScreenType == "horizontal"
+end
+
+---
+--- Checks if split screen is in vertical mode.
+---
+--- @return boolean true if split screen is in vertical mode, false otherwise
+---
+function IsSplitScreenVertical()
+    return SplitScreenEnabled and SplitScreenType == "vertical"
+end
+
+---
+--- Loads a map and camera location from a saved state.
+---
+--- @param map string The name of the map to load.
+--- @param cam_params table A table containing the camera parameters to set.
+--- @param editor_mode boolean Whether to activate the editor mode after loading.
+--- @param map_rand number The random seed to use for the map.
+---
+--- This function loads a map and camera location from a saved state. It first checks if the map exists, and if not, prints an error message. It then creates a real-time thread to perform the following steps:
+---
+--- 1. Deactivate the editor.
+--- 2. If the map or random seed is different from the current map, change the map and restore the configuration.
+--- 3. If the editor mode is enabled, activate the editor.
+--- 4. Set the camera parameters, activating the fly camera if necessary.
+--- 5. Close any open menu dialogs.
+--- 6. Send a "OnDbgLoadLocation" message.
+---
+--- This function is typically used for debugging purposes, to quickly load a specific map and camera location.
+function DbgLoadLocation(map, cam_params, editor_mode, map_rand)
+    if not MapData[map] then
+        print("No such map:", map)
+        return
+    end
+    CreateRealTimeThread(function()
+        EditorDeactivate()
+        if map ~= GetMapName() or map_rand and map_rand ~= MapLoadRandom then
+            if map_rand then
+                table.change(config, "DbgLoadLocation", {FixedMapLoadRandom=map_rand})
+            end
+            ChangeMap(map)
+            table.restore(config, "DbgLoadLocation", true)
+        end
+        if editor_mode then
+            EditorActivate()
+        end
+        if cam_params then
+            if cam_params[3] == "Fly" then
+                cam_params[3] = "Max"
+                SetCamera(table.unpack(cam_params))
+                cameraFly.Activate()
+            else
+                SetCamera(table.unpack(cam_params))
+            end
+        end
+        CloseMenuDialogs()
+        Msg("OnDbgLoadLocation")
+    end)
+end
+
+---
+--- Gets a string representation of the current camera location that can be used to restore the camera state.
+---
+--- @return string A string that can be passed to `DbgLoadLocation` to restore the camera state.
+---
+function GetCameraLocationString()
+    local cam_params
+    if cameraFly.IsActive() then
+        -- Fly camera doesn't expose its parameters, but it can be saved as Max and forced to Fly again on load
+        cameraMax.Activate()
+        cam_params = {GetCamera()}
+        cam_params[3] = "Fly"
+        cameraFly.Activate()
+    else
+        cam_params = {GetCamera()}
+    end
+    return string.format("DbgLoadLocation( \"%s\", %s, %s, %s)\n", GetMapName(), TableToLuaCode(cam_params, ' '),
+        IsEditorActive() and "true" or "false", tostring(MapLoadRandom))
+end
+
+function OnMsg.BugReportStart(print_func)
+	print_func(string.format("\nLocation: (paste in the console)\n%s", GetCameraLocationString()))
+end
+
+if FirstLoad then
+	g_ResetSceneCameraViewportThread = false
+end
+
+function OnMsg.SystemSize(pt)
+	--if FullscreenMode() == 0 then
+		DeleteThread(g_ResetSceneCameraViewportThread)
+		g_ResetSceneCameraViewportThread = CreateRealTimeThread(function()
+			WaitNextFrame(1)
+			SetupViews(pt)
+		end)
+	--end
+end
+
+---
+--- Checks if the given position is a valid camera position.
+---
+--- @param pos point The position to check.
+--- @return boolean True if the position is valid, false otherwise.
+---
+local function IsValidCameraPos(pos)
+    return pos and pos ~= point30 and pos ~= InvalidPos()
+end
+
+---
+--- Checks if the camera can move between two positions without intersecting terrain.
+---
+--- @param pos0 point The starting position for the camera movement.
+--- @param pos1 point The ending position for the camera movement.
+--- @return boolean True if the camera can move between the two positions without intersecting terrain, false otherwise.
+---
+local function CanMoveCamBetween(pos0, pos1)
+    local max_move_dist = const.MaxMoveCamDist or max_int
+    if max_move_dist >= max_int or IsCloser(pos0, pos1, max_move_dist) then
+        return true
+    end
+    return not terrain.IntersectSegment(pos0, pos1)
+end
+
+---
+--- Moves the camera to view the specified object, optionally with a zoom level.
+---
+--- @param obj table|point The object or position to view
+--- @param time number The time in seconds for the camera to move to the new position
+--- @param pos point The position to move the camera to
+--- @param zoom number The zoom level to set the camera to
+---
+function ViewObjectRTS(obj, time, pos, zoom)
+    if not obj then
+        return
+    end
+
+    local la = IsPoint(obj) and obj or IsValid(obj)
+                   and (obj:HasMember("GetLogicalPos") and obj:GetLogicalPos() or obj:GetVisualPos())
+    if not la or la == InvalidPos() then
+        return
+    end
+    la = la:SetTerrainZ()
+
+    local cur_pos, cur_la = cameraRTS.GetPosLookAt()
+    if not pos then
+        local cur_off = cur_pos - cur_la
+        if not IsValidCameraPos(cur_pos) or cur_pos == cur_la then
+            local lookatDist = const.DefaultCameraRTS.LookatDistZoomIn
+                                   + (const.DefaultCameraRTS.LookatDistZoomOut - const.DefaultCameraRTS.LookatDistZoomIn)
+                                   * cameraRTS.GetZoom()
+            cur_off = SetLen(point(1, 1, 0), lookatDist * guim) + point(0, 0, cameraRTS.GetHeight() * guim)
+            zoom = zoom or 0.5
+        end
+        pos = la + cur_off
+    end
+    pos, la = cameraRTS.Normalize(pos, la)
+
+    if not IsValidCameraPos(cur_pos) or not CanMoveCamBetween(cur_pos, pos) then
+        time = 0
+    elseif not time then
+        local min_dist, max_dist = 200 * guim, 1000 * guim
+        local min_time, max_time = 200, 500
+        local dist_factor = Clamp(pos:Dist2D(cur_pos) - min_dist, 0, max_dist) * 100 / (max_dist - min_dist)
+        time = min_time + (max_time - min_time) * dist_factor / 100
+    end
+
+    cameraRTS.SetCamera(pos, la, time or 0, "Sin in/out")
+    if zoom then
+        cameraRTS.SetZoom(zoom, time or 0)
+    end
+end
+
+---
+--- Defines the available types of camera interpolation.
+---
+--- @class CameraInterpolationTypes
+--- @field linear integer Linear interpolation.
+--- @field spherical integer Spherical interpolation.
+--- @field polar integer Polar interpolation.
+CameraInterpolationTypes = {linear=0, spherical=1, polar=2}
+
+---
+--- Defines the available types of camera movement.
+---
+--- @class CameraMovementTypes
+--- @field linear integer Linear movement.
+--- @field harmonic integer Harmonic movement.
+--- @field accelerated integer Accelerated movement.
+--- @field decelerated integer Decelerated movement.
+CameraMovementTypes = {linear=0, harmonic=1, accelerated=2, decelerated=3}
+
+---
+--- Sets the camera position and lookat point, taking into account the base offset and angle.
+---
+--- @param pos table The camera position.
+--- @param lookat table The camera lookat point.
+--- @param base_offset table The base offset to apply to the position and lookat.
+--- @param base_angle number The base angle to apply to the position and lookat.
+--- @param camera_view integer The camera view to use.
+---
+function SetCameraPosMaxLookAt(pos, lookat, base_offset, base_angle, camera_view)
+    cameraMax.SetPositionLookatAndRoll(base_offset + Rotate(pos, base_angle), base_offset + Rotate(lookat, base_angle),
+        0)
+end
+
+---
+--- Interpolates the camera position and lookat point between two camera states over a given duration, relative to a reference object.
+---
+--- @param camera1 table The initial camera state, with `pos` and `lookat` fields.
+--- @param camera2 table The final camera state, with `pos` and `lookat` fields.
+--- @param duration number The duration of the interpolation in frames.
+--- @param relative_to Entity The entity to use as the reference for the camera position and lookat.
+--- @param interpolation string The type of interpolation to use, one of "linear", "spherical", or "polar".
+--- @param movement string The type of camera movement to use, one of "linear", "harmonic", "accelerated", or "decelerated".
+--- @param camera_view integer The camera view to use.
+---
+function InterpolateCameraMaxWakeup(camera1, camera2, duration, relative_to, interpolation, movement, camera_view)
+    camera_view = camera_view or 1
+
+    local base_offset = IsValid(relative_to) and relative_to:GetVisualPosPrecise(1000) or point30
+    local base_angle = IsValid(relative_to) and relative_to:GetVisualAngle() or 0
+
+    local camera2_pos = Rotate(camera2.pos * 1000 - base_offset, 360 * 60 - base_angle)
+    local camera2_lookat = Rotate(camera2.lookat * 1000 - base_offset, 360 * 60 - base_angle)
+    if duration > 1 then
+        local camera1_pos = Rotate(camera1.pos * 1000 - base_offset, 360 * 60 - base_angle)
+        local camera1_lookat = Rotate(camera1.lookat * 1000 - base_offset, 360 * 60 - base_angle)
+        SetCameraPosMaxLookAt(camera1_pos, camera1_lookat, base_offset, base_angle, camera_view)
+        for t = 1, duration do
+            if WaitWakeup(1) then
+                break
+            end
+            base_offset = IsValid(relative_to) and relative_to:GetVisualPosPrecise(1000) or point30
+            base_angle = IsValid(relative_to) and relative_to:GetVisualAngle() or 0
+            local p, l = CameraLerp(camera1_pos, camera1_lookat, camera2_pos, camera2_lookat, t, duration,
+                CameraInterpolationTypes[interpolation] or 0, CameraMovementTypes[movement] or 0)
+            SetCameraPosMaxLookAt(p, l, base_offset, base_angle, camera_view)
+        end
+    end
+    SetCameraPosMaxLookAt(camera2_pos, camera2_lookat, base_offset, base_angle, camera_view)
+end
+
+---
+--- Toggles the fly camera mode.
+---
+--- If the fly camera is active, it deactivates the fly camera and applies the camera and controllers.
+--- If the fly camera is not active, it activates the fly camera and recalculates the active player control.
+--- It also sets the mouse delta mode accordingly.
+---
+function CheatToggleFlyCamera()
+    if cameraFly.IsActive() then
+        SetMouseDeltaMode(false)
+        if rawget(_G, "GetPlayerControlObj") and GetPlayerControlObj() then
+            ApplyCameraAndControllers()
+        else
+            SetupInitialCamera()
+        end
+    else
+        print("Camera Fly")
+        cameraFly.Activate(1)
+        if rawget(_G, "GetPlayerControlObj") and GetPlayerControlObj() then
+            PlayerControl_RecalcActive(true)
+        end
+        SetMouseDeltaMode(true)
+    end
+end

CommonLua/CameraControlUtils.lua

@@ -0,0 +1,149 @@
+--- Returns the camera eye position adjusted to be above the terrain.
+-- @param EyePt point The camera eye position.
+-- @param LookAtPt point The camera look at position.
+-- @return point The adjusted camera eye position.
+-- @return point The camera look at position.
+function GetCameraEyeOverTerrain(EyePt, LookAtPt)
+    local height = GetWalkableZ(EyePt) + const.CameraMinTerrainDist
+    local EyePt = EyePt
+    if height > EyePt:z() then
+        EyePt = EyePt:SetZ(height)
+    end
+    return EyePt, LookAtPt
+end
+
+--- Moves camera look at and eye pos smoothly over the given period of time.
+-- @cstyle int MoveCamera(function get_look_at, function get_eye, int time);
+-- @param get_look_at function; a callback function that receives time as parameter and returns the camera look at position; the callback function is called every 33ms.
+-- @param get_eye function; a callback function that receives time and look at position as parameter and returns the camera eye position; the callback function is called every 33ms.
+-- @param time int.
+-- @return int; orientation in minutes.
+
+function MoveCamera(get_look_at, get_eye, time)
+	if not camera3p.IsActive() then
+		return
+	end
+	local sleep = 33
+	local time_from_start = 0
+	while true do
+		local time_to_end = time - time_from_start
+		local sleep_time = Min(sleep, time - time_from_start)
+		local target_time = Min(time_from_start+sleep_time, time)
+
+		local look_at = get_look_at(target_time)
+		local eye     = get_eye    (look_at, target_time)
+		eye = GetCameraEyeOverTerrain(eye, look_at)
+		camera3p.SetLookAt(look_at, sleep_time)
+		camera3p.SetEye   (eye    , sleep_time)
+		if sleep_time > 0 then
+			Sleep(sleep_time)
+		end
+		if not camera3p.IsActive() then
+			return
+		end
+		time_from_start = time_from_start + sleep_time
+		if time_from_start >= time then
+			break
+		end
+	end
+end
+
+--- Return a callback function that is to be used as get_look_at parameter of MoveCamera function.
+-- The callback will move the current look at position from the camera current look at postion to the target_pos.
+-- 'observing' the target object's movement - the farther the target moves from his start position, the farther.
+-- the camera look at will move away from its initial position and will approach the target_pos.
+-- @cstyle function LookAtFollowCharacter(object target, point target_pos, int total_time).
+-- @param target object.
+-- @param target_pos point.
+-- @param total_time int.
+-- @return function.
+function LookAtFollowCharacter(target, target_pos, total_time)
+	if not camera3p.IsActive() then
+		return
+	end
+	local start_pt = camera3p.GetLookAt()
+	local last_dist = 0
+	local max_dist = start_pt:Dist(target_pos)
+	local pos_lerp = ValueLerp(start_pt, target_pos, max_dist)
+	local height_lerp = ValueLerp(start_pt:z(), target_pos:z(), total_time)
+	local last_pos
+	return function(time)
+		if IsValid(target) then
+			local pos = GetPosFromPosSpot(target)
+			local dist = Min(pos:Dist(start_pt), max_dist)
+			if dist > last_dist then
+				last_dist = dist
+			end
+		end
+		return pos_lerp(last_dist):SetZ(height_lerp(time))
+	end
+end
+
+--- Return a callback function that is to be used as get_eye parameter of MoveCamera function.
+-- The callback will move smoothly the camera eye's z to the targetz, rotate the camera to the target_yaw, keeping the 2d distance from the eye to the look at to dist_eye_look_at.
+-- @cstyle function RotateKeepDistEye(int target_eyez, int target_yaw, point dist_eye_look_at, int total_time).
+-- @param target_eyez int.
+-- @param target_yaw int.
+-- @param dist_eye_look_at int.
+-- @param total_time int.
+-- @return function.
+function RotateKeepDistEye(target_eyez, target_yaw, dist_eye_look_at, total_time)
+	local pt = point(-dist_eye_look_at, 0, 0)
+	local angle_lerp = AngleLerp(camera.GetYaw(), target_yaw, total_time)
+	local eye_height_lerp = ValueLerp(camera.GetEye():z(), target_eyez, total_time)
+	return function(look_at_pos, time)
+		local eye = look_at_pos + Rotate(pt, angle_lerp(time))
+		eye = eye:SetZ(eye_height_lerp(time))
+		return eye
+	end
+end
+
+--- This function will smoothly move/rotate the camera according the given parameters, mimicking the XCamera default behavior.
+-- @cstyle void DefMoveCamera(point pos, int yaw, int pitch, int rot_speed, int move_speed, int move_time, int yaw_time, int pitch_time).
+-- @param pos point; target camera look at position.
+-- @param yaw int; targer camera yaw.
+-- @param pitch int; target camera pitch.
+-- @param rot_speed int; camera rotation speed in angular minutes per sec; can be omitted; used to calculate move_time in case move_time is omitted.
+-- @param move_speed int; camera movement speed in angular minutes per sec; can be omitted; used to calculate yaw_time and pitch_time in case yaw_time or pitch_time are omitted.
+-- @param move_time int; the time the camera should reach the target position; if omitted the time will be calculated from move_speed parameter.
+-- @param yaw_time int; the time the camera should reach the target yaw; if omitted the time will be calculated from rot_speed parameter.
+-- @param pitch_time int; the time the camera should reach the target position; if omitted the time will be calculated from rot_speed parameter.
+-- @return void.
+function DefMoveCamera(pos, yaw, dist_scale, pitch, rot_speed, move_speed, move_time, yaw_time, pitch_time)
+	if not camera3p.IsActive() then
+		return
+	end
+	if not pos:IsValidZ() then
+		pos = pos:SetTerrainZ()
+	end
+	local start_look_at, start_pitch, start_yaw = camera3p.GetLookAt(), camera3p.GetPitch(), camera3p.GetYaw()
+	local look_at_height_offset = (const.CameraScale*const.CameraVerticalOffset/100)*dist_scale/100
+
+	rot_speed = rot_speed or const.CameraRotationDegreePerSec
+	move_speed = move_speed or const.CameraResetMmPerSec
+	
+	local pitch_time	= pitch_time or abs(AngleDiff(start_pitch, pitch)/60)*1000/rot_speed
+	local yaw_time		= yaw_time or abs(AngleDiff(start_yaw, yaw)/60)*1000/rot_speed
+	local move_time		= move_time or pos:Dist(start_look_at)*1000/move_speed
+	local yaw_lerp = AngleLerp(start_yaw, yaw, yaw_time, true)
+	local pos_lerp = ValueLerp(start_look_at, pos:SetZ(look_at_height_offset + (pos:z() or terrain.GetHeight(pos))), move_time, true)
+	local start_l, start_h = GetCameraLH(start_pitch, camera3p.DistanceAtPitch(start_pitch) * dist_scale / 100)
+	local end_l  , end_h   = GetCameraLH(      pitch, camera3p.DistanceAtPitch(      pitch) * dist_scale / 100)
+	
+	local l_lerp, h_lerp = ValueLerp(start_l, end_l, pitch_time, true), ValueLerp(start_h, end_h, pitch_time, true)
+	
+	
+	local function LookAt(t)
+		return pos_lerp(t)
+	end
+	
+	local function EyePt(look_at, t)
+		local yaw = yaw_lerp(t)
+		local l, h = l_lerp(t), h_lerp(t)
+
+		local eye = (look_at+Rotate(point(-l, 0, 0), yaw)):SetZ(h+look_at:z())
+		return eye
+	end
+	
+	MoveCamera(LookAt, EyePt, Max(pitch_time, yaw_time, move_time))
+end

CommonLua/CameraMakeTransparent.lua

@@ -0,0 +1,454 @@
+-- make objects that obstruct the view transparent (camera3p)
+if FirstLoad then
+	g_CameraMakeTransparentEnabled = false
+	g_updateStepOpacityThread = false
+	g_CameraMakeTransparentThread = false
+	g_CMT_fade_out = false
+	g_CMT_fade_in = false
+	g_CMT_hidden = false
+	g_CMT_replaced = false
+	g_CMT_replaced_destroy = false
+end
+
+local CMT_fade_out = g_CMT_fade_out
+local CMT_fade_in = g_CMT_fade_in
+local CMT_hidden = g_CMT_hidden
+local CMT_replaced = g_CMT_replaced
+local CMT_replaced_destroy = g_CMT_replaced_destroy
+
+local transparency_enum_flags = const.efCameraMakeTransparent
+local transparency_surf_flags = EntitySurfaces.Walk + EntitySurfaces.Collision
+local obstruct_view_refresh_time = const.ObstructViewRefreshTime
+local fade_in_time = const.ObstructOpacityFadeInTime
+local fade_out_time = const.ObstructOpacityFadeOutTime
+local obstruct_opacity = const.ObstructOpacity
+local obstruct_opacity_refresh_time = const.ObstructOpacityRefreshTime
+local refresh_time = Max(obstruct_opacity_refresh_time, Max(fade_out_time, fade_in_time) / (100 - Clamp(obstruct_opacity, 0, 99)))
+local opacity_change_fadein  = fade_in_time <= 0 and 100 or (100 - obstruct_opacity) * refresh_time / fade_in_time
+local opacity_change_fadeout = fade_out_time <= 0 and 100 or (100 - obstruct_opacity) * refresh_time / fade_out_time
+
+local function ResetLists()
+	g_CMT_fade_out = {}
+	g_CMT_fade_in = {}
+	g_CMT_hidden = {}
+	g_CMT_replaced = {}
+	g_CMT_replaced_destroy = {}
+	CMT_fade_out = g_CMT_fade_out
+	CMT_fade_in = g_CMT_fade_in
+	CMT_hidden = g_CMT_hidden
+	CMT_replaced = g_CMT_replaced
+	CMT_replaced_destroy = g_CMT_replaced_destroy
+end
+
+if FirstLoad then
+	ResetLists()
+end
+
+function OnMsg.DoneMap()
+	g_updateStepOpacityThread = false
+	g_CameraMakeTransparentThread = false
+	ResetLists()
+end
+
+local function UpdateObstructors_StepOpacity(obstructors)
+	local view = 1
+	CMT_fade_in[view] = CMT_fade_in[view] or {}
+	CMT_fade_out[view] = CMT_fade_out[view] or {}
+	local vfade_in = CMT_fade_in[view]
+	local vfade_out = CMT_fade_out[view]
+	-- move fade_out objects to fade_in
+	for i = #vfade_out, 1, -1 do
+		local o = vfade_out[i]
+		if not (obstructors and obstructors[o]) then
+			assert(not vfade_in[o])
+			table.remove(vfade_out, i)
+			vfade_out[o] = nil
+			if o:GetOpacity() < 100 then
+				vfade_in[#vfade_in + 1] = o
+				vfade_in[o] = true
+			end
+		end
+	end
+	-- set the new fade_out
+	if obstructors then
+		for i = 1, #obstructors do
+			local o = obstructors[i]
+			if not vfade_out[o] then
+				vfade_out[#vfade_out + 1] = o
+				vfade_out[o] = true
+			end
+			if vfade_in[o] then
+				table.remove_entry(vfade_in, o)
+				vfade_in[o] = nil
+			end
+		end
+	end
+end
+
+local function UpdateObstructors_Hidden(view, obstructors)
+	-- logic for objects for which hide/show is immediate
+	local hidden_for_view = CMT_hidden[view]
+	CMT_hidden[view] = obstructors
+	if obstructors then
+		for i = 1, #obstructors do
+			local o = obstructors[i]
+			o:SetOpacity(0)
+			obstructors[o] = true
+		end
+	end
+	if hidden_for_view then
+		for i = 1, #hidden_for_view do
+			local o = hidden_for_view[i]
+			if IsValid(o) and not (obstructors and obstructors[o]) then
+				o:SetOpacity(100) -- show what was hidden in the previous tick 
+			end
+		end
+	end
+end
+
+local function ClearObstructors()
+	for o in pairs(CMT_replaced) do
+		o:DestroyReplacement()
+	end
+	for view = 1, camera.GetViewCount() do
+		local vfade_out = CMT_fade_out[view]
+		if vfade_out then
+			for i = 1, #vfade_out do
+				local o = vfade_out[i]
+				if IsValid(o) then
+					o:SetOpacity(100)
+				end
+			end
+		end
+		local vfade_in = CMT_fade_in[view]
+		if vfade_in then
+			for i = 1, #vfade_in do
+				local o = vfade_in[i]
+				if IsValid(o) then
+					o:SetOpacity(100)
+				end
+			end
+		end
+		local hv = CMT_hidden[view]
+		if hv then
+			for i = 1, #hv do
+				local o = hv[i]
+				if IsValid(o) then
+					o:SetOpacity(100)
+				end
+			end
+		end
+	end
+	ResetLists()
+end
+
+local function UpdateObstructors(view, get_obstructors)
+	local success, obstructors, obstructors_immediate = procall(get_obstructors, view)
+	UpdateObstructors_StepOpacity(obstructors)
+	UpdateObstructors_Hidden(view, obstructors_immediate)
+end
+
+local function UpdateObstructorsRefresh(cam, get_obstructors)
+	local refresh_time = obstruct_view_refresh_time
+	while true do
+		while IsEditorActive() do
+			Sleep(2 * refresh_time)
+		end
+		-- restore opacity of fade_in/fade_out objects
+		if not g_CameraMakeTransparentEnabled or not cam.IsActive() then
+			ClearObstructors()
+			while not g_CameraMakeTransparentEnabled or not cam.IsActive() do
+				Sleep(refresh_time)
+			end
+		end
+		for view = 1, camera.GetViewCount() do
+			UpdateObstructors(view, get_obstructors)
+		end
+		Sleep(refresh_time)
+	end
+end
+
+local function UpdateStepOpacity(view)
+	local vfade_out = CMT_fade_out[view]
+	if vfade_out then
+		for i = #vfade_out, 1, -1 do
+			local o = vfade_out[i]
+			if not IsValid(o) then
+				vfade_out[o] = nil
+				table.remove(vfade_out, i)
+			else
+				local new_opacity = o:GetOpacity() - opacity_change_fadeout
+				if new_opacity < obstruct_opacity then
+					new_opacity = obstruct_opacity
+				end
+				o:SetOpacity(new_opacity)
+			end
+		end
+	end
+	local vfade_in = CMT_fade_in[view]
+	if vfade_in then
+		for i = #vfade_in, 1, -1 do
+			local o = vfade_in[i]
+			local keep
+			if IsValid(o) then
+				local new_opacity = Min(100, o:GetOpacity() + opacity_change_fadein)
+				o:SetOpacity(new_opacity)
+				keep = new_opacity < 100
+			end
+			if not keep then
+				vfade_in[o] = nil
+				table.remove(vfade_in, i)
+			end
+		end
+	end
+end
+
+local function UpdateStepOpacityRefresh()
+	local refresh_time = refresh_time
+	while true do
+		for view = 1, camera.GetViewCount() do
+			UpdateStepOpacity(view)
+		end
+		Sleep(refresh_time)
+	end
+end
+
+local DistSegmentToPt = DistSegmentToPt
+local camera_clip_extend_radius = const.CameraClipExtendRadius
+local offset_z_150cm = 150*guic
+local cone_radius_max = config.CameraTransparencyConeRadiusMax
+local cone_radius_min = config.CameraTransparencyConeRadiusMin
+if FirstLoad then
+	draw_transparency_cone = false
+end
+
+function ToggleTransparencyCone()
+	DbgClearVectors()
+	draw_transparency_cone = not draw_transparency_cone
+end
+
+local hide_filter = function(u, eye)
+	local posx, posy, posz = u:GetVisualPosXYZ()
+	local scale = u:GetScale()
+	local dist_to_eye = DistSegmentToPt(posx, posy, posz, 0, 0, u.height * scale / 100, eye, true)
+	return dist_to_eye < u.camera_radius * scale / 100 + camera_clip_extend_radius
+end
+local col_exec = function(o, list)
+	if not list[o] then
+		list[#list + 1] = o
+		list[o] = true
+	end
+end
+local function GetViewObstructorsCamera3p(view)
+	local eye = camera.GetEye(view)
+	local lookat = camera3p.GetLookAt(view)
+	if not eye or not eye:IsValid() then
+		return
+	end
+	local to_fade, to_fade_count
+	local to_hide = MapGet(eye, 4*guim, "Unit", hide_filter, eye) or {}
+	for i = 1, #to_hide do
+		to_hide[ to_hide[i] ] = true
+	end
+
+	for loc_player = 1, LocalPlayersCount do
+		local obj = GetPlayerControlCameraAttachedObj(loc_player)
+		if obj and obj:IsValidPos() then
+			local posx, posy, posz = obj:GetVisualPosXYZ()
+			local err1, to_fade1 = AsyncIntersectConeWithObstacles(
+				eye, point(posx, posy, posz + offset_z_150cm),
+				cone_radius_max, cone_radius_min,
+				transparency_enum_flags,
+				transparency_surf_flags,
+				draw_transparency_cone)
+			assert(not err1, err1)
+			if to_fade1 then
+				if to_fade then
+					for i = 1, #to_fade1 do
+						local o = to_fade1[i]
+						if not to_fade[o] then
+							to_fade_count = to_fade_count + 1
+							to_fade[to_fade_count] = o
+							to_fade[o] = true
+						end
+					end
+				else
+					to_fade = to_fade1
+					to_fade_count = #to_fade
+					for i = 1, to_fade_count do
+						to_fade[ to_fade[i] ] = true
+					end
+				end
+			end
+		end
+	end
+	if to_fade then
+		for i = 1, to_fade_count do
+			local col = to_fade[i]:GetRootCollection()
+			if col and not to_fade[col] then
+				to_fade[col] = true
+				local col_areapoint1 = eye
+				local col_areapoint2 = lookat
+				MapForEach(
+					col_areapoint1, col_areapoint2, 50*guim,
+					"attached", false, "collection", col.Index, true, 
+					const.efVisible, col_exec , to_fade)
+			end
+		end
+	end
+	return to_fade, to_hide
+end
+
+function RestartCameraMakeTransparent()
+	StopCameraMakeTransparent()
+	if g_CameraMakeTransparentEnabled then
+		g_CameraMakeTransparentThread = CreateMapRealTimeThread(UpdateObstructorsRefresh, camera3p, GetViewObstructorsCamera3p)
+		g_updateStepOpacityThread = CreateMapRealTimeThread(UpdateStepOpacityRefresh)
+	end
+end
+
+function StopCameraMakeTransparent()
+	ClearObstructors()
+	if g_updateStepOpacityThread then
+		DeleteThread(g_updateStepOpacityThread)
+		g_updateStepOpacityThread = false
+	end
+	if g_CameraMakeTransparentThread then
+		DeleteThread(g_CameraMakeTransparentThread)
+		g_CameraMakeTransparentThread = false
+	end
+end
+
+OnMsg.NewMapLoaded = RestartCameraMakeTransparent
+OnMsg.LoadGame = RestartCameraMakeTransparent
+OnMsg.GameEnterEditor = StopCameraMakeTransparent
+
+DefineClass.CameraTransparentWallReplacement = {
+	__parents = { "CObject", "ComponentAttach" },
+	flags = { efCameraMakeTransparent = false, efCameraRepulse = true, efSelectable = false, efWalkable = false, efCollision = false, efApplyToGrids = false, efShadow = false },
+	properties =
+	{
+		{ id = "CastShadow", name = "Shadow from All", editor = "bool", default = false },
+	},
+}
+
+local function CameraSpecialWallReplaceObjects(o)
+	return { "(default)", "place_default", "" }
+end
+
+DefineClass.CameraSpecialWall = {
+	__parents = { "Object" },
+	flags = { efCameraMakeTransparent = true, efCameraRepulse = false },
+	properties = {
+		{ id = "TransparentReplace", editor = "combo", items = CameraSpecialWallReplaceObjects },
+	},
+	TransparentReplace = "(default)",
+	replace_default = "",
+	replace_height_min = -guim,
+	replace_height_max = guim,
+}
+
+function OnMsg.ClassesPostprocess()
+	-- create unique GetAction and GetActionEnd functions per class
+	local replace_default = {}
+	ClassDescendants("CameraSpecialWall", function(class_name, class, replace_default)
+		if class.replace_default == "" then
+			local classname = class:GetEntity() .. "_Base"
+			if g_Classes[classname] then
+				replace_default[class] = classname
+			end
+		end
+		local properties = class.properties
+		local idx = table.find(properties, "id", "OnCollisionWithCamera")
+		if idx then
+			local idx_old = table.find(properties, "id", "TransparentReplace")
+			local prop = properties[idx_old]
+			table.remove(properties, idx_old)
+			table.insert(properties, idx + (idx < idx_old and 1 or 0), prop)
+		end
+	end, replace_default)
+	for class, value in pairs(replace_default) do
+		class.replace_default = value
+	end
+end
+
+local default_color = RGBA(128, 128, 128, 0)
+local default_roughness = 0
+local default_metallic = 0
+
+function CameraSpecialWall:PlaceReplacement()
+	local replacement = CMT_replaced[self]
+	if replacement then
+		CMT_replaced_destroy[self] = nil
+		return
+	end
+	local classname = self.TransparentReplace
+	if classname == "place_default" then
+		classname = self.replace_default
+	elseif classname == "(default)" then
+		classname = self.replace_default
+		local pos = self:GetPos()
+		local height = pos:z() and pos:z() - GetWalkableZ(pos) or 0
+		if height < self.replace_height_min or height > self.replace_height_max then
+			classname = ""
+		elseif self:RotateAxis(0,0,4096):z() < 2048 then
+			-- inclined more then 45 degrees
+			classname = ""
+		end
+	end
+	local replaced_base
+	if classname ~= "" then
+		local color1, roughness1, metallic1 = self:GetColorizationMaterial(1)
+		local color2, roughness2, metallic2 = self:GetColorizationMaterial(2)
+		local color3, roughness3, metallic3 = self:GetColorizationMaterial(3)
+		local components = 0
+		if (color1 ~= default_color or roughness1 ~= default_roughness or metallic1 ~= default_metallic) or 
+			(color2 ~= default_color or roughness2 ~= default_roughness or metallic2 ~= default_metallic) or 
+			(color3 ~= default_color or roughness3 ~= default_roughness or metallic3 ~= default_metallic) then
+			components = const.cofComponentColorizationMaterial
+		end
+		replaced_base = PlaceObject(classname, nil, components)
+		replaced_base:SetMirrored(self:GetMirrored())
+		replaced_base:SetAxis(self:GetAxis())
+		replaced_base:SetAngle(self:GetAngle())
+		replaced_base:SetScale(self:GetScale())
+		replaced_base:SetColorModifier(self:GetColorModifier())
+		if components == const.cofComponentColorizationMaterial then
+			replaced_base:SetColorizationMaterial(1, color1, roughness1, metallic1)
+			replaced_base:SetColorizationMaterial(2, color2, roughness2, metallic2)
+			replaced_base:SetColorizationMaterial(3, color3, roughness3, metallic3)
+		end
+		local anim = self:GetStateText()
+		if anim ~= "idle" and replaced_base:HasState(anim) and not replaced_base:IsErrorState(anim) then
+			replaced_base:SetState(anim)
+		end
+		replaced_base:SetPos(self:GetVisualPosXYZ())
+	end
+	CMT_replaced[self] = replaced_base or true
+end
+
+function CameraSpecialWall:DestroyReplacement(delay)
+	local obj = CMT_replaced[self]
+	if obj then
+		if obj == true then
+			CMT_replaced[self] = nil
+			return
+		end
+		if (delay or 0) == 0 then
+			CMT_replaced[self] = nil
+			CMT_replaced_destroy[self] = nil
+			DoneObject(obj)
+		elseif not CMT_replaced_destroy[self] then
+			CMT_replaced_destroy[self] = RealTime() + delay
+		end
+	end
+end
+
+function CameraSpecialWall:SetOpacity(opacity)
+	if opacity < 100 then
+		self:PlaceReplacement()
+	else
+		self:DestroyReplacement()
+	end
+	Object.SetOpacity(self, opacity)
+end

CommonLua/CanonizeFilename.lua

@@ -0,0 +1,95 @@
+local filename_chars =
+{
+	['"'] = "'",
+	["\\"] = "_",
+	["/"] = "_",
+	[":"] = "-",
+	["*"] = "+",
+	["?"] = "_",
+	["<"] = "(",
+	[">"] = ")",
+	["|"] = "-",
+}
+
+local escape_symbols =
+{
+	["%%"] = "%%%%",
+	["%("] = "%%(",
+	["%)"] = "%%)",
+	["%]"] = "%%]",
+	["%["] = "%%[",
+	["%-"] = "%%-",
+	["%+"] = "%%+",
+	["%*"] = "%%*",
+	["%?"] = "%%?",
+	["%$"] = "%%$",
+	["%."] = "%%.",
+	["%^"] = "%%^",
+}
+
+local filter = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ()_+-'"
+
+local filename_strings =
+{
+    ["A"] = { "À", "Á", "Â", "Ã", "Ä", "Å", "Æ", "Ā", "Ă", "Ą", "Ǟ", "ǟ", "Ǡ", "ǡ", "Ǣ", "ǣ", "ǻ", "Ǽ", "ǽ", "Ȁ", "ȁ", "Ȃ", "ȃ" },
+    ["a"] = { "à", "á", "â", "ã", "ä", "å", "æ", "ā", "ă", "ą", },
+    ["C"] = { "Ç" },
+    ["c"] = { "ç", },
+    ["D"] = { "Ď", "Đ", "Ð", },
+    ["d"] = { "ď", "đ", "ð" },
+    ["E"] = { "È", "É", "Ê", "Ë", "Ĕ", "Ė", "Ę", "Ě", },
+    ["e"] = { "ė", "ę", "ĕ", "ě", "è", "é", "ê", "ë" },
+    ["G"] = { "Ĝ", "Ġ", "Ğ", "Ģ", },
+    ["g"] = { "ğ", "ĝ", "ġ", "ģ" },
+    ["H"] = { "Ĥ", "Ħ", },
+    ["h"] = { "ĥ", "ħ" },
+    ["I"] = { "Ì", "Í", "Î", "Ï", "Į", "Ĭ", "Ī", "Ĩ", "IJ", "İ", },
+    ["i"] = { "ı", "ij", "ĩ", "ī", "ĭ", "į", "ì", "í", "î", "ï", },
+    ["J"] = { "ĵ", "ĵ", "ĵ" },
+    ["K"] = { "Ķ", },
+    ["k"] = { "ķ", "ĸ" },
+    ["L"] = { "Ł", "Ŀ", "Ľ", "Ĺ", "Ļ", },
+    ["l"] = { "ļ", "ĺ", "ľ", "ŀ", "ł" },
+    ["N"] = { "Ņ", "Ń", "Ň", "Ŋ", "Ñ", },
+    ["n"] = { "ñ", "ŋ", "ň", "ń", "ņ", "ʼn", },
+    ["O"] = { "Ò", "Ó", "Ô", "Õ", "Õ", "Ö", "Ø", "Ō", "Ŏ", "Ŏ", "Ő", "Œ", },
+    ["o"] = { "ò", "ó", "ô", "õ", "ö", "ø", "ō", "ő", "œ" },
+    ["R"] = { "Ŕ", "Ŗ", "Ř", },
+    ["r"] = { "ř", "ŗ", "ŕ", },
+    ["S"] = { "Ś", "Ŝ", "Ş", "Š", },
+    ["s"] = { "ß", "ś", "ŝ", "ŝ", "ş", "š" },
+    ["T"] = { "Þ", "Ţ", "Ť", "Ŧ", },
+    ["t"] = { "þ", "ţ", "ť", "ŧ", },
+    ["U"] = { "Ũ", "Ū", "Ŭ", "Ů", "Ų", "Ű", "Ù", "Ú", "Û", "Ü", },
+    ["u"] = { "ù", "ú", "û", "ü", "ű", "ų", "ů", "ŭ", "ū", "ũ", },
+    ["W"] = { "Ŵ", },
+    ["w"] = { "ŵ" },
+    ["Y"] = { "Ý", "Ŷ", "Ÿ", },
+    ["y"] = { "ý", "ÿ", "ŷ" },
+    ["Z"] = { "Ź", "Ż", "Ž", },
+    ["z"] = { "ż", "ź", "ž" },
+    ["'"] = { "“", "”" },
+}
+
+function CanonizeSaveGameName(name)
+	if not name then return end
+
+	name = name:gsub("(.)", filename_chars)
+	for k,v in pairs(filename_strings) do
+		if type(v) == "string" then
+			name = name:gsub(v, k)
+		elseif type(v) == "table" then
+			for i=1,#v do
+				name = name:gsub(v[i], k)
+			end
+		end
+	end
+	return name
+end
+
+function EscapePatternMatchingMagicSymbols(name)
+	for k,v in sorted_pairs(escape_symbols) do
+		name = name:gsub(k, v)
+	end
+	return name
+end

CommonLua/Classes/Achievement.lua

@@ -0,0 +1,160 @@
+ach_print = CreatePrint{
+	--"ach",
+}
+
+-- Game-specific hooks, titles should override these:
+
+function CanUnlockAchievement(achievement)
+	local reasons = {}
+	Msg("UnableToUnlockAchievementReasons", reasons, achievement)
+	local reason = next(reasons)
+	return not reason, reason
+end
+
+-- Platform-specific functions:
+
+function AsyncAchievementUnlock(achievement) 
+	Msg("AchievementUnlocked", achievement)
+end
+
+function SynchronizeAchievements() end
+
+PlatformCanUnlockAchievement = return_true
+
+CheatPlatformUnlockAllAchievements = empty_func
+CheatPlatformResetAllAchievements = empty_func
+
+-- Common functions:
+
+-- return unlocked, secret
+function GetAchievementFlags(achievement)
+	return AccountStorage.achievements.unlocked[achievement], AchievementPresets[achievement].secret
+end
+
+function GetUnlockedAchievementsCount()
+	local unlocked, total = 0, 0
+	ForEachPreset(Achievement, function(achievement)
+		if not achievement:IsCurrentlyUsed() then return end
+		unlocked = unlocked + (AccountStorage.achievements.unlocked[achievement.id] and 1 or 0)
+		total = total + 1
+	end)
+	return unlocked, total
+end
+
+function _CheckAchievementProgress(achievement, dont_unlock_in_provider)
+	local progress = AccountStorage.achievements.progress[achievement] or 0
+	local target = AchievementPresets[achievement].target
+	if target and progress >= target then
+		AchievementUnlock(achievement, dont_unlock_in_provider)
+	end
+end
+
+local function EngineCanUnlockAchievement(achievement)
+	if Platform.demo then return false, "not available in demo" end
+	if GameState.Tutorial then
+		return false, "in tutorial"
+	end
+	if AccountStorage.achievements.unlocked[achievement] then
+		return false, "already unlocked"
+	end
+	assert(AchievementPresets[achievement])
+	if not AchievementPresets[achievement] then
+		return false, "dlc not present"
+	end
+	return PlatformCanUnlockAchievement(achievement)
+end
+
+local function CanModifyAchievementProgress(achievement)
+	-- 1. Engine-specific reasons not to modify  achievement progress?
+	local success, reason = EngineCanUnlockAchievement(achievement)
+	if not success then
+		ach_print("cannot modify achievement progress, forbidden by engine check ", achievement, reason)
+		return false
+	end	
+	
+	-- 2. Game-specific reasons not to modify achievement progress?
+	local success, reason = CanUnlockAchievement(achievement)
+	if not success then
+		ach_print("cannot modify achievement progress, forbidden by title-specific check ", achievement, reason)
+		return false
+	end	
+	
+	return true
+end
+
+function AddAchievementProgress(achievement, progress, max_delay_save)
+	if not CanModifyAchievementProgress(achievement) then
+		return
+	end
+	
+	local ach = AchievementPresets[achievement]	
+	local current = AccountStorage.achievements.progress[achievement] or 0
+	local save_storage = not ach.save_interval or ((current + progress) / ach.save_interval > (current / ach.save_interval))
+	local total = current + progress
+	local target = ach.target or 0
+	if total >= target then
+		total = target
+		save_storage = false
+	end
+	AccountStorage.achievements.progress[achievement] = total
+	if save_storage then
+		SaveAccountStorage(max_delay_save)
+	end
+	Msg("AchievementProgress", achievement)
+	_CheckAchievementProgress(achievement)
+	
+	return true
+end
+
+function ClearAchievementProgress(achievement, max_delay_save)
+	if not CanModifyAchievementProgress(achievement) then
+		return
+	end
+
+	AccountStorage.achievements.progress[achievement] = 0
+	SaveAccountStorage(max_delay_save)
+	Msg("AchievementProgress", achievement)
+	
+	return true
+end
+
+-- Synchronous version, launches a thread
+function AchievementUnlock(achievement, dont_unlock_in_provider)
+	if not CanModifyAchievementProgress(achievement) then
+		return
+	end
+	
+	-- We set this before the thread, as otherwise calling AchievementUnlock twice will attempt to unlock it twice
+	AccountStorage.achievements.unlocked[achievement] = true
+	if not dont_unlock_in_provider then
+		AsyncAchievementUnlock(achievement)
+	end
+	
+	SaveAccountStorage(5000)
+	return true
+end
+
+if Platform.developer then
+	function AchievementUnlockAll()
+		CreateRealTimeThread(function()
+			for id, achievement_data in sorted_pairs(AchievementPresets) do
+				AchievementUnlock(id)
+				Sleep(100)
+			end
+		end)
+	end
+end
+
+function OnMsg.NetConnect()
+	local unlocked = AccountStorage and AccountStorage.achievements and AccountStorage.achievements.unlocked
+	if not unlocked then return end
+	
+	local achievements = {}
+	ForEachPreset(Achievement, function(achievement)
+		if unlocked[achievement.id] then
+			table.insert(achievements, achievement.id)
+		end
+	end)
+	
+	NetGossip("AllAchievementsUnlocked", achievements)
+end

CommonLua/Classes/AnimMomentHook.lua

@@ -0,0 +1,409 @@
+DefineClass.AnimChangeHook =
+{
+	__parents = { "Object", "Movable" },
+}
+
+function AnimChangeHook:AnimationChanged(channel, old_anim, flags, crossfade)
+end
+
+function AnimChangeHook:SetState(anim, flags, crossfade, ...)
+	local old_anim = self:GetStateText()
+	if IsValid(self) and self:IsAnimEnd() then
+		self:OnAnimMoment("end")
+	end
+	Object.SetState(self, anim, flags, crossfade, ...)
+	self:AnimationChanged(1, old_anim, flags, crossfade)
+end
+
+local pfStep = pf.Step
+local pfSleep = Sleep
+function AnimChangeHook:Step(...)
+	local old_state = self:GetState()
+	local status, new_path = pfStep(self, ...)
+	if old_state ~= self:GetState() then
+		self:AnimationChanged(1, GetStateName(old_state), 0, nil)
+	end
+	return status, new_path
+end
+
+function AnimChangeHook:SetAnim(channel, anim, flags, crossfade, ...)
+	local old_anim = self:GetStateText()
+	Object.SetAnim(self, channel, anim, flags, crossfade, ...)
+	self:AnimationChanged(channel, old_anim, flags, crossfade)
+end
+
+-- AnimMomentHook
+DefineClass.AnimMomentHook =
+{
+	__parents = { "AnimChangeHook" },
+	anim_moments_hook = false,				-- list with moments which have registered callback in the class
+	anim_moments_single_thread = false,	-- if false every moment will have its own thread launched
+	anim_moments_hook_threads = false,
+	anim_moment_fx_target = false,
+}
+
+function AnimMomentHook:Init()
+	self:StartAnimMomentHook()
+end
+
+function AnimMomentHook:Done()
+	self:StopAnimMomentHook()
+end
+
+function AnimMomentHook:IsStartedAnimMomentHook()
+	return self.anim_moments_hook_threads and true or false
+end
+
+function AnimMomentHook:WaitAnimMoment(moment)
+	repeat
+		local t = self:TimeToMoment(1, moment)
+		local index = 1
+		while t == 0 do
+			index = index + 1
+			t = self:TimeToMoment(1, moment, index)
+		end
+	until not WaitWakeup(t) -- if someone wakes us up we need to measure again
+end
+
+moment_hooks = {}
+
+function AnimMomentHook:OnAnimMoment(moment, anim)
+	anim = anim or GetStateName(self)
+	PlayFX(FXAnimToAction(anim), moment, self, self.anim_moment_fx_target or nil)
+	local anim_moments_hook = self.anim_moments_hook
+	if type(anim_moments_hook) == "table" and anim_moments_hook[moment] then
+		local method = moment_hooks[moment]
+		return self[method](self, anim)
+	end
+end
+
+function WaitTrackMoments(obj, callback, ...)
+	callback = callback or obj.OnAnimMoment
+	local last_state, last_phase, state_name, time, moment
+	while true do
+		local state, phase = obj:GetState(), obj:GetAnimPhase()
+		if state ~= last_state then
+			state_name = GetStateName(state)
+			if phase == 0 then
+				callback(obj, "start", state_name, ...)
+			end
+			time = nil
+		end
+		last_state, last_phase = state, phase
+		if not time then
+			moment, time = obj:TimeToNextMoment(1, 1)
+		end
+		if time then
+			local time_to_end = obj:TimeToAnimEnd()
+			if time_to_end <= time then
+				if not WaitWakeup(time_to_end) then
+					assert(IsValid(obj))
+					callback(obj, "end", state_name, ...)
+					if obj:IsAnimLooping(1) then
+						callback(obj, "start", state_name, ...)
+					end
+					time = time - time_to_end
+				else
+					time = false
+				end
+			end
+			-- if someone wakes us we need to query for a new moment
+			if time then
+				if time > 0 and WaitWakeup(time) then
+					time = nil
+				else
+					assert(IsValid(obj))
+					local index = 1
+					repeat
+						callback(obj, moment, state_name, ...)
+						index = index + 1
+						moment, time = obj:TimeToNextMoment(1, index)
+					until time ~= 0
+					if not time then
+						WaitWakeup()
+					end
+				end
+			end
+		else
+			WaitWakeup()
+		end
+	end
+end
+
+local gofRealTimeAnim = const.gofRealTimeAnim
+
+function AnimMomentHook:StartAnimMomentHook()
+	local moments = self.anim_moments_hook
+	if not moments or self.anim_moments_hook_threads then
+		return
+	end
+	if not IsValidEntity(self:GetEntity()) then 
+		return 
+	end
+	local create_thread = self:GetGameFlags(gofRealTimeAnim) ~= 0 and CreateMapRealTimeThread or CreateGameTimeThread
+	local threads
+	if self.anim_moments_single_thread then
+		threads = { create_thread(WaitTrackMoments, self) }
+		ThreadsSetThreadSource(threads[1], "AnimMoment")
+	else
+		threads = { table.unpack(moments) }
+		for _, moment in ipairs(moments) do
+			threads[i] = create_thread(function(self, moment)
+				local method = moment_hooks[moment]
+				while true do
+					self:WaitAnimMoment(moment)
+					assert(IsValid(self))
+					self[method](self)
+				end
+			end, self, moment)
+			ThreadsSetThreadSource(threads[i], "AnimMoment")
+		end
+	end
+	self.anim_moments_hook_threads = threads
+end
+
+function AnimMomentHook:StopAnimMomentHook()
+	local thread_list = self.anim_moments_hook_threads or ""
+	for i = 1, #thread_list do
+		DeleteThread(thread_list[i])
+	end
+	self.anim_moments_hook_threads = nil
+end
+
+function AnimMomentHook:AnimMomentHookUpdate()
+	for i, thread in ipairs(self.anim_moments_hook_threads) do
+		Wakeup(thread)
+	end
+end
+
+AnimMomentHook.AnimationChanged = AnimMomentHook.AnimMomentHookUpdate
+
+function OnMsg.ClassesPostprocess()
+	local str_to_moment_list = {} -- optimized to have one copy of each unique moment list
+
+	ClassDescendants("AnimMomentHook", function(class_name, class, remove_prefix, str_to_moment_list)
+		local moment_list
+		for name, func in pairs(class) do
+			local moment = remove_prefix(name, "OnMoment")
+			if type(func) == "function" and moment and moment ~= "" then
+				moment_list = moment_list or {}
+				moment_list[#moment_list + 1] = moment
+			end
+		end
+		for name, func in pairs(getmetatable(class)) do
+			local moment = remove_prefix(name, "OnMoment")
+			if type(func) == "function" and moment and moment ~= "" then
+				moment_list = moment_list or {}
+				moment_list[#moment_list + 1] = moment
+			end
+		end
+		if moment_list then
+			table.sort(moment_list)
+			for _, moment in ipairs(moment_list) do
+				moment_list[moment] = true
+				moment_hooks[moment] = moment_hooks[moment] or ("OnMoment" .. moment)
+			end
+			local str = table.concat(moment_list, " ")
+			moment_list = str_to_moment_list[str] or moment_list
+			str_to_moment_list[str] = moment_list
+			rawset(class, "anim_moments_hook", moment_list)
+		end
+	end, remove_prefix, str_to_moment_list)
+end
+
+---
+DefineClass.StepObjectBase =
+{
+	__parents = { "AnimMomentHook" },
+}
+
+function StepObjectBase:StopAnimMomentHook()
+	AnimMomentHook.StopAnimMomentHook(self)
+end
+
+if not Platform.ged then
+	function OnMsg.ClassesGenerate()
+		AppendClass.EntitySpecProperties = {
+			properties = {
+				{ id = "FXTargetOverride", name = "FX target override", category = "Misc", default = false,
+					editor = "combo", items = function(fx) return ActionFXClassCombo(fx) end, entitydata = true,
+				},
+				{ id = "FXTargetSecondary", name = "FX target secondary", category = "Misc", default = false,
+					editor = "combo", items = function(fx) return ActionFXClassCombo(fx) end, entitydata = true,
+				},
+			},
+		}
+	end
+end
+
+function GetObjMaterialFXTarget(obj)
+	local entity_data = obj and EntityData[obj:GetEntity()]
+	entity_data = entity_data and entity_data.entity
+	if entity_data and entity_data.FXTargetOverride then
+		return entity_data.FXTargetOverride, entity_data.FXTargetSecondary
+	end
+
+	local mat_type = obj and obj:GetMaterialType()
+	local material_preset = mat_type and (Presets.ObjMaterial.Default or empty_table)[mat_type]
+	local fx_target = (material_preset and material_preset.FXTarget ~= "") and material_preset.FXTarget or mat_type
+	
+	return fx_target, entity_data and entity_data.FXTargetSecondary
+end
+
+local surface_fx_types = {}
+local enum_decal_water_radius = const.AnimMomentHookEnumDecalWaterRadius
+
+function GetObjMaterial(pos, obj, surfaceType, fx_target_secondary)
+	local surfacePos = pos
+	if not surfaceType and obj then
+		surfaceType, fx_target_secondary = GetObjMaterialFXTarget(obj)
+	end
+
+	local propagate_above
+	if pos and not surfaceType then
+		propagate_above = true
+		if terrain.IsWater(pos) then
+			local water_z = terrain.GetWaterHeight(pos)
+			local dz = (pos:z() or terrain.GetHeight(pos)) - water_z
+			if dz >= const.FXWaterMinOffsetZ and dz <= const.FXWaterMaxOffsetZ then
+				if const.FXShallowWaterOffsetZ > 0 and dz > -const.FXShallowWaterOffsetZ then
+					surfaceType = "ShallowWater"
+				else
+					surfaceType = "Water"
+				end
+				surfacePos = pos:SetZ(water_z)
+			end
+		end
+		if not surfaceType and enum_decal_water_radius then
+			local decal = MapFindNearest(pos, pos, enum_decal_water_radius, "TerrainDecal", function (obj, pos)
+				if pos:InBox2D(obj) then
+					local dz = (pos:z() or terrain.GetHeight(pos)) - select(3, obj:GetVisualPosXYZ())
+					if dz <= const.FXDecalMaxOffsetZ and dz >= const.FXDecalMinOffsetZ then
+						return true
+					end
+				end
+			end, pos)
+			if decal then
+				surfaceType = decal:GetMaterialType()
+				if surfaceType then
+					surfacePos = pos:SetZ(select(3, decal:GetVisualPosXYZ()))
+				end
+			end
+		end
+		if not surfaceType then
+			-- get the surface type
+			local walkable_slab = const.SlabSizeX and WalkableSlabByPoint(pos) or GetWalkableObject(pos)
+			if walkable_slab then
+				surfaceType = walkable_slab:GetMaterialType()
+				if surfaceType then
+					surfacePos = pos:SetZ(select(3, walkable_slab:GetVisualPosXYZ()))
+				end
+			else
+				local terrain_preset = TerrainTextures[terrain.GetTerrainType(pos)]
+				surfaceType = terrain_preset and terrain_preset.type
+				if surfaceType then
+					surfacePos = pos:SetTerrainZ()
+				end
+			end
+		end
+	end
+	
+	local fx_type
+	if surfaceType then
+		fx_type = surface_fx_types[surfaceType]
+		if not fx_type then			-- cache it for later use
+			fx_type = "Surface:" .. surfaceType
+			surface_fx_types[surfaceType] = fx_type
+		end
+	end
+	local fx_type_secondary
+	if fx_target_secondary then
+		fx_type_secondary = surface_fx_types[fx_target_secondary]
+		if not fx_type_secondary then			-- cache it for later use
+			fx_type_secondary = "Surface:" .. fx_target_secondary
+			surface_fx_types[fx_target_secondary] = fx_type_secondary
+		end
+	end
+
+	return fx_type, surfacePos, propagate_above, fx_type_secondary
+end
+
+
+local enum_bush_radius = const.AnimMomentHookTraverseVegetationRadius
+
+function StepObjectBase:PlayStepSurfaceFX(foot, spot_name)
+	local spot = self:GetRandomSpot(spot_name)
+	local pos = self:GetSpotLocPos(spot)
+	local surface_fx_type, surface_pos, propagate_above = GetObjMaterial(pos)
+
+	if surface_fx_type then
+		local angle, axis = self:GetSpotVisualRotation(spot)
+		local dir = RotateAxis(axis_x, axis, angle)
+		local actionFX = self:GetStepActionFX()
+		PlayFX(actionFX, foot, self, surface_fx_type, surface_pos, dir)
+	end
+
+	if propagate_above and enum_bush_radius then
+		local bushes = MapGet(pos, enum_bush_radius, "TraverseVegetation", function(obj, pos) return pos:InBox(obj) end, pos)
+		if bushes and bushes[1] then
+			local veg_event = PlaceObject("VegetationTraverseEvent")
+			veg_event:SetPos(pos)
+			veg_event:SetActors(self, bushes)
+		end
+	end
+end
+
+function StepObjectBase:GetStepActionFX()
+	return "Step"
+end
+
+DefineClass.StepObject = {
+	__parents = { "StepObjectBase" },
+}
+
+function StepObject:OnMomentFootLeft()
+	self:PlayStepSurfaceFX("FootLeft", "Leftfoot")
+end
+
+function StepObject:OnMomentFootRight()
+	self:PlayStepSurfaceFX("FootRight", "Rightfoot")
+end
+
+function OnMsg.GatherFXActions(list)
+	list[#list+1] = "Step"
+end
+
+function OnMsg.GatherFXTargets(list)
+	local added = {}
+	ForEachPreset("TerrainObj", function(terrain_preset)
+		local type = terrain_preset.type
+		if type ~= "" and not added[type] then
+			list[#list+1] = "Surface:" .. type
+			added[type] = true
+		end
+	end)
+	local material_types = PresetsCombo("ObjMaterial")()
+	for i = 2, #material_types do
+		local type = material_types[i]
+		if not added[type] then
+			list[#list+1] = "Surface:" .. type
+			added[type] = true
+		end
+	end
+end
+
+DefineClass.AutoAttachAnimMomentHookObject = {
+	__parents = {"AutoAttachObject", "AnimMomentHook"},
+	
+	anim_moments_single_thread = true,
+	anim_moments_hook = true,
+}
+
+function AutoAttachAnimMomentHookObject:SetState(...)
+	AutoAttachObject.SetState(self, ...)
+	AnimMomentHook.SetState(self, ...)
+end
+
+function AutoAttachAnimMomentHookObject:OnAnimMoment(moment, anim)
+	return AnimMomentHook.OnAnimMoment(self, moment, anim)
+end

CommonLua/Classes/AppearanceObject.lua

@@ -0,0 +1,274 @@
+DefineClass.AppearanceObjectPart = {
+	__parents = { "CObject", "ComponentAnim", "ComponentAttach", "ComponentCustomData" },
+	flags = { gofSyncState = true, cofComponentColorizationMaterial = true },
+}
+
+function ValidAnimationsCombo(character)
+	local all_anims = character:GetStatesTextTable()
+	
+	local valid_anims = {}
+	for _, anim in ipairs(all_anims) do
+		if anim:sub(-1, -1) ~= "*" then
+			table.insert(valid_anims, anim)
+		end
+	end
+	
+	return valid_anims
+end
+
+DefineClass.AppearanceObject = {
+	__parents = { "Shapeshifter", "StripComponentAttachProperties", "ComponentAnim"},
+	flags = { gofSyncState = true, cofComponentColorizationMaterial = true },
+
+	properties =
+	{
+		{ category = "Animation", id = "Appearance", name = "Appearance", editor = "preset_id", preset_class = "AppearancePreset", default = "" },
+		{ category = "Animation", id = "anim", name = "Animation", editor = "dropdownlist", items = ValidAnimationsCombo, default = "idle" },
+		{ category = "Animation Blending", id = "animWeight", name = "Animation Weight", editor = "number", slider = true, min = 0, max = 100, default = 100, help = "100 means only Animation is played, 0 means only Animation 2 is played, 50 means both animations are blended equally" },
+		{ category = "Animation Blending", id = "animBlendTime", name = "Animation Blend Time", editor = "number", min = 0, default = 0 },
+		{ category = "Animation Blending", id = "anim2", name = "Animation 2", editor = "dropdownlist", items = function(character) local list = character:GetStatesTextTable() table.insert(list, 1, "") return list end, default = "" },
+		{ category = "Animation Blending", id = "anim2BlendTime", name = "Animation 2 Blend Time", editor = "number", min = 0, default = 0 },
+	},
+	
+	fallback_body = config.DefaultAppearanceBody,
+	parts = false,
+
+	animFlags  = 0,
+	animCrossfade = 0,
+	anim2Flags = 0,
+	anim2Crossfade = 0,
+
+	attached_parts = { "Head", "Pants", "Shirt", "Armor", "Hat", "Hat2", "Hair", "Chest", "Hip" },
+	animated_parts = { "Head", "Pants", "Shirt", "Armor" },
+	appearance_applied = false,
+
+	anim_speed = 1000,
+}
+
+function AppearanceObject:PostLoad()
+	self:ApplyAppearance()
+end
+
+function AppearanceObject:OnEditorSetProperty(prop_id)
+	if prop_id == "Appearance" then
+		self:ApplyAppearance()
+	end
+end
+
+function AppearanceObject:Setanim(anim)
+	self.anim = anim
+	self:SetAnimHighLevel()
+end
+
+function AppearanceObject:Setanim2(anim)
+	self.anim2 = anim
+	self:SetAnimHighLevel()
+end
+
+function AppearanceObject:SetanimFlags(anim_flags)
+	self.animFlags = anim_flags
+end
+
+function AppearanceObject:SetanimCrossfade(crossfade)
+	self.animCrossfade = crossfade
+end
+
+function AppearanceObject:Setanim2Flags(anim_flags)
+	self.anim2Flags = anim_flags
+end
+
+function AppearanceObject:Setanim2Crossfade(crossfade)
+	self.anim2Crossfade = crossfade
+end
+
+function AppearanceObject:SetanimWeight(weight)
+	self.animWeight = weight
+	self:SetAnimHighLevel()
+end
+
+function AppearanceObject:SetAnimChannel(channel, anim, anim_flags, crossfade, weight, blend_time)
+	if not self:HasState(anim) then
+		if self:GetEntity() ~= "" then
+			StoreErrorSource(self, "Missing object state " .. self:GetEntity() .. "." .. anim)
+		end
+		return
+	end
+	Shapeshifter.SetAnim(self, channel, anim, anim_flags, crossfade)
+	Shapeshifter.SetAnimWeight(self, channel, 100)
+	Shapeshifter.SetAnimWeight(self, channel, weight, blend_time)
+	self:SetAnimSpeed(channel, self.anim_speed)
+	local parts = self.parts
+	if parts then
+		for _, part_name in ipairs(self.animated_parts) do
+			local part = parts[part_name]
+			if part then
+				part:SetAnim(channel, anim, anim_flags, crossfade)
+				part:SetAnimWeight(channel, 100)
+				part:SetAnimWeight(channel, weight, blend_time)
+				part:SetAnimSpeed(channel, self.anim_speed)
+			end
+		end
+	end
+	return GetAnimDuration(self:GetEntity(), self:GetAnim(channel))
+end
+
+function AppearanceObject:SetAnimLowLevel()
+	self:ApplyAppearance()
+	local time = self:SetAnimChannel(1, self.anim, self.animFlags, self.animCrossfade, self.animWeight, self.animBlendTime)
+	if self.anim2 ~= "" then
+		local time2, duration2 = self:SetAnimChannel(2, self.anim2, self.anim2Flags, self.anim2Crossfade, 100 - self.animWeight, self.anim2BlendTime)
+		time = Max(time, time2)
+	end
+	return time
+end
+
+function AppearanceObject:SetAnimHighLevel()
+	self:SetAnimLowLevel()
+end
+
+function AppearanceObject:SetEntity()
+end
+
+local function get_part_offset_angle(appearance, prop_name)
+	local x = appearance[prop_name .. "AttachOffsetX"] or 0
+	local y = appearance[prop_name .. "AttachOffsetY"] or 0
+	local z = appearance[prop_name .. "AttachOffsetZ"] or 0
+	local angle = appearance[prop_name .. "AttachOffsetAngle"] or 0
+	if x ~= 0 or y ~= 0 or z ~= 0 or angle ~= 0 then
+		return point(x, y, z), angle
+	end
+end
+
+-- overload this in project
+config.DefaultAppearanceBody = "ErrorAnimatedMesh"
+
+function AppearanceObject:ColorizePart(part_name)
+	local appearance = AppearancePresets[self.Appearance]
+	local prop_color_name = string.format("%sColor", part_name)
+	if not appearance:HasMember(prop_color_name) then return end
+	
+	local part = self.parts[part_name]
+	local color_member = appearance[prop_color_name]
+	if not color_member then 
+		print("once", string.format("[WARNING] No color specified for %s in %s", part_name, self.Appearance))
+		return 
+	end
+	local palette = color_member["ColorizationPalette"]
+	part:SetColorizationPalette(palette)
+	for i = 1, const.MaxColorizationMaterials do
+		if string.match(part_name, "Hair") then
+			local custom = {}
+			for i = 1, 4 do
+				custom[i] = appearance["HairParam" .. i]
+			end
+			part:SetHairCustomParams(custom)
+		end
+		local color = color_member[string.format("EditableColor%d", i)]
+		local roughness = color_member[string.format("EditableRoughness%d", i)]
+		local metallic = color_member[string.format("EditableMetallic%d", i)]
+		part:SetColorizationMaterial(i, color, roughness, metallic)
+	end
+end
+
+function AppearanceObject:ApplyPartSpotAttachments(part_name)
+	local appearance = AppearancePresets[self.Appearance]
+	local part = self.parts[part_name]
+	local spot_prop = part_name .. "Spot"
+	local prop_spot = appearance:HasMember(spot_prop) and appearance[spot_prop]
+	local spot_name = prop_spot or "Origin"
+	self:Attach(part, self:GetSpotBeginIndex(spot_name))
+	if part_name == "Hat" or part_name == "Hat2" then
+		local offset, angle = get_part_offset_angle(appearance, part_name)
+		if offset and angle then
+			part:SetAttachOffset(offset)
+			part:SetAttachAngle(angle)
+		end
+	end
+end
+
+function AppearanceObject:ApplyAppearance(appearance, force)
+	appearance = appearance or self.Appearance
+	
+	if not appearance then return end
+	if not force and self.appearance_applied == appearance then return end
+	
+	self.appearance_applied = appearance
+	if type(appearance) == "string" then
+		self.Appearance = appearance
+		appearance = AppearancePresets[appearance]
+	else
+		self.Appearance = appearance.id
+	end
+	if not appearance then
+		local prop_meta = AppearanceObject:GetPropertyMetadata("Appearance")
+		appearance = AppearancePresets[prop_meta.default]
+		if not appearance then
+			StoreErrorSource(self, "Default Appearance can't be invalid!")
+		end
+		appearance = AppearancePresets[self.Appearance]
+		if not appearance then
+			StoreErrorSource(self, string.format("Invalid appearance '%s'", self.Appearance))
+			return 
+		end
+	end
+	for _, part in pairs(self.parts) do
+		DoneObject(part)
+	end
+	self:ChangeEntity(appearance.Body or self.fallback_body or config.DefaultAppearanceBody)
+	if not IsValidEntity(self:GetEntity()) then
+		StoreErrorSource(self, string.format("Invalid entity '%s'(%s) for Appearance '%s'", self:GetEntity(), appearance.Body, appearance.id))
+		printf("Invalid entity '%s'(%s) for Appearance '%s'", self:GetEntity(), appearance.Body, appearance.id)
+	end
+	if appearance:HasMember("BodyColor") and appearance.BodyColor then
+		self:SetColorization(appearance.BodyColor, true)
+	end
+	self.parts = {}
+	local real_time_animated = self:GetGameFlags(const.gofRealTimeAnim) ~= 0
+	for _, part_name in ipairs(self.attached_parts) do
+		if IsValidEntity(appearance[part_name]) then
+			local part = PlaceObject("AppearanceObjectPart")
+			if real_time_animated then
+				part:SetGameFlags(const.gofRealTimeAnim)
+			end
+			part:ChangeEntity(appearance[part_name])
+			if not IsValidEntity(part:GetEntity()) then
+				StoreErrorSource(part, string.format("Invalid entity part '%s'(%s) for Appearance '%s'", part:GetEntity(), appearance[part_name], appearance.id))
+				printf("Invalid entity part '%s'(%s) for Appearance '%s'", part:GetEntity(), appearance[part_name], appearance.id)
+			end
+			self.parts[part_name] = part
+			self:ColorizePart(part_name)
+			self:ApplyPartSpotAttachments(part_name)
+		end
+	end
+	self:Setanim(self.anim)
+end
+
+function AppearanceObject:PlayAnim(anim)
+	self:Setanim(anim)
+	local vec = self:GetStepVector()
+	local time = self:GetAnimDuration()
+	if vec:Len() > 0 then
+		self:SetPos(self:GetPos() + vec, time)
+	end
+	Sleep(time)
+end
+
+function AppearanceObject:SetPhaseHighLevel(phase)
+	self:SetAnimPhase(1, phase)
+	local parts = self.parts
+	if parts then
+		for _, part_name in ipairs(self.attached_parts) do
+			local part = parts[part_name]
+			if part then
+				part:SetAnimPhase(1, phase)
+			end
+		end
+	end
+end
+
+function AppearanceObject:SetAnimPose(anim, phase)
+	self:Setanim(anim)
+	self.anim_speed = 0
+	self:SetPhaseHighLevel(phase)
+end
+

CommonLua/Classes/AttachViaProp.lua

@@ -0,0 +1,262 @@
+local EDITOR = Platform.editor
+
+local function SpotEntry(obj, idx)
+	local name = idx >= 0 and obj:GetSpotName(idx) or ""
+	if name == "" then
+		return false
+	end
+	local offset = idx - obj:GetSpotBeginIndex(name)
+	return offset == 0 and name or {name, offset}
+end
+
+DefineClass.AttachViaProp = {
+	__parents = { "ComponentAttach" },
+	properties = {
+		{ category = "Attach-Via-Prop", id = "AttachList",    name = "Attach List",    editor = "prop_table",  default = "", no_edit = true },
+		{ category = "Attach-Via-Prop", id = "AttachCounter", name = "Attach Counter", editor = "number", default = 0, dont_save = true, read_only = true },
+	},
+}
+
+function AttachViaProp:SetAttachList(value)
+	self.AttachList = value
+	self:UpdatePropAttaches()
+end
+
+function AttachViaProp:ResolveSpotIdx(entry)
+	local spot = entry.spot
+	local offset
+	if type(spot) == "table" then
+		spot, offset = unpack_params(spot)
+		assert(type(spot) == "string")
+		assert(type(offset) == "number")
+	end
+	if type(spot) == "number" then
+		-- support for older version
+		entry.spot = SpotEntry(self, spot)
+	elseif type(spot) == "string" then
+		spot = self:HasSpot(spot) and self:GetSpotBeginIndex(spot)
+	end
+	return (spot or -1) + (offset or 0)
+end
+
+function AttachViaProp:UpdatePropAttaches()
+	if self.AttachCounter > 0 then
+		self:ForEachAttach(function(obj)
+			if rawget(obj, "attach_via_prop") then
+				DoneObject(obj)
+			end
+		end)
+		self.AttachCounter = nil
+	end
+	local list = self.AttachList
+	for i=#list,1,-1 do
+		local entry = list[i]
+		local spot = self:ResolveSpotIdx(entry)
+		if not spot then
+			table.remove(list, i)
+		else
+			local class = entry.class or ""
+			local particles = entry.particles or ""
+			local obj, err
+			if particles ~= "" then
+				obj = PlaceParticles(particles)
+			else
+				obj = PlaceObject(class)
+			end
+			if obj then
+				rawset(obj, "attach_via_prop", true)
+				if entry.offset then
+					obj:SetAttachOffset(entry.offset)
+				end
+				if entry.axis then
+					obj:SetAttachAxis(entry.axis)
+				end
+				if entry.angle then
+					obj:SetAttachAngle(entry.angle)
+				end
+				err = self:Attach(obj, spot)
+			end
+			if not IsValid(obj) or obj:GetAttachSpot() ~= spot or err then
+				StoreErrorSource(self, "Failed to attach via props!")
+				DoneObject(obj)
+			else
+				self.AttachCounter = self.AttachCounter + 1
+			end
+		end
+	end
+	if not EDITOR then
+		self.AttachList = nil
+	end
+end
+
+----
+if EDITOR then
+
+local function SpotName(obj, idx)
+	local name = obj:GetSpotName(idx)
+	local anot = obj:GetSpotAnnotation(idx)
+	return name .. (anot and (" (" .. anot .. ")") or "")
+end
+
+local function SpotNamesCombo(obj)
+	local start_idx, end_idx = obj:GetAllSpots( obj:GetState() )
+	local items = {}
+	local names = {}
+	for idx = start_idx, end_idx do
+		items[#items + 1] = {value = SpotEntry(obj, idx), text = SpotName(obj, idx)}
+	end
+	table.sortby_field(items, "text")
+	table.insert(items, 1, {value = false, text = ""})
+	return items
+end
+
+if FirstLoad then
+	l_used_entries = false
+end
+
+local function SmartAttachCombo()
+	local items = {}
+	local classes = ClassDescendantsList("ComponentAttach")
+	local tbl = {"", " - Object"}
+	for i = 1, #classes do
+		local class = classes[i]
+		tbl[1] = class
+		local text = table.concat(tbl)
+		items[#items + 1] = {value = { class, 1, text }, text = text}
+	end
+	local particles = ParticlesComboItems()
+	local tbl = {"", " - Particle"}
+	for i = 1, #particles do
+		local particle = particles[i]
+		tbl[1] = particle
+		local text = table.concat(tbl)
+		items[#items + 1] = {value = { particle, 2, text }, text = text}
+	end
+	table.sortby_field(items, "text")
+	if l_used_entries then
+		local idx = 1
+		local tbl = {"> ", ""}
+		for text, entry in sorted_pairs(l_used_entries) do
+			tbl[2] = text
+			table.insert(items, idx, {value = entry, text = table.concat(tbl)})
+			idx = idx + 1
+		end
+		table.insert(items, idx, {value = "", text = ""})
+	end
+	table.insert(items, 1, {value = false, text = ""})
+	return items
+end
+
+table.iappend(AttachViaProp.properties, {
+	{ category = "Attach-Via-Prop", id = "AttachPreview",    name = "Attach List",     editor = "text", lines = 5, default = "",      dont_save = true, read_only = true, min = 10 },
+	{ category = "Attach-Via-Prop", id = "AttachToSpot",     name = "Attach At",       editor = "combo",           default = false,   dont_save = true, items = SpotNamesCombo, min = 0, buttons = {{name = "Add", func = "ButtonAddAttach"}, {name = "Rem", func = "ButtonRemAttach"}, {name = "Rem All", func = "ButtonRemAllAttaches"}}},
+	{ category = "Attach-Via-Prop", id = "AttachObject",     name = "Attach Object",   editor = "combo",           default = false,   dont_save = true, items = SmartAttachCombo },
+	{ category = "Attach-Via-Prop", id = "AttachWithOffset", name = "Attach Offset ",  editor = "point",           default = point30, dont_save = true, scale = "m" },
+	{ category = "Attach-Via-Prop", id = "AttachWithAxis",   name = "Attach Axis ",    editor = "point",           default = axis_z,  dont_save = true },
+	{ category = "Attach-Via-Prop", id = "AttachWithAngle",  name = "Attach Angle ",   editor = "number",          default = 0,       dont_save = true, scale = "deg" },
+})
+
+function AttachViaProp:GetAttachListCombo()
+	local items = {}
+	local list = self.AttachList
+	for i=#list,1,-1 do
+		local entry = list[i]
+		local spot = self:ResolveSpotIdx(entry)
+		if not spot then
+			table.remove(list, i)
+		else
+			local str = SpotName(self, spot) .. " -- " .. (entry.particles or entry.class or "?")
+			if entry.offset then
+				str = str .. " o" .. tostring(entry.offset)
+			end
+			if entry.axis then
+				str = str .. " x" .. tostring(entry.axis)
+			end
+			if entry.angle then
+				str = str .. " a" .. tostring(entry.angle)
+			end
+			items[#items + 1] = str
+		end
+	end
+	table.sort(items)
+	return items
+end
+
+function AttachViaProp:GetAttachPreview()
+	local list = self:GetAttachListCombo()
+	return table.concat(list, "\n")
+end
+
+function ButtonAddAttach(main_obj, object, prop_id)
+	if type(object.AttachObject) ~= "table" then
+		return
+	end
+	local oname, otype, otext = unpack_params(object.AttachObject)
+	local class = otype == 1 and oname or ""
+	local particles = otype == 2 and oname or ""
+	if class == "" and particles == "" then
+		return
+	end
+	l_used_entries = l_used_entries or {}
+	l_used_entries[otext] = object.AttachObject
+	local spot = object.AttachToSpot or nil
+	local list = object.AttachList
+	if #list == 0 then
+		list = {}
+		object.AttachList = list
+	end
+	local offset = object.AttachWithOffset
+	if offset == point30 then
+		offset = nil
+	end
+	local axis = object.AttachWithAxis
+	if axis == axis_z then
+		axis = nil
+	end
+	local angle = object.AttachWithAngle
+	if angle == 0 then
+		angle = nil
+	end
+	if class ~= "" then
+		list[#list + 1] = {spot = spot, offset = offset, axis = axis, angle = angle, class = class, }
+	end
+	if particles ~= "" then
+		list[#list + 1] = {spot = spot, offset = offset, axis = axis, angle = angle, particles = particles, }
+	end
+	object:UpdatePropAttaches()
+end
+
+function ButtonRemAllAttaches(main_obj, object, prop_id)
+	if not object then
+		return
+	end
+	object.AttachList = nil
+	object:UpdatePropAttaches()
+end
+	
+function ButtonRemAttach(main_obj, object, prop_id)
+	if not object then
+		return
+	end
+	local list = object:GetAttachListCombo()
+	if #list == 0 then
+		return
+	end
+	local entry, err = PropEditorWaitUserInput(main_obj, list[#list], "Select attach to remove", list)
+	if not entry then
+		assert(false, err)
+		return
+	end
+	local idx = table.find(list, entry)
+	if not idx then
+		return
+	end
+	table.remove(object.AttachList, idx)
+	if #object.AttachList == 0 then
+		object.AttachList = nil
+	end
+	object:UpdatePropAttaches()
+end
+
+end -- EDITOR
+----

CommonLua/Classes/AutoAttach.lua

@@ -0,0 +1,1355 @@
+function GetObjStateAttaches(obj, entity)
+	entity = entity or (obj:GetEntity() or obj.entity)
+	
+	local state = obj and GetStateName(obj:GetState()) or "idle"
+	local entity_attaches = Attaches[entity]
+	
+	return entity_attaches and entity_attaches[state]
+end
+
+function GetEntityAutoAttachModes(obj, entity)
+	local attaches = GetObjStateAttaches(obj, entity)
+	local modes = {""}
+	for _, attach in ipairs(attaches or empty_table) do
+		if attach.required_state then
+			local mode = string.trim_spaces(attach.required_state)
+			table.insert_unique(modes, mode)
+		end
+	end
+	
+	return modes
+end
+
+--[[@@@
+@class AutoAttachCallback
+Inherit this if you want a callback when an objects is autoattached to its parent
+--]]
+
+DefineClass.AutoAttachCallback = {
+	__parents = {"InitDone"},
+}
+
+function AutoAttachCallback:OnAttachToParent(parent, spot)
+end
+
+--[[@@@
+@class AutoAttachObject
+Objects from this type are able to attach a preset of objects on their creation based on their spot annotations.
+--]]
+
+DefineClass.AutoAttachObject =
+{
+	__parents = { "Object", "ComponentAttach" },
+	auto_attach_props_description = false,
+
+	properties = {
+		{ id = "AutoAttachMode", editor = "choice", default = "", items = function(obj) return GetEntityAutoAttachModes(obj) or {} end },
+		{ id = "AllAttachedLightsToDetailLevel", editor = "choice", default = false, items = {"Essential", "Optional", "Eye Candy"}},
+	},
+
+	auto_attach_at_init = true,
+	auto_attach_mode = false,
+	is_forced_lod_min = false,
+	
+	max_colorization_materials_attaches = 0,
+}
+
+local gofAutoAttach = const.gofAutoAttach
+
+function IsAutoAttach(attach)
+	return attach:GetGameFlags(gofAutoAttach) ~= 0
+end
+
+function AutoAttachObject:DestroyAutoAttaches()
+	self:DestroyAttaches(IsAutoAttach)
+end
+
+function AutoAttachObject:ClearAttachMembers()
+	local attaches = GetObjStateAttaches(self)
+	for _, attach in ipairs(attaches) do
+		if attach.member then
+			self[attach.member] = nil
+		end
+	end
+end
+
+function AutoAttachObject:SetAutoAttachMode(value)
+	self.auto_attach_mode = value
+	self:DestroyAutoAttaches()
+	self:ClearAttachMembers()
+	self:AutoAttachObjects()
+end
+
+function AutoAttachObject:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "AllAttachedLightsToDetailLevel" or prop_id == "StateText" then
+		self:SetAutoAttachMode(self:GetAutoAttachMode())
+	end
+	Object.OnEditorSetProperty(self, prop_id, old_value, ged)
+end
+
+function AutoAttachObject:GetAutoAttachMode(mode)
+	local mode_set = GetEntityAutoAttachModes(self)
+	if not mode_set then
+		return ""
+	end
+	if table.find(mode_set, mode or self.auto_attach_mode) then
+		return self.auto_attach_mode
+	end
+	return mode_set[1] or ""
+end
+
+function AutoAttachObject:GetAttachModeSet()
+	return GetEntityAutoAttachModes(self)
+end
+
+if FirstLoad then
+	s_AutoAttachedLightDetailsBaseObject = false
+end
+
+function AutoAttachObjects(obj, context)
+	if not s_AutoAttachedLightDetailsBaseObject and obj.AllAttachedLightsToDetailLevel then
+		s_AutoAttachedLightDetailsBaseObject = obj
+	end
+	
+	local selectable = obj:GetEnumFlags(const.efSelectable) ~= 0
+	local attaches = GetObjStateAttaches(obj)
+	local max_colorization_materials = 0
+	for i = 1, #(attaches or "") do
+		local attach = attaches[i]
+		local class = GetAttachClass(obj, attach[2])
+
+		local spot_attaches = {}
+		local place, detail_class = PlaceCheck(obj, attach, class, context)
+		if place then
+			local o = PlaceAtSpot(obj, attach.spot_idx, class, context)
+			if o then
+				if attach.mirrored then
+					o:SetMirrored(true)
+				end
+				if attach.offset then
+					o:SetAttachOffset(attach.offset)
+				end
+				if attach.axis and attach.angle and attach.angle ~= 0 then
+					o:SetAttachAxis(attach.axis)
+					o:SetAttachAngle(attach.angle)
+				end
+				if selectable then 
+					o:SetEnumFlags(const.efSelectable)
+				end
+				if attach.inherited_properties then
+					for key, value in sorted_pairs(attach.inherited_properties) do
+						o:SetProperty(key, value)
+					end
+				end
+				if IsKindOf(o, "SubstituteByRandomChildEntity") then
+					-- NOTE:	when substituting entity the object is still not attached so it can't be
+					--			destroyed in SubstituteByRandomChildEntity and we have to do it manually here
+					if o:IsForcedLODMinAttach() and o:GetDetailClass() ~= "Essential" then
+						DoneObject(o)
+						o = nil
+					else
+						local top_parent = GetTopmostParent(o)
+						ApplyCurrentEnvColorizedToObj(top_parent) -- entity changed, possibly colorization too.
+						top_parent:DestroyRenderObj(true)
+					end
+				else
+					o:SetDetailClass(detail_class)
+				end
+				if o then
+					if attach.inherit_colorization then
+						o:SetGameFlags(const.gofInheritColorization)
+						max_colorization_materials = Max(max_colorization_materials, o:GetMaxColorizationMaterials())
+					end
+					o:SetForcedLODMin(rawget(obj, "is_forced_lod_min") or obj:GetForcedLODMin())
+					spot_attaches[#spot_attaches+1] = o
+				end
+			end
+		end
+		if context ~= "placementcursor" then
+			SetObjMembers(obj, attach, spot_attaches)
+		end
+	end
+	if max_colorization_materials > AutoAttachObject.max_colorization_materials_attaches then
+		obj.max_colorization_materials_attaches = max_colorization_materials
+	end
+	
+	if s_AutoAttachedLightDetailsBaseObject == obj then
+		s_AutoAttachedLightDetailsBaseObject = false
+	end
+end
+
+function AutoAttachObject:GetMaxColorizationMaterials()
+	return Max(self.max_colorization_materials_attaches, CObject.GetMaxColorizationMaterials(self))
+end
+
+function AutoAttachObject:CanBeColorized()
+	return self.max_colorization_materials_attaches and self.max_colorization_materials_attaches > 1 or CObject.CanBeColorized(self)
+end
+
+AutoAttachObject.AutoAttachObjects = AutoAttachObjects
+
+function RemoveObjMembers(obj, attach, list)
+	if attach.member then
+		local o = obj[attach.member]
+		for i = 1, #list do 
+			if o == list[i] then
+				obj[attach.member] = false
+				break
+			end
+		end
+	end
+	if attach.memberlist and obj[attach.memberlist] and type(obj[attach.memberlist]) == "table" then
+		table.remove_entry(obj[attach.memberlist], list)
+	end
+end
+
+-- local functions used in the class methods
+local AutoAttachObjects, RemoveObjMembers = AutoAttachObjects, RemoveObjMembers
+
+function AutoAttachObject:Init()
+	if self.auto_attach_at_init then
+		AutoAttachObjects(self, "init")
+	end
+end
+
+function AutoAttachObject:__fromluacode(props, arr, handle)
+	local obj = ResolveHandle(handle)
+	
+	if obj and obj[true] then
+		StoreErrorSource(obj, "Duplicate handle", handle)
+		assert(false, string.format("Duplicate handle %d: new '%s', prev '%s'", handle, self.class, obj.class))
+		obj = nil
+	end
+	
+	local idx = table.find(props, "AllAttachedLightsToDetailLevel")
+	local attached_lights_detail = idx and props[idx + 1]
+	if attached_lights_detail then
+		obj.AllAttachedLightsToDetailLevel = attached_lights_detail
+	end
+
+	local idx = table.find(props, "LowerLOD")
+	
+	if idx ~= nil then
+		obj.is_forced_lod_min = props[idx + 1]
+	else
+		idx = table.find(props, "ForcedLODState")
+		obj.is_forced_lod_min = idx and (props[idx + 1] == "Minimum")
+	end
+	
+	obj = self:new(obj)
+	SetObjPropertyList(obj, props)
+	SetArray(obj, arr)
+	obj.is_forced_lod_min = nil
+	
+	return obj
+end
+
+AutoAttachObject.ShouldAttach = return_true
+AutoResolveMethods.ShouldAttach = "and"
+
+function AutoAttachObject:OnAttachCreated(attach, spot)
+end
+
+function AutoAttachObject:MarkAttachEntities(entities)
+	if not IsValid(self) then return entities end
+	
+	entities = entities or {}
+	
+	self:__MarkEntities(entities)
+	
+	local cur_mode = self.auto_attach_mode
+	local modes = self:GetAttachModeSet()
+	for _, mode in ipairs(modes) do
+		self:SetAutoAttachMode(mode)
+		self:__MarkEntities(entities)
+	end
+	self:SetAutoAttachMode(cur_mode)
+	
+	return entities
+end
+
+function SetObjMembers(obj, attach, list)
+	if attach.member then
+		local name = attach.member
+		if #list == 0 then
+			if not rawget(obj, name) then
+				obj[name] = false -- initialize on init
+			end
+		else
+			assert(#list == 1 and not rawget(obj, name), 'Duplicate member "'..name..'" in the auto-attaches of class "'..obj.class..'"')
+			obj[name] = list[1]
+		end
+	end
+	if attach.memberlist then
+		local name = attach.memberlist
+		if not rawget(obj, name) or not type(obj[name]) == "table" or not IsValid(obj[name][1]) then
+			obj[name] = {}
+		end
+		if #list > 0 then
+			obj[name][#obj[name] + 1] = list
+		end
+	end
+end
+
+function GetAttachClass(self, classes)
+	if type(classes) == "string" then
+		return classes
+	end
+	assert(type(classes) == "table")
+	local rnd = self:Random(100)
+	local cur_prob = 0
+	for class, prob in pairs(classes) do
+		cur_prob = cur_prob + prob
+		if rnd <= cur_prob then
+			return class
+		end
+	end
+	-- probability of nothing left
+	return false
+end
+
+local IsKindOf = IsKindOf
+local shapeshifter_class_whitelist = { "Light", "AutoAttachSIModulator", "ParSystem" } -- classes that are alowed to be instantiated even in shapeshifters
+local function IsObjectClassAllowedInShapeshifter(class_to_spawn)
+	for _, class_name in ipairs(shapeshifter_class_whitelist) do
+		if IsKindOf(class_to_spawn, class_name) then
+			return true
+		end
+	end
+	return false
+end
+
+local gofDetailClassMask = const.gofDetailClassMask
+
+function PlaceCheck(obj, attach, class, context)
+	if not obj:ShouldAttach(attach) then
+		return false
+	end
+	
+	-- placement cursor check
+	if context == "placementcursor" then
+		if not attach.show_at_placement and not attach.placement_only then
+			return false
+		end
+	elseif attach.placement_only then
+		return false
+	end
+	if attach.required_state and IsKindOf(obj, "AutoAttachObject") and attach.required_state ~= obj.auto_attach_mode then
+		return false
+	end
+
+	-- condition check
+	local condition = attach.condition
+	if condition then
+		assert(type(condition) == "function" or type(condition) == "string")
+		if type(condition) == "function" then
+			if not condition(obj, attach) then
+				return false
+			end
+		else
+			if obj:HasMember(condition) and not obj[condition] then
+				return false
+			end
+		end
+	end
+	
+	local detail_class = s_AutoAttachedLightDetailsBaseObject and
+		IsKindOf(g_Classes[class], "Light") and
+		s_AutoAttachedLightDetailsBaseObject.AllAttachedLightsToDetailLevel		
+	detail_class = detail_class or (attach.DetailClass ~= "Default" and attach.DetailClass)
+	if not detail_class then
+		-- try to extract from the class
+		local detail_mask = GetClassGameFlags(class, gofDetailClassMask)
+		local detail_from_class = GetDetailClassMaskName(detail_mask)
+		detail_class = detail_from_class ~= "Default" and detail_from_class
+	end
+	local forced_lod_min = rawget(obj, "is_forced_lod_min") or obj:GetForcedLODMin()
+	if forced_lod_min and detail_class ~= "Essential" then
+		return false
+	end
+	
+	return true, detail_class
+end
+
+function PlaceAtSpot(obj, spot, class, context)
+	local o
+	if g_Classes[class] then
+		if context == "placementcursor" then
+			if g_Classes[class]:IsKindOfClasses("TerrainDecal", "BakedTerrainDecal") then
+				o = PlaceObject("PlacementCursorAttachmentTerrainDecal")
+			else
+				o = PlaceObject("PlacementCursorAttachment")
+			end
+			o:ChangeClass(class)
+			AutoAttachObjects(o, "placementcursor")
+		elseif context == "shapeshifter" and not IsObjectClassAllowedInShapeshifter(g_Classes[class]) then
+			o = PlaceObject("Shapeshifter", nil, const.cofComponentAttach)
+			if IsValidEntity(class) then
+				o:ChangeEntity(class)
+			end
+		else
+			o = PlaceObject(class, nil, const.cofComponentAttach)
+		end
+	else
+		print("once", 'AutoAttach: unknown class/particle "' .. class .. '" for [object "' .. obj.class .. '", spot "' .. obj:GetSpotName(spot) .. '"]')
+	end
+	if not o then
+		return
+	end
+	local err = obj:Attach(o, spot)
+	if err then
+		print("once", "Error attaching", o.class, "to", obj.class, ":", err)
+		return
+	end
+	o:SetGameFlags(const.gofAutoAttach)
+	if not IsKindOf(obj, "Shapeshifter") then
+		obj:OnAttachCreated(o, spot)
+	end
+	if IsKindOf(o, "AutoAttachCallback") then
+		o:OnAttachToParent(obj, spot)
+	end
+
+	return o
+end
+
+if FirstLoad then
+	Attaches = {}  -- global table that keeps the inherited auto_attaches
+end
+
+function AutoAttachObjectsToPlacementCursor(obj)
+	AutoAttachObjects(obj, "placementcursor")
+end
+
+--[Deprecated]
+function AutoAttachObjectsToShapeshifter(obj)
+	AutoAttachObjects(obj)
+end
+
+function AutoAttachShapeshifterObjects(obj)
+	AutoAttachObjects(obj, "shapeshifter")
+end
+
+local function CanInheritColorization(parent_entity, child_entity)
+	return true
+end
+
+function GetEntityAutoAttachTable(entity, auto_attach)
+	auto_attach = auto_attach or false
+	
+	local states = GetStates(entity)
+	for _, state in ipairs(states) do
+		local spbeg, spend = GetAllSpots(entity, state)
+		for spot = spbeg, spend do
+			local str = GetSpotAnnotation(entity, spot)
+			if str and #str > 0 then
+				local item
+				for w in string.gmatch(str,"%s*(.[^,]+)[, ]?") do
+					local lw = string.lower(w)
+					if not item then
+						-- auto attach description
+						if lw ~= "att" and lw~="autoattach" then
+							break
+						end
+						item = {}
+						item.spot_idx = spot
+					elseif lw=="show at placement" or lw=="show_at_placement" or lw=="show" then -- show at placement
+						item.show_at_placement = true
+					elseif lw=="placement only" or lw=="placement_only" then -- placement only
+						item.placement_only = true
+					elseif lw=="mirrored" or lw=="mirror" then
+						item.mirrored = true
+					elseif not item[2] then
+						item[2] = w
+						if not g_Classes[w] then
+							print("once", "Invalid autoattach", w, "for entity", entity)
+						end
+					end
+				end
+				if item then
+					item.inherit_colorization = CanInheritColorization(entity, item[2])
+					auto_attach = auto_attach or {}
+					auto_attach[state] = auto_attach[state] or {}
+					table.insert(auto_attach[state], item)
+				end
+			end
+		end
+	end
+	
+	return auto_attach
+end
+
+local function IsAutoAttachObject(entity)
+	local entity_data = EntityData and EntityData[entity] and EntityData[entity].entity
+	local classes = entity_data and entity_data.class_parent and entity_data.class_parent or ""
+	for class in string.gmatch(classes, "[^%s,]+%s*") do
+		if IsKindOf(g_Classes[class], "AutoAttachObject") then
+			return true
+		end
+	end
+end
+
+local function TransferMatchingIdleAttachesToAllState(auto_attach, states)
+	local idle_attaches = auto_attach["idle"]
+	if not idle_attaches then return end
+	
+	local attach_modes
+	for _, attach in ipairs(idle_attaches) do
+		if attach.required_state then
+			attach_modes = true
+			break
+		end
+	end
+	if not attach_modes then return end
+	
+	for _, state in ipairs(states) do
+		auto_attach[state] = auto_attach[state] or {}
+		table.iappend(auto_attach[state], idle_attaches)
+	end
+end
+
+-- build autoattach table
+function RebuildAutoattach()
+	if not config.LoadAutoAttachData then return end
+	
+	local ae = GetAllEntities()
+	for entity, _ in sorted_pairs(ae) do
+		local auto_attach = IsAutoAttachObject(entity) and GetEntityAutoAttachTable(entity)
+		auto_attach = GetEntityAutoAttachTableFromPresets(entity, auto_attach)
+		if auto_attach then
+			local states = GetStates(entity)
+			table.remove_value(states, "idle")
+			if #states > 0 then
+				-- transfer auto attaches to all states since AutoAttachEditor can define only in "idle" state
+				TransferMatchingIdleAttachesToAllState(auto_attach, states)
+			end
+			Attaches[entity] = auto_attach
+		else
+			Attaches[entity] = nil
+		end
+	end
+end
+
+OnMsg.EntitiesLoaded = RebuildAutoattach
+
+function OnMsg.PresetSave(name)
+	local class = g_Classes[name]
+	if IsKindOf(class, "AutoAttachPreset") then
+		RebuildAutoattach()
+	end
+end
+
+local function PlaceFadingObjects(category, init_pos)
+	local ae = GetAllEntities()
+	local init_pos = init_pos or GetTerrainCursor()
+	local pos = init_pos
+	for k,v in pairs(ae) do
+		if EntityData[k] and EntityData[k].entity and EntityData[k].entity.fade_category == category then
+			local o = PlaceObject(k)
+			o:ChangeEntity(k)
+			o:SetPos(pos)
+			o:SetGameFlags(const.gofPermanent)
+			pos = pos + point(10*guim, 0)
+			if (pos:x() / (600*guim) > 0) then
+				pos = point(init_pos:x(), pos:y() + 20*guim)
+			end
+		elseif not EntityData[k] then
+			print("No EntityData for: ", k)
+		elseif EntityData[k] and not EntityData[k].entity then
+			print("No EntityData[].entity for: ", k)
+		end
+	end
+end
+
+function TestFadeCategories()
+	local cat = {
+		"PropsUltraSmall",
+		"PropsSmall",
+		"PropsMedium",
+		"PropsBig",
+	}
+	local pos = point(100*guim, 100*guim)
+	for i=1, #cat do
+		PlaceFadingObjects(cat[i], pos)
+		pos = pos + point(0, 100*guim)
+	end
+end
+
+function GetEntitiesAutoattachCount(filter_count)
+	local el = GetAllEntities()
+	local filter_count = filter_count or 30
+	for k,v in pairs(el) do  
+		local s,e = GetSpotRange(k, EntityStates["idle"], "Autoattach") 
+		if (e-s) > filter_count then 
+			print(k, e-s)
+		end
+	end
+end
+
+function ListEntityAutoattaches(entity)
+	local s,e = GetSpotRange(entity, EntityStates["idle"], "Autoattach") 
+	for i=s, e do
+		local annotation = GetSpotAnnotation(entity, i)
+		print(i, annotation)
+	end
+end
+
+---------------------- AutoAttach editor ----------------------
+
+
+local function FindArtSpecById(id)
+	local spec = EntitySpecPresets[id]
+	if not spec then
+		local idx = string.find(id, "_[0-9]+$")
+		if idx then
+			spec = EntitySpecPresets[string.sub(id, 0, idx - 1)]
+		end
+	end
+	return spec
+end
+
+local function GenerateMissingEntities()
+	local all_entities = GetAllEntities()
+	local to_create = {}
+	for entity in pairs(all_entities) do
+		local spec = FindArtSpecById(entity)
+		if spec and not AutoAttachPresets[entity] and string.find(spec.class_parent, "AutoAttachObject", 1, true) then
+			table.insert(to_create, entity)
+		end
+	end
+
+	if #to_create > 0 then
+		for _, entity in ipairs(to_create) do
+			local preset = AutoAttachPreset:new({id = entity})
+			preset:Register()
+			preset:UpdateSpotData()
+			Sleep(1)
+		end
+
+		AutoAttachPreset:SortPresets()
+		ObjModified(Presets.AutoAttachPreset)
+	end
+end
+
+function GetEntitySpots(entity)
+	if not IsValidEntity(entity) then return {} end
+	local states = GetStates(entity)
+	local idle = table.find(states, "idle")
+	if not idle then
+		print("WARNING: No idle state for", entity, "cannot fetch spots.")
+		return {}
+	end
+	
+	local spots = {}
+	local spbeg, spend = GetAllSpots(entity, "idle")
+	for spot = spbeg, spend do
+		local str = GetSpotName(entity, spot) 
+		spots[str] = spots[str] or {}
+		table.insert(spots[str], spot)
+	end
+
+	return spots
+end
+
+local zeropoint = point(0, 0, 0)
+function GetEntityAutoAttachTableFromPresets(entity, attach_table)
+	local preset = AutoAttachPresets[entity]
+	if not preset then return attach_table end
+	
+	local spots
+	for _, spot in ipairs(preset) do
+		for _, rule in ipairs(spot) do
+			attach_table = rule:FillAutoAttachTable(attach_table, entity, preset)
+		end
+	end
+
+	return attach_table
+end
+
+DefineClass.AutoAttachRuleBase = {
+	__parents = { "PropertyObject" },
+	parent = false,
+}
+
+function AutoAttachRuleBase:FillAutoAttachTable(attach_table, entity, preset)
+	return attach_table
+end
+
+function AutoAttachRuleBase:IsActive()
+	return false
+end
+
+function AutoAttachRuleBase:OnEditorNew(parent, ged, is_paste)
+	self.parent = parent
+end
+
+local function GetSpotsCombo(entity_name)
+	local t = {}
+	local spots = GetEntitySpots(entity_name)
+	for spot_name, indices in sorted_pairs(spots) do
+		for i = 1, #indices do
+			table.insert(t, spot_name .. " " .. i)
+		end
+	end
+	return t
+end
+
+
+DefineClass.AutoAttachRuleInherit = {
+	__parents = { "AutoAttachRuleBase" },
+	properties = {
+		{ id = "parent_entity", category = "Rule", name = "Parent Entity", editor = "combo", items = function() return ClassDescendantsCombo("AutoAttachObject") end, default = "", },
+		{ id = "spot", category = "Rule", name = "Spot", editor = "combo", items = function(obj) return GetSpotsCombo(obj:GetParentEntity()) end, default = "", },
+	},
+}
+
+function AutoAttachRuleInherit:GetParentEntity()
+	return self.parent_entity
+end
+
+function AutoAttachRuleInherit:GetSpotAndIdx()
+	local spot = self.spot
+	local break_idx = string.find(spot, "%d+$")
+	if not break_idx then return end
+	local spot_name = string.sub(spot, 1, break_idx - 2)
+	local spot_idx = tonumber(string.sub(spot, break_idx))
+	if spot_name and spot_idx then
+		return spot_name, spot_idx
+	end
+end
+
+function AutoAttachRuleInherit:GetEditorView()
+	local str = string.format("Inherit %s from %s", self.spot or "[SPOT]", self:GetParentEntity() or "[ENTITY]")
+	if not self:FindInheritedSpot() then
+		str = "<color 168 168 168>" .. str .. "</color>"
+	end
+	return str
+end
+
+function AutoAttachRuleInherit:FindInheritedSpot()
+	local entity = self:GetParentEntity()
+	local parent_preset = AutoAttachPresets[entity]
+	if not parent_preset then return end
+	local spot_name, spot_idx = self:GetSpotAndIdx()
+	if not spot_name or not spot_idx then return end
+	local aaspot_idx, aapost_obj = parent_preset:GetSpot(spot_name, spot_idx)
+	if not aapost_obj then return end
+
+	return aapost_obj, entity, parent_preset
+end
+
+function AutoAttachRuleInherit:FillAutoAttachTable(attach_table, entity, preset)
+	local spot, parent_entity, parent_preset = self:FindInheritedSpot()
+	if not spot then return attach_table end
+
+	for _, rule in ipairs(spot) do
+		attach_table = rule:FillAutoAttachTable(attach_table, parent_entity, parent_preset, self.parent)
+	end
+	return attach_table
+end
+
+function AutoAttachRuleInherit:IsActive()
+	local spot, _, _ = self:FindInheritedSpot()
+	return not not spot
+end
+
+DefineClass.AutoAttachRule = {
+	__parents = { "AutoAttachRuleBase" },
+	properties = {
+		{ id = "attach_class", category = "Rule", name = "Object Class", editor = "combo", items = function() return ClassDescendantsCombo("CObject") end, default = "", },
+		{ id = "quick_modes", default = false, no_save = true, editor = "buttons", category = "Rule", buttons = {
+			{name = "ParSystem", func = "QuickSetToParSystem"},
+		}},
+		{ id = "offset", category = "Rule", name = "Offset", editor = "point", default = point(0, 0, 0), },
+		{ id = "axis" , category = "Rule", name = "Axis", editor = "point", default = point(0, 0, 0), },
+		{ id = "angle", category = "Rule", name = "Angle", editor = "number", default = 0, scale = "deg" },
+		{ id = "member", category = "Rule", name = "Member", help = "The name of the property of the parent object that should be pointing to the attach object.", editor = "text", default = "", },
+		{ id = "required_state", category = "Rule", name = "Attach State", help = "Conditional attachment", default = "", editor = "combo", items = function(obj)
+			return obj and obj.parent and obj.parent.parent and obj.parent.parent:GuessPossibleAutoattachStates() or {}
+		end, },
+		{ id = "GameStatesFilter", name="Game State", category = "Rule", editor = "set", default = set(), three_state = true, items = function() return GetGameStateFilter() end },
+		{ id = "DetailClass", category = "Rule", name = "Detail Class Override", editor = "dropdownlist",
+			items = {"Default", "Essential", "Optional", "Eye Candy"}, default = "Default",
+		},
+		{ id = "inherited_values", no_edit = true, editor = "prop_table", default = false, },
+	},
+	parent = false,
+}
+
+function AutoAttachRule:IsActive()
+	return self.attach_class ~= ""
+end
+
+
+function AutoAttachRule:QuickSetToParSystem()
+	self.attach_class = "ParSystem"
+	ObjModified(self)
+end
+
+function AutoAttachRule:ResolveConditionFunc()
+	local gamestates_filters = self.GameStatesFilter
+	if not gamestates_filters or not next(gamestates_filters) then 
+		return false
+	end
+
+	return function(obj, attach)
+		if gamestates_filters then
+			for key, value in pairs(gamestates_filters) do
+				if value then
+					if not GameState[key] then return false end
+				else
+					if GameState[key] then return false end
+				end
+			end
+		end
+
+		return true
+	end
+end
+
+function AutoAttachRule:GetCleanInheritedPropertyValues()
+	local inherited_values = self.inherited_values
+	if not inherited_values then
+		return false
+	end
+	local inherited_props = self:GetInheritedProps()
+	if not inherited_props or #inherited_props == 0 then
+		return false
+	end
+	local clean_value_list = {}
+	for _, prop in ipairs(inherited_props) do
+		local value = inherited_values[prop.id]
+		if value ~= nil then
+			clean_value_list[prop.id] = value
+		end
+	end
+	return clean_value_list
+end
+
+function AutoAttachRule:FillAutoAttachTable(attach_table, entity, preset, spot)
+	if self.attach_class == "" then
+		return attach_table
+	end
+	spot = spot or self.parent
+	attach_table = attach_table or {}
+	
+	local attach_table_idle = attach_table["idle"] or {}
+	attach_table["idle"] = attach_table_idle
+	
+	local istart, iend = GetSpotRange(spot.parent.id, "idle", spot.name)
+	if istart < 0 then
+		print(string.format("Warning: Could not find '%s' spot range for '%s'", spot.name, entity))
+	else
+		table.insert(attach_table_idle, {
+			spot_idx = istart + spot.idx - 1,
+			[2] = self.attach_class,
+			offset = self.offset,
+			axis = self.axis ~= zeropoint and self.axis,
+			angle = self.angle ~= 0 and self.angle,
+			member = self.member ~= "" and self.member,
+			required_state = self.required_state ~= "" and self.required_state or false,
+			condition = self:ResolveConditionFunc() or false, 
+			DetailClass = self.DetailClass ~= "Default" and self.DetailClass,
+			inherited_properties = self:GetCleanInheritedPropertyValues(),
+			inherit_colorization = preset.PropagateColorization and CanInheritColorization(entity, self.attach_class),
+		})
+	end
+	
+	return attach_table
+end
+
+function AutoAttachRule:GetEditorView()
+	local str
+	if self.attach_class == "ParSystem" then
+		str = "Particles <color 198 25 198>" .. (self.inherited_values and self.inherited_values["ParticlesName"] or "?") .. "</color>"
+	else
+		str = "Attach <color 75 105 198>" .. (self.attach_class or "?") .. "</color>"
+	end
+	str = str .. " (" .. self.DetailClass .. ")"
+	if self.required_state ~= "" then
+		str = str .. " : <color 20 120 20>" .. self.required_state .. "</color>"
+	end
+	if self.attach_class == "" then
+		str = "<color 168 168 168>" .. str .. "</color>"
+	end
+	return str
+end
+
+function AutoAttachRule:Setattach_class(value)
+	if self.parent and self.parent.parent and self.parent.parent.id == value then
+		value = ""
+		return false
+	end
+	self.attach_class = value
+end
+
+function AutoAttachRule:GetInheritedProps()
+	local properties = {}
+	local class_obj = g_Classes[self.attach_class]
+	if not class_obj then
+		return properties
+	end
+	
+	local orig_properties = PropertyObject.GetProperties(self)
+	local properties_of_target_entity = class_obj:GetProperties()
+	for _, prop in ipairs(properties_of_target_entity) do
+		if prop.autoattach_prop then
+			assert(not table.find(orig_properties, "id", prop.id),
+				string.format("Property %s conflict between AutoAttachRule and %s", prop.id, self.attach_class))
+			prop = table.copy(prop)
+			prop.dont_save = true
+			table.insert(properties, prop)
+		end
+	end
+	return properties
+end
+
+function AutoAttachRule:GetProperties()
+	local properties = PropertyObject.GetProperties(self)
+	local class_obj = g_Classes[self.attach_class]
+	if not class_obj then
+		return properties
+	end
+
+	properties = table.copy(properties)
+	properties = table.iappend(properties, self:GetInheritedProps())
+	return properties
+end
+
+function AutoAttachRule:SetProperty(id, value)
+	if table.find(self:GetInheritedProps(), "id", id) then
+		self.inherited_values = self.inherited_values or {}
+		self.inherited_values[id] = value
+		return
+	end
+	PropertyObject.SetProperty(self, id, value)
+end
+
+function AutoAttachRule:GetProperty(id)
+	if self.inherited_values and self.inherited_values[id] ~= nil then
+		return self.inherited_values[id]
+	end
+	
+	return PropertyObject.GetProperty(self, id)
+end
+
+function AutoAttachRule:OnEditorSetProperty(prop_id, old_value, ged)
+	RebuildAutoattach()
+	ged:ResolveObj("SelectedPreset"):RecreateDemoObject(ged)
+	local id = self.parent.parent.id
+	local class = rawget(_G, id)
+	if class and not class:IsKindOf("AutoAttachObject") then
+		return false
+	end
+	MapForEach("map", id, function(obj)
+		obj:SetAutoAttachMode(obj:GetAutoAttachMode())
+	end)
+end
+
+function AutoAttachRule:GetMaxColorizationMaterials()
+	if IsKindOf(_G[self.attach_class], "WaterObj") then return 3 end
+	return self.attach_class ~= "" and IsValidEntity(self.attach_class) and ColorizationMaterialsCount(self.attach_class) or 0
+end
+
+function AutoAttachRule:ColorizationReadOnlyReason()
+	return false
+end
+
+function AutoAttachRule:ColorizationPropsNoEdit(i)
+	if self.parent.parent.PropagateColorization then
+		return true
+	end
+	return self:GetMaxColorizationMaterials() < i
+end
+
+DefineClass.AutoAttachSpot = {
+	__parents = { "PropertyObject", "Container" },
+
+	properties = {
+		{ id = "name", name = "Spot Name", editor = "text", default = "", read_only = true },
+		{ id = "idx", name = "Number", editor = "number", default = -1, read_only = true, },
+		{ id = "original_index", name = "Original Index", editor = "number", default = -1, read_only = true, },
+	},
+
+	annotated_autoattach = false,
+	EditorView = Untranslated("<Color><name> <idx><opt(u(attach_class), ' - <color 32 192 32>')> <AnnotatedAutoattachMsg>"),
+	parent = false,
+	ContainerClass = "AutoAttachRuleBase",
+}
+
+function AutoAttachSpot:Color()
+	return not self:HasSomethingAttached() and "<color 168 168 168>" or ""
+end
+
+function AutoAttachSpot:HasSomethingAttached()
+	if #self == 0 then return false end
+	for _, rule in ipairs(self) do
+		if rule:IsActive() then
+			return true
+		end
+	end
+	return false
+end
+
+function AutoAttachSpot:AnnotatedAutoattachMsg()
+	if not self.annotated_autoattach then return "" end
+	return "<color 158 22 22>" .. self.annotated_autoattach
+end
+
+function AutoAttachSpot.CreateRule(root, obj)
+	obj[#obj + 1] = AutoAttachRule:new({parent = obj})
+	ObjModified(root)
+	ObjModified(obj)
+end
+
+function CommonlyUsedAttachItems()
+	local ret = {}
+	ForEachPreset("AutoAttachPreset", function(preset)
+		for _, rule in ipairs(preset) do
+			for _, subrule in ipairs(rule) do
+				local class = rawget(subrule, "attach_class")
+				if class and class ~= "" then
+					ret[class] = (ret[class] or 0) + 1
+				end
+			end
+		end
+	end)
+	for class, count in pairs(ret) do
+		if count == 1 then
+			ret[class] = nil
+		end
+	end
+	return table.keys2(ret, "sorted")
+end
+
+DefineClass.AutoAttachPresetFilter = {
+	__parents = { "GedFilter" },
+	properties = {
+		{ id = "NonEmpty", name = "Only show non-empty entries", default = false, editor = "bool" },
+		{ id = "HasAttach", name = "Has attach of class", default = false, editor = "combo", items = CommonlyUsedAttachItems },
+		{ id = "_", editor = "buttons", default = false, buttons = { { name = "Add new AutoAttach entity", func = "AddEntity" } } },
+	},
+}
+
+function AutoAttachPresetFilter:FilterObject(obj)
+	if self.NonEmpty then
+		for _, rule in ipairs(obj) do
+			for _, subrule in ipairs(rule) do
+				if subrule:IsKindOf("AutoAttachRule") and subrule.attach_class ~= "" then
+					return true
+				end
+			end
+		end
+		return false
+	end
+	local class = self.HasAttach
+	if class then
+		for _, rule in ipairs(obj) do
+			for _, subrule in ipairs(rule) do
+				if subrule:IsKindOf("AutoAttachRule") and subrule.attach_class == class then
+					return true
+				end
+			end
+		end
+		return false
+	end
+	return true
+end
+
+function AutoAttachPresetFilter:AddEntity(root, prop_id, ged)
+	local entities = {}
+	ForEachPreset("EntitySpec", function(preset)
+		if not string.find(preset.class_parent, "AutoAttachObject", 1, true) and not preset.id:starts_with("#") then
+			entities[#entities + 1] = preset.id
+		end
+	end)
+
+	local entity = ged:WaitListChoice(entities, "Choose entity to add:")
+	if not entity then
+		return
+	end
+
+	local spec = EntitySpecPresets[entity]
+	if spec.class_parent == "" then
+		spec.class_parent = "AutoAttachObject"
+	else
+		spec.class_parent = spec.class_parent .. ",AutoAttachObject"
+	end
+
+	GedSetUiStatus("add_autoattach_entity", "Saving ArtSpec...")
+	EntitySpec:SaveAll()
+	self.NonEmpty = false
+	self.HasAttach = false
+	GenerateMissingEntities()
+	ged:SetSelection("root", { 1, table.find(Presets.AutoAttachPreset.Default, "id", entity) })
+	GedSetUiStatus("add_autoattach_entity")
+
+	ged:ShowMessage(Untranslated("Attention!"), Untranslated("You need to commit both the assets and the project folder!"))
+end
+
+DefineClass.AutoAttachPreset = {
+	__parents = { "Preset" },
+
+	properties = {
+		{ id = "Id", read_only = true, },
+		{ id = "SaveIn", read_only = true, },
+		{ id = "help", editor = "buttons", buttons = {{name = "Go to ArtSpec", func = "GotoArtSpec"}}, default = false,},
+		{ id = "PropagateColorization", editor = "bool", default = true },
+	},
+
+	GlobalMap = "AutoAttachPresets",
+	ContainerClass = "AutoAttachSpot",
+	GedEditor = "GedAutoAttachEditor",
+	EditorMenubar = "Editors.Art",
+	EditorMenubarName = "AutoAttach Editor",
+	EditorIcon = "CommonAssets/UI/Icons/attach attachment paperclip.png",
+	FilterClass = "AutoAttachPresetFilter",
+
+	EnableReloading = false,
+}
+
+function AutoAttachPreset:GuessPossibleAutoattachStates()
+	return GetEntityAutoAttachModes(nil, self.id)
+end
+
+function AutoAttachPreset:EditorContext()
+	local context = Preset.EditorContext(self)
+	context.Classes = {}
+	context.ContainerTree = true
+	return context
+end
+
+function AutoAttachPreset:EditorItemsMenu()
+	return {}
+end
+
+function AutoAttachPreset:GotoArtSpec(root)
+	local editor = OpenPresetEditor("EntitySpec")
+	local spec = self:GetEntitySpec()
+	local root = editor:ResolveObj("root")
+	local group_idx = table.find(root, root[spec.group])
+	local idx = table.find(root[spec.group], spec)
+	editor:SetSelection("root", {group_idx, idx})
+end
+
+function AutoAttachPreset:PostLoad()
+	for idx, item in ipairs(self) do
+		item.parent = self
+		for _, subitem in ipairs(item) do
+			subitem.parent = item
+		end
+	end
+	Preset.PostLoad(self)
+end
+
+function AutoAttachPreset:GenerateCode(code)
+	self:UpdateSpotData() -- to read save_in
+	
+	-- drop redundant/unneeded data
+	local has_something_attached = false
+	for i = #self, 1, -1 do
+		local spot = self[i]
+		if not spot:HasSomethingAttached() then
+			table.remove(self, i)
+		else
+			spot.original_index = nil
+			spot.annotated_autoattach = nil
+			has_something_attached = true
+			if not spot[#spot]:IsActive() then
+				table.remove(spot, #spot)
+			end
+		end
+	end
+	if has_something_attached then
+		Preset.GenerateCode(self, code)
+	end
+
+	self:UpdateSpotData() -- to write original_index and annotated_autoattach back to the structure
+end
+
+function AutoAttachPreset:GetSpot(name, idx)
+	for i, value in ipairs(self) do
+		if value.name == name and value.idx == idx then
+			return i, value
+		end
+	end
+end
+
+function AutoAttachPreset:UpdateSpotData()
+	local spec = self:GetEntitySpec()
+	if not spec then
+		return
+	end
+	self.save_in = spec:GetSaveIn()
+	local spots = GetEntitySpots(self.id)
+	
+	-- drop additional spots
+	for i = #self, 1, -1 do
+		local entry = self[i]
+		if entry.idx > (spots[entry.name] and #spots[entry.name] or -1) then
+			table.remove(self, i)
+		end
+	end
+
+	for spot_name, indices in pairs(spots) do
+		for idx = 1, #indices do
+			local internal_idx, spot = self:GetSpot(spot_name, idx)
+			if spot then
+				spot.original_index = indices[idx]
+				spot.annotated_autoattach = GetSpotAnnotation(self.id, indices[idx])
+			else
+				spot = AutoAttachSpot:new({
+					name = spot_name,
+					idx = idx,
+					original_index = indices[idx],
+					annotated_autoattach = GetSpotAnnotation(self.id, indices[idx]),
+				})
+				table.insert(self, spot)
+			end
+			spot.parent = self
+		end
+	end
+
+	table.sort(self, function(a, b)
+		if a.name < b.name then return true end
+		if a.name > b.name then return false end
+		if a.idx < b.idx then return true end
+		return false
+	end)
+end
+
+if FirstLoad then
+	GedAutoAttachEditorLockedObject = {}
+	GedAutoAttachDemos = {}
+end
+
+DefineClass.AutoAttachPresetDemoObject = {
+	__parents = {"Shapeshifter", "AutoAttachObject"}
+}
+
+AutoAttachPresetDemoObject.ShouldAttach = return_true
+
+function AutoAttachPresetDemoObject:ChangeEntity(entity)
+	self:DestroyAutoAttaches()
+	self:ClearAttachMembers()
+	Shapeshifter.ChangeEntity(self, entity)
+	self:DestroyAutoAttaches()
+	self:ClearAttachMembers()
+	AutoAttachShapeshifterObjects(self)
+end
+
+function AutoAttachPresetDemoObject:CreateLightHelpers()
+	self:ForEachAttach(function(attach)
+		if IsKindOf(attach, "Light") then
+			PropertyHelpers_Init(attach)
+		end
+	end)
+end
+
+function AutoAttachPresetDemoObject:AutoAttachObjects()
+	AutoAttachShapeshifterObjects(self)
+	self:CreateLightHelpers()
+end
+
+function AutoAttachPreset:ViewDemoObject(ged)
+	local demo_obj = GedAutoAttachDemos[ged]
+	if demo_obj and IsValid(demo_obj) then
+		ViewObject(demo_obj)
+	end
+end
+
+function AutoAttachPreset:RecreateDemoObject(ged)
+	if CurrentMap == "" then
+		return
+	end
+	if ged and ged.context.lock_preset then
+		local obj = GedAutoAttachEditorLockedObject[ged]
+		obj:DestroyAutoAttaches()
+		obj:ClearAttachMembers()
+		AutoAttachObjects(GedAutoAttachEditorLockedObject[ged], "init")
+		return
+	end
+
+	local demo_obj = GedAutoAttachDemos[ged]
+	if not demo_obj or not IsValid(demo_obj) then
+		demo_obj = PlaceObject("AutoAttachPresetDemoObject")
+		local look_at = GetTerrainGamepadCursor()
+		look_at = look_at:SetZ(terrain.GetSurfaceHeight(look_at))
+		demo_obj:SetPos(look_at)
+	end
+	GedAutoAttachDemos[ged] = demo_obj
+	demo_obj:ChangeEntity(self.id)
+end
+
+function OnMsg.GedClosing(ged_id)
+	local demo_obj = GedAutoAttachDemos[GedConnections[ged_id]]
+	DoneObject(demo_obj)
+	GedAutoAttachDemos[GedConnections[ged_id]] = nil
+end
+
+function AutoAttachPreset:OnEditorSelect(selected, ged)
+	if selected then
+		self:UpdateSpotData()
+		self:RecreateDemoObject(ged)
+	end
+end
+
+function AutoAttachPreset:GetError()
+	if not self:GetEntitySpec() then
+		return "Could not find the ArtSpec."
+	end
+end
+
+function AutoAttachPreset:GetEntitySpec()
+	return FindArtSpecById(self.id)
+end
+
+function OnMsg.GedOpened(ged_id)
+	local ged = GedConnections[ged_id]
+	if ged and ged:ResolveObj("root") == Presets.AutoAttachPreset then
+		CreateRealTimeThread(GenerateMissingEntities)
+	end
+end
+
+function OpenAutoattachEditor(objlist, lock_entity)
+	if not IsRealTimeThread() then
+		CreateRealTimeThread(OpenAutoattachEditor, entity)
+		return
+	end
+	lock_entity = not not lock_entity
+	local target_entity
+	if objlist and objlist[1] and IsValid(objlist[1]) then
+		target_entity = objlist[1]
+	end
+
+	if not target_entity and lock_entity then
+		print("No entity selected.")
+		return
+	end
+
+	if target_entity then
+		GenerateMissingEntities() -- make sure all entities are generated. Otherwise the selection may fail
+	end
+	
+	local context = AutoAttachPreset:EditorContext()
+	context.lock_preset = lock_entity
+	local ged = OpenPresetEditor("AutoAttachPreset", context)
+	if target_entity then
+		ged:SetSelection("root", PresetGetPath(AutoAttachPresets[target_entity:GetEntity()]))
+		GedAutoAttachEditorLockedObject[ged] = target_entity
+	end
+end
+
+DefineClass.AutoAttachSIModulator =
+{
+	__parents = {"CObject", "PropertyObject"},
+	properties = {
+		{ id = "SIModulation", editor = "number", default = 100, min = 0, max = 255, slider = true, autoattach_prop = true },
+	}
+}
+
+function AutoAttachSIModulator:SetSIModulation(value)
+	local parent = self:GetParent()
+	if not parent.SIModulationManual then
+		parent:SetSIModulation(value)
+	end
+end

CommonLua/Classes/BaseObjects.lua

@@ -0,0 +1,376 @@
+----- UpdateObject
+
+DefineClass.UpdateObject = {
+	__parents = {"Object"},
+	
+	update_thread_on_init = true,
+	update_interval = 10000,
+	update_thread = false,
+}
+
+RecursiveCallMethods.OnObjUpdate = "call"
+
+local Sleep = Sleep
+local procall = procall
+local GameTime = GameTime
+function UpdateObject:Init()
+	if self.update_thread_on_init then
+		self:StartObjUpdateThread()
+	end
+end
+
+function UpdateObject:ObjUpdateProc(update_interval)
+	self:InitObjUpdate(update_interval)
+	while true do
+		procall(self.OnObjUpdate, self, GameTime(), update_interval)
+		Sleep(update_interval)
+	end
+end
+
+function UpdateObject:StartObjUpdateThread()
+	if not self:IsSyncObject() or not mapdata.GameLogic or not self.update_interval then
+		return
+	end
+	DeleteThread(self.update_thread)
+	self.update_thread = CreateGameTimeThread(self.ObjUpdateProc, self, self.update_interval)
+	if Platform.developer then
+		ThreadsSetThreadSource(self.update_thread, "ObjUpdateThread", self.ObjUpdateProc)
+	end
+end
+
+function UpdateObject:StopObjUpdateThread()
+	DeleteThread(self.update_thread)
+	self.update_thread = nil
+end
+
+function UpdateObject:InitObjUpdate(update_interval)
+	Sleep(1 + self:Random(update_interval, "InitObjUpdate"))
+end
+
+function UpdateObject:Done()
+	self:StopObjUpdateThread()
+end
+
+
+----- ReservedObject
+
+DefineClass.ReservedObject = {
+	__parents = { "InitDone" },
+	properties = {
+		{ id = "reserved_by", editor = "object", default = false, no_edit = true },
+	},
+}
+
+function TryInterruptReserved(reserved_obj)
+	local reserved_by = reserved_obj.reserved_by
+	if IsValid(reserved_by) then
+		return reserved_by:OnReservationInterrupted()
+	end 
+	reserved_obj.reserved_by = nil
+end
+
+ReservedObject.Disown = TryInterruptReserved
+
+AutoResolveMethods.CanReserverBeInterrupted = "or"
+ReservedObject.CanReserverBeInterrupted = empty_func
+
+function ReservedObject:CanBeReservedBy(obj)
+	return not self.reserved_by or self.reserved_by == obj or self:CanReserverBeInterrupted(obj)
+end
+
+function ReservedObject:TryReserve(reserved_by)
+	if not self:CanBeReservedBy(reserved_by) then return false end
+	if self.reserved_by and self.reserved_by ~= reserved_by then
+		if not TryInterruptReserved(self) then return end
+	end
+	return self:Reserve(reserved_by)
+end
+
+function ReservedObject:Reserve(reserved_by)
+	assert(IsKindOf(reserved_by, "ReserverObject"))
+	local previous_reservation = reserved_by.reserved_obj
+	if previous_reservation and previous_reservation ~= self then
+		--assert(not previous_reservation, "Reserver trying to reserve two objects at once!")
+		previous_reservation:CancelReservation(reserved_by)
+	end
+	self.reserved_by = reserved_by
+	reserved_by.reserved_obj = self
+	self:OnReserved(reserved_by)
+	return true
+end
+
+ReservedObject.OnReserved = empty_func
+ReservedObject.OnReservationCanceled = empty_func
+
+function ReservedObject:CancelReservation(reserved_by)
+	if self.reserved_by == reserved_by then
+		self.reserved_by = nil
+		reserved_by.reserved_obj = nil
+		self:OnReservationCanceled()
+		return true
+	end
+end
+
+function ReservedObject:Done()
+	self:Disown()
+end
+
+DefineClass.ReserverObject = {
+	__parents = { "CommandObject" },
+
+	reserved_obj = false,
+}
+
+function ReserverObject:OnReservationInterrupted()
+	return self:TrySetCommand("CmdInterrupt")
+end
+
+----- OwnedObject
+
+DefineClass.OwnershipStateBase = {
+	OnStateTick  = empty_func,
+	OnStateExit  = empty_func,
+
+	CanDisown    = empty_func,
+	CanBeOwnedBy = empty_func,
+}
+
+DefineClass("ConcreteOwnership", "OwnershipStateBase")
+
+local function SetOwnerObject(owned_obj, owner)
+	assert(not owner or IsKindOf(owner, "OwnerObject"))
+	owner = owner or false
+	local prev_owner = owned_obj.owner
+	if owner ~= prev_owner then
+		owned_obj.owner = owner
+		
+		local notify_owner = not prev_owner or prev_owner:GetOwnedObject(owned_obj.ownership_class) == owned_obj		
+		if notify_owner then
+			if prev_owner then
+				prev_owner:SetOwnedObject(false, owned_obj.ownership_class)
+			end
+			if owner then
+				owner:SetOwnedObject(owned_obj)
+			end
+		end
+	end
+end
+
+function ConcreteOwnership.OnStateTick(owned_obj, owner)
+	return SetOwnerObject(owned_obj, owner)
+end
+
+function ConcreteOwnership.OnStateExit(owned_obj)
+	return SetOwnerObject(owned_obj, false)
+end
+
+function ConcreteOwnership.CanDisown(owned_obj, owner, reason)
+	return owned_obj.owner == owner
+end
+
+function ConcreteOwnership.CanBeOwnedBy(owned_obj, owner, ...)
+	return owned_obj.owner == owner
+end
+
+DefineClass("SharedOwnership", "OwnershipStateBase")
+SharedOwnership.CanBeOwnedBy = return_true
+
+DefineClass("ForbiddenOwnership", "OwnershipStateBase")
+
+DefineClass.OwnedObject = {
+	__parents = { "ReservedObject" },
+	properties = {
+		{ id = "owner",                                               editor = "object", default = false, no_edit = true },
+		{ id = "can_change_ownership", name = "Can change ownership", editor = "bool",   default = true,  help = "If true, the player can change who owns the object", },
+		{ id = "ownership_class",      name = "Ownership class",      editor = "combo",  default = false, items = GatherComboItems("GatherOwnershipClasses"), },
+	},
+	
+	ownership = "SharedOwnership",
+}
+
+AutoResolveMethods.CanDisown = "and"
+function OwnedObject:CanDisown(owner, reason)
+	return g_Classes[self.ownership].CanDisown(self, owner, reason)
+end
+
+function OwnedObject:Disown()
+	ReservedObject.Disown(self)
+	self:TrySetSharedOwnership()
+end
+
+AutoResolveMethods.CanBeOwnedBy = "and"
+function OwnedObject:CanBeOwnedBy(obj, ...)
+	if not self:CanBeReservedBy(obj) then return end
+	return g_Classes[self.ownership].CanBeOwnedBy(self, obj, ...)
+end
+
+AutoResolveMethods.CanChangeOwnership = "and"
+function OwnedObject:CanChangeOwnership()
+	return self.can_change_ownership
+end
+
+function OwnedObject:GetReservedByOrOwner()
+	return self.reserved_by or self.owner
+end
+
+OwnedObject.OnOwnershipChanged = empty_func
+
+function OwnedObject:TrySetOwnership(ownership, forced, ...)
+	assert(ownership)
+	if not ownership or not forced and not self:CanChangeOwnership() then return end
+	
+	local prev_owner = self.owner
+	local prev_ownership = self.ownership
+	self.ownership = ownership
+	if prev_ownership ~= ownership then
+		g_Classes[prev_ownership].OnStateExit(self, ...)
+	end
+	g_Classes[ownership].OnStateTick(self, ...)
+	self:OnOwnershipChanged(prev_ownership, prev_owner)
+end
+
+local function TryInterruptReservedOnDifferentOwner(owned_obj)
+	local reserved_by = owned_obj.reserved_by
+	if IsValid(reserved_by) and reserved_by ~= owned_obj.owner then
+		reserved_by:OnReservationInterrupted()
+		owned_obj.reserved_by = nil
+	end
+end
+
+local OwnershipChangedReactions = {
+	ConcreteOwnership = {
+		ConcreteOwnership  = TryInterruptReservedOnDifferentOwner,
+		ForbiddenOwnership = TryInterruptReserved,
+	},
+	SharedOwnership = {
+		ConcreteOwnership  = TryInterruptReservedOnDifferentOwner,
+		ForbiddenOwnership = TryInterruptReserved,
+	}
+}
+
+function OwnedObject:OnOwnershipChanged(prev_ownership, prev_owner)
+	local transition = table.get(OwnershipChangedReactions, prev_ownership, self.ownership)
+	if transition then
+		transition(self)
+	end
+end
+
+----- OwnedObject helper functions
+
+function OwnedObject:TrySetConcreteOwnership(forced, owner)
+	return self:TrySetOwnership("ConcreteOwnership", forced, owner)
+end
+
+function OwnedObject:SetConcreteOwnership(...)
+	return self:TrySetConcreteOwnership("forced", ...)
+end
+
+function OwnedObject:HasConcreteOwnership()
+	return self.ownership == "ConcreteOwnership"
+end
+
+function OwnedObject:TrySetSharedOwnership(forced, ...)
+	return self:TrySetOwnership("SharedOwnership", forced, ...)
+end
+
+function OwnedObject:SetSharedOwnership(...)
+	return self:TrySetSharedOwnership("forced", ...)
+end
+
+function OwnedObject:HasSharedOwnership()
+	return self.ownership == "SharedOwnership"
+end
+
+function OwnedObject:TrySetForbiddenOwnership(forced, ...)
+	return self:TrySetOwnership("ForbiddenOwnership", forced, ...)
+end
+
+function OwnedObject:SetForbiddenOwnership(...)
+	return self:TrySetForbiddenOwnership("forced", ...)
+end
+
+function OwnedObject:HasForbiddenOwnership()
+	return self.ownership == "ForbiddenOwnership"
+end
+
+----- OwnedObject helper functions end
+
+DefineClass.OwnedByUnit = {
+	__parents = { "OwnedObject" },
+	properties = {
+		{ id = "can_have_dead_owners", name = "Can have dead owners", editor = "bool", default = false, help = "If true, the object can have dead units as owners", },
+	}
+}
+
+function OwnedByUnit:CanBeOwnedBy(obj, ...)
+	if not self.can_have_dead_owners and obj:IsDead() then return end
+	return OwnedObject.CanBeOwnedBy(self, obj, ...)
+end
+
+DefineClass.OwnerObject = {
+	__parents = { "ReserverObject" },
+	owned_objects = false,
+}
+
+function OwnerObject:Init()
+	self.owned_objects = {}
+end
+
+function OwnerObject:Owns(object)
+	local ownership_class = object.ownership_class
+	if not ownership_class then return end
+	return self.owned_objects[ownership_class] == object
+end
+
+function OwnerObject:DisownObjects(reason)
+	local owned_objects = self.owned_objects
+	for _, ownership_class in ipairs(owned_objects) do
+		local owned_object = owned_objects[ownership_class]
+		if owned_object and owned_object:CanDisown(self, reason) then
+			owned_object:Disown()
+		end
+	end
+end
+
+function OwnerObject:GetOwnedObject(ownership_class)
+	assert(ownership_class)
+	return self.owned_objects[ownership_class]
+end
+
+function OwnerObject:SetOwnedObject(owned_obj, ownership_class)
+	assert(not owned_obj or owned_obj:IsKindOf("OwnedObject"))
+	if owned_obj then
+		ownership_class = ownership_class or owned_obj.ownership_class
+		assert(ownership_class == owned_obj.ownership_class)
+	end
+	assert(ownership_class)
+	if not ownership_class then
+		return false
+	end
+	local prev_owned_obj = self:GetOwnedObject(ownership_class)
+	if prev_owned_obj == owned_obj then
+		return false
+	end
+	local owned_objects = self.owned_objects
+	
+	owned_objects[ownership_class] = owned_obj
+	table.remove_entry(owned_objects, ownership_class)
+	if owned_obj then
+		table.insert(owned_objects, ownership_class)
+		if prev_owned_obj then
+			prev_owned_obj:TrySetSharedOwnership()
+		end
+		owned_obj:TrySetConcreteOwnership(nil, self)
+	end
+	return true
+end
+
+if Platform.developer then
+
+function OwnedObject:GetTestData(data)
+	data.ReservedBy = self.reserved_by
+end
+
+end
+
+-----

CommonLua/Classes/BlendEntityObj.lua

@@ -0,0 +1,115 @@
+DefineClass.BlendEntityObj = {
+	__parents = { "Object" },
+	properties = {
+		{ category = "Blend", id = "BlendEntity1", name = "Entity 1", editor = "choice", default = "Human_Head_M_As_01", items = function (obj) return obj:GetBlendEntityList() end },
+		{ category = "Blend", id = "BlendWeight1", name = "Weight 1", editor = "number", default = 50, slider = true, min = 0, max = 100 },
+		{ category = "Blend", id = "BlendEntity2", name = "Entity 2", editor = "choice", default = "", items = function (obj) return obj:GetBlendEntityList() end },
+		{ category = "Blend", id = "BlendWeight2", name = "Weight 2", editor = "number", default = 0, slider = true, min = 0, max = 100 },
+		{ category = "Blend", id = "BlendEntity3", name = "Entity 3", editor = "choice", default = "", items = function (obj) return obj:GetBlendEntityList() end },
+		{ category = "Blend", id = "BlendWeight3", name = "Weight 3", editor = "number", default = 0, slider = true, min = 0, max = 100 },
+	},
+	entity = "Human_Head_M_Placeholder_01",
+}
+
+function BlendEntityObj:GetBlendEntityList()
+	return { "" }
+end
+
+local g_UpdateBlendObjs = {}
+local g_UpdateBlendEntityThread = false
+
+function GetEntityIdleMaterial(entity)
+	return entity and entity ~= "" and GetStateMaterial(entity, "idle") or ""
+end
+
+function BlendEntityObj:UpdateBlendInternal()
+	if (not self.BlendEntity1 or self.BlendWeight1 == 0) and
+	   (not self.BlendEntity2 or self.BlendWeight2 == 0) and
+	   (not self.BlendEntity3 or self.BlendWeight3 == 0) then
+	   return
+   end
+
+	local err = AsyncMeshBlend(self.entity, 0,
+		self.BlendEntity1, self.BlendWeight1, 
+		self.BlendEntity2, self.BlendWeight2,
+		self.BlendEntity3, self.BlendWeight3)
+	if err then print("Failed to blend meshes: ", err) end
+
+	do
+		local mat0 = GetEntityIdleMaterial(self.entity)
+		local mat1 = GetEntityIdleMaterial(self.BlendEntity1)
+		local mat2 = GetEntityIdleMaterial(self.BlendEntity2)
+		local mat3 = GetEntityIdleMaterial(self.BlendEntity3)
+		assert(mat0 ~= mat1 and mat0 ~= mat2 and mat0 ~= mat3)
+	end
+	
+	local sumBlends = self.BlendWeight1 + self.BlendWeight2 + self.BlendWeight2
+	local blend2, blend3 = 0, 0
+	if sumBlends ~= self.BlendWeight1 then
+		blend2 = self.BlendWeight2 * 100 / (sumBlends - self.BlendWeight1)
+		blend3 = self.BlendWeight3 * 100 / sumBlends
+	end
+	SetMaterialBlendMaterials(GetEntityIdleMaterial(self.entity),
+		GetEntityIdleMaterial(self.BlendEntity1), blend2,
+		GetEntityIdleMaterial(self.BlendEntity2), blend3,
+		GetEntityIdleMaterial(self.BlendEntity3))
+		
+	self:ChangeEntity(self.entity)
+end
+
+function BlendEntityObj:UpdateBlend()
+	g_UpdateBlendObjs[self] = true
+	if not g_UpdateBlendEntityThread then
+		g_UpdateBlendEntityThread = CreateRealTimeThread(function()
+			while true do
+				local obj, v = next(g_UpdateBlendObjs)
+				if obj == nil then
+					break
+				end
+				g_UpdateBlendObjs[obj] = nil
+				obj:UpdateBlendInternal()
+			end
+			g_UpdateBlendEntityThread = false
+		end)
+	end
+end
+
+function BlendEntityObj:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "BlendEntity1" or prop_id == "BlendEntity2" or prop_id == "BlendEntity3"
+		or prop_id == "BlendWeight1" or prop_id == "BlendWeight2" or prop_id == "BlendWeight3"
+	then
+		self:UpdateBlend()
+	end
+end
+
+function BlendTest()
+	local obj = BlendEntityObj:new()
+	obj:SetPos(GetTerrainCursor())
+	ViewObject(obj)
+	editor.ClearSel()
+	editor.AddToSel({obj})
+	OpenGedGameObjectEditor(editor.GetSel())
+	return obj
+end
+
+function BlendMatTest(weight2, weight3)
+	local obj = PlaceObj("Jacket_Nylon_M_Slim_01")
+	obj:SetPos(GetTerrainCursor())
+	ViewObject(obj)
+	editor.ClearSel()
+	editor.AddToSel({obj})
+	
+	local blendEntity1 = "Jacket_Nylon_M_Slim_01"
+	local blendEntity2 = "Jacket_Nylon_M_Skinny_01"
+	local blendEntity3 = "Jacket_Nylon_M_Chubby_01"
+	
+	weight2 = weight2 or 50
+	weight3 = weight3 or 25
+	
+	SetMaterialBlendMaterials(GetEntityIdleMaterial(obj:GetEntity()),
+		GetEntityIdleMaterial(blendEntity1), weight2,
+		GetEntityIdleMaterial(blendEntity2), weight3,
+		GetEntityIdleMaterial(blendEntity3))
+		
+	return obj
+end

CommonLua/Classes/CameraEditor.lua

@@ -0,0 +1,261 @@
+if FirstLoad then
+	s_CameraFadeThread = false
+end
+
+function DeleteCameraFadeThread()
+	if s_CameraFadeThread then
+		DeleteThread(s_CameraFadeThread)
+		s_CameraFadeThread = false
+	end
+end
+
+function CameraShowClose(last_camera)
+	DeleteCameraFadeThread()
+	if last_camera then
+		last_camera:RevertProperties()
+	end	
+	UnlockCamera("CameraPreset")
+end
+
+function SwitchToCamera(camera, old_camera, in_between_callback, dont_lock, ged)
+	if not CanYield() then
+		DeleteCameraFadeThread()
+		s_CameraFadeThread = CreateRealTimeThread(function()
+			SwitchToCamera(camera, old_camera, in_between_callback, dont_lock, ged)
+		end)
+		return
+	end
+
+	if IsEditorActive() then
+		editor.ClearSel()
+		editor.AddToSel({camera})
+	end
+	if old_camera then
+		old_camera:RevertProperties(not(camera.flip_to_adjacent and old_camera.flip_to_adjacent))
+	end
+	if in_between_callback then
+		in_between_callback()
+	end
+	camera:ApplyProperties(dont_lock, not(camera.flip_to_adjacent and old_camera.flip_to_adjacent), ged)
+end
+
+function ShowPredefinedCamera(id)
+	local cam = PredefinedCameras[id]
+	if not cam then
+		print("No such camera preset: ", id)
+		return
+	end
+	CreateRealTimeThread(cam.ApplyProperties, cam, "dont_lock")
+end
+
+function GedOpCreateCameraDest(ged, selected_camera)
+	if not selected_camera or not IsKindOf(selected_camera, "Camera") then return end
+	selected_camera:SetDest(selected_camera)
+	GedObjectModified(selected_camera)
+end
+
+function GedOpUpdateCamera(ged, selected_camera)
+	if not selected_camera or not IsKindOf(selected_camera, "Camera") then return end
+	selected_camera:QueryProperties()
+	GedObjectModified(selected_camera)
+end
+
+function GedOpViewMovement(ged, selected_camera)
+	if not selected_camera or not IsKindOf(selected_camera, "Camera") then return end
+	SwitchToCamera(selected_camera, nil, nil, "don't lock")
+end
+
+function GedOpIsViewMovementToggled()
+	return not not GetDialog("Showcase")
+end
+
+local function TakeCameraScreenshot(ged, path, sector, camera)
+	if GetMapName() ~= camera.map then
+		ChangeMap(camera.map)
+	end
+	
+	camera:ApplyProperties()
+	local oldInterfaceInScreenshot = hr.InterfaceInScreenshot
+	hr.InterfaceInScreenshot = camera.interface and 1 or 0
+	
+	local image = string.format("%s/%s.png", path, sector)
+	AsyncFileDelete(image)
+	WaitNextFrame(3)
+	local store = {}
+	Msg("BeforeUpsampledScreenshot", store)
+	WaitNextFrame()
+	MovieWriteScreenshot(image, 0, 64, false, 3840, 2160)
+	WaitNextFrame()
+	Msg("AfterUpsampledScreenshot", store)
+	
+	hr.InterfaceInScreenshot = oldInterfaceInScreenshot
+	camera:RevertProperties()
+	return image
+end
+
+function GedOpTakeScreenshots(ged, camera)
+	if not camera then return end
+	
+	local campaign = Game and Game.Campaign or rawget(_G, "DefaultCampaign") or "HotDiamonds"
+	local campaign_presets = rawget(_G, "CampaignPresets") or empty_table
+	local sectors = campaign_presets[campaign] and campaign_presets[campaign].Sectors or empty_table
+	local map_to_sector = {[false] = ""}
+	for _, sector in ipairs(sectors) do
+		if sector.Map then
+			map_to_sector[sector.Map] = sector.Id
+		end
+	end
+	
+	local path = string.format("svnAssets/Source/UI/LoadingScreens/%s", campaign)
+	local err = AsyncCreatePath(path)
+	if err then
+		local os_path = ConvertToOSPath(path)
+		ged:ShowMessage("Error", string.format("Can't create '%s' folder!", os_path))
+		return
+	end
+	local ok, result = SVNAddFile(path)
+	if not ok then
+		ged:ShowMessage("SVN Error", result)
+	end
+	
+	StopAllHiding("CameraEditorScreenshots", 0, 0)
+	local size = UIL.GetScreenSize()
+	ChangeVideoMode(3840, 2160, 0, false, true)
+	WaitChangeVideoMode()
+	LockCamera("Screenshot")
+	
+	local images = {}
+	if IsKindOf(camera, "Camera") then
+		images[1] = TakeCameraScreenshot(ged, path, map_to_sector[camera.map], camera)
+	else
+		local cameras = IsKindOf(camera, "GedMultiSelectAdapter") and camera.__objects or camera
+		table.sort(cameras, function(a, b) return a.map < b.map end)
+		for _, cam in ipairs(cameras) do
+			table.insert(images, TakeCameraScreenshot(ged, path, map_to_sector[cam.map], cam))
+		end
+	end
+
+	UnlockCamera("Screenshot")
+	ChangeVideoMode(size:x(), size:y(), 0, false, true)
+	WaitChangeVideoMode()
+	ResumeAllHiding("CameraEditorScreenshots")
+	
+	local ok, result = SVNAddFile(images)
+	if not ok then
+		ged:ShowMessage("SVN Error", result)
+	end
+	print("Taking screenshots and adding to SubVersion done.")
+end
+
+function OnMsg.GedOnEditorSelect(obj, selected, ged_editor)
+	if obj and IsKindOf(obj, "Camera") and selected then 
+		SwitchToCamera(obj, IsKindOf(ged_editor.selected_object, "Camera") and ged_editor.selected_object, nil, "don't lock", ged_editor)
+	end
+end
+
+function GedOpUnlockCamera()
+	camera.Unlock()
+end
+
+function GedOpMaxCamera()
+	cameraMax.Activate(1)
+end
+
+function GedOpTacCamera()
+	cameraTac.Activate(1)
+end
+
+function GedOpRTSCamera()
+	cameraRTS.Activate(1)
+end
+
+function GedOpSaveCameras()
+	local class = _G["Camera"]
+	class:SaveAll("save all", "user request")
+end
+
+function GedOpCreateReferenceImages()
+	CreateReferenceImages()
+end
+
+-- run to save a screenshot with every camera at correct video mode!
+function CreateReferenceImages()
+	if not IsRealTimeThread() then
+		CreateRealTimeThread(CreateReferenceImages)
+		return
+	end
+	
+	local folder = "svnAssets/Tests/ReferenceImages"
+	local cameras = Presets.Camera["reference"]
+	SetMouseDeltaMode(true)
+	SetLightmodel(0, LightmodelPresets.ArtPreview, 0)
+	local size = UIL.GetScreenSize()
+	ChangeVideoMode(512, 512, 0, false, true)
+	WaitChangeVideoMode()
+	local created = 0
+	for _, cam in ipairs(cameras) do
+		if GetMapName() ~= cam.map then
+			ChangeMap(cam.map)
+		end
+		cam:ApplyProperties()
+		Sleep(3000)
+		AsyncCreatePath(folder)
+		local image = string.format("%s/%s.png", folder, cam.id)
+		AsyncFileDelete(image)
+		if not WriteScreenshot(image, 512, 512) then
+			print(string.format("Failed to create screenshot '%s'", image))
+		else
+			created = created + 1
+		end
+		Sleep(300)
+		cam:RevertProperties()
+	end
+	SetMouseDeltaMode(false)
+	ChangeVideoMode(size:x(), size:y(), 0, false, true)
+	WaitChangeVideoMode()
+	print(string.format("Creating %d reference images in '%s' finished.", created, folder))
+end
+
+function GetShowcaseCameras(context)
+	local cameras = Presets.Camera[context and context.group or "reference"] or {}
+	table.sort(cameras, function(a, b) 
+		if a.map==b.map then		
+			return a.order < b.order 
+		else 
+			return a.map<b.map 
+		end	
+	end)
+	
+	return cameras
+end
+
+function OpenShowcase(root, obj, context)
+	if GetDialog("Showcase") then
+		CloseDialog("Showcase")
+		return
+	end
+	
+	if obj and IsKindOf(obj, "Camera") then
+		local group = obj.group
+		context = context or {}
+		context.group = group
+	elseif obj and type(obj)== "table" and next(obj) then
+		local group = obj[1].group
+		context = context or {}
+		context.group = group
+	end
+	OpenDialog("Showcase", nil, context)	
+end
+
+function OnMsg.GameEnterEditor()
+	CloseDialog("Showcase")
+end
+
+function IsCameraEditorOpened()
+	local ged = FindGedApp("PresetEditor")
+	if not ged then return end
+	
+	local sel = type(ged.selected_object) == "table" and ged.selected_object[1] or ged.selected_object
+	
+	return IsKindOf(sel, "Camera")
+end

CommonLua/Classes/CharacterControl.lua

@@ -0,0 +1,1065 @@
+if FirstLoad then
+	LocalPlayersCount = 0
+end
+
+DefineClass.CharacterControl = {
+	__parents = { "OldTerminalTarget", "InitDone" },
+	active = false,
+	character = false,
+	camera_active = true,
+	terminal_target_priority = -500,
+}
+
+function CharacterControl:Init(character)
+	self.character = character
+	terminal.AddTarget(self)
+end
+
+function CharacterControl:Done()
+	terminal.RemoveTarget(self)
+	self:SetActive(false)
+end
+
+function CharacterControl:SetActive(active)
+	if self.active == active then
+		return
+	end
+	if active then
+		self.active = active
+		self:OnActivate()
+	else
+		self.active = active
+		self:OnInactivate()
+	end
+	ChangeGameState("CharacterControl", active)
+end
+
+function CharacterControl:SetCameraActive(active)
+	self.camera_active = active
+end
+
+function CharacterControl:OnActivate()
+	self:SyncWithCharacter()
+end
+
+function CharacterControl:OnInactivate()
+	if not IsPaused() then
+		self:SyncWithCharacter()
+	end
+end
+
+function CharacterControl:GetBindingValue(binding)
+end
+
+function CharacterControl:GetActionBindings(action)
+end
+
+function CharacterControl:GetActionBinding1(action)
+	local bindings = self:GetActionBindings(action)
+	local binding = bindings and bindings[1]
+	return binding and (binding.xbutton or binding.key or binding.mouse_button)
+end
+
+function CharacterControl:GetBindingsCombinedValue(action)
+	local bindings = self:GetActionBindings(action)
+	if not bindings then return end
+	local best_value
+	for i = 1, #bindings do
+		local value = self:GetBindingValue(bindings[i])
+		if value then
+			if value == true then
+				return true
+			elseif type(value) == "number" then
+				best_value = Max(value, best_value or 0)
+			elseif IsPoint(value) then
+				if not best_value or value:Len2() > best_value:Len2() then
+					best_value = value
+				end
+			end	
+		end
+	end
+	return best_value
+end
+
+function CharacterControl:CallBindingsDown(bindings, param, time)
+	for i = 1, #bindings do
+		local binding = bindings[i]
+		if self:BindingModifiersActive(binding) then
+			local result = binding.func(self.character, self, param, time)
+			if result ~= "continue" then
+				return result
+			end
+		end
+	end
+	return "continue"
+end
+
+function CharacterControl:CallBindingsUp(bindings)
+	for i = 1, #bindings do
+		local binding = bindings[i]
+		local value = self:GetBindingsCombinedValue(binding.action)
+		if not value then
+			local result = binding.func(self.character, self)
+			if result ~= "continue" then
+				return result
+			end
+		end
+	end
+	return "continue"
+end
+
+function CharacterControl:SyncBindingsWithCharacter(bindings)
+	for i = 1, #bindings do
+		local binding = bindings[i]
+		local value = binding.action and self:GetBindingsCombinedValue(binding.action)
+		binding.func(self.character, self, value)
+	end
+end
+
+function CharacterControl:SyncWithCharacter()
+end
+
+function BindToKeyboardAndMouseSync(action)
+	local class = _G["CCA_"..action]
+	assert(class)
+	if class then
+		class:BindToControllerSync(action, CC_KeyboardAndMouseSync)
+	end
+end
+
+function BindToXboxControllerSync(action)
+	local class = _G["CCA_"..action]
+	assert(class)
+	if class then
+		class:BindToControllerSync(action, CC_XboxControllerSync)
+	end
+end
+
+-- CharacterControlAction
+
+DefineClass.CharacterControlAction = {
+	__parents = {},
+	ActionStop = false,
+	IsKindOf = IsKindOf,
+	HasMember = PropObjHasMember,
+}
+
+function CharacterControlAction:Action(character)
+	print("No Action defined: " .. self.class)
+	return "continue"
+end
+function OnMsg.ClassesPostprocess()
+	ClassDescendants("CharacterControlAction", function(class_name, class)
+		if class.GetAction == CharacterControlAction.GetAction and class.Action then
+			local f = function(...)
+				return class:Action(...)
+			end
+			class.GetAction = function() return f end
+		end
+		if class.GetActionSync == CharacterControlAction.GetActionSync and class.ActionStop then
+			local action_name = string.sub(class_name, #"CCA_" + 1)
+			local function f(character, controller)
+				local value = controller:GetBindingsCombinedValue(action_name)
+				if not value then
+					class:ActionStop(character, controller)
+				end
+				return "continue"
+			end
+			class.GetActionSync = function() return f end
+		end
+	end)
+end
+function CharacterControlAction:GetAction()
+end
+function CharacterControlAction:GetActionSync()
+end
+
+function CharacterControlAction:BindToControllerSync(action, bindings)
+	local f = self:GetActionSync()
+	if f and not table.find(bindings, "func", f) then
+		table.insert(bindings, { action = action, func = f })
+	end
+end
+
+function CharacterControlAction:BindKey(action, key, mod1, mod2)
+	local f = self:GetAction()
+	if f then
+		if mod1 == "double-click" then
+			BindToKeyboardEvent(action, "double-click", f, key, mod2)
+		elseif mod1 == "hold" then
+			BindToKeyboardEvent(action, "hold", f, key, mod2)
+		else
+			BindToKeyboardEvent(action, "down", f, key, mod1, mod2)
+		end
+	end
+	if mod1 == "double-click" or mod1 == "hold" then
+		mod1, mod2 = mod2, nil
+	end
+	f = self:GetActionSync()
+	if f then
+		BindToKeyboardEvent(action, "up", f, key)
+		if mod1 then
+			BindToKeyboardEvent(action, "up", f, mod1)
+		end
+		if mod2 then
+			BindToKeyboardEvent(action, "up", f, mod2)
+		end
+	end
+end
+
+function CharacterControlAction:BindMouse(action, button, key_mod)
+	assert(key_mod ~= "double-click" and key_mod ~= "hold", "Not supported mouse modifiers")
+	local f = self:GetAction()
+	if f then
+		if button == "MouseMove" then
+			BindToMouseEvent(action, "mouse_move", f, nil, key_mod)
+		else
+			BindToMouseEvent(action, "down", f, button, key_mod)
+		end
+	end
+	f = self:GetActionSync()
+	if f then
+		if button ~= "MouseMove" then
+			BindToMouseEvent(action, "up", f, button)
+		end
+		if key_mod then
+			BindToKeyboardEvent(action, "up", f, key_mod)
+		end
+	end
+end
+
+function CharacterControlAction:BindXboxController(action, button, mod1, mod2)
+	local f = self:GetAction()
+	if f then
+		if mod1 == "hold" then
+			BindToXboxControllerEvent(action, "hold", f, button, mod2)
+		else
+			BindToXboxControllerEvent(action, "down", f, button, mod1, mod2)
+		end
+	end
+	if mod1 == "hold" then
+		mod1, mod2 = mod2, nil
+	end
+	f = self:GetActionSync()
+	if f then
+		BindToXboxControllerEvent(action, "up", f, button)
+		if mod1 then
+			BindToXboxControllerEvent(action, "up", f, mod1)
+		end
+		if mod2 then
+			BindToXboxControllerEvent(action, "up", f, mod2)
+		end
+	end
+end
+
+-- Navigation
+
+if FirstLoad then
+	UpdateCharacterNavigationThread = false
+end
+
+function OnMsg.DoneMap()
+	UpdateCharacterNavigationThread = false
+end
+
+local function CalcNavigationVector(controller, camera_view)
+	local pt = controller:GetBindingsCombinedValue("Move_Direction")
+	if pt then
+		return Rotate(pt:SetX(-pt:x()), XControlCameraGetYaw(camera_view) - 90*60)
+	end
+	local x = (controller:GetBindingsCombinedValue("Move_CameraRight") and 32767 or 0) + (controller:GetBindingsCombinedValue("Move_CameraLeft") and -32767 or 0)
+	local y = (controller:GetBindingsCombinedValue("Move_CameraForward") and 32767 or 0) + (controller:GetBindingsCombinedValue("Move_CameraBackward") and -32767 or 0)
+	if x ~= 0 or y ~= 0 then
+		return Rotate(point(-x,y), XControlCameraGetYaw(camera_view) - 90*60)
+	end
+end
+
+function UpdateCharacterNavigation(character, controller)
+	local dir = CalcNavigationVector(controller, character.camera_view)
+	character:SetStateContext("navigation_vector", dir)
+	if dir and not IsValidThread(UpdateCharacterNavigationThread) then
+		UpdateCharacterNavigationThread = CreateMapRealTimeThread(function()
+			repeat
+				Sleep(20)
+				if IsPaused() then break end
+				local update
+				for loc_player = 1, LocalPlayersCount do
+					local o = PlayerControlObjects[loc_player]
+					if o and o.controller then
+						local dir = CalcNavigationVector(o.controller, o.camera_view)
+						o:SetStateContext("navigation_vector", dir)
+						update = update or dir and true
+					end
+				end
+			until not update
+			UpdateCharacterNavigationThread = false
+		end)
+	end
+	return "continue"
+end
+
+DefineClass("CCA_Navigation", "CharacterControlAction")
+DefineClass("CCA_Move_CameraForward", "CCA_Navigation")
+DefineClass("CCA_Move_CameraBackward", "CCA_Navigation")
+DefineClass("CCA_Move_CameraLeft", "CCA_Navigation")
+DefineClass("CCA_Move_CameraRight", "CCA_Navigation")
+
+function CCA_Navigation:BindKey(action, key)
+	BindToKeyboardEvent(action, "down", UpdateCharacterNavigation, key)
+	BindToKeyboardEvent(action, "up", UpdateCharacterNavigation, key)
+end
+function CCA_Navigation:BindXboxController(action, button)
+	BindToXboxControllerEvent(action, "down", UpdateCharacterNavigation, button)
+	BindToXboxControllerEvent(action, "up", UpdateCharacterNavigation, button)
+end
+function CCA_Navigation:GetActionSync()
+	return UpdateCharacterNavigation
+end
+
+-- Move_Direction
+DefineClass("CCA_Move_Direction", "CharacterControlAction")
+function CCA_Move_Direction:BindKey(action, key, mod1, mod2)
+	assert(false, "Can't bind 2D direction to a key")
+end
+function CCA_Move_Direction:BindMouse(action, button, key_mod)
+	assert(false, "Mouse cursor could be converted to a direction. Not implemented.")
+end
+function CCA_Move_Direction:BindXboxController(action, button)
+	assert(button == "LeftThumb" or button == "RightThumb")
+	BindToXboxControllerEvent(action, "change", UpdateCharacterNavigation, button)
+end
+function CCA_Move_Direction:GetActionSync()
+	return UpdateCharacterNavigation
+end
+
+-- RotateCamera
+function UpdateCameraRotate(character, controller)
+	if not g_LookAtObjectSA then
+		local dir = (controller:GetBindingsCombinedValue("CameraRotate_Left") and -1 or 0) + (controller:GetBindingsCombinedValue("CameraRotate_Right") and 1 or 0)
+		camera3p.SetAutoRotate(90*60*dir)
+	end
+	return "continue"
+end
+
+DefineClass("CCA_CameraRotate", "CharacterControlAction")
+DefineClass("CCA_CameraRotate_Left", "CCA_CameraRotate")
+DefineClass("CCA_CameraRotate_Right", "CCA_CameraRotate")
+
+function CCA_CameraRotate:BindKey(action, key)
+	BindToKeyboardEvent(action, "down", UpdateCameraRotate, key)
+	BindToKeyboardEvent(action, "up", UpdateCameraRotate, key)
+end
+function CCA_CameraRotate:BindXboxController(action, button)
+	BindToXboxControllerEvent(action, "down", UpdateCameraRotate, button)
+	BindToXboxControllerEvent(action, "up", UpdateCameraRotate, button)
+end
+function CCA_CameraRotate:GetActionSync()
+	return UpdateCameraRotate
+end
+
+if FirstLoad then
+	InGameMouseCursor = false
+end
+
+-- CameraRotate_Mouse
+DefineClass("CCA_CameraRotate_Mouse", "CharacterControlAction")
+function CCA_CameraRotate_Mouse:Action(character)
+	if not (character and character.controller and character.controller.camera_active) then
+		return "continue"
+	end
+	if InGameMouseCursor then
+		HideMouseCursor("InGameCursor") -- although MouseRotate(true) hides the mouse, IsMouseCursorHidden() depends on it
+	else
+		SetMouseDeltaMode(false)
+	end
+	MouseRotate(true)
+	Msg("CameraRotateStart", "mouse")
+	return "break"
+end
+function CCA_CameraRotate_Mouse:ActionStop(character)
+	MouseRotate(false)
+	if InGameMouseCursor then
+		ShowMouseCursor("InGameCursor")
+	else
+		HideMouseCursor("InGameCursor")
+		SetMouseDeltaMode(true) -- prevents the mouse to leave the game window
+	end
+	Msg("CameraRotateStop", "mouse")
+	return "continue"
+end
+function CCA_CameraRotate_Mouse:GetActionSync(character, controller)
+	local function f(character, controller)
+		local value = not CameraLocked and (MouseRotateCamera == "always" or controller:GetBindingsCombinedValue("CameraRotate_Mouse"))
+		if value then
+			return self:Action(character, controller)
+		else
+			return self:ActionStop(character, controller)
+		end
+	end
+	return f
+end
+
+-- KeyboardAndMouse Control
+
+DefineClass.CC_KeyboardAndMouse = {
+	__parents = { "CharacterControl" },
+	KeyHoldButtonTime = 350,
+	KeyDoubleClickTime = 300,
+	key_hold_thread = false,
+	key_last_double_click = false,
+	key_last_double_click_time = 0,
+}
+
+function CC_KeyboardAndMouse:OnActivate()
+	CharacterControl.OnActivate(self)
+	if InGameMouseCursor then
+		ShowMouseCursor("InGameCursor")
+	end
+end
+
+function CC_KeyboardAndMouse:OnInactivate()
+	CharacterControl.OnInactivate(self)
+	DeleteThread(self.key_hold_thread)
+	self.key_hold_thread = nil
+	self.key_last_double_click = nil
+	self.key_last_double_click_time = nil
+	HideMouseCursor("InGameCursor")
+	MouseRotate(false)
+end
+
+function CC_KeyboardAndMouse:SetCameraActive(active)
+	CharacterControl.SetCameraActive(self, active)
+	if self.active and not self.camera_active then
+		MouseRotate(false)
+	end
+end
+
+function CC_KeyboardAndMouse:GetActionBindings(action)
+	return CC_KeyboardAndMouse_ActionBindings[action]
+end
+
+function CC_KeyboardAndMouse:GetBindingValue(binding)
+	if not self.active or binding.key and not terminal.IsKeyPressed(binding.key) then
+		return false
+	end
+	if binding.mouse_button then
+		local pressed = self:IsMouseButtonPressed(binding.mouse_button)
+		if pressed == false then
+			return false
+		end
+	end
+	if not self:BindingModifiersActive(binding) then
+		return false
+	end
+	return true
+end
+
+function CC_KeyboardAndMouse:IsMouseButtonPressed(button)
+	local pressed, _
+	if button == "LButton" then
+		pressed = terminal.IsLRMX1X2MouseButtonPressed()
+	elseif button == "RButton" then
+		_, pressed = terminal.IsLRMX1X2MouseButtonPressed()
+	elseif button == "MButton" then
+		_, _, pressed = terminal.IsLRMX1X2MouseButtonPressed()
+	elseif button == "XButton1" then
+		_, _, _, pressed = terminal.IsLRMX1X2MouseButtonPressed()
+	elseif button == "XButton2" then
+		_, _, _, _, pressed = terminal.IsLRMX1X2MouseButtonPressed()
+	elseif button == "MouseWheelFwd" or button == "MouseWheelBack" then
+		return false
+	end
+	return pressed
+end
+
+function CC_KeyboardAndMouse:BindingModifiersActive(binding)
+	local keys = binding.key_modifiers
+	if keys then
+		for i = 1, #keys do
+			local key_or_button = keys[i]
+			if key_or_button == "MouseWheelFwd" or key_or_button == "MouseWheelBack" then
+				return false
+			end
+			local pressed = self:IsMouseButtonPressed(key_or_button)
+			if pressed == nil then
+				pressed = terminal.IsKeyPressed(key_or_button)
+			end
+			if not pressed then
+				return false
+			end
+		end
+	end
+	return true
+end
+
+-- keyboard events
+function CC_KeyboardAndMouse:OnKbdKeyDown(virtual_key, repeated, time)
+	if repeated or not self.active then
+		return "continue"
+	end
+	-- double click
+	if CC_KeyboardKeyDoubleClick[virtual_key] then
+		if self.key_last_double_click == virtual_key and RealTime() - self.key_last_double_click_time < self.KeyDoubleClickTime then
+			self.key_last_double_click = false
+			self:CallBindingsDown(CC_KeyboardKeyDoubleClick[virtual_key], true, time)
+		else
+			self.key_last_double_click = virtual_key
+			self.key_last_double_click_time = RealTime()
+		end
+	end
+	-- hold
+	if CC_KeyboardKeyHold[virtual_key] then
+		DeleteThread(self.key_hold_thread)
+		self.key_hold_thread = CreateRealTimeThread(function(self, virtual_key, time)
+			Sleep(self.KeyHoldButtonTime)
+			self.key_hold_thread = false
+			if terminal.IsKeyPressed(virtual_key) then
+				self:CallBindingsDown(CC_KeyboardKeyHold[virtual_key], true, time)
+			end
+		end, self, virtual_key, time)
+	end
+	-- down
+	local result
+	if CC_KeyboardKeyDown[virtual_key] then
+		result = self:CallBindingsDown(CC_KeyboardKeyDown[virtual_key], true, time)
+	end
+	return result or "continue"
+end
+
+function CC_KeyboardAndMouse:OnKbdKeyUp(virtual_key)
+	if not self.active then
+		return "continue"
+	end
+	if CC_KeyboardKeyHold[virtual_key] and self.key_hold_thread then
+		DeleteThread(self.key_hold_thread)
+		self.key_hold_thread = false
+	end
+	if CC_KeyboardKeyUp[virtual_key] then
+		local result = self:CallBindingsUp(CC_KeyboardKeyUp[virtual_key])
+		return result
+	end
+	return "continue"
+end
+
+-- mouse events
+
+function CC_KeyboardAndMouse:OnMouseButtonDown(button, pt, time)
+	if not self.active then
+		return "continue"
+	end
+	if CC_MouseButtonDown[button] then
+		local result = self:CallBindingsDown(CC_MouseButtonDown[button], true, time)
+		if result ~= "continue" then
+			return result
+		end
+	end
+	return "continue"
+end
+
+function CC_KeyboardAndMouse:OnMouseButtonUp(button, pt, time)
+	if not self.active then
+		return "continue"
+	end
+	if CC_MouseButtonUp[button] then
+		local result = self:CallBindingsUp(CC_MouseButtonUp[button], false, time)
+		if result ~= "continue" then
+			return result
+		end
+	end
+	return "continue"
+end
+
+function CC_KeyboardAndMouse:OnLButtonDown(...)
+	return self:OnMouseButtonDown("LButton", ...)
+end
+function CC_KeyboardAndMouse:OnLButtonUp(...)
+	return self:OnMouseButtonUp("LButton", ...)
+end
+function CC_KeyboardAndMouse:OnLButtonDoubleClick(...)
+	return self:OnMouseButtonDown("LButton", ...)
+end
+function CC_KeyboardAndMouse:OnRButtonDown(...)
+	return self:OnMouseButtonDown("RButton", ...)
+end
+function CC_KeyboardAndMouse:OnRButtonUp(...)
+	return self:OnMouseButtonUp("RButton", ...)
+end
+function CC_KeyboardAndMouse:OnRButtonDoubleClick(...)
+	return self:OnMouseButtonDown("RButton", ...)
+end
+function CC_KeyboardAndMouse:OnMButtonDown(...)
+	return self:OnMouseButtonDown("MButton", ...)
+end
+function CC_KeyboardAndMouse:OnMButtonUp(...)
+	return self:OnMouseButtonUp("MButton", ...)
+end
+function CC_KeyboardAndMouse:OnMButtonDoubleClick(...)
+	return self:OnMouseButtonDown("MButton", ...)
+end
+function CC_KeyboardAndMouse:OnXButton1Down(...)
+	return self:OnMouseButtonDown("XButton1", ...)
+end
+function CC_KeyboardAndMouse:OnXButton1Up(...)
+	return self:OnMouseButtonUp("XButton1", ...)
+end
+function CC_KeyboardAndMouse:OnXButton1DoubleClick(...)
+	return self:OnMouseButtonDown("XButton1", ...)
+end
+function CC_KeyboardAndMouse:OnXButton2Down(...)
+	return self:OnMouseButtonDown("XButton2", ...)
+end
+function CC_KeyboardAndMouse:OnXButton2Up(...)
+	return self:OnMouseButtonUp("XButton2", ...)
+end
+function CC_KeyboardAndMouse:OnXButton2DoubleClick(...)
+	return self:OnMouseButtonDown("XButton2", ...)
+end
+
+function CC_KeyboardAndMouse:OnMouseWheelForward(pt, time)
+	if not self.active then
+		return "continue"
+	end
+	local result = self:CallBindingsDown(CC_MouseWheelFwd, true, time)
+	if result ~= "break" then
+		result = self:CallBindingsDown(CC_MouseWheel, 1, time)
+	end
+	return result
+end
+function CC_KeyboardAndMouse:OnMouseWheelBack(pt, time)
+	if not self.active then
+		return "continue"
+	end
+	local result = self:CallBindingsDown(CC_MouseWheelBack, true, time)
+	if result ~= "break" then
+		result = self:CallBindingsDown(CC_MouseWheel, -1, time)
+	end
+	return result
+end
+
+function CC_KeyboardAndMouse:OnMousePos(pt, time)
+	if not self.active then
+		return "continue"
+	end
+	local result = self:CallBindingsDown(CC_MouseMove, pt, time)
+	return result
+end
+
+function CC_KeyboardAndMouse:SyncWithCharacter()
+	self:SyncBindingsWithCharacter(CC_KeyboardAndMouseSync)
+end
+
+local function ResetKeyboardAndMouseBindings()
+	CC_KeyboardKeyDown = {}
+	CC_KeyboardKeyUp = {}
+	CC_KeyboardKeyHold = {}
+	CC_KeyboardKeyDoubleClick = {}
+	CC_MouseButtonDown = {}
+	CC_MouseButtonUp = {}
+	CC_MouseWheel = {}
+	CC_MouseWheelFwd = {}
+	CC_MouseWheelBack = {}
+	CC_MouseMove = {}
+	CC_KeyboardAndMouse_ActionBindings = {}
+	CC_KeyboardAndMouseSync = {}
+end
+
+if FirstLoad then
+	ResetKeyboardAndMouseBindings()
+end
+
+function BindKey(action, key, mod1, mod2)
+	local class = _G["CCA_"..action]
+	assert(class)
+	if class then
+		class:BindKey(action, key, mod1, mod2)
+	end
+end
+
+function BindMouse(action, button, key_mod)
+	local class = _G["CCA_"..action]
+	assert(class)
+	if class then
+		class:BindMouse(action, button, key_mod)
+	end
+end
+
+local function ResolveRefBindings(list, bindings)
+	for i = 1, #list do
+		local action = list[i][1]
+		local blist = bindings[action]
+		for j = #blist, 1, -1 do
+			local binding = blist[j]
+			for k = #binding, 1, -1 do
+				local ref = bindings[binding[k]]
+				if ref then
+					if #ref == 0 then
+						table.remove(blist,j)
+					else
+						table.remove(binding, k)
+						for m = 2, #ref do
+							table.insert(blist, j, table.copy(binding))
+						end
+						for m = 1, #ref do
+							local rt = ref[m]
+							local binding_mod = blist[j+m-1]
+							for n = #rt, 1, -1 do
+								table.insert(binding_mod, k+n-1, rt[n])
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end
+
+function ReloadKeyboardAndMouseBindings(default_bindings, predefined_bindings)
+	ResetKeyboardAndMouseBindings()
+	if not default_bindings then
+		return
+	end
+	local bindings = {}
+	for i = 1, #default_bindings do
+		local default_list = default_bindings[i]
+		local action = default_list[1]
+		bindings[action] = {}
+		local predefined_list = predefined_bindings and predefined_bindings[action]
+		for j = 1, Max(predefined_list and #predefined_list or 0, #default_list-1) do
+			local binding = predefined_list and predefined_list[j] or nil
+			if binding == nil then
+				binding = default_list and default_list[j+1]
+			end
+			if binding and #binding > 0 then
+				local t = {}
+				for k = 1, #binding do
+					t[k] = type(binding[k]) == "string" and const["vk"..binding[k]] or binding[k]
+				end
+				table.insert(bindings[action], t)
+			end
+		end
+	end
+	ResolveRefBindings(default_bindings, bindings)
+	for i = 1, #default_bindings do
+		local action = default_bindings[i][1]
+		local blist = bindings[action]
+		for j = 1, #blist do
+			local binding = blist[j]
+			if type(binding[1]) == "number" then
+				BindKey(action, binding[1], binding[2], binding[3])
+			else
+				BindMouse(action, binding[1], binding[2], binding[3])
+			end
+			if binding[2] then
+				if type(binding[2]) == "number" then
+					BindKey(action, binding[2], binding[1], binding[3])
+				else
+					BindMouse(action, binding[2], binding[1], binding[3])
+				end
+			end
+			if binding[3] then
+				if type(binding[3]) == "number" then
+					BindKey(action, binding[3], binding[1], binding[2])
+				else
+					BindMouse(action, binding[3], binding[1], binding[2])
+				end
+			end
+		end
+		BindToKeyboardAndMouseSync(action)
+	end
+end
+
+function BindToKeyboardEvent(action, event, func, key, mod1, mod2)
+	local binding = { action = action, key = key, func = func }
+	if mod1 or mod2 then
+		binding.key_modifiers = {}
+		binding.key_modifiers[#binding.key_modifiers+1] = mod1
+		binding.key_modifiers[#binding.key_modifiers+1] = mod2
+	end
+	local list
+	if event == "down" then
+		list = CC_KeyboardKeyDown
+		CC_KeyboardAndMouse_ActionBindings[action] = CC_KeyboardAndMouse_ActionBindings[action] or {}
+		table.insert(CC_KeyboardAndMouse_ActionBindings[action], binding)
+	elseif event == "up" then
+		list = CC_KeyboardKeyUp
+	elseif event == "hold" then
+		list = CC_KeyboardKeyHold
+	elseif event == "double-click" then
+		list = CC_KeyboardKeyDoubleClick
+	end
+	list[key] = list[key] or {}
+	table.insert(list[key], binding)
+end
+
+function BindToMouseEvent(action, event, func, button, key_mod)
+	local binding = { action = action, mouse_button = button, func = func }
+	if key_mod then
+		binding.key_modifiers = {}
+		binding.key_modifiers[#binding.key_modifiers+1] = key_mod
+	end
+	if event == "down" or button == "MouseWheel" then
+		CC_KeyboardAndMouse_ActionBindings[action] = CC_KeyboardAndMouse_ActionBindings[action] or {}
+		table.insert(CC_KeyboardAndMouse_ActionBindings[action], binding)
+	end
+	if button == "MouseWheel" then
+		table.insert(CC_MouseWheel, binding)
+	elseif button == "MouseWheelFwd" then
+		table.insert(CC_MouseWheelFwd, binding)
+	elseif button == "MouseWheelBack" then
+		table.insert(CC_MouseWheelBack, binding)
+	elseif event == "down" then
+		CC_MouseButtonDown[button] = CC_MouseButtonDown[button] or {}
+		table.insert(CC_MouseButtonDown[button], binding)
+	elseif event == "up" then
+		CC_MouseButtonUp[button] = CC_MouseButtonUp[button] or {}
+		table.insert(CC_MouseButtonUp[button], binding)
+	elseif event == "mouse_move" then
+		table.insert(CC_MouseMove, binding)
+	end
+end
+
+
+-- XboxController
+
+DefineClass.CC_XboxController = {
+	__parents = { "CharacterControl" },
+	xbox_controller_id = false,
+	XboxHoldButtonTime = 350,
+	xbox_hold_thread = false,
+	XBoxComboButtonsDelay = 100,
+	xbox_last_combo_button = false,
+	xbox_last_combo_button_time = 0,
+}
+
+function CC_XboxController:Init(character, controller_id)
+	self.xbox_controller_id = controller_id
+end
+
+function CC_XboxController:OnActivate()
+	CharacterControl.OnActivate(self)
+	if self.xbox_controller_id and self.camera_active then
+		camera3p.EnableController(self.xbox_controller_id)
+	end
+end
+
+function CC_XboxController:SetCameraActive(active)
+	CharacterControl.SetCameraActive(self, active)
+	if self.xbox_controller_id and self.active then
+		if self.camera_active then
+			camera3p.EnableController(self.xbox_controller_id)
+		else
+			camera3p.DisableController(self.xbox_controller_id)
+		end
+	end
+end
+
+function CC_XboxController:OnInactivate()
+	CharacterControl.OnInactivate(self)
+	DeleteThread(self.xbox_hold_thread)
+	self.xbox_hold_thread = nil
+	if self.xbox_controller_id then
+		XInput.SetRumble(self.xbox_controller_id, 0, 0)
+		camera3p.DisableController(self.xbox_controller_id)
+	end
+end
+
+function CC_XboxController:GetActionBindings(action)
+	return CC_XboxController_ActionBindings[action]
+end
+
+function CC_XboxController:GetBindingValue(binding)
+	if not self.active then
+		return
+	end
+	local button = binding.xbutton
+	if button and not XInput.IsCtrlButtonPressed(self.xbox_controller_id, button) then
+		return
+	end
+	if not self:BindingModifiersActive(binding) then
+		return
+	end
+	local value = XInput.CurrentState[self.xbox_controller_id][button]
+	return value
+end
+
+function CC_XboxController:BindingModifiersActive(binding)
+	local buttons = binding.x_modifiers
+	if buttons then
+		for i = 1, #buttons do
+			if not XInput.IsCtrlButtonPressed(self.xbox_controller_id, buttons[i]) then
+				return false
+			end
+		end
+	end
+	return true
+end
+
+function CC_XboxController:OnXButtonDown(button, controller_id)
+	if not self.active or controller_id ~= self.xbox_controller_id then
+		return "continue"
+	end
+	-- hold
+	if CC_XboxButtonHold[button] then
+		DeleteThread(self.xbox_hold_thread)
+		self.xbox_hold_thread = CreateRealTimeThread(function(self, button, controller_id)
+			Sleep(self.XboxHoldButtonTime)
+			self.xbox_hold_thread = false
+			if XInput.IsCtrlButtonPressed(self.xbox_controller_id, button) then
+				local xstate = XInput.CurrentState[controller_id]
+				self:CallBindingsDown(CC_XboxButtonHold[button], xstate[button])
+			end
+		end, self, button, controller_id)
+	end
+	local result
+	if CC_XboxButtonDown[button] then
+		result = self:CallBindingsDown(CC_XboxButtonDown[button], true)
+	end
+	if CC_XboxButtonCombo[button] then
+		local handlers = self.xbox_last_combo_button and RealTime() - self.xbox_last_combo_button_time < self.XBoxComboButtonsDelay and CC_XboxButtonCombo[button][self.xbox_last_combo_button]
+		if handlers then
+			local result = self:CallBindingsDown(handlers, true)
+			if result and result ~= "continue" then
+				self.xbox_last_combo_button = false
+				return result
+			end
+		end
+		self.xbox_last_combo_button = button
+		self.xbox_last_combo_button_time = RealTime()
+	end
+	return result or "continue"
+end
+
+function CC_XboxController:OnXButtonUp(button, controller_id)
+	if not self.active or controller_id ~= self.xbox_controller_id then
+		return "continue"
+	end
+	if self.xbox_last_combo_button == button then
+		self.xbox_last_combo_button = false
+	end
+	if CC_XboxButtonHold[button] and self.xbox_hold_thread then
+		DeleteThread(self.xbox_hold_thread)
+		self.xbox_hold_thread = false
+	end
+	if CC_XboxButtonUp[button] then
+		local result = self:CallBindingsUp(CC_XboxButtonUp[button])
+		if result ~= "continue" then
+			return result
+		end
+	end
+	return "continue"
+end
+
+function CC_XboxController:OnXNewPacket(_, controller_id, last_state, current_state)
+	if not self.active or controller_id ~= self.xbox_controller_id then
+		return "continue"
+	end
+	for i = 1, #CC_XboxControllerNewPacket do
+		local button = CC_XboxControllerNewPacket[i]
+		self:CallBindingsDown(CC_XboxControllerNewPacket[button], current_state[button])
+	end
+	return "continue"
+end
+
+function CC_XboxController:SyncWithCharacter()
+	self:SyncBindingsWithCharacter(CC_XboxControllerSync)
+end
+
+local function ResetXboxControllerBindings()
+	CC_XboxButtonDown = {}
+	CC_XboxButtonUp = {}
+	CC_XboxButtonHold = {}
+	CC_XboxButtonCombo = {}
+	CC_XboxControllerNewPacket = {}
+	CC_XboxController_ActionBindings = {}
+	CC_XboxControllerSync = {}
+	table.insert(CC_XboxControllerSync,{ func = function() MouseRotate(false) end})
+end
+
+if FirstLoad then
+	ResetXboxControllerBindings()
+end
+
+function ReloadXboxControllerBindings(default_bindings, predefined_bindings)
+	ResetXboxControllerBindings()
+	if not default_bindings then
+		return
+	end
+	local bindings = {}
+	for i = 1, #default_bindings do
+		local default_list = default_bindings[i]
+		local action = default_list[1]
+		bindings[action] = {}
+		local predefined_list = predefined_bindings and predefined_bindings[action]
+		for i = 1, Max(predefined_list and #predefined_list or 0, #default_list-1) do
+			local binding = predefined_list and predefined_list[i] or nil
+			if binding == nil then
+				binding = default_list and default_list[i+1]
+			end
+			if binding and #binding > 0 then
+				local t = {}
+				for k = 1, #binding do
+					t[k] = binding[k]
+				end
+				table.insert(bindings[action], t)
+			end
+		end
+	end
+	ResolveRefBindings(default_bindings, bindings)
+	for i = 1, #default_bindings do
+		local action = default_bindings[i][1]
+		local blist = bindings[action]
+		for j = 1, #blist do
+			local binding = blist[j]
+			BindXboxController(action, unpack_params(binding))
+		end
+		BindToXboxControllerSync(action)
+	end
+end
+
+function BindXboxController(action, button, mod1, mod2)
+	local class = _G["CCA_"..action]
+	assert(class)
+	if class then
+		class:BindXboxController(action, button, mod1, mod2)
+	end
+end
+
+function BindToXboxControllerEvent(action, event, func, button, mod1, mod2)
+	if event == "sync" then
+		if action or not table.find(CC_XboxControllerSync, "func", func) then
+			local binding = { action = action, func = func }
+			table.insert(CC_XboxControllerSync, binding)
+		end
+		return
+	end
+	local binding = { action = action, xbutton = button, func = func }
+	if mod1 or mod2 then
+		binding.x_modifiers = {}
+		binding.x_modifiers[#binding.x_modifiers+1] = mod1
+		binding.x_modifiers[#binding.x_modifiers+1] = mod2
+	end
+	local list
+	if event == "down" then
+		CC_XboxController_ActionBindings[action] = CC_XboxController_ActionBindings[action] or {}
+		table.insert(CC_XboxController_ActionBindings[action], binding)
+		list = CC_XboxButtonDown
+	elseif event == "up" then
+		list = CC_XboxButtonUp
+		table.insert_unique(CC_XboxButtonUp, button)
+	elseif event == "hold" then
+		list = CC_XboxButtonHold
+	elseif event == "combo" then
+		list = CC_XboxButtonCombo
+	elseif event == "change" then
+		CC_XboxController_ActionBindings[action] = CC_XboxController_ActionBindings[action] or {}
+		table.insert(CC_XboxController_ActionBindings[action], binding)
+		table.insert_unique(CC_XboxControllerNewPacket, button)
+		list = CC_XboxControllerNewPacket
+	else
+		return
+	end
+	if not list[button] then
+		list[button] = {}
+	end
+	table.insert(list[button], binding)
+end

CommonLua/Classes/ClassDef.lua

@@ -0,0 +1,336 @@
+DefineClass.PropertyTabDef = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "TabName", editor = "text", default = "" },
+		{ id = "Categories", editor = "set", default = {}, items = function(self)
+				local class_def = GetParentTableOfKind(self, "ClassDef")
+				local categories = {}
+				for _, classname in ipairs(class_def.DefParentClassList) do
+					local base = g_Classes[classname]
+					for _, prop_meta in ipairs(base and base:GetProperties()) do
+						categories[prop_meta.category or "Misc"] = true
+					end
+				end
+				for _, subitem in ipairs(class_def) do
+					if IsKindOf(subitem, "PropertyDef") then
+						categories[subitem.category or "Misc"] = true
+					end
+				end
+				return table.keys2(categories, "sorted")
+			end
+		}
+	},
+	GetEditorView = function(self)
+		return string.format("%s - %s", self.TabName, table.concat(table.keys2(self.Categories or empty_table), ", "))
+	end,
+}
+
+DefineClass.ClassDef = {
+	__parents = { "Preset" },
+	properties = {
+		{ id = "DefParentClassList", name = "Parent classes", editor = "string_list", items = function(obj, prop_meta, validate_fn)
+				if validate_fn == "validate_fn" then
+					-- function for preset validation, checks whether the property value is from "items"
+					return "validate_fn", function(value, obj, prop_meta)
+						return value == "" or g_Classes[value]
+					end
+				end
+				return table.keys2(g_Classes, true, "")
+			end
+		},
+		{ id = "DefPropertyTranslation", name = "Translate property names", editor = "bool", default = false, },
+		{ id = "DefStoreAsTable", name = "Store as table", editor = "choice", default = "inherit", items = { "inherit", "true", "false" } },
+		{ id = "DefPropertyTabs", name = "Property tabs", editor = "nested_list", base_class = "PropertyTabDef", inclusive = true, default = false, },
+		{ id = "DefUndefineClass", name = "Undefine class", editor = "bool", default = false, },
+	},
+	DefParentClassList = { "PropertyObject" },
+	
+	ContainerClass = "ClassDefSubItem",
+	PresetClass = "ClassDef",
+	FilePerGroup = true,
+	HasCompanionFile = true,
+	GeneratesClass = true,
+	DefineKeyword = "DefineClass",
+	
+	GedEditor = "ClassDefEditor",
+	EditorMenubarName = "Class definitions",
+	EditorIcon = "CommonAssets/UI/Icons/cpu.png",
+	EditorMenubar = "Editors.Engine",
+	EditorShortcut = "Ctrl-Alt-F3",
+	EditorViewPresetPrefix = "<color 75 105 198>[Class]</color> ",
+}
+
+function ClassDef:FindSubitem(name)
+	for _, subitem in ipairs(self) do
+		if subitem:HasMember("name") and subitem.name == name or subitem:IsKindOf("PropertyDef") and subitem.id == name then
+			return subitem
+		end
+	end
+end
+
+function ClassDef:GetDefaultPropertyValue(prop_id, prop_meta)
+	if prop_id:starts_with("Def") then
+		local class_prop_id = prop_id:sub(4)
+		-- try to find the default property value from the parent list
+		-- this is not correct if there are multiple parent classes that have different default values for the property
+		for i, class_name in ipairs(self.DefParentClassList) do
+			local class = g_Classes[class_name]
+			if class then
+				local default = class:GetDefaultPropertyValue(class_prop_id)
+				if default ~= nil then
+					return default
+				end
+			end
+		end
+	end
+	return Preset.GetDefaultPropertyValue(self, prop_id, prop_meta)
+end
+
+function ClassDef:PostLoad()
+	for key, prop_def in ipairs(self) do
+		prop_def.translate_in_ged = self.DefPropertyTranslation
+	end
+	Preset.PostLoad(self)
+end
+
+function ClassDef:OnPreSave()
+	-- convert texts to/from Ts if the 'translated' value changed
+	local translate = self.DefPropertyTranslation
+	for key, prop_def in ipairs(self) do
+		if IsKindOf(prop_def, "PropertyDef") then
+			local convert_text = function(value)
+				local prop_translated = not value or IsT(value)
+				if prop_translated and not translate then
+					return value and TDevModeGetEnglishText(value) or false
+				elseif not prop_translated and translate then
+					return value and value ~= "" and T(value) or false 
+				end
+				return value
+			end
+			prop_def.name = convert_text(prop_def.name)
+			prop_def.help = convert_text(prop_def.help)
+			prop_def.translate_in_ged = translate
+		end
+	end
+end
+
+function ClassDef:GenerateCompanionFileCode(code)
+	if self.DefUndefineClass then
+		code:append("UndefineClass('", self.id, "')\n")
+	end
+	code:append(self.DefineKeyword, ".", self.id, " = {\n")
+	self:GenerateParents(code)
+	self:AppendGeneratedByProps(code)
+	self:GenerateProps(code)
+	self:GenerateConsts(code)
+	code:append("}\n\n")
+	self:GenerateMethods(code)
+	self:GenerateGlobalCode(code)
+end
+
+function ClassDef:GenerateParents(code)
+	local parents = self.DefParentClassList
+	if #(parents or "") > 0 then
+		code:append("\t__parents = { \"", table.concat(parents, "\", \""), "\", },\n")
+	end
+end
+
+function ClassDef:GenerateProps(code)
+	local extra_code_fn = self.GeneratePropExtraCode ~= ClassDef.GeneratePropExtraCode and
+		function(prop_def) return self:GeneratePropExtraCode(prop_def) end
+	self:GenerateSubItemsCode(code, "PropertyDef", "\tproperties = {\n", "\t},\n", self.DefPropertyTranslation, extra_code_fn )
+end
+
+function ClassDef:GeneratePropExtraCode(prop_def)
+end
+
+function ClassDef:AppendConst(code, prop_id, alternative_default, def_prop_id)
+	def_prop_id = def_prop_id or "Def" .. prop_id
+	local value = rawget(self, def_prop_id)
+	if value == nil then return end
+	local def_value = self:GetDefaultPropertyValue(def_prop_id)
+	if value ~= alternative_default and value ~= def_value then
+		code:append("\t", prop_id, " = ")
+		code:appendv(value)
+		code:append(",\n")
+	end
+end
+
+function ClassDef:GenerateConsts(code)
+	if self.DefStoreAsTable ~= "inherit" then
+		code:append("\tStoreAsTable = ", self.DefStoreAsTable, ",\n")
+	end
+	if self.DefPropertyTabs then
+		code:append("\tPropertyTabs = ")
+		code:appendv(self.DefPropertyTabs, "\t")
+		code:append(",\n")
+	end
+	self:GenerateSubItemsCode(code, "ClassConstDef")
+end
+
+function ClassDef:GenerateMethods(code)
+	self:GenerateSubItemsCode(code, "ClassMethodDef", "", "", self.id)
+end
+
+function ClassDef:GenerateGlobalCode(code)
+	self:GenerateSubItemsCode(code, "ClassGlobalCodeDef", "", "", self.id)
+end
+
+function ClassDef:GenerateSubItemsCode(code, subitem_class, prefix, suffix, ...)
+	local has_subitems
+	for i, prop in ipairs(self) do
+		if prop:IsKindOf(subitem_class) then
+			has_subitems = true
+			break
+		end
+	end
+	
+	if has_subitems then 
+		if prefix then code:append(prefix) end
+		for i, prop in ipairs(self) do
+			if prop:IsKindOf(subitem_class) then
+				prop:GenerateCode(code, ...)
+			end
+		end
+		if suffix then code:append(suffix) end
+	end
+end
+
+function ClassDef:GetCompanionFileSavePath(path)
+	if path:starts_with("Data") then
+		path = path:gsub("^Data", "Lua/ClassDefs") -- save in the game folder
+	elseif path:starts_with("CommonLua/Data") then
+		path = path:gsub("^CommonLua/Data", "CommonLua/Classes/ClassDefs") -- save in common lua
+	elseif path:starts_with("CommonLua/Libs/") then -- lib
+		path = path:gsub("/Data/", "/ClassDefs/")
+	else
+		path = path:gsub("^(svnProject/Dlc/[^/]*)/Presets", "%1/Code/ClassDefs") -- save in a DLC
+	end
+	return path:gsub(".lua$", ".generated.lua")
+end
+
+
+function ClassDef:GetError()
+	local names = {}
+	for _, element in ipairs(self or empty_table) do
+		local id = rawget(element, "id") or rawget(element, "id")
+		if id then
+			if names[id] then
+				return "Some class members have matching ids - '"..element.id.."'"
+			else
+				names[id] = true
+			end
+		end
+	end
+end
+
+function GetTextFilePreview(path, lines_count, filter_func)
+	if lines_count and lines_count > 0 then
+		local file, err = io.open(path, "r")
+		if not err then
+			local count = 1
+			local lines = {}
+			local line
+			while count <= lines_count do
+				line = file:read()
+				if line == nil then break end
+				for subline in line:gmatch("[^%\r?~%\n?]+") do
+					if count == lines_count + 1 or (filter_func and filter_func(subline)) then
+						break
+					end
+					lines[#lines + 1] = subline
+					count = count + 1
+				end
+			end
+			lines[#lines + 1] = ""
+			lines[#lines + 1] = "..."
+			file:close()
+			return table.concat(lines, "\n")
+		end
+	end
+end
+
+local function CleanUpHTMLTags(text)
+	text = text:gsub("<br>", "\n")
+	text = text:gsub("<br/>", "\n")
+	text = text:gsub("<script(.+)/script>", "")
+	text = text:gsub("<style(.+)/style>", "")
+	text = text:gsub("<!--(.+)-->", "")
+	text = text:gsub("<link(.+)/>", "")
+	return text
+end
+
+function GetDocumentation(obj)
+	if type(obj) == "table" and PropObjHasMember(obj, "Documentation") and obj.Documentation and obj.Documentation ~= "" then
+		return obj.Documentation
+	end
+end
+
+function GetDocumentationLink(obj)
+	if type(obj) == "table" and PropObjHasMember(obj, "DocumentationLink") and obj.DocumentationLink and obj.DocumentationLink ~= "" then
+		local link = obj.DocumentationLink
+		assert(link:starts_with("Docs/"))
+		if not link:starts_with("http") then
+			link = ConvertToOSPath(link)
+		end
+		link = string.gsub(link, "[\n\r]", "")
+		link = string.gsub(link, " ", "%%20")
+		return link
+	end
+end
+
+function GedOpenDocumentationLink(root, obj, prop_id, ged, btn_param, idx)
+	OpenUrl(GetDocumentationLink(obj), "force external browser")
+end
+
+
+----- AppendClassDef
+
+DefineClass.AppendClassDef = {
+	__parents = { "ClassDef" },
+	properties = {
+		{ id = "DefUndefineClass", editor = false, },
+		
+	},
+	GeneratesClass = false,
+	DefParentClassList = false,
+	DefineKeyword = "AppendClass",
+}
+
+
+----- ListPreset
+
+DefineClass.ListPreset = {
+	__parents = { "Preset", },
+	HasGroups = false,
+	HasSortKey = true,
+	EditorMenubar = "Editors.Lists",
+}
+
+-- deprecated and left for compatibility reasons, to be removed
+DefineClass.ListItem = {
+	__parents = { "Preset", },
+	properties = {
+		{ id = "Group", no_edit = false, },
+	},
+	HasSortKey = true,
+	PresetClass = "ListItem",
+}
+
+
+-----
+
+if Platform.developer and not Platform.ged then
+	function RemoveUnversionedClassdefs()
+		local err, files = AsyncListFiles("svnProject/../", "*.lua", "recursive")
+		local removed = 0
+		for _, file in ipairs(files) do
+			if string.match(file, "ClassDef%-.*%.lua$") and not SVNLocalInfo(file) then
+				print("removing", file)
+				os.remove(file)
+				removed = removed + 1
+			end
+		end
+		print(removed, "files removed")
+	end
+end

CommonLua/Classes/ClassDefFunctionObjects.lua

@@ -0,0 +1,930 @@
+local hintColor = RGB(210, 255, 210)
+local procall = procall
+
+----- FunctionObject (with paremeters specified in properties, used as building block in game content editors, e.g. story bits)
+
+DefineClass.FunctionObject = {
+	__parents = { "PropertyObject" },
+	RequiredObjClasses = false,
+	ForbiddenObjClasses = false,
+	Description = "",
+	ComboFormat = T(623739770783, "<class><opt(u(RequiredClassesFormatted),' ','')>"),
+	EditorNestedObjCategory = "General",
+	StoreAsTable = true,
+}
+
+function FunctionObject:GetDescription()
+	return self.Description
+end
+
+function FunctionObject:GetEditorView()
+	return self.EditorView ~= PropertyObject.EditorView and self.EditorView or self:GetDescription()
+end
+
+function FunctionObject:GetRequiredClassesFormatted()
+	if not self.RequiredObjClasses then return end
+	local classes = {}
+	for _, id in ipairs(self.RequiredObjClasses) do
+		classes[#classes + 1] = id:lower()
+	end
+	return Untranslated("(" .. table.concat(classes, ", ") .. ")")
+end
+
+function FunctionObject:ValidateObject(obj, parentobj_text, ...)
+	if not self.RequiredObjClasses and not self.ForbiddenObjClasses then return true end
+	local valid = obj and type(obj) == "table"
+	if valid then
+		if self.RequiredObjClasses and not obj:IsKindOfClasses(self.RequiredObjClasses) then
+			valid = false
+			parentobj_text = string.concat("", parentobj_text, ...) or "Unknown"
+			assert(valid, string.format("%s: Object for %s must be of class %s!\n(Current class is %s)",
+				parentobj_text, self.class, table.concat(self.RequiredObjClasses, " or "), obj.class))
+		end
+		if self.ForbiddenObjClasses and obj:IsKindOfClasses(self.ForbiddenObjClasses) then
+			valid = false
+			parentobj_text = string.concat("", parentobj_text, ...) or "Unknown"
+			assert(valid, string.format("%s: Object for %s must not be of class %s!",
+				parentobj_text, self.class, table.concat(self.ForbiddenObjClasses, " or ")))
+		end
+	end
+	return valid
+end
+
+function FunctionObject:HasNonPropertyMembers()
+	local properties = self:GetProperties()
+	for key, value in pairs(self) do
+		if key ~= "container" and key ~= "CreateInstance" and key ~= "StoreAsTable" and key ~= "param_bindings" and not table.find(properties, "id", key) then
+			return key
+		end
+	end
+end
+
+function FunctionObject:GetError()
+	if self:HasNonPropertyMembers() then
+		return "An Effect or Condition object must NOT keep internal state. For ContinuousEffects that need to have dynamic members, please set the CreateInstance class constant to 'true'."
+	end
+end
+
+function FunctionObject:TestInGed(subject, ged, context)
+	if self.RequiredObjClasses or self.ForbiddenObjClasses then
+		if self.RequiredObjClasses and not IsKindOfClasses(subject, self.RequiredObjClasses) then
+			local msg = string.format("%s requires an object of class %s!\n(Current class is '%s')",
+				self.class, table.concat(self.RequiredObjClasses, " or "), subject and subject.class or "")
+			ged:ShowMessage("Test Result", msg)
+			return
+		end
+		if self.ForbiddenObjClasses and IsKindOfClasses(subject, self.ForbiddenObjClasses) then
+			local msg = string.format("%s requires an object not of class %s!\n",
+				self.class, table.concat(self.ForbiddenObjClasses, " or "))
+			ged:ShowMessage("Test Result", msg)
+			return
+		end
+	end
+	local result, err, ok
+	if self:HasMember("Evaluate") then
+		result, err = self:Evaluate(subject, context)
+		ok = true
+	else
+		ok, result = self:Execute(subject, context)
+	end
+	if err then
+		ged:ShowMessage("Test Result", string.format("%s returned an error %s.", self.class, tostring(err)))
+	elseif not ok then
+		ged:ShowMessage("Test Result", string.format("%s returned an error %s.", self.class, tostring(result)))
+	elseif type(result) == "table" then
+		Inspect(result)
+		ged:ShowMessage("Test Result", string.format("%s returned a %s.\n\nCheck the newly opened Inspector window in-game.", self.class, result.class or "table"))
+	else
+		ged:ShowMessage("Test Result", string.format("%s returned '%s'.", self.class, result))
+	end
+end
+
+DefineClass.FunctionObjectDef = {
+	__parents = { "ClassDef" },
+	properties = {
+		{ id = "DefPropertyTranslation", no_edit = true, },
+	},
+	GedEditor = false,
+	EditorViewPresetPrefix = "",
+}
+
+function FunctionObjectDef:OnEditorNew(parent, ged, is_paste)
+	-- remove test harness on paste (the test object there is of the "old" class)
+	for i, obj in ipairs(self) do
+		if IsKindOf(obj, "TestHarness") then
+			table.remove(self, i)
+			break
+		end
+	end
+end
+
+local IsKindOf = IsKindOf
+function FunctionObjectDef:PostLoad()
+	for _, obj in ipairs(self) do
+		if IsKindOf(obj, "TestHarness") then
+			if type(obj.TestObject) == "table" and not obj.TestObject.class then
+				obj.TestObject = g_Classes[self.id]:new(obj.TestObject)
+			end
+		end
+	end
+	ClassDef.PostLoad(self)
+end
+
+local save_to_continue_message = { "Please save your new creation to continue.", hintColor }
+local missing_harness_message = "Missing Test Harness object, force resave (Ctrl-Shift-S) to create one."
+
+function FunctionObjectDef:GenerateCode(...)
+	if config.GedFunctionObjectsTestHarness then
+		local harness = self:FindSubitem("TestHarness")
+		if not harness and g_Classes[self.id] then
+			local error = self:GetError()
+			if error == missing_harness_message or error == save_to_continue_message then
+				local obj = TestHarness:new{ name = "TestHarness", TestObject = g_Classes[self.id]:new() }
+				obj:OnEditorNew()
+				self[#self + 1] = obj
+				UpdateParentTable(obj, self)
+				PopulateParentTableCache(obj)
+				ObjModified(self)
+			end
+		end
+	end
+	return ClassDef.GenerateCode(self, ...)
+end
+
+function FunctionObjectDef:DocumentationWarning(class, verb)
+	local documentation = self:FindSubitem("Documentation")
+	if not (documentation and documentation.class == "ClassConstDef" and documentation.value ~= ClassConstDef.value) then
+		return {
+string.format([[--== Documentation ==--
+What does your %s %s?
+
+Explain behavior not apparent from the %s's name and specific terms a new modder might not know.]], class, verb, class),
+		hintColor, table.find(self, documentation) }
+	end
+end
+
+function FunctionObjectDef:GetError()
+	if self:FindSubitem("Init") then
+		return "An Init method has no effect - Effect/Condition objects are not of class InitDone."
+	end
+	
+	if config.GedFunctionObjectsTestHarness then
+		local harness = self:FindSubitem("TestHarness")
+		if self:IsDirty() and not harness then
+			return save_to_continue_message -- see a bit up
+		elseif not harness then
+			return missing_harness_message -- see a bit up
+		elseif not harness.Tested then
+			if not harness.TestedOnce then
+				return { [[--== Testing ==--
+1. In Test Harness edit TestObject, test properties & warnings, and define a good test case.
+
+2. If your class requires an object, edit GetTestSubject to fetch one.
+
+3. Click Test to run Evaluate/Execute and check the results.]], hintColor, table.find(self, harness) }
+			else
+				return self:IsDirty()
+					and { [[--== Testing ==--
+Please save and test your changes using the Test Harness.]], hintColor, table.find(self, harness) }
+					or	{ [[--== Testing ==--
+Please test your changes using the Test Harness.]], hintColor, table.find(self, harness) }
+			end
+		end
+	end
+end
+
+function FunctionObjectDef:OnEditorDirty(dirty)
+	local harness = self:FindSubitem("TestHarness")
+	if harness then
+		if dirty and not harness.TestFlagsChanged then
+			harness.Tested = false
+			ObjModified(self)
+		end
+		harness.TestFlagsChanged = false
+	end
+end
+
+
+----- TestHarness
+
+DefineClass.TestHarness = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "name", name = "Name", editor = "text", default = false },
+		{ id = "TestedOnce", editor = "bool", default = false, no_edit = true, },
+		{ id = "Tested", editor = "bool", default = false, no_edit = true, },
+		{ id = "GetTestSubject", editor = "func", default = function() end, },
+		{ id = "TestObject", editor = "nested_obj", base_class = "FunctionObject", auto_expand = true, default = false, },
+		{ id = "Buttons", editor = "buttons", buttons = {{name = "Test this object!", func = "Test" }}, default = false,
+		  no_edit = function(obj) return not obj.TestObject or IsKindOf(obj.TestObject, "ContinuousEffect") end },
+		{ id = "ButtonsContinuous", editor = "buttons", buttons = {{name = "Start effect!", func = "Test"}, {name = "Stop Effect!", func = "Stop"}}, default = false,
+		  no_edit = function(obj) return not obj.TestObject or not IsKindOf(obj.TestObject, "ContinuousEffect") end },
+	},
+	EditorView = "[Test Harness]",
+	TestFlagsChanged = false,
+}
+
+function TestHarness:OnEditorNew()
+	self.GetTestSubject = function() return SelectedObj end
+end
+
+function TestHarness:Test(parent, prop_id, ged)
+	if parent:IsDirty() then
+		ged:ShowMessage("Please Save", "Please save before testing, unsaved changes won't apply before that.")
+		return
+	end
+	self.TestObject:TestInGed(self:GetTestSubject(), ged)
+	self.TestedOnce = true
+	self.Tested = true
+	self.TestFlagsChanged = true
+	ObjModified(parent)
+	ObjModified(ged:ResolveObj("root"))
+end
+
+function TestHarness:Stop(parent, prop_id, ged)
+	local fnobj, subject = self.TestObject, self:GetTestSubject()
+	if not fnobj.Id or fnobj.Id == "" then
+		ged:ShowMessage("Stop Effect", "You must specify an effect Id in order to use the Stop method!")
+		return
+	end
+	if fnobj:HasMember("RequiredObjClasses") and fnobj.RequiredObjClasses then
+		subject:StopEffect(fnobj.Id)
+	else
+		UIPlayer:StopEffect(fnobj.Id)
+	end
+	ged:ShowMessage("Stop Effect", "The effect was stopped.")
+end
+
+if not config.GedFunctionObjectsTestHarness then
+	TestHarness.GetDiagnosticMessage = empty_func
+end
+
+
+----- Condition (a predicate that can be used in, e.g. prerequisites for a game event)
+
+DefineClass.Condition = {
+	__parents = { "FunctionObject" },
+	Negate = false,
+	EditorViewNeg = false,
+	DescriptionNeg = "",
+	EditorExcludeAsNested = true,
+	__eval = function(self, obj, context) return false end,
+}
+
+function Condition:GetDescription() -- deprecated
+	return self.Negate and self.DescriptionNeg or self.Description
+end
+
+function Condition:GetEditorView()
+	return self.Negate and self.EditorViewNeg or FunctionObject.GetEditorView(self)
+end
+
+-- protected call - prevent game break when a condition crashes
+function Condition:Evaluate(...)
+	local ok, err_res = procall(self.__eval, self, ...)
+	if ok then
+		if err_res then
+			return not self.Negate
+		end
+		return self.Negate
+	end
+	return false, err_res
+end
+
+DefineClass.ConditionsWithParams = {
+	__parents = { "Condition" },
+	properties = {
+		{ id = "__params", name = "Parameters", editor = "expression", params = "self, obj, context, ...", default = function (self, obj, context, ...) return obj, context, ... end, },
+		{ id = "Conditions", name = "Conditions", editor = "nested_list", default = false, base_class = "Condition", },
+	},
+	EditorView = Untranslated("Conditions with parameters"),
+}
+
+function ConditionsWithParams:__eval(...)
+	return _EvalConditionList(self.Conditions, self:__params(...))
+end
+
+DefineClass.ConditionDef = {
+	__parents = { "FunctionObjectDef" },
+	group = "Conditions",
+	DefParentClassList = { "Condition" },
+	GedEditor = "ClassDefEditor",
+}
+
+function ConditionDef:OnEditorNew(parent, ged, is_paste)
+	if is_paste then return end
+	self[1] = self[1] or PropertyDefBool:new{ id = "Negate", name = "Negate Condition", default = false, }
+	self[2] = self[2] or ClassConstDef:new{ name = "RequiredObjClasses", type = "string_list", }
+	self[3] = self[3] or ClassConstDef:new{ name = "EditorView", type = "translate", untranslated = true, }
+	self[4] = self[4] or ClassConstDef:new{ name = "EditorViewNeg", type = "translate", untranslated = true, }
+	self[5] = self[5] or ClassConstDef:new{ name = "Documentation", type = "text" }
+	self[6] = self[6] or ClassMethodDef:new{ name = "__eval", params = "obj, context", code = function(self, obj, context) return false end, }
+	self[7] = self[7] or ClassConstDef:new{ name = "EditorNestedObjCategory", type = "text" }
+end
+
+function ConditionDef:GetError()
+	local required = self:FindSubitem("RequiredObjClasses")
+	if required and #(required.value or "") == 0 then
+		return {[[--== RequiredObjClasses ==--
+Please define the classes expected in __eval's 'obj' parameter, or delete if unused.]], hintColor, table.find(self, required) }
+	end	
+	
+	local description    = self:FindSubitem("Description") -- deprecated
+	local description_fn = self:FindSubitem("GetDescription") -- deprecated
+	local editor_view    = self:FindSubitem("EditorView")
+	local editor_view_fn = self:FindSubitem("GetEditorView")
+	if not (description    and description.class    == "ClassConstDef"  and description.value   ~= ClassConstDef.value) and
+	   not (description    and description.class    == "PropertyDefText") and
+	   not (description_fn and description_fn.class == "ClassMethodDef" and description_fn.code ~= ClassMethodDef.code) and
+	   not (editor_view    and editor_view.class    == "ClassConstDef"  and editor_view.value   ~= ClassConstDef.value) and
+	   not (editor_view_fn and editor_view_fn.class == "ClassMethodDef" and editor_view_fn.code ~= ClassMethodDef.code) then
+		return {[[--== Add Properties & EditorView ==--
+Add the Condition's properties and EditorView to format it in Ged.
+
+Sample: "Building is <BuildingClass>".]], hintColor, table.find(self, editor_view) }
+	end
+	
+	local editor_view_neg_fn = self:FindSubitem("GetEditorViewNeg")
+	if editor_view_neg_fn then
+		return {"You can't use a GetEditorViewNeg method. Please implement GetEditorView only and check for self.Negate inside.", nil, table.find(self, editor_view_neg_fn) }
+	end
+	
+	local negate = self:FindSubitem("Negate")
+	local eval = self:FindSubitem("__eval")
+	if negate and eval and eval.class == "ClassMethodDef" and eval:ContainsCode("self.Negate") then
+		return {"The value of Negate is taken into account automatically - you should not access self.Negate in __eval.", nil, table.find(self, eval) }
+	end
+
+	local editor_view_neg = self:FindSubitem("EditorViewNeg")
+	local description_neg = self:FindSubitem("DescriptionNeg") -- deprecated
+	
+	if negate or editor_view_neg or description_neg then
+		if negate and editor_view_fn and editor_view_fn.class == "ClassMethodDef" and editor_view_fn.code ~= ClassMethodDef.code then
+			if not editor_view_fn:ContainsCode("self.Negate") then
+				return {[[--== Negate & GetEditorView ==--
+If negating the makes sense for this Condition, check for self.Negate in GetEditorView to display it accordingly.
+
+Otherwise, delete the Negate property.]], hintColor, table.find(self, negate), table.find(self, editor_view_fn) }
+			elseif editor_view_neg or description_neg then
+				return {[[--== Negate & GetEditorView ==--
+Please delete EditorViewNeg, as you already check for self.Negate in GetEditorView.]], hintColor, table.find(self, editor_view_neg or description_neg) }
+			end
+		elseif not (negate and (editor_view_neg and editor_view_neg.class == "ClassConstDef" and editor_view_neg.value ~= ClassConstDef.value or
+								description_neg and description_neg.class == "ClassConstDef" and description_neg.value ~= ClassConstDef.value)) then
+			return {[[--== Negate & EditorViewNeg ==--
+If negating the makes sense for this Condition, define EditorViewNeg, otherwise delete EditorViewNeg and Negate.
+
+Sample: "Building is not <BuildingClass>".]], hintColor, table.find(self, negate), table.find(self, editor_view_neg) }
+		end
+	end
+
+	local doc_warning = self:DocumentationWarning("Condition", "check")
+	if not doc_warning then
+		local __eval = self:FindSubitem("__eval")
+		if not (__eval and __eval.class == "ClassMethodDef" and __eval.code ~= ClassMethodDef.code) and
+		   not (__eval and __eval.class == "PropertyDefFunc")
+		then
+			return {[[--== __eval & GetError ==--
+	Implement __eval, thinking about potential circumstances in which it might not work.
+
+	Perform edit-time property validity checks in GetError. Thanks!]], hintColor, table.find(self, __eval) }
+		end
+	end
+end
+
+function ConditionDef:GetWarning()
+	return self:DocumentationWarning("Condition", "check")
+end
+
+function Condition:CompareOp(value, context, amount)
+	local op = self.Condition
+	local amount = amount or self.Amount
+	if op == ">=" then
+		return value >= amount
+	elseif op == "<=" then
+		return value <= amount
+	elseif op == ">" then
+		return value > amount
+	elseif op == "<" then
+		return value < amount
+	elseif op == "==" then
+		return value == amount
+	else -- "~="
+		return value ~= amount
+	end
+end
+
+DefineClass.ConditionComparisonDef = {
+	__parents = { "ConditionDef" },
+}
+
+function ConditionComparisonDef:OnEditorNew(parent, ged, is_paste)
+	if is_paste then return end
+	self[1] = self[1] or PropertyDefChoice:new{ id = "Condition", help = "The comparison to perform", items = function (self) return { ">=", "<=", ">", "<", "==", "~=" } end, default = false, }
+	self[2] = self[2] or PropertyDefNumber:new{ id = "Amount", help = "The value to compare against", default = false, }
+	self[3] = self[3] or ClassConstDef:new{ name = "RequiredObjClasses", type = "string_list", }
+	self[4] = self[4] or ClassConstDef:new{ name = "EditorView", type = "translate", untranslated = true, }
+	self[5] = self[5] or ClassConstDef:new{ name = "Documentation", type = "text" }
+	self[6] = self[6] or ClassMethodDef:new{ name = "__eval", params = "obj, context", code = function(self, obj, context)
+-- Calculate the value to compare in 'count' here
+return self:CompareOp(count, context) end, }
+	self[7] = self[7] or ClassMethodDef:new{ name = "GetError", params = "", code = function()
+if not self.Condition then
+	return "Missing Condition"
+elseif not self.Amount then
+	return "Missing Amount"
+end
+	end }
+end
+
+
+----- Effect (an action that has an effect on the game, e.g. providing resources)
+
+DefineClass.Effect = {
+	__parents = { "FunctionObject" },
+	NoIngameDescription = false,
+	EditorExcludeAsNested = true,
+	__exec = function(self, obj, context) end,
+}
+
+function Effect:Execute(...)
+	return procall(self.__exec, self, ...)
+end
+
+
+DefineClass.EffectsWithParams = {
+	__parents = { "Effect" },
+	properties = {
+		{ id = "__params", name = "Parameters", editor = "expression", params = "self, obj, context, ...", default = function (self, obj, context, ...) return obj, context, ... end, },
+		{ id = "Effects", name = "Effects", editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+	},
+	EditorView = Untranslated("Effects with parameters"),
+}
+
+function EffectsWithParams:__exec(...)
+	_ExecuteEffectList(self.Effects, self:__params(...))
+end
+
+
+DefineClass.EffectDef = {
+	__parents = { "FunctionObjectDef" },
+	group = "Effects",
+	DefParentClassList = { "Effect" },
+	GedEditor = "ClassDefEditor",
+}
+
+function EffectDef:OnEditorNew(parent, ged, is_paste)
+	if is_paste then return end
+	self[1] = self[1] or ClassConstDef:new{ name = "RequiredObjClasses", type = "string_list", }
+	self[2] = self[2] or ClassConstDef:new{ name = "ForbiddenObjClasses", type = "string_list", }
+	self[3] = self[3] or ClassConstDef:new{ name = "ReturnClass", type = "text", }
+	self[4] = self[4] or ClassConstDef:new{ name = "EditorView", type = "translate", untranslated = true, }
+	self[5] = self[5] or ClassConstDef:new{ name = "Documentation", type = "text", }
+	self[6] = self[6] or ClassMethodDef:new{ name = "__exec", params = "obj, context", }
+	self[7] = self[7] or ClassConstDef:new{ name = "EditorNestedObjCategory", type = "text" }
+end
+
+function EffectDef:GetError()
+	local required = self:FindSubitem("RequiredObjClasses")
+	local forbidden = self:FindSubitem("ForbiddenObjClasses")
+	if required and #(required.value or "") == 0 or forbidden and #(forbidden.value or "") == 0 then
+		return {[[--== RequiredObjClasses & ForbiddenObjClasses ==--
+Please define the expected classes, or delete if unused.]], hintColor, table.find(self, required), table.find(self, forbidden) }
+	end
+
+--[=[	local return_class = self:FindSubitem("ReturnClass")
+	local return_class_fn = self:FindSubitem("GetReturnClass")
+	if return_class    and (return_class.class    ~= "ClassConstDef"  or return_class.value   == ClassConstDef.value) or
+	   return_class_fn and (return_class_fn.class ~= "ClassMethodDef" or return_class_fn.code == ClassMethodDef.code) then
+		return {[[--== ReturnClass / GetReturnClass ==--
+Please specify your Effect's return value class, or delete if no return value.
+
+Effects that associate a new object to a StoryBit must return the object.]], hintColor, table.find(self, return_class), table.find(self, return_class_fn) }
+	end]=]
+
+	local description    = self:FindSubitem("Description") -- deprecated
+	local description_fn = self:FindSubitem("GetDescription") -- deprecated
+	local editor_view    = self:FindSubitem("EditorView")
+	local editor_view_fn = self:FindSubitem("GetEditorView")
+	if not (description    and description.class    == "ClassConstDef"  and description.value   ~= ClassConstDef.value) and
+	   not (description    and description.class    == "PropertyDefText") and
+	   not (description_fn and description_fn.class == "ClassMethodDef" and description_fn.code ~= ClassMethodDef.code) and
+	   not (editor_view    and editor_view.class    == "ClassConstDef"  and editor_view.value   ~= ClassConstDef.value) and
+	   not (editor_view_fn and editor_view_fn.class == "ClassMethodDef" and editor_view_fn.code ~= ClassMethodDef.code) then
+		return {[[--== Add Properties & EditorView ==--
+Add the Effect's properties and EditorView/GetEditorView() to format it in Ged.
+
+Sample: "Increase trade price of <Resource> by <Percent>%".]], hintColor, table.find(self, editor_view), table.find(self, editor_view_fn) }
+	end
+
+	local doc_warning = self:DocumentationWarning("Effect", "do")
+	if doc_warning then
+		return
+	end
+	return self:CheckExecMethod()
+end
+
+function EffectDef:CheckExecMethod()
+	local execute = self:FindSubitem("__exec")
+	if not (execute and execute.class == "ClassMethodDef" and execute.code ~= ClassMethodDef.code) then
+		return {[[--== Execute ==--
+Implement __exec, thinking about potential circumstances in which it might not work.
+
+Perform edit-time property validity checks in GetError. Thanks!
+]], hintColor, table.find(self, execute) }
+	end
+end
+
+function EffectDef:GetWarning()
+	return self:DocumentationWarning("Effect", "do")
+end
+
+function GetEditorConditionsAndEffectsText(texts, obj)
+	local trigger = rawget(obj,"Trigger") or ""
+	for _, condition in ipairs(obj.Conditions or empty_table) do
+		if trigger == "once" then
+			texts[#texts+1] = "\t\t" .. Untranslated( "once ") .. Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false))
+		elseif trigger == "always" then
+			texts[#texts+1] = "\t\t" .. Untranslated( "always ") .. Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false))
+		elseif trigger == "activation" then
+			texts[#texts+1] = "\t\t" .. Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false)) .. Untranslated( " starts")
+		elseif trigger == "deactivation" then
+			texts[#texts+1] = "\t\t" .. Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false)) .. Untranslated( " ends")
+		else
+			texts[#texts+1] = "\t\t" .. Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false))
+		end
+	end
+	for _, effect in ipairs(obj.Effects or empty_table) do
+		texts[#texts+1] = "\t\t\t" .. Untranslated(_InternalTranslate(effect:GetEditorView(), effect, false))
+	end
+end
+
+function GetEditorStringListPropText(texts, obj, Prop)
+	if not obj[Prop] or not next(obj[Prop]) then 
+		return 
+	end
+	local string_list = {}
+	for _, str in ipairs(obj[Prop]) do
+		string_list[#string_list+1]= Untranslated(str)
+	end
+	string_list = table.concat(string_list, ", ")
+	texts[#texts+1] = "\t\t\t" .. Untranslated(Prop)..": "..string_list
+end
+
+function EvalConditionList(list, ...)
+	if list and #list > 0 then
+		local ok, result = procall(_EvalConditionList, list, ...)
+		if not ok then
+			return false
+		end
+		if not result then
+			return false
+		end
+	end
+	return true
+end
+
+-- unprotected call - used in already protected calls
+function _EvalConditionList(list, ...)
+	for _, cond in ipairs(list) do
+		if cond:__eval(...) then
+			if cond.Negate then
+				return false
+			end
+		else
+			if not cond.Negate then
+				return false
+			end
+		end
+	end
+	return true
+end
+
+function ExecuteEffectList(list, ...)
+	if list and #list > 0 then
+		procall(_ExecuteEffectList, list, ...)
+	end
+end
+
+-- unprotected call - used in already protected calls
+function _ExecuteEffectList(list, ...)
+	for _, effect in ipairs(list) do
+		effect:__exec(...)
+	end
+end
+
+function ComposeSubobjectName(parents)
+	local ids = {}
+	for i = 1, #parents do
+		local parent = parents[i]
+		local parent_id 
+		if IsKindOfClasses(parent, "Condition", "Effect") then
+			parent_id = parent.class
+		else
+			parent_id = parent:HasMember("id") and parent.id or (parent:HasMember("ParamId") and parent.ParamId) or parent.class or "?"
+		end
+		ids[#ids + 1] = parent_id or "?"
+	end
+	return table.concat(ids, ".")
+end
+
+
+----- New scripting
+
+DefineClass("ScriptTestHarnessProgram", "ScriptProgram") -- this class displays a Test button in the place of the Save button in the Script Editor
+
+function ScriptTestHarnessProgram:GetEditedScriptStatusText()
+	return "<center><color 0 128 0>This is a test script, press Ctrl-T to run it."
+end
+
+function ScriptDomainsCombo()
+	local items = { { text = "", value = false } }
+	for name, class in pairs(ClassDescendants("ScriptBlock")) do
+		if class.ScriptDomain then
+			if not table.find(items, "value", class.ScriptDomain) then
+				table.insert(items, { text = class.ScriptDomain, value = class.ScriptDomain })
+			end
+		end
+	end
+	return items
+end
+
+DefineClass.ScriptComponentDef = {
+	__parents = { "ClassDef" },
+	properties = {
+		{ id = "DefPropertyTranslation", no_edit = true, },
+		{ id = "DefStoreAsTable", no_edit = true, },
+		{ id = "DefPropertyTabs", no_edit = true, },
+		{ id = "DefUndefineClass", no_edit = true, },
+		{ category = "Script Component", id = "DefParentClassList", name = "Parent classes", editor = "string_list", items = function(obj, prop_meta, validate_fn)
+				if validate_fn == "validate_fn" then
+					-- function for preset validation, checks whether the property value is from "items"
+					return "validate_fn", function(value, obj, prop_meta)
+						return value == "" or g_Classes[value]
+					end
+				end
+				return table.keys2(g_Classes, true, "")
+			end
+		},
+		{ category = "Script Component", id = "EditorName", name = "Menu name", editor = "text", default = "", },
+		{ category = "Script Component", id = "EditorSubmenu", name = "Menu category", editor = "combo", default = "", items = PresetsPropCombo("ScriptComponentDef", "EditorSubmenu", "") },
+		{ category = "Script Component", id = "Documentation", editor = "text", lines = 1, default = "", },
+		{ category = "Script Component", id = "ScriptDomain", name = "Script domain", editor = "combo", default = false, items = function() return ScriptDomainsCombo() end },
+		
+		{ category = "Code", id = "Params", name = "Parameters", editor = "text", default = "", },
+		{ category = "Code", id = "Param1Help", name = "Param1 help", editor = "text", default = "",
+			no_edit = function(self) local _, num = string.gsub(self.Params .. ",", "([%w_]+)%s*,%s*", "") return num < 1 end,
+		},
+		{ category = "Code", id = "Param2Help", name = "Param2 help", editor = "text", default = "",
+			no_edit = function(self) local _, num = string.gsub(self.Params .. ",", "([%w_]+)%s*,%s*", "") return num < 2 end,
+		},
+		{ category = "Code", id = "Param3Help", name = "Param3 help", editor = "text", default = "",
+			no_edit = function(self) local _, num = string.gsub(self.Params .. ",", "([%w_]+)%s*,%s*", "") return num < 3 end,
+		},
+		{ category = "Code", id = "HasGenerateCode", editor = "bool", default = false, },
+		{ category = "Code", id = "CodeTemplate", name = "Code template", editor = "text", lines = 1, default = "",
+			help = "Here, self.Prop gets replaced with Prop's Lua value.\n$self.Prop omits the quotes, e.g. for variable names.",
+			no_edit = function(self) return self.HasGenerateCode end, dont_save = function(self) return self.HasGenerateCode end, },
+		{ category = "Code", id = "DefGenerateCode", name = "GenerateCode", editor = "func", params = "self, pstr, indent", default = empty_func,
+			no_edit = function(self) return not self.HasGenerateCode end, dont_save = function(self) return not self.HasGenerateCode end,},
+		
+		{ category = "Test Harness", sort_order = 10000, id = "GetTestParams", editor = "func", default = function(self) return SelectedObj end, dont_save = true, },
+		{ category = "Test Harness", sort_order = 10000, id = "TestHarness", name = "Test harness", editor = "script", default = false, dont_save = true,
+			params = function(self) return self.Params end,
+		},
+		{ category = "Test Harness", sort_order = 10000, id = "_", editor = "buttons", buttons = {
+			{ name = "Create",   is_hidden = function(self) return     self.TestHarness end, func = "CreateTestHarness" },
+			{ name = "Recreate", is_hidden = function(self) return not self.TestHarness end, func = "CreateTestHarness" },
+			{ name = "Test",     is_hidden = function(self) return not self.TestHarness end, func = "Test" },
+		}},
+	},
+	GedEditor = false,
+	EditorViewPresetPrefix = "",
+}
+
+-- Will replace instances of the parameter names - whole words only, as listed in the Params property.
+-- (for example, making Object become $self.Param1 in CodeTemplate, if Object is the 1st parameter)
+function ScriptComponentDef:SubstituteParamNames(str, prefix, in_tag)
+	local from_to, n = {}, 1
+	for param in string.gmatch(self.Params .. ",", "([%w_]+)%s*,%s*") do
+		from_to[param] = (prefix or "") .. "Param" .. n
+		n = n + 1
+	end
+	
+	local t = {}
+	for word, other in str:gmatch("([%a%d_]*)([^%a%d_]*)") do
+		if not in_tag or other:starts_with(">") then
+			word = from_to[word] or word
+		end
+		t[#t + 1] = word
+		t[#t + 1] = other
+	end
+	return table.concat(t)
+end
+
+function ScriptComponentDef:GenerateConsts(code)
+	code:append("\tEditorName = \"", self.EditorName, "\",\n")
+	code:append("\tEditorSubmenu = \"", self.EditorSubmenu, "\",\n")
+	code:append("\tDocumentation = \"", self.Documentation, "\",\n")
+	if self.ScriptDomain then
+		code:append("\tScriptDomain = \"", self.ScriptDomain, "\",\n")
+	end
+
+	local code_template = self:SubstituteParamNames(self.CodeTemplate, "$self.") -- allows using parameter names from Params instead of $self.Param1, etc.
+	code:append("\tCodeTemplate = ")
+	code:append(ValueToLuaCode(code_template))
+	code:append(",\n")
+	
+	local n = 1
+	for param in string.gmatch(self.Params .. ",", "([%w_]+)%s*,%s*") do
+		code:appendf("\tParam%dName = \"%s\",\n", n, param)
+		n = n + 1
+	end
+	if self.Param1Help ~= "" then
+		code:append("\tParam1Help = \"", self.Param1Help, "\",\n")
+	end
+	if self.Param2Help ~= "" then
+		code:append("\tParam2Help = \"", self.Param2Help, "\",\n")
+	end
+	if self.Param3Help ~= "" then
+		code:append("\tParam3Help = \"", self.Param3Help, "\",\n")
+	end
+	ClassDef.GenerateConsts(self, code)
+end
+
+function ScriptComponentDef:GenerateMethods(code)
+	if self.HasGenerateCode then
+		local method_def = ClassMethodDef:new{ name = "GenerateCode", params = "pstr, indent", code = self.DefGenerateCode }
+		method_def:GenerateCode(code, self.id)
+	end
+	ClassDef.GenerateMethods(self, code)
+end
+
+function ScriptComponentDef:CreateTestHarness(root, prop_id, ged)
+	CreateRealTimeThread(function()
+		if self:IsDirty() then
+			GedSetUiStatus("lua_reload", "Saving...")
+			self:Save()
+			WaitMsg("Autorun")
+		end
+		
+		self.TestHarness = self:CreateHarnessScriptProgram()
+		GedCreateOrEditScript(ged, self, "TestHarness", self.TestHarness)
+		PopulateParentTableCache(self)
+		ObjModified(self)
+	end)
+end
+
+function ScriptComponentDef:Test(root, prop_id, ged)
+	CreateRealTimeThread(function()
+		if self:IsDirty() then
+			GedSetUiStatus("lua_reload", "Saving...")
+			self:Save()
+			WaitMsg("Autorun")
+		end
+		
+		local eval, msg = self.TestHarness:Compile()
+		if not msg then -- compilation successful
+			local ok, result = procall(eval, self.GetTestParams())
+			if not ok then
+				msg = string.format("%s returned an error %s.", self.id, tostring(result))
+			elseif type(result) == "table" then
+				msg = string.format("%s returned a %s.\n\nCheck the newly opened Inspector window in-game.", self.id, result.class or "table")
+				Inspect(result)
+			else
+				msg = string.format("%s returned '%s'.", self.id, tostring(result))
+			end
+		end
+		ged:ShowMessage("Test Result", msg)
+		ObjModified(self.TestHarness)
+	end)
+end
+
+function ScriptComponentDef:GetError()
+	if self.EditorName == "" then
+		return { "Please set Menu name.", hintColor }
+	elseif self.EditorSubmenu == "" then
+		return { "Please set Menu category.", hintColor }
+	elseif self.CodeTemplate == "" and self.DefGenerateCode == empty_func then
+		return { "Please set either a CodeTemplate string, or a GenerateCode function.", hintColor }
+	end
+end
+
+
+DefineClass.ScriptConditionDef = {
+	__parents = { "ScriptComponentDef" },
+	properties = {
+		{ category = "Condition", id = "DefHasNegate", name = "Has Negate", editor = "bool", default = false, },
+		{ category = "Condition", id = "DefHasGetEditorView", name = "Has GetEditorView", editor = "bool", default = false, },
+		{ category = "Condition", id = "DefAutoPrependParam1", name = "Auto-prepend '<Param1>:'", editor = "bool", default = true,
+			no_edit = function(self) return self.DefHasGetEditorView or self.Params == "" end },
+		{ category = "Condition", id = "DefEditorView", name = "EditorView", editor = "text", translate = false, default = "",
+			no_edit = function(self) return self.DefHasGetEditorView end, dont_save = function(self) return self.DefHasGetEditorView end, },
+		{ category = "Condition", id = "DefEditorViewNeg", name = "EditorViewNeg", editor = "text", translate = false, default = "",
+			no_edit = function(self) return self.DefHasGetEditorView or not self.DefHasNegate end, dont_save = function(self) return self.DefHasGetEditorView or not self.DefHasNegate end, },
+		{ category = "Condition", id = "DefGetEditorView", name = "GetEditorView", editor = "func", params = "self", default = empty_func,
+			no_edit = function(self) return not self.DefHasGetEditorView end, dont_save = function(self) return not self.DefHasGetEditorView end },
+	},
+	group = "Conditions",
+	DefParentClassList = { "ScriptCondition" },
+	GedEditor = "ClassDefEditor",
+}
+
+function ScriptConditionDef:GenerateConsts(code)
+	if self.DefHasNegate then
+		code:append("\tHasNegate = true,\n")
+	end
+	if not self.DefHasGetEditorView then
+		local ev, evneg = self.DefEditorView, self.DefEditorViewNeg
+		if self.DefAutoPrependParam1 and self.Params ~= "" then
+			ev    = "<Param1>: " .. ev
+			evneg = "<Param1>: " .. evneg
+		end
+		code:append("\tEditorView = Untranslated(\"", self:SubstituteParamNames(ev, "", "in_tag"), "\"),\n")
+		if self.DefHasNegate then
+			code:append("\tEditorViewNeg = Untranslated(\"", self:SubstituteParamNames(evneg, "", "in_tag"), "\"),\n")
+		end
+	end
+	ScriptComponentDef.GenerateConsts(self, code)
+end
+
+function ScriptConditionDef:GenerateMethods(code)
+	if self.DefHasGetEditorView then
+		local method_def = ClassMethodDef:new{ name = "GetEditorView", code = self.DefGetEditorView }
+		method_def:GenerateCode(code, self.id)
+	end
+	ScriptComponentDef.GenerateMethods(self, code)
+end
+
+function ScriptConditionDef:CreateHarnessScriptProgram()
+	local test_obj = g_Classes[self.id]:new()
+	local program = ScriptTestHarnessProgram:new{
+		Params = self.Params,
+		ScriptReturn:new{ test_obj }
+	}
+	PopulateParentTableCache(program)
+	test_obj:OnAfterEditorNew()
+	return program
+end
+
+function ScriptConditionDef:GetError()
+	if self.DefHasNegate then
+		if (self.DefEditorView == "" or self.DefEditorViewNeg == "") and self.DefGetEditorView == empty_func then
+			return { "Please either set EditorView and EditorViewNeg, or define a GetEditorView method.", hintColor }
+		end
+	else
+		if self.DefEditorView == "" and self.DefGetEditorView == empty_func then
+			return { "Please either set EditorView, or define a GetEditorView method.", hintColor }
+		end
+	end
+end
+
+
+DefineClass.ScriptEffectDef = {
+	__parents = { "ScriptComponentDef" },
+	properties = {
+		{ category = "Condition", id = "DefHasGetEditorView", name = "Has GetEditorView", editor = "bool", default = false, },
+		{ category = "Condition", id = "DefAutoPrependParam1", name = "Auto-prepend '<Param1>:'", editor = "bool", default = true,
+			no_edit = function(self) return self.DefHasGetEditorView or self.Params == "" end },
+		{ category = "Condition", id = "DefEditorView", name = "EditorView", editor = "text", translate = false, default = "",
+			no_edit = function(self) return self.DefHasGetEditorView end, dont_save = function(self) return self.DefHasGetEditorView end, },
+		{ category = "Condition", id = "DefGetEditorView", name = "GetEditorView", editor = "func", params = "self", default = empty_func,
+			no_edit = function(self) return not self.DefHasGetEditorView end, dont_save = function(self) return not self.DefHasGetEditorView end, },
+	},
+	group = "Effects",
+	DefParentClassList = { "ScriptSimpleStatement" },
+	GedEditor = "ClassDefEditor",
+}
+
+function ScriptEffectDef:GenerateConsts(code)
+	if not self.DefHasGetEditorView then
+		local ev = self.DefEditorView
+		if self.DefAutoPrependParam1 and self.Params ~= "" then
+			ev = "<Param1>: " .. ev
+		end
+		code:append("\tEditorView = Untranslated(\"", self:SubstituteParamNames(ev, "", "in_tag"), "\"),\n")
+	end
+	ScriptComponentDef.GenerateConsts(self, code)
+end
+
+function ScriptEffectDef:GenerateMethods(code)
+	if self.DefHasGetEditorView then
+		local method_def = ClassMethodDef:new{ name = "GetEditorView", code = self.DefGetEditorView }
+		method_def:GenerateCode(code, self.id)
+	end
+	ScriptComponentDef.GenerateMethods(self, code)
+end
+
+function ScriptEffectDef:CreateHarnessScriptProgram()
+	local test_obj = g_Classes[self.id]:new()
+	local program = ScriptTestHarnessProgram:new{ [1] = test_obj, Params = self.Params }
+	PopulateParentTableCache(program)
+	test_obj:OnAfterEditorNew()
+	return program
+end
+
+function ScriptEffectDef:GetError()
+	if self.DefEditorView == "" and self.DefGetEditorView == empty_func then
+		return { "Please either set EditorView, or define a GetEditorView method.", hintColor }
+	end
+end

CommonLua/Classes/ClassDefSubItem.lua

@@ -0,0 +1,1476 @@
+DefineClass.ClassDefSubItem = {
+	__parents = { "PropertyObject" },
+}
+
+function ClassDefSubItem:ToStringWithColor(value, t)
+	local text = t and value or ValueToLuaCode(value)
+	t = t or type(value)
+	local color
+	if t == "string" or IsT(value) then
+		color = RGB(60, 140, 40)
+	elseif t == "boolean" or t == "nil" then
+		color = RGB(75, 105, 198)
+	elseif t == "number" then
+		color = RGB(150, 50, 20)
+	elseif t == "function" then
+		text = string.gsub(text, "^function ", "<color 75 105 198>function</color><color 92 92 92>")
+		text = string.gsub(text, "end$", "<color 75 105 198>end</color>")
+	end
+	if not color then
+		return text
+	end
+	local r, g, b = GetRGB(color)
+	return string.format("<color %s %s %s><tags off>%s<tags on></color>", r, g, b, text)
+end
+
+
+----- PropertyDef
+
+local function GetCategoryItems(self)
+	local categories = PresetGroupCombo("PropertyCategory", "Default")()
+	local parent
+	ForEachPreset("ClassDef", function(preset)
+		parent = parent or table.find(preset, self) and preset
+	end)
+	if parent then
+		local tmp = table.invert(categories)
+		for _, prop in ipairs(parent) do
+			if IsKindOf(prop, "PropertyDef") then
+				tmp[prop.category or ""] = true
+			end
+		end
+		categories = table.keys(tmp)
+	end
+	table.sort(categories, function(a, b)
+		if a and b then
+			return a < b
+		else
+			return b
+		end
+	end)
+	return categories
+end
+
+local reusable_expressions = {
+	dont_save = "Don't save",
+	read_only = "Read only",
+	no_edit = "Hidden",
+	no_validate = "No validation",
+}
+
+local function reusable_expressions_combo(self)
+	local ret = {
+		{ text = "true", value = true },
+		{ text = "false", value = false },
+		{ text = "expression", value = "expression"},
+	}
+	local preset = GetParentTableOfKind(self, "ClassDef")
+	for _, property_def in ipairs(preset) do
+		if IsKindOf(property_def, "PropertyDef") then
+			for id, name in pairs(reusable_expressions) do
+				if property_def[id] == "expression" then
+					table.insert(ret, {
+						text = "Reuse " .. name .. " from " .. property_def.id,
+						value = property_def.id .. "." .. id
+					})
+				end
+			end
+		end
+	end
+	return ret
+end
+
+function ValidateIdentifier(self, value)
+	return (type(value) ~= "string" or not value:match("^[%a_][%w_]*$")) and "Please enter a valid identifier"
+end
+
+DefineClass.PropertyDef = {
+	__parents = { "ClassDefSubItem" },
+	properties = {
+		{ category = "Property", id = "category", name = "Category", editor = "combo", items = GetCategoryItems, default = false, },
+		{ category = "Property", id = "id", name = "Id", editor = "text", default = "", validate = ValidateIdentifier },
+		{ category = "Property", id = "name", name = "Name", editor = "text", translate = function(self) return self.translate_in_ged end, default = false },
+		{ category = "Property", id = "help", name = "Help", editor = "text", translate = function(self) return self.translate_in_ged end, lines = 1, max_lines = 3, default = false },
+		
+		{ category = "Property", id = "dont_save", name = "Don't save", editor = "choice", default = false, items = reusable_expressions_combo },
+		{ category = "Property", id = "dont_save_expression", name = "Don't save", editor = "expression", default = return_true, params = "self, prop_meta",
+			no_edit = function(self) return type(self.dont_save) == "boolean" end,
+			read_only = function(self) return self.dont_save ~= "expression" end,
+			dont_save = function(self) return self.dont_save ~= "expression" end, },
+		{ category = "Property", id = "read_only", name = "Read only", editor = "choice", default = false, items = reusable_expressions_combo },
+		{ category = "Property", id = "read_only_expression", name = "Read only", editor = "expression", default = return_true, params = "self, prop_meta",
+			no_edit = function(self) return type(self.read_only) == "boolean" end,
+			read_only = function(self) return self.read_only ~= "expression" end,
+			dont_save = function(self) return self.read_only ~= "expression" end, },
+		{ category = "Property", id = "no_edit", name = "Hidden", editor = "choice", default = false, items = reusable_expressions_combo },
+		{ category = "Property", id = "no_edit_expression", name = "Hidden", editor = "expression", default = return_true, params = "self, prop_meta",
+			no_edit = function(self) return type(self.no_edit) == "boolean" end,
+			read_only = function(self) return self.no_edit ~= "expression" end,
+			dont_save = function(self) return self.no_edit ~= "expression" end, },
+		{ category = "Property", id = "no_validate", name = "No validation", editor = "choice", default = false, items = reusable_expressions_combo },
+		{ category = "Property", id = "no_validate_expression", name = "No validation", editor = "expression", default = return_true,  params = "self, prop_meta",
+			no_edit = function(self) return type(self.no_validate) == "boolean" end,
+			read_only = function(self) return self.no_validate ~= "expression" end,
+			dont_save = function(self) return self.no_validate ~= "expression" end, },
+		
+		{ category = "Property", id = "buttons", name = "Buttons", editor = "nested_list", base_class = "PropertyDefPropButton", default = false, inclusive = true, 
+		  help = "Button function is searched by name in the object, the root parent (Preset?), and then globally.\n\nParameters are (self, root, prop_id, ged) for the object method, (root, obj, prop_id, ged) otherwise." },
+		{ category = "Property", id = "template", name = "Template", editor = "bool", default = false, help = "Marks template properties for classes which inherit 'ClassTemplate'"},
+		{ category = "Property", id = "validate", name = "Validate", editor = "expression", params = "self, value", help = "A function called by Ged when changing the value. Returns error, updated_value."},
+		{ category = "Property", id = "extra_code", name = "Extra Code", editor = "text", lines = 1, max_lines = 5, default = false, help = "Additional code to insert in the property metadata" },
+	},
+	editor = false,
+	validate = false,
+	context = false,
+	gender = false,
+	os_path = false,
+	translate_in_ged = false,
+}
+
+function PropertyDef:GetEditorView()
+	local category = ""
+	if self.category then
+		category = string.format("<color 45 138 138>[%s]</color> ", self.category)
+	end
+	return string.format("%s<color 75 105 198>%s</color> %s <color 158 158 158>=</color> <color 150 90 40>%s",
+		category, self.editor, self.id, self:ToStringWithColor(self.default))
+end
+
+local function getTranslatableValue(text, translate)
+	if not text or text == "" then return end
+	if text then
+		assert(IsT(text) == translate)
+	end
+	return text
+end
+
+local reuse_error_fn = function() return "Unable to locate expression to reuse." end
+local reuse_prop_ids = { dont_save_expression = "dont_save", read_only_expression = "read_only", no_edit_expression = "no_edit", no_validate_expression = "no_validate" }
+
+function PropertyDef:GetProperty(prop)
+	local main_prop_id = reuse_prop_ids[prop]
+	if main_prop_id then
+		local value = self:GetProperty(main_prop_id)
+		if type(value) == "string" and value ~= "expression" then
+			local reuse_prop_id, reuse = value:match("([%w_]+)%.([%w_]+)")
+			if reuse then
+				local preset = GetParentTableOfKind(self, "ClassDef")
+				local property_def = table.find_value(preset, "id", reuse_prop_id)
+				return property_def and property_def[reuse .. "_expression"] or reuse_error_fn
+			end
+		end
+	end
+	return ClassDefSubItem.GetProperty(self, prop)
+end
+
+function PropertyDef:GenerateExpressionSettingCode(code, id)
+	local value = self[id]
+	if type(value) ~= "boolean" then
+		local expr = self:GetProperty(id .. "_expression")
+		if expr ~= reuse_error_fn then
+			code:appendf("%s = function(self) %s end, ", id, GetFuncBody(expr))
+		end
+	elseif value then
+		code:appendf("%s = true, ", id)
+	end
+end
+
+function PropertyDef:GenerateCode(code, translate, extra_code_fn)
+	if self.id == "" then return end
+	code:append("\t\t{ ")
+	if self.category and self.category ~= "" then
+		code:appendf("category = \"%s\", ", self.category)
+	end
+	code:append("id = \"", self.id, "\", ")
+	local name, help = getTranslatableValue(self.name, translate), getTranslatableValue(self.help, translate)
+	if name then
+		code:append("name = ", ValueToLuaCode(name), ", ")
+	end
+	if help then
+		code:append("help = ", ValueToLuaCode(help), ", ")
+	end
+	code:append("\n\t\t\t")
+	code:appendf("editor = \"%s\", default = %s, ", self.editor, self:GenerateDefaultValueCode())
+	
+	self:GenerateExpressionSettingCode(code, "dont_save")
+	self:GenerateExpressionSettingCode(code, "read_only")
+	self:GenerateExpressionSettingCode(code, "no_edit")
+	self:GenerateExpressionSettingCode(code, "no_validate")
+	if self.validate then
+		code:appendf("validate = function(self, value) %s end, ", GetFuncBody(self.validate))
+	end
+	
+	if self.buttons and #self.buttons > 0 then
+		code:append("buttons = {")
+		for _, data in ipairs(self.buttons) do
+			if data.Name ~= "" then
+				if data.IsHidden ~= empty_func then
+					code:appendf([[ {name = "%s", func = "%s", is_hidden = function(self) %s end }, ]], data.Name, data.FuncName, GetFuncBody(data.IsHidden))
+				else
+					code:appendf([[ {name = "%s", func = "%s"}, ]], data.Name, data.FuncName)
+				end
+			end
+		end
+		code:append("}, ")
+	end
+	if self.template then code:append("template = true, ") end
+	if self.extra_code and self.extra_code ~= "" or extra_code_fn then
+		local ext_code = self.extra_code and self.extra_code:gsub(",$", "")
+		if extra_code_fn then
+			ext_code = ext_code and (ext_code .. ", " .. extra_code_fn(self)) or extra_code_fn(self)
+			ext_code = ext_code:gsub(",$", "")
+		end
+		if ext_code and ext_code ~= "" then
+			code:append("\n\t\t\t", ext_code)
+			code:append(", ")
+		end
+	end
+	self:GenerateAdditionalPropCode(code, translate)
+	code:append("},\n")
+end
+
+function PropertyDef:GenerateDefaultValueCode()
+	return ValueToLuaCode(self.default, ' ', nil, {} --[[ enable property injection ]])
+end
+
+function PropertyDef:ValidateProperty(prop_meta)
+	if not self.no_validate then
+		return PropertyObject.ValidateProperty(self, prop_meta)
+	end
+end
+
+function PropertyDef:GenerateAdditionalPropCode(code, translate)
+end
+
+function PropertyDef:AppendFunctionCode(code, prop_name)
+	if not self[prop_name] then return end
+	local name, params, body = GetFuncSource(self[prop_name])
+	code:appendf("%s = function (%s)\n", prop_name, params)
+	if type(body) == "string" then
+		body = string.split(body, "\n")
+	end
+	code:append("\t", body and table.concat(body, "\n\t") or "", "\n")
+	code:append("end, \n")
+end
+
+function PropertyDef:GetError()
+	if not self.no_validate and self.extra_code and (self.extra_code:find("[^%w_]items%s*=") or self.extra_code:find("^items%s*=")) then
+		return "Please don't define 'items' as extra code. Use the dedicated Items property instead.\nThis is to make items appear in the default value property."
+	end
+end
+
+function PropertyDef:CleanupForSave()
+end
+
+function PropertyDef:EmulatePropEval(metadata_id, default, prop_meta, validate_fn)
+	local prop_meta = self
+	local classdef_preset = GetParentTableOfKind(self, "ClassDef")
+	if not classdef_preset then return default end
+	local obj_class = g_Classes[classdef_preset.id]
+	local instance = obj_class and not obj_class:IsKindOf("CObject") and obj_class:new() or {}
+	if validate_fn then
+		return eval_items(prop_meta[metadata_id], instance, prop_meta)
+	end
+	return prop_eval(prop_meta[metadata_id], instance, prop_meta, default)
+end
+
+local function EmulatePropEval(metadata_id, default)
+	return function(self, prop_meta, validate_fn)
+		return self:EmulatePropEval(metadata_id, default, prop_meta, validate_fn)
+	end
+end
+
+DefineClass.PropertyDefPropButton = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "Name", editor = "text", default = ""},
+		{ id = "FuncName", editor = "text", default = ""},
+		{ id = "IsHidden", editor = "expression", default = empty_func},
+	},
+	EditorView = Untranslated("[<Name>] = <FuncName>"),
+}
+
+DefineClass.PropertyDefButtons = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ id = "default", name = "Default value", editor = false, default = false, },
+	},	
+	editor = "buttons",
+	EditorName = "Buttons property",
+	EditorSubmenu = "Extras",
+}
+
+DefineClass.PropertyDefBool = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Bool", id = "default", name = "Default value", editor = "bool", default = false, },
+	},
+	editor = "bool",
+	EditorName = "Bool property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefTable = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Table", id = "default", name = "Default value", editor = "prop_table", default = false, },
+		{ category = "Table", id = "lines",   name = "Lines",         editor = "number", default = 1, },
+	},
+	editor = "prop_table",
+	EditorName = "Table property",
+	EditorSubmenu = "Objects",
+}
+
+function PropertyDefTable:GenerateAdditionalPropCode(code, translate)
+	if self.lines > 1 then
+		code:append("indent = \"\", lines = 1, max_lines = ", self.lines, ", ")
+	end
+end
+
+DefineClass.PropertyDefPoint = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Point", id = "default", name = "Default value", editor = "point", default = false, },
+	},
+	editor = "point",
+	EditorName = "Point property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefPoint2D = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Point2D", id = "default", name = "Default value", editor = "point2d", default = false, },
+	},
+	editor = "point2d",
+	EditorName = "Point2D property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefRect = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Rect", id = "default", name = "Default value", editor = "rect", default = false, },
+	},
+	editor = "rect",
+	EditorName = "Rect property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefMargins = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Margins", id = "default", name = "Default value", editor = "margins", default = false, },
+	},
+	editor = "margins",
+	EditorName = "Margins property",
+	EditorSubmenu = "Extras",
+}
+
+DefineClass.PropertyDefPadding = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Padding", id = "default", name = "Default value", editor = "padding", default = false, },
+	},
+	editor = "padding",
+	EditorName = "Padding property",
+	EditorSubmenu = "Extras",
+}
+
+DefineClass.PropertyDefBox = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Box", id = "default", name = "Default value", editor = "box", default = false, },
+	},
+	editor = "box",
+	EditorName = "Box property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefNumber = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Number", id = "default", name = "Default value", editor = "number", default = false, scale = function(obj) return obj.scale end, min = function(obj) return obj.min end, max = function(obj) return obj.max end, },
+		{ category = "Number", id = "scale", name = "Scale", editor = "choice", default = 1, items = function() return table.keys2(const.Scale, true, 1, 10, 100, 1000, 1000000) end, },
+		{ category = "Number", id = "step", name = "Step", editor = "number", default = 1, scale = function(obj) return obj.scale end, },
+		{ category = "Number", id = "float", name = "Float", editor = "bool", default = false, },
+		{ category = "Number", id = "slider", name = "Slider", editor = "bool", default = false, },
+		{ category = "Number", id = "min", name = "Min", editor = "number", default = min_int64, scale = function(obj) return obj.scale end, no_edit = PropChecker("custom_lims", true)},
+		{ category = "Number", id = "max", name = "Max", editor = "number", default = max_int64, scale = function(obj) return obj.scale end, no_edit = PropChecker("custom_lims", true) },
+		{ category = "Number", id = "custom_min", name = "Min", editor = "expression", default = false, no_edit = PropChecker("custom_lims", false) },
+		{ category = "Number", id = "custom_max", name = "Max", editor = "expression", default = false, no_edit = PropChecker("custom_lims", false) },
+		{ category = "Number", id = "custom_lims", name = "Custom Lims", editor = "bool", default = false, help = "Use custom limits"},
+		{ category = "Number", id = "modifiable", name = "Modifiable", editor = "bool", default = false, help = "Marks modifiable properties for classes which inherit 'Modifiable' class"},
+	},
+	editor = "number",
+	EditorName = "Number property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefNumber:GenerateAdditionalPropCode(code, translate)
+	local scale = self.scale
+	if scale ~= 1 then
+		code:appendf(type(scale) == "number" and "scale = %d, " or "scale = \"%s\", ", scale)
+	end
+	if self.step ~= 1 then code:appendf("step = %d, ", self.step) end
+	if self.slider then code:append("slider = true, ") end
+	if self.custom_lims then
+		if self.custom_min ~= PropertyDefNumber.custom_min then
+			local name, params, body = GetFuncSource(self.custom_min)
+			body = type(body) == "table" and table.concat(body, "\n") or body
+			code:appendf("min = function(self) %s end, ", body)
+		end
+		if self.custom_max ~= PropertyDefNumber.custom_max then
+			local name, params, body = GetFuncSource(self.custom_max)
+			body = type(body) == "table" and table.concat(body, "\n") or body
+			code:appendf("max = function(self) %s end, ", body)
+		end
+	else
+		if self.min ~= PropertyDefNumber.min then code:appendf("min = %d, ", self.min) end
+		if self.max ~= PropertyDefNumber.max then code:appendf("max = %d, ", self.max) end
+	end
+	if self.modifiable then code:append("modifiable = true, ") end
+end
+
+function PropertyDefNumber:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "slider" and self.slider then
+		if self.min == PropertyDefNumber.min then self.min = 0 end
+		if self.max == PropertyDefNumber.max then self.max = 100 * (const.Scale[self.scale] or self.scale) end
+	end
+end
+
+DefineClass.PropertyDefRange = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Range", id = "default", name = "Default value", editor = "range", scale = function(obj) return obj.scale end, min = function(obj) return obj.min end, max = function(obj) return obj.max end, default = false, },
+		{ category = "Range", id = "scale", name = "Scale", editor = "choice", default = 1, items = function() return table.keys2(const.Scale, true, 1, 10, 100, 1000, 1000000) end, },
+		{ category = "Range", id = "step", name = "Step", editor = "number", default = 1, scale = function(obj) return obj.scale end, },
+		{ category = "Range", id = "slider", name = "Slider", editor = "bool", default = false, },
+		{ category = "Range", id = "min", name = "Min", editor = "number", default = min_int64 },
+		{ category = "Range", id = "max", name = "Max", editor = "number", default = max_int64 },
+	},
+	editor = "range",
+	EditorName = "Range property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefRange:GenerateAdditionalPropCode(code, translate)
+	if self.scale ~= 1 then
+		code:appendf(type(self.scale) == "number" and "scale = %d, " or "scale = \"%s\", ", self.scale)
+	end
+	if self.step ~= 1 then code:appendf("step = %d, ", self.step) end
+	if self.slider then code:append("slider = true, ") end
+	if self.min ~= PropertyDefRange.min then code:appendf("min = %d, ", self.min) end
+	if self.max ~= PropertyDefRange.max then code:appendf("max = %d, ", self.max) end
+end
+
+function PropertyDefRange:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "slider" and self.slider then
+		if self.min == PropertyDefRange.min then self.min = 0 end
+		if self.max == PropertyDefRange.max then self.max = 100 * (const.Scale[self.scale] or self.scale) end
+	end
+end
+
+local function translate_only(obj) return not obj.translate end
+TextGenderOptions = {
+	{value = false, text = "None"},
+	{value = "ask", text = "Request translation gender for each language (for nouns)"},
+	{value = "variants", text = "Generate separate translation texts for each gender"},
+}
+
+DefineClass.PropertyDefText = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Text", id = "default", name = "Default value", editor = "text", default = false, translate = function (obj) return obj.translate end, },
+		{ category = "Text", id = "translate", name = "Translate", editor = "bool", default = true, },
+		{ category = "Text", id = "wordwrap", name = "Wordwrap", editor = "bool", default = false, },
+		{ category = "Text", id = "gender", name = "Gramatical gender", editor = "choice", default = false, items = TextGenderOptions,
+			no_edit = translate_only, dont_save = translate_only },
+		{ category = "Text", id = "lines", name = "Lines", editor = "number", default = false, },
+		{ category = "Text", id = "max_lines", name = "Max lines", editor = "number", default = false, },
+		{ category = "Text", id = "trim_spaces", name = "Trim Spaces", editor = "bool", default = true, },
+		{ category = "Text", id = "context", name = "Context", editor = "text", default = "", 
+			no_edit = translate_only, dont_save = translate_only }
+	},
+	editor = "text",
+	EditorName = "Text property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefText:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "translate" then
+		self:UpdateLocalizedProperty("default", self.translate)
+	end
+end
+
+function PropertyDefText:GenerateAdditionalPropCode(code, translate)
+	if self.translate then code:append("translate = true, ") end
+	if self.wordwrap then code:append("wordwrap = true, ") end
+	if self.lines then code:appendf("lines = %d, ", self.lines) end
+	if self.max_lines then code:appendf("max_lines = %d, ", self.max_lines) end	
+	if self.trim_spaces==false then	code:append("trim_spaces = false, ") end
+	local context = self.translate and self.context or ""
+	if context ~= "" then
+		assert(not self.gender, "Custom context code is not compatible with gender specification") -- you should include |gender-ask or |gender-variants in the function result
+		code:append("context = ", context, ", ")
+	elseif self.gender then
+		code:append('context = "|gender-', self.gender, '", ')
+	end
+end
+
+DefineClass.PropertyDefChoice = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Choice", id = "default", name = "Default value", editor = "choice", default = false, items = EmulatePropEval("items", {""}) },
+		{ category = "Choice", id = "items", name = "Items", editor = "expression", default = false, },
+		{ category = "Choice", id = "show_recent_items", name = "Show recent items", editor = "number", default = 0, },
+	},
+	translate = false,
+	editor = "choice",
+	EditorName = "Choice property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefChoice:GenerateAdditionalPropCode(code, translate)
+	if self.items then
+		code:append("items = ")
+		ValueToLuaCode(self.items, nil, code)
+		code:append(", ")
+	end
+	if self.show_recent_items and self.show_recent_items ~= 0 then
+		code:appendf("show_recent_items = %d,", self.show_recent_items)
+	end
+end
+
+function PropertyDefChoice:GetConvertToPresetIdClass()
+	local preset_class
+	if self.items then
+		local src = GetFuncSourceString(self.items)
+		local _, _, capture = string.find(src, 'PresetsCombo%("([%w_+-]*)"%)')
+		preset_class = capture
+	end
+	return preset_class
+end
+
+DefineClass.PropertyDefCombo = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Combo", id = "default", name = "Default value", editor = "combo", default = false, items = EmulatePropEval("items", {""}) },
+		{ category = "Combo", id = "items", name = "Items", editor = "expression", default = false, },
+		{ category = "Combo", id = "translate", name = "Translate", editor = "bool", default = false, },
+		{ category = "Combo", id = "show_recent_items", name = "Show recent items", editor = "number", default = 0, },
+	},
+	editor = "combo",
+	EditorName = "Combo property",
+	EditorSubmenu = "Basic property",
+}
+
+PropertyDefCombo.GenerateAdditionalPropCode = PropertyDefChoice.GenerateAdditionalPropCode
+
+DefineClass.PropertyDefPickerBase = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Picker", id = "default", name = "Default value", editor = "combo", default = false, items = EmulatePropEval("items", {""}) },
+		{ category = "Picker", id = "items", name = "Items", editor = "expression", default = false, },
+		{ category = "Picker", id = "max_rows", name = "Max rows", editor = "number", default = false, help = "Maximum number of rows displayed." },
+		{ category = "Picker", id = "multiple", name = "Multiple selection", editor = "bool", default = false, },
+		{ category = "Picker", id = "small_font", name = "Small font", editor = "bool", default = false, },
+		{ category = "Picker", id = "filter_by_prop", name = "Filter by prop", editor = "text", default = false, help = "Links this property to a text property with the specified id that serves as a filter." },
+	},
+}
+
+function PropertyDefPickerBase:GenerateAdditionalPropCode(code, translate)
+	PropertyDefChoice.GenerateAdditionalPropCode(self, code, translate)
+	if self.max_rows       then code:appendf("max_rows = %d, ", self.max_rows) end
+	if self.multiple       then code:append ("multiple = true, ") end
+	if self.small_font     then code:append ("small_font = true, ") end
+	if self.filter_by_prop then code:appendf("filter_by_prop = \"%s\", ", self.filter_by_prop) end
+end
+
+DefineClass.PropertyDefTextPicker = {
+	__parents = { "PropertyDefPickerBase" },
+	properties = {
+		{ category = "Picker", id = "horizontal", name = "Horizontal", editor = "bool", default = false, help = "Display items horizontally." },
+	},
+	editor = "text_picker",
+	EditorName = "Text picker property",
+	EditorSubmenu = "Extras",
+}
+
+function PropertyDefTextPicker:GenerateAdditionalPropCode(code, translate)
+	PropertyDefPickerBase.GenerateAdditionalPropCode(self, code, translate)
+	if self.horizontal then code:append("horizontal = true, ") end
+end
+
+DefineClass.PropertyDefTexturePicker = {
+	__parents = { "PropertyDefPickerBase" },
+	properties = {
+		{ category = "Picker", id = "thumb_width", name = "Width", editor = "number", default = false, },
+		{ category = "Picker", id = "thumb_height", name = "Height", editor = "number", default = false, },
+		{ category = "Picker", id = "thumb_zoom", name = "Zoom", editor = "number", min = 100, max = 200, slider = true, default = false, help = "Scale the texture up, displaying only the middle part with Width x Height dimensions.", },
+		{ category = "Picker", id = "alt_prop", name = "Alt prop", editor = "text", default = false, help = "Id of another property that gets set by Alt-click on this property.", },
+		{ category = "Picker", id = "base_color_map", name = "Base color map", editor = "bool", default = false, help = "Use to display a base color map texture in the correct colors.", },
+	},
+	editor = "texture_picker",
+	EditorName = "Texture picker property",
+	EditorSubmenu = "Extras",
+}
+
+function PropertyDefTexturePicker:GenerateAdditionalPropCode(code, translate)
+	PropertyDefPickerBase.GenerateAdditionalPropCode(self, code, translate)
+	if self.thumb_width    then code:appendf("thumb_width = %d, ", self.thumb_width) end
+	if self.thumb_height   then code:appendf("thumb_height = %d, ", self.thumb_height) end
+	if self.thumb_zoom     then code:appendf("thumb_zoom = %d, ", self.thumb_zoom) end
+	if self.alt_prop       then code:appendf("alt_prop = \"%s\", ", self.alt_prop) end
+	if self.base_color_map then code:append ("base_color_map = true, ") end
+end
+
+DefineClass.PropertyDefSet = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Set", id = "default", name = "Default value", editor = "set", default = false, items = EmulatePropEval("items", {""}), three_state = function(obj) return obj.three_state end, max_items_in_set = function(obj) return obj.max_items_in_set end, },
+		{ category = "Set", id = "items", name = "Items", editor = "expression", default = false, },
+		{ category = "Set", id = "arbitrary_value", name = "Allow arbitrary value", editor = "bool", default = false, },
+		{ category = "Set", id = "three_state", name = "Three-state", editor = "bool", default = false, help = "Each set item can have one of the three value 'nil', 'true', or 'false'." },
+		{ category = "Set", id = "max_items_in_set", name = "Max items", editor = "number", default = 0, help = "Max number of items in the set (0 = no limit)." },
+	},
+	translate = false,
+	editor = "set",
+	EditorName = "Set property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefSet:GenerateAdditionalPropCode(code, translate)
+	if self.three_state then code:append("three_state = true, ") end
+	if self.arbitrary_value then code:append("arbitrary_value = true, ") end
+	if self.max_items_in_set ~= 0 then code:appendf("max_items_in_set = %d, ", self.max_items_in_set) end
+	if self.items then 
+		code:append("items = ")
+		ValueToLuaCode(self.items, nil, code)
+		code:append(", ")
+	end
+end
+
+DefineClass.PropertyDefGameStatefSet = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Set", id = "default", name = "Default value", editor = "set", default = false, items = function() return GetGameStateFilter() end, three_state = true, },
+	},
+	translate = false,
+	editor = "set",
+	EditorName = "GameState Set property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefGameStatefSet:GenerateAdditionalPropCode(code, translate)
+	code:append("three_state = true, items = function (self) return GetGameStateFilter() end, ")
+	code:append('buttons = { {name = "Check Game States", func = "PropertyDefGameStatefSetCheck"}, },')
+end
+
+function PropertyDefGameStatefSetCheck(_, obj, prop_id, ged)
+	ged:ShowMessage("Test Result", GetMismatchGameStates(obj[prop_id]))
+end
+
+DefineClass.PropertyDefColor = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Color", id = "default", name = "Default value", editor = "color", default = RGB(0, 0, 0), },
+	},
+	editor = "color",
+	EditorName = "Color property",
+	EditorSubmenu = "Basic property",
+}
+
+DefineClass.PropertyDefImage = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Image", id = "default",        name = "Default value", editor = "image", default = false, },
+		{ category = "Image", id = "img_size",       name = "Image box", editor = "number", default = 200, },
+		{ category = "Image", id = "img_box",        name = "Image border", editor = "number", default = 1, },
+		{ category = "Image", id = "base_color_map", name = "Base color", editor = "bool", default = false, },
+	},
+	editor = "image",
+	EditorName = "Image preview property",
+	EditorSubmenu = "Extras",
+}
+
+function PropertyDefImage:GenerateAdditionalPropCode(code, translate)
+	code:appendf("img_size = %d, img_box = %d, base_color_map = %s, ", self.img_size, self.img_box, tostring(self.base_color_map)) 
+end
+
+DefineClass.PropertyDefGrid = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Grid", id = "default", name = "Default value", editor = "grid", default = false, },
+		{ category = "Grid", id = "frame",   name = "Frame", editor = "number", default = 0, },
+		{ category = "Grid", id = "color",   name = "Color", editor = "bool", default = false },
+		{ category = "Grid", id = "min",     name = "Min Size", editor = "number", default = 0, },
+		{ category = "Grid", id = "max",     name = "Max Size", editor = "number", default = 0 },
+	},
+	editor = "grid",
+	EditorName = "Grid property",
+	EditorSubmenu = "Extras",
+}
+
+function PropertyDefGrid:GenerateAdditionalPropCode(code, translate)
+	if self.frame > 0 then code:appendf("frame = %d, ", self.frame) end
+	if self.min > 0 then code:appendf("min = %d, ", self.min) end
+	if self.max > 0 then code:appendf("max = %d, ", self.max) end
+	if self.color then code:append("color = true, ") end
+end
+
+DefineClass.PropertyDefMaterial = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Color", id = "default", name = "Default value", editor = "rgbrm", default = RGBRM(200, 200, 200, 0, 0) },
+	},
+	editor = "rgbrm",
+	EditorName = "Material property",
+	EditorSubmenu = "Extras",
+}
+
+DefineClass.PropertyDefBrowse = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Browse", id = "default", name = "Default value", editor = "browse", default = false, },
+		{ category = "Browse", id = "folder", name = "Folder", editor = "text", default = "UI", },
+		{ category = "Browse", id = "filter", name = "Filter", editor = "text", default = "Image files|*.tga", },
+		{ category = "Browse", id = "extension", name = "Force extension", editor = "text", default = false,
+			buttons = { { name = "No extension", func = function(self) self.extension = "" ObjModified(self) end, } },
+		},
+		{ category = "Browse", id = "image_preview_size", name = "Image preview size", editor = "number", default = 0, },
+	},
+	editor = "browse",
+	EditorName = "Browse property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefBrowse:GenerateAdditionalPropCode(code, translate)
+	local folder, filter = self.folder or "", self.filter or ""
+	if folder ~= "" then
+		-- detect if we have a table or a single string for self.folder
+		if folder:match("^%s*[{\"]") then
+			code:appendf("folder = %s, ", self.folder)
+		else
+			code:appendf("folder = \"%s\", ", self.folder)
+		end
+	end
+	if self.filter    ~= "" then code:appendf("filter = \"%s\", ", self.filter) end
+	if self.extension ~= PropertyDefBrowse.extension then code:appendf("force_extension = \"%s\", ", self.extension) end
+	if self.image_preview_size > 0 then code:appendf("image_preview_size = %i, ", self.image_preview_size) end
+end
+
+
+DefineClass.PropertyDefUIImage = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Browse", id = "default", name = "Default value", editor = "ui_image", default = false, },
+		{ category = "Browse", id = "filter", name = "Filter", editor = "text", default = "All files|*.*", },
+		{ category = "Browse", id = "extension", name = "Force extension", editor = "text", default = false,
+			buttons = { { name = "No extension", func = function(self) self.extension = "" ObjModified(self) end, } },
+		},
+		{ category = "Browse", id = "image_preview_size", name = "Image preview size", editor = "number", default = 0, },
+	},
+	editor = "ui_image",
+	EditorName = "UI image property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefUIImage:GenerateAdditionalPropCode(code, translate)
+	if self.filter    ~= PropertyDefUIImage.filter    then code:appendf("filter = \"%s\", ", self.filter) end
+	if self.extension ~= PropertyDefUIImage.extension then code:appendf("force_extension = \"%s\", ", self.extension) end
+	if self.image_preview_size > 0 then code:appendf("image_preview_size = %i, ", self.image_preview_size) end
+end
+
+DefineClass.PropertyDefFunc = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Func", id = "params", name = "Params", editor = "text", default = "self", },
+		{ category = "Func", id = "default", name = "Default value", editor = "func", default = empty_func, lines = 1, max_lines = 20, params = function (self) return self.params end, },
+	},
+	editor = "func",
+	EditorName = "Func property",
+	EditorSubmenu = "Code",
+}
+
+function PropertyDefFunc:ToStringWithColor(value)
+	if value == empty_func then
+		return PropertyDef.ToStringWithColor(self, string.format("function (%s) end", self.params), "function")
+	end
+	return PropertyDef.ToStringWithColor(self, value)
+end
+
+
+function PropertyDefFunc:GenerateDefaultValueCode()
+	if not self.default then return "false" end
+	return GetFuncSourceString(self.default, "", self.params or "self")
+end
+
+function PropertyDefFunc:GenerateAdditionalPropCode(code, translate)
+	if self.params and self.params ~= "self" then
+		code:appendf("params = \"%s\", ", self.params)
+	end
+end
+
+DefineClass.PropertyDefExpression = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Expression", id = "params", name = "Params", editor = "text", default = "self", },
+		{ category = "Expression", id = "default", name = "Default value", editor = "expression", default = false, params = function(self) return self.params end, },
+	},
+	editor = "expression",
+	EditorName = "Expression property",
+	EditorSubmenu = "Code",
+}
+
+function PropertyDefExpression:GenerateDefaultValueCode()
+	if not self.default then return "false" end
+	return GetFuncSourceString(self.default, "", self.params or "self")
+end
+
+function PropertyDefExpression:GenerateAdditionalPropCode(code, translate)
+	if self.params and self.params ~= "self" then
+		code:appendf("params = \"%s\", ", self.params)
+	end
+end
+
+DefineClass.PropertyDefShortcut = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Expression", id = "shortcut_type", name = "Shortcut type", editor = "choice", default = "keyboard&mouse", items = {
+			"keyboard&mouse",
+			"keyboard",
+			"gamepad"
+		}, },
+		{ category = "Expression", id = "default", name = "Default value", editor = "text", default = "", no_edit = true, },
+	},
+	editor = "shortcut",
+	EditorName = "Shortcut property",
+	EditorSubmenu = "Extras",
+}
+
+function PropertyDefShortcut:GenerateAdditionalPropCode(code, translate)
+	code:appendf("shortcut_type = \"%s\", ", self.shortcut_type) 
+end
+
+----- Presets - preset_id & preset_id_list
+
+function IsPresetWithConstantGroup(classdef)
+	if not classdef then return end
+	local prop = classdef:GetPropertyMetadata("Group")
+	return not prop or prop_eval(prop.no_edit, classdef, prop, true) or prop_eval(prop.read_only, classdef, prop, true)	
+end
+
+DefineClass.PropertyDefPresetIdBase = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "PresetId", id = "preset_class", name = "Preset class", editor = "choice", default = "",
+			items = ClassDescendantsCombo("Preset", false, function(name, class)
+				return not IsKindOfClasses(class, "ClassDef", "ClassDefSubItem")
+			end),
+		},
+		{ category = "PresetId", id = "preset_group", name = "Preset group", editor = "choice", default = "",
+			help = "Restricts the choice to the specified group of the preset class.",
+			items = function(obj)
+				local class = g_Classes[obj.preset_class]
+				local preset_class = class.PresetClass or obj.preset_class
+				return class and PresetGroupsCombo(preset_class) or empty_table
+			end,
+			no_edit = function(obj) -- disable group restriction for classes with uneditable "Group" property
+				local class = g_Classes[obj.preset_class]
+				return not class or IsPresetWithConstantGroup(class)
+			end, },
+		{ category = "PresetId", id = "preset_filter", name = "PresetFilter", editor = "func", params = "preset, obj, prop_meta", lines = 1, max_lines = 20, default = false },
+		{ category = "PresetId", id = "extra_item", name = "Extra item", editor = "text", default = false },
+		{ category = "PresetId", id = "default", name = "Default value", editor = "choice",
+			items = function(obj)
+				local class = g_Classes[obj.preset_class]
+				if class and (class.GlobalMap or IsPresetWithConstantGroup(class) or obj.preset_group ~= "") then
+					return PresetsCombo(obj.preset_class, obj.preset_group ~= "" and obj.preset_group, {"", obj.extra_item or nil})
+				end
+				return { false }
+			end, default = false },
+	},
+	editor = "preset_id",
+	EditorName = "PresetId property",
+	EditorSubmenu = "Basic property",
+}
+
+function PropertyDefPresetIdBase:GenerateAdditionalPropCode(code, translate)
+	if self.preset_class ~= "" then code:appendf("preset_class = \"%s\", ", self.preset_class) end
+	if self.preset_group ~= "" then code:appendf("preset_group = \"%s\", ", self.preset_group) end
+	if self.extra_item         then code:appendf("extra_item = \"%s\", ",   self.extra_item)   end
+	self:AppendFunctionCode(code, "preset_filter")
+end
+
+function PropertyDefPresetIdBase:OnEditorSetProperty(prop_id, old_value, ...)
+	if prop_id == "preset_class" then
+		self.preset_group = nil
+		self.default = nil
+	elseif prop_id == "preset_group" then
+		self.default = nil
+	end
+	ObjModified(self)
+end
+
+function PropertyDefPresetIdBase:GetError()
+	local class = g_Classes[self.preset_class]
+	if class and not (class.GlobalMap or IsPresetWithConstantGroup(class) or self.preset_group ~= "") then
+		return string.format("%s doesn't have GlobalMap - all presets can't be listed. Please specify a Preset group.\n\nIf you want all presets to be selectable, either add GlobalMap, or create two properties - one for selecting a preset group and another for selecting a preset from that group.", self.preset_class)
+	end
+end
+
+DefineClass.PropertyDefPresetId = {
+	__parents = { "PropertyDefPresetIdBase" },
+}
+
+DefineClass.PropertyDefPresetIdList = {
+	__parents = { "PropertyDefPresetIdBase", "WeightedListProps" },
+	properties = {
+		{ category = "PresetId", id = "default", name = "Default value", editor = "preset_id_list",
+			preset_class = function(obj) return obj.preset_class end,
+			preset_group = function(obj) return obj.preset_group end,
+			extra_item = function(obj) return obj.extra_item end,
+			default = {}, },
+	},
+	editor = "preset_id_list",
+	EditorName = "PresetId list property",
+	EditorSubmenu = "Lists",
+}
+
+function PropertyDefPresetIdList:GenerateAdditionalPropCode(code, translate)
+	PropertyDefPresetIdBase.GenerateAdditionalPropCode(self, code, translate)
+	code:append("item_default = \"\"")
+	self:GenerateWeightPropCode(code)
+	code:append(", ")
+end
+
+
+----- Nested object & nested list
+
+local function BaseClassCombo(obj, prop_meta, validate_fn)
+	if validate_fn == "validate_fn" then
+		-- function for preset validation, checks whether the property value is from "items"
+		return "validate_fn", function(value, obj, prop_meta)
+			local class = g_Classes[value]
+			return value == "" or IsKindOf(class, "PropertyObject") and not IsKindOf(class, "CObject")
+		end
+	end
+	return ClassDescendantsList("PropertyObject", function(name, def)
+		return not def.__ancestors.CObject and name ~= "CObject"
+	end, "")
+end
+
+DefineClass.PropertyDefObject = {
+	__parents = { "PropertyDef" },
+	default = false,
+	editor = "object",
+	properties = {
+		{ category = "Property", id = "base_class", name = "Base class", editor = "choice", items = function() return ClassDescendantsListInclusive("Object") end, default = "Object" },
+		{ category = "Property", id = "format_func", name = "Format", editor = "func", default = GetObjectPropEditorFormatFuncDefault, lines = 1, max_lines = 10, params = "gameobj"},
+	},	
+	EditorName = "Object property",
+	EditorSubmenu = "Objects",
+}
+
+function PropertyDefObject:GenerateAdditionalPropCode(code, translate)
+	code:appendf("base_class = \"%s\", ", self.base_class)
+	self:AppendFunctionCode(code, "format_func")
+end
+
+DefineClass.PropertyDefNestedObj = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Nested Object", id = "base_class", name = "Base class", editor = "choice", items = BaseClassCombo, default = "PropertyObject" },
+		{ category = "Nested Object", id = "inclusive", name = "Allow base class", editor = "bool", default = false, },
+		{ category = "Nested Object", id = "no_descendants", name = "No descendants", editor = "bool", default = false, },
+		{ category = "Nested Object", id = "all_descendants", name = "Allow all descendants", editor = "bool", default = false, no_edit = function (self) return self.no_descendants end, },
+		{ category = "Nested Object", id = "class_filter", name = "ClassFilter", editor = "func", default = false, lines = 1, max_lines = 20, params = "name, class, obj"},
+		{ category = "Nested Object", id = "format", name = "Format in Ged", editor = "text", default = "<EditorView>", },
+		{ category = "Nested Object", id = "auto_expand", name = "Auto Expand", editor = "bool", default = false, },
+		{ category = "Nested Object", id = "default", name = "Default value", editor = "bool", default = false, no_edit = true, },
+	},
+	editor = "nested_obj",
+	EditorName = "Nested object property",
+	EditorSubmenu = "Objects",
+}
+
+function PropertyDefNestedObj:GenerateAdditionalPropCode(code, translate)
+	code:appendf("base_class = \"%s\", ", self.base_class)
+	if self.inclusive then code:append("inclusive = true, ") end
+	if self.no_descendants then code:append("no_descendants = true, ")
+	elseif self.all_descendants then code:append("all_descendants = true, ") end
+	if self.auto_expand then code:appendf("auto_expand = true, ") end
+	if self.format ~= PropertyDefNestedObj.format then code:appendf("format = \"%s\"", self.format) end
+	self:AppendFunctionCode(code, "class_filter")
+end
+
+function PropertyDefNestedObj:GetError()
+	if self.base_class == "PropertyObject" then
+		return "Please specify base class for the nested object(s)."
+	end
+end
+
+DefineClass.PropertyDefNestedList = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Nested List", id = "base_class", name = "Base class", editor = "choice", items = BaseClassCombo, default = "PropertyObject" },
+		{ category = "Nested List", id = "inclusive", name = "Allow base class", editor = "bool", default = false, },
+		{ category = "Nested List", id = "no_descendants", name = "No descendants", editor = "bool", default = false, },
+		{ category = "Nested List", id = "all_descendants", name = "Allow all descendants", editor = "bool", default = false, no_edit = function (self) return self.no_descendants end, },
+		{ category = "Nested List", id = "class_filter", name = "ClassFilter", editor = "func", default = false, lines = 1, max_lines = 20, params = "name, class, obj"},
+		{ category = "Nested List", id = "format", name = "Format in Ged", editor = "text", default = "<EditorView>", },
+		{ category = "Nested List", id = "auto_expand", name = "Auto Expand", editor = "bool", default = false, },
+		{ category = "Nested List", id = "default", name = "Default value", editor = "bool", default = false, no_edit = true, },
+	},
+	editor = "nested_list",
+	EditorName = "Nested list property",
+	EditorSubmenu = "Lists",
+}
+
+PropertyDefNestedList.GenerateAdditionalPropCode = PropertyDefNestedObj.GenerateAdditionalPropCode
+PropertyDefNestedList.GetError = PropertyDefNestedObj.GetError
+
+DefineClass.PropertyDefPropertyArray = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Dynamic Props", id = "from", name = "Generate id from", editor = "choice", default = false,
+			items = { "Table keys", "Table values", "Table field values", "Preset ids" },
+		},
+		{ category = "Dynamic Props", id = "field", name = "Table field", editor = "text", translate = false, default = "",
+			no_edit = function(self) return self.from ~= "Table field values" end,
+		},
+		{ category = "Dynamic Props", id = "items", name = "Items", editor = "expression", default = false, 
+			no_edit = function(self) return self.from == "Preset ids" end,
+		},
+		{ category = "Dynamic Props", id = "preset", name = "Preset class", editor = "choice", default = "",
+			items = ClassDescendantsCombo("Preset"),
+			no_edit = function(self) return self.from ~= "Preset ids" end,
+		},
+		{ category = "Dynamic Props", id = "prop_meta_update", name = "Update prop_meta", editor = "func", params = "self, prop_meta", default = false, 
+			help = "Update the prop_meta of each generated property from prop_meta.id, prop_meta.index (consecutive number), and prop_meta.prest/value.",
+		},
+		{ category = "Dynamic Props", id = "prop", name = "Property template", editor = "nested_obj", base_class = "PropertyDef", auto_expand = true, default = false,
+			suppress_props = { id = true, name = true, category = true, dont_save = true, no_edit = true, template = true, },
+		},
+	},
+	editor = "property_array",
+	EditorName = "Property array",
+	EditorSubmenu = "Objects",
+	default = false,
+}
+
+function PropertyDefPropertyArray:GenerateAdditionalPropCode(code, translate)
+	local from_preset = self.from == "Preset ids" and self.preset ~= "" and self.preset
+	if self.prop and (from_preset or not from_preset and self.items ~= false) then
+		if from_preset then
+			code:appendf("from = '%s', ", self.preset)
+		else
+			code:append("items = ")
+			ValueToLuaCode(self.items, nil, code)
+			code:appendf(", from = '%s', ", self.from)
+			if self.from == "Table field values" then
+				code:appendf("field = '%s', ", self.field)
+			end
+			if self.prop_meta_update then
+				code:appendf("prop_meta_update = ")
+				ValueToLuaCode(self.prop_meta_update, nil, code)
+				code:appendf(", ")
+			end
+		end
+		code:append("\nprop_meta =\n")
+		self.prop.id = " "
+		self.prop:GenerateCode(code, translate)
+	end
+end
+
+DefineClass.PropertyDefScript = {
+	__parents = { "PropertyDef" },
+	properties = {
+		{ category = "Script", id = "condition", name = "Is condition list", editor = "bool", default = false, },
+		{ category = "Script", id = "params_exp", name = "Params is an expression", editor = "bool", default = false, },
+		{ category = "Script", id = "params", name = "Params", editor = "text", default = "self", },
+		{ category = "Script", id = "script_domain", name = "Script domain", editor = "choice", default = false, items = function() return ScriptDomainsCombo() end },
+	},
+	default = false,
+	editor = "script",
+	EditorName = "Script",
+	EditorSubmenu = "Code",
+}
+
+function PropertyDefScript:GenerateAdditionalPropCode(code, translate)
+	if self.condition then
+		code:append('class = "ScriptConditionList", ')
+	end
+	if self.params_exp then
+		code:appendf('params = function(self) return %s end, ', self.params)
+	else
+		code:appendf('params = "%s", ', self.params)
+	end
+	if self.script_domain then
+		code:appendf('script_domain = "%s", ', self.script_domain)
+	end
+end
+
+
+----- Primitive lists
+
+DefineClass.WeightedListProps = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ category = "Weights", id = "weights", name = "Weights", editor = "bool", default = false, 
+			no_edit = function(obj) return obj:DisableWeights() end, help = "Associates weights to the list items"},
+		{ category = "Weights", id = "weight_default", name = "Default Weight", editor = "number", default = 100, 
+			no_edit = function(obj) return not obj.weights end, help = "Default weight for each list item" },
+		{ category = "Weights", id = "value_key", name = "Value Key", editor = "text", default = "value", 
+			no_edit = function(obj) return not obj.weights end, help = "Name of the 'value' key in each list item. Can be a number too." },
+		{ category = "Weights", id = "weight_key", name = "Weight Key", editor = "text", default = "weight", 
+			no_edit = function(obj) return not obj.weights end, help = "Name of the 'weight' key in each list item. Can be a number too." },
+	},
+	DisableWeights = empty_func,
+}
+
+function WeightedListProps:GetItemKeys()
+	local value_key = self.value_key
+	if value_key == "" then
+		value_key = "value"
+	end
+	value_key = tonumber(value_key) or value_key
+	
+	local weight_key = self.weight_key
+	if weight_key == "" then
+		weight_key = "weight"
+	end
+	weight_key = tonumber(weight_key) or weight_key
+	
+	return value_key, weight_key
+end
+
+function WeightedListProps:GenerateWeightPropCode(code)
+	if not self.weights then
+		return
+	end
+	code:append(", weights = true")
+	local value_key, weight_key = self:GetItemKeys()
+	if value_key ~= "value" then
+		code:append(", value_key = ")
+		ValueToLuaCode(value_key, nil, code)
+	end
+	if weight_key ~= "weight" then
+		code:append(", weight_key = ")
+		ValueToLuaCode(weight_key, nil, code)
+	end
+	if self.weight_default ~= 100 then
+		code:append(", weight_default = ")
+		ValueToLuaCode(self.weight_default, nil, code)
+	end
+end
+	
+DefineClass.PropertyDefPrimitiveList = {
+	__parents = { "PropertyDef", "WeightedListProps" },
+	properties = {
+		{ category = "List", id = "item_default", name = "Item Default", editor = "text", default = false, },
+		{ category = "List", id = "items", name = "Items", editor = "expression", default = false, },
+		{ category = "List", id = "max_items", name = "Max number of items", editor = "number", default = -1, },
+	},
+	editor = "",
+	EditorName = "",
+}
+
+function PropertyDefPrimitiveList:DisableWeights()
+	return self.editor ~= "number_list" and self.editor ~= "string_list"
+end
+
+function PropertyDefPrimitiveList:GenerateAdditionalPropCode(code, translate)
+	code:append("item_default = ")
+	ValueToLuaCode(self.item_default, nil, code)
+	code:append(", items = ")
+	ValueToLuaCode(self.items, nil, code)
+	if self.arbitrary_value then
+		code:append(", arbitrary_value = true")
+	end
+	if self.max_items >= 0 then
+		code:append(", max_items = ")
+		ValueToLuaCode(self.max_items, nil, code)
+	end
+	self:GenerateWeightPropCode(code)
+	code:append(", ")
+end
+
+DefineClass.PropertyDefNumberList = {
+	__parents = { "PropertyDefPrimitiveList" },
+	
+	properties = {
+		{ category = "List", id = "default", name = "Default value", editor = "number_list",
+				default = {}, item_default = function(self) return self.item_default end, items = EmulatePropEval("items", {0}) },
+		{ category = "List", id = "item_default", name = "Item Default", editor = "number", default = 0, },
+	},
+	
+	editor = "number_list",
+	EditorName = "Number list property",
+	EditorSubmenu = "Lists",
+}
+
+DefineClass.PropertyDefStringList = {
+	__parents = { "PropertyDefPrimitiveList" },
+	
+	properties = {
+		{ category = "List", id = "default", name = "Default value", editor = "string_list",
+				default = {}, items = EmulatePropEval("items", {""}),
+				item_default = function(self) return self.item_default end, 
+				arbitrary_value = function(self) return self.arbitrary_value end, },
+		{ category = "List", id = "item_default", name = "Item default", editor = "combo",
+				default = "", items = EmulatePropEval("items", {""}) },
+		{ category = "List", id = "arbitrary_value", name = "Allow arbitrary value", editor = "bool", default = false, },
+	},
+	
+	editor = "string_list",
+	EditorName = "String list property",
+	EditorSubmenu = "Lists",
+}
+
+DefineClass.PropertyDefTList = {
+	__parents = { "PropertyDefPrimitiveList" },
+	
+	properties = {
+		{ category = "List", id = "default", name = "Default value", editor = "T_list",
+					default = {}, item_default = function(self) return self.item_default end, items = EmulatePropEval("items", {""}) },
+		{ category = "List", id = "item_default", name = "Item default", editor = "text", default = "", translate = true},
+		{ category = "Text", id = "context", name = "Context", editor = "text", default = "", }
+	},
+	
+	editor = "T_list",
+	EditorName = "Translated list property",
+	EditorSubmenu = "Lists",
+}
+
+function PropertyDefTList:GenerateAdditionalPropCode(code, translate)
+	PropertyDefPrimitiveList.GenerateAdditionalPropCode(self, code, translate)
+	if self.context and self.context ~= "" then
+		code:append("context = " .. self.context .. ", ")
+	end
+end
+
+DefineClass.PropertyDefHelp = {
+	__parents = { "PropertyDef" },
+	default = false,
+	editor = "help",
+	EditorName = "Help text",
+	EditorSubmenu = "Extras",
+}
+
+
+----- ClassConstDef
+
+local const_items = {
+	{ text = "Bool", value = "bool" },
+	{ text = "Number", value = "number" },
+	{ text = "Text", value = "text" },
+	{ text = "Translated Text", value = "translate" },
+	{ text = "Point", value = "point" },
+	{ text = "Box", value = "rect" },
+	{ text = "Color", value = "color" },
+	{ text = "Range", value = "range" },
+	{ text = "Image", value = "browse" },
+	{ text = "Table", value = "prop_table" },
+	{ text = "String List", value = "string_list" },
+	{ text = "Number List", value = "number_list" },
+}
+
+DefineClass.ClassConstDef = {
+	__parents = { "ClassDefSubItem" },
+	properties = {
+		{ category = "Const", id = "name", name = "Name", editor = "text", default = "", validate = ValidateIdentifier },
+		{ category = "Const", id = "type", name = "Type", editor = "choice", default = "bool", items = const_items, },
+		{ category = "Const", id = "value", name = "Value", editor = function(self) return self.type == "translate" and "text" or self.type end,
+			translate = function(self) return self.type == "translate" end, default = false,
+			lines = function(self) return self.type == "prop_table" and 3 or self.type == "text" and 1 end,
+			max_lines = function(self) return self.type == "text" and 256 end, },
+		{ category = "Const", id = "untranslated", name = "Untranslated", editor = "bool",
+			no_edit = function(self) return self.type ~= "translate" and self.type ~= "text" end, default = false, }
+	},
+	EditorName = "Class member",
+	EditorSubmenu = "Code",
+}
+
+function ClassConstDef:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "type" then
+		local value = self.type
+		if value == "text" and old_value == "translate" then
+			self:UpdateLocalizedProperty("value", false)
+		elseif value == "translate" and old_value == "text" then
+			self:UpdateLocalizedProperty("value", true)
+		else
+			self.value = nil
+		end
+	end
+end
+
+function ClassConstDef:GetValue()
+	if not self.value and (self.type == "text" or self.type == "translate") then
+		return ""
+	end
+	return self.value
+end
+
+function ClassConstDef:GetEditorView()
+	local result = "<color 45 138 138>Class.</color>"
+	if self.type == "translate" then
+		result = result .. string.format(self.untranslated and '%s = Untranslated(%s)' or '%s = T(%s)', self.name, self:ToStringWithColor(TDevModeGetEnglishText(self:GetValue())))
+	else
+		result = result .. string.format("%s = %s", self.name, self:ToStringWithColor(self:GetValue()))
+	end
+	return result
+end
+
+function ClassConstDef:GenerateCode(code)
+	if not self.name:match("^[%w_]+$") then return end
+	if self.untranslated then
+		code:append("\t", self.name, " = Untranslated(" )
+		if self.type == "text" then
+			ValueToLuaCode(self:GetValue(), nil, code)
+		elseif self.type == "translate" then
+			ValueToLuaCode(TDevModeGetEnglishText(self:GetValue()), nil, code)
+		end
+		code:append("),\n")
+		return
+	end
+	code:append("\t", self.name, " = ") 
+	ValueToLuaCode(self:GetValue(), nil, code)
+	code:append(",\n")
+end
+
+
+----- ClassMethodDef
+
+local default_methods = {
+	"",
+	"GetEditorView()",
+	"GetError()",
+	"GetWarning()",
+	"OnEditorSetProperty(prop_id, old_value, ged)",
+	"OnEditorNew(parent, ged, is_paste)",
+	"OnEditorDelete(parent, ged)",
+	"OnEditorSelect(selected, ged)",
+}
+
+function ClassMethodDefKnownMethodsCombo(method_def)
+	local defaults = { delete = true }
+	for _, method in ipairs(default_methods) do
+		local name = method:match("(.+)%(")
+		if name then defaults[name] = true end
+	end
+
+	local methods = {}
+	local class_def = GetParentTableOfKind(method_def, "ClassDef")
+	for _, parent in ipairs(class_def.DefParentClassList) do
+		local class = g_Classes[parent]
+		while class and class.class ~= "PropertyObject" and class.class ~= "Preset" do
+			for k, v in pairs(class) do
+				if type(v) == "function" then
+					local name, params, body = GetFuncSource(v)
+					local sep_idx = name and name:find(":", 1, true)
+					if sep_idx then
+						name = name:sub(sep_idx + 1)
+						if not defaults[name] then
+							methods[#methods + 1] = string.format("%s(%s)", name, params:trim_spaces())
+						end
+					end
+				end
+			end
+			class = getmetatable(class)
+		end
+	end
+	table.sort(methods)
+	return #methods == 0 and default_methods or table.iappend(table.iappend(table.copy(default_methods), {"---"}), methods)
+end
+
+DefineClass.ClassMethodDef = {
+	__parents = { "ClassDefSubItem" },
+	properties = {
+		{ category = "Method", id = "name", name = "Name", editor = "combo", default = "",
+			items = ClassMethodDefKnownMethodsCombo,
+			validate = function (self, value)
+				local sep_idx = type(value) == "string" and value:find("(", 1, true)
+				local name = sep_idx and value:sub(1, sep_idx - 1) or value
+				if type(value) ~= "string" or not name:match("^[%w_]*$") then
+					return "Value must be a valid identifier or a function prototype."
+				end
+			end, },
+		{ category = "Method", id = "params", name = "Params", editor = "text", default = "", },
+		{ category = "Method", id = "comment", name = "Comment", editor = "text", default = "", lines = 1, max_lines = 5, },
+		{ category = "Method", id = "code", name = "Code", editor = "func", default = false, lines = 1, max_lines = 100,
+			params = function (self) return self.params == "" and "self" or "self, " .. self.params end, },
+	},
+	EditorName = "Method",
+	EditorSubmenu = "Code",
+}
+
+function ClassMethodDef:GetEditorView()
+	local ret = string.format("<color 75 105 198>function</color> <color 45 138 138>Class:</color>%s(%s)", self.name, self.params)
+	if self.comment ~= "" then
+		ret = string.format("%s <color 0 128 0> -- %s", ret, self.comment)
+	end
+	return ret
+end
+
+function ClassMethodDef:GenerateCode(code, class_name)
+	if not self.name:match("^[%w_]+$") then return end
+	code:appendf("function %s:%s(%s)\n", class_name, self.name, self.params)
+	local name, params, body = GetFuncSource(self.code)
+	if type(body) == "string" then
+		body = string.split(body, "\n")
+	end
+	code:append("\t", body and table.concat(body, "\n\t") or "", "\n")
+	code:append("end\n\n")
+end
+
+function ClassMethodDef:ContainsCode(snippet)
+	local name, params, body = GetFuncSource(self.code)
+	if type(body) == "table" then
+		body = table.concat(body, "\n")
+	end
+	return body and body:find(snippet, 1, true)
+end
+
+function ClassMethodDef:OnEditorSetProperty(prop_id, old_value, ged)
+	local method = self.name
+	if prop_id == "name" and method:find("(", 1, true) then
+		self.name = method:match("(.+)%(")
+		self.params = method:sub(#self.name + 2, -2)
+	end
+end
+
+
+----- ClassGlobalCodeDef
+
+DefineClass.ClassGlobalCodeDef = {
+	__parents = { "ClassDefSubItem" },
+	properties = {
+		{ id = "comment", name = "Comment", editor = "text", default = "", },
+		{ id = "code", name = "Code", editor = "func", default = false, lines = 1, max_lines = 100, params = "", },
+	},
+	EditorName = "Code",
+	EditorSubmenu = "Code",
+}
+
+function ClassGlobalCodeDef:GetEditorView()
+	if self.comment == "" then
+		return "code"
+	end
+	return string.format("code <color 0 128 0>-- %s</color>", self.comment)
+end
+
+function ClassGlobalCodeDef:GenerateCode(code, class_name)
+	local name, params, body = GetFuncSource(self.code)
+	if not body then return end
+	code:append("----- ", class_name, " ", self.comment, "\n\n")
+	if type(body) == "table" then
+		for _, line in ipairs(body) do
+			code:append(line, "\n")
+		end
+	else
+		code:append(body)
+	end
+	code:append("\n")
+end

CommonLua/Classes/ClassDefs/ClassDef-Common.generated.lua

@@ -0,0 +1,68 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+--- Defines a class `StoryBitWithWeight` that inherits from `PropertyObject`.
+---
+--- This class represents a story bit with a weight value that determines its probability of being selected.
+---
+--- @class StoryBitWithWeight
+--- @field StoryBitId string The ID of the story bit.
+--- @field NoCooldown boolean Whether to skip cooldowns for subsequent story bit activations.
+--- @field ForcePopup boolean Whether to directly display the popup without a notification phase.
+--- @field Weight number The weight of the story bit, used to determine its probability of being selected.
+--- @field StorybitSets string A comma-separated list of the story bit sets this story bit belongs to.
+--- @field OneTime boolean Whether this story bit can only be activated once.
+DefineClass.StoryBitWithWeight = {__parents={"PropertyObject"}, __generated_by_class="ClassDef",
+
+    properties={{id="StoryBitId", name="Id", editor="preset_id", default=false, preset_class="StoryBit"},
+        {id="NoCooldown", help="Don't activate any cooldowns for subsequent StoryBit activations", editor="bool",
+            default=false}, {id="ForcePopup", name="Force Popup",
+            help="Specifying true skips the notification phase, and directly displays the popup", editor="bool",
+            default=true}, {id="Weight", name="Weight", editor="number", default=100, min=0},
+        {id="StorybitSets", name="Storybit sets", editor="text", default="<StorybitSets>", dont_save=true,
+            read_only=true}, {id="OneTime", editor="bool", default=false, dont_save=true, read_only=true}},
+    EditorView=Untranslated('"Activate StoryBit <StoryBitId> (weight: <Weight>)"')}
+--- Returns a comma-separated string of the story bit sets that the current story bit belongs to.
+---
+--- If the story bit preset does not exist or has no sets defined, this function returns "None".
+---
+--- @return string A comma-separated list of the story bit sets, or "None" if there are no sets.
+function StoryBitWithWeight:GetStorybitSets()
+    local preset = StoryBits[self.StoryBitId]
+    if not preset or not next(preset.Sets) then
+        return "None"
+    end
+    local items = {}
+    for set in sorted_pairs(preset.Sets) do
+        items[#items + 1] = set
+    end
+    return table.concat(items, ", ")
+end
+
+function StoryBitWithWeight:GetStorybitSets()
+    local preset = StoryBits[self.StoryBitId]
+    if not preset or not next(preset.Sets) then
+        return "None"
+    end
+    local items = {}
+    for set in sorted_pairs(preset.Sets) do
+        items[#items + 1] = set
+    end
+    return table.concat(items, ", ")
+end
+--- Returns whether the current story bit can only be activated once.
+---
+--- @return boolean Whether the story bit can only be activated once.
+function StoryBitWithWeight:GetOneTime()
+    local preset = StoryBits[self.StoryBitId]
+    return preset and preset.OneTime
+end
+--- Returns an error message if the StoryBit preset for the current StoryBitWithWeight instance is invalid.
+---
+--- @return string An error message if the StoryBit preset is invalid, or nil if it is valid.
+function StoryBitWithWeight:GetError()
+    local story_bit = StoryBits[self.StoryBitId]
+    if not story_bit then
+        return "Invalid StoryBit preset"
+    end
+end
+

CommonLua/Classes/ClassDefs/ClassDef-Conditions.generated.lua

@@ -0,0 +1,521 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.CheckAND = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate", 
+			editor = "bool", default = false, },
+		{ id = "Conditions", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+	},
+	EditorView = Untranslated("AND"),
+	EditorViewNeg = Untranslated("NOT AND"),
+	Documentation = "Checks if all of the nested conditions are true.",
+}
+
+function CheckAND:__eval(obj, ...)
+	for _, cond in ipairs(self.Conditions) do
+		if cond:__eval(obj, ...) then
+			if cond.Negate then
+				return false
+			end
+		else
+			if not cond.Negate then
+				return false
+			end
+		end
+	end
+	return true
+end
+
+function CheckAND:GetWarning()
+	if #(self.Conditions or empty_table) < 2 then
+		return "CheckAND should have at least 2 parameters"
+	end
+end
+
+DefineClass.CheckCooldown = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate Condition", help = "If true, checks for the opposite condition", 
+			editor = "bool", default = false, },
+		{ id = "CooldownObj", name = "Cooldown object", 
+			editor = "combo", default = "Game", items = function (self) return {"obj", "context", "Player", "Game"} end, },
+		{ id = "Cooldown", 
+			editor = "preset_id", default = "Disabled", preset_class = "CooldownDef", },
+	},
+	EditorView = Untranslated("<CooldownObj> cooldown <Cooldown> is not active"),
+	EditorViewNeg = Untranslated("<CooldownObj> cooldown <Cooldown> is active"),
+	Documentation = "Checks if a given cooldown is active",
+	EditorNestedObjCategory = "",
+}
+
+function CheckCooldown:__eval(obj, context)
+	local cooldown_obj = self.CooldownObj
+	if cooldown_obj == "Player" then
+		obj = ResolveEventPlayer(obj, context)
+	elseif cooldown_obj == "Game" then
+		obj = Game
+	elseif cooldown_obj == "context" then
+		obj = context
+	end
+	assert(not obj or IsKindOf(obj, "CooldownObj"))
+	return not IsKindOf(obj, "CooldownObj") or not obj:GetCooldown(self.Cooldown)
+end
+
+function CheckCooldown:GetError()
+	if not CooldownDefs[self.Cooldown] then
+		return "No such cooldown"
+	end
+end
+
+DefineClass.CheckDifficulty = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate", 
+			editor = "bool", default = false, },
+		{ id = "Difficulty", name = "Difficulty", 
+			editor = "preset_id", default = "", preset_class = "GameDifficultyDef", },
+	},
+	EditorView = Untranslated("Difficulty <Difficulty>"),
+	EditorViewNeg = Untranslated("Difficulty not <Difficulty>"),
+	Documentation = "Checks game difficulty.",
+}
+
+function CheckDifficulty:__eval(obj, context)
+	return GetGameDifficulty() == self.Difficulty
+end
+
+DefineClass.CheckExpression = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "EditorViewComment", help = "Text that explains the expression and is shown in the editor view field.", 
+			editor = "text", default = "Check expression", },
+		{ id = "Params", 
+			editor = "text", default = "self, obj", },
+		{ id = "Expression", 
+			editor = "expression", default = function (self) return true end, 
+			params = function(self) return self.Params end, },
+	},
+	Documentation = "Checks expression (function) result.",
+}
+
+function CheckExpression:GetEditorView()
+	return self.EditorViewComment and Untranslated(self.EditorViewComment) or Untranslated("Check expression")
+end
+
+function CheckExpression:__eval(...)
+	return self:Expression(...)
+end
+
+DefineClass.CheckGameRule = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate", 
+			editor = "bool", default = false, },
+		{ id = "Rule", name = "Rule", 
+			editor = "preset_id", default = false, preset_class = "GameRuleDef", },
+	},
+	EditorView = Untranslated("Game rule <Rule> is active"),
+	EditorViewNeg = Untranslated("Game rule <Rule> is not active"),
+	Documentation = "Checks if a game rule is active.",
+}
+
+function CheckGameRule:__eval(obj, context)
+	return IsGameRuleActive(self.Rule)
+end
+
+DefineClass.CheckGameState = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate", 
+			editor = "bool", default = false, },
+		{ id = "GameState", name = "Game state", 
+			editor = "preset_id", default = false, preset_class = "GameStateDef", },
+	},
+	EditorView = Untranslated("Game state <u(GameState)> is active"),
+	EditorViewNeg = Untranslated("Game state <u(GameState)> is not active"),
+	Documentation = "Checks if a game state is active.",
+}
+
+function CheckGameState:__eval(obj, context)
+	return GameState[self.GameState]
+end
+
+function CheckGameState:GetError()
+	if not GameStateDefs[self.GameState] then
+		return "No such GameState"
+	end
+end
+
+DefineClass.CheckMapRandom = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Chance", 
+			editor = "number", default = 10, scale = "%", min = 0, max = 100, },
+		{ id = "Seed", help = "Seed should be different on each instance.", 
+			editor = "number", default = false, buttons = { {name = "Rand", func = "Rand"}, }, },
+	},
+	EditorView = Untranslated("Map chance <percent(Chance)>"),
+	Documentation = "Checks a random chance which stays the same until the map changes.",
+}
+
+function CheckMapRandom:__eval(obj, context)
+	return abs(MapLoadRandom + self.Seed) % 100 < self.Chance
+end
+
+function CheckMapRandom:OnEditorNew(parent, ged, is_paste)
+	self.Seed = AsyncRand()
+end
+
+function CheckMapRandom:Rand()
+	self.Seed = AsyncRand()
+	ObjModified(self)
+end
+
+DefineClass.CheckOR = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Negate", name = "Negate", 
+			editor = "bool", default = false, },
+		{ id = "Conditions", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+	},
+	EditorView = Untranslated("OR"),
+	EditorViewNeg = Untranslated("NOT OR"),
+	Documentation = "Checks if one of the nested conditions is true.",
+}
+
+function CheckOR:__eval(obj, ...)
+	for _, cond in ipairs(self.Conditions) do
+		if cond:__eval(obj, ...) then
+			if not cond.Negate then
+				return true
+			end
+		else
+			if cond.Negate then
+				return true
+			end
+		end
+	end
+end
+
+function CheckOR:GetWarning()
+	if #(self.Conditions or empty_table) < 2 then
+		return "CheckOR should have at least 2 parameters"
+	end
+end
+
+DefineClass.CheckPropValue = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "BaseClass", name = "Class", 
+			editor = "combo", default = false, items = function (self) return ClassDescendantsList("PropertyObject") end, },
+		{ id = "NonMatching", name = "Non-matching objects", help = "When the object does not match the provided class. \nnot IsKindOf(obj, Class)", 
+			editor = "choice", default = "fail", items = function (self) return {"fail", "succeed"} end, },
+		{ id = "PropId", name = "Prop", 
+			editor = "combo", default = false, items = function (self) return self:GetNumericProperties() end, },
+		{ id = "Condition", name = "Condition", 
+			editor = "choice", default = "==", items = function (self) return { ">=", "<=", ">", "<", "==", "~=" } end, },
+		{ id = "Amount", name = "Amount", 
+			editor = "number", default = 0, 
+			scale = function(self) return self:GetAmountMeta("scale") end, },
+	},
+	EditorView = Untranslated("<BaseClass>.<PropId> <Condition> <Amount>"),
+	Documentation = "Checks the value of a property.",
+}
+
+function CheckPropValue:__eval(obj, context)
+	if not obj or not IsKindOf(obj, self.BaseClass) then 
+		return self.NonMatching ~= "fail"
+	end
+	local value = obj:GetProperty(self.PropId) or 0
+	return self:CompareOp(value, context)
+end
+
+function CheckPropValue:GetError()
+	local class = g_Classes[self.BaseClass]
+	if not class then
+		return "No such class"
+	end
+	local prop_meta = class:GetPropertyMetadata(self.PropId)
+	if not prop_meta then
+		return "No such property"
+	end
+end
+
+function CheckPropValue:GetNumericProperties()
+	local class = g_Classes[self.BaseClass]
+	local properties = class and class:GetProperties() or empty_table
+	local props = {}
+	for i = #properties, 1, -1 do
+		if properties[i].editor == "number" then
+			props[#props + 1] = properties[i].id
+		end
+	end
+	return props
+end
+
+function CheckPropValue:GetAmountMeta(meta, default)
+	local class = g_Classes[self.BaseClass]
+	local prop_meta = class and class:GetPropertyMetadata(self.PropId)
+	if prop_meta then return prop_meta[meta] end
+	return default
+end
+
+DefineClass.CheckRandom = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "Chance", 
+			editor = "number", default = 10, scale = "%", min = 0, max = 100, },
+	},
+	EditorView = Untranslated("Chance <percent(Chance)>"),
+	Documentation = "Checks a random chance.",
+}
+
+function CheckRandom:__eval(obj, context)
+	return InteractionRand(100, "CheckRandom") < self.Chance
+end
+
+DefineClass.CheckTime = {
+	__parents = { "Condition", },
+	__generated_by_class = "ConditionDef",
+
+	properties = {
+		{ id = "TimeScale", name = "Time Scale", 
+			editor = "choice", default = "h", items = function (self) return GetTimeScalesCombo() end, },
+		{ id = "TimeMin", name = "Min Time", 
+			editor = "number", default = false, },
+		{ id = "TimeMax", name = "Max Time", 
+			editor = "number", default = false, },
+	},
+	EditorView = Untranslated("Time<opt(TimeMin,' after ',TimeScale)><opt(TimeMax,' before ',TimeScale)>"),
+	Documentation = "Checks if the game time matches an interval.",
+}
+
+function CheckTime:__eval(obj, context)
+	local scale = const.Scale[self.TimeScale] or 1
+	local min, max = self.TimeMin, self.TimeMax
+	local time = GameTime()
+	return (not min or time >= min * scale) and (not max or time <= max * scale)
+end
+
+function CheckTime:GetError()
+	if not self.TimeMin and not self.TimeMax then
+		return "No time restriction specified"
+	end
+end
+
+DefineClass.ScriptAND = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	HasNegate = true,
+	EditorView = Untranslated("AND"),
+	EditorViewNeg = Untranslated("NOT AND"),
+	EditorName = "AND",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks if all of the nested conditions are true.",
+	CodeTemplate = "(self[and])",
+	ContainerClass = "ScriptValue",
+}
+
+DefineClass.ScriptCheckCooldown = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	properties = {
+		{ id = "CooldownObj", name = "Cooldown object", 
+			editor = "combo", default = "Game", items = function (self) return {"parameter", "Player", "Game"} end, },
+		{ id = "Cooldown", 
+			editor = "preset_id", default = "Disabled", preset_class = "CooldownDef", },
+	},
+	HasNegate = true,
+	EditorName = "Check cooldown",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks if a given cooldown is active.",
+	CodeTemplate = "",
+	Param1Name = "Object",
+}
+
+function ScriptCheckCooldown:GetEditorView()
+	return string.format("%s%s cooldown %s is %sactive",
+	  self.CooldownObj == "Game" and 'Game' or self.Param1,
+	  self.CooldownObj == "Player" and "'s player" or "",
+	  self.Cooldown or "false", 
+	  self.Negate and "not " or "")
+end
+
+function ScriptCheckCooldown:GenerateCode(pstr, indent)
+	if self.Negate then pstr:append("not ") end
+	if self.CooldownObj == "Game" then
+		pstr:appendf('Game:GetCooldown("%s")', self.Cooldown)
+	elseif self.CooldownObj == "Player" then
+		pstr:appendf('ResolveEventPlayer(%s):GetCooldown("%s")', self.Param1, self.Cooldown)
+	else
+		pstr:appendf('(IsKindOf(%s, "CooldownObj") and %s:GetCooldown("%s"))', self.Param1, self.Param1, self.Cooldown)
+	end
+end
+
+function ScriptCheckCooldown:GetError()
+	if not CooldownDefs[self.Cooldown] then
+		return "No such cooldown"
+	end
+end
+
+DefineClass.ScriptCheckGameState = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	properties = {
+		{ id = "GameState", name = "Game state", 
+			editor = "preset_id", default = false, preset_class = "GameStateDef", },
+	},
+	HasNegate = true,
+	EditorView = Untranslated("Game state <u(GameState)> is active"),
+	EditorViewNeg = Untranslated("Game state <u(GameState)> not active"),
+	EditorName = "Check game state",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks if a game state is active.",
+	CodeTemplate = "GameState[self.GameState]",
+}
+
+function ScriptCheckGameState:GetError()
+	if not GameStateDefs[self.GameState] then
+		return "No such GameState"
+	end
+end
+
+DefineClass.ScriptCheckPropValue = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	properties = {
+		{ id = "BaseClass", name = "Class", 
+			editor = "combo", default = false, items = function (self) return ClassDescendantsList("PropertyObject") end, },
+		{ id = "PropId", name = "Prop", 
+			editor = "combo", default = false, items = function (self) return self:GetNumericProperties() end, },
+		{ id = "NonMatchingValue", name = "Value for non-matching objects", help = "Value used when the object does not match the provided class: not IsKindOf(obj, Class)", 
+			editor = "number", default = 0, 
+			scale = function(self) return self:GetAmountMeta("scale") end, },
+		{ id = "Condition", name = "Condition", 
+			editor = "choice", default = "==", items = function (self) return { ">=", "<=", ">", "<", "==", "~=" } end, },
+		{ id = "Amount", name = "Amount", 
+			editor = "number", default = 0, 
+			scale = function(self) return self:GetAmountMeta("scale") end, },
+	},
+	EditorView = Untranslated("<Param1>: <BaseClass>.<PropId> <Condition> <Amount>"),
+	EditorName = "Check a property value",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks the value of a numeric property.",
+	CodeTemplate = "(IsKindOf($self.Param1, self.BaseClass) and $self.Param1:GetProperty(self.PropId) or self.NonMatchingValue) $self.Condition self.Amount",
+	Param1Name = "Object",
+}
+
+function ScriptCheckPropValue:GetError()
+	local class = g_Classes[self.BaseClass]
+	if not class then
+		return "No such class"
+	end
+	local prop_meta = class:GetPropertyMetadata(self.PropId)
+	if not prop_meta then
+		return "No such property"
+	end
+end
+
+function ScriptCheckPropValue:GetNumericProperties()
+	local class = g_Classes[self.BaseClass]
+	local properties = class and class:GetProperties() or empty_table
+	local props = {}
+	for i = #properties, 1, -1 do
+		if properties[i].editor == "number" then
+			props[#props + 1] = properties[i].id
+		end
+	end
+	return props
+end
+
+function ScriptCheckPropValue:GetAmountMeta(meta, default)
+	local class = g_Classes[self.BaseClass]
+	local prop_meta = class and class:GetPropertyMetadata(self.PropId)
+	if prop_meta then return prop_meta[meta] end
+	return default
+end
+
+DefineClass.ScriptCheckTime = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	properties = {
+		{ id = "TimeScale", name = "Time Scale", 
+			editor = "choice", default = "h", items = function (self) return GetTimeScalesCombo() end, },
+		{ id = "TimeMin", name = "Min Time", 
+			editor = "number", default = false, },
+		{ id = "TimeMax", name = "Max Time", 
+			editor = "number", default = false, },
+	},
+	EditorView = Untranslated("Time<opt(TimeMin,' after ',TimeScale)><opt(TimeMax,' before ',TimeScale)>"),
+	EditorName = "Check time",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks if the game time matches an interval.",
+	CodeTemplate = "",
+}
+
+function ScriptCheckTime:GenerateCode(pstr, indent)
+	local scale = self.TimeScale
+	if scale ~= "" then
+		scale = scale == "sec" and "000" or string.format('*const.Scale["%s"]', self.TimeScale)
+	end
+	local min, max = self.TimeMin, self.TimeMax
+	if min and max then
+		pstr:appendf("GameTime() >= %d%s and GameTime() <= %d%s", min, scale, max, scale)
+	elseif min then
+		pstr:appendf("GameTime() >= %d%s", min, scale)
+	elseif max then
+		pstr:appendf("GameTime() <= %d%s", max, scale)
+	end
+end
+
+function ScriptCheckTime:GetError()
+	if not self.TimeMin and not self.TimeMax then
+		return "No time restriction specified."
+	end
+	if self.TimeMin and self.TimeMax and self.TimeMin > self.TimeMax then
+		return "TimeMin is greater than TimeMax."
+	end
+end
+
+DefineClass.ScriptOR = {
+	__parents = { "ScriptCondition", },
+	__generated_by_class = "ScriptConditionDef",
+
+	HasNegate = true,
+	EditorView = Untranslated("OR"),
+	EditorViewNeg = Untranslated("NOT OR"),
+	EditorName = "OR",
+	EditorSubmenu = "Conditions",
+	Documentation = "Checks if at least one of the nested conditions is true.",
+	CodeTemplate = "(self[or])",
+	ContainerClass = "ScriptValue",
+}
+

CommonLua/Classes/ClassDefs/ClassDef-Config.generated.lua

@@ -0,0 +1,1354 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.Achievement = {
+	__parents = { "MsgReactionsPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "display_name", name = "Display Name", 
+			editor = "text", default = false, translate = true, },
+		{ id = "description", name = "Description", 
+			editor = "text", default = false, translate = true, context = "(limited to 100 characters on XBOX)", },
+		{ id = "how_to", name = "How To", 
+			editor = "text", default = false, translate = true, context = "(limited to 100 characters on XBOX)", },
+		{ id = "image", name = "Image", 
+			editor = "ui_image", default = false, },
+		{ id = "secret", name = "Secret", 
+			editor = "bool", default = false, },
+		{ id = "target", name = "Target", 
+			editor = "number", default = 0, },
+		{ id = "time", name = "Time", 
+			editor = "number", default = 0, },
+		{ id = "save_interval", name = "Save Interval", 
+			editor = "number", default = false, },
+		{ category = "PS4", id = "ps4_trophy_group", name = "Trophy Group", 
+			editor = "preset_id", default = "Auto", preset_class = "TrophyGroup", extra_item = "Auto", },
+		{ category = "PS4", id = "ps4_used_trophy_group", name = "Used Trophy Group", 
+			editor = "preset_id", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, no_validate = true, preset_class = "TrophyGroup", },
+		{ category = "PS4", id = "ps4_duplicate", name = "Duplicate", 
+			editor = "buttons", default = false, dont_save = true, },
+		{ category = "PS4", id = "ps4_id", name = "Trophy Id", 
+			editor = "number", default = -1, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, buttons = { {name = "Generate", func = "GenerateTrophyIDs"}, }, min = -1, max = 128, },
+		{ category = "PS4", id = "ps4_grade", name = "Grade", 
+			editor = "choice", default = "bronze", no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, items = function (self) return PlayStationTrophyGrades end, },
+		{ category = "PS4", id = "ps4_points", name = "Points", 
+			editor = "number", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, },
+		{ category = "PS4", id = "ps4_grouppoints", name = "Group Points", help = "Total sum for the base game should be 950 - 1050. For each expansion <= 200.", 
+			editor = "text", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, },
+		{ category = "PS4", id = "ps4_icon", name = "Icon", 
+			editor = "ui_image", default = "", dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, 
+			no_validate = true, filter = "All files|*.png", },
+		{ category = "PS4", id = "ps4_platinum_linked", name = "Platinum Linked", 
+			editor = "bool", default = true, no_edit = function(self) local trophy_group_0 = GetTrophyGroupById("ps4", 0)
+return self:GetTrophyGroup("ps4") ~= trophy_group_0 or self.ps4_grade == "platinum" end, },
+		{ category = "PS5", id = "ps5_trophy_group", name = "Trophy Group", 
+			editor = "preset_id", default = "Auto", preset_class = "TrophyGroup", extra_item = "Auto", },
+		{ category = "PS5", id = "ps5_used_trophy_group", name = "Used Trophy Group", 
+			editor = "preset_id", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps5") == "" end, no_validate = true, preset_class = "TrophyGroup", },
+		{ category = "PS5", id = "ps5_id", name = "Trophy Id", 
+			editor = "number", default = -1, no_edit = function(self) return self:GetTrophyGroup("ps5") == "" end, buttons = { {name = "Generate", func = "GenerateTrophyIDs"}, }, min = -1, max = 128, },
+		{ category = "PS5", id = "ps5_grade", name = "Grade", 
+			editor = "choice", default = "bronze", no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, items = function (self) return PlayStationTrophyGrades end, },
+		{ category = "PS5", id = "ps5_points", name = "Points", 
+			editor = "number", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, },
+		{ category = "PS5", id = "ps5_grouppoints", name = "Group Points", help = "Total sum for the base game should be 950 - 1050. For each expansion <= 200.", 
+			editor = "number", default = false, dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, },
+		{ category = "PS5", id = "ps5_icon", name = "Icon", 
+			editor = "ui_image", default = "", dont_save = true, read_only = true, no_edit = function(self) return self:GetTrophyGroup("ps4") == "" end, 
+			no_validate = true, filter = "All files|*.png", },
+		{ category = "Xbox", id = "xbox_id", name = "Achievement Id", 
+			editor = "number", default = -1, },
+		{ category = "Steam", id = "steam_id", name = "Steam Id", help = "If not specified, the id of the preset will be used.", 
+			editor = "text", default = false, },
+		{ category = "Epic", id = "epic_id", name = "Epic Id", help = "If not specified, the id of the preset will be used.", 
+			editor = "text", default = false, },
+		{ category = "Epic", id = "flavor_text", name = "Flavor text", 
+			editor = "text", default = false, translate = true, },
+	},
+	HasSortKey = true,
+	GlobalMap = "AchievementPresets",
+	EditorMenubarName = "Achievements",
+	EditorIcon = "CommonAssets/UI/Icons/top trophy winner.png",
+	EditorMenubar = "Editors.Lists",
+}
+
+function Achievement:GetCompleteText()
+	local unlocked = GetAchievementFlags(self.id)
+	return unlocked and self.description or self.how_to
+end
+
+function Achievement:GetTrophyGroup(platform)
+	-- Use stored group if not Auto
+	local group_name_field = platform .. "_trophy_group"
+	if self[group_name_field] ~= "Auto" then
+		return self[group_name_field]
+	end
+	
+	-- Use last explicit trophy group in trophy's DLC
+	local trophies = PresetArray(Achievement, function(achievement)
+		return achievement.SaveIn == self.save_in
+	end)
+	if #trophies ~= 0 then
+		for i=#trophies,1,-1 do
+			local group = trophies[i][group_name_field]
+			if group ~= "" and group ~= "Auto" then
+				return group
+			end
+		end
+	end
+	
+	-- Fallback to a trophy group with id which matches the DLC's id
+	local group = FindPreset("TrophyGroup", self.save_in)
+	if group then return group.id end
+	
+	-- Fallback to inferring from DLC's handling
+	local dlc = FindPreset("DLCConfig", self.save_in)
+	local handling_field = platform .. "_handling"
+	if dlc and dlc[handling_field] ~= "Embed" then
+		-- We can not auto pick a group for "real" DLC trophy if the is non matching its id.
+		-- Do not include excluded DLCs' trophies.
+		return ""
+	end
+	
+	return GetTrophyGroupById(platform, 0)
+end
+
+function Achievement:IsBaseGameTrophy(platform)
+	local group = self:GetTrophyGroup(platform)
+	return group ~= "" and TrophyGroupPresets[group]:IsBaseGameGroup(platform)
+end
+
+function Achievement:IsPlatinumLinked(platform)
+	local trophy_group_0 = GetTrophyGroupById(platform, 0)
+	local trophy_group = self:GetTrophyGroup(platform)
+	local platinum_linked = trophy_group == trophy_group_0 and self[platform .. "_grade"] ~= "platinum"
+	if platform == "ps4" then
+		platinum_linked = platinum_linked and self.ps4_platinum_linked
+	end
+	return platinum_linked
+end
+
+function Achievement:IsCurrentlyUsed()
+	return
+		(Platform.steam and self.steam_id) or
+		(Platform.epic and self.epic_id) or
+		(Platform.ps4 and self.ps4_id >= 0) or
+		(Platform.ps5 and self.ps5_id >= 0) or
+		(Platform.xbox and self.xbox_id > 0) or
+		(Platform.pc and (self.image or self.msg_reactions))
+end
+
+function Achievement:GenerateTrophyIDs(root, prop_id)
+	local platform = string.match(prop_id, "(.*)_id")
+	local trophy_id_field = prop_id
+	local group_id_field = platform .. "_gid"
+	
+	local trophies = PresetArray(Achievement, function(achievement)
+		return achievement:GetTrophyGroup(platform) ~= ""
+	end)
+	
+	local trophies_by_group = {}
+	for _, trophy in ipairs(trophies) do
+		local group = TrophyGroupPresets[trophy:GetTrophyGroup(platform)]
+		local group_id = group[group_id_field]
+		trophies_by_group[group_id] = trophies_by_group[group_id] or {}
+		local group_trophies = trophies_by_group[group_id]
+		group_trophies[#group_trophies + 1] = trophy
+	end
+	
+	local trophy_id = 0
+	for _, group_trophies in sorted_pairs(trophies_by_group) do
+		for _, trophy in ipairs(group_trophies) do
+			if trophy[trophy_id_field] ~= trophy_id then
+				trophy[trophy_id_field] = trophy_id
+				trophy:MarkDirty()
+			end
+			trophy_id = trophy_id + 1
+		end
+	end
+end
+
+function Achievement:Getps4_grouppoints()
+	local group = self:GetTrophyGroup("ps4")
+	local group_points = CalcTrophyGroupPoints(group, "ps4")
+	local trophy_group_0 = GetTrophyGroupById("ps4", 0)
+	if group == trophy_group_0 then
+		local platinum_linked_points = CalcTrophyPlatinumLinkedPoints("ps4")
+		if platinum_linked_points ~= group_points then
+			return string.format("%d + %d", platinum_linked_points, group_points - platinum_linked_points)
+		end
+	end
+	
+	return tostring(group_points)
+end
+
+function Achievement:Getps4_used_trophy_group()
+	return self:GetTrophyGroup("ps4")
+end
+
+function Achievement:Getps4_points()
+	return TrophyGradesPlayStationPoints[self.ps4_grade] or 0
+end
+
+function Achievement:Getps4_icon()
+	local _, icon_path = GetPlayStationTrophyIcon(self, "ps4")
+	return icon_path
+end
+
+function Achievement:Getps5_used_trophy_group()
+	return self:GetTrophyGroup("ps4")
+end
+
+function Achievement:Getps5_points()
+	return TrophyGradesPlayStationPoints[self.ps5_grade] or 0
+end
+
+function Achievement:Getps5_grouppoints()
+	return CalcTrophyGroupPoints(self:GetTrophyGroup("ps5"), "ps5")
+end
+
+function Achievement:Getps5_icon()
+	local _, icon_path = GetPlayStationTrophyIcon(self, "ps5")
+	return icon_path
+end
+
+function Achievement:GetError(platform)
+	local errors = {}
+	
+	local ShouldTestPlatform = function(test_platform)
+		return (not platform or platform == test_platform)
+	end
+	
+	local trophies = PresetArray(Achievement)
+	local GetPlayStationErrors = function(platform)
+		local trophy_id_field = platform .. "_id"
+		local self_trophy_id = self[trophy_id_field]
+		if self.id == "PlatinumTrophy" and self_trophy_id ~= 0 then
+			errors[#errors + 1] = string.format("%s platinum trophy's id must be 0!", string.upper(platform))
+		elseif self:GetTrophyGroup(platform) ~= "" and self_trophy_id < 0 then
+			errors[#errors + 1] = string.format("Missing %s trophy id!", platform)
+		elseif self_trophy_id >= 0 then
+			table.sortby_field(trophies, trophy_id_field)
+			local next_trophy_id = 0
+			local trophy_id_holes = {}
+			for _, trophy in ipairs(trophies) do
+				local curr_trophy_id = trophy[trophy_id_field]
+				if next_trophy_id < self_trophy_id and curr_trophy_id >= 0 then
+					if curr_trophy_id > next_trophy_id then
+						if curr_trophy_id - next_trophy_id > 1 then
+							trophy_id_holes[#trophy_id_holes + 1] = string.format("%d-%d", next_trophy_id, curr_trophy_id)
+						else
+							trophy_id_holes[#trophy_id_holes + 1] = next_trophy_id
+						end
+					end
+					next_trophy_id = curr_trophy_id + 1
+				end
+				if self ~= trophy and self_trophy_id == curr_trophy_id then
+					errors[#errors + 1] = string.format("Duplicated %s trophy id (%s)!", platform, trophy.id)
+				end
+			end
+			
+			if #trophy_id_holes ~= 0 then
+				errors[#errors + 1] = string.format("%s trophy ids are not consecutive, missing %s!", string.upper(platform), table.concat(trophy_id_holes, ", "))
+			end
+		end
+	end
+	
+	if ShouldTestPlatform("ps4") then GetPlayStationErrors("ps4") end
+	if ShouldTestPlatform("ps5") then GetPlayStationErrors("ps5") end
+	
+	if ShouldTestPlatform("xbox_one") or ShouldTestPlatform("xbox_series") then
+		if self.description and #TDevModeGetEnglishText(self.description) > 100 then
+			errors[#errors + 1] = string.format("XBOX achievement description must be limited to 100 characters!")
+		end
+		if self.how_to and #TDevModeGetEnglishText(self.how_to) > 100 then
+			errors[#errors + 1] = string.format("XBOX achievement how to must be limited to 100 characters!")
+		end
+	end
+	
+	return #errors ~= 0 and table.concat(errors, "\n")
+end
+
+function Achievement:GetWarning(platform)
+	local warnings = {}
+	
+	local ShouldTestPlatform = function(test_platform)
+		return (not platform or platform == test_platform) and self:GetTrophyGroup(test_platform) ~= ""
+	end
+	
+	local GetPlayStationWarnings = function(platform)
+		local is_placeholder, icon_path = GetPlayStationTrophyIcon(self, platform)
+		if is_placeholder then
+			warnings[#warnings + 1] = string.format("Missing %s trophy icon (placeholder used): %s", platform, icon_path)
+		end
+		
+		local group = self:GetTrophyGroup(platform)
+		local group_points = CalcTrophyGroupPoints(group, platform)
+		local trophy_group_0 = GetTrophyGroupById(platform, 0)
+		if trophy_group_0 == group then
+			local platinum_linked_points = CalcTrophyPlatinumLinkedPoints(platform)
+			local min, max = GetTrophyBaseGameNonPlatinumLinkedPointsRange(platform)
+			local non_platinum_linked_points = group_points - platinum_linked_points
+			if non_platinum_linked_points < min or max < non_platinum_linked_points then
+				warnings[#warnings + 1] = string.format(
+					"%s non platinum linked trophy points sum in base group is not between %d and %d.",
+					string.upper(platform), min, max
+				)
+			end
+			group_points = platinum_linked_points
+		end
+		
+		local min, max = GetTrophyGroupPointsRange(group, platform)
+		if group_points < min or max < group_points then
+			warnings[#warnings + 1] = string.format(
+				"%s trophy group points sum is not between %d and %d.",
+				string.upper(platform), min, max
+			)
+		end
+	end
+	
+	if ShouldTestPlatform("ps4") then GetPlayStationWarnings("ps4") end
+	if ShouldTestPlatform("ps5") then GetPlayStationWarnings("ps5") end
+	
+	if ShouldTestPlatform("ps5") then
+		if #self.id > 32 then
+			warnings[#warnings + 1] = string.format("Trophy Id maximum length is 32 (< %d)!", #self.id)
+		end
+		if string.find(self.id, "[^%w]") then
+			warnings[#warnings + 1] = "Trophy Id contains non-alphanumeric characters!"
+		end
+	end
+	
+	return #warnings ~= 0 and table.concat(warnings, "\n")
+end
+
+function Achievement:SaveAll(...)
+	ForEachPreset(Achievement, function(trophy)
+		if trophy:GetTrophyGroup("ps4") == "" then
+			trophy:MarkDirty()
+			trophy.ps4_id = -1
+		end
+		if trophy:GetTrophyGroup("ps5") == "" then
+			trophy:MarkDirty()
+			trophy.ps5_id = -1
+		end
+	end)
+	Preset.SaveAll(self, ...)
+end
+
+DefineClass.DLCConfig = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "display_name", name = "Display Name", 
+			editor = "text", default = false, translate = true, },
+		{ category = "General", id = "description", name = "Description", 
+			editor = "text", default = false, translate = true, },
+		{ category = "General", id = "required_lua_revision", 
+			editor = "number", default = 237259, },
+		{ category = "General", id = "pre_load", 
+			editor = "func", default = function (self)
+if not IsDlcOwned(self) then
+	return "remove"
+end
+end, },
+		{ category = "General", id = "load_anyway", name = "Enable Loading Saves When Missing", help = "Set to true if you want to be able to load a save with this dlc missing. If the dlc was deleted, but still present in the save's metadata - it is consider as load_anyway = true (Developer only)", 
+			editor = "bool", default = true, },
+		{ category = "General", id = "show_in_reports", name = "Show in Reports", 
+			editor = "bool", default = false, },
+		{ category = "General", id = "post_load", 
+			editor = "func", default = function (self)
+g_AvailableDlc[self.name] = true
+end, },
+		{ category = "Build Steam", id = "steam_dlc_id", name = "Steam DLC Id", 
+			editor = "number", default = false, },
+		{ category = "Build Pops", id = "pops_dlc_id", name = "Pops DLC Id", 
+			editor = "text", default = false, },
+		{ category = "Build Epic", id = "epic_dlc_id", name = "Artifact Id (Dev)", help = "Where the DLC pack will be pushed to. Can be looked up in the EpicGames dev portal.", 
+			editor = "text", default = false, },
+		{ category = "Build Epic", id = "epic_catalog_dlc_id", name = "Catalog Id (Live)", help = "Which catalog item (seen in the Epic Launcher) the game will check ownership for. Can be in looked up in the .mancpn files after downloading from the Epic Launcher (AppName corresponds to ArtifactId, we need CatalogItemId of the live item).", 
+			editor = "text", default = false, },
+		{ category = "Build", id = "generate_build_rule", name = "Generate Build Rule", help = "With name Dlc%Id%", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "deprecated", name = "Deprecated", help = "Used only for compatibility", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "dont_localize", name = "Dont localize contents", help = "Skip the DLC contents when running localization", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "localization", name = "Has localization packs", help = "If the Dlc should include latest localization packfiles", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "generate_art_folders", 
+			editor = "buttons", default = false, buttons = { {name = "Locate PS4 Art", func = "LocatePS4Art"},  {name = "LocateXboxArt", func = "LocateXboxArt"}, }, },
+		{ category = "Build", id = "ext_name", help = "(optional) name of executables", 
+			editor = "text", default = false, },
+		{ category = "Build", id = "lua", help = "If the Dlc should include Lua.hpk", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "data", help = "If the Dlc should include Data.hpk", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "nonentitytextures", help = "If the Dlc should include all post release non-entity textures, texture lists and bin assets", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "entitytextures", help = "If the Dlc should include all post release entity textures and texture lists", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "ui", help = "If the Dlc should include UI.hpk", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "shaders", help = "If the Dlc should include lastest shader packs.", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "sounds", help = "If the Dlc should include the latest Sounds.hpk", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "resource_metadata", help = "Generate ressource metadata", 
+			editor = "bool", default = true, },
+		{ category = "Build", id = "content_dep", help = "List of rules to be build before the content.hpk is packed (e.g. BinAssets)", 
+			editor = "prop_table", default = {}, },
+		{ category = "Build", id = "content_files", help = "Files added to the dlc content.hpk (e.g. PatchTextures.hpk, etc.)", 
+			editor = "nested_list", default = false, base_class = "DLCConfigContentFile", inclusive = true, },
+		{ category = "BuildPS4", id = "ps4_handling", name = "Handling", help = "Enable - Creates a full dlc package\nEmbed - Creates only a .hpk to be embedded in the main game package\nEmbedPatch - Creates a .hpk that gets embedded in the main game package and replaces an old dlc\nExclude - Not shipped on this platform", 
+			editor = "combo", default = "Exclude", items = function (self) return { "Enable", "Embed", "EmbedPatch", "Exclude" } end, },
+		{ category = "BuildPS4", id = "ps4_label", name = "Label", 
+			editor = "text", default = false, no_edit = function(self) return self.ps4_handling ~= "Enable" and self.ps4_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS4", id = "ps4_version", name = "Version", 
+			editor = "text", default = "01.00", no_edit = function(self) return self.ps4_handling ~= "Enable" and self.ps4_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS4", id = "ps4_entitlement_key", name = "Entitlement Key", help = "Unique 16 byte key. Will be automatically generated. Must be kept secret and not regenerated after certification.", 
+			editor = "text", default = false, read_only = true, no_edit = function(self) return self.ps4_handling ~= "Enable" and self.ps4_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS5", id = "ps5_handling", name = "Handling", help = "Enable - Creates a full dlc package\nEmbed - Creates only a .hpk to be embedded in the main game package\nEmbedPatch - Creates a .hpk that gets embedded in the main game package and replaces an old dlc\nExclude - Not shipped on this platform", 
+			editor = "combo", default = "Exclude", items = function (self) return { "Enable", "Embed", "EmbedPatch", "Exclude" } end, },
+		{ category = "BuildPS5", id = "ps5_label", name = "Label", 
+			editor = "text", default = false, no_edit = function(self) return self.ps5_handling ~= "Enable" and self.ps5_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS5", id = "ps5_master_version", name = "Master Version", 
+			editor = "text", default = "01.00", no_edit = function(self) return self.ps5_handling ~= "Enable" and self.ps5_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS5", id = "ps5_content_version", name = "Content Version", 
+			editor = "text", default = "01.000.000", no_edit = function(self) return self.ps5_handling ~= "Enable" and self.ps5_handling ~= "EmbedPatch" end, },
+		{ category = "BuildPS5", id = "ps5_entitlement_key", name = "Entitlement Key", help = "Unique 16 byte key. Will be automatically generated. Must be kept secret and not regenerated after certification.", 
+			editor = "text", default = false, read_only = true, no_edit = function(self) return self.ps5_handling ~= "Enable" and self.ps5_handling ~= "EmbedPatch" end, },
+		{ category = "BuildXbox", id = "xbox_handling", name = "Handling", help = "Enable - Creates a full dlc package\nEmbed - Creates only a .hpk to be embedded in the main game package\nEmbedPatch - Creates a .hpk that gets embedded in the main game package and replaces an old dlc\nExclude - Not shipped on this platform", 
+			editor = "combo", default = "Exclude", items = function (self) return { "Enable", "Embed", "EmbedPatch", "Exclude" } end, },
+		{ category = "BuildXbox", id = "xbox_name", 
+			editor = "text", default = false, no_edit = function(self) return self.xbox_handling ~= "Enable" and self.xbox_handling ~= "EmbedPatch" end, },
+		{ category = "BuildXbox", id = "xbox_store_id", 
+			editor = "text", default = false, no_edit = function(self) return self.xbox_handling ~= "Enable" and self.xbox_handling ~= "EmbedPatch" end, },
+		{ category = "BuildXbox", id = "xbox_display_name", 
+			editor = "text", default = false, no_edit = function(self) return self.xbox_handling ~= "Enable" and self.xbox_handling ~= "EmbedPatch" end, },
+		{ category = "BuildXbox", id = "xbox_identity", 
+			editor = "text", default = false, no_edit = function(self) return self.xbox_handling ~= "Enable" and self.xbox_handling ~= "EmbedPatch" end, },
+		{ category = "BuildXbox", id = "xbox_version", 
+			editor = "text", default = "1.0.0.0", no_edit = function(self) return self.xbox_handling ~= "Enable" and self.xbox_handling ~= "EmbedPatch" end, },
+		{ category = "BuildWindowsStore", id = "ws_identity_name", 
+			editor = "text", default = false, },
+		{ category = "BuildWindowsStore", id = "ws_version", 
+			editor = "text", default = "1.0.0.0", },
+		{ category = "BuildWindowsStore", id = "ws_store_id", 
+			editor = "text", default = false, },
+		{ id = "SaveIn", 
+			editor = "text", default = false, read_only = true, no_edit = true, },
+		{ category = "Build", id = "public", help = "information from/about this DLC can be made public", 
+			editor = "bool", default = false, },
+		{ category = "Build", id = "split_files", help = "These files will be split and added to the DLC.", 
+			editor = "string_list", default = {}, item_default = "", items = false, arbitrary_value = true, },
+	},
+	HasCompanionFile = true,
+	SingleFile = false,
+	EditorMenubarName = "DLC config",
+	EditorIcon = "CommonAssets/UI/Icons/add buy cart plus.png",
+	EditorMenubar = "DLC",
+	save_in = "future",
+}
+
+function DLCConfig:GetEditorView()
+	local str =  self.id
+	if self.generate_build_rule then
+		str = str .. " <color 0 128 128>build</color>"
+	end
+	if self.deprecated then
+		str = str .. " <color 128 128 0>deprecated</color>"
+	end
+	if self.Comment ~= "" then
+		str = str .. " <color 0 128 0>" .. self.Comment .. "</color>"
+	end
+	return str
+end
+
+function DLCConfig:LocatePS4Art(root)
+	local folder = "svnAssets/Source/ps4/" .. root.id .. "/"
+	local files = { "icon0.png" }
+	if not io.exists(folder) then
+		io.createpath(folder)
+	end
+	for _, file in ipairs(files) do
+		local path = folder .. file
+		if not io.exists(path) then
+			CopyFile("CommonAssets/Images/Achievements/PS4/ICON0.PNG", path)
+		end
+	end
+	OS_LocateFile(folder)
+end
+
+function DLCConfig:LocateXboxArt(root)
+	local folder = "svnAssets/Source/xbox/" .. root.id .. "/"
+	local files = { "Logo.png", "SmallLogo.png", "WideLogo.png" }
+	if not io.exists(folder) then
+		io.createpath(folder)
+	end
+	for _, file in ipairs(files) do
+		local path = folder .. file
+		if not io.exists(path) then
+			CopyFile("CommonAssets/Images/Achievements/PS4/ICON0.PNG", path)
+		end
+	end
+	OS_LocateFile(folder)
+end
+
+function DLCConfig:GetCompanionFileSavePath(save_path)
+	local dlc_id = string.match(save_path, "(%w+)%.lua")
+	assert(dlc_id)
+	if not dlc_id then dlc_id = "unknown" end
+	return "svnProject/Dlc/" .. self.id .. "/autorun.lua"
+end
+
+function DLCConfig:GenerateCompanionFileCode(code)
+	-- generate autorun
+	local autorun_template = {
+		name = self.id,
+		deprecated = self.deprecated or nil,
+		display_name = self.display_name,
+		required_lua_revision = self.required_lua_revision,
+		ps4_trophy_group_description = self.ps4_trophy_group_description,
+		ps5_trophy_group_description = self.ps5_trophy_group_description,
+		steam_dlc_id = self.steam_dlc_id,
+		pops_dlc_id = self.pops_dlc_id,
+		epic_dlc_id = self.epic_dlc_id,
+		epic_catalog_dlc_id = self.epic_catalog_dlc_id,
+		ps4_label  = self.ps4_label,
+		ps5_label  = self.ps5_label,
+		xbox_store_id  = self.xbox_store_id,
+		ps4_gid = self.ps4_gid,
+		ps5_gid = self.ps5_gid,
+		pre_load = self.pre_load,
+		post_load = self.post_load,
+	}
+	code:append("return ")
+	code:append(TableToLuaCode(autorun_template))
+end
+
+function DLCConfig:SaveAll(...)
+	local class = self.PresetClass or self.class
+	local dlcs = PresetArray(class)
+	
+	local PlayStationGenerateEntitlementKeys = function(additional_contents, platform)
+		local handling = platform .. "_handling"
+		local entitlement_key = platform .. "_entitlement_key"
+		
+		local used_entitlement_keys = {}
+		for _, additional_content in ipairs(additional_contents) do
+			if additional_content[entitlement_key] then
+				used_entitlement_keys[additional_content[entitlement_key]] = true
+			end
+		end
+		
+		for _, additional_content in ipairs(additional_contents) do
+			if additional_content[handling] == "Enable" and not additional_content[entitlement_key] then
+				repeat
+					additional_content[entitlement_key] = random_hex(128)
+				until not used_entitlement_keys[additional_content[entitlement_key]]
+				used_entitlement_keys[additional_content[entitlement_key]] = true
+				additional_content:MarkDirty()
+			end
+		end
+	end
+	
+	PlayStationGenerateEntitlementKeys(dlcs, "ps4")
+	PlayStationGenerateEntitlementKeys(dlcs, "ps5")
+	
+	Preset.SaveAll(self, ...)
+	
+	local epic_ids = {}
+	ForEachPreset(class, function(preset, group)
+		local epic_catalog_dlc_id = preset.epic_catalog_dlc_id
+		if (epic_catalog_dlc_id or "") ~= "" then
+			epic_ids[#epic_ids + 1] = epic_catalog_dlc_id
+		end
+	end)
+	local text = string.format("%sg_EpicDlcIds = %s", exported_files_header_warning, TableToLuaCode(epic_ids))
+	local path = "svnProject/Lua/EpicDlcIds.lua"
+	local err = SaveSVNFile(path, text)
+	if err then
+		printf("Failed to save %s: %s", path, err);
+	end
+end
+
+----- DLCConfig Class DLCConfigContentFile
+
+DefineClass.DLCConfigContentFile = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "Source", editor = "text", default = ""},
+		{ id = "Destination", editor = "text", default = ""},
+	},
+}
+
+DefineClass.GradingLUTSource = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Input", id = "src_path", name = "Path", 
+			editor = "browse", default = false, folder = "svnAssets/Source/Textures/LUTs", filter = "LUT (*.cube)|*.cube", force_extension = ".cube", },
+		{ category = "Input", id = "display_name", name = "Display name", 
+			editor = "text", default = false, translate = true, },
+		{ category = "Output", id = "size", name = "Size", 
+			editor = "number", default = false, dont_save = true, read_only = true, },
+		{ category = "Output", id = "color_space", name = "Color Space", 
+			editor = "text", default = false, dont_save = true, read_only = true, },
+		{ category = "Output", id = "color_gamma", name = "Color Gamma", 
+			editor = "text", default = false, dont_save = true, read_only = true, },
+		{ category = "Output", id = "dst_path", name = "Path", 
+			editor = "text", default = false, dont_save = true, read_only = true, buttons = { {name = "Locate", func = "LUT_LocateFile"}, }, },
+	},
+	HasSortKey = true,
+	GlobalMap = "GradingLUTs",
+	EditorMenubarName = "Grading LUTs",
+	EditorMenubar = "Editors.Art",
+	dst_dir = "Textures/LUTs/",
+}
+
+DefineModItemPreset("GradingLUTSource", { EditorName = "Photo Mode - Grading LUT", EditorSubmenu = "Other" })
+
+function GradingLUTSource:OnPreSave()
+	if self:IsDirty() or self:IsDataDirty() then
+		self:OnSrcChange()
+	end
+end
+
+function GradingLUTSource:Getsize()
+	return hr.ColorGradingLUTSize
+end
+
+function GradingLUTSource:GetDstDir()
+	if self:IsModItem() then
+		return self.mod.content_path .. self.dst_dir
+	end
+	return self.dst_dir
+end
+
+function GradingLUTSource:Getcolor_space()
+	return GetColorSpaceName(hr.ColorGradingLUTColorSpace)
+end
+
+function GradingLUTSource:Getcolor_gamma()
+	return GetColorGammaName(hr.ColorGradingLUTColorGamma)
+end
+
+function GradingLUTSource:OnSrcChange()
+	CreateRealTimeThread(function(self)
+		local dst_dir = self:GetDstDir()
+		if not io.exists(dst_dir) then
+			local err = AsyncCreatePath(dst_dir)
+			if err then
+				print(string.format("Could not create path %s: err", dst_dir, err))
+			end
+			if not self:IsModItem() then
+				SVNAddFile(dst_dir)
+			end
+		end
+		
+		local dst_path = self:Getdst_path()
+		ImportColorGradingLUT(self:Getsize(), dst_path, self.src_path)
+		
+		Sleep(3000)
+		if not self:IsModItem() then
+			SVNAddFile(dst_path)
+			SVNAddFile(self.src_path)
+		end
+	end, self)
+end
+
+function GradingLUTSource:Getdst_path()
+	return self:GetResourcePath()
+end
+
+function GradingLUTSource:GetResourcePath()
+	return string.format("%s%s.dds", self:GetDstDir(), self.id)
+end
+
+function GradingLUTSource:GetError()
+	local errors = {}
+	if not self.src_path then
+		errors[#errors + 1] = "Missing input path."
+	elseif not io.exists(self.src_path) then
+		errors[#errors + 1] = "Invalid input path."
+	end
+	return #errors ~= 0 and table.concat(errors, "\n")
+end
+
+function GradingLUTSource:GetDisplayName()
+	return self.display_name
+end
+
+function GradingLUTSource:GetEditorView()
+	if self:GetDisplayName() then
+		return self.id .. ' <color 128 90 30>"' .. _InternalTranslate(self:GetDisplayName()) .. '"'
+	else
+		return self.id
+	end
+end
+
+function GradingLUTSource:IsModItem()
+	return config.Mods and self:IsKindOf("ModItem")
+end
+
+function GradingLUTSource:IsDataDirty()
+	if not IsFSUnpacked() and not self:IsModItem() then 
+		return false
+	end
+	
+	local src_timestamp, src_err = io.getmetadata(self.src_path, "modification_time")
+	if src_err then
+		print(string.format("[GradingLUTs] Failed checking %s for modification: %s", self.src_path, src_err))
+		return false
+	end
+	
+	local dst_timestamp, dst_err = io.getmetadata(self:Getdst_path(), "modification_time")
+	return dst_err or src_timestamp > dst_timestamp
+end
+
+----- GradingLUTSource 
+
+if Platform.pc and Platform.developer then
+
+function CleanGradingLUTsDir(luts_dir)
+	local err, processed_luts = AsyncListFiles(luts_dir, "*.dds", "relative")
+	if err then
+		print(string.format("[GradingLUTs] Failed listing processed LUTs: %s", err))
+	end
+	for _,lut in pairs(GradingLUTs) do
+		if lut:GetDstDir() == luts_dir then
+			table.remove_entry(processed_luts, lut.id .. ".dds")
+		end
+	end
+	for _,lut in ipairs(processed_luts) do
+		local lut_path = luts_dir .. lut
+		local err = AsyncFileDelete(lut_path)
+		if err then
+			print(string.format("[GradingLUTs] Failed deleting %s: %s", lut_path, err))
+		elseif luts_dir == GradingLUTSource.dst_dir then
+			SVNDeleteFile(lut_path)
+		end
+	end
+end
+
+function CleanGradingLUTsDirs()
+	if not IsFSUnpacked() then
+		CleanGradingLUTsDir(GradingLUTSource.dst_dir)
+	end
+	for _, mod in ipairs(ModsList) do
+		CleanGradingLUTsDir(mod.content_path .. GradingLUTSource.dst_dir)
+	end
+end
+
+function OnMsg.PresetSave(class)
+	if IsKindOf(class, "GradingLUTSource") then
+		CleanGradingLUTsDirs()
+	end
+end
+
+function OnMsg.DataLoaded()
+	for _,lut in pairs(GradingLUTs) do
+		if lut:IsDataDirty() then
+			lut:OnSrcChange()
+		end
+	end
+	CleanGradingLUTsDirs()
+end
+
+function LUT_LocateFile(preset)
+	OS_LocateFile(preset:Getdst_path())
+end
+
+end
+
+DefineClass.PlayStationActivities = {
+	__parents = { "MsgReactionsPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "title", name = "Title", help = "The name of the challenge. This field can be localized.", 
+			editor = "text", default = false, translate = true, },
+		{ id = "description", name = "Description", help = "The description of the challenge. This field can be localized.", 
+			editor = "text", default = false, translate = true, wordwrap = true, lines = 3, max_lines = 10, },
+		{ id = "_openEndedHelp", help = "An open-ended activity has no specific completion objective. It ends when the player chooses to end it. For example, batting practice in MLB® The Show™, build mode in Dreams, or realms in God of War.\n\nOpen-ended activities can contain tasks and subtasks that can be used to track optional objectives within the activity.\n\nThe system handles open-ended activities like progress activities, but when an open-ended activity ends, any result sent is ignored.\n\nJust like progress activities, results for single-player activities can be passed using UDS events. You must use the matches API to pass results for open-ended activities that are being played in multiplayer scenarios.", 
+			editor = "help", default = false, dont_save = true, read_only = true, no_edit = function(self) return self.category ~= "openEnded" end, },
+		{ id = "_progressHelp", help = "A progress activity is defined as any activity that requires the player to complete an objective or series of objectives in order to complete the activity. For example, chapters in Uncharted, or quests in Horizon Zero Dawn.\n\nProgress activities can optionally contain tasks and subtasks that players can use to understand what they should do next and track how close they are to completing an activity. See Tasks and Subtasks for more information on how these can be used.\n\nProgress activities must have a result when ended. For single-player progress activities, the game can set the result to COMPLETED, FAILED, or ABANDONED and pass this result back to the platform by means of the UDS activityEnd event. If you end a progress activity as COMPLETED or FAILED, it is written into the player's history and progress is reset for the next instance.\n\nNote:\nThese outcomes are automatically tagged on any publicly available UGC that is created. In the case of successful completion, this UGC can be surfaced to other players who are at the same point in the game as a form of help or walkthrough.\n\nFor the multiplayer match case, SUCCESS or FAILED are the only supported results. You must use the matches API to pass these results. If you want to make an activity no longer active while retaining its progress, you must move the match to ONHOLD through its status property.", 
+			editor = "help", default = false, dont_save = true, read_only = true, no_edit = function(self) return self.category ~= "progress" end, },
+		{ id = "category", name = "Category", 
+			editor = "choice", default = "openEnded", items = function (self) return { "openEnded", "progress" } end, },
+		{ id = "default_playtime_estimate", name = "Default Playtime Estimate (minutes)", help = 'The default playtime estimate is displayed in System UI when the system has not determined the estimated playtime. Once the system determines the estimated playtime, the value may be switched over from the default playtime that is specified. You can specify the time in minute at the activity, task and subtask level.\n• When the category is not "challenge", allow the value at 5-minute intervals. (e.g. 5, 10, 15);\n• When the category is "challenge", allow the value at 1-minute intervals (e.g. 1, 2, 3);\n• When the type is "task" or "subTask", allow the value at 1-minute intervals (e.g. 1, 2, 3).', 
+			editor = "number", default = false, step = 5, min = 0, },
+		{ id = "available_by_default", name = "Available By Default", help = 'When set to true, this automatically sets the availability of an activity to available. Use this for any activity that the player can play from the very first time they launch the game. For players who have the Spoiler Warning set to warn on "Everything You Haven\'t Seen Yet", this setting instructs the Spoiler service to ignore this activity as containing any spoilers, even when it hasn\'t yet been seen by the user.', 
+			editor = "bool", default = true, },
+		{ id = "hidden_by_default", name = "Hidden By Default", help = "When set to true, this activity, task, or subtask is considered a spoiler throughout the UX of the platform, until it becomes available, started, or ended for the player. This means that players see a spoiler flag on any user-generated content containing this activity, task, or subtask if they have not encountered it in the game yet. Additionally, if a friend is playing a hidden activity that the player hasn't encountered yet, the card is obscured for the player when viewed on the friend's profile.", 
+			editor = "bool", default = false, },
+		{ id = "is_required_for_completion", name = "Required For Completion", help = "This is used to determine if the player must complete the activity to complete the main story and to pass the activities TRC if your game has a main story. Primarily, this is used to determine the sorting of activities, as activities with isRequiredforCompletion set to true that the player has never completed are more likely to be suggested to the player. In addition, this can be set on tasks. When completed, those tasks are treated as part of the progress of the activity, ultimately controlling the completion percentage progress bars. If set to false, then tasks are ignored in the completion percentage progress bar giving you more granular control of those bars. You cannot set this value on subtasks. All subtasks are considered required for completion.", 
+			editor = "bool", default = false, no_edit = function(self) return self.category ~= "progress" end, },
+		{ id = "abandon_on_done_map", name = "Abandon on DoneMap", 
+			editor = "bool", default = false, },
+		{ id = "state", name = "Is Active", 
+			editor = "bool", default = false, dont_save = true, read_only = true, buttons = { {name = "Start", func = "Start"},  {name = "Abandon", func = "Abandon"},  {name = "Complete", func = "Complete"},  {name = "Fail", func = "Fail"}, }, },
+		{ id = "_test_buttons", 
+			editor = "buttons", default = false, buttons = { {name = "Test Launch Now", func = "Launch"},  {name = "Test Launch On Next Boot", func = "DbgLaunchOnBoot"}, }, },
+		{ id = "Launch", name = "Launch", 
+			editor = "func", default = function (self)  end, },
+		{ id = "fullscreen_image", name = "Fullscreen Image", help = "• Dimension : 3840x2160 px\n• Image Format : PNG\n• 24-bit non-Interlaced\n• Full screen image used", 
+			editor = "ui_image", default = false, dont_save = true, read_only = true, no_validate = true, },
+		{ id = "card_image", name = "Card Image", help = "Image used on action cards representing the game or challenge and in notifications triggered for a challenge.\n• Dimension : 864x1040 px\n• Image Format : PNG\n• 24 bit non-Interlaced", 
+			editor = "ui_image", default = false, dont_save = true, read_only = true, no_validate = true, },
+	},
+	GlobalMap = "ActivitiesPresets",
+	EditorMenubarName = "PlayStation Activities",
+	EditorMenubar = "Editors.Other",
+}
+
+function PlayStationActivities:Getfullscreen_image()
+	return string.format("svnAssets/Source/Images/Activities/%s_fullscreen.png", self.id)
+end
+
+function PlayStationActivities:Getcard_image()
+	return string.format("svnAssets/Source/Images/Activities/%s_card.png", self.id)
+end
+
+function PlayStationActivities:Start()
+	if Platform.ps5 then
+		AsyncPlayStationActivityStart(self.id)
+	end
+	AccountStorage.PlayStationStartedActivities[self.id] = true
+	SaveAccountStorage(5000)
+end
+
+function PlayStationActivities:DbgLaunchOnBoot()
+	if not Platform.ps5 then
+		AccountStorage.PlayStationActivityDbgLaunchOnBoot = self.id
+		SaveAccountStorage(1000)
+	end
+end
+
+function PlayStationActivities:IsActive()
+	return AccountStorage.PlayStationStartedActivities[self.id]
+end
+
+function PlayStationActivities:Getstate()
+	return AccountStorage.PlayStationStartedActivities[self.id]
+end
+
+function PlayStationActivities:Complete()
+	if Platform.ps5 then
+		AsyncPlayStationActivityEnd(self.id, const.PlayStationActivityOutcomeCompleted)
+	end
+	AccountStorage.PlayStationStartedActivities[self.id] = nil
+	SaveAccountStorage(5000)
+end
+
+function PlayStationActivities:Fail()
+	if Platform.ps5 then
+		AsyncPlayStationActivityEnd(self.id, const.PlayStationActivityOutcomeFailed)
+	end
+	AccountStorage.PlayStationStartedActivities[self.id] = nil
+	SaveAccountStorage(5000)
+end
+
+function PlayStationActivities:Abandon()
+	if Platform.ps5 then
+		AsyncPlayStationActivityEnd(self.id, const.PlayStationActivityOutcomeAbandoned)
+	end
+	AccountStorage.PlayStationStartedActivities[self.id] = nil
+	SaveAccountStorage(5000)
+end
+
+function PlayStationActivities:GetWarning()
+	local warnings = {}
+	
+	if not rawget(self, "Launch") then
+		warnings[#warnings + 1] = "Missing launch procedure!"
+	end
+	
+	return #warnings ~= 0 and table.concat(warnings, "\n")
+end
+
+----- PlayStationActivities 
+
+if Platform.developer or Platform.ps5 then
+
+if FirstLoad then
+	g_DelayedLaunchActivity = false
+	g_PauseLaunchActivityReasons = {
+		["EngineStarted"] = true,
+		["AccountStorage"] = true
+	}
+end
+
+function PlayStationLaunchActivity(activity_id)
+	if g_PauseLaunchActivityReasons ~= empty_table then
+		g_DelayedLaunchActivity = activity_id
+		return
+	end
+	
+	local activity = ActivitiesPresets[activity_id]
+	if activity then
+		assert(rawget(activity, "Launch"), "Activity not launchable!")
+		activity:Launch()
+		return
+	end
+	assert(false, string.format("Missing activity '%s'!", activity_id))
+end
+
+function PauseLaunchActivity(reason)
+	g_PauseLaunchActivityReasons[reason] = true
+end
+
+function ResumeLaunchActivity(reason)
+	g_PauseLaunchActivityReasons[reason] = nil
+	if g_DelayedLaunchActivity and g_PauseLaunchActivityReasons == empty_table then
+		PlayStationLaunchActivity(g_DelayedLaunchActivity)
+		g_DelayedLaunchActivity = false
+	end
+end
+
+function PlayStationGetActiveActivities(account_ids)
+	if not account_ids then
+		local err, account_id = PlayStationGetUserAccountId()
+		if err then return err end
+		account_ids = { account_id }
+	end
+	
+	account_ids = table.map(account_ids, tostring)
+	local uri = string.format("/v1/users/activities?accountIds=%s&limit=10", table.concat(account_ids, ","))	
+	local err, http_code, request_result_json = AsyncOpWait(PSNAsyncOpTimeout, nil, "AsyncPlayStationWebApiRequest", "activities", uri, "", "GET", "", {})
+	if err or http_code ~= 200 then
+		return err or "Failed", http_code
+	end
+	
+	local err, request_result = JSONToLua(request_result_json)
+	if err then return err end
+	
+	local result = {}
+	for _,account_id in ipairs(account_ids) do
+		local user = table.find_value(request_result.users, "accountId", account_id)
+		result[#result + 1] = user and user.activities or empty_table
+	end
+	
+	return nil, result
+end
+
+function OnMsg.DoneMap()
+	for activity_id,_ in pairs(AccountStorage.PlayStationStartedActivities) do
+		if g_DelayedLaunchActivity == activity_id then
+			goto continue
+		end
+
+		local activity = ActivitiesPresets[activity_id]
+		if activity.abandon_on_done_map then
+			activity:Abandon()
+		end
+
+		::continue::
+	end
+end
+
+function OnMsg.ChangeMap()
+	PauseLaunchActivity("ChangeMap")
+end
+
+function OnMsg.ChangeMapDone()
+	ResumeLaunchActivity("ChangeMap")
+end
+
+function OnMsg.EngineStarted()
+	ResumeLaunchActivity("EngineStarted")
+	CreateRealTimeThread(function()
+		-- The SDK does not provide any info on activities from last run.
+		-- Wait for AccountStorage because we store it there
+		while not AccountStorage do
+			WaitMsg("AccountStorageChanged")
+		end
+		
+		-- First run? Create started activities table.
+		AccountStorage.PlayStationStartedActivities = AccountStorage.PlayStationStartedActivities or {}
+
+		-- If PSN is available use activity state from there.
+		if Platform.ps5 then
+			local err, psn_activities = PlayStationGetActiveActivities()
+			if not err and psn_activities[1] then
+				table.clear(AccountStorage.PlayStationStartedActivities)
+				for _,activity in ipairs(psn_activities[1]) do
+					AccountStorage.PlayStationStartedActivities[activity.activityId] = true
+				end
+			end
+		end
+		
+		if not Platform.ps5 and AccountStorage.PlayStationActivityDbgLaunchOnBoot then
+			PlayStationLaunchActivity(AccountStorage.PlayStationActivityDbgLaunchOnBoot)
+			AccountStorage.PlayStationActivityDbgLaunchOnBoot = false
+			SaveAccountStorage(1000)
+		end
+		
+		-- Abandon all activities that cannot persist between game runs.
+		for activity_id,_ in pairs(AccountStorage.PlayStationStartedActivities) do
+			local activity = ActivitiesPresets[activity_id]
+			if not activity.abandon_on_done_map and g_DelayedLaunchActivity == activity_id then
+				goto continue
+			end
+
+			if activity.abandon_on_done_map then
+				activity:Abandon()
+			end
+
+			::continue::
+		end
+
+		ResumeLaunchActivity("AccountStorage")
+	end)
+end
+
+end
+
+DefineClass.RichPresence = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "name", name = "Name", 
+			editor = "text", default = false, translate = true, },
+		{ id = "desc", name = "Description", 
+			editor = "text", default = false, translate = true, },
+		{ id = "xbox_id", name = "Xbox ID", 
+			editor = "text", default = false, },
+	},
+	GlobalMap = "RichPresencePresets",
+	EditorMenubarName = "Rich Presence",
+	EditorMenubar = "Editors.Lists",
+}
+
+DefineClass.TrophyGroup = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "BuildPS4", id = "ps4_gid", name = "Group ID", help = "Those must be consecutive and unique.", 
+			editor = "number", default = -1, buttons = { {name = "Generate", func = "GenerateGroupIDs"}, }, min = -1, max = 128, },
+		{ category = "BuildPS4", id = "ps4_name", name = "Name", 
+			editor = "text", default = false, translate = true, },
+		{ category = "BuildPS4", id = "ps4_description", name = "Trophy Group Description", 
+			editor = "text", default = false, translate = true, },
+		{ category = "BuildPS4", id = "ps4_icon", name = "Icon", 
+			editor = "ui_image", default = "", dont_save = true, read_only = true, 
+			no_validate = true, filter = "All files|*.png", },
+		{ category = "BuildPS4", id = "ps4_trophies", name = "Trophies", 
+			editor = "preset_id_list", default = {}, dont_save = true, read_only = true, no_validate = true, preset_class = "Achievement", item_default = "", },
+		{ category = "BuildPS5", id = "ps5_gid", name = "Group ID", help = "Those must be consecutive and unique.", 
+			editor = "number", default = -1, buttons = { {name = "Generate", func = "GenerateGroupIDs"}, }, min = -1, max = 128, },
+		{ category = "BuildPS5", id = "ps5_name", name = "Name", 
+			editor = "text", default = false, translate = true, },
+		{ category = "BuildPS5", id = "ps5_description", name = "Description", 
+			editor = "text", default = false, translate = true, },
+		{ category = "BuildPS5", id = "ps5_icon", name = "Icon", 
+			editor = "ui_image", default = "", dont_save = true, read_only = true, 
+			no_validate = true, filter = "All files|*.png", },
+		{ category = "BuildPS5", id = "ps5_trophies", name = "Trophies", 
+			editor = "preset_id_list", default = {}, dont_save = true, read_only = true, no_validate = true, preset_class = "Achievement", item_default = "", },
+	},
+	GlobalMap = "TrophyGroupPresets",
+	EditorMenubarName = "Trophy Groups",
+	EditorIcon = "CommonAssets/UI/Icons/top trophy winner.png",
+	EditorMenubar = "Editors.Lists",
+}
+
+function TrophyGroup:Getps4_icon()
+	local _, icon_path = GetPlayStationTrophyGroupIcon(self.id, "ps4")
+	return icon_path
+end
+
+function TrophyGroup:Getps4_trophies()
+	return self:GetTrophies("ps4")
+end
+
+function TrophyGroup:Getps5_icon()
+	local _, icon_path = GetPlayStationTrophyGroupIcon(self.id, "ps5")
+	return icon_path
+end
+
+function TrophyGroup:Getps5_trophies()
+	return self:GetTrophies("ps5")
+end
+
+function TrophyGroup:GenerateGroupIDs(root, prop_id)
+	local platform = string.match(prop_id, "(.*)_gid")
+	local group_id_field = prop_id
+	local groups_counter = 0
+	ForEachPreset(TrophyGroup, function(group)
+		local is_group_used = CalcTrophyGroupPoints(group.id, platform) ~= 0
+		
+		local group_id = -1
+		if is_group_used then
+			group_id = groups_counter
+			groups_counter = groups_counter + 1
+		end
+		
+		if group[group_id_field] ~= group_id then
+			group[group_id_field] = group_id
+			group:MarkDirty()
+		end
+	end)
+end
+
+function TrophyGroup:GetTrophies(platform)
+	local trophies = PresetArray(Achievement, function(achievement)
+		return achievement:GetTrophyGroup(platform) == self.id
+	end)
+	return table.imap(trophies, function(trophy)
+		return trophy.id
+	end)
+end
+
+function TrophyGroup:IsBaseGameGroup(platform)
+	if self[platform .. "_gid"] < 0  then return false end
+	local dlc = FindPreset("DLCConfig", self.save_in)
+	return not dlc or dlc[platform .. "_handling"] == "Embed"
+end
+
+function TrophyGroup:GetError(platform)
+	local errors = {}
+	
+	local ShouldTestPlatform = function(test_platform)
+		return (not platform or platform == test_platform)
+	end
+	
+	local groups = PresetArray(TrophyGroup)
+	local GetPlayStationErrors = function(platform)
+		local group_id_field = platform .. "_gid"
+		local self_group_id = self[group_id_field]
+		if CalcTrophyGroupPoints(self.id, platform) > 0 and self_group_id < 0 then
+			errors[#errors + 1] = string.format("Missing %s trophy group id!", platform)
+		elseif self_group_id >= 0 then
+			table.sortby_field(groups, group_id_field)
+			local next_group_id = 0
+			local group_id_holes = {}
+			for _, group in ipairs(groups) do
+				local curr_group_id = group[group_id_field]
+				if next_group_id < self_group_id and curr_group_id >= 0 then
+					if curr_group_id > next_group_id then
+						if curr_group_id - next_group_id > 1 then
+							group_id_holes[#group_id_holes + 1] = string.format("%d-%d", next_group_id, curr_group_id)
+						else
+							group_id_holes[#group_id_holes + 1] = next_group_id
+						end
+					end
+					next_group_id = curr_group_id + 1
+				end
+				if self ~= group and self_group_id == curr_group_id then
+					errors[#errors + 1] = string.format("Duplicated %s trophy group id (%s)!", platform, group.id)
+				end
+			end
+			
+			if #group_id_holes ~= 0 then
+				errors[#errors + 1] = string.format("%s group ids are not consecutive, missing %s!", string.upper(platform), table.concat(group_id_holes, ", "))
+			end
+		end
+	end
+	
+	if ShouldTestPlatform("ps4") then GetPlayStationErrors("ps4") end
+	if ShouldTestPlatform("ps5") then GetPlayStationErrors("ps5") end
+	
+	return #errors ~= 0 and table.concat(errors, "\n")
+end
+
+function TrophyGroup:GetWarning(platform)
+	local warnings = {}
+	
+	local ShouldTestPlatform = function(test_platform)
+		return (not platform or platform == test_platform)
+	end
+	
+	local GetPlayStationWarnings = function(platform)
+		local trophies = self:GetTrophies(platform)	
+		if self[platform .. "_gid"] >= 0 then
+			if #trophies == 0 then
+				warnings[#warnings + 1] = string.format("Has %s group id but no trophies assigned!", platform)
+			end
+			local is_placeholder, icon_path = GetPlayStationTrophyGroupIcon(self.id, platform)
+			if is_placeholder then
+				warnings[#warnings + 1] = string.format("Missing %s trophy group icon (placeholder used): %s", platform, icon_path)
+			end
+		end
+		
+		local is_base_game_group = self:IsBaseGameGroup(platform)
+		for _, trophy_name in ipairs(trophies) do
+			local trophy = FindPreset("Achievement", trophy_name)
+			local is_base_game_trophy = trophy:IsBaseGameTrophy(platform)
+			if trophy.save_in ~= self.save_in and not (is_base_game_group and is_base_game_trophy) then
+				warnings[#warnings + 1] = string.format(
+					"%s trophy %s saved in %s while the group is saved in %s.",
+					string.upper(platform), trophy_name, trophy.save_in, self.save_in)
+			end
+		end
+	end
+	
+	if ShouldTestPlatform("ps4") then GetPlayStationWarnings("ps4") end
+	if ShouldTestPlatform("ps5") then GetPlayStationWarnings("ps5") end
+	
+	return #warnings ~= 0 and table.concat(warnings, "\n")
+end
+
+DefineClass.VideoDef = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Common", id = "source", 
+			editor = "browse", default = false, folder = "svnAssets/Source/Movies", filter = "Video Files|*.avi|All Files|*.*", },
+		{ category = "Common", id = "ffmpeg_input_pattern", 
+			editor = "text", default = '-i "$(source)"', },
+		{ category = "Common", id = "sound", 
+			editor = "browse", default = false, folder = "svnAssets/Source/Movies", filter = "Audio Files|*.wav", },
+		{ category = "Desktop", id = "present_desktop", 
+			editor = "bool", default = true, },
+		{ category = "Desktop", id = "extension_desktop", 
+			editor = "text", default = "ivf", 
+			no_edit = function(self) return not self.present_desktop end, },
+		{ category = "Desktop", id = "ffmpeg_commandline_desktop", 
+			editor = "text", default = "-c:v vp8 -preset veryslow", 
+			no_edit = function(self) return not self.present_desktop end, },
+		{ category = "Desktop", id = "bitrate_desktop", 
+			editor = "number", default = 8000, 
+			no_edit = function(self) return not self.present_desktop end, },
+		{ category = "Desktop", id = "framerate_desktop", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_desktop end, },
+		{ category = "Desktop", id = "resolution_desktop", 
+			editor = "point", default = point(1920, 1080), 
+			no_edit = function(self) return not self.present_desktop end, },
+		{ category = "PS4", id = "present_ps4", 
+			editor = "bool", default = true, },
+		{ category = "PS4", id = "extension_ps4", 
+			editor = "text", default = "bsf", 
+			no_edit = function(self) return not self.present_ps4 end, },
+		{ category = "PS4", id = "ffmpeg_commandline_ps4", 
+			editor = "text", default = "-c:v h264 -profile:v high422 -pix_fmt yuv420p -x264opts force-cfr -bsf h264_mp4toannexb -f h264 -r 30000/1001", 
+			no_edit = function(self) return not self.present_ps4 end, },
+		{ category = "PS4", id = "bitrate_ps4", 
+			editor = "number", default = 6000, 
+			no_edit = function(self) return not self.present_ps4 end, },
+		{ category = "PS4", id = "framerate_ps4", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_ps4 end, },
+		{ category = "PS4", id = "resolution_ps4", 
+			editor = "point", default = point(1920, 1080), 
+			no_edit = function(self) return not self.present_ps4 end, },
+		{ category = "PS5", id = "present_ps5", 
+			editor = "bool", default = true, },
+		{ category = "PS5", id = "extension_ps5", 
+			editor = "text", default = "bsf", 
+			no_edit = function(self) return not self.present_ps5 end, },
+		{ category = "PS5", id = "ffmpeg_commandline_ps5", 
+			editor = "text", default = "-c:v h264 -profile:v high422 -pix_fmt yuv420p -x264opts force-cfr -bsf h264_mp4toannexb -f h264 -r 30000/1001", 
+			no_edit = function(self) return not self.present_ps5 end, },
+		{ category = "PS5", id = "bitrate_ps5", 
+			editor = "number", default = 6000, 
+			no_edit = function(self) return not self.present_ps5 end, },
+		{ category = "PS5", id = "framerate_ps5", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_ps5 end, },
+		{ category = "PS5", id = "resolution_ps5", 
+			editor = "point", default = point(1920, 1080), 
+			no_edit = function(self) return not self.present_ps5 end, },
+		{ category = "Xbox One", id = "present_xbox_one", 
+			editor = "bool", default = true, },
+		{ category = "Xbox One", id = "extension_xbox_one", 
+			editor = "text", default = "mp4", 
+			no_edit = function(self) return not self.present_xbox_one end, },
+		{ category = "Xbox One", id = "ffmpeg_commandline_xbox_one", 
+			editor = "text", default = "-c:v h264 -preset veryslow -pix_fmt yuv420p", 
+			no_edit = function(self) return not self.present_xbox_one end, },
+		{ category = "Xbox One", id = "bitrate_xbox_one", 
+			editor = "number", default = 8000, 
+			no_edit = function(self) return not self.present_xbox_one end, },
+		{ category = "Xbox One", id = "framerate_xbox_one", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_xbox_one end, },
+		{ category = "Xbox One", id = "resolution_xbox_one", 
+			editor = "point", default = point(1920, 1080), 
+			no_edit = function(self) return not self.present_xbox_one end, },
+		{ category = "Xbox Series", id = "present_xbox_series", 
+			editor = "bool", default = true, },
+		{ category = "Xbox Series", id = "extension_xbox_series", 
+			editor = "text", default = "mp4", 
+			no_edit = function(self) return not self.present_xbox_series end, },
+		{ category = "Xbox Series", id = "ffmpeg_commandline_xbox_series", 
+			editor = "text", default = "-c:v libx265 -tag:v hvc1 -preset veryslow -pix_fmt yuv420p", 
+			no_edit = function(self) return not self.present_xbox_series end, },
+		{ category = "Xbox Series", id = "bitrate_xbox_series", 
+			editor = "number", default = 8000, 
+			no_edit = function(self) return not self.present_xbox_series end, },
+		{ category = "Xbox Series", id = "framerate_xbox_series", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_xbox_series end, },
+		{ category = "Xbox Series", id = "resolution_xbox_series", 
+			editor = "point", default = point(1920, 1080), 
+			no_edit = function(self) return not self.present_xbox_series end, },
+		{ category = "Switch", id = "present_switch", 
+			editor = "bool", default = true, },
+		{ category = "Switch", id = "extension_switch", 
+			editor = "text", default = "mp4", 
+			no_edit = function(self) return not self.present_switch end, },
+		{ category = "Switch", id = "ffmpeg_commandline_switch", 
+			editor = "text", default = "-c:v h264 -preset veryslow -pix_fmt yuv420p", 
+			no_edit = function(self) return not self.present_switch end, },
+		{ category = "Switch", id = "bitrate_switch", 
+			editor = "number", default = 700, 
+			no_edit = function(self) return not self.present_switch end, },
+		{ category = "Switch", id = "framerate_switch", 
+			editor = "number", default = 30, 
+			no_edit = function(self) return not self.present_switch end, },
+		{ category = "Switch", id = "resolution_switch", 
+			editor = "point", default = point(1280, 720), 
+			no_edit = function(self) return not self.present_switch end, },
+	},
+	HasCompanionFile = true,
+	GlobalMap = "VideoDefs",
+	EditorMenubarName = "Video defs",
+	EditorIcon = "CommonAssets/UI/Icons/outline video.png",
+	EditorMenubar = "Editors.Engine",
+}
+
+function VideoDef:GetPropsForPlatform(platform)
+	assert(table.find({ "desktop", "ps4", "ps5", "xbox_one", "xbox_series", "switch" }, platform))
+	local result = {}
+	local props = { "extension", "ffmpeg_commandline", "bitrate", "framerate", "resolution", "present" }
+	for key, value in ipairs(props) do
+		result[value] = self[value .. "_" .. platform]
+	end
+	local video_path = string.match(self.source or "", "svnAssets/Source/(.+)")
+	if video_path then
+		local dir, name, ext = SplitPath(video_path)
+		result.video_game_path = dir .. name .. "." .. result.extension
+	end
+	
+	local sound_path = string.match(self.sound or "", "svnAssets/Source/(.+)")
+	if sound_path then
+		local dir, name, ext = SplitPath(sound_path)
+		result.sound_game_path = dir .. name
+	end
+	
+	return result
+end
+
+DefineClass.VoiceActorDef = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "VoiceId", name = "VoiceID", 
+			editor = "text", default = false, },
+	},
+	GlobalMap = "VoiceActors",
+	EditorMenubarName = "Voice Actors",
+	EditorIcon = "CommonAssets/UI/Icons/human male man people person.png",
+	EditorMenubar = "Editors.Audio",
+	EditorView = Untranslated("<u(Id)> <color 0 128 0><u(VoiceId)>"),
+}
+

CommonLua/Classes/ClassDefs/ClassDef-Default.generated.lua

@@ -0,0 +1,193 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.AnimComponentWeight = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "AnimComponent", 
+			editor = "preset_id", default = false, preset_class = "AnimComponent", },
+		{ id = "BlendAfterChannel", help = "If false, the component will execute on the channel animation, if true, it will execute after the channel has beel blended with all before it.", 
+			editor = "bool", default = false, },
+	},
+}
+
+DefineClass.AnimLimbData = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "fit_bone", help = "Bone name to be fit to target", 
+			editor = "text", default = false, },
+		{ id = "joint_bone", 
+			editor = "text", default = false, },
+		{ id = "joint_companion_bone", 
+			editor = "text", default = false, },
+		{ id = "top_bone", 
+			editor = "text", default = false, },
+		{ id = "top_companion_bone", 
+			editor = "text", default = false, },
+		{ id = "fit_normal", help = "Local bone space normal direction to be fit to target", 
+			editor = "point", default = point(0, 1000, 0), },
+		{ id = "fit_offset", help = "Local bone space position offset to be fit to target", 
+			editor = "point", default = point(0, 0, 0), },
+		{ id = "joint_axis", help = "Local bone space joint axis direction", 
+			editor = "point", default = point(0, 0, 1000), },
+	},
+}
+
+DefineClass.CommonGameSettings = {
+	__parents = { "InitDone", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "Modifiers", id = "game_difficulty", name = T(607013881337, --[[ClassDef Default CommonGameSettings name]] "Game difficulty"), 
+			editor = "preset_id", default = false, preset_class = "GameDifficultyDef", },
+		{ category = "Modifiers", id = "seed_text", name = T(968127954818, --[[ClassDef Default CommonGameSettings name]] "Seed"), help = T(657915341595, --[[ClassDef Default CommonGameSettings help]] "Text used to generate seed. If empty a random (async) seed will be used."), 
+			editor = "text", default = "", },
+		{ category = "Modifiers", id = "game_rules", name = T(567633276594, --[[ClassDef Default CommonGameSettings name]] "Game Rules"), 
+			editor = "prop_table", default = false, },
+		{ category = "Modifiers", id = "forced_game_rules", name = T(957452987296, --[[ClassDef Default CommonGameSettings name]] "Forced game rules"), help = T(745042998514, --[[ClassDef Default CommonGameSettings help]] "If a rule is set to true, it is force enabled, false means force disabled."), 
+			editor = "prop_table", default = false, dont_save = true, no_edit = true, },
+	},
+	StoreAsTable = true,
+	id = false,
+	save_id = false,
+	loaded_from_id = false,
+}
+
+function CommonGameSettings:Init()
+	self.id = self.id or random_encode64(96)
+	
+	local difficulty = table.get(Presets, "GameDifficultyDef", 1) or empty_table
+	difficulty = difficulty[(#difficulty + 1) / 2]
+	self.game_difficulty = self.game_difficulty or difficulty and difficulty.id or nil
+	
+	self.game_rules = self.game_rules or {}
+	self.forced_game_rules = self.forced_game_rules or {}
+	ForEachPreset("GameRule", function(rule)
+		if rule.init_as_active then
+			self:AddGameRule(rule.id)
+		end
+	end)
+end
+
+function CommonGameSettings:ToggleListValue(prop_id, item_id)
+	if prop_id == "game_rules" then
+		self:ToggleGameRule(item_id)
+		return
+	end
+	local value = self[prop_id]
+	if value[item_id] then
+		value[item_id] = nil
+	else
+		value[item_id] = true
+	end
+end
+
+function CommonGameSettings:ToggleGameRule(rule_id)
+	local value = self.game_rules[rule_id]
+	if value then
+		self:RemoveGameRule(rule_id)
+	else
+		self:AddGameRule(rule_id)
+	end
+end
+
+function CommonGameSettings:AddGameRule(rule_id)
+	if self:CanAddGameRule(rule_id) then
+		self.game_rules[rule_id] = true
+	end
+end
+
+function CommonGameSettings:RemoveGameRule(rule_id)
+	if self:CanRemoveGameRule(rule_id) then
+		self.game_rules[rule_id] = nil
+	end
+end
+
+function CommonGameSettings:SetForceEnabledGameRule(rule_id, set)
+	if set then
+		self:AddGameRule(rule_id)
+	else
+		self:RemoveGameRule(rule_id)
+	end
+	self.forced_game_rules[rule_id] = set and true or nil
+end
+
+function CommonGameSettings:SetForceDisabledGameRule(rule_id, set)
+	if set then
+		self:RemoveGameRule(rule_id)
+	end
+	if set then
+		self.forced_game_rules[rule_id] = false
+	else
+		self.forced_game_rules[rule_id] = nil
+	end
+end
+
+function CommonGameSettings:CanAddGameRule(rule_id)
+	if self.forced_game_rules[rule_id] == false then
+		return
+	end
+	local rule = GameRuleDefs[rule_id]
+	return not self:IsGameRuleActive(rule_id) and rule and rule:IsCompatible(self.game_rules)
+end
+
+function CommonGameSettings:CanRemoveGameRule(rule_id)
+	return self.forced_game_rules[rule_id] == nil
+end
+
+function CommonGameSettings:IsGameRuleActive(rule_id)
+	return self.game_rules[rule_id]
+end
+
+function CommonGameSettings:CopyCategoryTo(other, category)
+	for _, prop in ipairs(self:GetProperties()) do
+		if prop.category == category then
+			local value = self:GetProperty(prop.id)
+			value = type(value) == "table" and table.copy(value) or value
+			other:SetProperty(prop.id, value)
+		end
+	end
+end
+
+function CommonGameSettings:Clone()
+	local obj = CooldownObj.Clone(self)
+	obj.id = self.id or nil
+	obj.save_id = self.save_id or nil
+	obj.loaded_from_id = self.loaded_from_id or nil
+	return obj
+end
+
+DefineClass.Explanation = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "Text", 
+			editor = "text", default = false, translate = true, },
+		{ id = "Id", 
+			editor = "text", default = false, },
+		{ id = "ObjIsKindOf", name = "Object is of type", help = "The explanation is provided only if the parameter object inherits the specified class.", 
+			editor = "combo", default = "", items = function (self) return ClassDescendantsList("PropertyObject") end, },
+		{ id = "Conditions", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+	},
+	EditorView = Untranslated("Explanation: <Text>"),
+}
+
+----- Explanation 
+
+function GetFirstExplanation(list, obj, ...)
+	local IsKindOf = IsKindOf
+	local EvalConditionList = EvalConditionList
+	for _, explanation in ipairs(list) do
+		local kind_of = explanation.ObjIsKindOf or ""
+		if (kind_of == "" or IsKindOf(obj, kind_of)) and EvalConditionList(explanation.Conditions, obj, ...) then
+			return explanation.Text, explanation.Id
+		end
+	end
+	return ""
+end
+

CommonLua/Classes/ClassDefs/ClassDef-Effects.generated.lua

@@ -0,0 +1,495 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.ChangeGameStateEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "GameState", name = "Game state", 
+			editor = "preset_id", default = false, preset_class = "GameStateDef", },
+		{ id = "Value", name = "Value", 
+			editor = "bool", default = false, },
+	},
+	EditorView = Untranslated("<select(Value,'Clear','Set')> game state <GameState>"),
+	Documentation = "Changes a game state",
+}
+
+function ChangeGameStateEffect:__exec(obj, context)
+	ChangeGameState(self.GameState, self.Value)
+end
+
+function ChangeGameStateEffect:GetError()
+	if not GameStateDefs[self.GameState] then
+		return "No such GameState"
+	end
+end
+
+DefineClass.ChangeLightmodel = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "Lightmodel", name = "Light model", help = "Specify a light model, or leave as 'false' to restore the previous one.", 
+			editor = "preset_id", default = false, preset_class = "LightmodelPreset", },
+	},
+	EditorView = Untranslated("<if(Lightmodel)>Change light model to <Lightmodel>.</if><if(not(Lightmodel))>Restore last light model.</if>"),
+	Documentation = "Changes the current light model, or restores the last one if Light model is 'false'.",
+}
+
+function ChangeLightmodel:__exec(obj, context)
+	SetLightmodelOverride(false, self.Lightmodel)
+end
+
+DefineClass.EffectsWithCondition = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "Conditions", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+		{ id = "Effects", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+		{ id = "EffectsElse", name = "Else", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+	},
+	EditorView = Untranslated("Effects with condition"),
+	Documentation = "Executes different effects when a list of conditions is true or not.",
+}
+
+function EffectsWithCondition:__exec(obj, ...)
+	if _EvalConditionList(self.Conditions, obj, ...) then
+		for _, effect in ipairs(self.Effects) do
+			effect:__exec(obj, ...)
+		end
+		return true
+	else
+		for _, effect in ipairs(self.EffectsElse) do
+			effect:__exec(obj, ...)
+		end
+	end
+end
+
+DefineClass.ExecuteCode = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "Params", 
+			editor = "text", default = "self, obj", },
+		{ id = "SaveAsText", 
+			editor = "bool", default = false, },
+		{ id = "Code", 
+			editor = "func", default = function (self)  end, 
+			params = function(self) return self.Params end, no_edit = function(self) return self.SaveAsText end, },
+		{ id = "FuncCode", 
+			editor = "text", default = false, 
+			params = function(self) return self.Params end, no_edit = function(self) return not self.SaveAsText end, lines = 1, },
+	},
+	EditorView = Untranslated("Execute Code"),
+	Documentation = "Execute arbitrary code.",
+}
+
+function ExecuteCode:__exec(...)
+	if self.SaveAsText and self.FuncCode then
+		local prop_meta = self:GetPropertyMetadata("FuncCode")
+		local params = prop_meta.params(self, prop_meta) or "self"
+		local func, err = CompileFunc("FuncCode", params, self.FuncCode)
+		if not func then
+			assert(false, err)
+			return false
+		end
+		return func(self, ...)
+	end
+	return self.Code(self, ...)
+end
+
+function ExecuteCode:__toluacode(...)
+	if not self.SaveAsText then
+		assert(not g_PresetForbidSerialize, "Attempt to save ExecuteCode not from Ged!")
+	end
+	
+	return Effect.__toluacode(self, ...)
+end
+
+function ExecuteCode:GetError()
+	local code
+	if self.SaveAsText then
+		if self.FuncCode then
+			code = string.split(self.FuncCode, "\n")
+		end
+	else
+		if self.Code then
+			local _,_, body = GetFuncSource(self.Code)
+			code = body
+		end
+	end
+	if not code then return end
+	
+	code =  (type(code) == "string") and {code} or code
+	for _, line in ipairs(code) do
+		if string.match(line, "T{") then
+			return "FuncCode can't use T{}"
+		end
+		if string.match(line, "Translated%(") then
+			return "FuncCode can't use Translated()"
+		end
+		if string.match(line, "Untranslated%(")  then
+			return "FuncCode can't use Untranslated()"
+		end
+	end
+end
+
+DefineClass.ModifyCooldownEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "CooldownObj", name = "Cooldown object", 
+			editor = "combo", default = "Game", items = function (self) return {"obj", "context", "Player", "Game"} end, },
+		{ id = "Cooldown", 
+			editor = "preset_id", default = "Disabled", preset_class = "CooldownDef", },
+		{ id = "TimeScale", name = "Time Scale", 
+			editor = "choice", default = "h", items = function (self) return GetTimeScalesCombo() end, },
+		{ id = "Time", help = "If time is not provided the default time from the cooldown definition is used.", 
+			editor = "number", default = 0, 
+			scale = function(self) return self.TimeScale end, },
+		{ id = "RandomTime", 
+			editor = "number", default = 0, 
+			scale = function(self) return self.TimeScale end, },
+	},
+	EditorView = Untranslated("Add to <CooldownObj> cooldown <Cooldown>"),
+	Documentation = "Adds time to an existing cooldown",
+	EditorNestedObjCategory = "",
+}
+
+function ModifyCooldownEffect:__exec(obj, context)
+	local cooldown_obj = self.CooldownObj
+	if cooldown_obj == "Player" then
+		obj = ResolveEventPlayer(obj, context)
+	elseif cooldown_obj == "Game" then
+		obj = Game
+	elseif cooldown_obj == "context" then
+		obj = context
+	end
+	assert(not obj or IsKindOf(obj, "CooldownObj"))
+	if IsKindOf(obj, "CooldownObj") then
+		local rand = self.RandomTime
+		local time = self.Time + (rand > 0 and InteractionRand(rand, self.Cooldown, obj) or 0)
+		obj:ModifyCooldown(self.Cooldown, time)
+	end
+end
+
+function ModifyCooldownEffect:GetError()
+	if not CooldownDefs[self.Cooldown] then
+		return "No such cooldown"
+	end
+end
+
+DefineClass.PlayActionFX = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "ActionFX", name = "ActionFX", 
+			editor = "combo", default = "", items = function (self) return PresetsPropCombo("FXPreset", "Action", "") end, },
+		{ id = "ActionMoment", name = "ActionMoment", 
+			editor = "combo", default = "start", items = function (self) return PresetsPropCombo("FXPreset", "Moment") end, },
+	},
+	EditorView = Untranslated("PlayFX <FX>"),
+	Documentation = "PlayFX",
+}
+
+function PlayActionFX:__exec(obj, context)
+	if self.ActionFX ~= "" then
+		PlayFX(self.ActionFX, self.ActionMoment, obj, context)
+	end
+end
+
+DefineClass.RemoveGameNotificationEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "NotificationId", 
+			editor = "text", default = false, },
+	},
+	EditorView = Untranslated("Remove notification <NotificationId>"),
+	Documentation = "Removes the specified notification if it is present",
+}
+
+function RemoveGameNotificationEffect:__exec(obj, context)
+	RemoveGameNotification(self.NotificationId)
+end
+
+function RemoveGameNotificationEffect:GetError()
+	if not self.NotificationId then
+		return "No notification id set"
+	end
+end
+
+DefineClass.ScriptStoryBitActivate = {
+	__parents = { "ScriptSimpleStatement", },
+	__generated_by_class = "ScriptEffectDef",
+
+	properties = {
+		{ id = "StoryBitId", name = "Id", 
+			editor = "preset_id", default = false, preset_class = "StoryBit", },
+		{ id = "NoCooldown", help = "Don't activate any cooldowns for subsequent StoryBit activations", 
+			editor = "bool", default = false, },
+		{ id = "ForcePopup", name = "Force Popup", help = "Specifying true skips the notification phase, and directly displays the popup", 
+			editor = "bool", default = true, },
+	},
+	EditorView = Untranslated("Activate story bit <StoryBitId>"),
+	EditorName = "Activate story bit",
+	EditorSubmenu = "Effects",
+	Documentation = "",
+	CodeTemplate = 'ForceActivateStoryBit(self.StoryBitId, $self.Param1, self.ForcePopup and "immediate", $self.Param2, self.NoCooldown)',
+	Param1Name = "obj",
+	Param2Name = "context",
+}
+
+function ScriptStoryBitActivate:GetError()
+	local story_bit = StoryBits[self.StoryBitId]
+	if not story_bit then
+		return "Invalid StoryBit preset"
+	end
+end
+
+DefineClass.SelectObjectEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "SelectionIsEmpty", name = "Only if selection is empty", 
+			editor = "bool", default = false, },
+		{ id = "ObjNonEmpty", name = "Only if obj is not empty", 
+			editor = "bool", default = false, },
+	},
+	EditorView = Untranslated("Select object"),
+	Documentation = "Select the object",
+}
+
+function SelectObjectEffect:__exec(obj, context)
+	if self.SelectionIsEmpty and SelectedObj then return end
+	if self.ObjNonEmpty and not obj then return end
+	SelectObj(obj)
+end
+
+DefineClass.SetCooldownEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "CooldownObj", name = "Cooldown object", 
+			editor = "combo", default = "Game", items = function (self) return {"obj", "context", "Player", "Game"} end, },
+		{ id = "Cooldown", 
+			editor = "preset_id", default = "Disabled", preset_class = "CooldownDef", },
+		{ id = "TimeScale", name = "Time Scale", 
+			editor = "choice", default = "h", items = function (self) return GetTimeScalesCombo() end, },
+		{ id = "TimeMin", name = "Time min", help = "If time is not provided the default time from the cooldown definition is used.", 
+			editor = "number", default = false, 
+			scale = function(self) return self.TimeScale end, },
+		{ id = "TimeMax", name = "Time max", help = "If time is not provided the default time from the cooldown definition is used.", 
+			editor = "number", default = false, 
+			scale = function(self) return self.TimeScale end, no_edit = function(self) return not self.TimeMin end, },
+	},
+	EditorView = Untranslated("Set <CooldownObj> cooldown <Cooldown>"),
+	Documentation = "Sets a cooldown",
+	EditorNestedObjCategory = "",
+}
+
+function SetCooldownEffect:__exec(obj, context)
+	local cooldown_obj = self.CooldownObj
+	if cooldown_obj == "Player" then
+		obj = ResolveEventPlayer(obj, context)
+	elseif cooldown_obj == "Game" then
+		obj = Game
+	elseif cooldown_obj == "context" then
+		obj = context
+	end
+	assert(not obj or IsKindOf(obj, "CooldownObj"))
+	if IsKindOf(obj, "CooldownObj") then
+		local min, max = self.TimeMin, self.TimeMax
+		local time
+		if min then
+			time = min
+			if max then
+				time = InteractionRandRange(min, max, self.Cooldown, obj)
+			end
+		end
+		obj:SetCooldown(self.Cooldown, time)
+	end
+end
+
+function SetCooldownEffect:GetError()
+	if not CooldownDefs[self.Cooldown] then
+		return "No such cooldown"
+	end
+end
+
+DefineClass.StoryBitActivate = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "Id", name = "Id", 
+			editor = "preset_id", default = false, preset_class = "StoryBit", },
+		{ id = "NoCooldown", help = "Don't activate any cooldowns for subsequent StoryBit activations", 
+			editor = "bool", default = false, },
+		{ id = "ForcePopup", name = "Force Popup", help = "Specifying true skips the notification phase, and directly displays the popup", 
+			editor = "bool", default = true, },
+		{ id = "StorybitSets", name = "Storybit sets", 
+			editor = "text", default = "<StorybitSets>", dont_save = true, read_only = true, },
+		{ id = "OneTime", 
+			editor = "bool", default = false, dont_save = true, read_only = true, },
+	},
+	EditorView = Untranslated('"Activate StoryBit <Id>"'),
+	Documentation = "Activates a StoryBit with the specified Id",
+	NoIngameDescription = true,
+	EditorNestedObjCategory = "Story Bits",
+}
+
+function StoryBitActivate:GetStorybitSets()
+	local preset = StoryBits[self.Id]
+	if not preset or not next(preset.Sets) then return "None" end
+	local items = {}
+	for set in sorted_pairs(preset.Sets) do
+		items[#items + 1] = set
+	end
+	return table.concat(items, ", ")
+end
+
+function StoryBitActivate:GetOneTime()
+	local preset = StoryBits[self.Id]
+	return preset and preset.OneTime
+end
+
+function StoryBitActivate:__exec(obj, context)
+	ForceActivateStoryBit(self.Id, obj, self.ForcePopup and "immediate", context, self.NoCooldown)
+end
+
+DefineClass.StoryBitActivateRandom = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "StoryBits", help = "A list of storybits with weight. One will be chosen and activated based on weight and met prerequisites.", 
+			editor = "nested_list", default = false, base_class = "StoryBitWithWeight", all_descendants = true, },
+	},
+	Documentation = "Performs a weighted random on a list of story bits and activates the one that is picked (if any)",
+	EditorNestedObjCategory = "Story Bits",
+}
+
+function StoryBitActivateRandom:GetEditorView(...)
+	local items = {}
+	for i, item in ipairs(self.StoryBits) do
+		local id = item.StoryBitId or ""
+		if item.Weight then
+			id = id .. " (" .. item.Weight .. ")"
+		end
+		items[i] = id
+	end
+	local names_text = next(items) and table.concat(items, ", ") or "None"
+	return Untranslated(string.format("Activate random event: %s", names_text))
+end
+
+function StoryBitActivateRandom:__exec(obj, context)
+	TryActivateRandomStoryBit(self.StoryBits, obj, context)
+end
+
+function StoryBitActivateRandom:GetError()
+	if not next(StoryBits) then return end
+	if not next(self.StoryBits) then
+		return "No StoryBits to pick from "
+	else
+		for i, item in ipairs(self.StoryBits) do
+			local id = item.StoryBitId
+			if id ~= "" and not StoryBits[id] then
+				return string.format("No such storybit: %s", id)
+			end
+		end
+	end
+end
+
+DefineClass.StoryBitEnableRandom = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	properties = {
+		{ id = "StoryBits", name = "Story Bits", help = "List of StoryBit ids to pick from", 
+			editor = "preset_id_list", default = {}, preset_class = "StoryBit", item_default = "", },
+		{ id = "Weights", name = "Weights", help = "Weights for the entries in StoryBits (default 100)", 
+			editor = "number_list", default = {}, item_default = 100, items = false, },
+	},
+	Documentation = "Performs a weighted random on a list of story bits and enables the one that is picked (if any)",
+	EditorNestedObjCategory = "Story Bits",
+}
+
+function StoryBitEnableRandom:GetEditorView(...)
+	local items = {}
+	local weights = self.Weights
+	for i, id in ipairs(self.StoryBits) do
+		local w = weights[i]
+		if w then
+			id = id .. " (" .. w .. ")"
+		end
+		items[i] = id
+	end
+	local names_text = next(items) and table.concat(items, ", ") or "None"
+	return Untranslated(string.format("Enable random event: %s", names_text))
+end
+
+function StoryBitEnableRandom:__exec(obj, context)
+	local items = {}
+	local weights = self.Weights
+	local states = g_StoryBitStates
+	for i, id in ipairs(self.StoryBits) do
+		local state = states[id]
+		if not state then
+			local def = StoryBits[id]
+			if def and not def.Enabled then
+				local weight = weights[i] or 100
+				items[#items + 1] = {id, weight}
+			end
+		end
+	end
+	local item = table.weighted_rand(items, 2)
+	if not item then
+		return
+	end
+	local id = item[1]
+	local storybit = StoryBits[id]
+	StoryBitState:new{
+		id = id,
+		object = storybit.InheritsObject and context and context.object or nil,
+		player = ResolveEventPlayer(obj, context),
+		inherited_title = context and context:GetTitle() or nil,
+		inherited_image = context and context:GetImage() or nil,
+	}
+end
+
+function StoryBitEnableRandom:GetError()
+	if not next(StoryBits) then return end
+	if not next(self.StoryBits) then
+		return "No StoryBits to pick from "
+	else
+		for i, id in ipairs(self.StoryBits) do
+			if id ~= "" and not StoryBits[id] then
+				return string.format("No such storybit: %s", id)
+			end
+		end
+	end
+end
+
+DefineClass.ViewObjectEffect = {
+	__parents = { "Effect", },
+	__generated_by_class = "EffectDef",
+
+	EditorView = Untranslated("View object"),
+	Documentation = "Move the camera to view the object",
+}
+
+function ViewObjectEffect:__exec(obj, context)
+	ViewObject(obj)
+end
+

CommonLua/Classes/ClassDefs/ClassDef-PresetDefs.generated.lua

@@ -0,0 +1,2072 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.ActorFXClassDef = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Preset", id = "help", help = T(757555070861, --[[PresetDef ActorFXClassDef help]] "Use the Group property to define the ActorFXClass parent - all FX from the parent are inherited.\n\nEntries in the Default group are considered top level and have no parents."), 
+			editor = "help", default = false, },
+	},
+	PropertyTranslation = true,
+	GlobalMap = "ActorFXClassDefs",
+	EditorMenubarName = "FX Classes",
+	EditorMenubar = "Editors.Art",
+	StoreAsTable = true,
+}
+
+----- ActorFXClassDef 
+
+function OnMsg.GatherFXActors(list)
+	ForEachPreset("ActorFXClassDef", function(preset, group, list)
+		list[#list + 1] = preset.id
+	end, list)
+end
+
+function OnMsg.GetCustomFXInheritActorRules(custom_inherit)
+	ForEachPreset("ActorFXClassDef", function(preset, group, custom_inherit)
+		if preset.group ~= "Default" then
+			assert(ActorFXClassDefs[preset.group]) -- any preset group other than 'Default' should have its own ActorFXClass definition; actor classes  in 'Default' are top-level
+			custom_inherit[#custom_inherit + 1] = preset.id
+			custom_inherit[#custom_inherit + 1] = preset.group
+		end
+	end, custom_inherit)
+end
+
+DefineClass.AnimComponent = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "label", name = "Label", help = "Label that identifies the kind of IK", 
+			editor = "text", default = false, },
+	},
+	GlobalMap = "AnimComponents",
+	EditorMenubar = "Editors.Art",
+}
+
+DefineClass.AnimIKLimbAdjust = {
+	__parents = { "AnimComponent", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "Limbs", 
+			editor = "nested_list", default = false, base_class = "AnimLimbData", inclusive = true, auto_expand = true, },
+		{ id = "adjust_root_to_reach_targets", help = "Adjust root position along an axis in case limb targets are too far from the current position", 
+			editor = "bool", default = false, },
+		{ id = "adjust_root_axis", help = "Axis to adjust root position to reach far out limb targets", 
+			editor = "point", default = point(0, 0, 1000), },
+		{ id = "max_target_speed", help = "Maximum units per second the adjusted limb fit positions are allowed to move, 0 means no limit", 
+			editor = "number", default = 5000, min = 0, },
+	},
+	PresetClass = "AnimComponent",
+}
+
+DefineClass.AnimIKLookAt = {
+	__parents = { "AnimComponent", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "pivot_bone", 
+			editor = "text", default = false, },
+		{ id = "pivot_parents", help = "Number of bones to distribute the rotation between", 
+			editor = "number", default = 1, min = 1, },
+		{ id = "aim_bone", 
+			editor = "text", default = false, },
+		{ id = "aim_forward", help = "Forward direction in local bone space", 
+			editor = "point", default = point(-1000, 0, 0), },
+		{ id = "aim_up", help = "Up direction in local bone space", 
+			editor = "point", default = point(0, -1000, 0), },
+		{ id = "max_vertical_angle", 
+			editor = "number", default = 2700, scale = "deg", min = 0, max = 10800, },
+		{ id = "max_horizontal_angle", 
+			editor = "number", default = 5400, scale = "deg", min = 0, max = 10800, },
+		{ id = "out_of_bound_vertical_snap", help = "Snap vertical angle to 0 if target is outside horizontal limits", 
+			editor = "bool", default = false, },
+		{ id = "max_angular_speed", help = "Maximum local angle per second", 
+			editor = "number", default = 5400, scale = "deg", min = 0, max = 43200, },
+	},
+	PresetClass = "AnimComponent",
+}
+
+DefineClass.AnimMetadata = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "FX", id = "Action", name = "Test action", 
+			editor = "combo", default = false, dont_save = true, items = function (self)
+return table.ifilter(PresetsPropCombo("FXPreset", "Action")(), function(idx, item) 
+	return FXActionToAnim(item) == item
+end)
+end, show_recent_items = 7,},
+		{ category = "FX", id = "Actor", name = "Test actor", 
+			editor = "combo", default = false, dont_save = true, items = function (self) return ActionFXClassCombo() end, show_recent_items = 7,},
+		{ category = "FX", id = "Target", name = "Test target", 
+			editor = "combo", default = false, dont_save = true, items = function (self) return TargetFXClassCombo end, show_recent_items = 7,},
+		{ category = "FX", id = "FXInherits", 
+			editor = "string_list", default = {}, item_default = "idle", items = function (self) return IsValidEntity(self.group) and GetStates(self.group) or { "idle" } end, },
+		{ category = "Moments", id = "ReconfirmAll", 
+			editor = "buttons", default = false, buttons = { {name = "Reconfirm", func = "ReconfirmMoments"}, }, },
+		{ category = "Moments", id = "Moments", 
+			editor = "nested_list", default = false, base_class = "AnimMoment", inclusive = true, },
+		{ category = "Animation", id = "SpeedModifier", 
+			editor = "number", default = 100, min = 10, max = 1000, },
+		{ category = "Animation", id = "StepModifier", 
+			editor = "number", default = 100, min = 10, max = 1000, },
+		{ category = "Anim Components", id = "VariationWeight", 
+			editor = "number", default = 100, slider = true, min = 0, max = 10000, },
+		{ category = "Anim Components", id = "RandomizePhase", 
+			editor = "number", default = -1, min = -1, },
+		{ category = "Anim Components", id = "AnimComponents", 
+			editor = "nested_list", default = false, base_class = "AnimComponentWeight", inclusive = true, auto_expand = true, },
+	},
+	GedEditor = "",
+}
+
+function AnimMetadata:GetAction()
+	if not self.Action then
+		local obj = GetAnimationMomentsEditorObject()
+		if obj then
+			local anim = AnimationMomentsEditorMode == "selection" and obj:Getanim() or GetStateName(obj:GetState())
+			return FXAnimToAction(anim)
+		end
+	end
+	return self.Action
+end
+
+function AnimMetadata:GetActor()
+	if not self.Actor then
+		local obj = GetAnimationMomentsEditorObject()
+		if obj and g_Classes.Unit then
+			obj = rawget(obj, "obj") or obj
+			local obj_class = obj.class
+			if obj:IsKindOfClasses("Unit", "BaseObjectAME") or obj_class == "DummyUnit" then
+				obj_class = "Unit"
+			end
+			return g_Classes[obj_class].fx_actor_class or obj_class
+		end
+	end
+	return self.Actor
+end
+
+function AnimMetadata:PostLoad()
+	local ent_speed_mod = const.AnimSpeedScale * self.SpeedModifier / 100
+	local entity = self.group
+	local state = GetStateIdx(self.id)
+	SetStateSpeedModifier(entity, state, ent_speed_mod)
+	SetStateStepModifier(entity, state, self.StepModifier)
+end
+
+function AnimMetadata:OnPreSave()
+	-- fixup revisions of files that were modified locally when animation moments were added
+	for _, moment in ipairs(self.Moments) do
+		if moment.AnimRevision == 999999999 then
+			moment.AnimRevision = EntitySpec:GetAnimRevision(self.group, self.id)
+		end
+	end
+end
+
+function AnimMetadata:ReconfirmMoments(root, prop_id, ged)
+	local revision = GetAnimationMomentsEditorObject().AnimRevision
+	for _, moment in ipairs(self.Moments or empty_table) do
+		if moment.AnimRevision ~= revision then
+			moment.AnimRevision = revision
+			ObjModified(moment)
+		end
+	end
+	ObjModified(self)
+	ObjModified(ged:ResolveObj("Animations"))
+end
+
+function AnimMetadata:GetError()
+	local entity = self.group
+	if not IsValidEntity(entity) then
+		return "No such entity " .. (entity or "")
+	end
+	local state = self.id
+	if not HasState(entity, state) then
+		return "No such anim " .. entity .. "." .. (state or "")
+	end
+end
+
+----- AnimMetadata remove group and id properties
+
+table.insert(AnimMetadata.properties, { id = "Id", editor = "text", no_edit = true })
+table.insert(AnimMetadata.properties, { id = "Group", editor = "text", no_edit = true })
+
+DefineClass.Appearance = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "Body", id = "Body", name = "Body", 
+			editor = "combo", default = false, items = function (self) return GetCharacterBodyComboItems() end, },
+		{ category = "Body", id = "BodyColor", name = "Body Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Head", id = "Head", name = "Head", 
+			editor = "combo", default = false, items = function (self) return GetCharacterHeadComboItems(self) end, },
+		{ category = "Head", id = "HeadColor", name = "Head Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Shirt", id = "Shirt", name = "Shirt", 
+			editor = "combo", default = false, items = function (self) return GetCharacterShirtComboItems(self) end, },
+		{ category = "Shirt", id = "ShirtColor", name = "Shirt Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Pants", id = "Pants", name = "Pants", 
+			editor = "combo", default = false, items = function (self) return GetCharacterPantsComboItems(self) end, },
+		{ category = "Pants", id = "PantsColor", name = "Pants Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Armor", id = "Armor", name = "Armor", 
+			editor = "combo", default = false, items = function (self) return GetCharacterArmorComboItems(self) end, },
+		{ category = "Armor", id = "ArmorColor", name = "Armor Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Chest", id = "Chest", name = "Chest", 
+			editor = "combo", default = false, items = function (self) return GetCharacterChestComboItems(self) end, },
+		{ category = "Chest", id = "ChestSpot", name = "Chest Spot", help = "Where to attach the hat", 
+			editor = "combo", default = "Torso", items = function (self) return {"Torso", "Origin"} end, },
+		{ category = "Chest", id = "ChestColor", name = "Chest Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Hip", id = "Hip", name = "Hip", 
+			editor = "combo", default = false, items = function (self) return GetCharacterHipComboItems(self) end, },
+		{ category = "Hip", id = "HipSpot", name = "Hip Spot", help = "Where to attach the hat", 
+			editor = "combo", default = "Groin", items = function (self) return {"Groin", "Origin"} end, },
+		{ category = "Hip", id = "HipColor", name = "Hip Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Hat", id = "Hat", name = "Hat", 
+			editor = "combo", default = false, items = function (self) return GetCharacterHatComboItems() end, },
+		{ category = "Hat", id = "HatSpot", name = "Hat Spot", help = "Where to attach the hat", 
+			editor = "combo", default = "Head", items = function (self) return {"Head", "Origin"} end, },
+		{ category = "Hat", id = "HatAttachOffsetX", name = "Hat Attach Offset X", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "HatAttachOffsetY", name = "Hat Attach Offset Y", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "HatAttachOffsetZ", name = "Hat Attach Offset Z", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "HatAttachOffsetAngle", name = "Hat Attach Offset Angle", 
+			editor = "number", default = false, scale = "deg", slider = true, min = -18000, max = 10800, },
+		{ category = "Hat", id = "HatColor", name = "Hat Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Hat", id = "Hat2", name = "Hat2", 
+			editor = "combo", default = false, items = function (self) return GetCharacterHatComboItems() end, },
+		{ category = "Hat", id = "Hat2Spot", name = "Hat 2 Spot", help = "Where to attach the hat", 
+			editor = "combo", default = "Head", items = function (self) return {"Head", "Origin"} end, },
+		{ category = "Hat", id = "Hat2AttachOffsetX", name = "Hat 2 Attach Offset X", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "Hat2AttachOffsetY", name = "Hat 2 Attach Offset Y", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "Hat2AttachOffsetZ", name = "Hat 2 Attach Offset Z", 
+			editor = "number", default = false, scale = "cm", slider = true, min = -50, max = 50, },
+		{ category = "Hat", id = "Hat2AttachOffsetAngle", name = "Hat 2 Attach Offset Angle", 
+			editor = "number", default = false, scale = "deg", slider = true, min = -18000, max = 10800, },
+		{ category = "Hat", id = "Hat2Color", name = "Hat 2 Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Hair", id = "Hair", name = "Hair", 
+			editor = "combo", default = false, items = function (self) return GetCharacterHairComboItems(self) end, },
+		{ category = "Hair", id = "HairSpot", name = "Hair Spot", help = "Where to attach the hat", 
+			editor = "combo", default = "Head", items = function (self) return {"Head"} end, },
+		{ category = "Hair", id = "HairColor", name = "Hair Color", 
+			editor = "nested_obj", default = false, base_class = "ColorizationPropSet", },
+		{ category = "Hair", id = "HairParam1", name = "Hair Spec Strength", 
+			editor = "number", default = 51, slider = true, min = 0, max = 255, },
+		{ category = "Hair", id = "HairParam2", name = "Hair Env Strength", 
+			editor = "number", default = 51, slider = true, min = 0, max = 255, },
+		{ category = "Hair", id = "HairParam3", name = "Hair Light Softness", 
+			editor = "number", default = 255, slider = true, min = 0, max = 255, },
+		{ category = "Hair", id = "HairParam4", name = "Hair Specular Colorization", 
+			editor = "number", default = 0, no_edit = true, slider = true, min = 0, max = 255, },
+	},
+}
+
+DefineClass.AppearancePreset = {
+	__parents = { "Preset", "Appearance", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "ViewInChararacterEditorButton", 
+			editor = "buttons", default = false, buttons = { {name = "View in Anim Metadata Editor", func = "ViewInAnimMetadataEditor"}, }, },
+		{ id = "ViewInAnimMetadataEditor", 
+			editor = "func", default = function (self)
+CloseAnimationMomentsEditor() -- close if opened
+OpenAnimationMomentsEditor(self.id)
+end, no_edit = true, },
+	},
+	GlobalMap = "AppearancePresets",
+	EditorMenubarName = "Appearance Editor",
+	EditorIcon = "CommonAssets/UI/Icons/business compare decision direction marketing.png",
+	EditorMenubar = "Characters",
+	EditorCustomActions = {
+	{
+		FuncName = "RefreshApperanceToAllUnits",
+		Icon = "CommonAssets/UI/Ged/play",
+		Menubar = "Actions",
+		Name = "Apply to All",
+		Rollover = "Refreshes all units on map with this appearance",
+		Toolbar = "main",
+	},
+},
+}
+
+function AppearancePreset:GetError()
+	local parts = table.copy(AppearanceObject.attached_parts)
+	table.insert(parts, "Body")
+	local results = {}
+	for _, part in ipairs(parts) do
+		if self[part] and self[part] ~= "" and not IsValidEntity(self[part]) then
+			results[#results+1] = string.format("%s: invalid entity %s", part, self[part])
+		end
+	end
+	if next(results) then
+		return table.concat(results, "\n")
+	end
+end
+
+DefineClass.BadgePresetDef = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "HasArrow", name = "HasArrow", 
+			editor = "bool", default = false, },
+		{ id = "ArrowTemplate", name = "ArrowTemplate", 
+			editor = "combo", default = false, items = function (self) return XTemplateCombo("XBadgeArrow", false) end, },
+		{ id = "UITemplate", name = "UITemplate", help = "The UI template which defines how the badge will look above the object.", 
+			editor = "combo", default = false, items = function (self) return XTemplateCombo() end, },
+		{ id = "ZoomUI", name = "Zoom UI", 
+			editor = "bool", default = false, },
+		{ id = "EntityName", name = "EntityName", help = "The entity to spawn as a badge on the unit, if any.", 
+			editor = "combo", default = false, items = function (self)
+return table.keys2(table.filter(GetAllEntities(), function(e) return e:sub(1, 2) == "Iw" end, "none"))
+end, },
+		{ id = "AttachSpotName", name = "Attach Spot Name", help = "If set the badge will attach to the spot with that name.", 
+			editor = "text", default = false, },
+		{ id = "attachOffset", name = "Entity Attach Offset", help = "An offset from the specified point to attach the badge to. Will overwrite any such offsets from the entity class.", 
+			editor = "point", default = false, },
+		{ id = "noRotate", name = "Don't Rotate Arrow", help = "If set the arrow template will not be rotated according to the direction of the target but just stick on the edge of the screen.", 
+			editor = "bool", default = false, },
+		{ id = "noHide", name = "Don't Hide", help = "Don't hide this badge if there are other badges on the target. Badges marked as \"noHide\" also do not count towards \"other badges on the target\".", 
+			editor = "bool", default = false, },
+		{ id = "handleMouse", name = "Handle Mouse", help = "If enabled the badge will have a thread running to make sure it can handle mouse events like a normal UI window.", 
+			editor = "bool", default = false, },
+		{ id = "BadgePriority", name = "BadgePriority", 
+			editor = "number", default = false, },
+	},
+	GlobalMap = "BadgePresetDefs",
+}
+
+DefineClass.BindingsMenuCategory = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "Name", 
+			editor = "text", default = false, translate = true, },
+	},
+}
+
+DefineClass.BugReportTag = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "Platform", help = "Whether this is a Platform tag.", 
+			editor = "bool", default = false, },
+		{ id = "Automatic", 
+			editor = "bool", default = false, },
+		{ id = "ShowInExternal", name = "Show in External Bug Report", 
+			editor = "bool", default = false, },
+	},
+}
+
+DefineClass.Camera = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Preset", id = "comment", name = "comment", 
+			editor = "text", default = "Camera", },
+		{ category = "Preset", id = "display_name", name = "Display Name", 
+			editor = "text", default = T(145449857928, --[[PresetDef Camera default]] "Camera"), translate = true, },
+		{ category = "Preset", id = "description", name = "Description", 
+			editor = "text", default = false, translate = true, lines = 3, max_lines = 10, },
+		{ category = "Camera", id = "map", name = "Map", 
+			editor = "combo", default = false, 
+			cam_prop = true, items = function (self) return ListMaps() end, },
+		{ category = "Camera", id = "SavedGame", name = "Saved Game", 
+			editor = "text", default = false, },
+		{ category = "Camera", id = "order", name = "Order", 
+			editor = "number", default = 0, },
+		{ category = "Camera", id = "locked", name = "Locked", 
+			editor = "bool", default = false, 
+			cam_prop = true, },
+		{ category = "Camera", id = "flip_to_adjacent", name = "Flip to Adjacent", 
+			editor = "bool", default = false, },
+		{ category = "Camera", id = "fade_in", name = "Fade In", 
+			editor = "number", default = 200, },
+		{ category = "Camera", id = "fade_out", name = "Fade Out", 
+			editor = "number", default = 200, },
+		{ category = "Camera", id = "movement", name = "Movement", 
+			editor = "combo", default = "", items = function (self) return table.keys2(CameraMovementTypes, nil, "") end, },
+		{ category = "Camera", id = "interpolation", name = "Interpolation", 
+			editor = "combo", default = "linear", items = function (self) return table.keys2(CameraInterpolationTypes) end, },
+		{ category = "Camera", id = "duration", name = "Duration", 
+			editor = "number", default = 1000, },
+		{ category = "Camera", id = "buttonsSrc", 
+			editor = "buttons", default = false, buttons = { {name = "View Start", func = "ViewStart"},  {name = "Set Start", func = "SetStart"}, }, },
+		{ category = "Camera", id = "cam_lookat", 
+			editor = "point", default = false, 
+			cam_prop = true, },
+		{ category = "Camera", id = "cam_pos", 
+			editor = "point", default = false, 
+			cam_prop = true, },
+		{ category = "Camera", id = "buttonsDest", 
+			editor = "buttons", default = false, buttons = { {name = "View Dest", func = "ViewDest"},  {name = "Set Dest", func = "SetDest"}, }, },
+		{ category = "Camera", id = "cam_dest_lookat", 
+			editor = "point", default = false, 
+			cam_prop = true, },
+		{ category = "Camera", id = "cam_dest_pos", 
+			editor = "point", default = false, 
+			cam_prop = true, },
+		{ category = "Camera", id = "cam_type", 
+			editor = "choice", default = "Max", items = function (self) return GetCameraTypesItems end, },
+		{ category = "Camera", id = "fovx", 
+			editor = "number", default = 4200, 
+			cam_prop = true, },
+		{ category = "Camera", id = "zoom", 
+			editor = "number", default = 2000, 
+			cam_prop = true, },
+		{ category = "Camera", id = "lightmodel", name = "Light Model", help = "Specify a light model, or leave as 'false' to restore the previous one.", 
+			editor = "preset_id", default = false, preset_class = "LightmodelPreset", },
+		{ category = "Camera", id = "interface", name = "Interface in Screenshots", help = "Check this to include game interface in the screenshots", 
+			editor = "bool", default = false, },
+		{ category = "Camera", id = "cam_props", 
+			editor = "prop_table", default = false, 
+			cam_prop = true, indent = "", lines = 1, max_lines = 20, },
+		{ category = "Camera", id = "camera_properties", name = "Camera Properties", 
+			editor = "prop_table", default = false, no_edit = true, indent = "", lines = 1, max_lines = 20, },
+		{ category = "Functions", id = "beginFunc", name = "Begin() Function", 
+			editor = "func", default = function (self)  end, },
+		{ category = "Functions", id = "endFunc", name = "End() Function", 
+			editor = "func", default = function (self)  end, },
+	},
+	GlobalMap = "PredefinedCameras",
+	EditorMenubarName = "Camera Editor",
+	EditorIcon = "CommonAssets/UI/Icons/outline video.png",
+	EditorMenubar = "Map",
+	EditorCustomActions = {
+	{
+		FuncName = "OpenShowcase",
+		Icon = "CommonAssets/UI/Ged/play",
+		Menubar = "Actions",
+		Name = "ShowcaseUI",
+		Rollover = 'Showcase UI <newline>Toggles "Show Case" interface showing all cameras from a group, sorted by order',
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpCreateCameraDest",
+		Icon = "CommonAssets/UI/Ged/create_camera_destination",
+		Menubar = "Actions",
+		Name = "CameraDest",
+		Rollover = "Create Camera Destination",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpUpdateCamera",
+		Icon = "CommonAssets/UI/Ged/update_current_camera",
+		Menubar = "Actions",
+		Name = "UpdateCamera",
+		Rollover = "Update Camera",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpViewMovement",
+		Icon = "CommonAssets/UI/Ged/preview",
+		IsToggledFuncName = "GedOpIsViewMovementToggled",
+		Menubar = "Actions",
+		Name = "ViewMovement",
+		Rollover = "View Movement",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpUnlockCamera",
+		Icon = "CommonAssets/UI/Ged/unlock_camera",
+		Menubar = "Actions",
+		Name = "UnlockCamera",
+		Rollover = "Unlock Camera",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpMaxCamera",
+		Icon = "CommonAssets/UI/Ged/max_camera",
+		Menubar = "Camera",
+		Name = "MaxCamera",
+		Rollover = "Max Camera",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpRTSCamera",
+		Icon = "CommonAssets/UI/Ged/rts_camera",
+		Menubar = "Camera",
+		Name = "RTSCamera",
+		Rollover = "RTS Camera",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpTacCamera",
+		Icon = "CommonAssets/UI/Ged/tac_camera",
+		Menubar = "Camera",
+		Name = "TacCamera",
+		Rollover = "Tac Camera",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpCreateReferenceImages",
+		Icon = "CommonAssets/UI/Ged/create_reference_images",
+		Menubar = "Actions",
+		Name = "CreateReferenceImages",
+		Rollover = "Create Reference Images(used during Night Build Game Tests)",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedOpTakeScreenshots",
+		Icon = "CommonAssets/UI/Ged/camera",
+		Menubar = "Actions",
+		Name = "TakeScreenshot",
+		Rollover = "Takes screenshot of the selected camera(s)",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedPrgPresetToggleStrips",
+		Icon = "CommonAssets/UI/Ged/explorer",
+		IsToggledFuncName = "GedPrgPresetBlackStripsVisible",
+		Menubar = "Actions",
+		Name = "ToggleBlackStrips",
+		Rollover = "Toggle black strips (Alt-T)",
+		Shortcut = "Alt-T",
+		SortKey = "strips",
+		Toolbar = "main",
+	},
+},
+}
+
+function Camera:ApplyProperties(dont_lock, should_fade, ged)
+	if (self.SavedGame or "") ~= "" then
+		if (SavegameMeta or empty_table).savename ~= self.SavedGame then
+			if not ged or ged:WaitQuestion("Load Game", "Load camera save?", "Yes", "No") == "ok" then
+				LoadGame(self.SavedGame)
+			end
+		end
+	elseif (self.map or "") ~= "" then
+		if GetMapName() ~= self.map then
+			if ged then
+				if  ged:WaitQuestion("Change Map", "Change camera map?", "Yes", "No") == "ok" then
+					ChangeMap(self.map)
+				else
+					return
+				end
+			else
+				ChangeMap(self.map)
+			end
+		end
+	end
+	SetCamera(self.cam_pos, self.cam_lookat, self.cam_type, self.zoom, self.cam_props, self.fovx)
+	if self.locked and not dont_lock then
+		LockCamera("CameraPreset")
+	else
+		UnlockCamera("CameraPreset")
+	end
+	if should_fade and self.fade_in > 0 then
+		local fade_in = should_fade and self.fade_in or 0
+		local fade = OpenDialog("Fade")
+		fade.idFade:SetVisible(true, "instant")
+		if should_fade then
+			WaitResourceManagerRequests(1000,1)
+		end	
+		fade.idFade.FadeOutTime = should_fade and self.fade_in or 0
+		fade.idFade:SetVisible(false)
+	end
+	if self.movement ~= "" then
+		local camera1 = { pos = self.cam_pos, lookat = self.cam_lookat }
+		local camera2 = { pos = self.cam_dest_pos, lookat = self.cam_dest_lookat }
+		InterpolateCameraMaxWakeup(camera1, camera2, self.duration, nil, self.interpolation, self.movement)
+	end
+	if self.lightmodel then
+		SetLightmodel(1, self.lightmodel)
+	end
+	self:beginFunc()
+	if should_fade and self.fade_in > 0 then
+		local fade_in = should_fade and self.fade_in or 0
+		if self.movement == "" then
+			Sleep(fade_in)
+		elseif fade_in > self.duration then
+			Sleep(fade_in - self.duration)
+		end
+	end
+end
+
+function Camera:RevertProperties(should_fade)
+	if should_fade and self.fade_out > 0 then
+		local fade_out = should_fade and self.fade_out or 0
+		local fade = GetDialog("Fade")
+		if fade then
+			fade.idFade:SetVisible(false, "instant")
+			fade.idFade.FadeInTime = fade_out
+			fade.idFade:SetVisible(true)
+			Sleep(fade_out)
+		end
+	end
+	CloseDialog("Fade")
+	self:endFunc()
+end
+
+function Camera:QueryProperties()
+	local cam_pos, cam_lookat, cam_type, zoom, cam_props, fovx = GetCamera()
+	if cam_type ~= "Max" then
+		self.movement = ""
+	end
+	self.cam_pos = cam_pos
+	self.cam_lookat = cam_lookat
+	self.cam_type = cam_type
+	self.zoom = zoom
+	self.cam_props = cam_props
+	self.locked = camera.IsLocked()
+	self.fovx = fovx
+	self.map = GetMapName()
+	GedObjectModified(self)
+end
+
+function Camera:PostLoad()
+	Preset.PostLoad(self)
+	-- old format compatibility code:
+	local cam_props = self.camera_properties or empty_table
+	for _, prop in ipairs(self:GetProperties()) do
+		if prop.cam_prop then
+			local value = cam_props[prop.id]
+			if value ~= nil then
+				self[prop.id] = value
+			end
+		end
+	end
+	self.camera_properties = nil
+end
+
+function Camera:SetStart()
+	local cam_pos, cam_lookat = GetCamera()
+	self:SetProperty("cam_pos", cam_pos)
+	self:SetProperty("cam_lookat", cam_lookat)
+	ObjModified(self)
+end
+
+function Camera:ViewStart()
+	SetCamera(self.cam_pos, self.cam_lookat, self.cam_type, self.zoom, self.cam_props, self.fovx)
+end
+
+function Camera:SetDest()
+	local cam_pos, cam_lookat = GetCamera()
+	self:SetProperty("cam_dest_pos", cam_pos)
+	self:SetProperty("cam_dest_lookat", cam_lookat)
+	self:SetProperty("cam_type", "Max")	-- movement forces Max camera
+	ObjModified(self)
+end
+
+function Camera:ViewDest(camera)
+	local pos = self.cam_dest_pos or self.cam_pos
+	local lookat = self.cam_dest_lookat or self.cam_lookat
+	SetCamera(pos, lookat, self.cam_type, self.zoom, self.cam_props, self.fovx)
+end
+
+function Camera:GetEditorView()
+	if tonumber(self.order) then
+		return Untranslated("<u(id)> <color 0 200 0><u(Comment)>(Showcase: #<u(order)>)</color>")
+	else
+		return Untranslated("<u(id)> <color 0 200 0><u(Comment)></color>")
+	end
+end
+
+function Camera:OnEditorNew(parent, ged, is_paste)
+	self.order = (#Presets.Camera[self.group] or 0) + 1
+	self:SetId(self:GenerateUniquePresetId("Camera_" .. self.order))
+	self:QueryProperties()
+end
+
+DefineClass.CheatDef = {
+	__parents = { "DisplayPreset", "TODOPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "in_menu", name = "Show in menu", 
+			editor = "combo", default = "", items = function (self) return {""} end, show_recent_items = 10,},
+		{ id = "modes", name = "Menu modes", 
+			editor = "string_list", default = {}, dont_save = function(self) return self.in_menu == "" end, no_edit = function(self) return self.in_menu == "" end, item_default = "", items = false, arbitrary_value = true, },
+		{ category = "Execution", id = "params", name = "Parameters", help = 'Cheats without parameters or with parameters "Selection" appear in the game cheats menu', 
+			editor = "combo", default = "", items = function (self) return {"", "SelectedObj", "Selection"} end, },
+		{ category = "Execution", id = "param_values", name = "Parameter values", 
+			editor = "expression", default = false, dont_save = function(self) local params = self.params:trim_spaces() return params == "" or params == "Selection" or params == "SelectedObj" end, no_edit = function(self) local params = self.params:trim_spaces() return params == "" or params == "Selection" or params == "SelectedObj" end, },
+		{ category = "Execution", id = "sync", name = "Sync", 
+			editor = "bool", default = true, },
+		{ category = "Execution", id = "run", name = "Run", 
+			editor = "func", default = function (self)  end, 
+			params = function(obj) return obj:GetParamNames() end, },
+		{ category = "Execution", id = "state", name = "State", help = 'Can return "hidden", "disabled" or nil', 
+			editor = "func", default = function (self)  end, 
+			params = function(obj) return obj:GetParamNames() end, },
+	},
+	GlobalMap = "CheatDefs",
+	EditorMenubarName = "Cheats",
+	EditorMenubar = "Editors.Engine",
+}
+
+function CheatDef:GetParamNames()
+	local params = self.params:trim_spaces()
+	if params == "" then return "self" end
+	if params == "SelectedObj" then return "self, obj" end
+	if params == "Selection" then return "self, objs" end
+	return "self, " .. self.params
+end
+
+function CheatDef:GetParams()
+	local params = self.params:trim_spaces()
+	if params == "" then return end
+	if params == "SelectedObj" then return SelectedObj end
+	if params == "Selection" then return Selection end
+	if self.param_values then
+		return self:param_values()
+	end
+end
+
+function CheatDef:Exec()
+	if self.sync then
+		NetSyncEvent("CheatDef", self.id, self:GetParams())
+	else
+		self:run(self:GetParams())
+	end
+end
+
+function CheatDef:SpawnAction(host)
+	XAction:new({
+		ActionMode = table.concat(self.modes,","),
+		ActionMenubar = self.in_menu ~= "" and self.in_menu or nil,
+		ActionName = self:GetDisplayName(),
+		ActionDescription = self:GetDescription(),
+		ActionSortKey = string.format("%09d", self.SortKey or 0),
+		ActionTranslate = true,
+		ActionState = function(self, host)
+			return self.cheat:state(self.cheat:GetParams())
+		end,
+		OnAction = function (self, host, source, ...)
+			self.cheat:Exec()
+		end,
+		cheat = self,
+	}, host)
+end
+
+----- CheatDef 
+
+function NetSyncEvents.CheatDef(id, ...)
+	local def = CheatDefs[id]
+	if not AreCheatsEnabled() or not def then return end
+	print("Cheat", def.id)
+	LogCheatUsed(def.id)
+	def:run(...)
+end
+
+function OnMsg.Shortcuts(host)
+	ForEachPreset("CheatDef", function(preset, group, host)
+		if preset.in_menu ~= "" then
+			preset:SpawnAction(host)
+		end
+	end, host)
+end
+
+function OnMsg.PresetSave(class)
+	if IsKindOf(g_Classes[class], "CheatDef") then
+		ReloadShortcuts()
+	end
+end
+
+DefineClass.CommonTags = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+}
+
+DefineClass.DisplayPreset = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "display_name", name = "Display Name", 
+			editor = "text", default = "", translate = true, },
+		{ category = "General", id = "display_name_caps", name = "Display Name Caps", 
+			editor = "text", default = "", translate = true, },
+		{ category = "General", id = "description", name = "Description", 
+			editor = "text", default = "", translate = true, lines = 3, max_lines = 20, },
+		{ category = "General", id = "description_gamepad", name = "Gamepad description", 
+			editor = "text", default = "", translate = true, wordwrap = true, lines = 3, max_lines = 20, },
+		{ category = "General", id = "flavor_text", name = "Flavor text", 
+			editor = "text", default = "", translate = true, lines = 3, max_lines = 20, },
+		{ category = "General", id = "new_in", name = "New in update", help = 'Update showing this preset with a "New!" tag', 
+			editor = "text", default = "", no_edit = function(self) return not self.NewFeatureTag end, },
+	},
+	AltFormat = "<EditorViewPresetPrefix><display_name><EditorViewPresetPostfix><color 0 128 0><opt(u(Comment),' ','')><color 128 128 128><opt(u(save_in),' - ','')>",
+	EditorMenubarName = false,
+	__hierarchy_cache = true,
+	DescriptionFlavor = T(334322641039, --[[PresetDef DisplayPreset value]] "<description><newline><newline><flavor><flavor_text></flavor>"),
+	NewFeatureTag = T(820790154429, --[[PresetDef DisplayPreset value]] "<em>NEW!</em> "),
+}
+
+function DisplayPreset:GetDisplayName()
+	if self.new_in == config.NewFeaturesUpdate and self.NewFeatureTag then
+		return self.NewFeatureTag .. self.display_name
+	else
+		return self.display_name
+	end
+end
+
+function DisplayPreset:GetDisplayNameCaps()
+	if self.new_in == config.NewFeaturesUpdate and self.NewFeatureTag then
+		return self.NewFeatureTag .. self.display_name_caps
+	else
+		return self.display_name_caps
+	end
+end
+
+function DisplayPreset:GetDescription()
+	local description = self.description
+	if GetUIStyleGamepad() and self.description_gamepad ~= "" then
+		description = self.description_gamepad
+	end
+		
+	if self.flavor_text == "" or not self.DescriptionFlavor then
+		return description
+	else
+		return T{self.DescriptionFlavor, self, description = description}
+	end
+end
+
+function DisplayPreset:OnEditorNew()
+	self.new_in = config.NewFeaturesUpdate or nil
+end
+
+----- DisplayPreset DisplayPresetCombo
+
+function DisplayPresetCombo(class, filter, ...)
+	local params = pack_params(...)
+	return function()
+		return ForEachPreset(class, function(preset, group, items, filter, params)
+			if not filter or filter(preset, unpack_params(params)) then
+				items[#items + 1] = { value = preset.id, text = preset:GetDisplayName() }
+			end
+		end, {}, filter, params)
+	end
+end
+
+DefineClass.GameDifficultyDef = {
+	__parents = { "MsgReactionsPreset", "DisplayPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "effects", name = "Effects on NewMapLoaded", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, auto_expand = true, },
+	},
+	HasGroups = false,
+	HasSortKey = true,
+	HasParameters = true,
+	GlobalMap = "GameDifficulties",
+	EditorMenubarName = "Game Difficulty",
+	EditorIcon = "CommonAssets/UI/Icons/bullet list.png",
+	EditorMenubar = "Editors.Lists",
+	Documentation = "Creates a custom game difficulty and sets custom effects on the loaded map.",
+}
+
+DefineModItemPreset("GameDifficultyDef", { EditorName = "Game difficulty", EditorSubmenu = "Gameplay" })
+
+----- GameDifficultyDef 
+
+function GetGameDifficulty()
+	local game = Game
+	return game and game.game_difficulty
+end
+
+function OnMsg.NewMapLoaded()
+	if not mapdata.GameLogic or not Game then return end
+	local difficulty = GameDifficulties[GetGameDifficulty()]
+	ExecuteEffectList(difficulty and difficulty.effects, Game)
+end
+
+function AddDifficultyLootConditions()
+	ForEachPreset("GameDifficultyDef", function(preset, group)
+		local difficulty = preset.id
+		LootCondition["Difficulty " .. difficulty] = function() return (Game and Game.game_difficulty) == difficulty end
+	end)
+end
+
+OnMsg.PresetSave = AddDifficultyLootConditions
+OnMsg.DataLoaded = AddDifficultyLootConditions
+
+DefineClass.GameRuleDef = {
+	__parents = { "MsgReactionsPreset", "DisplayPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "init_as_active", name = "Active by default", 
+			editor = "bool", default = false, },
+		{ category = "General", id = "option", name = "Add as option", 
+			editor = "bool", default = false, },
+		{ id = "option_id", name = "Option Id", 
+			editor = "text", default = false, 
+			no_edit = function(self) return not self.option end, },
+		{ category = "General", id = "exclusionlist", name = "Exclusion List", help = "List of other game rules that are not compatible with this one. If this rule is active the player won't be able to enable the rules in the exclusion list.", 
+			editor = "preset_id_list", default = {}, preset_class = "GameRuleDef", item_default = "", },
+		{ id = "effects", name = "Effects on NewMapLoaded", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+	},
+	HasGroups = false,
+	HasSortKey = true,
+	HasParameters = true,
+	GlobalMap = "GameRuleDefs",
+	EditorMenubarName = "Game Rules",
+	EditorIcon = "CommonAssets/UI/Icons/bullet list.png",
+	EditorMenubar = "Editors.Lists",
+	Documentation = "Defines a new game rule that can be activated by players when starting a new game.",
+}
+
+DefineModItemPreset("GameRuleDef", { EditorName = "Game rule", EditorSubmenu = "Gameplay" })
+
+function GameRuleDef:IsCompatible(active_rules)
+	local exclusions = table.invert(self.exclusionlist or empty_table)
+	local id = self.id
+	for rule_id in pairs(active_rules) do
+		if exclusions[rule_id] or table.find(GameRuleDefs[rule_id].exclusionlist or empty_table, id) then
+			return false
+		end
+	end
+	return true
+end
+
+----- GameRuleDef 
+
+function IsGameRuleActive(rule_id)
+	local game = Game
+	return (game and game.game_rules or empty_table)[rule_id]
+end
+
+function OnMsg.NewMapLoaded()
+	if not mapdata.GameLogic or not Game then return end
+	ForEachPreset("GameRuleDef", function(rule)
+		if IsGameRuleActive(rule.id) then
+			ExecuteEffectList(rule.effects, Game)
+		end
+	end)
+end
+
+DefineClass.GameStateDef = {
+	__parents = { "DisplayPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "ShowInFilter", name = "Show in filters", 
+			editor = "bool", default = true, },
+		{ id = "PlayFX", name = "Play FX", 
+			editor = "bool", default = true, },
+		{ id = "MapState", name = "Is map state", help = "Map states are removed when exiting a map", 
+			editor = "bool", default = true, },
+		{ id = "PersistInSaveGame", name = "Persist in save game", 
+			editor = "bool", default = false, },
+		{ id = "Gossip", name = "Gossip", help = "Send gossip on state change", 
+			editor = "bool", default = false, },
+		{ id = "GroupExclusive", name = "Exclusive for the group", help = "When set, removes any other game states from the same group", 
+			editor = "bool", default = false, },
+		{ id = "Color", name = "Color", help = "Used for easier visual identification of the game state in editors", 
+			editor = "color", default = 4278190080, },
+		{ id = "Icon", name = "Icon", 
+			editor = "ui_image", default = false, },
+		{ id = "AutoSet", name = "Auto set", help = "State is recalculated on every GameStateChange", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+		{ category = "Debug", id = "CurrentState", name = "Current state", 
+			editor = "bool", default = false, dont_save = true, },
+	},
+	HasSortKey = true,
+	GlobalMap = "GameStateDefs",
+	EditorMenubarName = "Game States",
+	EditorMenubar = "Editors.Lists",
+	EditorViewPresetPostfix = Untranslated("<select(AutoSet,'',' [autoset]')><select(CurrentState,'',' [on]')>"),
+}
+
+function GameStateDef:GetCurrentState()
+	return GameState[self.id]
+end
+
+function GameStateDef:SetCurrentState(state)
+	return ChangeGameState(self.id, state)
+end
+
+function GameStateDef:OnDataUpdated()
+	RebuildAutoSetGameStates()
+end
+
+----- GameStateDef PlayFX
+
+function OnMsg.GameStateChanged(changed)
+	local fx
+	for state, active in pairs(changed) do
+		local def = GameStateDefs[state]
+		if def and def.PlayFX then
+			fx = fx or {}
+			fx[#fx + 1] = state
+			fx[state] = active
+		end
+	end
+	if not fx then return end
+	table.sort(fx)
+	-- as certain FX depend on game states, delay the actual FX trigger to allow all of the game state changes to be invoked
+	CreateGameTimeThread(function(fx)
+		for _, state in ipairs(fx) do
+			if fx[state] then
+				PlayFX(state, "start")
+			else
+				PlayFX(state, "end")
+			end
+		end
+	end, fx)
+end
+
+function OnMsg.GatherFXActions(list)
+	ForEachPreset("GameStateDef", function(state, group, list)
+		if state.PlayFX then
+			list[#list + 1] = state.id
+		end
+	end, list)
+end
+
+----- GameStateDef GetGameStateFilter
+
+function GetGameStateFilter()
+	return ForEachPreset("GameStateDef", function(state, group, items)
+		if state.ShowInFilter then
+			items[#items + 1] = state.id
+		end
+	end, {})
+end
+
+----- GameStateDef MapState
+
+function OnMsg.DoneMap()
+	local map_states = ForEachPreset("GameStateDef", function(state, group, map_states, GameState)
+		if state.MapState and GameState[state.id] then
+			map_states[state.id] = false
+		end
+	end, {}, GameState)
+	ChangeGameState(map_states)
+end
+
+----- GameStateDef Persist
+
+function OnMsg.PersistSave(data)
+	local persisted_gamestate = {}
+	ForEachPreset("GameStateDef", function(state, group, persisted_gamestate, GameState)
+		if state.PersistInSaveGame and GameState[state.id] then
+			persisted_gamestate[state.id] = true
+		end
+	end, persisted_gamestate, GameState)
+	if next(persisted_gamestate) then
+		data.GameState = persisted_gamestate
+	end
+end
+
+function OnMsg.PersistLoad(data)
+	local persisted_gamestate = data.GameState or empty_table
+	ForEachPreset("GameStateDef", function(state, group, persisted_gamestate, GameState)
+		if state.PersistInSaveGame then
+			GameState[state.id] = persisted_gamestate[state.id] or false
+		end
+	end, persisted_gamestate, GameState)
+end
+
+DefineClass.LootDef = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Loot", id = "loot", name = "Loot", 
+			editor = "choice", default = "random", items = function (self) return {"random", "all", "first", "cycle", "each then last"} end, },
+		{ category = "Test", id = "TestDlcs", name = "Test dlcs", 
+			editor = "set", default = set(), dont_save = true, items = function (self) return DlcComboItems() end, },
+		{ category = "Test", id = "TestConditions", name = "Loot conditions", 
+			editor = "set", default = set(), dont_save = true, items = function (self) return table.keys2(LootCondition, true) end, },
+		{ category = "Test", id = "TestGameConditions", name = "Test Additional Conditions", help = "If not set the additional conditions are ignored during testing. \nIf set, the additional conditions are evaluated against the current state of the game. Therefore test results can change when the current game state changes.", 
+			editor = "bool", default = false, },
+		{ category = "Test", id = "TestFile", name = "Output CSV", 
+			editor = "text", default = "svnProject/items.csv", dont_save = true, buttons = { {name = "Write", func = "WriteChancesCSV"}, }, },
+		{ category = "Test", id = "TestResults", name = "Test results", 
+			editor = "text", default = false, dont_save = true, read_only = true, lines = 1, max_lines = 30, },
+	},
+	GlobalMap = "LootDefs",
+	ContainerClass = "LootDefEntry",
+	EditorMenubarName = "Loot Tables",
+	EditorShortcut = "Ctrl-L",
+	EditorIcon = "CommonAssets/UI/Icons/currency dollar finance money payment.png",
+	EditorView = Untranslated("<if(eq(loot,'all'))><color 255 128 64></if><id><color 0 128 0><opt(u(Comment),' - ','')>"),
+	EditorPreview = Untranslated("<Preview>"),
+	Documentation = "Creates a new loot definition that contains possible items to drop.",
+}
+
+DefineModItemPreset("LootDef", { EditorName = "Loot definition", EditorSubmenu = "Gameplay" })
+
+function LootDef:GenerateLootSeed(init_seed, looter, looted)
+	local loot, seed = self.loot
+	if loot == "cycle" or loot == "each then last" then
+		seed = (init_seed == -1) and InteractionRand(nil, "Loot", looter, looted) or (init_seed + 1)
+		seed = (loot == "each then last") and Min(seed, #self) or seed
+	else
+		seed = InteractionRand(nil, "Loot", looter, looted)
+	end
+	
+	return seed
+end
+
+function LootDef:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+	local rand, loot
+	seed = seed or self:GenerateLootSeed(nil, looter, looted)
+	NetUpdateHash("LootDef:GenerateLoot", seed)
+	
+	if self.loot == "random" then
+		local weight, none_weight = 0, 0
+		for _, entry in ipairs(self) do
+			if entry:TestConditions(looter, looted) then
+				if entry.class == "LootEntryNoLoot" then
+					none_weight = none_weight + entry.weight
+				else
+					weight = weight + entry.weight
+				end
+			end
+		end
+		rand, seed = BraidRandom(seed, weight + none_weight)
+		if rand >= weight then return end
+		for _, entry in ipairs(self) do
+			if entry.class ~= "LootEntryNoLoot" and entry:TestConditions(looter, looted) then
+				rand = rand - entry.weight
+				if rand < 0 then
+					loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+					break
+				end
+			end
+		end
+	elseif self.loot == "all" then
+		for _, entry in ipairs(self) do
+			rand, seed = BraidRandom(seed)
+			if entry:TestConditions(looter, looted) then
+				local entry_loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+				loot = loot or entry_loot
+			end
+		end
+	elseif self.loot == "first" then
+		for _, entry in ipairs(self) do
+			if entry:TestConditions(looter, looted) then
+				loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+				break
+			end
+		end
+	elseif self.loot == "cycle" then
+		local start_idx = 1 + seed % #self
+		local idx = start_idx
+		local entry = self[idx]
+		local entry_ok = entry:TestConditions(looter, looted)
+		while not entry_ok do
+			idx = (idx < #self) and (idx + 1) or 1
+			entry = self[idx]
+			entry_ok = (idx ~= start_idx) and entry:TestConditions(looter, looted)
+		end
+		if entry_ok then
+			loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+		end
+	else -- if self.loot == "each then last" then
+		if seed < #self then
+			for idx = seed, #self do
+				local entry = self[idx]
+				if entry:TestConditions(looter, looted) then
+					loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+					break
+				end
+			end
+		else
+			for idx = #self, 1, -1 do
+				local entry = self[idx]
+				if entry:TestConditions(looter, looted) then
+					loot = entry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+					break
+				end
+			end
+		end
+	end
+	Msg("GenerateLoot", self, items, loot)
+	return loot
+end
+
+function LootDef:ListChances(items, env, chance, amount_modifier)
+	if self.loot == "random" then
+		local weight = 0
+		for _, entry in ipairs(self) do
+			if entry:ListChancesTest(env) then
+				weight = weight + entry.weight
+			end
+		end
+		if weight <= 0 then return end
+		for _, entry in ipairs(self) do
+			if entry.class ~= "LootEntryNoLoot" and entry:ListChancesTest(env) then
+				entry:ListChances(items, env, chance * entry.weight / weight, amount_modifier)
+			end
+		end
+	elseif self.loot == "all" then
+		for _, entry in ipairs(self) do
+			if entry:ListChancesTest(env) then
+				entry:ListChances(items, env, chance, amount_modifier)
+			end
+		end
+	else -- self.loot == "first"
+		for _, entry in ipairs(self) do
+			if entry:ListChancesTest(env) then
+				return entry:ListChances(items, env, chance, amount_modifier)
+			end
+		end
+	end
+end
+
+function LootDef:SetTestDlcs(v)
+	LootTestDlcs=v
+end
+
+function LootDef:GetTestDlcs()
+	return LootTestDlcs
+end
+
+function LootDef:SetTestConditions(v)
+	LootTestConditions=v
+end
+
+function LootDef:GetTestConditions()
+	return LootTestConditions
+end
+
+function LootDef:SetTestFile(v)
+	LootTestFile=v
+end
+
+function LootDef:GetTestFile()
+	return LootTestFile
+end
+
+function LootDef:WriteChancesCSV(root)
+	local item_list = root:GetTestItems()
+	SaveCSV(LootTestFile, item_list, nil, {"Chance (%)", "Item"})
+end
+
+function LootDef:GetTestItems()
+	local env = {
+		dlcs = {[""] = true},
+		conditions = {[""] = true},	
+	}
+	for v in pairs(LootTestDlcs) do
+		env.dlcs[v] = true
+	end
+	for v in pairs(LootTestConditions) do
+		env.conditions[v] = true
+	end
+	env.game_conditions = self.TestGameConditions
+	
+	local items = {}
+	self:ListChances(items, env, 1.0)
+	local item_list = {}
+	for item, chance in pairs(items) do
+		if chance > 0.000000001 then
+			item_list[#item_list + 1] = { chance, item }
+		end
+	end
+	table.sort(item_list,function(a,b)
+		if a[1] == b[1] then 
+			return a[2] < b[2]
+		end
+		return a[1]>b[1]
+	 end)
+	return item_list
+end
+
+function LootDef:GetTestResults()
+	local item_list = self:GetTestItems()
+	local nothing = 1.0
+	for i, pair in ipairs(item_list) do
+		item_list[i] = string.format("%6.02f%%      %s", pair[1] * 100, pair[2])
+		nothing = nothing - pair[1]
+	end
+	if nothing > 0.0001 then
+		item_list[#item_list + 1] = string.format("%6.02f%%      Nothing", nothing * 100)
+	end
+	return table.concat(item_list, "\n")
+end
+
+function LootDef:GetPreview()
+	local texts = {}
+	for _, entry in ipairs(self) do
+		texts[#texts+1] =   entry:GetEditorPreview()
+	end
+	return table.concat(texts, "; ")
+end
+
+----- LootDef 
+
+LootTestDlcs = {}
+LootTestConditions = {}
+LootTestFile = "svnProject/items.csv"
+
+----- LootDef mod item
+
+if config.Mods then
+	AppendClass.ModItemLootDef = {
+		properties = {
+			{ id = "TestDlcs", },
+			{ id = "TestConditions", },
+			{ id = "TestGameConditions", },
+			{ id = "TestFile", },
+			{ id = "TestResults", },
+		},
+	}
+	
+	DefineClass.ModItemLootDefEdit = {
+		__parents = { "ModItemChangePropBase" },
+		properties = {
+			{ id = "TargetClass" },
+			{ id = "TargetProp" },
+			{ id = "EditType" },
+			{ id = "TargetFunc" },
+			{ category = "Mod", id = "TargetId", name = "Loot table", default = "", editor = "choice", items = function(self, prop_meta) return PresetsCombo(self.TargetClass)(self, prop_meta) end, no_edit = function(self) return not self:ResolveTargetMap() end, reapply = true },
+			{ category = "Change Property", id = "TargetValue", name = "Entries to append", default = false, editor = "bool", },
+		},
+		TargetClass = "LootDef",
+		TargetProp = "__children",
+		EditType = "Append To Table",
+
+		EditorName = "Loot definition change",
+		EditorSubmenu = "Gameplay",
+		Documentation = "Appends entries to a specific Loot definition. The Test button will apply the change.",
+	}
+
+	function ModItemLootDefEdit:GetModItemDescription()
+		if self.name == "" and self.TargetId ~= "" then
+			return Untranslated("<u(TargetId)>[...]")
+		end
+		return self.ModItemDescription
+	end
+
+	function ModItemLootDefEdit:ResolvePropTarget()
+		return {
+			id = "__children",
+			editor = "nested_list",
+			base_class = LootDef.ContainerClass,
+			default = false,
+		}
+	end
+
+	function ModItemLootDefEdit:GetPropValue()
+		local preset = self:ResolveTargetPreset()
+		local result = {}
+		for i,child in ipairs(preset) do
+			result[#result + 1] = child:Clone()
+		end	
+		return result
+	end
+
+	function ModItemLootDefEdit:AssignValue(preset, value)
+		table.iclear(preset)
+		table.iappend(preset, value)
+		ModLogF("%s %s: %s[...] = %s", self.class, self.mod.title, self.TargetId, ValueToStr(value))
+	end
+end
+
+DefineClass.LootDefEntry = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "Conditions", id = "disable", name = "Disable", 
+			editor = "bool", default = false, },
+		{ category = "Conditions", id = "comment", name = "Comment", 
+			editor = "text", default = false, },
+		{ category = "Conditions", id = "weight", name = "Weight", 
+			editor = "number", default = 1000, scale = 1000, min = 0, max = 1000000000, },
+		{ category = "Conditions", id = "dlc", name = "Require dlc", 
+			editor = "choice", default = "", items = function (self) return DlcComboItems() end, },
+		{ category = "Conditions", id = "negate", name = "Negate loot condition", 
+			editor = "bool", default = false, },
+		{ category = "Conditions", id = "condition", name = "Loot condition", help = "Loot specific conditions (defined in LootConditions) such as game difficulty. These can be manipulated in Test section to simulate expected loot results.", 
+			editor = "choice", default = "", items = function (self) return table.keys2(LootCondition, true) end, },
+		{ category = "Conditions", id = "game_conditions", name = "Additional conditions", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+	},
+	StoreAsTable = true,
+	EditorView = Untranslated("<if(disable)>*** </if><FormatAsFloat(weight,1000)><tab 50><dlc><tab 170><if(negate)>!</if><condition><tab 300><EntryView><color 0 128 0><opt(u(comment),'<tab 600>','')>"),
+	EntryView = Untranslated("<class>"),
+	EditorName = "Loot Entry",
+}
+
+function LootDefEntry:GetEditorPreview()
+	local text =(T{self.EntryView, self})
+	local txt
+	if self.weight~=1000 then
+		txt =(txt or "(")..Untranslated("w:"..self.weight)
+	end
+	if self.dlc~="" then
+		txt =(txt or "(")..Untranslated(" d:"..self.dlc)
+	end
+	
+	local condition_texts = {}
+	if self.condition~="" then
+		condition_texts[#condition_texts+1] = Untranslated((self.negate and " !" or " ") .. self.condition)
+	end			
+	for _, condition in ipairs(self.game_conditions) do
+		condition_texts[#condition_texts+1] = Untranslated(_InternalTranslate(condition:GetEditorView(), condition, false))
+	end
+	if next(condition_texts) then
+		txt = (txt or "(") ..table.concat(condition_texts, ";")
+	end
+	if txt then
+		text = text..txt..Untranslated(")")
+	end
+	return text
+end
+
+function LootDefEntry:TestConditions(looter, looted)
+	if self.disable then return end
+	if not IsDlcAvailable(self.dlc) then
+		return false
+	end
+	local res = LootCondition[self.condition](looter, looted)
+	if self.negate then
+		res = not res
+	end
+	res = res and EvalConditionList(self.game_conditions, looter, looted)
+	return res
+end
+
+function LootDefEntry:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+	assert(false, self.class .. ":GenerateLoot() not implemented")
+end
+
+function LootDefEntry:ListChancesTest(env)
+	if self.disable or not env.dlcs[self.dlc] then
+		return
+	end
+	local res = env.conditions[self.condition]
+	if self.negate then
+		res = not res
+	end
+	if env.game_conditions then
+		res = res and EvalConditionList(self.game_conditions)
+	end
+	return res
+end
+
+function LootDefEntry:ListChances(items, env, chance, amount_modifier)
+	assert(false, self.class .. ":ListChances() not implemented")
+end
+
+----- LootDefEntry LootCondition
+
+LootCondition = rawget(_G, "LootCondition") or {
+	[""] = function(looter, looted) return true end,
+}
+setmetatable(LootCondition, {
+	__index = function() return empty_func end,
+})
+
+DefineClass.LootEntryLootDef = {
+	__parents = { "LootDefEntry", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "Loot", id = "loot_def", name = "Loot def", 
+			editor = "preset_id", default = false, preset_class = "LootDef", },
+		{ category = "Loot", id = "amount_modifier", name = "Amount modifier", help = "Modifies the amount of resources generated from the loot", 
+			editor = "number", default = 1000000, scale = 1000000, step = 100000, min = 1000, max = 1000000000, },
+	},
+	EntryView = Untranslated("<loot_def> <if(not_eq(amount_modifier,1000000))>x<FormatAsFloat(amount_modifier,1000000,3,true)></if>"),
+	EditorName = "Invoke Loot Definition",
+}
+
+function LootEntryLootDef:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+	local loot_def = LootDefs[self.loot_def]
+	if not loot_def then return end
+	return loot_def:GenerateLoot(looter, looted, seed, items, modifiers, MulDivRound(amount_modifier or 1000000, self.amount_modifier, 1000000))
+end
+
+function LootEntryLootDef:ListChances(items, env, chance, amount_modifier)
+	local loot_def = LootDefs[self.loot_def]
+	if not loot_def then return end
+	local nesting = env.nesting or 0
+	if nesting > 100 then 
+		local item = "LootDef: " .. self.loot_def
+		items[item] = (items[item] or 0.0) + chance
+		return
+	end
+	env.nesting = nesting + 1 
+	loot_def:ListChances(items, env, chance, MulDivRound(amount_modifier or 1000000, self.amount_modifier, 1000000))
+	assert(env.nesting == nesting + 1)
+	env.nesting = nesting
+end
+
+function LootEntryLootDef:GetError()
+	local loot_def = GetParentTableOfKindNoCheck(self, "LootDef")
+	if loot_def and self.loot_def == loot_def.id then
+		return "Recursive LootDef!"
+	end
+end
+
+DefineClass.LootEntryNoLoot = {
+	__parents = { "LootDefEntry", },
+	__generated_by_class = "ClassDef",
+
+	EntryView = Untranslated("<color 192 0 0 >No loot"),
+	EditorName = "No Loot",
+}
+
+function LootEntryNoLoot:ListChances(items, env, chance, amount_modifier)
+	
+end
+
+function LootEntryNoLoot:GenerateLoot(looter, looted, seed, items, modifiers, amount_modifier)
+	
+end
+
+DefineClass.NoisePreset = {
+	__parents = { "Preset", "PerlinNoise", },
+	__generated_by_class = "PresetDef",
+
+	GlobalMap = "NoisePresets",
+	PresetClass = "NoisePreset",
+	EditorMenubarName = "Noise Editor",
+	EditorIcon = "CommonAssets/UI/Icons/bell message new notification sign.png",
+	EditorMenubar = "Map",
+}
+
+DefineClass.ObjMaterial = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "invulnerable", name = "Invulnerable", 
+			editor = "bool", default = false, },
+		{ id = "impenetrable", name = "Impenetrable", 
+			editor = "bool", default = false, },
+		{ id = "is_prop", name = "Prop Material", 
+			editor = "bool", default = false, },
+		{ id = "max_hp", name = "Max HP", 
+			editor = "number", default = 100, },
+		{ id = "breakdown_defense", name = "Breakdown Defense", help = "If the material is attached to a door, this defense is added to the break difficulty.", 
+			editor = "number", default = 30, },
+		{ id = "destruction_propagation_strength", name = "Destruction Propagation Strength", help = "If the material is attached to a door, this defense is added to the break difficulty.", 
+			editor = "number", default = 0, },
+		{ id = "FXTarget", name = "FX Target", 
+			editor = "text", default = false, },
+		{ id = "noise_on_hit", name = "Noise On Hit", 
+			editor = "number", default = 0, min = 0, },
+		{ id = "noise_on_break", name = "Noise On Break", 
+			editor = "number", default = 0, min = 0, },
+	},
+	GlobalMap = "ObjMaterials",
+	EditorMenubarName = "ObjMaterial Editor",
+	FilterClass = "ObjMaterialFilter",
+}
+
+DefineClass.ObjMaterialFilter = {
+	__parents = { "GedFilter", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "invulnerable", name = "Invulnerable", 
+			editor = "set", default = false, max_items_in_set = 1, items = function (self) return { "true", "false" } end, },
+		{ id = "impenetrable", name = "Impenetrable", 
+			editor = "set", default = false, max_items_in_set = 1, items = function (self) return { "true", "false" } end, },
+		{ id = "is_prop", name = "Prop Material", 
+			editor = "set", default = false, max_items_in_set = 1, items = function (self) return { "true", "false" } end, },
+	},
+}
+
+function ObjMaterialFilter:FilterObject(obj)
+	local function filter(prop)
+		local filter, value = self[prop], obj[prop]
+		return filter and (filter["true"] and not value or filter["false"] and value)
+	end
+	return not (filter("invulnerable") or filter("impenetrable") or filter("is_prop"))
+end
+
+DefineClass.PhotoFilterPreset = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "display_name", name = "Display Name", 
+			editor = "text", default = false, translate = true, },
+		{ category = "General", id = "description", name = "Description", 
+			editor = "text", default = false, translate = true, },
+		{ category = "General", id = "shader_file", name = "Shader Filename", 
+			editor = "browse", default = "", folder = "Shaders/", filter = "FX files|*.fx", },
+		{ category = "General", id = "shader_pass", name = "Shader Pass", 
+			editor = "text", default = "Generic", },
+		{ category = "General", id = "texture1", name = "Texture 1", 
+			editor = "browse", default = "", filter = "Image files|*.tga", },
+		{ category = "General", id = "texture2", name = "Texture 2", 
+			editor = "browse", default = "", filter = "Image files|*.tga", },
+		{ category = "General", id = "activate", name = "Run on activation", 
+			editor = "func", default = function (self)  end, },
+		{ category = "General", id = "deactivate", name = "Run on deactivation", 
+			editor = "func", default = function (self)  end, },
+	},
+	HasSortKey = true,
+	GlobalMap = "PhotoFilterPresetMap",
+	EditorMenubarName = "Photo Filters",
+	EditorIcon = "CommonAssets/UI/Icons/camera digital image media photo photography picture.png",
+	EditorMenubar = "Editors.Other",
+}
+
+function PhotoFilterPreset:GetShaderDescriptor()
+	return {
+		shader = self.shader_file,
+		pass = self.shader_pass,
+		tex1 = self.texture1,
+		tex2 = self.texture2,
+		activate = self.activate,
+		deactivate = self.deactivate,
+	}
+end
+
+DefineClass.PhotoFramePreset = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "display_name", name = "Display Name", 
+			editor = "text", default = false, translate = true, },
+		{ id = "frame_file", name = "Frame Filename", 
+			editor = "ui_image", default = false, filter = "Image files|*.png;*.dds", force_extension = "", },
+		{ category = "General", id = "translate", name = "Translate", 
+			editor = "bool", default = true, },
+	},
+	HasSortKey = true,
+	GlobalMap = "PhotoFramePresetMap",
+	EditorMenubarName = "Photo Frames",
+	EditorIcon = "CommonAssets/UI/Icons/camera digital image media photo photography picture.png",
+	EditorMenubar = "Editors.Other",
+	Documentation = "Allows adding new frames for the photo mode.",
+}
+
+DefineModItemPreset("PhotoFramePreset", { EditorName = "Photo Mode - frame", EditorSubmenu = "Other" })
+
+function PhotoFramePreset:GetName()
+	if self.translate then
+		return self.display_name
+	else
+		return Untranslated(self.display_name)
+	end
+end
+
+DefineClass.RadioStationPreset = {
+	__parents = { "DisplayPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "Folder", name = "Folder", 
+			editor = "browse", default = "Music", folder = "Music", filter = "folder", },
+		{ category = "General", id = "SilenceDuration", name = "Silence between tracks", 
+			editor = "number", default = 1000, scale = "sec", },
+		{ category = "General", id = "Volume", name = "Volume", help = "Volume to play at each new track", 
+			editor = "number", default = false, },
+		{ category = "General", id = "FadeOutTime", name = "Fade Out Time", help = "Time to fade out to a new volume", 
+			editor = "number", default = false, 
+			no_edit = function(self) return not self.Volume end, scale = "sec", },
+		{ category = "General", id = "FadeOutVolume", name = "FadeOutVolume", help = "Volume to fade out to after the fade out time", 
+			editor = "number", default = false, 
+			no_edit = function(self) return not self.FadeOutTime end, },
+		{ category = "General", id = "Mode", name = "Mode", help = 'Tracks play randomly by default but if "list" mode is set they play one after another', 
+			editor = "choice", default = false, items = function (self) return {"list"} end, },
+	},
+	HasSortKey = true,
+	GlobalMap = "RadioStationPresets",
+	EditorMenubarName = "Radio Stations",
+	EditorIcon = "CommonAssets/UI/Icons/notes.png",
+	EditorMenubar = "Editors.Audio",
+	EditorCustomActions = {
+	{
+		FuncName = "TestPlay",
+		Icon = "CommonAssets/UI/Ged/play",
+		Name = "Play",
+		Toolbar = "main",
+	},
+},
+	Documentation = "Adds a custom radio station, allowing to select folders with tracks to be implemented in the game instead of the soundtrack.",
+}
+
+DefineModItemPreset("RadioStationPreset", { EditorName = "Radio station", EditorSubmenu = "Other" })
+
+function RadioStationPreset:TestPlay()
+	StartRadioStation(self.id)
+end
+
+function RadioStationPreset:Play()
+	local playlist = self:GetPlaylist()
+	Playlists.Radio = playlist
+	if not Music or Music.Playlist == "Radio" then
+		SetMusicPlaylist("Radio", true, "force")
+	end
+end
+
+function RadioStationPreset:GetPlaylist()
+	local playlist = PlaylistCreate(self.Folder)
+	playlist.SilenceDuration = self.SilenceDuration
+	playlist.Volume = self.Volume
+	playlist.FadeOutTime = self.FadeOutTime
+	playlist.FadeOutVolume = self.FadeOutVolume
+	
+	return playlist
+end
+
+----- RadioStationPreset 
+
+if FirstLoad then
+	ActiveRadioStation = false
+	ActiveRadioStationThread = false
+	ActiveRadioStationStart = RealTime()
+end
+
+function StartRadioStation(station_id, delay, force)
+	local station = RadioStationPresets[station_id or false] or RadioStationPresets[GetDefaultRadioStation() or false]
+	station_id = station and station.id or false
+	if force or (ActiveRadioStation ~= station_id and mapdata and mapdata.GameLogic) then
+		DbgMusicPrint(string.format("Start radio '%s' with %d delay%s", station_id, delay or 0, force and "[forced]" or ""))
+		if ActiveRadioStation and config.Radio then
+			local session_duration = (RealTime() - ActiveRadioStationStart) / 1000
+			Msg("RadioStationSession", ActiveRadioStation, session_duration)
+			NetGossip("RadioStationSession", ActiveRadioStation, session_duration)
+		end
+		ActiveRadioStation = station_id
+		ActiveRadioStationStart = RealTime()
+		DeleteThread(ActiveRadioStationThread)
+		ActiveRadioStationThread = CreateRealTimeThread(function(station)
+			Sleep(delay or 0)
+			if station then station:Play() end
+			ActiveRadioStationThread = false
+		end, station)
+		Msg("RadioStationPlay", station_id, station)
+	end
+end
+
+function OnMsg.QuitGame()
+	if config.Radio then
+		StartRadioStation(false)
+	end
+end
+
+function OnMsg.LoadGame()
+	if config.Radio then
+		StartRadioStation(GetAccountStorageOptionValue("RadioStation"))
+	end
+end
+
+function OnMsg.NewMapLoaded()
+	if config.Radio then
+		StartRadioStation(GetAccountStorageOptionValue("RadioStation"))
+	end
+end
+
+function GetDefaultRadioStation()
+	return const.MusicDefaultRadioStation or ""
+end
+
+----- RadioStationPreset mod item
+
+if rawget(_G, "ModItemRadioStationPreset") then
+	local properties = ModItemRadioStationPreset.properties
+	if not properties then
+		local properties = {}
+		ModItemRadioStationPreset.properties = properties
+	end
+	
+	local org_prop = table.find_value(RadioStationPreset.properties, "id", "Folder")
+	local prop = table.copy(org_prop, "deep")
+	prop.default = "RadioStations"
+	table.insert(properties, prop)
+	
+	local oldOnEditorNew = ModItemRadioStationPreset.OnEditorNew or empty_func
+	function ModItemRadioStationPreset.OnEditorNew(self, ...)
+		local radio_stations_path = self.mod.content_path .. "RadioStations/"
+		local radio_stations_os_path, err = ConvertToOSPath(radio_stations_path)
+		assert(not err)
+		AsyncCreatePath(radio_stations_os_path)
+		self:SetProperty("Folder", radio_stations_os_path)
+		return oldOnEditorNew(self, ...)
+	end
+end
+
+DefineClass.RoofTypes = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ id = "display_name", name = "Display Name", 
+			editor = "text", default = false, translate = true, },
+		{ id = "default_inclination", name = "Default Inclination", 
+			editor = "number", default = 1200, scale = "deg", slider = true, min = 0, max = 2700, },
+	},
+}
+
+DefineClass.RoomDecalData = {
+	__parents = { "ListPreset", },
+	__generated_by_class = "PresetDef",
+
+}
+
+DefineClass.TODOPreset = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	TODOItems = {
+	"Implement",
+	"Review",
+	"Test",
+},
+	EditorMenubarName = false,
+}
+
+DefineClass.TagsProperty = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "General", id = "tags", name = "Tags", 
+			editor = "set", default = false, buttons = { {name = "Edit", func = "OpenTagsEditor"}, }, items = function (self) return PresetsCombo(self.TagsListItem, "Default") end, },
+	},
+	TagsListItem = "CommonTags",
+}
+
+function TagsProperty:HasTag(tag)
+	return (self.tags or empty_table)[tag] and true or false
+end
+
+function TagsProperty:OpenTagsEditor()
+	g_Classes[self.TagsListItem]:OpenEditor()
+end
+
+DefineClass.TerrainGrass = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "Classes", 
+			editor = "string_list", default = {}, item_default = "", items = function (self) return ClassDescendantsCombo("Grass") end, },
+		{ id = "SizeFrom", name = "Size From", 
+			editor = "number", default = 100, min = 50, max = 200, },
+		{ id = "SizeTo", name = "Size To", 
+			editor = "number", default = 100, min = 50, max = 200, },
+		{ id = "Weight", name = "Weight", help = "For a weighted random selection between multiple grass definitions", 
+			editor = "number", default = 100, slider = true, min = 0, max = 100, },
+		{ id = "NoiseWeight", name = "Noise Strength", help = "Weight of a random spatial noise modification to density", 
+			editor = "number", default = 0, scale = 10, slider = true, min = -1000, max = 1000, },
+		{ id = "TiltWithTerrain", name = "TiltWithTerrain", help = "Orient with terrain normal", 
+			editor = "bool", default = false, },
+		{ id = "PlaceOnWater", name = "PlaceOnWater", help = "Place on water surface", 
+			editor = "bool", default = false, },
+		{ id = "ColorVarFrom", name = "Color Variation From", 
+			editor = "color", default = 4284769380, },
+		{ id = "ColorVarTo", name = "Color Variation To", 
+			editor = "color", default = 4284769380, },
+	},
+}
+
+function TerrainGrass:GetEditorView()
+	local classes = self:GetClassList() or {""}
+	table.replace(classes, "", "No Grass")
+	return table.concat(classes, ", ") .. " (" .. self.Weight .. ")"
+end
+
+function TerrainGrass:GetClassList()
+	local classes = table.keys(table.invert(self.Classes or empty_table), true)
+	return #classes > 0 and classes
+end
+
+DefineClass.TerrainProps = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "TerrainName", name = "Terrain Name", 
+			editor = "choice", default = false, items = function (self) return GetTerrainNamesCombo() end, },
+		{ id = "TerrainIndex", name = "Terrain Index", 
+			editor = "number", default = false, dont_save = true, read_only = true, },
+		{ id = "TerrainPreview", name = "Terrain Preview", 
+			editor = "image", default = false, dont_save = true, read_only = true, img_size = 100, img_box = 1, base_color_map = true, },
+	},
+}
+
+function TerrainProps:GetTerrainPreview()
+	return GetTerrainTexturePreview(self.TerrainName)
+end
+
+function TerrainProps:GetTerrainIndex()
+	return GetTerrainTextureIndex(self.TerrainName)
+end
+
+DefineClass.TestCombatFilter = {
+	__parents = { "GedFilter", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "ShowInCheats", name = "Shown In Cheats", help = "Filters depending if shown in cheats or not", 
+			editor = "choice", default = "", items = function (self) return {"", "true", "false"} end, },
+	},
+}
+
+function TestCombatFilter:FilterObject(obj)
+	if self.ShowInCheats ~= "" and obj.show_in_cheats ~= (self.ShowInCheats == "true") then
+		return false
+	end
+	
+	return true
+end
+
+DefineClass.TextStyle = {
+	__parents = { "Preset", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "Text", id = "TextFont", name = "Font", 
+			editor = "text", default = T(202962508484, --[[PresetDef TextStyle default]] "droid, 12"), translate = true, },
+		{ category = "Text", id = "TextColor", name = "Color", 
+			editor = "color", default = 4280295456, },
+		{ category = "Text", id = "RolloverTextColor", name = "Rollover color", 
+			editor = "color", default = 4278190080, },
+		{ category = "Text", id = "DisabledTextColor", name = "Disabled color", 
+			editor = "color", default = 2149589024, },
+		{ category = "Text", id = "DisabledRolloverTextColor", name = "Disabled rollover color", 
+			editor = "color", default = 2147483648, },
+		{ category = "Text", id = "ShadowType", name = "Shadow type", 
+			editor = "choice", default = "shadow", items = function (self) return {"shadow", "extrude", "outline", "glow"} end, },
+		{ category = "Text", id = "ShadowSize", name = "Shadow size", 
+			editor = "number", default = 0, },
+		{ category = "Text", id = "ShadowColor", name = "Shadow color", 
+			editor = "color", default = 805306368, },
+		{ category = "Text", id = "ShadowDir", name = "Shadow dir", 
+			editor = "point", default = point(1, 1), },
+		{ id = "DarkMode", 
+			editor = "preset_id", default = false, preset_class = "TextStyle", },
+		{ category = "Text", id = "DisabledShadowColor", name = "Disabled shadow color", 
+			editor = "color", default = 805306368, },
+	},
+	HasSortKey = true,
+	GlobalMap = "TextStyles",
+	EditorMenubarName = "Text styles",
+	EditorShortcut = "Ctrl-Alt-T",
+	EditorIcon = "CommonAssets/UI/Icons/detail list view.png",
+	EditorMenubar = "Editors.UI",
+	EditorPreview = Untranslated("<Preview>"),
+	Documentation = "Adds a new text style that can be used by XFontControl and other classes in XTemplate presets.",
+}
+
+DefineModItemPreset("TextStyle", { EditorName = "Text style", EditorSubmenu = "Other" })
+
+function TextStyle:GetFontIdHeightBaseline(scale)
+	local cache = TextStyleCache[self.id]
+	if not cache then
+		cache = {}
+		TextStyleCache[self.id] = cache
+	end
+	
+	scale = scale or 1000
+	if cache[scale] then
+		return unpack_params(cache[scale])
+	end
+	
+	local font = _InternalTranslate(self.TextFont) or _InternalTranslate(TextStyle.TextFont)
+	font = font:gsub("%d+", function(size) 
+		return Max(MulDivRound(tonumber(size) or 1, scale, 1000), 1)
+	end)
+	
+	font = GetProjectConvertedFont(font)
+	
+	-- Mods can replace fonts with other fonts
+	if g_FontReplaceMap then
+		local font_name = string.match(font, "([^,]+),")
+		if font_name then
+			if g_FontReplaceMap[font_name] then
+				font_name = g_FontReplaceMap[font_name]
+				-- Replace the font name only, leave the size and style
+				font = font:gsub("[^,]+,", font_name .. ",")
+			else
+				-- Match the font if the used name is part of the actual full name
+				for replace, with in pairs(g_FontReplaceMap) do
+					if string.find(replace, font_name) then
+						font_name = g_FontReplaceMap[replace]
+						-- Replace the font name only, leave the size and style
+						font = font:gsub("[^,]+,", font_name .. ",")
+						break
+					end
+				end
+			end
+		end
+	end
+	
+	local id = UIL.GetFontID(font)
+	if not id or id < 0 then
+		print("once", "[WARNING] Invalid font", font, "in text style", self.id)
+		return -1, 0, 0
+	end
+	local _, height = UIL.MeasureText("AQj", id)
+	local baseline = height * 8 / 10 -- there is currently no way to get the font's baseline
+	cache[scale] = { id, height, baseline }
+	return id, height, baseline
+end
+
+function TextStyle:GetPreview()
+	return string.format("<style %s><%s></style>", self.id, _InternalTranslate(self.TextFont, nil, not "check"))
+end
+
+----- TextStyle globals
+
+TextStyleCache = {}
+
+function ClearTextStyleCache() TextStyleCache = {} end
+OnMsg.EngineOptionsSaved = ClearTextStyleCache
+OnMsg.ClassesBuilt = ClearTextStyleCache
+OnMsg.DataLoaded = ClearTextStyleCache
+OnMsg.DataReload = ClearTextStyleCache
+
+function LoadTextStyles()
+	local old_text_styles = Presets.TextStyle
+	Presets.TextStyle = {}
+	TextStyles = {}
+	LoadPresets("CommonLua/Data/TextStyle.lua")
+	ForEachLib("Data/TextStyle.lua", function(lib, path) LoadPresets(path) end)
+	LoadPresets("Data/TextStyle.lua")
+	for _, dlc_folder in ipairs(DlcFolders or empty_table) do
+		LoadPresets(dlc_folder .. "/Presets/TextStyle.lua")
+	end
+	TextStyle:SortPresets()
+	for _, group in ipairs(Presets.TextStyle) do
+		for _, preset in ipairs(group) do
+			preset:PostLoad()
+		end
+	end
+	if Platform.developer and not Platform.ged then
+		LoadCollapsedPresetGroups()
+	end
+	GedRebindRoot(old_text_styles, Presets.TextStyle)
+end
+
+if FirstLoad or ReloadForDlc then
+	OnMsg.ClassesBuilt = LoadTextStyles
+	OnMsg.DataLoaded = LoadTextStyles
+end
+
+DefineClass.WangNoisePreset = {
+	__parents = { "NoisePreset", "WangPerlinNoise", },
+	__generated_by_class = "PresetDef",
+
+	EditorMenubarName = "Noise Editor",
+}
+

CommonLua/Classes/ClassDefs/ClassDef-StoryBits.generated.lua

@@ -0,0 +1,367 @@
+-- ========== GENERATED BY ClassDef Editor (Ctrl-Alt-F3) DO NOT EDIT MANUALLY! ==========
+
+DefineClass.StoryBit = {
+	__parents = { "PresetWithQA", },
+	__generated_by_class = "PresetDef",
+
+	properties = {
+		{ category = "General", id = "ScriptDone", name = "Script done", 
+			editor = "bool", default = false, no_edit = function(self) return IsKindOf(self, "ModItem") end, },
+		{ category = "General", id = "TextReadyForValidation", name = "Text ready for validation", 
+			editor = "bool", default = false, no_edit = function(self) return IsKindOf(self, "ModItem") end, },
+		{ category = "General", id = "TextsDone", name = "Texts done", 
+			editor = "bool", default = false, no_edit = function(self) return IsKindOf(self, "ModItem") end, },
+		{ category = "Activation", id = "Category", 
+			editor = "preset_id", default = "FollowUp", preset_class = "StoryBitCategory", extra_item = "FollowUp", },
+		{ category = "Activation", id = "Trigger", 
+			editor = "choice", default = "StoryBitTick", 
+			read_only = function(self) return self.Category ~= "FollowUp" end, items = function (self) return StoryBitTriggersCombo end, },
+		{ category = "Activation", id = "Enabled", 
+			editor = "bool", default = false, 
+			read_only = function(self) return self.Category == "FollowUp" end, },
+		{ category = "Activation", id = "EnableChance", name = "Enable Chance", help = "Chance to be enabled in a specific playthrough (use sparingly for story bits that occur too often)", 
+			editor = "number", default = 100, 
+			no_edit = function(self) return not self.Enabled end, scale = "%", },
+		{ category = "Activation", id = "InheritsObject", name = "Inherits object", help = "Associate with the object of the story bit that enabled this one", 
+			editor = "bool", default = true, 
+			no_edit = function(self) return self.Enabled end, },
+		{ category = "Activation", id = "OneTime", name = "One-time", 
+			editor = "bool", default = true, 
+			read_only = function(self) return self.Category == "FollowUp" end, },
+		{ category = "Activation", id = "ExpirationTime", name = "Expiration time", 
+			editor = "number", default = false, scale = "h", },
+		{ category = "Activation", id = "ExpirationModifier", name = "Expiration modifier", 
+			editor = "expression", default = function (self, context, obj) return 100 end, params = "self, context, obj", },
+		{ category = "Activation", id = "SuppressTime", name = "Suppress for", help = "This StoryBit can't trigger for this period after it was enabled", 
+			editor = "number", default = 0, scale = "h", },
+		{ category = "Activation", id = "Sets", name = "Sets", help = "Sets this story bit belongs to. These sets can be disabled by game-specific logic.", 
+			editor = "set", default = false, items = function (self) return PresetsCombo("CooldownDef", "StoryBits") end, },
+		{ category = "Activation", id = "Prerequisites", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+		{ category = "Activation Effects", id = "Disables", help = "List of StoryBits to disable", 
+			editor = "preset_id_list", default = {}, preset_class = "StoryBit", item_default = "", },
+		{ category = "Activation Effects", id = "Delay", help = "This StoryBit waits this long after triggering before it gets activated and displayed", 
+			editor = "number", default = 0, scale = "h", },
+		{ category = "Activation Effects", id = "DetachObj", name = "Detach object", help = "Detach the story bit related object on delay.", 
+			editor = "bool", default = false, },
+		{ category = "Activation Effects", id = "ActivationEffects", name = "Activation Effects", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+		{ category = "Notification", id = "HasNotification", name = "Has notification", 
+			editor = "bool", default = true, },
+		{ category = "Notification", id = "NotificationPriority", name = "Notification priority", 
+			editor = "choice", default = "StoryBit", 
+			no_edit = function(self) return not self.HasNotification end, items = function (self) return GetGameNotificationPriorities() end, },
+		{ category = "Notification", id = "NotificationTitle", name = "Notification Title", help = "Leave empty to use the popup title", 
+			editor = "text", default = "", 
+			no_edit = function(self) return not self.HasNotification end, translate = true, lines = 1, },
+		{ category = "Notification", id = "NotificationText", name = "Notification Text", help = "Leave empty to use the popup title", 
+			editor = "text", default = "", 
+			no_edit = function(self) return not self.HasNotification end, translate = true, lines = 1, },
+		{ category = "Notification", id = "NotificationRolloverTitle", name = "Notification rollover title", 
+			editor = "text", default = "", 
+			no_edit = function(self) return not self.HasNotification end, translate = true, lines = 1, },
+		{ category = "Notification", id = "NotificationRolloverText", name = "Notification rollover text", 
+			editor = "text", default = "", 
+			no_edit = function(self) return not self.HasNotification end, translate = true, lines = 1, max_lines = 6, },
+		{ category = "Notification", id = "NotificationAction", name = "Notification action", 
+			editor = "choice", default = "complete", 
+			no_edit = function(self) return not self.HasNotification end, items = function (self) return {"complete", "select object", "callback", "nothing"} end, },
+		{ category = "Notification", id = "NotificationCallbackFunc", name = "Notification click callback", 
+			editor = "func", default = function (self, state)
+return true
+end, no_edit = function(self) return self.NotificationAction ~= "callback" end, params = "self, state", },
+		{ category = "Notification", id = "NotificationExpirationBar", name = "Display expiration bar", 
+			editor = "bool", default = false, 
+			no_edit = function(self) return not self.HasNotification end, },
+		{ category = "Notification", id = "NotificationCanDismiss", name = "Can dismiss", 
+			editor = "bool", default = true, 
+			no_edit = function(self) return not self.HasNotification or self.HasPopup end, },
+		{ category = "Popup", id = "HasPopup", name = "Has popup", 
+			editor = "bool", default = true, },
+		{ category = "Notification", id = "FxAction", name = "FX Action", help = "This is used for calling the FX system with given action. Leave it empty to have default notification FX actions.", 
+			editor = "text", default = "", },
+		{ category = "Popup", id = "Actor", 
+			editor = "combo", default = "narrator", 
+			no_edit = function(self) return not self.HasPopup end, items = function (self) return VoiceActors end, },
+		{ category = "Popup", id = "Title", 
+			editor = "text", default = false, 
+			no_edit = function(self) return not self.HasPopup end, translate = true, lines = 1, },
+		{ category = "Popup", id = "VoicedText", name = "Voiced Text", 
+			editor = "text", default = false, 
+			no_edit = function(self) return not self.HasPopup end, translate = true, lines = 1, max_lines = 256, context = VoicedContextFromField("Actor"), },
+		{ category = "Popup", id = "Text", 
+			editor = "text", default = false, 
+			no_edit = function(self) return not self.HasPopup end, translate = true, lines = 4, max_lines = 256, },
+		{ category = "Popup", id = "Image", 
+			editor = "ui_image", default = "", 
+			no_edit = function(self) return not self.HasPopup end, image_preview_size = 200, },
+		{ category = "Popup", id = "UseObjectImage", name = "Use object image", help = "Extract a popup image from the context object", 
+			editor = "bool", default = false, 
+			no_edit = function(self) return not self.HasPopup end, },
+		{ category = "Popup", id = "SelectObject", name = "Select Object", help = "Select the object when opening the popup", 
+			editor = "bool", default = true, 
+			no_edit = function(self) return not self.HasPopup end, },
+		{ category = "Popup", id = "PopupFxAction", name = "FX Action", help = "This is used for calling the FX system with given action when opening Popup.", 
+			editor = "text", default = "", },
+		{ category = "Completion Effects", id = "Enables", help = "List of StoryBits to enable", 
+			editor = "preset_id_list", default = {}, preset_class = "StoryBit", item_default = "", },
+		{ category = "Completion Effects", id = "Effects", name = "Completion Effects", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+		{ id = "max_reply_id", name = "Max Reply Id", 
+			editor = "number", default = 0, read_only = true, no_edit = true, },
+	},
+	HasParameters = true,
+	SingleFile = false,
+	GlobalMap = "StoryBits",
+	ContainerClass = "StoryBitSubItem",
+	EditorMenubarName = "Story Bits",
+	EditorShortcut = "Ctrl-Alt-E",
+	EditorIcon = "CommonAssets/UI/Icons/book 2.png",
+	EditorMenubar = "Scripting",
+	EditorCustomActions = {
+	{
+		Name = "Debug",
+	},
+	{
+		FuncName = "GedRpcTestStoryBit",
+		Icon = "CommonAssets/UI/Ged/play.tga",
+		Menubar = "Debug",
+		Name = "TestStoryBit",
+		Toolbar = "main",
+	},
+	{
+		FuncName = "GedRpcTestPrerequisitesStoryBit",
+		Icon = "CommonAssets/UI/Ged/preview.tga",
+		Menubar = "Debug",
+		Name = "Test prerequisites",
+		Toolbar = "main",
+	},
+},
+	EditorView = Untranslated("<ChooseColor><id><color 0 128 0><if(not_eq(Trigger,'StoryBitTick'))> (<Trigger>)</if><opt(u(Comment),' ','')><color 128 128 128><opt(u(save_in),' - ','')>"),
+}
+
+DefineModItemPreset("StoryBit", { EditorName = "Story bit", EditorSubmenu = "Gameplay" })
+
+function StoryBit:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "Category" then 
+		if self.Category == "FollowUp" or self.Category == "" then
+			self.Enabled = false
+			self.OneTime = true
+		else
+			self.Trigger = StoryBitCategories[self.Category].Trigger
+			self.Enabled = true
+		end
+	end
+	if prop_id == "Enables" or prop_id == "Effects" or prop_id == "ActivationEffects" then
+		StoryBitResetEnabledReferences()
+	end
+end
+
+function StoryBit:ChooseColor()
+	if not self.ScriptDone then return "" end
+	local color =
+		not self.TextsDone and (self.TextReadyForValidation and RGB(180, 0, 180) or RGB(205, 32, 32)) or
+		not self.TextReadyForValidation and RGB(220, 120, 0) or
+		not (self.Image and self.Image ~= "" or self.Category == "FollowUp") and RGB(50, 50, 200) or
+		RGB(32, 128, 32)
+	local r,g,b = GetRGB(color)
+	return string.format("<color %s %s %s>", r, g ,b)
+end
+
+----- StoryBit function ModItemStoryBit:TestModItem(ged)
+
+if config.Mods then
+	function ModItemStoryBit:TestModItem(ged)
+		if not GameState.gameplay then return end
+		CreateGameTimeThread(function()
+			ForceActivateStoryBit(self.id, SelectedObj, "immediate")
+		end)
+	end
+end
+
+----- StoryBit Add ! marks
+
+if Platform.developer then
+	local referenced_storybits = false
+	
+	function StoryBitResetEnabledReferences()
+		referenced_storybits = false
+		ObjModified(Presets.StoryBit)
+	end
+	
+	local function add_effect_references(effects)
+		for _, effect in ipairs(effects or empty_table) do
+			if effect:IsKindOf("StoryBitActivate") then
+				referenced_storybits[effect.Id] = true
+			end
+			if effect:IsKindOf("StoryBitEnableRandom") then
+				for _, id in ipairs(effect.StoryBits or empty_table) do
+					referenced_storybits[id] = true
+				end
+			end
+		end
+	end
+	
+	function OnMsg.MarkReferencedStoryBits(referenced_storybits)
+		ForEachPreset(StoryBit, function(storybit)
+			for _, id in ipairs(storybit.Enables or empty_table) do
+				referenced_storybits[id] = true
+			end
+			add_effect_references(storybit.Effects)
+			add_effect_references(storybit.ActivationEffects)
+			for _, child in ipairs(storybit) do
+				if child:IsKindOf("StoryBitOutcome") then
+					for _, id in ipairs(child.Enables) do
+						referenced_storybits[id] = true
+					end
+					add_effect_references(child.Effects)
+				end
+			end
+		end)
+	end
+	
+	function StoryBit:GetError()
+		if not referenced_storybits then
+			referenced_storybits = {}
+			Msg("MarkReferencedStoryBits", referenced_storybits)
+		end
+		return not (self.Enabled or referenced_storybits[self.id]) and
+			"This story bit is not enabled by itself, or from anywhere else."
+	end
+else
+	function StoryBitResetEnabledReferences()
+	end
+end
+
+DefineClass.StoryBitOutcome = {
+	__parents = { "StoryBitSubItem", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ category = "Activation", id = "Prerequisites", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+		{ category = "Activation", id = "Weight", 
+			editor = "number", default = 100, },
+		{ category = "Popup", id = "Title", 
+			editor = "text", default = false, translate = true, lines = 1, },
+		{ category = "Popup", id = "VoicedText", name = "Voiced Text", 
+			editor = "text", default = false, translate = true, lines = 1, max_lines = 256, context = VoicedContextFromField("Actor"), },
+		{ category = "Popup", id = "Text", 
+			editor = "text", default = false, translate = true, lines = 4, max_lines = 256, },
+		{ category = "Popup", id = "Actor", 
+			editor = "combo", default = "narrator", items = function (self) return VoiceActors end, },
+		{ category = "Popup", id = "Image", 
+			editor = "ui_image", default = "", },
+		{ id = "Enables", help = "List of StoryBits to enable", 
+			editor = "preset_id_list", default = {}, preset_class = "StoryBit", item_default = "", },
+		{ id = "Disables", help = "List of StoryBits to disable", 
+			editor = "preset_id_list", default = {}, preset_class = "StoryBit", item_default = "", },
+		{ category = "Effect", id = "StoryBits", help = "A list of storybits with weight. One will be chosen and activated based on weight and met prerequisites.", 
+			editor = "nested_list", default = false, base_class = "StoryBitWithWeight", all_descendants = true, },
+		{ category = "Effect", id = "Effects", help = "All effects in the list will be executed even if some storybits have been added to the StoryBits property.", 
+			editor = "nested_list", default = false, base_class = "Effect", all_descendants = true, },
+	},
+	EditorName = "New Outcome",
+}
+
+function StoryBitOutcome:GetEditorView()
+	local result = "<tab 20>Outcome (<Weight>): "
+	if self.VoicedText then
+		result = result ..  "<color 128 128 128><literal(VoicedText)></color>"
+	elseif self.Text then	
+		result = result ..  "<color 128 128 128><literal(Text)></color>"
+	else
+		result = result .. "<color 128 128 128>no display text</color>"
+	end
+	for _, cond in ipairs(self.Prerequisites or empty_table) do
+		result = result .. "\n<tab 20><color 140 64 32>" .. _InternalTranslate(cond:GetProperty("EditorView"), cond, false) .. "</color>"
+	end
+	for _, effect in ipairs(self.Effects or empty_table) do
+		result = result .. "\n<tab 20><color 140 64 32>" .. _InternalTranslate(effect:GetProperty("EditorView"), effect, false) .. "</color>"
+	end
+	for _, effect in ipairs(self.StoryBits) do
+		result = result .. "\n<tab 20><color 140 64 32>" .. _InternalTranslate(effect:GetProperty("EditorView"), effect, false) .. "</color>"
+	end
+	if next(self.Enables or empty_table) then
+		result = result .. "\n<tab 20>Enables: <color 140 64 32>" .. table.concat(self.Enables, ", ") .. "</color>"
+	end
+	if next(self.Disables or empty_table) then
+		result = result .. "\n<tab 20>Disables: <color 140 64 32>" .. table.concat(self.Disables, ", ") .. "</color>"
+	end
+	return T{Untranslated(result)}
+end
+
+function StoryBitOutcome:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "Enables" or prop_id == "Effects" then
+		StoryBitResetEnabledReferences()
+	end
+end
+
+DefineClass.StoryBitReply = {
+	__parents = { "StoryBitSubItem", },
+	__generated_by_class = "ClassDef",
+
+	properties = {
+		{ id = "Text", 
+			editor = "text", default = false, translate = true, lines = 1, },
+		{ id = "PrerequisiteText", name = "Prerequisite text", 
+			editor = "text", default = false, translate = true, },
+		{ id = "Prerequisites", 
+			editor = "nested_list", default = false, base_class = "Condition", },
+		{ id = "Cost", 
+			editor = "number", default = 0, },
+		{ id = "HideIfDisabled", name = "Hide if disabled", 
+			editor = "bool", default = false, },
+		{ id = "OutcomeText", name = "Outcome Text", 
+			editor = "choice", default = "none", items = function (self) return { { text = "None", value = "none" }, { text = "Auto (from 1st outcome effects)", value = "auto" }, { text = "Custom", value = "custom" } } end, },
+		{ id = "CustomOutcomeText", name = "Custom outcome text", 
+			editor = "text", default = false, 
+			no_edit = function(self) return self.OutcomeText ~= "custom" end, translate = true, lines = 1, },
+		{ category = "Comment", id = "Comment", 
+			editor = "text", default = false, },
+		{ id = "unique_id", name = "Unique Id", 
+			editor = "number", default = 0, read_only = true, no_edit = true, },
+	},
+	EditorName = "New Reply",
+}
+
+function StoryBitReply:GetEditorView()
+	local conditions = {}
+	for _, cond in ipairs(self.Prerequisites) do
+		table.insert(conditions, _InternalTranslate(cond:GetProperty("EditorView"), cond, false))
+	end
+	local cost = self.Cost
+	if cost ~= 0 then
+		table.insert(conditions, "Cost " .. _InternalTranslate(T(504461186435, "<cost>"), cost, false))
+	end
+	
+	local cond_text = #conditions > 0 and "[" .. table.concat(conditions, ", ") .. "] " or ""
+	local result = "Reply: <color 0 128 0>" .. cond_text .. "<literal(Text)></color>"
+	if self.OutcomeText == "custom" then
+		result = result .. "\n<color 128 128 128>(<literal(CustomOutcomeText)>)"
+	elseif self.OutcomeText == "auto" then
+		result = result .. "\n<color 128 128 128> - auto display of outcome text -"
+	end
+	if self.Comment and self.Comment ~= "" then
+		result = result .. "\n<color 75 105 198>" .. self.Comment .. "</color>"
+	end
+	if const.TagLookupTable["em"] then
+		result = result:gsub(const.TagLookupTable["em"],"")
+		result = result:gsub(const.TagLookupTable["/em"],"")
+	end
+	return T{Untranslated(result)}
+end
+
+function StoryBitReply:OnEditorNew(parent, ged, is_paste)
+	parent.max_reply_id = parent.max_reply_id + 1
+	self.unique_id = parent.max_reply_id
+end
+
+DefineClass.StoryBitSubItem = {
+	__parents = { "PropertyObject", },
+	__generated_by_class = "ClassDef",
+
+	StoreAsTable = true,
+	EditorName = "StoryBit Element",
+}
+

CommonLua/Classes/CodeRenderableObject.lua

@@ -0,0 +1,1375 @@
+local AppendVertex = pstr().AppendVertex
+local GetHeight = terrain.GetHeight
+local height_tile = const.HeightTileSize
+local InvalidZ = const.InvalidZ
+local KeepRefOneFrame = KeepRefOneFrame
+
+local SetCustomData
+local GetCustomData
+function OnMsg.Autorun()
+	SetCustomData = ComponentCustomData.SetCustomData
+	GetCustomData = ComponentCustomData.GetCustomData
+end
+
+DefineClass.CodeRenderableObject = 
+{
+	__parents = { "Object", "ComponentAttach", "ComponentCustomData" },
+	entity = "",
+	flags = { 
+		gofAlwaysRenderable = true, cfCodeRenderable = true, cofComponentInterpolation = true, cfConstructible = false,
+		efWalkable = false, efCollision = false, efApplyToGrids = false, efSelectable = false, efShadow = false, efSunShadow = false
+	},
+	depth_test = false,
+	zwrite = true,
+}
+
+DefineClass.Text =
+{
+	--[[
+		Custom data layout:
+		const.CRTextCCDIndexColorMain    - base color, RGBA
+		const.CRTextCCDIndexColorShadow  - shadow color, RGBA
+		const.CRTextCCDIndexFlags        - flags: 0: depth test, 1, center
+		const.CRTextCCDIndexText         - text, as string - you must keep this string from being GCed while the Text object is alive
+		const.CRTextCCDIndexFont         - font_id, integer as returned by UIL.GetFontID
+		const.CRTextCCDIndexShadowOffset - shadow offset
+		const.CRTextCCDIndexOpacity      - opacity interpolation parameters
+		const.CRTextCCDIndexScale        - scale interpolation parameters
+		const.CRTextCCDIndexZOffset      - z offset interpolation parameters
+	]]
+	__parents = { "CodeRenderableObject" },
+	text = false,
+	text_style = false,
+	hide_in_editor = true, -- hide using the T button in the editor statusbar (or Alt-Shift-T shortcut)
+}
+
+local TextFlag_DepthTest = 1
+local TextFlag_Center = 2
+
+function Text:SetColor1(c) SetCustomData(self, const.CRTextCCDIndexColorMain, c) end
+function Text:SetColor2(c) SetCustomData(self, const.CRTextCCDIndexColorShadow, c) end
+function Text:GetColor1(c) return GetCustomData(self, const.CRTextCCDIndexColorMain) end
+function Text:GetColor2(c) return GetCustomData(self, const.CRTextCCDIndexColorShadow) end
+
+function Text:SetColor(c)
+	self:SetColor1(c)
+	self:SetColor2(RGB(0,0,0))
+end
+
+function Text:GetColor(c)
+	return self:GetColor1()
+end
+
+function Text:SetDepthTest(depth_test) 
+	local flags = GetCustomData(self, const.CRTextCCDIndexFlags)
+	if depth_test then
+		SetCustomData(self, const.CRTextCCDIndexFlags, FlagSet(flags, TextFlag_DepthTest))
+	else
+		SetCustomData(self, const.CRTextCCDIndexFlags, FlagClear(flags, TextFlag_DepthTest))
+	end
+end
+function Text:GetDepthTest()   
+	return IsFlagSet(GetCustomData(self, const.CRTextCCDIndexFlags), TextFlag_DepthTest)
+end
+
+function Text:SetCenter(c) 
+	local flags = GetCustomData(self, const.CRTextCCDIndexFlags)
+	if c then
+		SetCustomData(self, const.CRTextCCDIndexFlags, FlagSet(flags, TextFlag_Center)) 
+	else
+		SetCustomData(self, const.CRTextCCDIndexFlags, FlagClear(flags, TextFlag_Center)) 
+	end
+end
+function Text:GetCenter()   
+	return IsFlagSet(GetCustomData(self, const.CRTextCCDIndexFlags), TextFlag_Center)
+end
+
+function Text:SetText(txt) 
+	KeepRefOneFrame(self.text)
+	self.text = txt  
+	SetCustomData(self, const.CRTextCCDIndexText, self.text) 
+end
+function Text:GetText()
+	return self.text
+end
+
+function Text:SetFontId(id)       SetCustomData(self, const.CRTextCCDIndexFont, id)    end
+function Text:GetFontId()         return GetCustomData(self, const.CRTextCCDIndexFont) end
+function Text:SetShadowOffset(so) SetCustomData(self, const.CRTextCCDIndexShadowOffset, so)    end
+function Text:GetShadowOffset()   return GetCustomData(self, const.CRTextCCDIndexShadowOffset) end
+
+function Text:SetTextStyle(style, scale)
+	local style = TextStyles[style]
+	if not style then
+		assert(false, string.format("Invalid text style '%s'", style))
+		return
+	end
+	scale = scale or terminal.desktop.scale:y()
+	local font, height, base_height = style:GetFontIdHeightBaseline(scale)
+	self:SetFontId(font, height, base_height)
+	self:SetColor(style.TextColor)
+	self:SetShadowOffset(style.ShadowSize)
+	self.text_style = style
+end
+
+function Text:SetOpacityInterpolation(v0, t0, v1, t1)
+	-- opacities are 0..100, 7 bits
+	-- times are encoded as ms/10, 8 bits each
+	v0 = v0 or 100
+	v1 = v1 or v0
+	t0 = t0 or 0
+	t1 = t1 or 0
+	SetCustomData(self, const.CRTextCCDIndexOpacity, EncodeBits(v0, 7, v1, 7, t0/10, 8, t1/10, 8))
+end
+
+function Text:SetScaleInterpolation(v0, t0, v1, t1)
+	-- scales are encoded 0..127, scale in percent/4 - so range 0..500%
+	-- times are encoded as ms/10, 8 bits each
+	v0 = v0 or 100
+	v1 = v1 or v0
+	t0 = t0 or 0
+	t1 = t1 or 0
+	SetCustomData(self, const.CRTextCCDIndexScale, EncodeBits(v0/4, 7, v1/4, 7, t0/10, 8, t1/10, 8))
+end
+
+function Text:SetZOffsetInterpolation(v0, t0, v1, t1)
+	-- Z offsets are encoded 0..127, in guim/50 - so range 0..6.35 m
+	-- times are encoded as ms/10, 8 bits each
+	v0 = v0 or 0
+	v1 = v1 or v0
+	t0 = t0 or 0
+	t1 = t1 or 0
+	SetCustomData(self, const.CRTextCCDIndexZOffset, EncodeBits(v0/50, 7, v1/50, 7, t0/10, 8, t1/10, 8))
+end
+
+function Text:Init()	
+	self:SetTextStyle(self.text_style or "EditorText")
+end
+
+function Text:Done()
+	KeepRefOneFrame(self.text)
+	self.text = nil
+end
+
+function Text:SetCustomData(idx, data)
+    assert(idx ~= const.CRTextCCDIndexText, "Use SetText instead")
+    return SetCustomData(self, idx, data)
+end
+
+DefineClass.TextEditor = {
+	__parents = {"Text", "EditorVisibleObject"},
+}
+
+function PlaceText(text, pos, color, editor_visibile_only)
+	local obj = PlaceObject(editor_visibile_only and "TextEditor" or "Text")
+	if pos then
+		obj:SetPos(pos)
+	end
+	obj:SetText(text)
+	if color then
+		obj:SetColor(color)
+	end
+	return obj
+end
+
+function RemoveAllTexts()
+	MapDelete("map", "Text")
+end
+
+local function GetMeshFlags()
+	local flags = {}
+	for name, value in pairs(const) do
+		if string.starts_with(name, "mf") then
+			flags[value] = name
+		end
+	end
+	return flags
+end
+
+DefineClass.MeshParamSet = {
+	__parents = { "PropertyObject" },
+	properties = {
+		
+	},
+	uniforms = false,
+	uniforms_size = 0,
+}
+
+local uniform_sizes = {
+	integer = 4,
+	float = 4,
+	color = 4,
+	point2 = 8,
+	point3 = 12,
+}
+
+function GetUniformMeta(properties)
+	local uniforms = {}
+	local offset = 0
+	for _, prop in ipairs(properties) do
+		local uniform_type = prop.uniform
+		if uniform_type then
+			if type(uniform_type) ~= "string" then
+				if prop.editor == "number" then
+					uniform_type = prop.scale and prop.scale ~= 1 and "float" or "integer"
+				elseif prop.editor == "point" then
+					uniform_type = "point3"
+				else
+					uniform_type = prop.editor
+				end
+			end
+			local size = uniform_sizes[uniform_type]
+			if not size then
+				assert(false, "Unknown uniform type.")
+			end
+			local space = 16 - (offset % 16)
+			if space < size then
+				table.insert(uniforms, {id = false, type = "padding", offset = offset, size = space})
+				offset = offset + space
+			end
+			table.insert(uniforms, {id = prop.id, type = uniform_type, offset = offset, size = size, scale = prop.scale})
+			offset = offset + size
+		end
+	end
+	return uniforms, offset
+end
+
+function OnMsg.ClassesPostprocess()
+	ClassDescendantsList("MeshParamSet", function(name, def)
+		def.uniforms, def.uniforms_size = GetUniformMeta(def:GetProperties())
+	end)
+end
+
+function MeshParamSet:WriteBuffer(param_pstr, offset, getter)
+	if not offset then
+		offset = 0
+	end
+	if not getter then 
+		getter = self.GetProperty
+	end
+	param_pstr = param_pstr or pstr("", self.uniforms_size)
+	param_pstr:resize(offset)
+	for _, prop in ipairs(self.uniforms) do
+		local value
+		if prop.type == "padding" then
+			value = prop.size
+		else
+			value = getter(self, prop.id)
+		end
+		
+		param_pstr:AppendUniform(prop.type, value, prop.scale)
+	end
+	return param_pstr
+end
+
+function MeshParamSet:ComposeBuffer(param_pstr, getter)
+	return self:WriteBuffer(param_pstr, 0, getter)
+end
+
+DefineClass.Mesh = {
+	__parents = { "CodeRenderableObject" },
+	
+	properties = {
+		{ id = "vertices_len", read_only = true, dont_save = true, editor = "number", default = 0,},
+		{ id = "CRMaterial", editor = "nested_obj", base_class = "CRMaterial", default = false, },
+		{ id = "MeshFlags", editor = "flags", default = 0, items = GetMeshFlags },
+		{ id = "DepthTest", editor = "bool", default = false, read_only = function(s) return not s.shader or s.shader.depth_test ~= "runtime" end, },
+		{ id = "ShaderName", editor = "choice", default = "default_mesh", items = function() return table.keys2(ProceduralMeshShaders, "sorted") end},
+	},
+	--[[
+		Custom data layout:
+		const.CRMeshCCDIndexGeometry  - vertices, packed in a pstr
+		const.CRMeshCCDIndexPipeline  - shader; depth_test >> 31, 0 for off, 1 for on
+		const.CRMeshCCDIndexMeshFlags - mesh flags
+		const.CRMeshCCDIndexUniforms  - uniforms, packed in a pstr
+		const.CRMeshCCDIndexTexture0, const.CRMeshCCDIndexTexture1 - textures
+	]]
+
+	vertices_pstr = false,
+	uniforms_pstr = false,
+	shader = false,
+	textstyle_id = false,
+}
+
+function Mesh:GedTreeViewFormat()
+	return string.format("%s (%s)", self.class, self.CRMaterial and self.CRMaterial.id or self:GetShaderName())
+end
+
+function Mesh:Getvertices_len()
+	return self.vertices_pstr and #self.vertices_pstr or 0
+end
+
+function Mesh:GetShaderName()
+	return self.shader and self.shader.name or ""
+end
+
+function Mesh:SetShaderName(value)
+	self:SetShader(ProceduralMeshShaders[value])
+end
+
+function Mesh:Init()
+	self:SetShader(ProceduralMeshShaders.default_mesh)
+end
+
+function Mesh:SetMesh(vpstr)
+	KeepRefOneFrame(self.vertices_pstr)
+	local vertices_pstr = #(vpstr or "") > 0 and vpstr or nil -- an empty string would result in a crash :|
+	self.vertices_pstr = vertices_pstr
+	SetCustomData(self, const.CRMeshCCDIndexGeometry, vertices_pstr)
+end
+
+function Mesh:SetUniformSet(uniform_set)
+	self:SetUniformsPstr(uniform_set:ComposeBuffer())
+end
+
+function Mesh:SetUniformsPstr(uniforms_pstr)
+	KeepRefOneFrame(self.uniforms_pstr)
+	self.uniforms_pstr = uniforms_pstr
+	SetCustomData(self, const.CRMeshCCDIndexUniforms, uniforms_pstr)
+end
+
+function Mesh:SetUniformsList(uniforms, isDouble)
+	KeepRefOneFrame(self.uniforms_pstr)
+	local count = Max(8, #uniforms)
+	local uniforms_pstr = pstr("", count * 4)
+	self.uniforms_pstr = uniforms_pstr
+	for i = 1, count do
+		if isDouble then
+			uniforms_pstr:AppendUniform("double", uniforms[i] or 0)
+		else
+			uniforms_pstr:AppendUniform("float", uniforms[i] or 0, 1000)
+		end
+	end
+	SetCustomData(self, const.CRMeshCCDIndexUniforms, uniforms_pstr)
+end
+
+function Mesh:SetUniforms(...)
+	return self:SetUniformsList{...}
+end
+
+function Mesh:SetDoubleUniforms(...)
+	return self:SetUniformsList({...}, true)
+end
+
+function Mesh:SetShader(shader, depth_test)
+	assert(shader.shaderid)
+	assert(shader.defines)
+	assert(shader.ref_id > 0)
+	if depth_test == nil then
+		if shader.depth_test == "always" then
+			depth_test = true
+		elseif shader.depth_test == "never" then
+			depth_test = false
+		else
+			depth_test = self:GetDepthTest()
+		end
+	end
+	local depth_test_int = 0
+	if depth_test then
+		depth_test_int = 1
+		assert(shader.depth_test == "runtime" or shader.depth_test == "always", "Tried to enable depth test for shader with depth_test = never")
+	else
+		depth_test_int = 0
+		assert(shader.depth_test == "runtime" or shader.depth_test == "never", "Tried to disable depth test for shader with depth_test = always")
+	end
+	SetCustomData(self, const.CRMeshCCDIndexPipeline, shader.ref_id | (depth_test_int << 31))
+	self.shader = shader
+end
+
+function Mesh:SetDepthTest(depth_test)
+	assert(self.shader)
+	self:SetShader(self.shader, depth_test)
+end
+
+function Mesh:SetCRMaterial(material)
+	if type(material) == "string" then
+		local new_material = CRMaterial:GetById(material, true)
+		assert(new_material, "CRMaterial not found.")
+		material = new_material
+	end
+	self.CRMaterial = material
+	local depth_test = material.depth_test
+	if depth_test == "default" then depth_test = nil end
+
+	CodeRenderableLockCCD(self)
+	self:SetShader(material:GetShader(), depth_test)
+	self:SetUniformsPstr(material:GetDataPstr())
+	CodeRenderableUnlockCCD(self)
+end
+
+function Mesh:GetCRMaterial()
+	return self.CRMaterial
+end
+
+if FirstLoad then
+	MeshTextureRefCount = {}
+end
+
+local function ModifyMeshTextureRefCount(id, change)
+	if id == 0 then return end
+	local old = MeshTextureRefCount[id] or 0
+	local new = old + change
+	if new == 0 then
+		MeshTextureRefCount[id] = nil
+		ProceduralMeshReleaseResource(id)
+	else
+		MeshTextureRefCount[id] = new
+	end
+end
+
+function Mesh:SetTexture(idx, resource_id)
+	assert(idx >= 0 and idx <= 1)
+	if self:GetTexture(idx) == resource_id then return end
+	ModifyMeshTextureRefCount(self:GetTexture(idx), -1)
+	SetCustomData(self, const.CRMeshCCDIndexTexture0 + idx, resource_id or 0)
+	ModifyMeshTextureRefCount(resource_id, 1) 
+end
+
+function Mesh:GetTexture(idx)
+	assert(idx >= 0 and idx <= 1)
+	return GetCustomData(self, const.CRMeshCCDIndexTexture0 + idx) or 0
+end
+
+function Mesh:Done()
+	KeepRefOneFrame(self.vertices_pstr)
+	KeepRefOneFrame(self.uniforms_pstr)
+	self.vertices_pstr = nil
+	self.uniforms_pstr = nil
+	self:SetTexture(0, 0)
+	self:SetTexture(1, 0)
+end
+
+function OnMsg.DoneMap()
+	for key, value in pairs(MeshTextureRefCount) do
+		ProceduralMeshReleaseResource(key)
+	end
+	MeshTextureRefCount = {}
+end
+
+function Mesh:SetCustomData(idx, data)
+	assert(idx > const.CRMeshCCDIndexGeometry, "Use SetMesh instead!")
+	return SetCustomData(self, idx, data)
+end
+function Mesh:GetDepthTest() return (GetCustomData(self, const.CRMeshCCDIndexPipeline) >> 31) == 1 end
+function Mesh:SetMeshFlags(flags) SetCustomData(self, const.CRMeshCCDIndexMeshFlags, flags) end
+function Mesh:GetMeshFlags() return GetCustomData(self, const.CRMeshCCDIndexMeshFlags) end
+function Mesh:AddMeshFlags(flags) self:SetMeshFlags(flags | self:GetMeshFlags()) end
+function Mesh:ClearMeshFlags(flags) self:SetMeshFlags(~flags & self:GetMeshFlags()) end
+
+function Mesh.ColorFromTextStyle(id)
+	assert(TextStyles[id])
+	return TextStyles[id].TextColor
+end
+
+function AppendCircleVertices(vpstr, center, radius, color, strip)
+	local HSeg = 32
+	vpstr = vpstr or pstr("", 1024)
+	color = color or RGB(254, 127, 156)
+	center = center or point30
+	local x0, y0, z0
+	for i = 0, HSeg do
+		local x, y, z = RotateRadius(radius, MulDivRound(360 * 60, i, HSeg), center, true)
+		AppendVertex(vpstr, x, y, z, color)
+		if not strip then
+			if i ~= 0 then
+				AppendVertex(vpstr, x, y, z, color)
+				if i == HSeg then
+					AppendVertex(vpstr, x0, y0, z0)
+				end
+			else
+				x0, y0, z0 = x, y, z
+			end
+		end
+	end
+
+	return vpstr
+end
+
+function AppendTileVertices(vstr, x, y, z, tile_size, color, offset_z, get_height)
+	offset_z = offset_z or 0
+	z = z or InvalidZ
+	local d = tile_size / 2
+	local x1, y1, z1 = x - d, y - d
+	local x2, y2, z2 = x + d, y - d
+	local x3, y3, z3 = x - d, y + d
+	local x4, y4, z4 = x + d, y + d
+	get_height = get_height or GetHeight
+	if z ~= InvalidZ and z ~= get_height(x, y) then
+		z = z + offset_z
+		z1, z2, z3, z4 = z, z, z, z
+	else
+		z1 = get_height(x1, y1) + offset_z
+		z2 = get_height(x2, y2) + offset_z
+		z3 = get_height(x3, y3) + offset_z
+		z4 = get_height(x4, y4) + offset_z
+	end
+	AppendVertex(vstr, x1, y1, z1, color)
+	AppendVertex(vstr, x2, y2, z2, color)
+	AppendVertex(vstr, x3, y3, z3, color)
+	AppendVertex(vstr, x4, y4, z4, color)
+	AppendVertex(vstr, x2, y2, z2, color)
+	AppendVertex(vstr, x3, y3, z3, color)
+end
+
+function GetSizePstrTile()
+	return 6 * const.pstrVertexSize
+end
+
+function AppendTorusVertices(vpstr, radius1, radius2, axis, color, normal)
+	local HSeg = 32
+	local VSeg = 10
+	vpstr = vpstr or pstr("", 1024)
+	local rad1 = Rotate(axis, 90 * 60)
+	rad1 = Cross(axis, rad1)
+	rad1 = Normalize(rad1)
+	rad1 = MulDivRound(rad1, radius1, 4096)
+	for i = 1, HSeg do
+		local localCenter1 = RotateAxis(rad1, axis, MulDivRound(360 * 60, i, HSeg))
+		local localCenter2 = RotateAxis(rad1, axis, MulDivRound(360 * 60, i - 1, HSeg))
+		local lastUpperPt, lastPt
+		if not normal or not IsPointInFrontOfPlane(point(0, 0, 0), normal, (localCenter1 + localCenter2) / 2) then
+			for j = 0, VSeg do
+				local rad2 = MulDivRound(localCenter1, radius2, radius1)
+				local localAxis = Cross(rad2, axis)
+				local pt = RotateAxis(rad2, localAxis, MulDivRound(360 * 60, j, VSeg))
+				pt = localCenter1 + pt
+				rad2 = MulDivRound(localCenter2, radius2, radius1)
+				localAxis = Cross(rad2, axis)
+				local upperPt = RotateAxis(rad2, localAxis, MulDivRound(360 * 60, j, VSeg))
+				upperPt = localCenter2 + upperPt
+				if j ~= 0 then
+					AppendVertex(vpstr, pt, color)
+					AppendVertex(vpstr, lastPt)
+					AppendVertex(vpstr, upperPt)
+					AppendVertex(vpstr, upperPt, color)
+					AppendVertex(vpstr, lastUpperPt)
+					AppendVertex(vpstr, lastPt)
+				end
+				lastPt = pt
+				lastUpperPt = upperPt
+			end
+		end
+	end
+	
+	return vpstr
+end
+
+function AppendConeVertices(vpstr, center, displacement, radius1, radius2, axis, angle, color, offset)
+	local HSeg = 10
+	vpstr = vpstr or pstr("", 1024)
+	center = center or point(0, 0, 0)
+	displacement = displacement or point(0, 0, 30 * guim)
+	axis = axis or axis_z
+	angle = angle or 0
+	offset = offset or point(0, 0, 0)
+	color = color or RGB(254, 127, 156)
+	local lastPt, lastUpperPt
+	for i = 0, HSeg do
+		local rad = point(radius1, 0, 0)
+		local pt = center + Rotate(rad, MulDivRound(360 * 60, i, HSeg))
+		local upperRad = point(radius2, 0, 0)
+		local upperPt = center + displacement + Rotate(upperRad, MulDivRound(360 * 60, i, HSeg))
+		pt = RotateAxis(pt, axis, angle * 60) + offset
+		upperPt = RotateAxis(upperPt, axis, angle * 60) + offset
+		if i ~= 0 then
+			AppendVertex(vpstr, pt, color)
+			AppendVertex(vpstr, lastPt)
+			AppendVertex(vpstr, upperPt)
+			if radius2 ~= 0 then
+				AppendVertex(vpstr, upperPt, color)
+				AppendVertex(vpstr, lastUpperPt)
+				AppendVertex(vpstr, lastPt)
+			end
+		end
+		lastPt = pt
+		lastUpperPt = upperPt
+	end
+	
+	return vpstr
+end
+
+DefineClass.Polyline =
+{
+	__parents = { "Mesh" },
+}
+
+function Polyline:Init()
+	self:SetMeshFlags(const.mfWorldSpace)
+	self:SetShader(ProceduralMeshShaders.default_polyline)
+end
+
+DefineClass.Vector = {
+	__parents = {"Polyline"},
+}
+
+function Vector:Set (a, b, col)
+	col = col or RGB(255, 255, 255)
+	a = ValidateZ(a)
+	b = ValidateZ(b)
+	self:SetPos(a)
+	
+	local vpstr = pstr("", 1024)
+	
+	AppendVertex(vpstr, a, col)
+	AppendVertex(vpstr, b)
+
+	local ab = b - a
+	local cb = (ab * 5) / 100
+	local f = cb:Len() / 4
+	local c = b - cb
+
+	local n = 4
+	local ps = GetRadialPoints (n, c, cb, f)
+	for i = 1 , n/2 do
+		AppendVertex(vpstr, ps[i])
+		AppendVertex(vpstr, ps[i + n/2])
+		AppendVertex(vpstr, b)
+	end
+	self:SetMesh(vpstr)
+end
+
+function Vector:GetA()
+	return self:GetPos() 
+end
+
+function ShowVector(vector, origin, color, time)
+	local v = PlaceObject("Vector")
+	origin = origin:z() and origin or point(origin:x(), origin:y(), GetWalkableZ(origin))
+	vector = vector:z() and vector or point(vector:x(), vector:y(), 0)
+	v:Set(origin, origin + vector, color)
+	if time then
+		CreateGameTimeThread(function()
+			Sleep(time)
+			DoneObject(v)
+		end)
+	end
+	
+	return v
+end
+
+DefineClass.Segment = {
+	__parents = {"Polyline"},
+}
+
+function Segment:Init()
+	self:SetDepthTest(false)
+end
+
+function Segment:Set (a, b, col)
+	col = col or RGB(255, 255, 255)
+	a = ValidateZ(a)
+	b = ValidateZ(b)
+	self:SetPos(a)
+	local vpstr = pstr("", 1024)
+	AppendVertex(vpstr, a, col)
+	AppendVertex(vpstr, b)
+	self:SetMesh(vpstr)
+end
+
+-- After loading the code renderables from C, fix their string custom data in the Lua
+function OnMsg.PersistLoad(_dummy_)
+	MapForEach(true, "Text", function(obj)
+		SetCustomData(obj, const.CRTextCCDIndexText, obj.text or 0)
+	end)
+	MapForEach(true, "Mesh", function(obj)
+		CodeRenderableLockCCD(obj)
+		SetCustomData(obj, const.CRMeshCCDIndexGeometry, obj.vertices_pstr or 0)
+		SetCustomData(obj, const.CRMeshCCDIndexUniforms, obj.uniforms_pstr or 0)
+		CodeRenderableUnlockCCD(obj)
+	end)
+end
+
+----
+
+function PlaceTerrainCircle(center, radius, color, step, offset, max_steps)
+	step = step or guim
+	offset = offset or guim
+	local steps = Min(Max(12, (44 * radius) / (7 * step)), max_steps or 360)
+	local last_pt
+	local mapw, maph = terrain.GetMapSize()
+	local vpstr = pstr("", 1024)
+	for i = 0,steps do
+		local x, y = RotateRadius(radius, MulDivRound(360*60, i, steps), center, true)
+		x = Clamp(x, 0, mapw - height_tile)
+		y = Clamp(y, 0, maph - height_tile)
+		AppendVertex(vpstr, x, y, offset, color)
+	end
+
+	local line = PlaceObject("Polyline")
+	line:SetMesh(vpstr)
+	line:SetPos(center)
+	line:AddMeshFlags(const.mfTerrainDistorted)
+	return line
+end
+
+local function GetTerrainPointsPStr(vpstr, pt1, pt2, step, offset, color)
+	step = step or guim
+	offset = offset or guim
+	local diff = pt2 - pt1
+	local steps = Max(2, 1 + diff:Len2D() / step)
+	local mapw, maph = terrain.GetMapSize()
+	vpstr = vpstr or pstr("", 1024)
+	for i=1,steps do
+		local pos = pt1 + MulDivRound(diff, i - 1, steps - 1)
+		local x, y = pos:xy()
+		x = Clamp(x, 0, mapw - height_tile)
+		y = Clamp(y, 0, maph - height_tile)
+		AppendVertex(vpstr, x, y, offset, color)
+	end
+	return vpstr
+end
+
+function PlaceTerrainLine(pt1, pt2, color, step, offset)
+	local vpstr = GetTerrainPointsPStr(false, pt1, pt2, step, offset, color)
+	local line = PlaceObject("Polyline")
+	line:SetMesh(vpstr)
+	line:SetPos((pt1 + pt2) / 2)
+	line:AddMeshFlags(const.mfTerrainDistorted)
+	return line
+end
+
+function PlaceTerrainBox(box, color, step, offset, mesh_obj, depth_test)
+	local p = {box:ToPoints2D()}
+	local m
+	for i = 1, #p do
+		m = GetTerrainPointsPStr(m, p[i], p[i + 1] or p[1], step, offset, color)
+	end
+	mesh_obj = mesh_obj or PlaceObject("Polyline")
+	if depth_test ~= nil then
+		mesh_obj:SetDepthTest(depth_test)
+	end
+	mesh_obj:SetMesh(m)
+	mesh_obj:SetPos(box:Center())
+	mesh_obj:AddMeshFlags(const.mfTerrainDistorted)
+	return mesh_obj
+end
+
+function PlaceTerrainPoly(p, color, step, offset, mesh_obj)
+	local m
+	local center = p[1] + ((p[1] - p[3]) / 2)
+	for i = 1, #p do
+		m = GetTerrainPointsPStr(m, p[i], p[i + 1] or p[1], step, offset, color)
+	end
+	mesh_obj = mesh_obj or PlaceObject("Polyline")
+	mesh_obj:SetMesh(m)
+	mesh_obj:SetPos(center)
+	return mesh_obj
+end
+
+function PlacePolyLine(pts, clrs, depth_test)
+	local line = PlaceObject("Polyline")
+	line:SetEnumFlags(const.efVisible)
+	if depth_test ~= nil then
+		line:SetDepthTest(depth_test)
+	end
+	local vpstr = pstr("", 1024)
+	local clr
+	local pt0
+	for i, pt in ipairs(pts) do
+		if IsValidPos(pt) then
+			pt0 = pt0 or pt
+			clr = type(clrs) == "table" and clrs[i] or clrs or clr
+			AppendVertex(vpstr, pt, clr)
+		end
+	end
+	line:SetMesh(vpstr)
+	if pt0 then
+		line:SetPos(pt0)
+	end
+	return line
+end
+
+function AppendSplineVertices(spline, color, step, min_steps, max_steps, vpstr)
+	step = step or guim
+	min_steps = min_steps or 7
+	max_steps = max_steps or 1024
+	local len = BS3_GetSplineLength3D(spline)
+	local steps = Clamp(len / step, min_steps, max_steps)
+	vpstr = vpstr or pstr("", (steps + 2) * const.pstrVertexSize)
+	local x, y, z
+	local x0, y0, z0 = BS3_GetSplinePos(spline, 0)
+	AppendVertex(vpstr, x0, y0, z0, color)
+	for i = 1,steps-1 do
+		local x, y, z = BS3_GetSplinePos(spline, i, steps)
+		AppendVertex(vpstr, x, y, z, color)
+	end
+	local x1, y1, z1 = BS3_GetSplinePos(spline, steps, steps)
+	AppendVertex(vpstr, x1, y1, z1, color)
+	return vpstr, point((x0 + x1) / 2, (y0 + y1) / 2, (z0 + z1) / 2)
+end
+
+function PlaceSpline(spline, color, depth_test, step, min_steps, max_steps)
+	local line = PlaceObject("Polyline")
+	line:SetEnumFlags(const.efVisible)
+	if depth_test ~= nil then
+		line:SetDepthTest(depth_test)
+	end
+	local vpstr, pos = AppendSplineVertices(spline, color, step, min_steps, max_steps)
+	line:SetMesh(vpstr)
+	line:SetPos(pos)
+	return line
+end
+
+function PlaceSplines(splines, color, depth_test, start_idx, step, min_steps, max_steps)
+	local line = PlaceObject("Polyline")
+	line:SetEnumFlags(const.efVisible)
+	if depth_test ~= nil then
+		line:SetDepthTest(depth_test)
+	end
+	local count = #(splines or "")
+	local pos = point30
+	local vpstr = pstr("", count * 128 * const.pstrVertexSize)
+	for i = (start_idx or 1), count do
+		local _, posi = AppendSplineVertices(splines[i], color, step, min_steps, max_steps, vpstr)
+		pos = pos + posi
+	end
+	if count > 0 then
+		pos = pos / count
+	end
+	line:SetMesh(vpstr)
+	line:SetPos(pos)
+	return line
+end
+
+function PlaceBox(box, color, mesh_obj, depth_test)
+	local p1, p2, p3, p4 = box:ToPoints2D()
+	local minz, maxz = box:minz(), box:maxz()
+	local vpstr = pstr("", 1024)
+	if minz and maxz then
+		if minz >= maxz - 1 then
+			for _, p in ipairs{p1, p2, p3, p4, p1} do
+				local x, y = p:xy()
+				AppendVertex(vpstr, x, y, minz, color)
+			end
+		else
+			for _, z in ipairs{minz, maxz} do
+				for _, p in ipairs{p1, p2, p3, p4, p1} do
+					local x, y = p:xy()
+					AppendVertex(vpstr, x, y, z, color)
+				end
+			end
+			AppendVertex(vpstr, p2:SetZ(maxz), color)
+			AppendVertex(vpstr, p2:SetZ(minz), color)
+			AppendVertex(vpstr, p3:SetZ(minz), color)
+			AppendVertex(vpstr, p3:SetZ(maxz), color)
+			AppendVertex(vpstr, p4:SetZ(maxz), color)
+			AppendVertex(vpstr, p4:SetZ(minz), color)
+		end
+	else
+		local z = terrain.GetHeight(p1)
+		for _, p in ipairs{p2, p3, p4} do
+			z = Max(z, terrain.GetHeight(p))
+		end
+		for _, p in ipairs{p1, p2, p3, p4, p1} do
+			local x, y = p:xy()
+			AppendVertex(vpstr, x, y, z, color)
+		end
+	end
+	mesh_obj = mesh_obj or PlaceObject("Polyline")
+	if depth_test ~= nil then
+		mesh_obj:SetDepthTest(depth_test)
+	end
+	mesh_obj:SetMesh(vpstr)
+	mesh_obj:SetPos(box:Center())
+	return mesh_obj
+end
+
+function PlaceVector(pos, vec, color, depth_test)
+	vec = vec or 10*guim
+	vec = type(vec) == "number" and point(0, 0, vec) or vec
+	return PlacePolyLine({pos, pos + vec}, color, depth_test)
+end
+
+function CreateTerrainCursorCircle(radius, color)
+	color = color or RGB(23, 34, 122)
+	radius = radius or 30 * guim
+	
+	local line = CreateCircleMesh(radius, color)
+	line:SetPos(GetTerrainCursor())
+	line:SetMeshFlags(const.mfOffsetByTerrainCursor + const.mfTerrainDistorted + const.mfWorldSpace)
+	return line
+end
+
+function CreateTerrainCursorSphere(radius, color)
+	color = color or RGB(23, 34, 122)
+	radius = radius or 30 * guim
+	
+	local line = PlaceObject("Mesh")
+	line:SetMesh(CreateSphereVertices(radius, color))
+	line:SetShader(ProceduralMeshShaders.mesh_linelist)
+	line:SetPos(GetTerrainCursor())
+	line:SetMeshFlags(const.mfOffsetByTerrainCursor + const.mfTerrainDistorted + const.mfWorldSpace)
+	return line
+end
+
+function CreateOrientationMesh(pos)
+	local o_mesh = Mesh:new()
+	pos = pos or point(0, 0, 0) 
+	o_mesh:SetShader(ProceduralMeshShaders.mesh_linelist)
+	local r = guim/4
+	local vpstr = pstr("", 1024)
+	AppendVertex(vpstr, point(0, 0, 0), RGB(255, 0, 0))
+	AppendVertex(vpstr, point(r, 0, 0))
+	AppendVertex(vpstr, point(0, 0, 0), RGB(0, 255, 0))
+	AppendVertex(vpstr, point(0, r, 0))
+	AppendVertex(vpstr, point(0, 0, 0), RGB(0, 0, 255))
+	AppendVertex(vpstr, point(0, 0, r))
+	o_mesh:SetMesh(vpstr)
+	o_mesh:SetPos(pos)
+	return o_mesh
+end
+
+function CreateSphereMesh(radius, color, precision)
+	local sphere_mesh = Mesh:new()
+	sphere_mesh:SetMesh(CreateSphereVertices(radius, color))
+	sphere_mesh:SetShader(ProceduralMeshShaders.mesh_linelist)
+	return sphere_mesh
+end
+
+function PlaceSphere(center, radius, color, depth_test)
+	local sphere = CreateSphereMesh(radius, color)
+	if depth_test ~= nil then
+		sphere:SetDepthTest(depth_test)
+	end
+	sphere:SetPos(center)
+	return sphere
+end
+
+function ShowMesh(time, func, ...)
+	local ok, meshes = procall(func, ...)
+	if not ok or not meshes then
+		return
+	end
+	return CreateRealTimeThread(function(meshes, time)
+		Msg("ShowMesh")
+		WaitMsg("ShowMesh", time)
+		if IsValid(meshes) then
+			DoneObject(meshes)
+		else
+			DoneObjects(meshes)
+		end
+	end, meshes, time)
+end
+
+function CreateCircleMesh(radius, color, center)
+	local circle_mesh = Mesh:new()
+	circle_mesh:SetMesh(AppendCircleVertices(nil, center, radius, color, true))
+	circle_mesh:SetShader(ProceduralMeshShaders.default_polyline)
+	return circle_mesh
+end	
+
+function PlaceCircle(center, radius, color, depth_test)
+	local circle = CreateCircleMesh(radius, color)
+	if depth_test ~= nil then
+		circle:SetDepthTest(depth_test)
+	end
+	circle:SetPos(center)
+	return circle
+end
+
+function CreateConeMesh(center, displacement, radius1, radius2, axis, angle, color)
+	local circle_mesh = Mesh:new()
+	circle_mesh:SetMesh(AppendConeVertices(nil, center, displacement, radius1, radius2, axis, angle, color))
+	circle_mesh:SetShader(ProceduralMeshShaders.mesh_linelist)
+	return circle_mesh
+end	
+
+function CreateCylinderMesh(center, displacement, radius, axis, angle, color)
+	local circle_mesh = Mesh:new()
+	circle_mesh:SetMesh(AppendConeVertices(nil, center, displacement, radius, radius, axis, angle, color))
+	circle_mesh:SetShader(ProceduralMeshShaders.default_mesh)
+	return circle_mesh
+end	
+
+function CreateMoveGizmo()
+	local g_MoveGizmo = MoveGizmo:new()
+	CreateRealTimeThread(function()
+		while true do
+			g_MoveGizmo:OnMousePos(GetTerrainCursor())
+			Sleep(100)
+		end
+	end)
+end
+
+function CreateTerrainCursorTorus(radius1, radius2, axis, angle, color)
+	color = color or RGB(255, 0, 0)
+	radius1 = radius1 or 2.3 * guim
+	radius2 = radius2 or 0.15 * guim
+	axis = axis or axis_y
+	angle = angle or 90
+	
+	local line = PlaceObject("Mesh")
+	local vpstr = pstr("", 1024)
+	local normal = selo():GetPos() - camera.GetEye()
+	local b = selo():GetPos()
+	local bigTorusAxis, bigTorusAngle = GetAxisAngle(normal, axis_z)
+	bigTorusAxis = Normalize(bigTorusAxis)
+	bigTorusAngle = 180 - bigTorusAngle / 60
+	vpstr = AppendTorusVertices(vpstr, point(0, 0, 0), 2.3 * guim, 0.15 * guim, bigTorusAxis, bigTorusAngle, RGB(128, 128, 128))
+	vpstr = AppendTorusVertices(vpstr, point(0, 0, 0), 2.3 * guim, 0.15 * guim, axis_y, 90, RGB(255, 0, 0), normal, b)
+	vpstr = AppendTorusVertices(vpstr, point(0, 0, 0), 2.3 * guim, 0.15 * guim, axis_x, 90, RGB(0, 255, 0), normal, b)
+	vpstr = AppendTorusVertices(vpstr, point(0, 0, 0), 2.3 * guim, 0.15 * guim, axis_z, 0, RGB(0, 0, 255), normal, b)
+	vpstr = AppendTorusVertices(vpstr, point(0, 0, 0), 3.5 * guim, 0.15 * guim, bigTorusAxis, bigTorusAngle, RGB(0, 192, 192))
+	line:SetMesh(vpstr)
+	line:SetPos(selo():GetPos())
+	return line
+end
+
+function CreateObjSurfaceMesh(obj, surface_flag, color1, color2)
+	if not IsValidPos(obj) then
+		return
+	end
+	local v_pstr = pstr("", 1024)
+	ForEachSurface(obj, surface_flag, function(pt1, pt2, pt3, v_pstr, color1, color2)
+		local color
+		if color1 and color2 then
+			local rand = xxhash(pt1, pt2, pt3) % 1024
+			color = InterpolateRGB(color1, color2, rand, 1024)
+		end
+		v_pstr:AppendVertex(pt1, color)
+		v_pstr:AppendVertex(pt2, color)
+		v_pstr:AppendVertex(pt3, color)
+	end, v_pstr, color1, color2)
+	local mesh = PlaceObject("Mesh")
+	mesh:SetMesh(v_pstr)
+	mesh:SetPos(obj:GetPos())
+	mesh:SetMeshFlags(const.mfWorldSpace)
+	mesh:SetDepthTest(true)
+	if color1 and not color2 then
+		mesh:SetColorModifier(color1)
+	end
+	return mesh
+end
+
+function FlatImageMesh(texture, width, height, glow_size, glow_period, glow_color)
+	local text = PlaceObject("Mesh")
+	local vpstr = pstr("", 1024)
+	local color = RGB(255,255,255)
+	local half_size_x = width or 1000
+	local half_size_y = height or 1000
+	glow_size = glow_size or 0
+	glow_period = glow_period or 0
+	glow_color = glow_color or RGB(255,255,255)
+
+	AppendVertex(vpstr, point(-half_size_x, -half_size_y, 0), color, 0, 0)
+	AppendVertex(vpstr, point(half_size_x, -half_size_y, 0), color, 1, 0)
+	AppendVertex(vpstr, point(-half_size_x, half_size_y, 0), color, 0, 1)
+
+	AppendVertex(vpstr, point(half_size_x, -half_size_y, 0), color, 1, 0)
+	AppendVertex(vpstr, point(half_size_x, half_size_y, 0), color, 1, 1)
+	AppendVertex(vpstr, point(-half_size_x, half_size_y, 0), color, 0, 1)
+
+	text:SetMesh(vpstr)
+
+	if texture then
+		local use_sdf = false
+		local padding = 0
+		local low_edge = 0
+		local high_edge = 0
+		if glow_size > 0 then
+			use_sdf = true
+			padding = 16
+			low_edge = 490
+			high_edge = 510
+		end
+		text:SetTexture(0, ProceduralMeshBindResource("texture", texture, false, 0))
+		if glow_size > 0 then
+			text:SetTexture(1, ProceduralMeshBindResource("texture", texture, true, 0, const.fmt_unorm16_c1))
+			text:SetShader(ProceduralMeshShaders.default_ui_sdf)
+		else
+			text:SetShader(ProceduralMeshShaders.default_ui)
+		end
+		local r, g, b = GetRGB(glow_color)
+		text:SetUniforms(low_edge, high_edge, glow_size, glow_period, r, g, b)
+	end
+	
+	return text
+end
+
+DefineClass.FlatTextMesh = {
+	__parents = { "Mesh" },
+	properties = {
+		{id = "font_id", editor = "number", read_only = true, default = 0, category = "Rasterize" },
+		{id = "text_style_id", editor = "preset_id", preset_class = "TextStyle", editor_preview = true, default = false, category = "Rasterize" },
+		{id = "text_scale", editor = "number", default = 1000, category = "Rasterize" },
+		{id = "text", editor = "text", default = "", category = "Rasterize" },
+		{id = "padding", editor = "number", default = 0, category = "Rasterize", help = "How much pixels to leave around the text(for effects)"},
+
+		{id = "width", editor = "number", default = 0, category = "Present", help = "In meters. Leave 0 to calculate automatically"},
+		{id = "height", editor = "number", default = 0, category = "Present", help = "In meters. Leave 0 to calculate automatically"},
+		{id = "text_color", editor = "color", default = RGB(255,255,255), category = "Present"},
+		{id = "effect_type", editor = "choice", items = {"none", "glow"}, default = "glow", category = "Present" },
+		{id = "effect_color", editor = "color", default = RGB(255,255,255), category = "Present"},
+		{id = "effect_size", editor = "number", default = 0, help = "In pixels from the rasterized image.", category = "Present" },
+		{id = "effect_period", editor = "number", default = 0, help = "1 pulse per each period seconds. ", category = "Present"},
+	}
+}
+
+function FlatTextMesh:Init()
+	self:Recreate()
+end
+
+function FlatTextMesh:FetchEffectsFromTextStyle()
+	local text_style = TextStyles[self.text_style_id]
+	if not text_style then return end
+	self.text_color = text_style.TextColor
+	self.effect_type = text_style.ShadowType == "glow" and "glow" or "none"
+	self.effect_color = text_style.ShadowColor
+	self.effect_size = text_style.ShadowSize
+	self.textstyle_id = self.text_style_id
+end
+
+function FlatTextMesh:SetColorFromTextStyle(text_style_id)
+	self.text_style_id = text_style_id
+	self.textstyle_id = text_style_id
+	self:FetchEffectsFromTextStyle()
+	self:Recreate()
+end
+
+function FlatTextMesh:CalculateSizes(max_width, max_height, default_scale)
+	local width_pixels, height_pixels = UIL.MeasureText(self.text, self.font_id)
+	local scale = 0
+	if max_width == 0 and max_height == 0 then
+		scale = default_scale or 10000
+	elseif max_width == 0 then
+		max_width = 1000000
+	elseif max_height == 0 then
+		max_height = 1000000
+	end
+
+	if scale == 0 then
+		local scale1 = MulDivRound(max_width, 1000, width_pixels)
+		local scale2 = MulDivRound(max_height, 1000, height_pixels)
+		scale = Min(scale1, scale2)
+	end
+
+	self.width = MulDivRound(width_pixels, scale, 1000)
+	self.height = MulDivRound(height_pixels, scale, 1000)
+end
+
+function FlatTextMesh:Recreate()
+	local text_style = TextStyles[self.text_style_id]
+	if not text_style then return end
+	local font_id = text_style:GetFontIdHeightBaseline(self.text_scale)
+	self.font_id = font_id
+
+	local effect_type = self.effect_type
+	local use_sdf = false
+	local padding = 0
+	if effect_type == "glow" then
+		use_sdf = true
+		padding = 16
+	end
+
+	local width_pixels, height_pixels = UIL.MeasureText(self.text, font_id)
+	local width = self.width
+	local height = self.height
+	if width == 0 and height == 0 then
+		local default_scale = 10000
+		width = MulDivRound(width_pixels, default_scale, 1000)
+		height = MulDivRound(height_pixels, default_scale, 1000)
+	end
+	if width == 0 then
+		width = MulDivRound(width_pixels, height, height_pixels)
+	end
+	if height == 0 then
+		height = MulDivRound(height_pixels, width, width_pixels)
+	end
+	
+	--add for padding
+	width = width + MulDivRound(width, padding * 2 * 1000, width_pixels * 1000)
+	height = height + MulDivRound(height, padding * 2 * 1000, height_pixels * 1000)
+
+
+	local vpstr = pstr("", 1024)
+	local half_size_x = (width or 1000) / 2
+	local half_size_y = (height or 1000) / 2
+	local color = self.text_color
+	AppendVertex(vpstr, point(-half_size_x, -half_size_y, 0), color, 0, 0)
+	AppendVertex(vpstr, point(half_size_x, -half_size_y, 0), color, 1, 0)
+	AppendVertex(vpstr, point(-half_size_x, half_size_y, 0), color, 0, 1)
+
+	AppendVertex(vpstr, point(half_size_x, -half_size_y, 0), color, 1, 0)
+	AppendVertex(vpstr, point(half_size_x, half_size_y, 0), color, 1, 1)
+	AppendVertex(vpstr, point(-half_size_x, half_size_y, 0), color, 0, 1)
+
+	self:SetMesh(vpstr)
+
+	self:SetTexture(0, ProceduralMeshBindResource("text", self.text, font_id, use_sdf, padding))
+	local r, g, b = GetRGB(self.effect_color)
+	self:SetUniforms(use_sdf and 1000 or 0, 0, self.effect_size * 1000, self.effect_period, r, g, b)
+	self:SetShader(ProceduralMeshShaders.default_ui)
+end
+
+function TestUIRenderables()
+	local pt = GetTerrainCursor() + point(0, 0, 100)
+	for i = 0, 4 do
+		local height = 700
+		local space = 5000
+
+		local text = FlatTextMesh:new({
+			text_style_id = "ProcMeshDefault",
+			text_scale = 500 + 400 * i,
+			text = "Hello world",
+			height = height,
+		})
+		text:SetPos(pt + point(i * space, 0, 0))
+
+		text = FlatTextMesh:new({
+			text_style_id = "ProcMeshDefaultFX",
+			text_scale = 500 + 400 * i,
+			text = "Hello world",
+			height = height,
+			effect_type = "glow",
+			effect_size = 8,
+			effect_period = 200,
+			effect_color = RGB(255, 0, 0),
+		})
+		text:SetPos(pt + point(i * space, 3000, 0))
+		text:SetGameFlags(const.gofRealTimeAnim)
+
+		local mesh = FlatImageMesh("UI/MercsPortraits/Buns", 1000, 1000, 200 * i, 1000, RGB(255, 255, 255))
+		mesh:SetPos(pt + point(i * space, 6000, 0))
+
+		mesh = FlatImageMesh("UI/MercsPortraits/Buns", 1000, 1000)
+		mesh:SetPos(pt + point(i * space, 9000, 0))
+	end
+end
+
+function DebugShowMeshes()
+	local meshes = MapGet("map", "Mesh")
+	OpenGedGameObjectEditor(meshes, true)
+end
+
+-- Represents combination of shader & the data the shader accepts. Provides "properties" interface for the underlying raw bits sent to the shader.
+-- Inherits from PersistedRenderVars(is a preset) and provides minimalistic default logic for updating meshes on the fly.
+local function depth_test_values(obj)
+	local tbl = {{value = "default", text = "default"}}
+	local shader_id = obj.shader_id
+	local shader_data = ProceduralMeshShaders[shader_id]
+	if shader_data then
+		if shader_data.depth_test == "runtime" or shader_data.depth_test == "never" then
+			table.insert(tbl, {value = false, text = "never"})
+		end
+		if shader_data.depth_test == "runtime" or shader_data.depth_test == "always" then
+			table.insert(tbl, {value = true, text = "always"})
+		end
+	end
+	return tbl
+end
+DefineClass.CRMaterial = {
+	__parents = {"PersistedRenderVars", "MeshParamSet"},
+
+	properties = { 
+		{ id = "ShaderName", editor = "choice", default = "default_mesh", items = function() return table.keys2(ProceduralMeshShaders, "sorted") end, read_only = true,},
+		{ id = "depth_test", editor = "choice", items = depth_test_values },
+	},
+	group = "CRMaterial",
+	depth_test = "default",
+	cloned_from = false,
+	shader_id = "default_mesh",
+	shader = false,
+	pstr_buffer = false,
+	dirty = false,
+}
+
+function CRMaterial:GetError()
+	if not self.shader_id then
+		return "CRMaterial without a shader_id."
+	end
+	if not ProceduralMeshShaders[self.shader_id] then
+		return "ShaderID " .. self.shader_id .. " is not valid."
+	end
+end
+
+function CRMaterial:GetShader()
+	if self.shader then
+		return self.shader
+	end
+	if self.shader_id then
+		return ProceduralMeshShaders[self.shader_id]
+	end
+	return false
+end
+
+------- Prevent triggering Preset logic on cloned materials. Probably should be implemented smarter, maybe by __index table reference, so even clones are live updated by editor
+function CRMaterial:SetId(value)
+	if self.cloned_from then
+		self.id = value
+	else
+		PersistedRenderVars.SetId(self, value)
+	end
+end
+
+function CRMaterial:SetGroup(value)
+	if self.cloned_from then
+		self.group = value
+	else
+		PersistedRenderVars.SetGroup(self, value)
+	end
+end
+
+function CRMaterial:Register(...)
+	if self.cloned_from then
+		return
+	end
+	return PersistedRenderVars.Register(self, ...)
+end
+
+function CRMaterial:Clone()
+	local obj = _G[self.class]:new({cloned_from = self.id})
+	obj:CopyProperties(self)
+	return obj
+end
+
+function CRMaterial:GetDataPstr()
+	if self.dirty or not self.pstr_buffer then
+		self:Recreate()
+	end
+	return self.pstr_buffer
+end
+
+function CRMaterial:GetShaderName()
+	return self.shader and self.shader.id or self.shader_id
+end
+
+function CRMaterial:Recreate()
+	self.dirty = false
+	self.pstr_buffer = self:WriteBuffer()
+end
+
+function CRMaterial:OnPreSave()
+	self.pstr_buffer = nil
+end
+
+function CRMaterial:Apply()
+	self:Recreate()
+	if CurrentMap ~= "" then
+		MapGet("map", "Mesh", function(o)
+			local omtrl = o.CRMaterial
+			if omtrl == self then
+				o:SetCRMaterial(self)
+			elseif (omtrl and omtrl.id == self.id) then
+				for _, prop in ipairs(omtrl:GetProperties()) do
+					local value = rawget(omtrl, prop.id)
+					if value == nil or (not prop.read_only and not prop.no_edit) then
+						omtrl:SetProperty(prop.id, self:GetProperty(prop.id))
+					end
+				end
+				omtrl:Recreate()
+				o:SetCRMaterial(omtrl)
+			end
+		end)
+	end
+end
+
+
+
+DefineClass.CRM_DebugMeshMaterial = {
+	__parents = {"CRMaterial"},
+
+	shader_id = "debug_mesh",
+	properties = {
+	},
+}
+

CommonLua/Classes/CollectionAnimator.lua

@@ -0,0 +1,172 @@
+DefineClass.CollectionAnimator = {
+	__parents = { "Object", "EditorEntityObject", "EditorObject" },
+	--entity = "WayPoint",
+	editor_entity = "WayPoint",
+	properties = {
+		{ name = "Rotate Speed", id = "rotate_speed", category = "Animator", editor = "number", default = 0, scale = 100, help = "Revolutions per minute" },
+		{ name = "Oscillate Offset", id = "oscillate_offset", category = "Animator", editor = "point", default = point30, scale = "m", help = "Map offset acceleration movement up and down (in meters)" },
+		{ name = "Oscillate Cycle", id = "oscillate_cycle", category = "Animator", editor = "number", default = 0, help = "Full cycle time in milliseconds" },
+		{ name = "Locked Orientation", id = "LockedOrientation", category = "Animator", editor = "bool", default = false },
+	},
+	animated_obj = false,
+	rotation_thread = false,
+	move_thread = false,
+}
+
+DefineClass.CollectionAnimatorObj = {
+	__parents = { "Object", "ComponentAttach" },
+	flags = { cofComponentInterpolation = true, efWalkable = false, efApplyToGrids = false, efCollision = false },
+	properties = {
+		-- exclude properties to not copy them
+		{ id = "Pos" },
+		{ id = "Angle" },
+		{ id = "Axis" },
+		{ id = "Walkable" },
+		{ id = "ApplyToGrids" },
+		{ id = "Collision" },
+		{ id = "OnCollisionWithCamera" },
+		{ id = "CollectionIndex" },
+		{ id = "CollectionName" },
+	},
+}
+
+function CollectionAnimator:GameInit()
+	self:StartAnimate()
+end
+
+function CollectionAnimator:Done()
+	self:StopAnimate()
+end
+
+function CollectionAnimator:StartAnimate()
+	if self.animated_obj then
+		return -- already started
+	end
+	if not self:AttachObjects() then
+		return
+	end
+	-- rotation
+	if not self.rotation_thread and self.rotate_speed ~= 0 then
+		self.rotation_thread = CreateGameTimeThread(function()
+			local obj = self.animated_obj
+			obj:SetAxis(self:RotateAxis(0,0,4096))
+			local a = 162*60*(self.rotate_speed < 0 and -1 or 1)
+			local t = 27000 * 100 / abs(self.rotate_speed)
+			while true do
+				obj:SetAngle(obj:GetAngle() + a, t)
+				Sleep(t)
+			end
+		end)
+	end
+	-- movement
+	if not self.move_thread and self.oscillate_cycle >= 100 and self.oscillate_offset:Len() > 0 then
+		self.move_thread = CreateGameTimeThread(function()
+			local obj = self.animated_obj
+			local pos = self:GetVisualPos()
+			local vec = self.oscillate_offset
+			local t = self.oscillate_cycle/4
+			local acc = self:GetAccelerationAndStartSpeed(pos+vec, 0, t)
+			while true do
+				obj:SetAcceleration(acc)
+				obj:SetPos(pos+vec, t)
+				Sleep(t)
+				obj:SetAcceleration(-acc)
+				obj:SetPos(pos, t)
+				Sleep(t)
+				obj:SetAcceleration(acc)
+				obj:SetPos(pos-vec, t)
+				Sleep(t)
+				obj:SetAcceleration(-acc)
+				obj:SetPos(pos, t)
+				Sleep(t)
+			end
+		end)
+	end
+end
+
+function CollectionAnimator:StopAnimate()
+	DeleteThread(self.rotation_thread)
+	self.rotation_thread = nil
+	DeleteThread(self.move_thread)
+	self.move_thread = nil
+	self:RestoreObjects()
+end
+
+function CollectionAnimator:AttachObjects()
+	local col = self:GetCollection()
+	if not col then
+		return false
+	end
+	SuspendPassEdits("CollectionAnimator")
+	local obj = PlaceObject("CollectionAnimatorObj")
+	self.animated_obj = obj
+	local pos = self:GetPos()
+	local max_offset = 0
+	MapForEach (col.Index, false, "map", "attached", false, function(o)
+			if o == self then return end
+			local o_pos, o_axis, o_angle = o:GetVisualPos(), o:GetAxis(), o:GetAngle()
+			local o_offset = o_pos - pos
+			--if o:IsKindOf("ComponentAttach") then
+				o:DetachFromMap()
+				o:SetAngle(0) -- fixes a problem when attaching
+				obj:Attach(o)
+			--else
+			--	local clone = PlaceObject("CollectionAnimatorObj")
+			--	clone:ChangeEntity(o:GetEntity())
+			--	clone:CopyProperties(o)
+			--end
+			o:SetAttachAxis(o_axis)
+			o:SetAttachAngle(o_angle)
+			o:SetAttachOffset(o_offset)
+			max_offset = Max(max_offset, o_offset:Len())
+		end)
+	if max_offset > 20*guim then
+		obj:SetGameFlags(const.gofAlwaysRenderable)
+	end
+	if self.LockedOrientation then
+		obj:SetHierarchyGameFlags(const.gofLockedOrientation)
+	end
+	obj:ClearHierarchyEnumFlags(const.efWalkable + const.efApplyToGrids + const.efCollision)
+	obj:SetPos(pos)
+	ResumePassEdits("CollectionAnimator")
+	return true
+end
+
+function CollectionAnimator:RestoreObjects()
+	local obj = self.animated_obj
+	if not obj then
+		return
+	end
+	SuspendPassEdits("CollectionAnimator")
+	self.animated_obj = nil
+	obj:SetPos(self:GetPos())
+	obj:SetAxis(axis_z)
+	obj:SetAngle(0)
+	for i = obj:GetNumAttaches(), 1, -1 do
+		local o = obj:GetAttach(i)
+		local o_pos, o_axis, o_angle = o:GetAttachOffset(), o:GetAttachAxis(), o:GetAttachAngle()
+		o:Detach()
+		o:SetPos(o:GetPos() + o_pos)
+		o:SetAxis(o_axis)
+		o:SetAngle(o_angle)
+		o:ClearGameFlags(const.gofLockedOrientation)
+	end
+	DoneObject(obj)
+	ResumePassEdits("CollectionAnimator")
+end
+
+function CollectionAnimator:EditorEnter()
+	self:StopAnimate()
+end
+
+function CollectionAnimator:EditorExit()
+	self:StartAnimate()
+end
+
+function OnMsg.PreSaveMap()
+	MapForEach("map", "CollectionAnimator", function(obj) obj:StopAnimate() end)
+end
+
+function OnMsg.PostSaveMap()
+	MapForEach("map", "CollectionAnimator", function(obj) obj:StartAnimate() end)
+end

CommonLua/Classes/ColorModifierReason.lua

@@ -0,0 +1,188 @@
+ColorModifierReasons = {
+	--override this in your project
+	--{id = "reason_name", weight = default reason weight number, color = default reason color},
+}
+
+MapVar("ColorModifierReasonsData", false)
+local table_find = table.find
+local SetColorModifier = CObject.SetColorModifier
+local GetColorModifier = CObject.GetColorModifier
+local clrNoModifier = const.clrNoModifier
+local default_color_modifier = RGBA(100, 100, 100, 0)
+
+function SetColorModifierReason(obj, reason, color, weight, blend, skip_attaches)
+	assert(reason)
+	if not reason then
+		return
+	end
+	local color_value = color
+	
+	if obj:GetRadius() > 0 then
+		local data = ColorModifierReasonsData
+		if not data then
+			data = {}
+			ColorModifierReasonsData = data 
+		end
+		local mrt = data[obj]
+		local orig_color
+		if not mrt then
+			orig_color = GetColorModifier(obj)
+			mrt = { orig_color = orig_color }
+			data[obj] = mrt
+		end
+		
+		local rt = ColorModifierReasons
+		local idx = table_find(rt, "id", reason)
+		local rdata = idx and rt[idx] or false
+		
+		color = color or rdata and rdata.color or nil
+		if not color then
+			printf("[WARNING] SetColorModifierReason no color! reason %s, color %s, weight %s", reason, tostring(color), tostring(weight))
+			return
+		end
+		weight = weight or rdata and rdata.weight or const.DefaultColorModWeight
+		if not weight then
+			printf("[WARNING] SetColorModifierReason no weight! reason %s, color %s, weight %s", reason, tostring(color), tostring(weight))
+			return
+		end
+		
+		if blend then
+			orig_color = orig_color or mrt.orig_color
+			if orig_color ~= clrNoModifier then
+				color = InterpolateRGB(orig_color, color, blend, 100)
+			end
+		end
+		local idx = table_find(mrt, "reason", reason)
+		local entry = idx and mrt[idx]
+		if entry then
+			entry.weight = weight
+			entry.color = color
+		else
+			entry = { reason = reason, weight = weight, color = color }
+			table.insert(mrt, entry)
+		end
+		table.stable_sort(mrt, function(a, b)
+			return a.weight < b.weight
+		end)
+		SetColorModifier(obj, mrt[#mrt].color)
+	end
+	if skip_attaches then
+		return
+	end
+	obj:ForEachAttach(SetColorModifierReason, reason, color_value, weight, blend)
+end
+
+function SetOrigColorModifier(obj, color, skip_attaches)
+	local data = ColorModifierReasonsData
+	local mrt = data and data[obj]
+	if not mrt then
+		SetColorModifier(obj, color)
+	else
+		mrt.orig_color = color
+	end
+	if skip_attaches then return end
+	obj:ForEachAttach(SetOrigColorModifier, color)
+end
+
+function GetOrigColorModifier(obj)
+	local modifier = GetColorModifier(obj)
+	return modifier == default_color_modifier and table.get(ColorModifierReasonsData, obj, "orig_color") or modifier
+end
+
+function ValidateColorReasons()
+	table.validate_map(ColorModifierReasonsData)
+end
+
+function ClearColorModifierReason(obj, reason, skip_color_change, skip_attaches)	
+	assert(reason)
+	if not reason then
+		return
+	end
+	local data = ColorModifierReasonsData
+	local mrt = data and data[obj]
+	if mrt then
+		if not IsValid(obj) then
+			data[obj] = nil
+			return
+		end
+		local idx = table_find(mrt, "reason", reason)
+		if not idx then
+			return
+		end
+		local update = idx == #mrt
+		table.remove(mrt, idx)
+		if #mrt == 0 then
+			data[obj] = nil
+			DelayedCall(1000, ValidateColorReasons)
+			if not next(data) then
+				ColorModifierReasonsData = false
+			end
+		end
+		if update and not skip_color_change then
+			local active = mrt[#mrt]
+			local color = active and active.color or mrt.orig_color or const.clrNoModifier
+			SetColorModifier(obj, color)
+		end
+	end
+	if skip_attaches then
+		return
+	end
+	obj:ForEachAttach(ClearColorModifierReason, reason, skip_color_change)
+end
+
+function ClearColorModifierReasons(obj)
+	local data = ColorModifierReasonsData
+	local mrt = data and data[obj]
+	if not mrt then
+		return
+	end
+	if IsValid(obj) then
+		SetColorModifier(obj, mrt.orig_color or const.clrNoModifier)
+		obj:ForEachAttach(ClearColorModifierReasons)
+	end
+	data[obj] = nil
+end
+
+OnMsg.StartSaveGame = ValidateColorReasons
+	
+----
+
+MapVar("InvisibleReasons", {}, weak_keys_meta)
+
+local efVisible = const.efVisible
+
+function SetInvisibleReason(obj, reason)
+	local invisible_reasons = InvisibleReasons
+	local obj_reasons = invisible_reasons[obj]
+	if obj_reasons then
+		obj_reasons[reason] = true
+		return
+	end
+	invisible_reasons[obj] = { [reason] = true }
+	obj:ClearHierarchyEnumFlags(efVisible)
+end
+
+function ClearInvisibleReason(obj, reason)
+	local invisible_reasons = InvisibleReasons
+	local obj_reasons = invisible_reasons[obj]
+	if not obj_reasons or not obj_reasons[reason] then
+		return
+	end
+	obj_reasons[reason] = nil
+	if next(obj_reasons) then
+		return
+	end
+	invisible_reasons[obj] = nil
+	obj:SetHierarchyEnumFlags(efVisible)
+end
+
+function ClearInvisibleReasons(obj)
+	local invisible_reasons = InvisibleReasons
+	if not invisible_reasons[obj] then
+		return
+	end
+	invisible_reasons[obj] = nil
+	obj:SetHierarchyEnumFlags(efVisible)
+end
+
+----

CommonLua/Classes/Colorization.lua

@@ -0,0 +1,854 @@
+if FirstLoad then
+	g_DefaultColorsPalette = "Default colors"
+end
+
+local prop_cat = "Colorization Palette"
+
+DefineClass.ColorizableObject = {
+	__parents = { "PropertyObject" },
+	flags = { cofComponentColorizationMaterial = true },
+	properties = {
+		{ category = "Colorization Palette", id = "ColorizationPalette", name = "Colorization Palette",
+			editor = "choice",
+			default = g_DefaultColorsPalette,
+			preset_class = "ColorizationPalettePreset", -- For GedRpcEditPreset
+			items = function(self)
+				-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+				if not IsValid(self) then
+					return false
+				end
+				
+				local entity = self:GetEntity() ~= "" and self:GetEntity() or self.class
+				local palettes = g_EntityToColorPalettes_Cache[entity]
+				palettes = palettes and table.map(palettes, function(pal) return pal.PaletteName end) or {}
+				palettes[#palettes + 1] = g_DefaultColorsPalette
+				palettes[#palettes + 1] = ""
+				return palettes
+			end,
+			no_edit = function(self)
+				return self:ColorizationPropsNoEdit("palette") and true
+			end,
+			dont_save = function(self)
+				return self:ColorizationPropsDontSave("palette") and true
+			end,
+			read_only = function(self)
+				return self:ColorizationReadOnlyReason("palette") and true
+			end,
+			buttons = {{
+				name = "Edit",
+				is_hidden = function(self)
+					return not IsValid(self) or self:GetColorizationPalette() == ""
+				end,
+				-- Open the editor which can edit the colors currently used on the object
+				func = function(self, root, prop_id, socket)
+					local palette_value = self:GetColorizationPalette()
+					local preset_obj
+					
+					if palette_value == "" then return end
+					
+					-- If palette is "Default colors" => open Art Spec editor
+					if palette_value == g_DefaultColorsPalette then
+						local entity = self:GetEntity() ~= "" and self:GetEntity() or self.class
+						
+						ForEachPreset("EntitySpec", function(preset)
+							if preset.id == entity then
+								preset_obj = preset
+								return "break"
+							end
+						end)
+						
+						local ged = OpenPresetEditor("EntitySpec")
+						if ged then
+							ged:SetSelection("root", PresetGetPath(preset_obj))
+						end
+						
+						return
+					end
+					
+					-- If palette is something else => open Colorization Palette editor
+					local select_idx
+					ForEachPreset("ColorizationPalettePreset", function(preset)
+						for idx, entry in ipairs(preset) do
+							if entry.class == "CPPaletteEntry" and entry.PaletteName == palette_value then
+								preset_obj = preset
+								select_idx = idx
+								return "break"
+							end
+						end
+					end)
+					
+					if not preset_obj then
+						return
+					end
+					
+					GedRpcEditPreset(socket, "SelectedObject", prop_id, preset_obj.id)
+					
+					local ged = FindPresetEditor("ColorizationPalettePreset")
+					if ged then
+						ged:SetSelection("SelectedPreset", { select_idx })
+					end
+				end
+			}}
+		},
+	},
+	env_colorized = false,
+}
+
+-- Returns if a given entity (by name) can be colorized through the Object editor
+local function CanEntityBeColorized(entity)
+	-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+	local entity_data = EntityData[entity]
+	if not entity_data then
+		return false
+	end
+	
+	return ColorizationMaterialsCount(entity) > 0 and not (entity_data.entity and entity_data.entity.env_colorized)
+end
+
+function ColorizableObject:CanBeColorized()
+	local entity = self:GetEntity() ~= "" and self:GetEntity() or self.class
+	return not self.env_colorized and CanEntityBeColorized(entity)
+end
+
+function ColorizableObject:GetColorizationPalette()
+	-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+	if not IsValid(self) then
+		return
+	end
+
+	-- Get the value from C++
+	return self:GetColorizationPaletteName()
+end
+
+function ColorizableObject:SetColorsFromTable(colors)
+	if colors.EditableColor1 then
+		self:SetEditableColor1(colors.EditableColor1)
+	end
+	if colors.EditableColor2 then
+		self:SetEditableColor2(colors.EditableColor2)
+	end
+	if colors.EditableColor3 then
+		self:SetEditableColor3(colors.EditableColor3)
+	end
+	
+	if colors.EditableRoughness1 then
+		self:SetEditableRoughness1(colors.EditableRoughness1)
+	end
+	if colors.EditableRoughness2 then
+		self:SetEditableRoughness2(colors.EditableRoughness2)
+	end
+	if colors.EditableRoughness3 then
+		self:SetEditableRoughness3(colors.EditableRoughness3)
+	end
+	
+	if colors.EditableMetallic1 then
+		self:SetEditableMetallic1(colors.EditableMetallic1)
+	end
+	if colors.EditableMetallic2 then
+		self:SetEditableMetallic2(colors.EditableMetallic2)
+	end
+	if colors.EditableMetallic3 then
+		self:SetEditableMetallic3(colors.EditableMetallic3)
+	end	
+end
+
+-- Colorizes the object with the colors from the palette with the given name
+-- name == "" or nil => apply previous palette colors
+-- name == "Default colors" => apply default entity colors
+function ColorizableObject:SetColorsByColorizationPaletteName(palette_name, previous_palette)
+	-- If we're removing the palette, set the colors to those from the previous palette so they can be easily adjusted
+	if not palette_name or palette_name == "" then
+		palette_name = previous_palette or ""
+	end
+	
+	if palette_name == g_DefaultColorsPalette then
+		-- Set to the Default entity colors defined in the Art Spec editor 
+		local default_colors = self:GetDefaultColorizationSet()
+		if default_colors then
+			self:SetColorsFromTable(default_colors)
+			return
+		end
+		
+		-- Set all the color properties to their default values from the prop meta
+		self:SetEditableColor1(self:GetDefaultPropertyValue("EditableColor1"))
+		self:SetEditableColor2(self:GetDefaultPropertyValue("EditableColor2"))
+		self:SetEditableColor3(self:GetDefaultPropertyValue("EditableColor3"))
+		
+		self:SetEditableRoughness1(self:GetDefaultPropertyValue("EditableRoughness1"))
+		self:SetEditableRoughness2(self:GetDefaultPropertyValue("EditableRoughness2"))
+		self:SetEditableRoughness3(self:GetDefaultPropertyValue("EditableRoughness3"))
+		
+		self:SetEditableMetallic1(self:GetDefaultPropertyValue("EditableMetallic1"))
+		self:SetEditableMetallic2(self:GetDefaultPropertyValue("EditableMetallic2"))
+		self:SetEditableMetallic3(self:GetDefaultPropertyValue("EditableMetallic3"))
+		return
+	end
+	
+	-- If not empty or default => find the palette colors and apply them on the object
+	local entity = self:GetEntity() ~= "" and self:GetEntity() or self.class
+	for _, palette in ipairs(g_EntityToColorPalettes_Cache[entity]) do
+		if palette.PaletteName == palette_name and palette.PaletteColors then
+			self:SetColorsFromTable(palette.PaletteColors)
+			break
+		end
+	end
+end
+
+local function real_set_modifier(object, setter, value, ...)
+	-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+	if IsValid(object) then
+		object[setter](object, value, ...)
+	end
+end
+
+function ColorizableObject:SetColorizationPalette(palette_name)
+	-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+	if not IsValid(self) then
+		return
+	end
+
+	palette_name = palette_name or ""
+	
+	-- Set the palette name in C++
+	self:SetColorizationPaletteName(palette_name)
+	
+	-- Apply the colors of the chosen palette
+	self:SetColorsByColorizationPaletteName(palette_name)
+end
+
+function ColorizableObject:ColorizationPropsNoEdit(i)
+	if type(i) == "number" then return i > self:GetMaxColorizationMaterials() end
+	return false
+end
+
+function ColorizableObject:GetMaxColorizationMaterials()
+	if not IsValid(self) or self.env_colorized then
+		return const.MaxColorizationMaterials
+	end
+	return Min(const.MaxColorizationMaterials, ColorizationMaterialsCount(self))
+end
+
+function ColorizableObject:OnEditorSetProperty(prop_id, old_value, ged, multi)
+	-- When pasting a color/roughness/metallic prop in the editor, remove the palette and keep the colors for edit
+	if string.match(prop_id, "Editable") and self:GetColorizationPalette() ~= "" then
+		local new_value = self:GetProperty(prop_id)
+		
+		-- Removing the palette will set the colors to the palette colors so we have to manually set the property again
+		self:SetColorizationPalette("")
+		self:SetProperty(prop_id, new_value)
+	end
+end
+
+function ColorizableObject:ColorizationReadOnlyReason(usage)
+	if IsValid(self) and self:GetParent() then
+		return "Object is an attached one. AutoAttaches are not persisted and colorization is either inherited from the parent or set explicitly in the AutoAttach editor."
+	end
+	
+	local palette_value = self:GetColorizationPalette()
+	if palette_value and palette_value ~= "" and usage ~= "palette" then
+		return "A Colorization Palette preset is chosen and the colors are loaded from there."
+	end
+	
+	if IsKindOf(self, "AppearanceObject") then
+		return "AppearanceObjects are managed in the Appearance Editor."
+	end
+	
+	return false
+end
+
+function ColorizableObject:ColorizationReadOnlyText()
+	local reason = self:ColorizationReadOnlyReason()
+	return reason and "Colorization is read only:\n"..reason
+end
+
+function ColorizableObject:ColorizationPropsDontSave(i)
+	local no_edit_result = self:ColorizationPropsNoEdit(i)
+	if no_edit_result then
+		return true
+	end
+	if self:ColorizationReadOnlyReason() then
+		return true -- if they are readonly they probably don't have to be saved(and are initialized by someone else)
+	end
+	if type(i) == "number" then
+		local palette_value = self:GetColorizationPalette()
+		if palette_value and palette_value ~= "" then
+			return true
+		end
+	end
+	return false
+end
+
+local default_color = const.ColorPaletteWhitePoint
+local default_roughness = 0
+local default_metallic = 0
+
+for i = 1, const.MaxColorizationMaterials or 0 do
+	local color = string.format("Color%d", i)
+	local roughness = string.format("Roughness%d", i)
+	local metallic = string.format("Metallic%d", i)
+	local color_prop = string.format("Editable%s", color)
+	local roughness_prop = string.format("Editable%s", roughness)
+	local metallic_prop = string.format("Editable%s", metallic)
+	local reset = string.format("ResetColorizationMaterial%d", i)
+	
+	_G[reset] = function(parentEditor, object, property, ...)
+		object:SetProperty(color_prop, default_color)
+		object:SetProperty(roughness_prop, default_roughness)
+		object:SetProperty(metallic_prop, default_metallic)
+		ObjModified(object)
+	end
+	
+	local no_edit = function(self)
+		return self:ColorizationPropsNoEdit(i) and true
+	end
+	local no_save = function(self)
+		return self:ColorizationPropsDontSave(i) and true
+	end
+	table.iappend( ColorizableObject.properties, {
+		{
+			id = color_prop,
+			category = prop_cat,
+			name = string.format("%d: Base Color", i),
+			editor = "color", default = default_color,
+			no_edit = no_edit,
+			dont_save = no_save,
+			alpha = false,
+			buttons = {{name = "Reset", func = reset, is_hidden = function(obj)
+				if IsKindOf(obj, "GedMultiSelectAdapter") then
+					for _, o in ipairs(obj.__objects) do
+						if IsKindOf(0, "ColorizableObject") and o:ColorizationReadOnlyReason() then
+							return true
+						end
+					end
+					return false
+				end
+				return obj:ColorizationReadOnlyReason()
+			end}},
+			autoattach_prop = true,
+			read_only = function(obj)
+				return obj:ColorizationReadOnlyReason() and true
+			end,
+			help = ColorizableObject.ColorizationReadOnlyText,
+		},
+		{
+			id = roughness_prop,
+			category = prop_cat,
+			name = string.format("%d: Roughness", i),
+			editor = "number", default = default_roughness, slider = true,
+			min = -128, max = 127,
+			no_edit = no_edit,
+			dont_save = no_save,
+			autoattach_prop = true,
+			read_only = function(obj)
+				return obj:ColorizationReadOnlyReason() and true
+			end,
+			help = ColorizableObject.ColorizationReadOnlyText,
+		},
+		{
+			id = metallic_prop,
+			category = prop_cat,
+			name = string.format("%d: Metallic", i),
+			editor = "number", default = default_metallic, slider = true,
+			min = -128, max = 127,
+			no_edit = no_edit,
+			dont_save = no_save,
+			autoattach_prop = true,
+			read_only = function(obj)
+				return obj:ColorizationReadOnlyReason() and true
+			end,
+			help = ColorizableObject.ColorizationReadOnlyText,
+		},
+	})
+	ColorizableObject[color_prop] = default_color
+	ColorizableObject[roughness_prop] = default_roughness
+	ColorizableObject[metallic_prop] = default_metallic
+	
+	local set_func_color = string.format("Set%s", color)
+	ColorizableObject["Set" .. color_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			object[color_prop] = property
+			return
+		end
+		
+		return object[set_func_color](object, property, ...)
+	end
+
+	local get_func_color = string.format("Get%s", color)
+	ColorizableObject["Get" .. color_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			return object[color_prop]
+		end
+		
+		return object[get_func_color](object)
+	end
+	
+	local set_func_roughness = string.format("Set%s", roughness)
+	ColorizableObject["Set" .. roughness_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			object[roughness_prop] = property
+			return
+		end
+		
+		return object[set_func_roughness](object, property, ...)
+	end
+
+	local get_func_roughness = string.format("Get%s", roughness)
+	ColorizableObject["Get" .. roughness_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			return object[roughness_prop]
+		end
+		
+		return object[get_func_roughness](object)
+	end
+	
+	local set_func_metallic = string.format("Set%s", metallic)
+	ColorizableObject["Set" .. metallic_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			object[metallic_prop] = property
+			return
+		end
+		
+		return object[set_func_metallic](object, property, ...)
+	end
+
+	local get_func_metallic = string.format("Get%s", metallic)
+	ColorizableObject["Get" .. metallic_prop] = function(object, property, ...)
+		-- Filters out ColorizationPropSet and EnvironmentColorEntry (and other descendants of ColorizableObject that are not CObjects)
+		if not IsValid(object) then
+			return object[metallic_prop]
+		end
+		
+		return object[get_func_metallic](object)
+	end
+end
+
+local function GeneratePropNames(prefixes, count)
+	local t = {}
+	for i = 1, count do
+		for _, prefix in ipairs(prefixes) do
+			table.insert(t, prefix .. i)
+		end
+	end
+	return t
+end
+
+local setter_names = GeneratePropNames({"SetEditableColor", "SetEditableRoughness", "SetEditableMetallic"}, const.MaxColorizationMaterials)
+local getter_names = GeneratePropNames({"GetEditableColor", "GetEditableRoughness", "GetEditableMetallic"}, const.MaxColorizationMaterials)
+local prop_names = GeneratePropNames({"EditableColor", "EditableRoughness", "EditableMetallic"}, const.MaxColorizationMaterials)
+local defaults = {}
+for i = 1, const.MaxColorizationMaterials do 
+	table.iappend(defaults, {default_color, default_roughness, default_metallic})
+end
+
+function ColorizableObject:AreColorsModified()
+	local count = const.MaxColorizationMaterials
+	for i = 1, count * 3 do
+		if not self:IsPropertyDefault(prop_names[i]) then
+			return true
+		end
+	end
+	return false
+end
+
+function SetColorizationNoSetter(dst, src)
+	local count = const.MaxColorizationMaterials
+	for i = 1, count * 3 do
+		local getter_name = getter_names[i]
+		local value = src[getter_name](src)
+		dst[prop_names[i]] = value
+	end
+end
+
+function SetColorizationNoGetter(dst, src)
+	local count = const.MaxColorizationMaterials
+	for i = 1, count * 3 do
+		local setter_name = setter_names[i]
+		local value = src[prop_names[i]]
+		dst[setter_name](dst, value)
+	end
+end
+
+
+function ColorizableObject:GetColorsAsTable()
+	if not self[getter_names[1]] then
+		return
+	end
+	local ret = nil
+	local count = self:GetMaxColorizationMaterials()
+	for i = 1, count * 3 do
+		local getter_name = getter_names[i]
+		local prop_name = prop_names[i]
+		local value = self[getter_name](self)
+		if value ~= defaults[i] then
+			ret = ret or {}
+			ret[prop_name] = value
+		end
+	end
+	
+	return ret
+end
+
+
+function ColorizableObject:SetColorization(obj, ignore_his_max)
+	if obj then
+		if not obj[getter_names[1]] then
+			self:SetColorizationPalette(obj["ColorizationPalette"] or "")
+			SetColorizationNoGetter(self, obj)
+			return
+		end
+		local his_max = IsKindOf(obj, "ColorizableObject") and obj:GetMaxColorizationMaterials() or const.MaxColorizationMaterials
+		local count = not ignore_his_max and Min(self:GetMaxColorizationMaterials(), his_max) or self:GetMaxColorizationMaterials()
+		self:SetColorizationPalette(obj:GetColorizationPalette() or "")
+		for i = 1, count * 3 do
+			local setter_name = setter_names[i]
+			local getter_name = getter_names[i]
+			local value = obj[getter_name](obj)
+			self[setter_name](self, value)
+		end
+	else
+		self:SetColorizationPalette("")
+		local count = self:GetMaxColorizationMaterials()
+		for i = 1, count * 3 do
+			self[ setter_names[i] ] ( self, defaults[i] )
+		end
+	end
+end
+
+function ColorizableObject:SetMaterialColor(idx, value)    self[setter_names[idx * 3 - 2]](self, value) end
+function ColorizableObject:SetMaterialRougness(idx, value) self[setter_names[idx * 3 - 1]](self, value) end
+function ColorizableObject:SetMaterialMetallic(idx, value) self[setter_names[idx * 3]]    (self, value) end
+
+function ColorizableObject:GetMaterialColor(idx, value)    return self[getter_names[idx * 3 - 2]](self, value) end
+function ColorizableObject:GetMaterialRougness(idx, value) return self[getter_names[idx * 3 - 1]](self, value) end
+function ColorizableObject:GetMaterialMetallic(idx, value) return self[getter_names[idx * 3]]    (self, value) end
+
+if Platform.developer then
+	if FirstLoad then
+		ColorizationMatrixObjects = {}
+	end
+	function CreateGameObjectColorizationMatrix()
+		for key, value in ipairs(ColorizationMatrixObjects) do
+			DoneObject(value)
+		end
+		ColorizationMatrixObjects = {}
+
+		local selected = editor.GetSel()
+		if not selected or #selected == 0 then
+			print("Please, select a valid object.")
+			return false
+		end
+
+		local first = selected[1]
+		if not IsValid(first) then
+			print("Object was invalid.")
+			return false
+		end
+		local width = first:GetEntityBBox():sizex()
+		local length = first:GetEntityBBox():sizey()
+
+		local start_pos = first:GetPos()
+		local colors = { RGB(0, 0, 0), RGB(200, 200, 200), RGB(100, 100, 100), RGB(120, 10, 10), RGB(10, 120, 10), RGB(10, 10, 120), RGB(90, 90, 30), RGB(90, 30, 90), RGB(30, 90, 90) }
+		local roughness_metallic = { point(0, 0), point(-80, 0), point(0, -80), point(80, 0), point(0, 80), point(80, 80), point(-80, -80) }
+		for x, rm in ipairs(roughness_metallic) do
+			for idx, color in ipairs(colors) do
+				local obj = PlaceObject("Shapeshifter")
+				obj:ChangeEntity(first:GetEntity())
+				obj:SetPos(start_pos + point(x * width, idx * length))
+				for c = 1, const.MaxColorizationMaterials do
+					local method_name =  "SetEditableColor" .. c
+					obj[method_name](obj, colors[((idx + c - 2) % #colors) + 1])
+					method_name = "SetEditableRoughness" .. c
+					obj[method_name](obj, rm:x())
+					method_name = "SetEditableMetallic" .. c
+					obj[method_name](obj, rm:y())
+				end
+				table.insert(ColorizationMatrixObjects, obj)
+			end
+		end
+	end
+end
+
+
+
+DefineClass.ColorizationPropSet = {
+	__parents = {"ColorizableObject"},
+}
+
+function ColorizationPropSet:GetEditorView()
+	local clrs = {}
+	local count = self:GetMaxColorizationMaterials()
+	for i=1,count do
+		local color_get = string.format("GetEditableColor%d", i)
+		local color = self[color_get] and self[color_get](self)
+		local r, g, b = GetRGB(color)
+		clrs[#clrs + 1] = string.format("<color %d %d %d>C%d</color>", r, g, b, i)
+	end
+	return Untranslated(table.concat(clrs, " "))
+end
+
+function ColorizationPropSet:Clone()
+	local result = g_Classes[self.class]:new({})
+	result:CopyProperties(self)
+	result:SetColorization(self)
+	return result
+end
+
+function ColorizationPropSet:OnEditorSetProperty(prop_id, old_value, ged)
+	-- TODO: this should be a native ged functionality - modifying props with sub objects have to notify the prop owner as well
+	local parent = ged.selected_object
+	if not parent then return end
+	local list, parent_prop_id = parent:FindSubObjectLocation(self)
+	if list ~= parent then return end
+	return parent:OnEditorSetProperty(parent_prop_id, nil, ged)
+end
+
+function ColorizationPropSet:GetError()
+	if not AreBinAssetsLoaded() then
+		return "Entities not loaded yet - load a map to edit colors."
+	end
+end
+
+function ColorizationPropSet:EqualsByValue(other)
+	if rawequal(self, other) then return true end
+	
+	if not IsKindOf(self, "ColorizationPropSet") then
+		return false
+	end
+	if not IsKindOf(other, "ColorizationPropSet") then
+		return false
+	end
+	for i = 1, const.MaxColorizationMaterials or 0 do
+		local color_get = string.format("GetEditableColor%d", i)
+		local roughness_get = string.format("GetEditableRoughness%d", i)
+		local metallic_get = string.format("GetEditableMetallic%d", i)
+		
+		if self[color_get] and other[color_get] and self[color_get](self) ~= other[color_get](other) then
+			return false
+		end
+		if self[roughness_get] and other[roughness_get] and self[roughness_get](self) ~= other[roughness_get](other) then
+			return false
+		end
+		if self[metallic_get] and other[metallic_get] and self[metallic_get](self) ~= other[metallic_get](other) then
+			return false
+		end
+	end
+	return true
+end
+
+ColorizationPropSet.__eq = ColorizationPropSet.EqualsByValue
+
+
+function GetEnvColorizedGroups() -- Stub
+	return {}
+end
+
+function EnvColorizedTerrainColor(terrain_obj) -- Called from C
+	local color_mod = terrain_obj.color_modifier
+	return color_mod
+end
+
+local function GetDefaultColorizationSet(entity_name)
+	if not entity_name then return end
+	local entity_data = EntityData[entity_name]
+	if not entity_data then return end
+	local default_colors = entity_data.default_colors
+	if default_colors and next(default_colors) then
+		return default_colors
+	end
+end
+ColorizableObject.GetDefaultColorizationSet = function(obj) return GetDefaultColorizationSet(obj:GetEntity()) end
+
+if Platform.developer then
+	function OnMsg.EditorCallback(id, objects, reason)
+		if (id == "EditorCallbackPlace" or id == "EditorCallbackPlaceCursor")
+			and reason ~= "undo"
+		then
+			for i = 1, #objects do
+				local obj = objects[i]
+				-- NOTE: Light should not be ColorizableObject since it treats its Color properties differently
+				--		so we ignore them here because the palette will overwrite their copy/pasted colors
+				local colorizable = obj and IsKindOf(obj, "ColorizableObject") and not IsKindOf(obj, "Light")
+				if colorizable and not obj:ColorizationReadOnlyReason("palette") and obj:GetColorizationPaletteName() == g_DefaultColorsPalette then
+					-- Newly placed objects have the "Default colors" color palette
+					-- which inherits the Default colors from the Art spec editor
+					obj:SetColorizationPalette(g_DefaultColorsPalette)
+				end
+			end
+		end
+	end
+end
+
+-- Applies the latest colors to objects with a chosen palette when the ColorizationPalettePreset is saved
+-- This allows the person creating new palettes to immediately see how the latest colors look on the object
+local function ApplyLatestColorPalettes()
+	if GetMap() == "" then return end
+	MapForEach("map", "CObject", function(obj)
+		local palette_value = obj:GetColorizationPalette()
+		if palette_value and palette_value ~= "" then
+			obj:SetColorsByColorizationPaletteName(palette_value)
+		end
+	end)
+end
+
+if FirstLoad then
+	g_EntityToColorPalettes_Cache = {} -- for preset dropdown in entity object editor
+end
+
+DefineClass.ColorizationPalettePreset = {
+	__parents = { "Preset" },
+	properties = {},
+	
+	GlobalMap = "ColorizationPalettePresets",
+	EditorMenubarName = "Colorization Palettes Editor",
+	EditorMenubar = "Editors.Art",
+	EditorIcon = "CommonAssets/UI/Icons/colour creativity palette.png",
+	
+	ContainerClass = "CPEntry",
+	--ValidateAfterSave = true,
+}
+
+-- CP = ColorizationPalette
+DefineClass.CPEntry = {
+	__parents = { "InitDone" },
+}
+
+DefineClass.CPPaletteEntry = {
+	__parents = { "CPEntry" },
+	
+	properties = {
+		{ id = "PaletteName", name = "Palette Name", editor = "text", default = false  },
+		{ id = "PaletteColors", name = "Color Palette", editor = "nested_obj", base_class = "ColorizationPropSet", auto_expand = true, inclusive = true, default = false,  },
+	},
+	
+	EditorView = Untranslated("<color 0 143 0>Palette</color> - <PaletteName> <GetColorsPreviewString>")
+}
+
+function CPPaletteEntry:OnEditorSetProperty(prop_id, old_value, ged)
+	-- Called by ColorizationPropSet:OnEditorSetProperty
+	ApplyLatestColorPalettes()
+end
+
+function CPPaletteEntry:GetColorsPreviewString()
+	if not self.PaletteColors then
+		return ""
+	end
+
+	local c1, c2, c3 = "", "", ""
+	
+	if self.PaletteColors.EditableColor1 then
+		local r, g, b = GetRGB(self.PaletteColors.EditableColor1)
+		c1 = string.format("<color %s %s %s>C1</color>", r, g, b)
+	end
+	if self.PaletteColors.EditableColor2 then
+		local r, g, b = GetRGB(self.PaletteColors.EditableColor2)
+		c2 = string.format("<color %s %s %s>C2</color>", r, g, b)
+	end
+	if self.PaletteColors.EditableColor3 then
+		local r, g, b = GetRGB(self.PaletteColors.EditableColor3)
+		c3 = string.format("<color %s %s %s>C3</color>", r, g, b)
+	end
+	
+	return string.format("- %s %s %s", c1, c2, c3)
+end
+
+local function GetColorizableEntities()
+	local result = {}
+	for entity_name, entity_data in pairs(EntityData) do
+		if CanEntityBeColorized(entity_name) then
+			result[#result + 1] = entity_name
+		end
+	end
+	return result
+end
+
+DefineClass.CPEntityEntry = {
+	__parents = { "CPEntry" },
+	
+	properties = {
+		{ id = "ForEntity", name = "For Entity", editor = "choice", items = GetColorizableEntities, default = false  },
+	},
+	
+	EditorView = Untranslated("<color 143 0 0>Entity</color> - <ForEntity>")
+}
+
+
+local function RebuildCPMappingCaches()
+	g_EntityToColorPalettes_Cache = {}
+	
+	-- Rebuild the mapping caches
+	ForEachPreset("ColorizationPalettePreset", function(preset)
+		local palette_names = {}
+		local palettes = {}
+		local entities = {}
+		for _, entry in ipairs(preset) do
+			if entry.class == "CPPaletteEntry" and entry.PaletteName and entry.PaletteColors then
+				palettes[#palettes + 1] = entry
+			elseif entry.class == "CPEntityEntry" and entry.ForEntity then
+				entities[#entities + 1] = entry
+			end
+		end
+		
+		for _, entity in ipairs(entities) do
+			g_EntityToColorPalettes_Cache[entity.ForEntity] = palettes
+		end
+	end)
+end
+
+function OnMsg.PresetSave(class)
+	local classdef = g_Classes[class]
+	if IsKindOf(classdef, "ColorizationPalettePreset") then
+		RebuildCPMappingCaches()
+		ApplyLatestColorPalettes()
+	elseif IsKindOf(classdef, "EntitySpec") then
+		ApplyLatestColorPalettes()
+	end
+end
+-- Initial Presets load
+OnMsg.DataLoaded = RebuildCPMappingCaches
+-- Presets reload
+OnMsg.DataReloadDone = RebuildCPMappingCaches
+
+
+-- Colorizes objects on map load based on default colors as setters were not called!
+function OnMsg.NewMapLoaded()
+	MapForEach("map", "Object", const.efRoot, function(obj)
+		-- Skip objects that can't be colorized (EnvColorized or have no Colorization Materials)
+		if not obj:CanBeColorized() then
+			return
+		end
+		-- Only g_DefaultColorsPalette colors were not updated!
+		local palette_value = obj:GetColorizationPalette()
+		if palette_value == g_DefaultColorsPalette then
+			obj:SetColorsByColorizationPaletteName(palette_value)
+		end
+	end)
+end
+
+-- called by C when initializing CObjects with palettes
+function GetColorsByColorizationPaletteName(entity, palette_value)
+	if palette_value == g_DefaultColorsPalette then
+		-- Set to the Default entity colors defined in the Art Spec editor 
+		local default_colors = GetDefaultColorizationSet(entity)
+		if default_colors then
+			return RGBRM(default_colors.EditableColor1, default_colors.EditableRoughness1, default_colors.EditableMetallic1),
+				RGBRM(default_colors.EditableColor2, default_colors.EditableRoughness2, default_colors.EditableMetallic2),
+				RGBRM(default_colors.EditableColor3, default_colors.EditableRoughness3, default_colors.EditableMetallic3)
+		end
+
+	end
+	
+	-- If not empty or default => find the palette colors and apply them on the object
+	for _, palette in ipairs(g_EntityToColorPalettes_Cache[entity] or empty_table) do
+		if palette.PaletteName == palette_name and palette.PaletteColors then
+			local colors = palette.PaletteColors
+			return RGBRM(colors.EditableColor1, colors.EditableRoughness1, colors.EditableMetallic1),
+				RGBRM(colors.EditableColor2, colors.EditableRoughness2, colors.EditableMetallic2),
+				RGBRM(colors.EditableColor3, colors.EditableRoughness3, colors.EditableMetallic3)
+		end
+	end
+end

CommonLua/Classes/CommandObject.lua

@@ -0,0 +1,704 @@
+local DebugCommand = (Platform.developer or Platform.asserts) and not Platform.console
+local Trace_SetCommand = DebugCommand and "log"
+
+local CommandImportance = const.CommandImportance or empty_table
+local WeakImportanceThreshold = CommandImportance.WeakImportanceThreshold
+
+--[[@@@
+@class CommandObject
+It is often necessary to ensure that an object is doing one thing – and one thing only. The command system is used to accomplish just that.
+
+A CommandObject has a single thread executing its current command (if any). A command is just a function. When the current command finishes (the function returs), the current command changes to "Idle". A call to SetCommand (or a similar function) interrupts the currently executed command (deletes the thread) and creates a new thread to run the new command.
+
+For example, imagine a `Citizen` called Hulio who is walking to work and gets murdered by a `Soldier`. We'd like to have Hulio fall on the ground – dead – and interrupt his workday for good. 
+
+~~~~ Lua
+  -- This sets Hulio's command to "CmdGoWork"
+  function Citizen:FindWork()
+    ...
+    self:SetCommand("CmdGoWork", workplace)
+  end
+
+  -- This is called by the soldier who will kill Hulio
+  function Soldier:DoKill(obj)
+    ...
+    if not IsDead(obj) then
+      -- This cancels Hulio's "GoWork" command
+      obj:SetCommand("CmdGoDie", "Eliminated")
+    end
+  end
+~~~~
+
+
+## Destructors
+
+When a command gets interrupted, the object can remain in an unpredictable state. Destructors solve that problem.
+
+Each command or a function called from a command can push one or more destructors and *must* later pop them. If the command gets interrupted, any active destructors get executed from the most recently pushed one to the oldest one.
+
+~~~~ Lua
+  function Citizen:CmdUseWaterDispenser(dispencer)
+    assert(dispencer.in_use == false)
+    dispencer.in_use = true
+    self:PushDestructor(function(self) -- run this in case someone interrupts the Citizen (e.g. kidnaps him) while using the dispenser
+      dispenser.in_use = false
+    end)
+    self:Goto(dispenser) -- Goto probably pushes (and pops) its own destructor
+    self:SetAnim("UseWaterDispenser")
+    Sleep(self:TimeToAnimEnd())
+    self:PopAndCallDestructor() -- removes and executes the destuctor above, which will get also executed if the command is interrupted before reaching this code
+  end
+~~~~
+
+
+## Importance of commands
+
+A CommandObject can execute hundreds of different commands it is quite difficult to figure out if an event should interrupt the current command or not.
+
+We assign *importance* to each command - a number in most cases taken from const.CommandImportance[command], although some functions take *importance* as a parameter.
+This allows us to implement methods such as TrySetCommand(cmd, ...) and CanInterruptCommand(cmd).
+
+For example, if a stone hits a Citizen going to work, the Citizen should hold his head and scream with pain. If the Citizen is unconscious, nothing should happen. Command importance provides an elegant way to do that.
+
+~~~~ Lua
+    -- a stone has hit a citizen
+    citizen:TrySetCommand("CmdInPain") -- will be set only if running a less important command than CmdInPain
+~~~~
+
+In the example above, if CmdGoDie has higher importance than CmdInPain (as it should) it will not be interrupted while CmdUseWaterDispenser will be correctly interrupted.
+
+## Queue
+
+Commands can be queued for execution after the current command completes. 
+
+For example, a unit should complete something important (run from an enemy) and then return to whatever it was doing.
+
+Another example is when the player has given a unit several commands to execute in order: kill this guy then kill that guy then return to the base for repairs.
+
+--]]
+DefineClass.CommandObject =
+{
+	__parents = { "InitDone" },
+
+	command = false,
+	command_queue = false,
+	dont_clear_queue = false,
+	command_destructors = false,
+	command_thread = false,
+	thread_running_destructors = false,
+	command_call_stack = false,
+	forced_cmd_importance = false,
+	trace_setcmd = Trace_SetCommand,
+	last_error_time = false,
+	uninterruptable_importance = false,
+
+	CreateThread = CreateGameTimeThread,
+	IsValid = IsValid,
+}
+
+DefineClass.RealTimeCommandObject =
+{
+	__parents = { "CommandObject" },
+	
+	CreateThread = CreateRealTimeThread,
+	IsValid = function() return true end,
+	NetUpdateHash = function () end,
+}
+
+function RealTimeCommandObject:Done()
+	self.IsValid = empty_func
+end
+
+--[[@@@
+When deleted, the command object interrupts the currently executed command. All present destructors will be called in another thread.
+@function void CommandObject:Done()
+--]]
+function CommandObject:Done()
+	if self.command and CurrentThread() ~= self.command_thread then
+		self:SetCommand(false)
+	end
+	self.command_queue = nil
+end
+
+function CommandObject:Idle()
+	self[false](self)
+end
+
+function CommandObject:CmdInterrupt()
+end
+
+CommandObject[false] = function(self)
+	self.command = nil
+	self.command_thread = nil
+	self.command_destructors = nil
+	self.thread_running_destructors = nil
+	Halt()
+end
+
+--[[@@@
+Called whenever a new command starts executing. It might be faster to do some simple cleanup here instead of pushing a destructor often.
+@function void CommandObject:OnCommandStart()
+--]]
+AutoResolveMethods.OnCommandStart = true
+CommandObject.OnCommandStart = empty_func
+
+local SetCommandErrorChecks = empty_func
+local SleepOnInfiniteLoop = empty_func
+
+local function GetNextDestructor(obj, destructors)
+	local count = destructors[1]
+	if count == 0 then
+		return empty_func
+	end
+	local dstor = destructors[count + 1]
+	destructors[count + 1] = false
+	destructors[1] = count - 1
+	
+	if type(dstor) == "string" then
+		assert(obj[dstor], string.format("Missing destructor: %s.%s", obj.class, dstor))
+		dstor = obj[dstor] or empty_func
+	elseif type(dstor) == "table" then
+		assert(type(dstor[1]) == "string")
+		assert(obj[dstor[1]], string.format("Missing destructor: %s.%s", obj.class, dstor[1]))
+		assert(#dstor == table.maxn(dstor)) -- make sure table.unpack works properly
+		return obj[dstor[1]] or empty_func, obj, table.unpack(dstor, 2)
+	end
+	return dstor, obj
+end
+
+local function CommandThreadProc(self, command, ...)
+	dbg(SleepOnInfiniteLoop(self))
+	
+	-- wait the thread calling destructors to finish
+	local destructors = self.command_destructors
+	local thread_running_destructors = self.thread_running_destructors
+	if thread_running_destructors then
+		while IsValidThread(self.thread_running_destructors) and not WaitMsg(destructors, 100) do
+		end
+	end
+	local thread = CurrentThread()
+	if self.command_thread ~= thread then return end
+	assert(not self.uninterruptable_importance)
+	assert(not self.thread_running_destructors)
+
+	local command_func = type(command) == "function" and command or self[command]
+	local packed_command
+	while true do
+	
+		if destructors and destructors[1] > 0 then
+			self.thread_running_destructors = thread
+			while destructors[1] > 0 do
+				sprocall(GetNextDestructor(self, destructors))
+			end
+			self.thread_running_destructors = false
+			if self.command_thread ~= thread then
+				Msg(destructors)
+				return
+			end
+		end
+		if not self:IsValid() then
+			return
+		end
+
+		self:NetUpdateHash("Command", type(command) == "function" and "function" or command, ...)
+		self:OnCommandStart()
+		local success, err
+		if packed_command == nil then
+			success, err = sprocall(command_func, self, ...)
+		else
+			success, err = sprocall(command_func, self, unpack_params(packed_command, 3))
+		end
+		assert(self.command_thread == thread)
+		if not success and not IsBeingDestructed(self) then
+			if self.last_error_time == now()  then
+				-- throttle in case of an error right after another error to avoid infinite loops
+				Sleep(1000)
+			end
+			self.last_error_time = now()
+		end
+		local forced_cmd_importance
+		local queue = self.command_queue
+		packed_command = queue and table.remove(queue, 1)
+		if packed_command then
+			if type(packed_command) == "table" then
+				forced_cmd_importance = packed_command[1] or nil
+				command = packed_command[2]
+			else
+				command = packed_command
+			end
+			command_func = type(command) == "function" and command or self[command]
+		else
+			dbg(not success or SetCommandErrorChecks(self, "->Idle", ...))
+			command = "Idle"
+			command_func = self.Idle
+		end
+		self.forced_cmd_importance = forced_cmd_importance
+		self.command = command
+		destructors = self.command_destructors
+	end
+	self.command_thread = nil
+end
+
+--[[@@@
+Changes the current command unconditionally. Any present destructors form the previous command will be called before executing it. The method can fail if the current command thread cannot be deleted. When invoked, the self is passed as a first param.
+@function bool CommandObject:SetCommand(string command, ...)
+@function bool CommandObject:SetCommand(function command_func, ...)
+@param string command - Name of the command. Should be an object's method name.
+@param function command_func - Alternatively, the command to execute can be provided as a function param.
+@result bool - Command change success. 
+--]]
+function CommandObject:SetCommand(command, ...)
+	return self:DoSetCommand(nil, command, ...)
+end
+
+-- Use with SetCommand or SetCommandImportance
+function CommandObject:DoSetCommand(importance, command, ...)
+	self:NetUpdateHash("SetCommand", type(command) == "function" and "function" or command, ...)
+	dbg(SetCommandErrorChecks(self, command, ...))
+	self.command = command or nil
+	if not self.dont_clear_queue then
+		self.command_queue = nil
+	end
+	self.dont_clear_queue = nil
+	local old_thread = self.command_thread
+	local new_thread = self.CreateThread(CommandThreadProc, self, command, ...)
+	self.command_thread = new_thread
+	self.forced_cmd_importance = importance or nil
+	ThreadsSetThreadSource(new_thread, "Command", command)
+	if old_thread == self.thread_running_destructors then
+		local uninterruptable_importance = self.uninterruptable_importance
+		if not uninterruptable_importance then
+			-- wait the current thread to finish destructor execution
+			return true
+		end
+		local test_importance = importance or CommandImportance[command or false] or 0
+		if uninterruptable_importance >= test_importance then
+			-- wait the current thread to finish uninterruptable execution
+			return true
+		end
+		self.uninterruptable_importance = false
+		self.thread_running_destructors = false
+	end
+	
+	DeleteThread(old_thread, true)
+	if old_thread == CurrentThread() then
+		-- the old thread failed to be deleted, revert!!!
+		DeleteThread(new_thread)
+		self.command_thread = old_thread
+		return false
+	end
+	return true
+end
+
+function CommandObject:TestInfiniteLoop()
+	self:SetCommand("TestInfiniteLoop2")
+end
+
+function CommandObject:TestInfiniteLoop2()
+	self:SetCommand("TestInfiniteLoop")
+end
+
+function CommandObject:GetCommandText()
+	return tostring(self.command)
+end
+
+local function IsCommandThread(self, thread)
+	thread = thread or CurrentThread()
+	return thread and (thread == self.command_thread or thread == self.thread_running_destructors)
+end
+CommandObject.IsCommandThread = IsCommandThread
+
+--[[@@@
+Pushes a destructor to be executed if the command is interrupted. The destructor stack is a LIFO structure. When invoked, the self is passed as a first param.
+@function int CommandObject:PushDestructor(function dtor)
+@function int CommandObject:PushDestructor(string dtor)
+@function int CommandObject:PushDestructor(table dtor)
+@param function dtor - Destructor function.
+@param string dtor - Destructor name. Should be an object's method name.
+@param table dtor - Destructor table, containing a method name and the params to be passed.
+@result number - The count of the destructors pushed in the destructor stack. 
+Example:
+~~~~
+	local orig_name = unit.name
+	unit:PushDestructor(function(unit)
+		unit.name = orig_name
+	end)
+~~~~
+--]]
+function CommandObject:PushDestructor(dtor)
+	assert(IsCommandThread(self))
+	local destructors = self.command_destructors
+	if destructors then
+		destructors[1] = destructors[1] + 1
+		destructors[destructors[1] + 1] = dtor
+		return destructors[1]
+	else
+		self.command_destructors = { 1, dtor }
+		return 1
+	end
+end
+
+--[[@@@
+Pops and calls the last pushed destructor to be executed if the command is interrupted.
+@function void CommandObject:PopAndCallDestructor(int check_count = false)
+@param int check_count - And optional param used to check for destructor stack consistency.
+--]]
+function CommandObject:PopAndCallDestructor(check_count)
+	local destructors = self.command_destructors
+	
+	assert(destructors and destructors[1] > 0)
+	assert(not check_count or check_count == destructors[1])
+	assert(IsCommandThread(self))
+	
+	local old_thread_running_destructors = self.thread_running_destructors
+	if not IsValidThread(old_thread_running_destructors) then
+		self.thread_running_destructors = CurrentThread()
+		assert(not old_thread_running_destructors)
+		old_thread_running_destructors = false
+	end
+	sprocall(GetNextDestructor(self, destructors))
+	
+	if not old_thread_running_destructors then
+		self.thread_running_destructors = false
+		if self.command_thread ~= CurrentThread() then
+			Msg(destructors)
+			Halt()
+		end
+	end
+end
+
+--[[@@@
+Same as PopAndCallDestructor but the destructor isn't invoked.
+@function void CommandObject:PopDestructor(int check_count)
+--]]
+function CommandObject:PopDestructor(check_count)
+	local destructors = self.command_destructors
+	
+	assert(destructors and destructors[1] > 0)
+	assert(not check_count or check_count == destructors[1])
+	assert(IsCommandThread(self))
+	
+	destructors[destructors[1] + 1] = false
+	destructors[1] = destructors[1] - 1
+end
+
+function CommandObject:GetDestructorsCount()
+	local destructors = self.command_destructors
+	return destructors and destructors[1] or 0
+end
+
+--[[@@@
+Executes a function, interruptable only by commands with higher importance than the specified one. The execution immitates a destructor call, meaning that if the new command fails to interrupt, that will happen immediately after the uninterruptable execution terminates. The self is pased as a first param when called.
+@function void CommandObject:ExecuteUninterruptableImportance(int importance, function func, ...)
+@function void CommandObject:ExecuteUninterruptableImportance(int importance, string method_name, ...)
+@param int importance - Command importance threshold.
+@param function func - Function to be executed.
+@param string method_name - Alternatively, the function to execute can be provided as a object's method name.
+--]]
+function CommandObject:ExecuteUninterruptableImportance(importance, func, ...)
+	local thread = CurrentThread()
+	local func_to_execute = type(func) == "function" and func or self[func]
+
+	if self.command_thread ~= thread or self.thread_running_destructors then
+		assert((self.uninterruptable_importance or max_int) >= (importance or max_int))
+		sprocall(func_to_execute, self, ...)
+		return
+	end
+	
+	local destructors = self.command_destructors
+	if not destructors then
+		-- the destructors table is needed to sync command threads
+		destructors = { 0 }
+		self.command_destructors = destructors
+	end
+	
+	self.uninterruptable_importance = importance
+	self.thread_running_destructors = thread
+
+	sprocall(func_to_execute, self, ...)
+	
+	self.uninterruptable_importance = false
+	self.thread_running_destructors = false
+	
+	if self.command_thread == thread then
+		return
+	end
+	
+	Msg(destructors)
+	Halt()
+end
+
+--[[@@@
+A shortcut to invoke [ExecuteUninterruptableImportance](#CommandObject:ExecuteUninterruptableImportance) with maximum importance, disallowing interruption by any commands
+@function void CommandObject:ExecuteUninterruptable(function func, ...)
+--]]
+function CommandObject:ExecuteUninterruptable(func, ...)
+	return self:ExecuteUninterruptableImportance(nil, func, ...)
+end
+
+--[[@@@
+A shortcut to invoke [ExecuteUninterruptableImportance](#CommandObject:ExecuteUninterruptableImportance) with WeakImportanceThreshold, allowing interruption by all commands with higher importance.
+@function void CommandObject:ExecuteWeakUninterruptable(function func, ...)
+--]]
+function CommandObject:ExecuteWeakUninterruptable(func, ...)
+	assert(WeakImportanceThreshold)
+	return self:ExecuteUninterruptableImportance(WeakImportanceThreshold, func, ...)
+end
+
+function CommandObject:IsIdleCommand()
+	return (self.command or "Idle") == "Idle"
+end
+
+local function InsertCommand(self, index, forced_importance, command, ...)
+	if self:IsIdleCommand() then
+		return self:SetCommand(command, ...)
+	end
+	local packed_command = not forced_importance and count_params(...) == 0 and command or pack_params(forced_importance or false, command or false, ...)
+	local queue = self.command_queue
+	if not queue then
+		self.command_queue = { packed_command }
+	else
+		if index then
+			table.insert(queue, index, packed_command)
+		else
+			queue[#queue + 1] = packed_command
+		end
+	end
+end
+
+-- queue command to be executed after the current and all other queued commands complete
+function CommandObject:QueueCommand(command, ...)
+	return InsertCommand(self, false, false, command, ...)
+end
+
+function CommandObject:QueueCommandImportance(forced_importance, command, ...)
+	return InsertCommand(self, false, forced_importance, command, ...)
+end
+
+-- insert command at the specified place in the queue to be executed right after the current one completes
+-- this is often used with 1 to place a command to be executed ASAP before continuing with the rest of the queue
+function CommandObject:InsertCommand(index, forced_importance, command, ...)
+	return InsertCommand(self, index, forced_importance, command, ...)
+end
+
+-- Like setcommand, but without clearing the queue. Useful when we want current command to terminate immediately, 
+-- regardless of current stack position, start the new command and preserve the queue.
+function CommandObject:SetCommandKeepQueue(command, ...)
+	self.dont_clear_queue = true
+	self:SetCommand(command, ...)
+end
+
+function CommandObject:HasCommandsInQueue()
+	return #(self.command_queue or "") > 0
+end
+
+function CommandObject:ClearCommandQueue()
+	self.command_queue = nil
+end
+
+
+----- Command importance
+
+function CommandObject:GetCommandImportance(command)
+	if not command then
+		return self.forced_cmd_importance or CommandImportance[self.command]
+	else
+		return CommandImportance[command or false]
+	end
+end
+
+--[[@@@
+Checks if the current command can be changed by the given one.
+@function bool CommandObject:CanSetCommand(string command, int importance = false)
+@param string command - Name of the command to test.
+@param int importance - Optional custom importance.
+@result bool - Command change test success. 
+--]]
+function CommandObject:CanSetCommand(command, importance)
+	assert(not importance or type(importance) == "number")
+	local current_importance = self.forced_cmd_importance or CommandImportance[self.command] or 0
+	importance = importance or CommandImportance[command or false] or 0
+	return current_importance <= importance
+end
+
+--[[@@@
+Same as [SetCommand](#CommandObject:SetCommand) but may fail if the current command has a higher importance.
+@function bool CommandObject:TrySetCommand(string command, ...)
+--]]
+function CommandObject:TrySetCommand(cmd, ...)
+	if not self:CanSetCommand(cmd) then
+		return
+	end
+	return self:SetCommand(cmd, ...)
+end
+
+--[[@@@
+Same as [SetCommand](#CommandObject:SetCommand) but a custom importance is forced. The command importances are specified in the CommandImportance const group.
+@function bool CommandObject:SetCommandImportance(int importance, string command, ...)
+@param int importance - A custom importance to replace the default command importance.
+--]]
+function CommandObject:SetCommandImportance(importance, cmd, ...)
+	assert(not importance or type(importance) == "number")
+	return self:DoSetCommand(importance or nil, cmd, ...)
+end
+
+--[[@@@
+See [SetCommandImportance](#CommandObject:SetCommandImportance), [TrySetCommand](#CommandObject:TrySetCommand)
+@function bool CommandObject:TrySetCommandImportance(int importance, string command, ...)
+--]]
+function CommandObject:TrySetCommandImportance(importance, cmd, ...)
+	if not self:CanSetCommand(cmd, importance) then
+		return
+	end
+	return self:SetCommandImportance(importance, cmd, ...)
+end
+
+function CommandObject:ExecuteInCommand(method_name, ...)
+	if CanYield() and IsCommandThread(self) then
+		self[method_name](self, ...)
+		return true
+	end
+	return self:TrySetCommand(method_name, ...)
+end
+
+SuspendCommandObjectInfiniteChangeDetection = empty_func
+ResumeCommandObjectInfiniteChangeDetection = empty_func
+
+----
+
+if DebugCommand then
+
+CommandObject.command_change_prev = false
+CommandObject.command_change_count = 0
+CommandObject.command_change_gtime = 0
+CommandObject.command_change_rtime = 0
+CommandObject.command_change_loops = 0
+
+local lCommandChangeLoopDetection = true
+
+function SuspendCommandObjectInfiniteChangeDetection()
+	lCommandChangeLoopDetection = false
+end
+
+function ResumeCommandObjectInfiniteChangeDetection()
+	lCommandChangeLoopDetection = true
+end
+
+local infinite_command_changes = 10
+
+SleepOnInfiniteLoop = function(self)
+	if not lCommandChangeLoopDetection then return end
+
+	local rtime, gtime = RealTime(), GameTime()
+	if self.command_change_rtime ~= rtime or self.command_change_gtime ~= gtime then
+		self.command_change_rtime = rtime -- real time to avoid false positive on paused game
+		self.command_change_gtime = gtime -- game time to avoid false positive on falling behind gametime
+		self.command_change_count = nil
+		return
+	end
+	local command_change_count = self.command_change_count
+	if command_change_count <= infinite_command_changes then
+		self.command_change_count = command_change_count + 1
+		return
+	end
+	self.command_change_loops = self.command_change_loops + 1
+	Sleep(50 * self.command_change_loops)
+	self.command_change_count = nil
+end
+
+SetCommandErrorChecks = function(self, command, ...)
+	local destructors = self.command_destructors
+	local prev_command = self.command
+	if command == "->Idle" and destructors and destructors[1] > 0 then -- the command should pop all its destructors
+		print("Command", self.class .. "." .. tostring(prev_command), "remaining destructors:")
+		for i = 1,destructors[1] do
+			local destructor = destructors[i + 1]
+			if type(destructor) == "string" then
+				printf("\t%d. %s.%s", i, self.class, destructor)
+			elseif type(destructor) == "table" then
+				printf("\t%d. %s.%s", i, self.class, destructor[1])
+			else
+				local info = debug.getinfo(destructor, "S") or empty_table
+				local source = info.source or "Unknown"
+				local line = info.linedefined or -1
+				printf("\t%d. %s(%d)", i, source, line)
+			end
+		end
+		error(string.format("Command %s.%s did not pop its destructors.", self.class, tostring(self.command)), 2)
+		-- remove the remaining destructors to avoid having the error all the time
+		while destructors[1] > 0 do
+			self:PopDestructor()
+		end
+	end
+	if command and command ~= "->Idle" then
+		if type(command) ~= "function" and not self:HasMember(command) then
+			error(string.format("Invalid command %s:%s", self.class, tostring(command)), 3)
+		end
+		if IsBeingDestructed(self) then
+			error(string.format("%s:SetCommand('%s') called from Done() or delete()", self.class, tostring(command)), 3)
+		end
+	end
+	if command ~= "->Idle" or prev_command ~= "Idle" then
+		self.command_call_stack = GetStack(3)
+		if self.trace_setcmd then
+			if self.trace_setcmd == "log" then
+				self:Trace("SetCommand {1}", tostring(command), self.command_call_stack, ...)
+			else
+				error(string.format("%s:SetCommand(%s) time %d, old command %s", self.class, concat_params(", ", tostring(command), ...), GameTime(), tostring(self.command)), 3)
+			end
+		end
+	end
+	if self.command_change_count == infinite_command_changes then
+		assert(false, string.format("Infinite command change in %s: %s -> %s -> %s", self.class, tostring(self.command_change_prev), tostring(prev_command), tostring(command)))
+		--StoreErrorSource(self, "Infinite command change") Pause("Debug")
+	end
+	self.command_change_prev = prev_command
+end
+
+local function __DbgForEachMethod(passed, obj, callback, ...)
+	if not obj then
+		return
+	end
+	for name, value in pairs(obj) do
+		if type(value) == "function" and not passed[name] then
+			passed[name] = true
+			callback(name, value, ...)
+		end
+	end
+	return __DbgForEachMethod(passed, getmetatable(obj), callback, ...)
+end
+
+function DbgForEachMethod(obj, callback, ...)
+	return __DbgForEachMethod({}, obj, callback, ...)
+end
+
+function DbgBreakRemove(obj)
+	DbgForEachMethod(obj, function(name, value, obj)
+		obj[name] = nil
+	end, obj)
+end
+
+function DbgBreakSchedule(obj, methods)
+	DbgBreakRemove(obj)
+	if methods == "string" then methods = { methods } end
+	DbgForEachMethod(obj, function(name, value, obj)
+		if not methods or table.find(methods, name) then
+			local new_value = function(...)
+				if IsCommandThread(obj) then
+					DbgBreakRemove(obj)
+					print("Break removed")
+					bp(true, 1) 
+				end
+				return value(...)
+			end
+			obj[name] = new_value
+		end
+	end, obj)
+	print("Break schedule")
+end
+
+function CommandObject:AsyncCheatDebugger()
+	DbgBreakSchedule(self)
+end
+
+end -- DebugCommand

CommonLua/Classes/Common.lua

@@ -0,0 +1,74 @@
+DefineClass.CameraFacingObject = {
+	__parents = { "CObject", "ComponentExtraTransform" },
+
+	properties = {
+		{ id = "CameraFacing",  name="Camera facing", default = false, editor = "bool", help = "Let object use camera facing, specified in its class" },
+	},
+	SetCameraFacing = function( self, value )
+		if value then
+			self:SetSpecialOrientation(const.soFacing)
+		else
+			self:SetSpecialOrientation()
+		end
+	end,
+	GetCameraFacing = function(self)
+		return self:GetSpecialOrientation() == const.soFacing
+	end,
+}
+
+function DepositionTypesItems(obj)
+	local deposition = obj:GetDepositionSupported()
+	local items = {
+		{ value = "", text = "None"},
+	}
+	if deposition == "terrainchunk" or deposition == "all" then
+		table.insert(items, {value = "terrainchunk", text = "Terrain Chunk"})
+	end
+
+	if deposition == "terraintype" or deposition == "all" then
+		local subitems = { }
+		ForEachPreset("TerrainObj", function(preset)
+			table.insert(subitems, { value = preset.material_name, text = preset.material_name })
+		end)
+		table.sort(subitems, function(a, b) return a.value < b.value end)
+		table.append(items, subitems)
+	end
+
+	return items;
+end
+
+DefineClass.Deposition = {
+	__parents = { "CObject", "ComponentCustomData" },
+	flags = { efSelectable = false, },
+	properties = {
+		{ category = "Deposition", id = "DepositionType", editor = "dropdownlist", default = "", items = DepositionTypesItems, help = "The type of material that is going to be applied on top of this object." },
+		{ category = "Deposition", id = "DepositionScale", editor = "number", default = 10, min = 1, max = 100, scale = 10, slider = true, help = "The scale of all textures extracted from the material.", no_edit=function(obj) return obj:IsTerrainChunkDeposition() end },
+		{ category = "Deposition", id = "DepositionAxis", editor = "point", default = point(0, 0, 127), helper = "relative_pos", helper_origin = true, helper_outside_object = true, helper_scale_with_parent = true, help = "The axis used for determining where the deposition must be applied.", no_edit=function(obj) return obj:IsTerrainChunkDeposition() end },
+		{ category = "Deposition", id = "DepositionFadeStart", editor = "number", default = 40, min = 0, max = 100, scale = 1, slider = true, help = "At which point relative to the axis the deposition must be completely invisible." },
+		{ category = "Deposition", id = "DepositionFadeEnd", editor = "number", default = 60, min = 0, max = 100, scale = 1, slider = true, help = "At which point relative to the axis the deposition must be completely visible." },
+		{ category = "Deposition", id = "DepositionFadeCurve", editor = "number", default = 10, min = 1, max = 100, scale = 10, slider = true, help = "Determines the hardness of the transition between areas with and without deposition." },
+		{ category = "Deposition", id = "DepositionAlphaStart", editor = "number", default = 40, min = 0, max = 100, scale = 1, slider = true, help = "At which point relative to the axis the alpha of the diffuse texture is completely applied. You can use it to create sparse deposition or improve the transition between areas with and without deposition.",
+			no_edit=function(obj) return obj:IsTerrainChunkDeposition() end },
+		{ category = "Deposition", id = "DepositionAlphaEnd", editor = "number", default = 60, min = 0, max = 100, scale = 1, slider = true, help = "At which point relative to the axis the alpha of the diffuse texture is not applied. You can use it to create sparse deposition or improve the transition between areas with and without deposition.",
+			no_edit=function(obj) return obj:IsTerrainChunkDeposition() end },
+		{ category = "Deposition", id = "DepositionNoiseGamma", editor = "number", default = 0, min = 0, max = 255, scale = 128, slider = true, help = "How much of the noise to apply. 0 to disable.", },
+		{ category = "Deposition", id = "DepositionNoiseFreq", editor = "number", default = 0, min = 0, max = 255, scale = 64, slider = true, help = "Noise frequency", },
+	}
+}
+
+function Deposition:IsTerrainChunkDeposition()
+	local deposition = self:GetDepositionType()
+	return deposition == "terrainchunk"
+end
+
+function OnMsg.BinAssetsLoaded()
+	UpdateDepositionMaterialLUT()
+	UpdateDustMaterial(const.DustMaterialExterior, "TerrainSand_01_mesh.mtl")
+	UpdateDustMaterial(const.DustMaterialInterior, "DustRust_mesh.mtl")
+end
+
+DefineClass.Mirrorable = {
+	__parents = {"CObject"},
+	properties = {
+	}
+}

CommonLua/Classes/Components.lua

@@ -0,0 +1,130 @@
+local function not_attached(obj)
+	return not obj:GetParent()
+end
+
+--[[@@@
+@class ComponentAttach
+Objects inheriting this class can attach other objects or be attached to other objects
+--]]
+
+DefineClass.ComponentAttach = {
+	__parents = { "CObject" },
+	flags = { cofComponentAttach = true },
+	properties = {
+		{ category = "Child", id = "AttachOffset",   name = "Attached Offset",  editor = "point",  default = point30, no_edit = not_attached, dont_save = true },
+		{ category = "Child", id = "AttachAxis",     name = "Attached Axis",    editor = "point",  default = axis_z,  no_edit = not_attached, dont_save = true },
+		{ category = "Child", id = "AttachAngle",    name = "Attached Angle",   editor = "number", default = 0,       no_edit = not_attached, dont_save = true, min = -180*60, max = 180*60, slider = true, scale = "deg" },
+		{ category = "Child", id = "AttachSpotName", name = "Attached At",      editor = "text",   default = "",      no_edit = not_attached, dont_save = true, read_only = true },
+		{ category = "Child", id = "Parent",         name = "Attached To",      editor = "object", default = false,   no_edit = not_attached, dont_save = true, read_only = true },
+		{ category = "Child", id = "TopmostParent",  name = "Topmost Parent",   editor = "object", default = false,   no_edit = not_attached, dont_save = true, read_only = true },
+		{ category = "Child", id = "AngleLocal",     name = "Local Angle",      editor = "number", default = 0,       no_edit = not_attached, dont_save = true, min = -180*60, max = 180*60, slider = true, scale = "deg" },
+		{ category = "Child", id = "AxisLocal",      name = "Local Axis",       editor = "point",  default = axis_z,  no_edit = not_attached, dont_save = true },
+	},
+}
+
+ComponentAttach.SetAngleLocal = CObject.SetAngle
+ComponentAttach.SetAxisLocal = CObject.SetAxis
+
+DefineClass.StripComponentAttachProperties = {
+	__parents = { "ComponentAttach" },
+	properties = {
+		{ id = "AttachOffset",   },
+		{ id = "AttachAxis",     },
+		{ id = "AttachAngle",    },
+		{ id = "AttachSpotName", },
+		{ id = "Parent",         },
+	},
+}
+
+function ComponentAttach:GetAttachSpotName()
+	local parent = self:GetParent()
+	return parent and parent:GetSpotName(self:GetAttachSpot())
+end
+
+DefineClass.ComponentCustomData = {
+	__parents = { "CObject" },
+	flags = { cofComponentCustomData = true },
+	-- when inheriting ComponentCustomData from multiple parents you have to:
+	-- 1. review if its use is not conflicting
+	-- 2. add member CustomDataType = "<class-name>" to suppress the class system error
+	
+	GetCustomData = _GetCustomData,
+	SetCustomData = _SetCustomData,
+	GetCustomString = _GetCustomString,
+	SetCustomString = _SetCustomString,
+}
+
+if Platform.developer then
+function OnMsg.ClassesPreprocess(classdefs)
+	for name, class in pairs(classdefs) do
+		if table.find(class.__parents, "ComponentCustomData") then
+			if not class.CustomDataType then
+				class.CustomDataType = name
+			end
+		end
+	end
+end
+end
+
+function SpecialOrientationItems()
+	local SpecialOrientationNames = { "soTerrain", "soTerrainLarge", "soFacing", "soFacingY", "soFacingVertical", "soVelocity", "soZOffset", "soTerrainPitch", "soTerrainPitchLarge" }
+	table.sort(SpecialOrientationNames)
+	local items = {}
+	for i, name in ipairs(SpecialOrientationNames) do
+		items[i] = { text = name, value = const[name] }
+	end
+	table.insert(items, 1, { text = "", value = const.soNone })
+	return items
+end
+
+DefineClass.ComponentExtraTransform = {
+	__parents = { "CObject" },
+	flags = { cofComponentExtraTransform = true },
+	properties = {
+		{ id = "SpecialOrientation", name = "Special Orientation", editor = "choice", default = const.soNone, items = SpecialOrientationItems },
+	},
+}
+
+DefineClass.ComponentInterpolation = {
+	__parents = { "CObject" },
+	flags = { cofComponentInterpolation = true },
+}
+
+DefineClass.ComponentCurvature = {
+	__parents = { "CObject" },
+	flags = { cofComponentCurvature = true },
+}
+
+DefineClass.ComponentAnim = {
+	__parents = { "CObject" },
+	flags = { cofComponentAnim = true },
+}
+
+DefineClass.ComponentSound = {
+	__parents = { "CObject" },
+	flags = { cofComponentSound = true },
+	properties = {
+		{ category = "Sound", id = "SoundBank",     name = "Bank",     editor = "preset_id",  default = "", preset_class = "SoundPreset", dont_save = true },
+		{ category = "Sound", id = "SoundType",     name = "Type",     editor = "preset_id",  default = "", preset_class = "SoundTypePreset", dont_save = true, read_only = true },
+		{ category = "Sound", id = "Sound",         name = "Sample",   editor = "text",       default = "", dont_save = true, read_only = true },
+		{ category = "Sound", id = "SoundDuration", name = "Duration", editor = "number",     default = -1, dont_save = true, read_only = true },
+		{ category = "Sound", id = "SoundHandle",   name = "Handle",   editor = "number",     default = -1, dont_save = true, read_only = true },
+	},
+}
+
+function ComponentSound:GetSoundBank()
+	local sname, sbank, stype, shandle, sduration, stime = self:GetSound()
+	return sbank or ""
+end
+function ComponentSound:GetSoundType()
+	local sname, sbank, stype, shandle, sduration, stime = self:GetSound()
+	return stype or ""
+end
+function ComponentSound:GetSoundHandle()
+	local sname, sbank, stype, shandle, sduration, stime = self:GetSound()
+	return shandle or -1
+end
+function ComponentSound:GetSoundDuration()
+	local sname, sbank, stype, shandle, sduration, stime = self:GetSound()
+	return sduration or -1
+end

CommonLua/Classes/Composite.lua

@@ -0,0 +1,503 @@
+----- Composite objects with components of base class CompositeClass that can be turned on and off
+--
+-- create the specific classes, setting their components and properties, using the Ged editor that will appear
+-- properties of all components that have template = true in their metadata are editable in the Ged editor
+-- use AutoResolveMethod to defind how to combine methods present in multiple components
+
+const.ComponentsPropCategory = "Components"
+
+DefineClass.CompositeDef = {
+	__parents = { "Preset" },
+	properties = {
+		{ category = "Preset", id = "object_class", name = "Object Class", editor = "choice", default = "", items = function(self) return ClassDescendantsCombo(self.ObjectBaseClass, true) end, },
+		{ category = "Preset", id = "code", name = "Global Code", editor = "func", default = false, lines = 1, max_lines = 100, params = "",
+			no_edit = function(self) return IsKindOf(self, "ModItem") end,
+		},
+	},
+	
+	-- Preset settings
+	GeneratesClass = true,
+	SingleFile = false,
+	GedShowTemplateProps = true,
+	
+	-- CompositeDef settings
+	ObjectBaseClass = false,
+	ComponentClass = false,
+	
+	components_cache = false,
+	components_sorting = false,
+	properties_cache = false,
+	EditorMenubarName = false,
+	
+	EditorViewPresetPostfix = Untranslated(" <style GedSmall><color 164 128 64><object_class></color></style>"),
+	Documentation = "This is a preset that results in a composite class definition. You can look at it as a template from which objects are created.\n\nThe generated class will inherit the specified Object Class and all component classes.",
+}
+
+function CompositeDef.new(class, obj)
+	local object = Preset.new(class, obj)
+	object.object_class = CompositeDef.GetObjectClass(object)
+	return object
+end
+
+function CompositeDef:GetObjectClass()
+	return self.object_class ~= "" and self.object_class or self.ObjectBaseClass
+end
+
+function CompositeDef:GetComponents(filter)
+	if not self.ComponentClass then return empty_table end
+
+	local components_cache = self.components_cache
+	if not components_cache then
+		local sorting_keys = {}
+		local component_class = g_Classes[self.ComponentClass]
+		local blacklist = component_class.BlackListBaseClasses
+		components_cache = ClassDescendantsList(self.ComponentClass, function(classname, class, base_class, base_def, sorting_keys, blacklist)
+			if class:IsKindOf(base_class) or base_def:IsKindOf(classname)
+				or IsKindOf(g_Classes[class.__generated_by_class or false], "CompositeDef")
+				or class:IsKindOfClasses(blacklist) then
+				return
+			end
+			if (class.ComponentSortKey or 0) ~= 0 then
+				sorting_keys[classname] = class.ComponentSortKey
+			end
+			return true
+		end, self.ObjectBaseClass, g_Classes[self.ObjectBaseClass], sorting_keys, blacklist)
+		local classdef = g_Classes[self.class]
+		rawset(classdef, "components_cache", components_cache)
+		rawset(classdef, "components_sorting", sorting_keys)
+	end
+	if filter == "active" then
+		return table.ifilter(components_cache, function(_, classname) return self:GetProperty(classname) end)
+	elseif filter == "inactive" then
+		return table.ifilter(components_cache, function(_, classname) return not self:GetProperty(classname) end)
+	end
+	return components_cache
+end
+
+function CompositeDef:GetProperties()
+	local object_class = self:GetObjectClass()
+	local object_def = g_Classes[object_class]
+	assert(not object_class or object_def)
+	if not object_def then
+		return self.properties
+	end
+	
+	local cache = self.properties_cache or {}
+	if not cache[object_class] then
+		local props, prop_data = {}, {}
+		local function add_prop(prop, default, class)
+			local added
+			if not prop_data[prop.id] then
+				added = true
+				if prop.default ~= default then
+					prop = table.copy(prop)
+					prop.default = default
+				end
+				props[#props + 1] = prop
+			else
+				assert(prop_data[prop.id].default == default,
+					string.format("Default value conflict for property '%s' in classes '%s' and '%s'", prop.id, prop_data[prop.id].class, class))
+			end
+			prop_data[prop.id] = { default = default, class = class }
+			return added and prop or table.find_value(props, "id", prop.id)
+		end
+		
+		for _, prop in ipairs(self.properties) do
+			if prop.id ~= "code" then add_prop(prop, prop.default, self.class) end
+		end
+		for _, prop in ipairs(object_def.properties) do
+			if prop.template then
+				add_prop(prop, object_def:GetDefaultPropertyValue(prop.id), self.class)
+			end
+		end
+		
+		local components = self:GetComponents()
+		for _, classname in ipairs(components) do
+			local inherited = object_def:IsKindOf(classname) or false
+			local help = inherited and "Inherited from the base class"
+			local prop = { category = const.ComponentsPropCategory, id = classname, editor = "bool", default = inherited, read_only = inherited, help = help }
+			add_prop(prop, inherited, self.class)
+		end
+		add_prop(table.find_value(self.properties, "id", "code"), self:GetDefaultPropertyValue("code"), self.class)
+		for _, classname in ipairs(components) do
+			if not object_def:IsKindOf(classname) then
+				local component_def = g_Classes[classname]
+				for _, prop in ipairs(component_def.properties) do
+					local category = prop.category or classname
+					local no_edit = prop.no_edit
+					prop = table.copy(prop, "deep")
+					prop.category = category
+					prop = add_prop(prop, component_def:GetDefaultPropertyValue(prop.id), classname)
+					local composite_owner_classes = prop.composite_owner_classes or {}
+					composite_owner_classes[#composite_owner_classes + 1] = classname
+					prop.composite_owner_classes = composite_owner_classes
+					prop.no_edit = function(self, ...)
+						if no_edit == true or type(no_edit) == "function" and no_edit(self, ...) then return true end
+						local prop_meta = select(1, ...)
+						for _, name in ipairs(prop_meta.composite_owner_classes or empty_table) do
+							if rawget(self, name) then
+								return
+							end
+						end
+						return true
+					end
+				end
+			end
+		end
+		
+		-- store the cache in the class, this auto-invalidates it on Lua reload
+		rawset(g_Classes[self.class], "properties_cache", cache)
+		rawset(cache, object_class, props)
+		return props
+	end
+	
+	return cache[object_class]
+end
+
+function CompositeDef:SetProperty(prop_id, value)
+	local prop_meta = self:GetPropertyMetadata(prop_id)
+	if prop_meta and prop_meta.template and prop_meta.setter then
+		return prop_meta.setter(self, value, prop_id, prop_meta)
+	end
+	if table.find(CompositeDef.properties, "id", prop_id) then
+		return Preset.SetProperty(self, prop_id, value)
+	end
+	if value and table.find(self:GetComponents(), prop_id) and _G[prop_id]:HasMember("OnEditorNew") then
+		_G[prop_id].OnEditorNew(self) -- OnEditorNew can initialize component property defaults of e.g. nested_obj/list component properties
+	end	
+	rawset(self, prop_id, value)
+end
+
+function CompositeDef:GetProperty(prop_id)
+	local prop_meta = self:GetPropertyMetadata(prop_id)
+	if prop_meta and prop_meta.template and prop_meta.getter then
+		return prop_meta.getter(self, prop_id, prop_meta)
+	end
+	local value = Preset.GetProperty(self, prop_id)
+	if value ~= nil then
+		return value
+	end
+	return prop_meta and prop_meta.default
+end
+
+function CompositeDef:OnEditorSetProperty(prop_id, old_value, ged)
+	local prop_meta = self:GetPropertyMetadata(prop_id)
+	if prop_meta and prop_meta.template and prop_meta.edited then
+		return prop_meta.edited(self, old_value, prop_id, prop_meta)
+	end
+	return Preset.OnEditorSetProperty(self, prop_id, old_value, ged)
+end
+
+function CompositeDef:__toluacode(...)
+	-- clear properties of the inactive components
+	local properties = self:GetProperties()
+	local find = table.find
+	local rawget = rawget
+	for _, classname in ipairs(self:GetComponents("inactive")) do
+		for _, prop in ipairs(g_Classes[classname].properties) do
+			if rawget(self, prop.id) ~= nil and not find(properties, "id", prop.id) then
+				self[prop.id] = nil
+			end
+		end
+	end
+	return Preset.__toluacode(self, ...)
+end
+
+-- supports generating a different class for each DLC, including property values for this DLC; see PresetDLCSplitting.lua
+-- return a table with <key, file_name> pairs to generate multiple companion files, where key = dlc
+function CompositeDef:GetCompanionFilesList(save_path)
+	local files = { }
+	for _, prop in pairs(self:GetProperties()) do
+		local save_in = prop.dlc or ""
+		if not files[save_in] then
+			-- GetSavePath depends on self.group and self.id
+			files[save_in] = self:GetCompanionFileSavePath(prop.dlc and self:GetSavePath(prop.dlc) or save_path)
+		end
+	end
+	return files
+end
+
+function CompositeDef:GenerateCompanionFileCode(code, dlc)
+	local class_exists_err = self:CheckIfIdExistsInGlobal()
+	if class_exists_err then
+		return class_exists_err
+	end
+	
+	code:appendf("UndefineClass('%s')\nDefineClass.%s = {\n", self.id, self.id)
+	self:GenerateParents(code)
+	self:AppendGeneratedByProps(code)
+	self:GenerateFlags(code)
+	self:GenerateConsts(code, dlc)
+	code:append("}\n\n")
+	self:GenerateGlobalCode(code)
+end
+
+function CompositeDef:GenerateParents(code)
+	local object_class = self:GetObjectClass()
+	
+	local list = self:GetComponents("active")
+	if #list > 0 then
+		assert(list ~= self.components_cache)
+		local object_def = g_Classes[object_class]
+		assert(object_def)
+		if object_def then
+			list = table.ifilter(list, function(_, classname) return not object_def:IsKindOf(classname) end)
+		end
+	end
+	if #list == 0 then
+		code:appendf('\t__parents = { "%s" },\n', object_class)
+		return
+	end
+	
+	if next(self.components_sorting) then
+		table.insert(list, 1, object_class)
+		local sorting_keys = self.components_sorting
+		table.stable_sort(list, function(class1, class2)
+			return (sorting_keys[class1] or 0) < (sorting_keys[class2] or 0)
+		end)
+		code:append('\t__parents = { "', table.concat(list, '", "'), '" },\n')
+	else
+		code:appendf('\t__parents = { "%s", "', object_class)
+		code:append(table.concat(list, '", "'))
+		code:append('" },\n')
+	end
+end
+
+ClassNonInheritableMembers.composite_flags = true
+
+function CompositeDef:GenerateFlags(code)
+	local object_def = g_Classes[self:GetObjectClass()]
+	assert(object_def)
+	if not object_def then return end
+	
+	local flags = table.copy(object_def.composite_flags or empty_table)
+	for _, component in ipairs(self:GetComponents("active")) do
+		for flag, set in pairs(g_Classes[component].composite_flags) do
+			assert(flags[flag] == nil)
+			flags[flag] = set
+		end
+	end
+	if not next(flags) then
+		return
+	end
+	code:append('\tflags = { ')
+	for flag, set in sorted_pairs(flags) do
+		code:appendf("%s = %s, ", flag, set and "true" or "false")
+	end
+	code:append('},\n')
+end
+
+function CompositeDef:IncludePropAs(prop, dlc)
+	local id = prop.id
+	if Preset:GetPropertyMetadata(id) or id == "code" then
+		return false
+	end
+	if not prop.dlc and not (dlc ~= "" and prop.dlc_override) or prop.dlc == dlc then
+		return prop.maingame_prop_id or prop.id
+	end
+end
+
+function CompositeDef:GenerateConsts(code, dlc)
+	local props = self:GetProperties()
+	code:append(#props > 0 and "\n" or "")
+	local has_embedded_objects = false
+	for _, prop in ipairs(props) do
+		local id = prop.id
+		local include_as = self:IncludePropAs(prop, dlc)
+		if include_as then
+			local value = rawget(self, id)
+			if not self:IsDefaultPropertyValue(id, prop, value) then
+				code:append("\t", include_as, " = ")
+				ValueToLuaCode(value, 1, code, {} --[[ enable property injection ]])
+				code:append(",\n")
+			end
+		end
+	end
+	return has_embedded_objects
+end
+
+function CompositeDef:GenerateGlobalCode(code)
+	if self.code and self.code ~= "" then
+		code:append("\n")
+		local name, params, body = GetFuncSource(self.code)
+		if type(body) == "table" then
+			for _, line in ipairs(body) do
+				code:append(line, "\n")
+			end
+		elseif type(body) == "string" then
+			code:append(body)
+		end
+		code:append("\n")
+	end
+end
+
+function CompositeDef:GetObjectClassLuaFilePath(path)
+	if self.save_in == "" then
+		return string.format("Lua/%s/__%s.generated.lua", self.class, self.ObjectBaseClass)
+	elseif self.save_in == "Common" then
+		return string.format("CommonLua/Classes/%s/__%s.generated.lua", self.class, self.ObjectBaseClass)
+	elseif self.save_in:starts_with("Libs/") then -- lib
+		return string.format("CommonLua/%s/%s/__%s.generated.lua", self.save_in, self.class, self.ObjectBaseClass)
+	else -- save_in is a DLC name
+		return string.format("svnProject/Dlc/%s/Presets/%s/__%s.generated.lua", self.save_in, self.class, self.ObjectBaseClass)
+	end
+end
+
+function CompositeDef:GetWarning()
+	if not g_Classes[self.id] then
+		return "The class for this preset has not been generated yet.\nIt needs to be saved before it can be used or referenced from elsewhere."
+	end
+end
+
+function CompositeDef:GetError()
+	for _, component in ipairs(self:GetComponents()) do
+		if self[component] then
+			local err = g_Classes[component].GetError(self)
+			if err then
+				return err
+			end
+		end
+	end
+end
+
+function OnMsg.ClassesPreprocess(classdefs)
+	for name, classdef in pairs(classdefs) do
+		if classdef.__parents and classdef.__parents[1] == "CompositeDef" then
+			classdefs[classdef.ObjectBaseClass].__hierarchy_cache = true
+		end
+	end	
+end
+
+function OnMsg.ClassesBuilt()
+	ClassDescendants("CompositeDef", function(class_name, class)
+		if IsKindOf(class, "ModItem") then return end
+		
+		local objclass = class.ObjectBaseClass
+		local path = class:GetObjectClassLuaFilePath()
+		
+		-- can't generate the file in packed builds, as we can't get Lua source for func properties
+		if config.RunUnpacked and Platform.developer and not Platform.console then
+			-- Map all component methods => list of components they are defined in
+			local methods = {}
+			for _, component in ipairs(class:GetComponents()) do
+				for name, member in pairs(g_Classes[component]) do
+					if type(member) == "function" and not RecursiveCallMethods[name] then
+						local classlist = methods[name]
+						if classlist then
+							classlist[#classlist + 1] = component
+						else
+							methods[name] = { component }
+						end
+					end
+				end
+			end
+			
+			-- Generate the code for the CompositeDef's object class here
+			local code = pstr(exported_files_header_warning, 16384)
+			code:appendf("function __%sExtraDefinitions()\n", objclass)
+			
+			-- a) make GetComponents callable from the object class
+			code:appendf("\t%s.components_cache = false\n", objclass)
+			code:appendf("\t%s.GetComponents = %s.GetComponents\n", objclass, class_name)
+			code:appendf("\t%s.ComponentClass = %s.ComponentClass\n", objclass, class_name)
+			code:appendf("\t%s.ObjectBaseClass = %s.ObjectBaseClass\n\n", objclass, class_name)
+			
+			-- b) add default property values for ALL component properites, so accessing them is fine from the object class
+			local objprops = _G[objclass].properties
+			for _, prop in ipairs(class:GetProperties()) do
+				if not table.find(class.properties, "id", prop.id) and not table.find(objprops, "id", prop.id) then
+					code:append("\t", objclass, ".", prop.id, " = ")
+					ValueToLuaCode(class:GetDefaultPropertyValue(prop.id, prop), nil, code, {} --[[ enable property injection ]])
+					code:append("\n")
+				end
+			end
+			code:append("end\n\n")
+			code:appendf("function OnMsg.ClassesBuilt() __%sExtraDefinitions() end\n", objclass)
+			
+			-- Save the code and execute it now
+			local err = SaveSVNFile(path, code, class.LocalPreset)
+			if err then
+				printf("Error '%s' saving %s", tostring(err), path)
+				return
+			end	
+		end
+		
+		if io.exists(path) then
+			dofile(path)
+			_G[string.format("__%sExtraDefinitions", objclass)]()
+		else
+			-- saved in a DLC folder, in a pack file mounted somewhere in DlcFolders
+			assert(path:starts_with("svnProject/Dlc/"))
+			for _, dlc_folder in ipairs(rawget(_G, "DlcFolders")) do
+				local path = string.format("%s/Presets/%s/__%s.generated.lua", dlc_folder, class_name, objclass)
+				if io.exists(path) then
+					dofile(path)
+					_G[string.format("__%sExtraDefinitions", objclass)]()
+					return
+				end
+			end
+			assert(false, "Unable to find and execute " .. path .. " from a DLC folder.")
+		end
+	end)
+end
+
+
+----- Test/sample code below
+
+--[[DefineClass.TestClass = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ category = "General", id = "BaseProp1", editor = "text", default = "", translate = true, lines = 1, max_lines = 10, },
+		{ category = "General", id = "BaseProp2", editor = "bool", default = true, },
+	},
+	Value = true,
+	TestMethod = true,
+}
+
+DefineClass.TestClassComponent = {
+	__parents = { "PropertyObject" }
+}
+
+DefineClass.TestClassComponent1 = {
+	__parents = { "TestClassComponent" },
+	properties = {
+		{ id = "Component1Prop1", editor = "text", default = "", translate = true, lines = 1, max_lines = 10 },
+		{ id = "Component1Prop2", editor = "bool", default = true },
+	},
+}
+
+function TestClassComponent1:Value()
+	return 1
+end
+
+function TestClassComponent1:TestMethod()
+	return 1
+end
+
+DefineClass.TestClassComponent2 = {
+	__parents = { "TestClassComponent" },
+	properties = {
+		{ id = "Component2Prop", editor = "number", default = 0 },
+	},
+}
+
+function TestClassComponent2:Value()
+	return 2
+end
+
+RecursiveCallMethods.Value = "+"
+RecursiveCallMethods.TestMethod = "call"
+
+DefineClass.TestCompositeDef = {
+	__parents = { "CompositeDef" },
+	
+	-- composite def
+	ObjectBaseClass = "TestClass",
+	ComponentClass = "TestClassComponent",
+	
+	-- preset
+	EditorMenubarName = "TestClass Composite Objects Editor",
+	EditorMenubar = "Editors",
+	EditorShortcut = "Ctrl-T",
+	GlobalMap = "TestCompositeDefs",
+}]]

CommonLua/Classes/CompositeBody.lua

@@ -0,0 +1,1428 @@
+function GetSpotOffset(obj, name, idx, state, phase)
+	assert(obj)
+	if not IsValid(obj) then
+		return 0, 0, 0, "obj"
+	end
+	idx = idx or obj:GetSpotBeginIndex(name) or -1
+	if idx == -1 then
+		return 0, 0, 0, "spot"
+	end
+	state = state or "idle"
+	phase = phase or 0
+	local x, y, z = GetEntitySpotPos(obj, state, phase, idx, idx, true):xyz()
+	local s = obj:GetWorldScale()
+	if s ~= 100 then
+		x, y, z = x * s / 100, y * s / 100, z * s / 100
+	end
+	return x, y, z
+end
+
+function GetLocalAngleDiff(attach, local_angle)
+	return abs(AngleDiff(attach:GetVisualAngleLocal(), local_angle))
+end
+
+function GetLocalRotationTime(attach, local_angle, speed)
+	return MulDivRound(1000, GetLocalAngleDiff(attach, local_angle), speed)
+end
+
+function GetLocalAngle(obj, angle)
+	return AngleDiff(angle, obj:GetAngle())
+end
+
+----
+
+DefineClass.CompositeBodyPart = {
+	__parents = { "ComponentAnim", "ComponentAttach", "ColorizableObject" },
+	flags = { gofSyncState = true, efWalkable = false, efApplyToGrids = false, efCollision = false, efSelectable = true },
+}
+
+function CompositeBodyPart:GetName()
+	local parent = self:GetParent()
+	while IsValid(parent) do
+		if IsKindOf(parent, "CompositeBody") then
+			for name, part in pairs(parent.attached_parts) do
+				if part == self then
+					return name
+				end
+			end
+			return
+		else
+			parent = parent:GetParent()
+		end
+	end
+end
+
+local function RecomposeBody(obj)
+	for name, part in pairs(obj.attached_parts) do
+		if part ~= obj then
+			obj:RemoveBodyPart(part, name)
+		end
+	end
+	obj.attached_parts = nil
+	obj:ComposeBodyParts()
+end
+		
+local function EditorRecomposeBodiesOnMap(obj, root, prop_id, ged)
+	if IsValid(obj) then
+		RecomposeBody(obj)
+	elseif obj.object_class then
+		MapForEach("map", obj.object_class, RecomposeBody)
+	end
+end
+
+local function get_body_parts_count(self)
+	local class_name = self.id
+	local class = g_Classes[class_name] or empty_table
+	local target = self.composite_part_target or class.composite_part_target or class_name
+	local composite_part_groups = self.composite_part_groups or class.composite_part_groups or { class_name }
+	local part_presets = Presets.CompositeBodyPreset
+	local count = 0
+	for _, part_name in ipairs(self.composite_part_names or class.composite_part_names) do
+		for _, part_group in ipairs(composite_part_groups) do
+			for _, part_preset in ipairs(part_presets[part_group] or empty_table) do
+				if (not target or part_preset.Target == target) and (part_preset.Parts or empty_table)[part_name] then
+					count = count + 1
+				end
+			end
+		end
+	end
+	return count
+end
+
+-- Composite bodies change the entity, scale and colors of the unit."
+DefineClass.CompositeBody = {
+	__parents = { "Object", "CompositeBodyPart" },
+
+	properties = {
+		{ category = "Composite Body", id = "recompose",                name = "Recompose", editor = "buttons", default = false, template = true, buttons = { { name = "Recompose", func = function(...) return EditorRecomposeBodiesOnMap(...) end, } } },
+		{ category = "Composite Body", id = "composite_part_names",     name = "Parts", editor = "string_list", template = true, help = "Composite body parts. Each body preset may cover one or more parts. Each part may have another part as a parent and a custom attach spot.", body_part_match = true },
+		{ category = "Composite Body", id = "composite_part_main",      name = "Main Part", editor = "choice", items = PropGetter("composite_part_names"), template = true, help = "Main body part to be applied directly to the composite object." },
+		{ category = "Composite Body", id = "composite_part_target",    name = "Target", editor = "text", template = true, help = "Will match composite body presets having the same target. If not specified, the class name is used.", body_part_match = true },
+		{ category = "Composite Body", id = "composite_part_groups",    name = "Groups", editor = "string_list", items = PresetGroupsCombo("CompositeBodyPreset"), template = true, help = "Will match composite body presets from those groups. If not specified, the class name is used as a group name.", body_part_match = true },
+		{ category = "Composite Body", id = "CompositePartCount",       name = "Parts Found", editor = "number", template = true, default = 0, dont_save = true, read_only = 0, getter = get_body_parts_count },
+		{ category = "Composite Body", id = "composite_part_parent",    name = "Parent", editor = "prop_table", read_only = true, template = true, help = "Defines custom parent for each body part." },
+		{ category = "Composite Body", id = "composite_part_spots",     name = "Spots", editor = "prop_table", read_only = true, template = true, help = "Defines custom attach spots for each body part." },
+		{ category = "Composite Body", id = "cycle_colors",             name = "Cycle Colors", editor = "bool", default = false, template = true, help = "If you can cycle through the composite body colors during construction.", },
+	},
+
+	flags = { gofSyncState = false, gofPropagateState = true },
+	
+	composite_seed = false,
+	colorization_offset = 0,
+	composite_part_target = false,
+	composite_part_names = { "Body" },
+	composite_part_spots = false,
+	composite_part_parent = false,
+	composite_part_main = "Body",
+	composite_part_groups = false,
+	
+	attached_parts = false,
+	override_parts = false,
+	override_parts_spot = false,
+	
+	InitBodyParts = empty_func,
+	SetAutoAttachMode = empty_func,
+	ChangeEntityDisabled = empty_func,
+}
+
+function CompositeBody:CheatCompose()
+	self:ComposeBodyParts()
+end
+
+local props = CompositeBody.properties
+for i=1,10 do
+	local category = "Composite Body Hierarchy"
+	local function no_edit(self)
+		local names = self:GetProperty("composite_part_names") or empty_table
+		local name = names[i]
+		return not name or name == self:GetProperty("composite_part_main")
+	end
+	local function GetPartName(self)
+		local names = self:GetProperty("composite_part_names")
+		return names[i] or ""
+	end
+	local function GetSpotName(self)
+		local name = GetPartName(self)
+		return name .. " Spot"
+	end
+	local function GetParentName(self)
+		local name = GetPartName(self)
+		return name .. " Parent"
+	end
+	local spot_id = "composite_part_spot_" .. i
+	local parent_id = "composite_part_parent_" .. i
+	local function getter(self, prop_id)
+		local target_id
+		if prop_id == spot_id then
+			target_id = "composite_part_spots"
+		elseif prop_id == parent_id then
+			target_id = "composite_part_parent"
+		else
+			return ""
+		end
+		local name = GetPartName(self)
+		local map = self:GetProperty(target_id)
+		return map and map[name] or ""
+	end
+	local function setter(self, value, prop_id)
+		local target_id
+		if prop_id == spot_id then
+			target_id = "composite_part_spots"
+		elseif prop_id == parent_id then
+			target_id = "composite_part_parent"
+		else
+			return
+		end
+		local name = GetPartName(self)
+		local map = self:GetProperty(target_id) or empty_table
+		map = table.raw_copy(map)
+		map[name] = (value or "") ~= "" and value or nil
+		rawset(self, target_id, map)
+	end
+	local function GetParentItems(self)
+		local names = self:GetProperty("composite_part_names") or empty_table
+		if names[i] then
+			names = table.icopy(names)
+			table.remove_value(names, names[i])
+		end
+		return names, return_true
+	end
+	table.iappend(props, {
+		{ category = category, id = spot_id, name = GetSpotName, editor = "text", default = "", dont_save = true, getter = getter, setter = setter, no_edit = no_edit, template = true },
+		{ category = category, id = parent_id, name = GetParentName, editor = "choice", default = "", items = GetParentItems, dont_save = true, getter = getter, setter = setter, no_edit = no_edit, template = true },
+	})
+	CompositeBody["Get" .. spot_id] = function(self)
+		return getter(self, spot_id)
+	end
+	CompositeBody["Get" .. parent_id] = function(self)
+		return getter(self, parent_id)
+	end
+	CompositeBody["Set" .. spot_id] = function(self, value)
+		return setter(self, spot_id, value)
+	end
+	CompositeBody["Set" .. parent_id] = function(self, value)
+		return setter(self, parent_id, value)
+	end
+end
+
+function CompositeBody:Done()
+	-- allow garbage collection of CompositeBody objects which otherwise have a non-weak reference to themselves
+	self.attached_parts = nil
+	self.override_parts = nil
+end
+
+function CompositeBody:GetPart(name)
+	local parts = self.attached_parts
+	return parts and parts[name]
+end
+
+function CompositeBody:GetPartName(part_to_find)
+	for name, part in pairs(self.attached_parts) do
+		if part == part_to_find then
+			return name
+		end
+	end
+end
+
+function CompositeBody:ForEachBodyPart(func, ...)
+	local attached_parts = self.attached_parts or empty_table
+	for _, name in ipairs(self.composite_part_names) do
+		local part = attached_parts[name]
+		if part then
+			func(part, self, ...)
+		end
+	end
+end
+
+function CompositeBody:UpdateEntity()
+	return self:ComposeBodyParts()
+end
+
+local function ResolveCompositeMainEntity(classdef)
+	if not classdef then return end
+	local composite_part_groups = classdef.composite_part_groups
+	local composite_part_group = composite_part_groups and composite_part_groups[1] or classdef.class
+	local part_presets = table.get(Presets, "CompositeBodyPreset", composite_part_group)
+	if next(part_presets) then
+		local composite_part_target = classdef.composite_part_target
+		local composite_part_main = classdef.composite_part_main or "Body"
+		for _, part_preset in ipairs(part_presets) do
+			if not composite_part_target or composite_part_target == part_preset.Target then
+				if (part_preset.Parts or empty_table)[composite_part_main] then
+					return part_preset.Entity
+				end
+			end
+		end
+	end
+	return classdef.entity or classdef.class
+end
+
+function ResolveTemplateEntity(self)
+	local entity = IsValid(self) and self:GetEntity()
+	if IsValidEntity(entity) then
+		return entity
+	end
+	local class = self.id or self.class
+	local classdef = g_Classes[class]
+	if not classdef then return end
+	entity = ResolveCompositeMainEntity(classdef)
+	return IsValidEntity(entity) and entity
+end
+
+function TemplateSpotItems(self)
+	local entity = ResolveTemplateEntity(self)
+	if not entity then return {} end
+	local spots = {{ value = false, text = "" }}
+	local seen = {}
+	local spbeg, spend = GetAllSpots(entity)
+	for spot = spbeg, spend do
+		local name = GetSpotName(entity, spot)
+		if not seen[name] then
+			seen[name] = true
+			spots[#spots + 1] = { value = name, text = name }
+		end
+	end
+	table.sortby_field(spots, "text")
+	return spots
+end
+
+function CompositeBody:CollectBodyParts(part_to_preset, seed)
+	local target = self.composite_part_target or self.class
+	local composite_part_groups = self.composite_part_groups or { self.class }
+	local part_presets = Presets.CompositeBodyPreset
+	for _, part_name in ipairs(self.composite_part_names) do
+		if not part_to_preset[part_name] then
+			local matched_preset, matched_presets
+			for _, part_group in ipairs(composite_part_groups) do
+				for _, part_preset in ipairs(part_presets[part_group]) do
+					if (not target or part_preset.Target == target) and (part_preset.Parts or empty_table)[part_name] then
+						local matched = true
+						for _, filter in ipairs(part_preset.Filters) do
+							if not filter:Match(self) then
+								matched = false
+								break
+							end
+						end
+						if matched then
+							if not matched_preset or matched_preset.ZOrder < part_preset.ZOrder then
+								matched_preset = part_preset
+								matched_presets = nil
+							elseif matched_preset.ZOrder == part_preset.ZOrder then
+								if matched_presets then
+									matched_presets[#matched_presets + 1] = part_preset
+								else
+									matched_presets = { matched_preset, part_preset }
+								end
+							end
+						end
+					end
+				end
+			end
+			if matched_presets then
+				seed = self:ComposeBodyRand(seed)
+				matched_preset = table.weighted_rand(matched_presets, "Weight", seed)
+			end
+			if matched_preset then
+				part_to_preset[part_name] = matched_preset
+			end
+		end
+	end
+	return seed
+end
+
+function CompositeBody:GetConstructionCopyObjectData(copy_data)
+	table.rawset_values(copy_data, self,         "composite_seed", "colorization_offset")
+end
+
+function CompositeBody:GetConstructionCursorDynamicData(controller, cursor_data)
+	table.rawset_values(cursor_data, controller, "composite_seed", "colorization_offset")
+end
+
+function CompositeBody:GetConstructionControllerDynamicData(controller_data)
+	table.rawset_values(controller_data, self,   "composite_seed", "colorization_offset")
+end
+
+function OnMsg.GatherConstructionInitData(construction_init_data)
+	rawset(construction_init_data, "composite_seed", true)
+	rawset(construction_init_data, "colorization_offset", true)
+end
+
+function CompositeBody:ComposeBodyRand(seed, ...)
+	seed = seed or self.composite_seed or self:RandSeed("Body")
+	self.composite_seed = self.composite_seed or seed
+	return BraidRandom(seed, ...)
+end
+
+function CompositeBody:GetPartFXTarget(part)
+	return self
+end
+
+function CompositeBody:ComposeBodyParts(seed)
+	if self:ChangeEntityDisabled() then
+		return
+	end
+	local part_to_preset = { }
+	-- collect the best matched body presets for the remaining parts without equipment
+	seed = self:CollectBodyParts(part_to_preset, seed) or seed
+	
+	-- apply the main body entity (all others are attached to this one)
+	local main_name = self.composite_part_main	
+	local main_preset = main_name and part_to_preset[main_name]
+	if not main_preset and not IsValidEntity(self:GetEntity()) then
+		return
+	end
+	local applied_presets = {}
+	local changed
+	if main_preset then
+		local changed_i, seed_i = self:ApplyBodyPart(self, main_preset, main_name, seed)
+		assert(IsValidEntity(self:GetEntity()))
+		changed = changed_i or changed
+		seed = seed_i or seed
+		applied_presets = { [main_preset] = true }
+	end
+
+	local last_part_class, part_def
+	
+	local override_parts = self.override_parts or empty_table
+	-- apply all the remaining as attaches (removing the unused ones from the previous procedure)
+	local attached_parts = self.attached_parts or {}
+	attached_parts[main_name] = self
+	self.attached_parts = attached_parts
+	for _, part_name in ipairs(self.composite_part_names) do
+		if part_name == main_name then
+			goto continue
+		end
+		local part_obj = attached_parts[part_name]
+		--body part overriding
+		local override = override_parts[part_name]
+		if override then
+			if override ~= part_obj then
+				if part_obj then
+					self:RemoveBodyPart(part_obj, part_name)
+				end
+				attached_parts[part_name] = override
+				local parent = self
+				if override:GetParent() ~= parent then
+					local spot = self.override_parts_spot and self.override_parts_spot[part_name]
+					spot = spot or self.composite_part_spots[part_name]
+					local spot_idx = spot and parent:GetSpotBeginIndex(spot)
+					parent:Attach(override, spot_idx)
+				end
+			end
+			goto continue
+		end
+		--preset search
+		local preset = part_to_preset[part_name]
+		if preset and not applied_presets[preset] then
+			applied_presets[preset] = true
+			if preset.Entity ~= "" then
+				local part_class = preset.PartClass or "CompositeBodyPart"
+				if not IsValid(part_obj) or part_obj.class ~= part_class then
+					if last_part_class ~= part_class then
+						last_part_class = part_class
+						part_def = g_Classes[part_class]
+						assert(part_def)
+						part_def = part_def or CompositeBodyPart
+					end
+					DoneObject(part_obj)
+					part_obj = part_def:new()
+					attached_parts[part_name] = part_obj
+					changed = true
+				end
+				local changed_i, seed_i = self:ApplyBodyPart(part_obj, preset, part_name, seed)
+				changed = changed_i or changed
+				seed = seed_i or seed 
+				goto continue
+			end
+		end
+		-- 1) body part preset not found
+		-- 2) part already covered, should be removed
+		-- 3) part used to specify a missing part
+		if part_obj then
+			attached_parts[part_name] = nil
+			self:RemoveBodyPart(part_obj, part_name)
+		end
+		::continue::
+	end
+	if changed then
+		self:NetUpdateHash("BodyChanged", seed)
+	end
+	self:InitBodyParts()
+	return changed
+end
+
+local def_scale = range(100, 100)
+
+function CompositeBody:ChangeBodyPartEntity(part, preset, name)
+	local entity = preset.Entity
+	if (preset.AffectedBy or "") ~= "" and (preset.EntityWhenAffected or "") ~= "" and self.attached_parts[preset.AffectedBy] then
+		entity = preset.EntityWhenAffected
+	end
+	
+	local current_entity = part:GetEntity()
+	if current_entity == entity or not IsValidEntity(entity) then
+		return
+	end
+	if current_entity ~= "" then
+		PlayFX("ApplyBodyPart", "end", part, self:GetPartFXTarget(part))
+	end
+	local state = part:GetGameFlags(const.gofSyncState) == 0 and EntityStates.idle or nil
+	part:ChangeEntity(entity, state)
+	return true
+end
+
+function CompositeBody:ChangeBodyPartScale(part, name, scale)
+	if part:GetScale() ~= scale then
+		part:SetScale(scale)
+		return true
+	end
+end
+
+function CompositeBody:ApplyBodyPart(part, preset, name, seed)
+	-- entity
+	local changed_entity = self:ChangeBodyPartEntity(part, preset, name)
+	local changed = changed_entity
+	-- mirrored
+	if part:GetMirrored() ~= preset.Mirrored then
+		part:SetMirrored(preset.Mirrored)
+		changed = true
+	end
+	-- scale
+	local scale = 100
+	local scale_range = preset.Scale
+	if scale_range ~= def_scale then
+		local scale_min, scale_max = scale_range.from, scale_range.to
+		if scale_min == scale_max then
+			scale = scale_min
+		else
+			scale, seed = self:ComposeBodyRand(seed, scale_min, scale_max)
+		end
+	end
+	if self:ChangeBodyPartScale(part, name, scale) then
+		changed = true
+	end
+	-- color
+	seed = self:ColorizeBodyPart(part, preset, name, seed) or seed
+	-- attach
+	if part ~= self then
+		local axis = preset.Axis
+		if axis and part:GetAxisLocal() ~= axis then
+			part:SetAxis(axis)
+			changed = true
+		end
+		local angle = preset.Angle
+		if angle and part:GetAngleLocal() ~= angle then
+			part:SetAngle(angle)
+			changed = true
+		end
+		local spot_name = preset.AttachSpot or ""
+		if spot_name == "" then
+			local spots = self.composite_part_spots
+			spot_name = spots and spots[name] or ""
+			if spot_name == "" then
+				spot_name = "Origin"
+			end
+		end
+		local sync_state = preset.SyncState
+		if sync_state == "auto" then
+			sync_state = spot_name == "Origin"
+		end
+		if not sync_state then
+			part:ClearGameFlags(const.gofSyncState)
+		else
+			part:SetGameFlags(const.gofSyncState)
+		end
+		local prev_parent, prev_spot_idx = part:GetParent(), part:GetAttachSpot()
+		local parents = self.composite_part_parent
+		local parent_part = preset.Parent or parents and parents[name] or ""
+		local parent = parent_part ~= "" and self.attached_parts[parent_part] or self
+		local spot_idx = parent:GetSpotBeginIndex(spot_name)
+		assert(spot_idx ~= -1, string.format("Failed to attach body part %s to spot %s of %s with state %s", name, spot_name, parent:GetEntity(), parent:GetStateText()))
+		if prev_parent ~= parent or prev_spot_idx ~= spot_idx then
+			parent:Attach(part, spot_idx)
+			changed = true
+		end
+		local attach_offset = preset.AttachOffset or point30
+		local attach_axis = preset.AttachAxis or axis_z
+		local attach_angle = preset.AttachAngle or 0
+		if attach_offset ~= part:GetAttachOffset() or attach_axis ~= part:GetAttachAxis() or attach_angle ~= part:GetAttachAngle() then
+			part:SetAttachOffset(attach_offset)
+			part:SetAttachAxis(attach_axis)
+			part:SetAttachAngle(attach_angle)
+			changed = true
+		end
+	end
+	
+	local changed_fx
+	local fx_actor_class = (preset.FxActor or "") ~= "" and preset.FxActor or nil
+	local current_fx_actor = rawget(part, "fx_actor_class") -- avoid clearing class fx actor with the default FxActor value
+	if current_fx_actor ~= fx_actor_class then
+		if current_fx_actor then
+			PlayFX("ApplyBodyPart", "end", part, self:GetPartFXTarget(part))
+		end
+		part.fx_actor_class = fx_actor_class
+		changed_fx = true
+	end
+
+	if changed_fx or changed_entity then
+		PlayFX("ApplyBodyPart", "start", part, self:GetPartFXTarget(part))
+	end
+	
+	return changed, seed
+end
+
+function CompositeBody:ColorizeBodyPart(part, preset, name, seed)
+	local inherit_from = preset.ColorInherit
+	local colorization = inherit_from ~= "" and table.get(self.attached_parts, inherit_from)
+	if not colorization then
+		seed = self:ComposeBodyRand(seed)
+		local colors = preset.Colors or empty_table
+		local idx
+		colorization, idx = table.weighted_rand(colors, "Weight", seed)
+		local offset = self.colorization_offset
+		if idx and offset then
+			idx = ((idx + offset - 1) % #colors) + 1
+			colorization = colors[idx]
+		end
+	end
+	part:SetColorization(colorization)
+	return seed
+end
+
+function CompositeBody:SetColorizationOffset(offset)
+	local part_to_preset = {}
+	local seed = self.composite_seed
+	self:CollectBodyParts(part_to_preset, seed)
+	local attached_parts = self.attached_parts
+	self.colorization_offset = offset
+	for _, part_name in ipairs(self.composite_part_names) do
+		local preset = part_to_preset[part_name]
+		if preset then
+			local part = attached_parts[part_name]
+			self:ColorizeBodyPart(part, preset, part_name, seed, offset)
+		end
+	end
+end
+
+function CompositeBody:RemoveBodyPart(part, name)
+	DoneObject(part)
+end
+
+function CompositeBody:OverridePart(name, obj, spot)
+	if not IsValid(self) or IsBeingDestructed(self) then
+		return
+	end
+	assert(table.find(self.composite_part_names, name), "Invalid part name")
+	if type(obj) == "string" and IsValidEntity(obj) then
+		local entity = obj
+		obj = CompositeBodyPart:new()
+		obj:ChangeEntity(entity)
+		AutoAttachObjects(obj)
+	end
+	if IsValid(obj) then
+		self.override_parts = self.override_parts or {}
+		assert(not self.override_parts[name], "Part already overridden")
+		self.override_parts[name] = obj
+		self.override_parts_spot = self.override_parts_spot or {}
+		self.override_parts_spot[name] = spot
+	elseif self.override_parts then
+		obj = self.override_parts[name]
+		if self.attached_parts[name] == obj then
+			self.attached_parts[name] = nil
+		end
+		self.override_parts[name] = nil
+		self.override_parts_spot[name] = nil
+	end
+	self:ComposeBodyParts()
+	return obj
+end
+
+function CompositeBody:RemoveOverridePart(name)
+	local part = self:OverridePart(name, false)
+	if IsValid(part) then
+		self:RemoveBodyPart(part)
+	end
+end
+
+local composite_body_targets, composite_body_filters, composite_body_parts, composite_body_defs
+
+function CompositeBody:OnEditorSetProperty(prop_id, old_value, ged)
+	local prop_meta = self:GetPropertyMetadata(prop_id) or empty_table
+	if prop_meta.body_part_match then
+		composite_body_targets = nil
+	end
+	if prop_meta.body_part_filter then
+		self:ComposeBodyParts()
+	end
+	return Object.OnEditorSetProperty(self, prop_id, old_value, ged)
+end
+
+----
+-- Editor only code:
+
+local function UpdateItems()
+	if composite_body_targets then
+		return
+	end
+	composite_body_filters, composite_body_parts, composite_body_defs = {}, {}, {}
+	ClassDescendantsList("CompositeBody", function(class, def)
+		local target = def.composite_part_target or class
+		
+		local filters = composite_body_filters[target] or {}
+		for _, prop in ipairs(def:GetProperties()) do
+			if prop.body_part_filter then
+				filters[prop.id] = filters[prop.id] or prop
+			end
+		end
+		composite_body_filters[target] = filters
+		
+		local defs = composite_body_defs[target] or {}
+		if not defs[class] then
+			defs[class] = true
+			table.insert(defs, def)
+		end
+		composite_body_defs[target] = defs
+		
+		local parts = composite_body_parts[target] or {}
+		for _, part in ipairs(def.composite_part_names) do
+			table.insert_unique(parts, part)
+		end
+		composite_body_parts[target] = parts
+	end, "")
+	composite_body_targets = table.keys2(composite_body_parts, true, "")
+end
+
+function GetBodyPartEntityItems()
+	local items = {}
+	for entity in pairs(GetAllEntities()) do
+		local data = EntityData[entity]
+		if data then
+			items[#items + 1] = entity
+		end
+	end
+	table.sort(items)
+	table.insert(items, 1, "")
+	return items
+end
+
+function GetBodyPartNameItems(preset)
+	UpdateItems()
+	return composite_body_parts[preset.Target]
+end
+
+function GetBodyPartNameCombo(preset)
+	local items = table.copy(GetBodyPartNameItems(preset) or empty_table)
+	table.insert(items, 1, "")
+	return items
+end
+
+function GetBodyPartTargetItems(preset)
+	UpdateItems()
+	return composite_body_targets
+end
+
+function EntityStatesCombo(entity, ...)
+	entity = entity or ""
+	if entity == "" then
+		return { ... }
+	end
+	local anims = GetStates(entity)
+	table.sort(anims)
+	table.insert(anims, 1, "")
+	return anims
+end
+
+function EntityStateMomentsCombo(entity, anim, ...)
+	entity = entity or ""
+	anim = anim or ""
+	if entity == "" or anim == "" then
+		return { ... }
+	end
+	local moments = GetStateMomentsNames(entity, anim)
+	table.insert(moments, 1, "")
+	return moments
+end
+
+----
+
+DefineClass.CompositeBodyPreset = {
+	__parents = { "Preset" },
+	properties = {
+		{ id = "Target",       name = "Target",        editor = "choice",      default = "",    items = GetBodyPartTargetItems },
+		{ id = "Parts",        name = "Covered Parts", editor = "set",         default = false, items = GetBodyPartNameItems },
+		{ id = "CustomMatch",  name = "Custom Match",  editor = "bool",        default = false, },
+		{ id = "BodiesFound",  name = "Bodies Found",  editor = "text",        default = "", dont_save = true, read_only = 0, lines = 1, max_lines = 3, no_edit = PropChecker("CustomMatch", true) },
+		{ id = "Parent",       name = "Parent Part",   editor = "choice",      default = false, items = GetBodyPartNameItems },
+		{ id = "Entity",       name = "Entity",        editor = "choice",      default = "",    items = GetBodyPartEntityItems },
+		{ id = "PartClass",    name = "Custom Class",  editor = "text",        default = false, translate = false, validate = function(self) return self.PartClass and not g_Classes[self.PartClass] and "Invalid class" end },
+		{ id = "AttachSpot",   name = "Attach Spot",   editor = "text",        default = "",    translate = false, help = "Force attach spot" },
+		{ id = "Scale",        name = "Scale",         editor = "range",       default = def_scale },
+		{ id = "Axis",         name = "Axis",          editor = "point",       default = false, help = "Force a specific axis" },
+		{ id = "Angle",        name = "Angle",         editor = "number",      default = false, scale = "deg", min = -180*60, max = 180*60, slider = true, help = "Force a specific angle" },
+		{ id = "Mirrored",     name = "Mirrored",      editor = "bool",        default = false },
+		{ id = "SyncState",    name = "Sync State",    editor = "choice",      default = "auto", items = {true, false, "auto"}, help = "Force sync state" },
+		{ id = "ZOrder",       name = "ZOrder",        editor = "number",      default = 0,     },
+		{ id = "Weight",       name = "Weight",        editor = "number",      default = 1000,  min = 0, scale = 10 },
+		{ id = "FxActor",      name = "Fx Actor",      editor = "combo",       default = "",    items = ActorFXClassCombo },
+		{ id = "Filters",      name = "Filters",       editor = "nested_list", default = false, base_class = "CompositeBodyPresetFilter", inclusive = true },
+		{ id = "ColorInherit", name = "Color Inherit", editor = "choice",      default = "",    items = GetBodyPartNameCombo },
+		{ id = "Colors",       name = "Colors",        editor = "nested_list", default = false, base_class = "CompositeBodyPresetColor", inclusive = true, no_edit = function(self) return self.ColorInherit ~= "" end },
+		{ id = "Lights",       name = "Lights",        editor = "nested_list", default = false, base_class = "CompositeBodyPresetLight", inclusive = true },
+		{ id = "AffectedBy",   name = "Affected by",   editor = "choice",      default = "",    items = GetBodyPartNameCombo },
+		{ id = "EntityWhenAffected", name = "Entity when affected", editor = "choice", default = "", items = GetBodyPartEntityItems, no_edit = function(o) return not o.AffectedBy end },
+		{ id = "AttachOffset", name = "Attach Offset", editor = "point",       default = point30, },
+		{ id = "AttachAxis",   name = "Attach Axis",   editor = "point",       default = axis_z, },
+		{ id = "AttachAngle",  name = "Attach Angle",  editor = "number",      default = 0, scale = "deg", min = -180*60, max = 180*60, slider = true },
+		
+		{ id = "ApplyAnim",       name = "Apply Anim",        editor = "choice", default = "", items = function(self) return EntityStatesCombo(self.AnimTestEntity, "") end },
+		{ id = "UnapplyAnim",     name = "Unapply Anim",      editor = "choice", default = "", items = function(self) return EntityStatesCombo(self.AnimTestEntity, "") end },
+		{ id = "ApplyAnimMoment", name = "Apply Anim Moment", editor = "choice", default = "hit", items = function(self) return EntityStateMomentsCombo(self.AnimTestEntity, self.ApplyAnim, "", "hit") end, },
+		{ id = "AnimTestEntity",  name = "Anim Test Entity",  editor = "text",   default = false },
+	},
+	GlobalMap = "CompositeBodyPresets",
+	EditorMenubar = "Editors.Art",
+	EditorMenubarName = "Composite Body Parts",
+	EditorIcon = "CommonAssets/UI/Icons/atom molecule science.png",
+	
+	StoreAsTable = false,
+}
+
+CompositeBodyPreset.Documentation = [[The composite body system is a matching system for attaching parts to a body.
+
+A body collects its potential parts not from all part presets, but from a specified preset <style GedHighlight>Group</style>. The matched parts are those having the same <style GedHighlight>Target</style> property as the body target property.
+
+If no matching information is specified in the body, then its class name is used instead for all matching.
+
+Each part can contain filters for additional conditions during the matching process.
+
+Each part covers a specific named location on the body specified by <style GedHighlight>Covered Parts</style> property. If several parts are matched for the same location, a single one is chosen based on the <style GedHighlight>ZOrder</style> property. If there are still multiple parts with equal ZOrder, then a part is randomly selected based on the <style GedHighlight>Weight</style> property.]]
+
+function CompositeBodyPreset:GetError()
+	if self.CustomMatch then
+		return
+	end
+	local parts = self.Parts
+	if not next(parts) then
+		return "No covered parts specified!"
+	end
+	UpdateItems()
+	local defs = composite_body_defs[self.Target]
+	if not defs then
+		return string.format("No composite bodies found with target '%s'", self.Target)
+	end
+	local group = self.group
+	local count_group = 0
+	local count_part = 0
+	for _, def in ipairs(defs) do
+		local composite_part_groups = def.composite_part_groups or { def.class }
+		if table.find(composite_part_groups, group) then
+			count_group = count_group + 1
+			for _, part_name in ipairs(def.composite_part_names) do
+				if parts[part_name] then
+					count_part = count_part + 1
+					break
+				end
+			end
+		end
+	end
+	if count_group == 0 then
+		return string.format("No composite bodies found with group '%s'", tostring(group))
+	end
+	if count_part == 0 then
+		return string.format("No composite bodies found with parts %s", table.concat(table.keys(parts, true)))
+	end
+end
+
+function CompositeBodyPreset:GetBodiesFound()
+	UpdateItems()
+	local parts = self.Parts
+	if not next(parts) then
+		return 0
+	end
+	local found = {}
+	for _, def in ipairs(composite_body_defs[self.Target]) do
+		local composite_part_groups = def.composite_part_groups or { def.class }
+		if table.find(composite_part_groups, self.group) then
+			for _, part_name in ipairs(def.composite_part_names) do
+				if parts[part_name] then
+					found[def.class] = true
+					break
+				end
+			end
+		end
+	end
+	return table.concat(table.keys(found, true), ", ")
+end
+
+function CompositeBodyPreset:OnEditorSetProperty(prop_id, old_value, ged)
+	if prop_id == "Entity" then
+		for _, obj in ipairs(self.Colors) do
+			ObjModified(obj) -- properties for modifiable colors have changed
+		end
+	end
+end
+
+local function FindParentPreset(obj, member)
+	return GetParentTableOfKind(obj, "CompositeBodyPreset")
+end
+
+function OnMsg.ClassesGenerate()
+	DefineModItemPreset("CompositeBodyPreset", {
+		EditorSubmenu = "Other",
+		EditorName = "Composite body",
+		EditorShortcut = false,
+	})
+end
+
+----
+
+local function GetBodyFilters(filter)
+	UpdateItems()
+	local parent = FindParentPreset(filter)
+	local props = parent and composite_body_filters[parent.Target]
+	if not props then
+		return {}
+	end
+	local filters = {}
+	for _, def in ipairs(composite_body_defs[parent.Target]) do
+		for name, prop in pairs(props) do
+			local items
+			if prop.items then
+				items = prop_eval(prop.items, def, prop)
+			elseif prop.preset_class then
+				local filter = prop.preset_filter
+				items = {}
+				ForEachPreset(prop.preset_class, function(preset, group, items)
+					if not filter or filter(preset) then
+						items[#items + 1] = preset.id
+					end
+				end, items)
+				table.sort(items)
+			end
+			if items and #items > 0 then
+				local prev_filters = filters[name]
+				if not prev_filters then
+					filters[name] = items
+				else
+					for _, value in ipairs(items) do
+						table.insert_unique(prev_filters, value)
+					end
+				end
+			end
+		end
+	end
+	return filters
+end
+
+local function GetFilterNameItems(filter)
+	local filters = GetBodyFilters(filter)
+	local items = filters and table.keys(filters, true)
+	if items[1] ~= "" then
+		table.insert(items, 1, "")
+	end
+	return items
+end
+
+local function GetFilterValueItems(filter)
+	local filters = GetBodyFilters(filter)
+	return filters and filters[filter.Name] or {""}
+end
+
+DefineClass.CompositeBodyPresetFilter = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "Name",  name = "Name",  editor = "choice", default = "", items = GetFilterNameItems, },
+		{ id = "Value", name = "Value", editor = "choice", default = "", items = GetFilterValueItems, },
+		{ id = "Test",  name = "Test",  editor = "choice", default = "=", items = {"=", ">", "<"}, },
+	},
+	EditorView = Untranslated("<Name> <Test> <Value>"),
+}
+
+function CompositeBodyPresetFilter:Match(obj)
+	local obj_value, value, test = obj[self.Name], self.Value, self.Test
+	if test == '=' then
+		return obj_value == value
+	elseif test == '>' then
+		return obj_value > value
+	elseif test == '<' then
+		return obj_value < value
+	end
+end
+
+----
+
+DefineClass.CompositeBodyPresetColor = {
+	__parents = { "ColorizationPropSet" },
+	properties = {
+		{ id = "Weight",  name = "Weight",  editor = "number", default = 1000, min = 0, scale = 10 },
+	},
+}
+
+function CompositeBodyPresetColor:GetMaxColorizationMaterials()
+	PopulateParentTableCache(self)
+	if not ParentTableCache[self] then
+		return ColorizationPropSet.GetMaxColorizationMaterials(self)
+	end
+	local parent = FindParentPreset(self)
+	return parent and ColorizationMaterialsCount(parent.Entity) or 0
+end
+
+function CompositeBodyPresetColor:GetError()
+	if self:GetMaxColorizationMaterials() == 0 then
+		local parent = FindParentPreset(self)
+		if not parent or parent.Entity == "" then
+			return "The composite body entity is not set."
+		else
+			return "There are no modifiable colors in the composite body entity."
+		end
+	end
+end
+
+----
+
+local light_props = {}
+function OnMsg.ClassesBuilt()
+	local function RegisterProps(class, classdef)
+		local props = {}
+		for _, prop in ipairs(classdef:GetProperties()) do
+			if prop.category == "Visuals"
+			and not prop_eval(prop.no_edit, classdef, prop)
+			and not prop_eval(prop.read_only, classdef, prop) then
+				props[#props + 1] = prop
+				props[prop.id] = classdef:GetDefaultPropertyValue(prop.id, prop)
+			end
+		end
+		light_props[class] = props
+	end
+	RegisterProps("Light", Light)
+	ClassDescendants("Light", RegisterProps)
+end
+
+function OnMsg.GatherFXActors(list)
+	for _, preset in pairs(CompositeBodyPresets) do
+		if (preset.FxActor or "") ~= "" then
+			list[#list + 1] = preset.FxActor
+		end
+	end
+end
+
+function OnMsg.DataLoaded()
+	PopulateParentTableCache(Presets.CompositeBodyPreset)
+end
+
+local function GetEntitySpotsItems(light)
+	local parent = FindParentPreset(light)
+	local entity = parent and parent.Entity or ""
+	local states = IsValidEntity(entity) and GetStates(entity) or ""
+	if #states == 0 then return empty_table end
+	local idx = table.find(states, "idle")
+	local spots = {}
+	local spbeg, spend = GetAllSpots(entity, states[idx] or states[1])
+	for spot = spbeg, spend do
+		spots[GetSpotName(entity, spot)] = true
+	end
+	return table.keys(spots, true)
+end
+
+DefineClass.CompositeBodyPresetLight = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ id = "LightType",  name = "Light Type", editor = "choice", default = "Light",  items = ToCombo(light_props) },
+		{ id = "LightSpot",  name = "Light Spot", editor = "combo",  default = "Origin", items = GetEntitySpotsItems },
+		{ id = "LightSIEnable",     name = "SI Apply", editor = "bool", default = true },
+		{ id = "LightSIModulation", name = "SI Modulation", editor = "number", default = 255, min = 0, max = 255, slider = true, no_edit = function(self) return not self.LightSIEnable end  },
+		{ id = "night_mode", name = "Night mode", editor = "dropdownlist", items = { "Off", "On" }, default = "On" },
+		{ id = "day_mode",   name = "Day mode",   editor = "dropdownlist", items = { "Off", "On" }, default = "Off" },
+	},
+	EditorView = Untranslated("<LightType>: <LightSpot>"),
+}
+
+function CompositeBodyPresetLight:GetError()
+	if not light_props[self.LightType] then
+		return "Invalid light type selected!"
+	end
+end
+
+function CompositeBodyPresetLight:ApplyToLight(light)
+	local props = light_props[self.LightType] or empty_table
+	for _, prop in ipairs(props) do
+		local prop_id = prop.id
+		local prop_value = rawget(self, prop_id)
+		if prop_value ~= nil then
+			light:SetProperty(prop_id, prop_value)
+		end
+	end
+end
+
+function CompositeBodyPresetLight:GetProperties()
+	local props = table.icopy(self.properties)
+	table.iappend(props, light_props[self.LightType] or empty_table)
+	return props
+end
+
+function CompositeBodyPresetLight:GetDefaultPropertyValue(prop_id, prop_meta)
+	local def = table.get(light_props, self.LightType, prop_id)
+	if def ~= nil then
+		return def
+	end
+	return PropertyObject.GetDefaultPropertyValue(self, prop_id, prop_meta)
+end
+
+DefineClass.BaseLightObject = {
+	__parents = { "Object" },
+}
+
+function BaseLightObject:UpdateLight(lm, delayed)
+end
+
+function BaseLightObject:GameInit()
+	Game:AddToLabel("Lights", self)
+end
+
+function BaseLightObject:Done()
+	Game:RemoveFromLabel("Lights", self)
+end
+
+if FirstLoad then
+	UpdateLightsThread = false
+end
+
+function OnMsg.DoneMap()
+	UpdateLightsThread = false
+end
+
+function UpdateLights(lm, delayed)
+	local lights = table.get(Game, "labels", "Lights")
+	for _, obj in ipairs(lights) do
+		obj:UpdateLight(lm, delayed)
+	end
+end
+
+function UpdateLightsDelayed(lm, delayed_time)
+	DeleteThread(UpdateLightsThread)
+	UpdateLightsThread = false
+	if delayed_time > 0 then
+		UpdateLightsThread = CreateGameTimeThread(function(lm, delayed_time)
+			Sleep(delayed_time)
+			UpdateLights(lm, true)
+			UpdateLightsThread = false
+		end, lm, delayed_time)
+	else
+		UpdateLights(lm)
+	end
+end
+
+function OnMsg.LightmodelChange(view, lm, time)
+	UpdateLightsDelayed(lm, time/2)
+end
+
+function OnMsg.GatherAllLabels(labels)
+	labels.Lights = true
+end
+
+DefineClass.CompositeLightObject = {
+	__parents = { "CompositeBody", "BaseLightObject" },
+
+	light_parts = false,
+	light_objs = false,
+}
+
+function CompositeLightObject:ComposeBodyParts(seed)
+	self.light_parts = nil
+	
+	local changed = CompositeBody.ComposeBodyParts(self, seed)
+	
+	local light_parts = self.light_parts
+	local light_objs = self.light_objs
+	for i = #(light_objs or ""),1,-1 do
+		local config = light_objs[i]
+		local part = light_parts and light_parts[config]
+		if not part then
+			DoneObject(light_objs[config])
+			light_objs[config] = nil
+			table.remove_value(light_objs, config)
+		end
+	end
+	for _, config in ipairs(light_parts) do
+		light_objs = light_objs or {}
+		if light_objs[config] == nil then
+			light_objs[config] = false
+			light_objs[#light_objs + 1] = config
+		end
+	end
+	self.light_objs = light_objs
+	
+	return changed
+end
+
+function CompositeLightObject:ApplyBodyPart(part, preset, ...)
+	local light_parts = self.light_parts
+	for _, config in ipairs(preset.Lights) do
+		light_parts = light_parts or {}
+		light_parts[config] = part
+		light_parts[#light_parts + 1] = config
+	end
+	self.light_parts = light_parts
+	
+	return CompositeBody.ApplyBodyPart(self, part, preset, ...)
+end
+
+function CompositeLightObject:IsBodyPartLightOn(config)
+	local mode = GameState.Night and config.night_mode or config.day_mode
+	return mode == "On"
+end
+
+function CompositeLightObject:UpdateLight(delayed)
+	local light_objs = self.light_objs or empty_table
+	local IsBodyPartLightOn = self.IsBodyPartLightOn
+	for _, config in ipairs(light_objs) do
+		local light = light_objs[config]
+		local part = self.light_parts[config]
+		local turned_on = IsBodyPartLightOn(self, config)
+		if turned_on and not light then
+			light = PlaceObject(config.LightType)
+			config:ApplyToLight(light)
+			part:Attach(light, GetSpotBeginIndex(part, config.LightSpot))
+			light_objs[config] = light
+		elseif not turned_on and light then
+			DoneObject(light)
+			light_objs[config] = false
+		end
+		if config.LightSIEnable then
+			part:SetSIModulation(turned_on and config.LightSIModulation or 0)
+		end
+	end
+end
+
+----
+
+DefineClass.BlendedCompositeBody = {
+	__parents = { "CompositeBody", "Object" },
+	composite_part_blend = false,
+	
+	blended_body_parts_params = false,
+	blended_body_parts = false,
+}
+
+function BlendedCompositeBody:Init()
+	self.blended_body_parts_params = { }
+	self.blended_body_parts = { }
+end
+
+function BlendedCompositeBody:ForceComposeBlendedBodyParts()
+	self.blended_body_parts_params = { }
+	self.blended_body_parts = { }
+	self:ComposeBodyParts()
+end
+
+function BlendedCompositeBody:ForceRevertBlendedBodyParts()
+	if next(self.attached_parts) then
+		local part_to_preset = {}
+		self:CollectBodyParts(part_to_preset)
+		for name,preset in sorted_pairs(part_to_preset) do
+			local part = self.attached_parts[name]
+			local entity = preset.Entity
+			if IsValid(part) and IsValidEntity(entity) then
+				Msg("RevertBlendedBodyPart", part)
+				part:ChangeEntity(entity)
+			end
+		end
+	end
+end
+
+function BlendedCompositeBody:UpdateBlendPartParams(params, part, preset, name, seed)
+	return part:GetEntity()
+end
+
+function BlendedCompositeBody:ShouldBlendPart(params, part, preset, name, seed)
+	return false
+end
+
+if FirstLoad then
+	g_EntityBlendLocks = { }
+	--g_EntityBlendLog = { }
+end
+
+local function BlendedEntityLocksGet(entity_name)
+	return g_EntityBlendLocks[entity_name] or 0
+end
+
+function BlendedEntityIsLocked(entity_name)
+	--table.insert(g_EntityBlendLog, GameTime() .. " lock " .. entity_name)
+	return BlendedEntityLocksGet(entity_name) > 0
+end
+
+function BlendedEntityLock(entity_name)
+	--table.insert(g_EntityBlendLog, GameTime() .. " unlock " .. entity_name)
+	g_EntityBlendLocks[entity_name] = BlendedEntityLocksGet(entity_name) + 1
+end
+
+function BlendedEntityUnlock(entity_name)
+	local locks_count = BlendedEntityLocksGet(entity_name)
+	assert(locks_count >= 1, "Unlocking a blended entity that isn't locked")
+	if locks_count > 1 then
+		g_EntityBlendLocks[entity_name] = locks_count - 1
+	else
+		g_EntityBlendLocks[entity_name] = nil
+	end
+end
+
+function WaitBlendEntityLocks(obj, entity_name)
+	while BlendedEntityIsLocked(entity_name) do
+		if obj and not IsValid(obj) then
+			return false
+		end
+		WaitNextFrame(1)
+	end
+	
+	return true
+end
+
+function BlendedCompositeBody:BlendEntity(t, e1, e2, e3, w1, w2, w3, m2, m3)
+	--table.insert(g_EntityBlendLog, GameTime() .. " " .. self.class .. " blend " .. t)
+	assert(BlendedEntityIsLocked(t), "To blend an entity you must lock it using BlendedEntityLock")
+	assert(t ~= e1 and t ~= e2 and t ~= e3)
+
+	SetMaterialBlendMaterials(
+		GetEntityIdleMaterial(t), --target
+		GetEntityIdleMaterial(e1), --base
+		m2, GetEntityIdleMaterial(e2), --weight 1, material
+		m3, GetEntityIdleMaterial(e3)) --weight 2, material
+	WaitNextFrame(1)
+	
+	local err = AsyncOpWait(nil, nil, "AsyncMeshBlend", 
+		t, 0, --target, LOD
+		e1, w1, --entity 1, weight
+		e2, w2, --entity 2, weight
+		e3, w3) --entity 3, weight
+	if err then print("Failed to blend meshes: ", err) end
+end
+
+function BlendedCompositeBody:AsyncBlendEntity(obj, t, e1, e2, e3, w1, w2, w3, m2, m3, callback)
+	return CreateRealTimeThread(function(self, obj, t, e1, e2, e3, w1, w2, w3, m2, m3, callback)
+		WaitBlendEntityLocks(obj, t)
+		BlendedEntityLock(t)
+		
+		self:BlendEntity(t, e1, e2, e3, w1, w2, w3, m2, m3)
+		
+		if callback then
+			callback(self, obj, t, e1, e2, e3, w1, w2, w3, m2, m3)
+		end
+		
+		BlendedEntityUnlock(t)
+	end, self, obj, t, e1, e2, e3, w1, w2, w3, m2, m3, callback)
+end
+
+function BlendedCompositeBody:ApplyBlendBodyPart(blended_entity, part, preset, name, seed)
+	return CompositeBody.ApplyBodyPart(self, preset, name, seed)
+end
+
+function BlendedCompositeBody:BlendBodyPartFailed(blended_entity, part, preset, name, seed)
+	return CompositeBody.ApplyBodyPart(self, part, preset, name, seed)
+end
+
+-- if the body part is declared as "to be blended"
+function BlendedCompositeBody:IsBlendBodyPart(name)
+	return self.composite_part_blend and self.composite_part_blend[name]
+end
+
+-- if the body part is using a blended entity or is being blended at the moment
+function BlendedCompositeBody:IsCurrentlyBlendedBodyPart(name)
+	return self.blended_body_parts and self.blended_body_parts[name]
+end
+
+function BlendedCompositeBody:ColorizeBodyPart(part, preset, name, seed)
+	if self:IsCurrentlyBlendedBodyPart(name) then
+		return
+	end
+	return CompositeBody.ColorizeBodyPart(self, part, preset, name, seed)
+end
+
+function BlendedCompositeBody:ChangeBodyPartEntity(part, preset, name)
+	if self:IsCurrentlyBlendedBodyPart(name) then
+		return
+	end
+	return CompositeBody.ChangeBodyPartEntity(self, part, preset, name)
+end
+
+function BlendedCompositeBody:ApplyBodyPart(part, preset, name, seed)
+	if self:IsBlendBodyPart(name) then
+		self.blended_body_parts_params = self.blended_body_parts_params or { }
+		local params = self.blended_body_parts_params[name]
+		if not params or self:ShouldBlendPart(params, part, preset, name, seed) then
+			params = params or { }
+			local blended_entity = self:UpdateBlendPartParams(params, part, preset, name, seed)
+			if IsValidEntity(blended_entity) then
+				self.blended_body_parts_params[name] = params
+				self.blended_body_parts[name] = (self.blended_body_parts[name] or 0) + 1
+				return self:ApplyBlendBodyPart(blended_entity, part, preset, name, seed)
+			else
+				self.blended_body_parts[name] = nil
+				return self:BlendBodyPartFailed(blended_entity, part, preset, name, seed)
+			end
+		end
+	end
+	
+	return CompositeBody.ApplyBodyPart(self, part, preset, name, seed)
+end
+
+function BlendedCompositeBody:RemoveBodyPart(part, name)
+	if self:IsBlendBodyPart(name) and self.blended_body_parts_params then
+		self.blended_body_parts_params[name] = nil
+	end
+	return CompositeBody.RemoveBodyPart(self, part, name)
+end
+
+function ForceRecomposeAllBlendedBodies()
+	local objs = MapGet("map", "BlendedCompositeBody")
+	for i,obj in ipairs(objs) do
+		obj:ForceRevertBlendedBodyParts()
+	end
+	for i,obj in ipairs(objs) do
+		obj:ForceComposeBlendedBodyParts()
+	end
+end
+
+function OnMsg.PostLoadGame()
+	ForceRecomposeAllBlendedBodies()
+end
+
+function OnMsg.AdditionalEntitiesLoaded()
+	if type(__cobjectToCObject) ~= "table" then return end
+	ForceRecomposeAllBlendedBodies()
+end
+
+local body_to_states
+function CompositeBodyAnims(classdef)
+	local id = classdef.id or classdef.class
+	body_to_states = body_to_states or {}
+	local states = body_to_states[id]
+	if not states then
+		local entity = ResolveTemplateEntity(classdef)
+		states = IsValidEntity(entity) and GetStates(entity) or empty_table
+		table.sort(states)
+		body_to_states[id] = states
+	end
+	return states
+end
+
+function SavegameFixups.BlendedBodyPartsList()
+	MapForEach(true, "BlendedCompositeBody", function(obj)
+		obj.blended_body_parts = {}
+	end)
+end
+
+function SavegameFixups.BlendedBodyBlendIDs()
+	MapForEach(true, "BlendedCompositeBody", function(obj)
+		for name in pairs(obj.blended_body_parts) do
+			obj.blended_body_parts[name] = 1
+		end
+	end)
+end
+
+function SavegameFixups.FixSyncStateFlag2()
+	MapForEach(true, "CompositeBody", "Building", function(obj)
+		obj:ClearGameFlags(const.gofSyncState)
+		obj:SetGameFlags(const.gofPropagateState)
+	end)
+end

CommonLua/Classes/Context.lua

@@ -0,0 +1,125 @@
+--- An object which can resolve a key to a value.
+-- Context objects can be nested to create a complex value resolution structure.
+-- The global function ResolveValue allows resolving a tuple to a value in an arbitrary context.
+
+DefineClass.Context = {
+	__parents = {},
+	__hierarchy_cache = true,	
+}
+
+function Context:new(obj)
+	return setmetatable(obj or {}, self)
+end
+
+function Context:ResolveValue(key)
+	local value = rawget(self, key)
+	if value ~= nil then return value end
+	for _, sub_context in ipairs(self) do
+		value = ResolveValue(sub_context, key)
+		if value ~= nil then return value end
+	end
+end
+
+-- change __index method to allow full member resolution without warning
+function OnMsg.ClassesBuilt()
+	local context_class = g_Classes.Context
+	context_class.__index = function (self, key)
+		if type(key) == "string" then
+			return rawget(context_class, key) or context_class.ResolveValue(self, key)
+		end
+	end
+end
+
+function Context:IsKindOf(class)
+	if IsKindOf(self, class) then return true end
+	for _, sub_context in ipairs(self) do
+		if IsKindOf(sub_context, "Context") and sub_context:IsKindOf(class) or IsKindOf(sub_context, class) then
+			return true
+		end
+	end
+end
+
+function Context:IsKindOfClasses(...)
+	if IsKindOfClasses(self, ...) then return true end
+	for _, sub_context in ipairs(self) do
+		if IsKindOf(sub_context, "Context") and sub_context:IsKindOfClasses(...) or IsKindOfClasses(sub_context, ...) then
+			return true
+		end
+	end
+end
+
+function ForEachObjInContext(context, f, ...)
+	if not context then return end
+	if IsKindOf(context, "Context") then
+		for _, sub_context in ipairs(context) do
+			ForEachObjInContext(sub_context, f, ...)
+		end
+	else
+		f(context, ...)
+	end
+end
+
+function SubContext(context, t)
+	assert(not IsKindOf(t, "PropertyObject"))
+	t = t or {}
+	if IsKindOf(context, "PropertyObject") or type(context) ~= "table" then
+		t[#t + 1] = context
+	elseif type(context) == "table" then
+		for _, obj in ipairs(context) do
+			t[#t + 1] = obj
+		end
+		for k, v in pairs(context) do
+			if rawget(t, k) == nil then
+				t[k] = v
+			end
+		end
+	end
+	return Context:new(t)
+end
+
+function ResolveValue(context, key, ...)
+	if key == nil then return context end
+	if type(context) == "table" then
+		if IsKindOfClasses(context, "Context", "PropertyObject") then
+			return ResolveValue(context:ResolveValue(key), ...)
+		end
+		return ResolveValue(rawget(context, key), ...)
+	end
+end
+
+function ResolveFunc(context, key)
+	if key == nil then return end
+	if type(context) == "table" then
+		if IsKindOf(context, "Context") then
+			local f = rawget(context, key)
+			if type(f) == "function" then
+				return f
+			end
+			for _, sub_context in ipairs(context) do
+				local f, obj = ResolveFunc(sub_context, key)
+				if f ~= nil then return f, obj end
+			end
+			return
+		end
+		if IsKindOf(context, "PropertyObject") and context:HasMember(key) then
+			local f = context[key]
+			if type(f) == "function" then return f, context end
+		else
+			local f = rawget(context, key)
+			if f == false or type(f) == "function" then return f end
+		end
+	end
+end
+
+function ResolvePropObj(context)
+	if IsKindOf(context, "PropertyObject") then
+		return context
+	end
+	if IsKindOf(context, "Context") then
+		for _, sub_context in ipairs(context) do
+			local obj = ResolvePropObj(sub_context)
+			if obj then return obj end
+		end
+	end
+end
+

CommonLua/Classes/ContinuousEffect.lua

@@ -0,0 +1,195 @@
+local hintColor = RGB(210, 255, 210)
+
+
+----- ContinuousEffect
+
+DefineClass.ContinuousEffect = {
+	__parents = { "Effect" },
+	properties = {
+		{ id = "Id", editor = "text", help = "A unique Id allowing you to later stop this effect using StopEffect/StopGlobalEffect; optional", default = "",
+		  no_edit = function(obj) return obj.Id:starts_with("autoid") end,
+		},
+	},
+	CreateInstance = false,
+	EditorExcludeAsNested = true,
+	container = false, -- restored in ModifiersPreset:PostLoad(), won't be valid if the ContinuousEffect is not stored in a ModifiersPreset
+}
+
+function ContinuousEffect:Execute(object, ...)
+	self:ValidateObject(object)
+	assert(IsKindOf(object, "ContinuousEffectContainer"))
+	object:StartEffect(self, ...)
+end
+
+if FirstLoad then
+	g_MaxContinuousEffectId = 0
+end
+
+function ContinuousEffect:OnEditorNew(parent, ged, is_paste)
+	-- ContinuousEffects embedded in a parent ContinuousEffect are managed by
+	-- the parent effect and have an auto-generated internal uneditable Id
+	local obj = ged:GetParentOfKind(parent, "PropertyObject")
+	if obj and (obj:IsKindOf("ContinuousEffect") or obj:HasMember("ManagesContinuousEffects") and obj.ManagesContinuousEffects) then
+		g_MaxContinuousEffectId = g_MaxContinuousEffectId + 1
+		self.Id = "autoid" .. tostring(g_MaxContinuousEffectId)
+	elseif self.Id:starts_with("autoid") then
+		self.Id = ""
+	elseif ged.app_template:starts_with("Mod") then
+		local mod_item = IsKindOf(parent, "ModItem") and parent or ged:GetParentOfKind(parent, "ModItem")
+		local mod_def = mod_item.mod
+		self.Id = mod_def:GenerateModItemId(self)
+	end
+	self.container = obj
+end
+
+function ContinuousEffect:__fromluacode(table)
+	local obj = Effect.__fromluacode(self, table)
+	local id = obj.Id
+	if id:starts_with("autoid") then
+		g_MaxContinuousEffectId = Max(g_MaxContinuousEffectId, tonumber(id:sub(7, -1)))
+	end
+	return obj
+end
+
+function ContinuousEffect:__toluacode(...)
+	local old = self.container
+	self.container = nil -- restored in ModifiersPreset:PostLoad()
+	local ret = Effect.__toluacode(self, ...)
+	self.container = old
+	return ret
+end
+
+
+----- ContinuousEffectDef
+
+DefineClass.ContinuousEffectDef = {
+	__parents = { "EffectDef" },
+	group = "ContinuousEffects",
+	DefParentClassList = { "ContinuousEffect" },
+	GedEditor = "ClassDefEditor",
+}
+
+function ContinuousEffectDef:OnEditorNew(parent, ged, is_paste)
+	if is_paste then return end
+
+	-- remove Execute/__exec metod
+	for i = #self, 1, -1 do
+		if IsKindOf(self[i], "ClassMethodDef") and (self[i].name == "Execute" and self[i].name == "__exec" )then
+			table.remove(self, i)
+			break
+		end	
+	end
+	-- add CreateInstance, Start, Stop, and Id
+	local idx = #self + 1
+	self[idx] = self[idx] or ClassMethodDef:new{ name = "OnStart", params = "obj, context"}
+	idx = idx + 1
+	self[idx] = self[idx] or ClassMethodDef:new{ name = "OnStop", params = "obj, context"}
+	table.insert(self, 1, ClassConstDef:new{ id = "CreateInstance", name = "CreateInstance" , type = "bool", })
+end
+
+function ContinuousEffectDef:CheckExecMethod()
+	local start = self:FindSubitem("Start")
+	local stop = self:FindSubitem("Stop")
+	if start and (start.class ~= "ClassMethodDef" or start.code == ClassMethodDef.code)  or 
+		stop and (stop.class ~= "ClassMethodDef" or stop.code == ClassMethodDef.code) then
+		return {[[--== Start & Stop ==--
+Add Start and Stop methods that implement the effect. 
+]], hintColor, table.find(self, start), table.find(self, stop) }
+	end
+end
+
+function ContinuousEffectDef:GetError()
+	local id = self:FindSubitem("CreateInstance")
+	if not id then
+		return "The CreateInstance constant is required for ContinuousEffects."
+	end
+end
+
+
+----- ContinuousEffectContainer
+
+DefineClass.ContinuousEffectContainer = {
+	__parents = {"InitDone"},
+	effects = false,	
+}
+
+function ContinuousEffectContainer:Done()
+	for _, effect in ipairs(self.effects or empty_table) do
+		effect:OnStop(self)
+	end
+	self.effects = false
+end
+
+function ContinuousEffectContainer:StartEffect(effect, context)
+	self.effects = self.effects or {}
+	
+	local id = effect.Id or ""
+	if id == "" then
+		id = effect
+	end
+	if self.effects[id] then
+		-- TODO: Add an AllowReplace property and assert whether AllowReplace is true?
+		self:StopEffect(id)
+	end
+	if effect.CreateInstance then
+		effect = effect:Clone()
+	end
+	self.effects[id] = effect
+	self.effects[#self.effects + 1] = effect
+	effect:OnStart(self, context)
+	Msg("OnEffectStarted", self, effect)
+	assert(effect.CreateInstance or not effect:HasNonPropertyMembers()) -- please set the CreateInstance class constant to 'true' to use dynamic members
+end
+
+function ContinuousEffectContainer:StopEffect(id)
+	if not self.effects then return end
+	local effect = self.effects[id]
+	if not effect then return end
+	effect:OnStop(self)
+	table.remove_entry(self.effects, effect)
+	self.effects[id] = nil
+	Msg("OnEffectEnded", self, effect)
+end
+
+----- InfopanelMessage Effects
+
+MapVar("g_AdditionalInfopanelSectionText", {})
+function GetAdditionalInfopanelSectionText(sectionId, obj)	
+	if not sectionId or sectionId=="" then
+		return ""
+	end	
+	local section = g_AdditionalInfopanelSectionText[sectionId]
+	if not section or not next(section) then 
+		return ""
+	end
+	local texts = {}
+	for label, text in pairs(section) do
+		if label== "__AllSections" or IsKindOf(obj, label) then
+			texts[#texts + 1] = text
+		end
+	end
+	if not next(texts)then 
+		return ""
+	end
+	return table.concat(texts, "\n")
+end
+
+function AddAdditionalInfopanelSectionText(sectionId, label, text, color, object, context)
+	local style = "Infopanel"
+	if color == "red" then
+		style = "InfopanelError"
+	elseif	color == "green" then
+		style = "InfopanelBonus"	
+	end
+	local section = g_AdditionalInfopanelSectionText[sectionId] or {}
+	label = label or "__AllSections"
+	section[label] =  T{410957252932, "<textcolor><text></color>", textcolor = "<color " .. style .. ">", text = T{text, object, context}}	
+	g_AdditionalInfopanelSectionText[sectionId] = section
+end
+
+function RemoveAdditionalInfopanelSectionText(sectionId, label)
+	if g_AdditionalInfopanelSectionText[sectionId] then
+		label = label or "__AllSections"
+		g_AdditionalInfopanelSectionText[sectionId][label]= nil
+	end
+end

CommonLua/Classes/Decal.lua

@@ -0,0 +1,50 @@
+-- base class required for filtering in map editor
+DefineClass.Decal = {
+	__parents = { "CObject" },
+	flags = { efSelectable = false, efSunShadow = false, efShadow = false, cofComponentColorizationMaterial = true, },
+
+	properties = {
+		{ category = "Decal", id = "sort_priority", name = "SortPriority", editor = "number", default = 0, max = 3, min = -4, template = true }
+	}
+}
+
+function Decal:SetShadowOnly(bSet)
+	if g_CMTPaused then return end
+	if bSet then
+		self:SetHierarchyGameFlags(const.gofSolidShadow)
+	else
+		self:ClearHierarchyGameFlags(const.gofSolidShadow)
+	end
+end
+
+DefineClass.TerrainDecal = 
+{
+	__parents = { "Decal", "EntityClass" },
+	flags = { cfDecal = true },
+}
+
+DefineClass.BakedTerrainDecal = 
+{
+	__parents = { "TerrainDecal", "InvisibleObject" },
+	flags = { cfConstructible = false, efBakedTerrainDecal = true },
+	max_allowed_radius = hr.TR_DecalSearchRadius * guim,
+}
+
+function BakedTerrainDecal:ConfigureInvisibleObjectHelper(helper)
+	helper:SetColorModifier(RGBRM(60, 60, 60, 127, 127))
+	helper:SetScale(35)
+	self:SetVisible(true)
+end
+
+DefineClass.BakedTerrainDecalLarge = 
+{
+	__parents = { "BakedTerrainDecal" },
+	flags = { efBakedTerrainDecalLarge = true },
+}
+
+DefineClass.BakedTerrainDecalDetailed = 
+{
+	__parents = { "BakedTerrainDecal" },
+	flags = { gofDetailedDecal = true },
+	max_allowed_radius = hr.TR_DetailedDecalSearchRadius * guim,
+}

CommonLua/Classes/DeveloperOptions.lua

@@ -0,0 +1,73 @@
+DefineClass.DeveloperOptions = {
+	__parents = { "PropertyObject" },
+	option_name = "",
+}
+
+function DeveloperOptions:GetProperty(property)
+	local meta = table.find_value(self.properties, "id", property)
+	if meta and not prop_eval(meta.dont_save, self, meta) then
+		return GetDeveloperOption(property, self.class, self.option_name, meta.default)
+	end
+	return PropertyObject.GetProperty(self, property)
+end
+
+function DeveloperOptions:SetProperty(property, value)
+	local meta = table.find_value(self.properties, "id", property)
+	if meta and not prop_eval(meta.dont_save, self, meta) then
+		return SetDeveloperOption(property, value, self.class, self.option_name)
+	end
+	return PropertyObject.SetProperty(self, property, value)
+end
+
+function GetDeveloperOption(option, storage, substorage, default)
+	storage = storage or "Developer"
+	substorage = substorage or "General"
+	local ds = LocalStorage and LocalStorage[storage]
+	return ds and ds[substorage] and ds[substorage][option] or default or false
+end
+
+function SetDeveloperOption(option, value, storage, substorage)
+	if not LocalStorage then
+		print("no local storage available!")
+		return
+	end
+	storage = storage or "Developer"
+	substorage = substorage or "General"
+	value = value or nil
+	local infos = LocalStorage[storage] or {}
+	local info = infos[substorage] or {}
+	info[option] = value
+	infos[substorage] = info
+	LocalStorage[storage] = infos
+	Msg("DeveloperOptionsChanged", storage, substorage, option, value)
+	DelayedCall(0, SaveLocalStorage)
+end
+
+function GetDeveloperHistory(class, name)	
+	if not LocalStorage then
+		return {}
+	end
+	
+	local history = LocalStorage.History or {}
+	LocalStorage.History = history
+	
+	history[class] = history[class] or {}
+	local list = history[class][name] or {}
+	history[class][name] = list
+	
+	return list
+end
+
+function AddDeveloperHistory(class, name, entry, max_size, accept_empty)
+	max_size = max_size or 20
+	if not LocalStorage or not accept_empty and (entry or "") == "" then
+		return
+	end
+	local history = GetDeveloperHistory(class, name)
+	table.remove_entry(history, entry)
+	table.insert(history, 1, entry)
+	while #history > max_size do
+		table.remove(history)
+	end
+	SaveLocalStorageDelayed()
+end

CommonLua/Classes/DuckingParams.lua

@@ -0,0 +1,70 @@
+DefineClass.DuckingParam = {
+	__parents = { "Preset" },
+	GlobalMap = "DuckingParams",
+
+	properties = { 
+		{ id = "Name",		name = "Name",					editor = "text",	default = ""	,																help = "The name with which this ducking tier will appear in the sound type editor." },
+		{ id = "Tier",		name = "Tier",					editor = "number", default = 0,		min = -1, max = 100,  								   help = "Which tiers will be affected by this one - lower tiers affect higher ones." },
+		{ id = "Strength",	name = "Strength",				editor = "number",	default = 100,	min = 0,  max = 1000, scale = 1, slider = true, help = "How much will this tier duck the ones below it." },
+		{ id = "Attack",	name = "Attack Duration",		editor = "number",	default = 100,  min = 0,  max = 1000, scale = 1, slider = true, help = "How long will this tier take to go from no effect to full ducking in ms." },
+		{ id = "Release",	name = "Release Duration",	editor = "number",	default = 100,	min = 0,  max = 1000, scale = 1, slider = true, help = "How long will this tier take to go from full ducking to no effect in ms." },
+		{ id = "Hold",		name = "Hold Duration",		editor = "number", default = 100, 	min = 0,  max = 5000, scale = 1, slider = true,	help = "How long will this tier take, before starting to decay the ducking strength, after the sound strength decreases." },
+		{ id = "Envelope",	name = "Use side chain",		editor = "bool",	default = true,																help = "Should the sounds in this preset modify the other sounds based on the current strength of their sound, or apply a constant static effect." },
+	},
+	
+	OnEditorSetProperty = function(properties)
+		ReloadDucking()
+	end,
+
+	Apply = function(self)
+		ReloadDucking()
+	end,
+	
+	EditorMenubarName = "Ducking Editor",
+	EditorMenubar = "Editors.Audio",
+	EditorIcon = "CommonAssets/UI/Icons/church.png",
+}
+
+function ReloadDucking()
+	local names = {}
+	local tiers = {}
+	local strengths = {}
+	local attacks = {}
+	local releases = {}
+	local hold = {}
+	local envelopes = {}
+	local i = 1
+	for _, p in pairs(DuckingParams) do
+		names[i] = p.id
+		tiers[i] = p.Tier
+		strengths[i] = p.Strength
+		attacks[i] = p.Attack
+		releases[i] = p.Release
+		hold[i] = p.Hold
+		envelopes[i] = p.Envelope and 1 or 0
+		i = i + 1
+	end
+	LoadDuckingParams(names, tiers, strengths, attacks, releases, hold, envelopes)
+	ReloadSoundTypes()
+end
+
+function ChangeDuckingPreset(id, tier, str, attack, release, hold)
+	if tier then
+		DuckingParams[id].Tier = tier
+	end
+	if str then
+		DuckingParams[id].Strength = str
+	end
+	if attack then
+		DuckingParams[id].Attack = attack
+	end
+	if release then
+		DuckingParams[id].Release = release
+	end
+	if hold then
+		DuckingParams[id].Hold = hold
+	end
+	ReloadDucking()
+end
+
+OnMsg.DataLoaded = ReloadDucking

CommonLua/Classes/DumbAI.lua

@@ -0,0 +1,392 @@
+local ai_debug = Platform.developer and Platform.pc
+local bias_base = 1000000 -- fixed point value equivalent to 1 or 100%
+
+DefineClass.DumbAIPlayer = {
+	__parents = { "InitDone" },
+	
+	actions = false,
+	action_log = false,
+	log_size = 10,
+	running_actions = false,
+	biases = false,
+	resources = false,
+	display_name = false,
+	
+	absolute_actions = 10,
+	absolute_threshold = 10000,
+	relative_threshold = 50, -- percent of the highest eval
+	think_interval = 1000,
+
+	seed = 0,
+	think_thread = false,
+	ai_start = 0,
+
+	GedEditor = "DumbAIDebug",
+	
+	-- production
+	production_interval = 60000,
+	next_production = 0,
+	production_rules = false,
+	next_production_times = false,
+}
+
+function DumbAIPlayer:Init()
+	self.actions = {}
+	self.action_log = {}
+	self.running_actions = {}
+	self.biases = {}
+	self.resources = {}
+	for _, def in ipairs(Presets.AIResource.Default) do
+		self.resources[def.id] = 0
+	end
+	self.ai_start = GameTime()
+	self.production_rules = {}
+	self.next_production = GameTime()
+	self.next_production_times = setmetatable({}, weak_keys_meta)
+end
+
+function DumbAIPlayer:Done()
+	DeleteThread(self.think_thread)
+	GedObjectDeleted(self)
+end
+
+function DumbAIPlayer:AddAIDef(ai_def)
+	if not ai_def then return end
+	local actions = self.actions
+	for _, action in ipairs(ai_def) do
+		actions[#actions + 1] = action
+	end
+	local resources = self.resources
+	for _, res in ipairs(ai_def.initial_resources) do
+		local resource = res.resource
+		resources[resource] = resources[resource] + res:Amount()
+	end
+	local production_rules = self.production_rules
+	for _, rule in ipairs(ai_def.production_rules or empty_table) do
+		production_rules[#production_rules + 1] = rule
+	end
+	local label = "AIDef " .. ai_def.id
+	for _, bias in ipairs(ai_def.biases) do
+		self:AddBias(bias.tag, bias.bias, nil, label)
+	end
+end
+
+function DumbAIPlayer:RemoveAIDef(ai_def)
+	if not ai_def then return end
+	local actions = self.actions
+	for _, action in ipairs(ai_def) do
+		table.remove_entry(actions, action)
+	end
+	local production_rules = self.production_rules
+	for _, rule in ipairs(ai_def.production_rules or empty_table) do
+		table.remove_entry(production_rules, rule)
+	end
+	local label = "AIDef " .. ai_def.id
+	for _, bias in ipairs(ai_def.biases) do
+		self:RemoveBias(bias.tag, nil, label)
+	end
+end
+
+
+-- AI bias
+
+local function recalc_bias(tag_biases)
+	local acc = bias_base
+	for _, bias in ipairs(tag_biases) do
+		acc = MulDivRound(acc, bias.change, bias_base)
+	end
+	tag_biases.acc = acc
+end
+
+function DumbAIPlayer:AddBias(tag, change, source, label)
+	local tag_biases = self.biases[tag]
+	if not tag_biases then
+		tag_biases = { acc = bias_base }
+		self.biases[tag] = tag_biases
+	end
+	if label then
+		local idx = table.find(tag_biases, "label", label)
+		if idx then
+			table.remove(tag_biases, idx)
+		end
+	end
+	local bias = {
+		change = change,
+		label = label or nil,
+		source = ai_debug and source or nil,
+	}
+	tag_biases[#tag_biases + 1] = bias
+	recalc_bias(tag_biases)
+	return bias
+end
+
+function DumbAIPlayer:RemoveBias(tag, bias, label)
+	local tag_biases = self.biases[tag]
+	if tag_biases then
+		table.remove_entry(tag_biases, bias)
+		local idx = table.find(tag_biases, "label", label)
+		if idx then
+			table.remove(tag_biases, idx)
+		end
+		recalc_bias(tag_biases)
+	end
+end
+
+function DumbAIPlayer:BiasValue(value, tags)
+	local biases = self.biases
+	for _, tag in ipairs(tags or empty_table) do
+		local tag_biases = biases[tag]
+		if tag_biases then
+			value = MulDivRound(value, tag_biases.acc, bias_base)
+		end
+	end
+	return value
+end
+
+function DumbAIPlayer:BiasValueByTag(value, tag)
+	local tag_biases = self.biases[tag]
+	if tag_biases then
+		value = MulDivRound(value, tag_biases.acc, bias_base)
+	end
+	return value
+end
+
+-- AI main loop
+
+function DumbAIPlayer:AIUpdate(seed)
+	local resources = self.resources
+	for _, rule in ipairs(self.production_rules) do
+		local time = self.next_production_times[rule] or 0
+		if GameTime() >= time then
+			self.next_production_times[rule] = time + rule.production_interval
+			procall(rule.Run, rule, resources, self)
+		end
+	end
+end
+
+function DumbAIPlayer:LogAction(action)
+	table.insert(self.action_log, {action = action, time = GameTime()})
+	while #self.action_log > self.log_size do
+		table.remove(self.action_log, 1)
+	end
+end
+
+function DumbAIPlayer:GetDisplayName()
+	return self.display_name or ""
+end
+
+function DumbAIPlayer:AIStartAction(action)
+	self.running_actions[action] = (self.running_actions[action] or 0) + 1
+	local resources = self.resources
+	for _, res in ipairs(action.required_resources) do
+		local resource = res.resource
+		resources[resource] = resources[resource] - res.amount
+	end
+	CreateGameTimeThread(function(self, action, ai_debug)
+		sprocall(action.Run, action, self)
+		Sleep(self:BiasValueByTag(action.delay, "action_delay"))
+		if (action.log_entry or "") ~= "" then
+			self:LogAction(action)
+		end
+		local resources = self.resources
+		for _, res in ipairs(action.resulting_resources) do
+			local resource = res.resource
+			resources[resource] = resources[resource] + res:Amount()
+		end
+		sprocall(action.OnEnd, action, self)
+		assert((self.running_actions[action] or 0) > 0)
+		self.running_actions[action] = (self.running_actions[action] or 0) - 1
+		if ai_debug then
+			ObjModified(self)
+		end
+	end, self, action, ai_debug)
+end
+
+function DumbAIPlayer:AILimitActions(actions)
+	local active_actions = {}
+	local resources = self.resources
+	local running_actions = self.running_actions
+	for _, action in ipairs(actions) do
+		if (running_actions[action] or 0) < action.max_running then
+			for _, res in ipairs(action.required_resources) do
+				assert(res:Amount() == res.amount, "randomized amounts are not supported for required_resources")
+				if resources[res.resource] < res.amount then
+					action = nil
+					break
+				end
+			end
+			if action and action:IsAllowed(self) then
+				local eval = action:Eval(self) or action.base_eval
+				action.eval = self:BiasValue(eval, action.tags)
+				active_actions[#active_actions + 1] = action
+			end
+		end
+	end
+	table.sortby_field_descending(active_actions, "eval")
+	-- limit by number of actions
+	local count = self:BiasValueByTag(self.absolute_actions, "ai_absolute_actions")
+	count = Min(count, #active_actions)
+	if count < 1 then
+		return active_actions, 0
+	end
+	-- limit by evaluation
+	local threshold = self:BiasValueByTag(self.absolute_threshold, "ai_absolute_threshold")
+	local rel_threshold = self:BiasValueByTag(self.relative_threshold, "ai_relative_threshold")
+	threshold = Max(threshold, MulDivRound(active_actions[1].eval, rel_threshold, 100))
+
+	while count > 0 
+		and active_actions[count].eval < threshold do
+		count = count - 1
+	end
+	return active_actions, count
+end
+
+function DumbAIPlayer:AIThink(seed)
+	seed = seed or AsyncRand()
+	self:AIUpdate(seed)
+	local actions, count = self:AILimitActions(self.actions)
+	local action = actions[BraidRandom(seed, count) + 1]
+	if action then
+		self:AIStartAction(action)
+	end
+	if ai_debug then
+		if #self > 40 then -- remove entries beyond 40
+			for i = 1, #self do
+				self[i] = self[i + 1]
+			end
+		end
+		if #self > 0 and not self[#self][3] then
+			self[#self] = nil -- replace last entry if there was no action selected
+		end
+		self[#self + 1] = {
+			GameTime() - self.ai_start,
+			seed,
+			action or false,
+			actions,
+			count,
+			table.copy(self.resources),
+			action and action.eval,
+		}
+		ObjModified(self)
+	end
+	return action
+end
+
+function DumbAIPlayer:CreateAIThinkThread()
+	DeleteThread(self.think_thread)
+	self.think_thread = CreateGameTimeThread(function(self)
+		local rand, think_seed = BraidRandom(self.seed)
+		while true do
+			Sleep(self:BiasValueByTag(self.think_interval, "ai_think_interval"))
+			rand, think_seed = BraidRandom(think_seed)
+			self:AIThink(rand)
+		end
+	end, self)
+end
+
+-- AI Debug
+
+if ai_debug then
+
+local function format_bias(n)
+	return string.format("%d.%02d", n / bias_base, (n % bias_base) * 100 / bias_base)
+end
+
+local function DumbAIDebugActions(texts, actions, count, eval)
+	texts[#texts + 1] = "<style GedTitleSmall><center>Actions selection</style>"
+	for i, action in ipairs(actions) do
+		if i == count + 1 then
+			texts[#texts + 1] = ""
+			texts[#texts + 1] = "<style GedTitleSmall><center>Low evaluation</style>"
+		end
+		if eval then
+			texts[#texts + 1] = string.format("<left>%s<right>%s", action.id, format_bias(action.eval))
+		else
+			texts[#texts + 1] = string.format("<left>%s", action.id)
+		end
+	end
+end
+
+local function DumbAIDebugResources(texts, resources)
+	texts[#texts + 1] = "<style GedTitleSmall><center>Resources</style>"
+	for _, def in ipairs(Presets.AIResource.Default) do
+		local resource = def.id
+		texts[#texts + 1] = string.format("<left>%s<right>%d", resource, resources[resource])
+	end
+end
+
+function GedDumbAIDebugState(ai_player)
+	local texts = {}
+	DumbAIDebugResources(texts, ai_player.resources)
+	texts[#texts + 1] = ""
+	texts[#texts + 1] = "<style GedTitleSmall><center>Tag biases</style>"
+	for _, def in ipairs(Presets.AITag.Default) do
+		local tag = def.id
+		local tag_biases = ai_player.biases[tag]
+		if tag_biases then
+			texts[#texts + 1] = string.format("<left>%s<right>%d%%", tag, MulDivRound(tag_biases.acc, 100, bias_base))
+		end
+	end
+	
+	texts[#texts + 1] = ""
+	local actions, count = ai_player:AILimitActions(ai_player.actions)
+	DumbAIDebugActions(texts, actions, count, true)
+	return table.concat(texts, "\n")
+end
+
+local function time(time)
+	time = tonumber(time)
+	if time then
+		local sign = time < 0 and "-" or ""
+		local sec = abs(time) / 1000
+		local min = sec / 60
+		local hours = min / 60
+		local days = hours / 24
+		if days > 0 then
+			return string.format("%s%dd%02dh%02dm%02ds", sign, days, hours % 24, min % 60, sec % 60)
+		else
+			return string.format("%s%dh%02dm%02ds", sign, hours, min % 60, sec % 60)
+		end
+	end
+end
+
+function GedDumbAIDebugLog(ai_player)
+	local list = {}
+	for i, entry in ipairs(ai_player) do
+		local t, seed, action, actions, count, resources, eval = table.unpack(entry)
+		list[i] = string.format("%s %s %s", time(t) or "???", action and action.id or "---", action and format_bias(eval) or "")
+	end
+	return list
+end
+
+function GedDumbAIDebugLogEntry(entry)
+	local texts = {}
+	local time, seed, action, actions, count, resources = table.unpack(entry)
+	DumbAIDebugResources(texts, resources)
+	texts[#texts + 1] = ""
+	DumbAIDebugActions(texts, actions, count)
+	return table.concat(texts, "\n")
+end
+
+-- Test
+
+__TestAI = false
+
+function TestAI()
+	if __TestAI then __TestAI:delete() end
+	__TestAI = DumbAIPlayer:new{
+		think_interval = const.HourDuration,
+		production_interval = const.DayDuration,
+	}
+	__TestAI:AddAIDef(Presets.DumbAIDef.Default.default)
+	__TestAI:AddAIDef(Presets.DumbAIDef.MissionSponsors.IMM)
+	__TestAI:CreateAIThinkThread()
+	__TestAI:OpenEditor()
+	Resume()
+end
+
+end
+
+function DumbAIPlayer:GetCurrentStanding()
+	return self.resources.standing
+end

CommonLua/Classes/EditorBase.lua

@@ -0,0 +1,543 @@
+DefineClass.EditorObject = {
+	__parents = { "CObject" },
+
+	EditorEnter = empty_func,
+	EditorExit = empty_func,
+}
+
+function EditorObject:PostLoad()
+	if IsEditorActive() then
+		self:EditorEnter()
+	end
+end
+
+RecursiveCallMethods.EditorEnter = "procall"
+RecursiveCallMethods.EditorExit = "procall_parents_last"
+
+DefineClass.EditorCallbackObject = {
+	__parents = { "CObject" },
+	flags = { cfEditorCallback = true },
+
+	-- all callbacks receive no parameters, except EditorCallbackClone, which receives the original object
+	EditorCallbackPlace = empty_func,
+	EditorCallbackPlaceCursor = empty_func,
+	EditorCallbackDelete = empty_func,
+	EditorCallbackRotate = empty_func,
+	EditorCallbackMove = empty_func,
+	EditorCallbackScale = empty_func,
+	EditorCallbackClone = empty_func, -- function(orig) end,
+	EditorCallbackGenerate = empty_func, -- function(generator, object_source, placed_objects, prefab_list) end,
+}
+
+AutoResolveMethods.EditorCallbackPlace = true
+AutoResolveMethods.EditorCallbackPlaceCursor = true
+AutoResolveMethods.EditorCallbackDelete = true
+AutoResolveMethods.EditorCallbackRotate = true
+AutoResolveMethods.EditorCallbackMove = true
+AutoResolveMethods.EditorCallbackScale = true
+AutoResolveMethods.EditorCallbackClone = true
+AutoResolveMethods.EditorCallbackGenerate = true
+
+function OnMsg.ChangeMapDone()
+	--CObjects that are EditorVisibleObject will get saved as efVisible == true and pop up on first map load
+	if GetMap() == "" then return end
+	if not IsEditorActive() then
+		MapForEach("map", "EditorVisibleObject", const.efVisible, function(o)
+			o:ClearEnumFlags(const.efVisible)
+		end)
+	end
+end
+
+DefineClass.EditorVisibleObject = {
+	__parents = { "EditorObject" },
+	flags = { efVisible = false },
+	properties = {
+		{ id = "OnCollisionWithCamera" },
+	},
+}
+
+function EditorVisibleObject:EditorEnter()
+	self:SetEnumFlags(const.efVisible)
+end
+
+function EditorVisibleObject:EditorExit()
+	self:ClearEnumFlags(const.efVisible)
+end
+
+----
+
+DefineClass.EditorColorObject = {
+	__parents = { "EditorObject" },
+	editor_color = false,
+	orig_color = false,
+}
+
+function EditorColorObject:EditorGetColor()
+	return self.editor_color
+end
+
+function EditorColorObject:EditorEnter()
+	local editor_color = self:EditorGetColor()
+	if editor_color then
+		self.orig_color = self:GetColorModifier()
+		self:SetColorModifier(editor_color)
+	end
+end
+
+function EditorColorObject:EditorExit()
+	if self.orig_color then
+		self:SetColorModifier(self.orig_color)
+		self.orig_color = false
+	end
+end
+
+function EditorColorObject:GetColorModifier()
+	if self.orig_color then
+		return self.orig_color
+	end
+	return EditorObject.GetColorModifier(self)
+end
+
+----
+
+DefineClass.EditorEntityObject = {
+	__parents = { "EditorCallbackObject", "EditorColorObject" },
+	entity = "",
+	editor_entity = "",
+	orig_scale = false,
+	editor_scale = false,
+}
+
+function EditorEntityObject:EditorCanPlace()
+	return true
+end
+
+function EditorEntityObject:SetEditorEntity(set)
+	if (self.editor_entity or "") ~= "" then
+		self:ChangeEntity(set and self.editor_entity or g_Classes[self.class]:GetEntity())
+	end
+	if self.editor_scale then
+		if set then
+			self.orig_scale = self:GetScale()
+			self:SetScale(self.editor_scale)
+		elseif self.orig_scale then
+			self:SetScale(self.orig_scale)
+			self.orig_scale = false
+		end
+	end
+end
+function EditorEntityObject:GetScale()
+	if self.orig_scale then
+		return self.orig_scale
+	end
+	return EditorObject.GetScale(self)
+end
+
+function EditorEntityObject:EditorEnter()
+	self:SetEditorEntity(true)
+end
+function EditorEntityObject:EditorExit()
+	self:SetEditorEntity(false)
+end
+function OnMsg.EditorCallback(id, objects, ...)
+	if id == "EditorCallbackPlace" or id == "EditorCallbackPlaceCursor" then
+		for i = 1, #objects do
+			local obj = objects[i]
+			if obj:IsKindOf("EditorEntityObject") then
+				obj:SetEditorEntity(true)
+			end
+		end
+	end
+end
+
+----
+
+DefineClass.EditorTextObject = {
+	__parents = { "EditorObject", "ComponentAttach" },
+	editor_text_spot = "Label",
+	editor_text_color = RGBA(255,255,255,255),
+	editor_text_offset = point(0,0,3*guim),
+	editor_text_style = false,
+	editor_text_depth_test = true,
+	editor_text_ctarget = "SetColor",
+	editor_text_obj = false,
+	editor_text_member = "class",
+	editor_text_class = "Text",
+}
+
+function EditorTextObject:EditorEnter()
+	self:EditorTextUpdate(true)
+end
+
+function EditorTextObject:EditorExit()
+	DoneObject(self.editor_text_obj)
+	self.editor_text_obj = nil
+end
+
+AutoResolveMethods.EditorGetText = ".."
+
+function EditorTextObject:EditorGetText()
+	return self[self.editor_text_member]
+end
+
+function EditorTextObject:EditorGetTextColor()
+	return self.editor_text_color
+end
+
+function EditorTextObject:EditorGetTextStyle()
+	return self.editor_text_style
+end
+
+function EditorTextObject:Clone(class, ...)
+	local clone = EditorObject.Clone(self, class or self.class, ...)
+	if IsKindOf(clone, "EditorTextObject") then
+		clone:EditorTextUpdate(true)
+	end
+	return clone
+end
+
+function EditorTextObject:EditorTextUpdate(create)
+	if not IsValid(self) then
+		return
+	end
+	local obj = self.editor_text_obj
+	if not IsValid(obj) and not create then return end
+	local is_hidden = GetDeveloperOption("Hidden", "EditorHiddenTextOptions", self.class)
+	local text = not is_hidden and self:EditorGetText()
+	if not text then
+		DoneObject(obj)
+		return
+	end
+	if not IsValid(obj) then
+		obj = PlaceObject(self.editor_text_class, {text_style = self:EditorGetTextStyle()})
+		obj:SetDepthTest(self.editor_text_depth_test)
+		local spot = self.editor_text_spot
+		if spot and self:HasSpot(spot) then
+			self:Attach(obj, self:GetSpotBeginIndex(spot))
+		else
+			self:Attach(obj)
+		end
+		local offset = self.editor_text_offset
+		if offset then
+			obj:SetAttachOffset(offset)
+		end
+		self.editor_text_obj = obj
+	end
+	obj:SetText(text)
+	local color = self:EditorGetTextColor()
+	if color then
+		obj[self.editor_text_ctarget](obj, color)
+	end
+end
+
+function EditorTextObject:OnEditorSetProperty(prop_id)
+	if prop_id == self.editor_text_member then
+		self:EditorTextUpdate(true)
+	end
+	return EditorObject.OnEditorSetProperty(self, prop_id)
+end
+
+DefineClass.NoteMarker = {
+	__parents = { "Object", "EditorVisibleObject", "EditorTextObject" },
+	properties = {
+		{ id = "MantisID", editor = "number", default = 0, important = true , buttons = {{name = "OpenMantis", func = "OpenMantisFromMarker"}}},
+		{ id = "Text", editor = "text", lines = 5, default = "", important = true },
+		{ id = "TextColor", editor = "color", default = RGB(255,255,255), important = true },
+		{ id = "TextStyle", editor = "text", default = "InfoText", important = true },
+		-- disabled properties
+		{ id = "Angle", editor = false},
+		{ id = "Axis", editor = false},
+		{ id = "Opacity", editor = false},
+		{ id = "StateCategory", editor = false},
+		{ id = "StateText", editor = false},
+		{ id = "Groups", editor = false},
+		{ id = "Mirrored", editor = false},
+		{ id = "ColorModifier", editor = false},
+		{ id = "Occludes", editor = false},
+		{ id = "Walkable", editor = false},
+		{ id = "ApplyToGrids", editor = false},
+		{ id = "Collision", editor = false},
+		{ id = "OnCollisionWithCamera", editor = false},
+		{ id = "CollectionIndex", editor = false},
+		{ id = "CollectionName", editor = false},
+	},
+	editor_text_offset = point(0,0,4*guim),
+	editor_text_member = "Text",
+}
+
+for i = 1, const.MaxColorizationMaterials do
+	table.iappend( NoteMarker.properties, { 
+		{ id = string.format("Color%d", i), editor = false },
+		{ id = string.format("Roughness%d", i), editor = false },
+		{ id = string.format("Metallic%d", i), editor = false },
+	})
+end
+
+function NoteMarker:EditorGetTextColor()
+	return self.TextColor
+end
+
+function NoteMarker:EditorGetTextStyle()
+	return self.TextStyle
+end
+
+function OpenMantisFromMarker(parentEditor, object, prop_id, ...)
+	local mantisID = object:GetProperty(prop_id)
+	if mantisID and mantisID ~= "" and mantisID ~= 0 then
+		local url = "http://mantis.haemimontgames.com/view.php?id="..mantisID
+		OpenUrl(url, "force external browser")
+	end
+end
+
+if not Platform.editor then
+
+	function OnMsg.ClassesPreprocess(classdefs)
+		for name, class in pairs(classdefs) do
+			class.EditorCallbackPlace = nil
+			class.EditorCallbackPlaceCursor = nil
+			class.EditorCallbackDelete = nil
+			class.EditorCallbackRotate = nil
+			class.EditorCallbackMove = nil
+			class.EditorCallbackScale = nil
+			class.EditorCallbackClone = nil
+			class.EditorCallbackGenerate = nil
+
+			class.EditorEnter = nil
+			class.EditorExit = nil
+
+			class.EditorGetText = nil
+			class.EditorGetTextColor = nil
+			class.EditorGetTextStyle = nil
+			class.EditorGetTextFont = nil
+			
+			class.editor_text_obj = nil
+			class.editor_text_spot = nil
+			class.editor_text_color = nil
+			class.editor_text_offset = nil
+			class.editor_text_style = nil
+		end
+	end
+
+	function OnMsg.Autorun()
+		MsgClear("EditorCallback")
+		MsgClear("GameEnterEditor")
+		MsgClear("GameExitEditor")
+	end
+
+end
+
+----
+
+local update_thread
+function UpdateEditorTexts()
+	if not IsEditorActive() or IsValidThread(update_thread) then
+		return
+	end
+	update_thread = CreateRealTimeThread(function()
+		MapForEach("map", "EditorTextObject", function(obj)
+			obj:EditorTextUpdate(true)
+		end)
+	end)
+end
+
+
+function OnMsg.DeveloperOptionsChanged(storage, name, id, value)
+	if storage == "EditorHiddenTextOptions" then
+		UpdateEditorTexts()
+	end
+end
+
+----
+
+DefineClass.ForcedTemplate =
+{
+	__parents = { "EditorObject" },
+	template_class = "Template",
+}
+
+function GetTemplateBase(class_name)
+	local class = g_Classes[class_name]
+	return class and class.template_class or ""
+end
+
+MapVar("ForcedTemplateObjs", {})
+
+function ForcedTemplate:EditorEnter()
+	if self:GetGameFlags(const.gofPermanent) == 0 and self:GetEnumFlags(const.efVisible) ~= 0 then
+		ForcedTemplateObjs[self] = true
+		self:ClearEnumFlags(const.efVisible)
+	end
+end
+
+function ForcedTemplate:EditorExit()
+	if ForcedTemplateObjs[self] then
+		self:SetEnumFlags(const.efVisible)
+	end
+end
+
+
+---- EditorSelectedObject --------------------------------------
+
+MapVar("l_editor_selection", empty_table)
+
+DefineClass.EditorSelectedObject = {
+	__parents = { "CObject" },
+}
+
+function EditorSelectedObject:EditorSelect(selected)
+end
+
+function EditorSelectedObject:EditorIsSelected(check_helpers)
+	if l_editor_selection[self] then
+		return true
+	end
+	if check_helpers then
+		local helpers = PropertyHelpers and PropertyHelpers[self] or empty_table
+		for prop_id, helper in pairs(helpers) do
+			if editor.IsSelected(helper) then
+				return true
+			end
+		end
+	end
+	return false
+end
+
+function UpdateEditorSelectedObjects(selection)
+	local new_selection = setmetatable({}, weak_keys_meta)
+	local old_selection = l_editor_selection
+	l_editor_selection = new_selection
+	for i=1,#(selection or "") do
+		local obj = selection[i]
+		if IsKindOf(obj, "EditorSelectedObject") then
+			new_selection[obj] = true
+			if not old_selection[obj] then
+				obj:EditorSelect(true)
+			end
+		end
+	end
+	for obj in pairs(old_selection or empty_table) do
+		if not new_selection[obj] then
+			obj:EditorSelect(false)
+		end
+	end
+end
+
+function OnMsg.EditorSelectionChanged(selection)
+	UpdateEditorSelectedObjects(selection)
+end
+
+function OnMsg.GameEnterEditor()
+	UpdateEditorSelectedObjects(editor.GetSel())
+end
+
+function OnMsg.GameExitEditor()
+	UpdateEditorSelectedObjects()
+end
+
+
+---- EditorSubVariantObject --------------------------------------
+
+DefineClass.EditorSubVariantObject = {
+	__parents = { "PropertyObject" },
+	properties = {
+		{ name = "Subvariant", id = "subvariant", editor = "number", default = -1,
+			buttons = { 
+				{ name = "Next", func = "CycleEntityBtn" },
+			},
+		},
+	},
+}
+
+function EditorSubVariantObject:CycleEntityBtn()
+	self:CycleEntity()
+end
+
+function EditorSubVariantObject:Setsubvariant(val)
+	self.subvariant = val
+end
+
+function EditorSubVariantObject:PreviousEntity()
+	self:CycleEntity(-1)
+end
+
+function EditorSubVariantObject:NextEntity()
+	self:CycleEntity(-1)
+end
+
+local maxEnt = 20
+function EditorSubVariantObject:CycleEntity(delta)
+	delta = delta or 1
+	local curE = self:GetEntity()
+	local nxt = self.subvariant == -1 and (tonumber(string.match(curE, "%d+$")) or 1) or self.subvariant
+	nxt = nxt + delta
+	
+	local nxtE = string.gsub(curE, "%d+$", (nxt < 10 and "0" or "") .. tostring(nxt))
+	if not IsValidEntity(nxtE) then
+		if delta > 0 then
+			--going up, reset to first
+			nxt = 1
+			nxtE = string.gsub(curE, "%d+$", (nxt < 10 and "0" or "") .. tostring(nxt))
+		else
+			--going down, reset to last, whichever that is..
+			nxt = maxEnt + 1
+			while not IsValidEntity(nxtE) and nxt > 0 do
+				nxt = nxt - 1
+				nxtE = string.gsub(curE, "%d+$", (nxt < 10 and "0" or "") .. tostring(nxt))
+			end
+		end
+		
+		if not IsValidEntity(nxtE) then
+			nxtE = curE
+			nxt = -1
+		end
+	end
+	
+	if self.subvariant ~= nxt then
+		self.subvariant = nxt
+		self:ChangeEntity(nxtE)
+		ObjModified(self)
+		return true
+	end
+	return false
+end
+
+function EditorSubVariantObject:ResetSubvariant()
+	self.subvariant = -1
+end
+
+function EditorSubVariantObject.OnShortcut(delta)
+	local sel = editor.GetSel()
+	if sel and #sel > 0 then
+		XEditorUndo:BeginOp{ objects = sel }
+		for i = 1, #sel do
+			if IsKindOf(sel[i], "EditorSubVariantObject") then
+				sel[i]:CycleEntity(delta)
+			end
+		end
+		XEditorUndo:EndOp(sel)
+	end
+end
+
+function CycleObjSubvariant(obj, dir)
+	if IsKindOf(obj, "EditorSubVariantObject") then
+		obj:CycleEntity(dir)
+	else
+		local class = obj.class
+		local num = tonumber(class:sub(-2, -1))
+		if num then
+			local list = {}
+			for i = 0, 99 do
+				local class_name = class:sub(1, -3) .. (i <= 9 and "0" or "") .. tostring(i)
+				if g_Classes[class_name] and IsValidEntity(g_Classes[class_name]:GetEntity()) then
+					list[#list + 1] = class_name
+				end
+			end
+			
+			local idx = table.find(list, class) + dir
+			if idx == 0 then idx = #list elseif idx > #list then idx = 1 end
+			obj = editor.ReplaceObject(obj, list[idx])
+		end
+	end
+	
+	return obj
+end

CommonLua/Classes/EntityClass.lua

@@ -0,0 +1,196 @@
+if Platform.ged then 
+	DefineClass("EntityClass", "CObject")
+	return 
+end
+
+DefineClass.EntityClass = {
+	flags = { efCameraRepulse = true, efSelectable = false },
+	__hierarchy_cache = true,
+	__parents = { "CObject" },
+}
+
+local detail_flags = {
+	["Default"] = { gofDetailClass0 = false, gofDetailClass1 = false },
+	["Essential"] = { gofDetailClass0 = false, gofDetailClass1 = true },
+	["Optional"] = { gofDetailClass0 = true, gofDetailClass1 = false },
+	["Eye Candy"] = { gofDetailClass0 = true, gofDetailClass1 = true },
+}
+
+function CopyDetailFlagsFromEntity(class, entity, name)
+	local detail_class = entity and entity.DetailClass or "Essential"
+	local flags = detail_flags[detail_class]
+	if class.flags then
+		for k, v in pairs(flags or empty_table) do
+			class.flags[k] = v
+		end
+	else
+		class.flags = flags
+	end
+end
+
+function OnMsg.ClassesGenerate(classdefs)
+	local all_entities = GetAllEntities()
+	local EntityData = EntityData
+	local CopyDetailFlagsFromEntity = CopyDetailFlagsFromEntity
+	local UseCameraCollision = not config.NoCameraCollision
+	local UseColliders = const.maxCollidersPerObject > 0
+
+	for name in pairs(EntityData) do
+		all_entities[name] = true
+	end
+	
+	for name, class in pairs(classdefs) do
+		local entity = class.entity or name
+		local cls_data = entity and (EntityData[entity] or empty_table).entity
+		for id, value in pairs(cls_data) do
+			if not rawget(class, id) and id ~= "class_parent" then
+				class[id] = value
+			end
+		end
+		local flags = class.flags
+		if not flags or flags.gofDetailClass0 == nil and flags.gofDetailClass1 == nil then
+			CopyDetailFlagsFromEntity(class, cls_data, name)
+		end
+		
+		all_entities[name] = nil -- exclude used entities
+		if rawget(class, "prevent_entity_class_creation") then
+			all_entities[entity or false] = nil
+		end
+	end
+	all_entities["StatesSpots"] = nil
+	all_entities["error"] = nil
+	all_entities[""] = nil
+	
+	local __parent_tables = { }
+	
+	for name in pairs(all_entities) do
+		local entity_data = EntityData[name]
+		local cls_data = entity_data and entity_data.entity
+		local class = cls_data and table.copy(cls_data) or { }
+		local parent = class.class_parent or "EntityClass"
+		if parent ~= "NoClass" then
+			class.class_parent = nil
+
+			local __parents = __parent_tables[parent]
+			if not __parents then
+				if parent ~= "EntityClass" and parent:find(",") then
+					__parents = string.split(parent, "[^%w]+")
+					table.remove_value(__parents, "")
+				else
+					__parents = { parent }
+				end
+				__parent_tables[parent] = __parents
+			end
+			class.__parents = __parents
+			
+			CopyDetailFlagsFromEntity(class, cls_data, name)
+			
+			if UseCameraCollision then
+				local entity_occ = cls_data and cls_data.on_collision_with_camera or "no action"
+				local occ_flags = OCCtoFlags[entity_occ]
+				if occ_flags then
+					if class.flags then
+						for k, v in pairs(occ_flags) do
+							class.flags[k] = v
+						end
+					else
+						class.flags = occ_flags
+					end
+				end
+			end
+			
+			if UseColliders and IsValidEntity(name) and not HasColliders(name) then
+				class.flags = class.flags and table.copy(class.flags) or {}
+				class.flags.cofComponentCollider = false
+			end
+			class.entity = false
+			class.__generated_by_class = "EntityClass"
+			classdefs[name] = class
+		end
+	end
+	
+	Msg("BeforeClearEntityData") -- game specific hook to give the game the chance to do something with the entities
+	MsgClear("BeforeClearEntityData")
+	
+	CreateRealTimeThread(ReloadFadeCategories, true)
+end
+
+function ReloadFadeCategories(apply_to_objects)
+	if const.UseDistanceFading and rawget(_G, "EntityData") then
+		for name,entity_data in pairs(EntityData) do
+			local fade = FadeCategories[entity_data.entity and entity_data.entity.fade_category or false]
+			SetEntityFadeDistances(name, fade and fade.min or 0, fade and fade.max or 0)
+		end
+		if apply_to_objects and __cobjectToCObject then
+			MapForEach("map", function(x)
+				x:GenerateFadeDistances() 
+			end)
+		end
+	end
+end
+
+AnimatedTextureObjectTypes = {
+	{ value = pbo.Normal, text = "Normal" },
+	{ value = pbo.PingPong, text = "Ping-Pong" },
+}
+DefineClass.AnimatedTextureObject = 
+{
+	__parents = { "ComponentCustomData", "Object" },
+
+	properties = { 
+		{ category = "Animated Texture", id = "anim_type", name = "Pick frame by", editor = "choice", items = function() return AnimatedTextureObjectTypes end, template = true },
+		{ category = "Animated Texture", id = "anim_speed", name = "Speed Multiplier", editor = "number", max = 4095, min = 0, template = true },
+		{ category = "Animated Texture", id = "sequence_time_remap", name = "Sequence time", editor = "curve4", max = 63, scale = 63, max_x = 15, scale_x = 15, template = true },
+	},
+
+	anim_type = pbo.Normal,
+	anim_speed = 1000,
+	sequence_time_remap = MakeLine(0, 63, 15),
+}
+
+function AnimatedTextureObject:Setanim_type(value)
+	self:SetFrameAnimationPlaybackOrder(value)
+end
+
+function AnimatedTextureObject:Getanim_type()
+	return self:GetFrameAnimationPlaybackOrder()
+end
+
+function AnimatedTextureObject:Setanim_speed(value)
+	self:SetFrameAnimationSpeed(value)
+end
+
+function AnimatedTextureObject:Getanim_speed()
+	return self:GetFrameAnimationSpeed()
+end
+
+function AnimatedTextureObject:Setsequence_time_remap(curve)
+	local value = (curve[1]:y()) |
+		(curve[2]:y() << 6) |
+		(curve[3]:y() << 12) |
+		(curve[4]:y() << 18) |
+		(curve[2]:x() << 24) |
+		(curve[3]:x() << 28)
+	self:SetFrameAnimationPackedCurve(value)
+end
+
+function AnimatedTextureObject:Getsequence_time_remap()
+	local value = self:GetFrameAnimationPackedCurve() 
+	local curve = {
+		point(0, value & 0x3F),
+		point((value >> 24) & 0xF, (value >> 6) & 0x3F),
+		point((value >> 28) & 0xF, (value >> 12) & 0x3F),
+		point(15,                  (value >> 18) & 0x3F),
+	}
+	for i = 1, 4 do
+		curve[i] = point(curve[i]:x(), curve[i]:y(), curve[i]:y())
+	end
+	return curve
+end
+
+function AnimatedTextureObject:Init()
+	self:InitTextureAnimation()
+	self:Setanim_type(self.anim_type)
+	self:Setanim_speed(self.anim_speed)
+	self:Setsequence_time_remap(self.sequence_time_remap)
+end