feat: IW3 menu dumping and loading (#909)

* feat: IW3 menu dumping

* fix: IW3 menu dumper preserve menu ownerdraw flag masks

* fix: IW3 menu dumper preserve numeric script arguments

Emit numeric tokens without quotes so the linker keeps colour arguments separate.

Before: `"0.1" "0.1" "0.12" "0.5"` becomes `"0.10.10.120.5"`
After: `0.1 0.1 0.12 0.5`

This fixes `mouseExit` colour commands failing to clear menu hover borders.

* fix: IW3 menu dumper preserve empty item text

Keep explicit empty text distinct from null text when dumping menu items.

This fixes CD-key values overflowing their input boxes.

* test: cover IW3 menu dumper material case

* test: cover IW3 menu list path precedence

* chore: clang format

* fix: reverse order of union to avoid edge case bug in zcg

* feat: IW3 menu loading

* fix: validate menu expression name table

* chore: explain numeric token quoting in comment

* refactor: simplify menu dump fallback path

* chore: add more dynamic window flags

* refactor: reuse IW3 menu window flag constants

* refactor: use explicit menu item feature lookup

* refactor: represent menu item text as optional

* refactor: clarify shared IW3 and IW4 menu constants

IW4 only extends the type enum so they can be shared

* refactor: clarify IW3 menu zone state naming

* fix: log IW3 menu conversion failures

* refactor: align IW3 menu list loader with IW4

* refactor: align IW3 menu dumpers with IW4

* refactor: align IW3 menu converter with IW4

* chore: use default enum numeration for operationEnum

* chore: small optimization on edit field capability initialization

* fix: iw3 menu optimizations for rect not considering relative position to parent

* chore: align iw3 menu converting closer to iw4

* chore: align iw3 menu dumping closer to iw4

* fix: not dumping menu flags properties correctly

* chore: adjust iw3 expression dumping to work similar to iw4

* chore: adjust iw3 expression converting to work similar to iw4

* chore: use unordered_map for MenuExpressionMatchers

---------

Co-authored-by: Jan Laupetin <[email protected]>

src/ObjLoading/Game/IW3/Menu/LoaderMenuListIW3.cpp

@@ -0,0 +1,215 @@
+#include "LoaderMenuListIW3.h"
+
+#include "Game/IW3/Menu/MenuConversionZoneStateIW3.h"
+#include "Game/IW3/Menu/MenuConverterIW3.h"
+#include "ObjLoading.h"
+#include "Parsing/Menu/MenuAssetZoneState.h"
+#include "Parsing/Menu/MenuFileReader.h"
+#include "Utils/Logging/Log.h"
+
+#include <deque>
+
+using namespace IW3;
+
+namespace
+{
+    class MenuListLoader final : public AssetCreator<AssetMenuList>
+    {
+    public:
+        MenuListLoader(MemoryManager& memory, ISearchPath& searchPath)
+            : m_memory(memory),
+              m_search_path(searchPath)
+        {
+        }
+
+        AssetCreationResult CreateAsset(const std::string& assetName, AssetCreationContext& context) override
+        {
+            std::vector<menuDef_t*> menus;
+            AssetRegistration<AssetMenuList> registration(assetName);
+
+            auto& zoneState = context.GetZoneAssetCreationState<menu::MenuAssetZoneState>();
+            auto& conversionState = context.GetZoneAssetCreationState<MenuConversionZoneState>();
+
+            std::deque<std::string> menuLoadQueue;
+            const auto alreadyLoadedMenuListFileMenus = conversionState.m_menus_by_filename.find(assetName);
+
+            if (alreadyLoadedMenuListFileMenus == conversionState.m_menus_by_filename.end())
+            {
+                const auto file = m_search_path.Open(assetName);
+                if (!file.IsOpen())
+                    return AssetCreationResult::NoAction();
+
+                const auto menuListResult = ParseMenuFile(*file.m_stream, assetName, zoneState);
+                if (menuListResult)
+                {
+                    if (!ProcessParsedResults(assetName, context, *menuListResult, zoneState, conversionState, menus, registration))
+                        return AssetCreationResult::Failure();
+
+                    for (const auto& menuToLoad : menuListResult->m_menus_to_load)
+                        menuLoadQueue.emplace_back(menuToLoad);
+
+                    zoneState.AddMenusToLoad(assetName, std::move(menuListResult->m_menus_to_load));
+                }
+                else
+                    return AssetCreationResult::Failure();
+            }
+            else
+            {
+                for (auto* menu : alreadyLoadedMenuListFileMenus->second)
+                {
+                    menus.emplace_back(menu->Asset());
+                    registration.AddDependency(menu);
+                }
+            }
+
+            while (!menuLoadQueue.empty())
+            {
+                const auto& menuFileToLoad = menuLoadQueue.front();
+
+                if (!LoadMenuFileFromQueue(menuFileToLoad, context, zoneState, conversionState, menus, registration))
+                    return AssetCreationResult::Failure();
+
+                menuLoadQueue.pop_front();
+            }
+
+            auto* menuListAsset = m_memory.Alloc<MenuList>();
+            menuListAsset->name = m_memory.Dup(assetName.c_str());
+            registration.SetAsset(menuListAsset);
+
+            CreateMenuListAsset(*menuListAsset, menus);
+
+            return AssetCreationResult::Success(context.AddAsset(std::move(registration)));
+        }
+
+    private:
+        bool LoadMenuFileFromQueue(const std::string& menuFilePath,
+                                   AssetCreationContext& context,
+                                   menu::MenuAssetZoneState& zoneState,
+                                   MenuConversionZoneState& conversionState,
+                                   std::vector<menuDef_t*>& menus,
+                                   AssetRegistration<AssetMenuList>& registration) const
+        {
+            const auto alreadyLoadedMenuFile = conversionState.m_menus_by_filename.find(menuFilePath);
+            if (alreadyLoadedMenuFile != conversionState.m_menus_by_filename.end())
+            {
+                con::debug("Already loaded \"{}\", skipping", menuFilePath);
+                for (auto* menu : alreadyLoadedMenuFile->second)
+                {
+                    menus.emplace_back(menu->Asset());
+                    registration.AddDependency(menu);
+                }
+                return true;
+            }
+
+            const auto file = m_search_path.Open(menuFilePath);
+            if (!file.IsOpen())
+            {
+                con::error("Could not open menu file \"{}\"", menuFilePath);
+                return false;
+            }
+
+            const auto menuFileResult = ParseMenuFile(*file.m_stream, menuFilePath, zoneState);
+            if (menuFileResult)
+            {
+                if (!ProcessParsedResults(menuFilePath, context, *menuFileResult, zoneState, conversionState, menus, registration))
+                    return false;
+                if (!menuFileResult->m_menus_to_load.empty())
+                    con::warn("Menu file has menus to load even though it is not a menu list, ignoring: \"{}\"", menuFilePath);
+
+                return true;
+            }
+            else
+                con::error("Could not read menu file \"{}\"", menuFilePath);
+
+            return false;
+        }
+
+        bool ProcessParsedResults(const std::string& fileName,
+                                  AssetCreationContext& context,
+                                  menu::ParsingResult& parsingResult,
+                                  menu::MenuAssetZoneState& zoneState,
+                                  MenuConversionZoneState& conversionState,
+                                  std::vector<menuDef_t*>& menus,
+                                  AssetRegistration<AssetMenuList>& registration) const
+        {
+            const auto menuCount = parsingResult.m_menus.size();
+            const auto menuLoadCount = parsingResult.m_menus_to_load.size();
+            auto totalItemCount = 0uz;
+            for (const auto& menu : parsingResult.m_menus)
+                totalItemCount += menu->m_items.size();
+
+            con::info("Successfully read menu file \"{}\" ({} loads, {} menus, {} items)", fileName, menuLoadCount, menuCount, totalItemCount);
+
+            // Prepare a list of all menus of this file
+            std::vector<XAssetInfo<menuDef_t>*> allMenusOfFile;
+            allMenusOfFile.reserve(parsingResult.m_menus.size());
+
+            // Convert all menus and add them as assets
+            for (auto& commonMenu : parsingResult.m_menus)
+            {
+                auto converter = IMenuConverter::Create(ObjLoading::Configuration.MenuNoOptimization, m_search_path, m_memory, context);
+
+                auto* menuAsset = m_memory.Alloc<menuDef_t>();
+                AssetRegistration<AssetMenu> menuRegistration(commonMenu->m_name, menuAsset);
+
+                if (!converter->ConvertMenu(*commonMenu, *menuAsset, menuRegistration))
+                {
+                    con::error("Failed to convert menu file \"{}\"", commonMenu->m_name);
+                    return false;
+                }
+
+                menus.emplace_back(menuAsset);
+                auto* menuAssetInfo = context.AddAsset(std::move(menuRegistration));
+
+                if (menuAssetInfo)
+                {
+                    allMenusOfFile.emplace_back(menuAssetInfo);
+                    registration.AddDependency(menuAssetInfo);
+                }
+
+                zoneState.AddMenu(std::move(commonMenu));
+            }
+
+            // Register this file with all loaded menus
+            conversionState.AddLoadedFile(fileName, std::move(allMenusOfFile));
+
+            return true;
+        }
+
+        void CreateMenuListAsset(MenuList& menuList, const std::vector<menuDef_t*>& menus) const
+        {
+            menuList.menuCount = static_cast<int>(menus.size());
+
+            if (menuList.menuCount > 0)
+            {
+                menuList.menus = m_memory.Alloc<menuDef_t*>(menuList.menuCount);
+                for (auto i = 0; i < menuList.menuCount; i++)
+                    menuList.menus[i] = menus[i];
+            }
+            else
+                menuList.menus = nullptr;
+        }
+
+        std::unique_ptr<menu::ParsingResult>
+            ParseMenuFile(std::istream& stream, const std::string& menuFileName, const menu::MenuAssetZoneState& zoneState) const
+        {
+            menu::MenuFileReader reader(stream, menuFileName, menu::FeatureLevel::IW3, m_search_path);
+
+            reader.IncludeZoneState(zoneState);
+            reader.SetPermissiveMode(ObjLoading::Configuration.MenuPermissiveParsing);
+
+            return reader.ReadMenuFile();
+        }
+
+        MemoryManager& m_memory;
+        ISearchPath& m_search_path;
+    };
+} // namespace
+
+namespace menu
+{
+    std::unique_ptr<AssetCreator<AssetMenuList>> CreateMenuListLoaderIW3(MemoryManager& memory, ISearchPath& searchPath)
+    {
+        return std::make_unique<MenuListLoader>(memory, searchPath);
+    }
+} // namespace menu

src/ObjLoading/Game/IW3/Menu/LoaderMenuListIW3.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "Asset/IAssetCreator.h"
+#include "Game/IW3/IW3.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <memory>
+
+namespace menu
+{
+    std::unique_ptr<AssetCreator<IW3::AssetMenuList>> CreateMenuListLoaderIW3(MemoryManager& memory, ISearchPath& searchPath);
+}

src/ObjLoading/Game/IW3/Menu/MenuConversionZoneStateIW3.cpp

@@ -0,0 +1,8 @@
+#include "MenuConversionZoneStateIW3.h"
+
+using namespace IW3;
+
+void MenuConversionZoneState::AddLoadedFile(std::string loadedFileName, std::vector<XAssetInfo<menuDef_t>*> menusOfFile)
+{
+    m_menus_by_filename.emplace(std::move(loadedFileName), std::move(menusOfFile));
+}

src/ObjLoading/Game/IW3/Menu/MenuConversionZoneStateIW3.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "Asset/IZoneAssetCreationState.h"
+#include "Game/IW3/IW3.h"
+
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+namespace IW3
+{
+    class MenuConversionZoneState final : public IZoneAssetCreationState
+    {
+    public:
+        void AddLoadedFile(std::string loadedFileName, std::vector<XAssetInfo<menuDef_t>*> menusOfFile);
+
+        std::unordered_map<std::string, std::vector<XAssetInfo<menuDef_t>*>> m_menus_by_filename;
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/Menu/MenuConverterIW3.cpp

@@ -0,0 +1,729 @@
+#include "MenuConverterIW3.h"
+
+#include "Menu/AbstractMenuConverter.h"
+#include "Parsing/Menu/Domain/EventHandler/CommonEventHandlerScript.h"
+#include "Parsing/Menu/Domain/Expression/CommonExpressionBaseFunctionCall.h"
+#include "Parsing/Menu/Domain/Expression/CommonExpressionCustomFunctionCall.h"
+#include "Parsing/Simple/Expression/SimpleExpressionBinaryOperation.h"
+#include "Parsing/Simple/Expression/SimpleExpressionConditionalOperator.h"
+#include "Parsing/Simple/Expression/SimpleExpressionUnaryOperation.h"
+
+#include <algorithm>
+#include <cassert>
+#include <format>
+#include <sstream>
+#include <vector>
+
+using namespace IW3;
+using namespace menu;
+
+namespace
+{
+    class MenuConverter final : public AbstractMenuConverter, public IMenuConverter
+    {
+        [[nodiscard]] static rectDef_s ConvertRectDef(const CommonRect& rect)
+        {
+            return rectDef_s{
+                .x = static_cast<float>(rect.x),
+                .y = static_cast<float>(rect.y),
+                .w = static_cast<float>(rect.w),
+                .h = static_cast<float>(rect.h),
+                .horzAlign = rect.horizontalAlign,
+                .vertAlign = rect.verticalAlign,
+            };
+        }
+
+        [[nodiscard]] static rectDef_s ConvertRectDefRelativeTo(const rectDef_s& rect, const rectDef_s& relativeTo)
+        {
+            return rectDef_s{
+                .x = relativeTo.x + rect.x,
+                .y = relativeTo.y + rect.y,
+                .w = static_cast<float>(rect.w),
+                .h = static_cast<float>(rect.h),
+                .horzAlign = rect.horzAlign,
+                .vertAlign = rect.vertAlign,
+            };
+        }
+
+        static void ConvertColor(float (&output)[4], const CommonColor& input)
+        {
+            output[0] = static_cast<float>(input.r);
+            output[1] = static_cast<float>(input.g);
+            output[2] = static_cast<float>(input.b);
+            output[3] = static_cast<float>(input.a);
+        }
+
+        static void ApplyFlag(unsigned& flags, const bool shouldApply, const unsigned flagValue)
+        {
+            if (!shouldApply)
+                return;
+
+            flags |= flagValue;
+        }
+
+        [[nodiscard]] Material* ConvertMaterial(const std::string& materialName, const CommonMenuDef* menu, const CommonItemDef* item = nullptr) const
+        {
+            if (materialName.empty())
+                return nullptr;
+
+            auto* materialDependency = m_context.LoadDependency<AssetMaterial>(materialName);
+            if (!materialDependency)
+                throw MenuConversionException(std::format("Failed to load material \"{}\"", materialName), menu, item);
+
+            return materialDependency->Asset();
+        }
+
+        [[nodiscard]] snd_alias_list_t* ConvertSound(const std::string& soundName, const CommonMenuDef* menu, const CommonItemDef* item = nullptr) const
+        {
+            if (soundName.empty())
+                return nullptr;
+
+            auto* soundDependency = m_context.LoadDependency<AssetSound>(soundName);
+            if (!soundDependency)
+                throw MenuConversionException(std::format("Failed to load sound \"{}\"", soundName), menu, item);
+
+            return soundDependency->Asset();
+        }
+
+        constexpr static operationEnum UNARY_OPERATION_MAPPING[]{
+            OP_NOT,
+            OP_BITWISENOT,
+            OP_SUBTRACT,
+        };
+        static_assert(std::size(UNARY_OPERATION_MAPPING) == static_cast<unsigned>(SimpleUnaryOperationId::COUNT));
+
+        constexpr static operationEnum BINARY_OPERATION_MAPPING[]{
+            OP_ADD,
+            OP_SUBTRACT,
+            OP_MULTIPLY,
+            OP_DIVIDE,
+            OP_MODULUS,
+            OP_BITWISEAND,
+            OP_BITWISEOR,
+            OP_BITSHIFTLEFT,
+            OP_BITSHIFTRIGHT,
+            OP_GREATERTHAN,
+            OP_GREATERTHANEQUALTO,
+            OP_LESSTHAN,
+            OP_LESSTHANEQUALTO,
+            OP_EQUALS,
+            OP_NOTEQUAL,
+            OP_AND,
+            OP_OR,
+        };
+        static_assert(std::size(BINARY_OPERATION_MAPPING) == static_cast<unsigned>(SimpleBinaryOperationId::COUNT));
+
+        [[nodiscard]] bool IsOperation(const ISimpleExpression* expression) const
+        {
+            if (!m_disable_optimizations && expression->IsStatic())
+                return false;
+
+            return dynamic_cast<const SimpleExpressionBinaryOperation*>(expression) != nullptr
+                   || dynamic_cast<const SimpleExpressionUnaryOperation*>(expression) != nullptr;
+        }
+
+        void ConvertExpressionEntryBaseFunctionCall(std::vector<expressionEntry>& entries,
+                                                    const CommonExpressionBaseFunctionCall* baseFunction,
+                                                    const CommonMenuDef* menu,
+                                                    const CommonItemDef* item) const
+        {
+            entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = static_cast<operationEnum>(baseFunction->m_function_index)}});
+
+            auto firstArg = true;
+            for (const auto& arg : baseFunction->m_args)
+            {
+                if (firstArg)
+                    firstArg = false;
+                else
+                    entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_COMMA}});
+
+                ConvertExpressionEntry(entries, arg.get(), menu, item);
+            }
+
+            entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_RIGHTPAREN}});
+        }
+
+        void ConvertExpressionEntryUnaryOperation(std::vector<expressionEntry>& entries,
+                                                  const SimpleExpressionUnaryOperation* unary,
+                                                  const CommonMenuDef* menu,
+                                                  const CommonItemDef* item) const
+        {
+            assert(static_cast<unsigned>(unary->m_operation_type->m_id) < static_cast<unsigned>(SimpleUnaryOperationId::COUNT));
+
+            entries.emplace_back(expressionEntry{
+                .type = EET_OPERATOR,
+                .data = {.op = UNARY_OPERATION_MAPPING[static_cast<unsigned>(unary->m_operation_type->m_id)]},
+            });
+
+            const auto wrapOperand = IsOperation(unary->m_operand.get());
+            if (wrapOperand)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_LEFTPAREN}});
+            ConvertExpressionEntry(entries, unary->m_operand.get(), menu, item);
+            if (wrapOperand)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_RIGHTPAREN}});
+        }
+
+        void ConvertExpressionEntryBinaryOperation(std::vector<expressionEntry>& entries,
+                                                   const SimpleExpressionBinaryOperation* binary,
+                                                   const CommonMenuDef* menu,
+                                                   const CommonItemDef* item) const
+        {
+            // Game needs all nested operations to have parenthesis
+            const auto wrapLeft = IsOperation(binary->m_operand1.get());
+            if (wrapLeft)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_LEFTPAREN}});
+            ConvertExpressionEntry(entries, binary->m_operand1.get(), menu, item);
+            if (wrapLeft)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_RIGHTPAREN}});
+
+            assert(static_cast<unsigned>(binary->m_operation_type->m_id) < static_cast<unsigned>(SimpleBinaryOperationId::COUNT));
+            entries.emplace_back(expressionEntry{
+                .type = EET_OPERATOR,
+                .data = {.op = BINARY_OPERATION_MAPPING[static_cast<unsigned>(binary->m_operation_type->m_id)]},
+            });
+
+            // Game needs all nested operations to have parenthesis
+            const auto wrapRight = IsOperation(binary->m_operand2.get());
+            if (wrapRight)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_LEFTPAREN}});
+            ConvertExpressionEntry(entries, binary->m_operand2.get(), menu, item);
+            if (wrapRight)
+                entries.emplace_back(expressionEntry{.type = EET_OPERATOR, .data = {.op = OP_RIGHTPAREN}});
+        }
+
+        void ConvertExpressionValue(std::vector<expressionEntry>& entries, const SimpleExpressionValue& value) const
+        {
+            expressionEntry entry{};
+            entry.type = EET_OPERAND;
+
+            switch (value.m_type)
+            {
+            case SimpleExpressionValue::Type::INT:
+                entry.data.operand.dataType = VAL_INT;
+                entry.data.operand.internals.intVal = value.m_int_value;
+                break;
+            case SimpleExpressionValue::Type::DOUBLE:
+                entry.data.operand.dataType = VAL_FLOAT;
+                entry.data.operand.internals.floatVal = static_cast<float>(value.m_double_value);
+                break;
+            case SimpleExpressionValue::Type::STRING:
+                entry.data.operand.dataType = VAL_STRING;
+                entry.data.operand.internals.stringVal = m_memory.Dup(value.m_string_value->c_str());
+                break;
+            }
+
+            entries.emplace_back(entry);
+        }
+
+        void ConvertExpressionEntry(std::vector<expressionEntry>& entries,
+                                    const ISimpleExpression* expression,
+                                    const CommonMenuDef* menu,
+                                    const CommonItemDef* item) const
+        {
+            if (!m_disable_optimizations && expression->IsStatic())
+            {
+                const auto staticValue = expression->EvaluateStatic();
+                ConvertExpressionValue(entries, staticValue);
+            }
+            else if (const auto* value = dynamic_cast<const SimpleExpressionValue*>(expression))
+            {
+                ConvertExpressionValue(entries, *value);
+            }
+            else if (const auto* binary = dynamic_cast<const SimpleExpressionBinaryOperation*>(expression))
+            {
+                ConvertExpressionEntryBinaryOperation(entries, binary, menu, item);
+            }
+            else if (const auto* unary = dynamic_cast<const SimpleExpressionUnaryOperation*>(expression))
+            {
+                ConvertExpressionEntryUnaryOperation(entries, unary, menu, item);
+            }
+            else if (const auto* baseFunction = dynamic_cast<const CommonExpressionBaseFunctionCall*>(expression))
+            {
+                ConvertExpressionEntryBaseFunctionCall(entries, baseFunction, menu, item);
+            }
+            else if (dynamic_cast<const CommonExpressionCustomFunctionCall*>(expression))
+            {
+                throw MenuConversionException("IW3 does not support custom menu functions", menu, item);
+            }
+            else if (dynamic_cast<const SimpleExpressionConditionalOperator*>(expression))
+            {
+                throw MenuConversionException("Cannot use conditional expression in menu expressions", menu, item);
+            }
+            else
+            {
+                assert(false);
+                throw MenuConversionException("Unknown expression entry type in menu expressions", menu, item);
+            }
+        }
+
+        void
+            ConvertExpression(statement_s& statement, const ISimpleExpression* expression, const CommonMenuDef* menu, const CommonItemDef* item = nullptr) const
+        {
+            if (!expression)
+                return;
+
+            std::vector<expressionEntry> entries;
+            ConvertExpressionEntry(entries, expression, menu, item);
+
+            statement.numEntries = static_cast<int>(entries.size());
+            statement.entries = m_memory.Alloc<expressionEntry*>(entries.size());
+            for (auto i = 0u; i < entries.size(); i++)
+            {
+                statement.entries[i] = m_memory.Alloc<expressionEntry>();
+                *statement.entries[i] = entries[i];
+            }
+        }
+
+        void ConvertOrApplyStatement(float& staticValue,
+                                     statement_s& statement,
+                                     const ISimpleExpression* expression,
+                                     const CommonMenuDef* menu,
+                                     const CommonItemDef* item = nullptr) const
+        {
+            if (!expression)
+                return;
+
+            if (!m_disable_optimizations && expression->IsStatic())
+            {
+                const auto value = expression->EvaluateStatic();
+
+                if (value.m_type == SimpleExpressionValue::Type::INT)
+                    staticValue = static_cast<float>(value.m_int_value);
+                else if (value.m_type == SimpleExpressionValue::Type::DOUBLE)
+                    staticValue = static_cast<float>(value.m_double_value);
+                else
+                    throw MenuConversionException("Cannot convert string expression value to floating point", menu, item);
+            }
+            else
+            {
+                ConvertExpression(statement, expression, menu, item);
+            }
+        }
+
+        void ConvertOrApplyStatement(const char*& staticValue,
+                                     statement_s& statement,
+                                     const ISimpleExpression* expression,
+                                     const CommonMenuDef* menu,
+                                     const CommonItemDef* item = nullptr) const
+        {
+            if (!expression)
+                return;
+
+            if (!m_disable_optimizations && expression->IsStatic())
+            {
+                const auto value = expression->EvaluateStatic();
+                if (value.m_type != SimpleExpressionValue::Type::STRING)
+                    throw MenuConversionException("Cannot convert numeric expression value to string", menu, item);
+
+                staticValue = m_memory.Dup(value.m_string_value->c_str());
+            }
+            else
+            {
+                ConvertExpression(statement, expression, menu, item);
+            }
+        }
+
+        void ConvertOrApplyStatement(Material*& staticValue,
+                                     statement_s& statement,
+                                     const ISimpleExpression* expression,
+                                     const CommonMenuDef* menu,
+                                     const CommonItemDef* item = nullptr) const
+        {
+            if (!expression)
+                return;
+
+            if (!m_disable_optimizations && expression->IsStatic())
+            {
+                const auto value = expression->EvaluateStatic();
+                if (value.m_type != SimpleExpressionValue::Type::STRING)
+                    throw MenuConversionException("Cannot convert numeric expression value to material", menu, item);
+
+                staticValue = ConvertMaterial(*value.m_string_value, menu, item);
+            }
+            else
+            {
+                ConvertExpression(statement, expression, menu, item);
+            }
+        }
+
+        void ConvertVisibleExpression(windowDef_t& window,
+                                      statement_s& statement,
+                                      const ISimpleExpression* expression,
+                                      const CommonMenuDef* commonMenu,
+                                      const CommonItemDef* commonItem = nullptr) const
+        {
+            if (!expression)
+                return;
+
+            bool isStatic;
+            bool isTruthy;
+            if (m_disable_optimizations)
+            {
+                const auto* staticValue = dynamic_cast<const SimpleExpressionValue*>(expression);
+                isStatic = staticValue != nullptr;
+                isTruthy = isStatic && (staticValue->m_type == SimpleExpressionValue::Type::INT || staticValue->m_type == SimpleExpressionValue::Type::DOUBLE)
+                           && staticValue->IsTruthy();
+            }
+            else
+            {
+                isStatic = expression->IsStatic();
+                isTruthy = isStatic && expression->EvaluateStatic().IsTruthy();
+            }
+
+            if (isStatic)
+            {
+                if (isTruthy)
+                    window.dynamicFlags[0] |= WINDOW_FLAG_VISIBLE;
+            }
+            else
+            {
+                window.dynamicFlags[0] |= WINDOW_FLAG_VISIBLE;
+                ConvertExpression(statement, expression, commonMenu, commonItem);
+            }
+        }
+
+        [[nodiscard]] const char*
+            ConvertEventHandlerSet(const CommonEventHandlerSet* handlers, const CommonMenuDef* menu, const CommonItemDef* item = nullptr) const
+        {
+            if (!handlers)
+                return nullptr;
+
+            std::ostringstream ss;
+            for (const auto& element : handlers->m_elements)
+            {
+                if (element->GetType() != CommonEventHandlerElementType::SCRIPT)
+                    throw MenuConversionException("IW3 event handlers must compile to a script string", menu, item);
+
+                ss << dynamic_cast<const CommonEventHandlerScript*>(element.get())->m_script;
+            }
+
+            const auto script = ss.str();
+            return script.empty() ? nullptr : m_memory.Dup(script.c_str());
+        }
+
+        [[nodiscard]] ItemKeyHandler* ConvertKeyHandler(const std::multimap<int, std::unique_ptr<CommonEventHandlerSet>>& keyHandlers,
+                                                        const CommonMenuDef* menu,
+                                                        const CommonItemDef* item = nullptr) const
+        {
+            if (keyHandlers.empty())
+                return nullptr;
+
+            const auto keyHandlerCount = keyHandlers.size();
+            auto* output = m_memory.Alloc<ItemKeyHandler>(keyHandlerCount);
+            auto currentKeyHandler = keyHandlers.cbegin();
+            for (auto i = 0u; i < keyHandlerCount; i++)
+            {
+                output[i].key = currentKeyHandler->first;
+                output[i].action = ConvertEventHandlerSet(currentKeyHandler->second.get(), menu, item);
+
+                if (i + 1 < keyHandlerCount)
+                    output[i].next = &output[i + 1];
+                else
+                    output[i].next = nullptr;
+                ++currentKeyHandler;
+            }
+
+            return output;
+        }
+
+        [[nodiscard]] const char* CreateEnableDvarString(const std::vector<std::string>& stringElements) const
+        {
+            std::ostringstream ss;
+
+            for (const auto& element : stringElements)
+            {
+                ss << "\"" << element << "\" ";
+            }
+
+            return m_memory.Dup(ss.str().c_str());
+        }
+
+        [[nodiscard]] const char* ConvertEnableDvar(const CommonItemDef& commonItem, int& dvarFlags) const
+        {
+            dvarFlags = 0;
+
+            if (!commonItem.m_enable_dvar.empty())
+            {
+                dvarFlags |= ITEM_DVAR_FLAG_ENABLE;
+                return CreateEnableDvarString(commonItem.m_enable_dvar);
+            }
+
+            if (!commonItem.m_disable_dvar.empty())
+            {
+                dvarFlags |= ITEM_DVAR_FLAG_DISABLE;
+                return CreateEnableDvarString(commonItem.m_disable_dvar);
+            }
+
+            if (!commonItem.m_show_dvar.empty())
+            {
+                dvarFlags |= ITEM_DVAR_FLAG_SHOW;
+                return CreateEnableDvarString(commonItem.m_show_dvar);
+            }
+
+            if (!commonItem.m_hide_dvar.empty())
+            {
+                dvarFlags |= ITEM_DVAR_FLAG_HIDE;
+                return CreateEnableDvarString(commonItem.m_hide_dvar);
+            }
+
+            if (!commonItem.m_focus_dvar.empty())
+            {
+                dvarFlags |= ITEM_DVAR_FLAG_FOCUS;
+                return CreateEnableDvarString(commonItem.m_focus_dvar);
+            }
+
+            return nullptr;
+        }
+
+        [[nodiscard]] listBoxDef_s* ConvertListBoxFeatures(itemDef_s* item,
+                                                           CommonItemFeaturesListBox* commonListBox,
+                                                           const CommonMenuDef& parentMenu,
+                                                           const CommonItemDef& commonItem) const
+        {
+            if (!commonListBox)
+                return nullptr;
+
+            auto* listBox = m_memory.Alloc<listBoxDef_s>();
+            listBox->notselectable = commonListBox->m_not_selectable ? 1 : 0;
+            listBox->noScrollBars = commonListBox->m_no_scrollbars ? 1 : 0;
+            listBox->usePaging = commonListBox->m_use_paging ? 1 : 0;
+            listBox->elementWidth = static_cast<float>(commonListBox->m_element_width);
+            listBox->elementHeight = static_cast<float>(commonListBox->m_element_height);
+            item->special = static_cast<float>(commonListBox->m_feeder);
+            listBox->elementStyle = commonListBox->m_element_style;
+            listBox->onDoubleClick = ConvertEventHandlerSet(commonListBox->m_on_double_click.get(), &parentMenu, &commonItem);
+            ConvertColor(listBox->selectBorder, commonListBox->m_select_border);
+            ConvertColor(listBox->disableColor, commonItem.m_disable_color);
+            listBox->selectIcon = ConvertMaterial(commonListBox->m_select_icon, &parentMenu, &commonItem);
+
+            listBox->numColumns = static_cast<int>(std::min(std::size(listBox->columnInfo), commonListBox->m_columns.size()));
+            for (auto i = 0; i < listBox->numColumns; i++)
+            {
+                auto& col = listBox->columnInfo[i];
+                const auto& commonCol = commonListBox->m_columns[i];
+
+                col.pos = commonCol.m_x_pos;
+                col.width = commonCol.m_width;
+                col.maxChars = commonCol.m_max_chars;
+                col.alignment = commonCol.m_alignment;
+            }
+
+            return listBox;
+        }
+
+        [[nodiscard]] editFieldDef_s* ConvertEditFieldFeatures(CommonItemFeaturesEditField* commonEditField) const
+        {
+            if (!commonEditField)
+                return nullptr;
+
+            auto* editField = m_memory.Alloc<editFieldDef_s>();
+            editField->defVal = static_cast<float>(commonEditField->m_def_val);
+            editField->minVal = static_cast<float>(commonEditField->m_min_val);
+            editField->maxVal = static_cast<float>(commonEditField->m_max_val);
+            editField->maxChars = commonEditField->m_max_chars;
+            editField->maxCharsGotoNext = commonEditField->m_max_chars_goto_next ? 1 : 0;
+            editField->maxPaintChars = commonEditField->m_max_paint_chars;
+
+            return editField;
+        }
+
+        [[nodiscard]] multiDef_s* ConvertMultiValueFeatures(CommonItemFeaturesMultiValue* commonMultiValue) const
+        {
+            if (!commonMultiValue)
+                return nullptr;
+
+            auto* multiValue = m_memory.Alloc<multiDef_s>();
+            multiValue->count = static_cast<int>(std::min(std::size(multiValue->dvarList), commonMultiValue->m_step_names.size()));
+            multiValue->strDef = !commonMultiValue->m_string_values.empty() ? 1 : 0;
+
+            for (auto i = 0; i < multiValue->count; i++)
+            {
+                multiValue->dvarList[i] = ConvertString(commonMultiValue->m_step_names[i]);
+
+                if (multiValue->strDef)
+                {
+                    if (commonMultiValue->m_string_values.size() > static_cast<unsigned>(i))
+                        multiValue->dvarStr[i] = ConvertString(commonMultiValue->m_string_values[i]);
+                }
+                else
+                {
+                    if (commonMultiValue->m_double_values.size() > static_cast<unsigned>(i))
+                        multiValue->dvarValue[i] = static_cast<float>(commonMultiValue->m_double_values[i]);
+                }
+            }
+
+            return multiValue;
+        }
+
+        [[nodiscard]] itemDef_s* ConvertItem(const CommonMenuDef& commonParentMenu, menuDef_t& parentMenu, const CommonItemDef& commonItem) const
+        {
+            auto* item = m_memory.Alloc<itemDef_s>();
+
+            item->window.name = ConvertString(commonItem.m_name);
+            item->text = commonItem.m_text ? m_memory.Dup(commonItem.m_text->c_str()) : nullptr;
+            item->window.group = ConvertString(commonItem.m_group);
+            item->window.rectClient = ConvertRectDef(commonItem.m_rect);
+            item->window.style = commonItem.m_style;
+            ApplyFlag(item->window.staticFlags, commonItem.m_decoration, WINDOW_FLAG_DECORATION);
+            ApplyFlag(item->window.staticFlags, commonItem.m_auto_wrapped, WINDOW_FLAG_AUTO_WRAPPED);
+            ApplyFlag(item->window.staticFlags, commonItem.m_horizontal_scroll, WINDOW_FLAG_HORIZONTAL_SCROLL);
+            item->type = commonItem.m_type;
+            item->dataType = commonItem.m_type;
+            item->window.border = commonItem.m_border;
+            item->window.borderSize = static_cast<float>(commonItem.m_border_size);
+            ConvertVisibleExpression(item->window, item->visibleExp, commonItem.m_visible_expression.get(), &commonParentMenu, &commonItem);
+            item->window.ownerDraw = commonItem.m_owner_draw;
+            item->window.ownerDrawFlags = commonItem.m_owner_draw_flags;
+            item->alignment = commonItem.m_align;
+            item->textAlignMode = commonItem.m_text_align;
+            item->textalignx = static_cast<float>(commonItem.m_text_align_x);
+            item->textaligny = static_cast<float>(commonItem.m_text_align_y);
+            item->textscale = static_cast<float>(commonItem.m_text_scale);
+            item->textStyle = commonItem.m_text_style;
+            item->fontEnum = commonItem.m_text_font;
+            ConvertColor(item->window.backColor, commonItem.m_back_color);
+
+            ConvertColor(item->window.foreColor, commonItem.m_fore_color);
+            ApplyFlag(item->window.dynamicFlags[0], !commonItem.m_fore_color.Equals(CommonColor(1.0, 1.0, 1.0, 1.0)), WINDOW_FLAG_NON_DEFAULT_FORECOLOR);
+
+            ConvertColor(item->window.borderColor, commonItem.m_border_color);
+            ConvertColor(item->window.outlineColor, commonItem.m_outline_color);
+            item->window.background = ConvertMaterial(commonItem.m_background, &commonParentMenu, &commonItem);
+            item->onFocus = ConvertEventHandlerSet(commonItem.m_on_focus.get(), &commonParentMenu, &commonItem);
+            item->leaveFocus = ConvertEventHandlerSet(commonItem.m_on_leave_focus.get(), &commonParentMenu, &commonItem);
+            item->mouseEnter = ConvertEventHandlerSet(commonItem.m_on_mouse_enter.get(), &commonParentMenu, &commonItem);
+            item->mouseExit = ConvertEventHandlerSet(commonItem.m_on_mouse_exit.get(), &commonParentMenu, &commonItem);
+            item->mouseEnterText = ConvertEventHandlerSet(commonItem.m_on_mouse_enter_text.get(), &commonParentMenu, &commonItem);
+            item->mouseExitText = ConvertEventHandlerSet(commonItem.m_on_mouse_exit_text.get(), &commonParentMenu, &commonItem);
+            item->action = ConvertEventHandlerSet(commonItem.m_on_action.get(), &commonParentMenu, &commonItem);
+            item->onAccept = ConvertEventHandlerSet(commonItem.m_on_accept.get(), &commonParentMenu, &commonItem);
+            item->focusSound = ConvertSound(commonItem.m_focus_sound, &commonParentMenu, &commonItem);
+            item->dvar = ConvertString(commonItem.m_dvar);
+            item->dvarTest = ConvertString(commonItem.m_dvar_test);
+            item->enableDvar = ConvertEnableDvar(commonItem, item->dvarFlags);
+            item->onKey = ConvertKeyHandler(commonItem.m_key_handlers, &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->text, item->textExp, commonItem.m_text_expression.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->window.background, item->materialExp, commonItem.m_material_expression.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->window.rectClient.x, item->rectXExp, commonItem.m_rect_x_exp.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->window.rectClient.y, item->rectYExp, commonItem.m_rect_y_exp.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->window.rectClient.w, item->rectWExp, commonItem.m_rect_w_exp.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(item->window.rectClient.h, item->rectHExp, commonItem.m_rect_h_exp.get(), &commonParentMenu, &commonItem);
+            ConvertOrApplyStatement(
+                item->window.foreColor[3], item->forecolorAExp, commonItem.m_forecolor_expressions.m_a_exp.get(), &commonParentMenu, &commonItem);
+            item->gameMsgWindowIndex = commonItem.m_game_message_window_index;
+            item->gameMsgWindowMode = commonItem.m_game_message_window_mode;
+
+            switch (commonItem.m_feature_type)
+            {
+            case CommonItemFeatureType::LISTBOX:
+                item->typeData.listBox = ConvertListBoxFeatures(item, commonItem.m_list_box_features.get(), commonParentMenu, commonItem);
+                break;
+
+            case CommonItemFeatureType::EDIT_FIELD:
+                item->typeData.editField = ConvertEditFieldFeatures(commonItem.m_edit_field_features.get());
+                break;
+
+            case CommonItemFeatureType::MULTI_VALUE:
+                item->typeData.multi = ConvertMultiValueFeatures(commonItem.m_multi_value_features.get());
+                break;
+
+            case CommonItemFeatureType::ENUM_DVAR:
+                item->typeData.enumDvarName = ConvertString(commonItem.m_enum_dvar_name);
+                break;
+
+            case CommonItemFeatureType::NONE:
+            default:
+                break;
+            }
+
+            // Do this last so any optimizations are considered
+            item->window.rect = ConvertRectDefRelativeTo(item->window.rectClient, parentMenu.window.rect);
+
+            item->parent = &parentMenu;
+
+            return item;
+        }
+
+        itemDef_s** ConvertMenuItems(const CommonMenuDef& commonMenu, menuDef_t& menu, int& itemCount) const
+        {
+            if (commonMenu.m_items.empty())
+            {
+                itemCount = 0;
+                return nullptr;
+            }
+
+            auto* items = m_memory.Alloc<itemDef_s*>(commonMenu.m_items.size());
+            for (auto i = 0u; i < commonMenu.m_items.size(); i++)
+                items[i] = ConvertItem(commonMenu, menu, *commonMenu.m_items[i]);
+
+            itemCount = static_cast<int>(commonMenu.m_items.size());
+
+            return items;
+        }
+
+    public:
+        MenuConverter(const bool disableOptimizations, ISearchPath& searchPath, MemoryManager& memory, AssetCreationContext& context)
+            : AbstractMenuConverter(disableOptimizations, searchPath, memory, context)
+        {
+        }
+
+        bool ConvertMenu(const CommonMenuDef& commonMenu, menuDef_t& menu, AssetRegistration<AssetMenu>& registration) override
+        {
+            try
+            {
+                menu.window.name = m_memory.Dup(commonMenu.m_name.c_str());
+                menu.fullScreen = commonMenu.m_full_screen ? 1 : 0;
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_decoration, WINDOW_FLAG_DECORATION);
+                menu.window.rect = ConvertRectDef(commonMenu.m_rect);
+                menu.window.rectClient = menu.window.rect;
+                menu.window.style = commonMenu.m_style;
+                menu.window.border = commonMenu.m_border;
+                menu.window.borderSize = static_cast<float>(commonMenu.m_border_size);
+                ConvertColor(menu.window.backColor, commonMenu.m_back_color);
+                ConvertColor(menu.window.foreColor, commonMenu.m_fore_color);
+                ApplyFlag(menu.window.dynamicFlags[0], !commonMenu.m_fore_color.Equals(CommonColor(1.0, 1.0, 1.0, 1.0)), WINDOW_FLAG_NON_DEFAULT_FORECOLOR);
+                ConvertColor(menu.window.borderColor, commonMenu.m_border_color);
+                ConvertColor(menu.window.outlineColor, commonMenu.m_outline_color);
+                ConvertColor(menu.focusColor, commonMenu.m_focus_color);
+                ConvertColor(menu.disableColor, commonMenu.m_disable_color);
+                menu.window.background = ConvertMaterial(commonMenu.m_background, &commonMenu);
+                menu.window.ownerDraw = commonMenu.m_owner_draw;
+                menu.window.ownerDrawFlags = commonMenu.m_owner_draw_flags;
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_out_of_bounds_click, WINDOW_FLAG_OUT_OF_BOUNDS_CLICK);
+                menu.soundName = ConvertString(commonMenu.m_sound_loop);
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_popup, WINDOW_FLAG_POPUP);
+                menu.fadeClamp = static_cast<float>(commonMenu.m_fade_clamp);
+                menu.fadeCycle = commonMenu.m_fade_cycle;
+                menu.fadeAmount = static_cast<float>(commonMenu.m_fade_amount);
+                menu.fadeInAmount = static_cast<float>(commonMenu.m_fade_in_amount);
+                menu.blurRadius = static_cast<float>(commonMenu.m_blur_radius);
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_legacy_split_screen_scale, WINDOW_FLAG_LEGACY_SPLIT_SCREEN_SCALE);
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_hidden_during_scope, WINDOW_FLAG_HIDDEN_DURING_SCOPE);
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_hidden_during_flashbang, WINDOW_FLAG_HIDDEN_DURING_FLASH_BANG);
+                ApplyFlag(menu.window.staticFlags, commonMenu.m_hidden_during_ui, WINDOW_FLAG_HIDDEN_DURING_UI);
+                menu.allowedBinding = ConvertString(commonMenu.m_allowed_binding);
+                ConvertVisibleExpression(menu.window, menu.visibleExp, commonMenu.m_visible_expression.get(), &commonMenu);
+                ConvertOrApplyStatement(menu.window.rect.x, menu.rectXExp, commonMenu.m_rect_x_exp.get(), &commonMenu);
+                ConvertOrApplyStatement(menu.window.rect.y, menu.rectYExp, commonMenu.m_rect_y_exp.get(), &commonMenu);
+                menu.onOpen = ConvertEventHandlerSet(commonMenu.m_on_open.get(), &commonMenu);
+                menu.onClose = ConvertEventHandlerSet(commonMenu.m_on_close.get(), &commonMenu);
+                menu.onESC = ConvertEventHandlerSet(commonMenu.m_on_esc.get(), &commonMenu);
+                menu.onKey = ConvertKeyHandler(commonMenu.m_key_handlers, &commonMenu);
+                menu.items = ConvertMenuItems(commonMenu, menu, menu.itemCount);
+            }
+            catch (const MenuConversionException& e)
+            {
+                PrintConversionExceptionDetails(e);
+                return false;
+            }
+
+            return true;
+        }
+    };
+} // namespace
+
+std::unique_ptr<IMenuConverter>
+    IMenuConverter::Create(const bool disableOptimizations, ISearchPath& searchPath, MemoryManager& memory, AssetCreationContext& context)
+{
+    return std::make_unique<MenuConverter>(disableOptimizations, searchPath, memory, context);
+}

src/ObjLoading/Game/IW3/Menu/MenuConverterIW3.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Asset/AssetCreationContext.h"
+#include "Game/IW3/IW3.h"
+#include "Parsing/Menu/Domain/CommonMenuDef.h"
+#include "SearchPath/ISearchPath.h"
+#include "Utils/MemoryManager.h"
+
+#include <memory>
+
+namespace IW3
+{
+    class IMenuConverter
+    {
+    public:
+        IMenuConverter() = default;
+        virtual ~IMenuConverter() = default;
+
+        virtual bool ConvertMenu(const menu::CommonMenuDef& commonMenu, menuDef_t& menu, AssetRegistration<AssetMenu>& registration) = 0;
+
+        static std::unique_ptr<IMenuConverter> Create(bool disableOptimizations, ISearchPath& searchPath, MemoryManager& memory, AssetCreationContext& context);
+    };
+} // namespace IW3

src/ObjLoading/Game/IW3/ObjLoaderIW3.cpp

@@ -7,6 +7,7 @@
 #include "Game/IW3/IW3.h"
 #include "Game/IW3/Image/ImageLoaderEmbeddedIW3.h"
 #include "Game/IW3/Image/ImageLoaderExternalIW3.h"
+#include "Game/IW3/Menu/LoaderMenuListIW3.h"
 #include "Game/IW3/Techset/PixelShaderLoaderIW3.h"
 #include "Game/IW3/Techset/VertexShaderLoaderIW3.h"
 #include "Game/IW3/Weapon/AccuracyGraphLoaderIW3.h"
@@ -121,7 +122,7 @@ namespace
         // collection.AddAssetCreator(std::make_unique<AssetLoaderGfxWorld>(memory));
         collection.AddAssetCreator(light_def::CreateLoaderIW3(memory, searchPath));
         collection.AddAssetCreator(font::CreateLoaderIW3(memory, searchPath));
-        // collection.AddAssetCreator(std::make_unique<AssetLoaderMenuList>(memory));
+        collection.AddAssetCreator(menu::CreateMenuListLoaderIW3(memory, searchPath));
         // collection.AddAssetCreator(std::make_unique<AssetLoaderMenu>(memory));
         collection.AddAssetCreator(localize::CreateLoaderIW3(memory, searchPath, zone));
         collection.AddAssetCreator(weapon::CreateRawLoaderIW3(memory, searchPath, zone));

src/ObjLoading/Game/IW4/Menu/MenuConverterIW4.cpp

@@ -1117,7 +1117,7 @@ namespace
             auto* item = m_memory.Alloc<itemDef_s>();
 
             item->window.name = ConvertString(commonItem.m_name);
-            item->text = ConvertString(commonItem.m_text);
+            item->text = commonItem.m_text ? m_memory.Dup(commonItem.m_text->c_str()) : nullptr;
             ApplyFlag(item->itemFlags, commonItem.m_text_save_game, ITEM_FLAG_SAVE_GAME_INFO);
             ApplyFlag(item->itemFlags, commonItem.m_text_cinematic_subtitle, ITEM_FLAG_CINEMATIC_SUBTITLE);
             item->window.group = ConvertString(commonItem.m_group);

src/ObjLoading/Game/IW5/Menu/MenuConverterIW5.cpp

@@ -1123,7 +1123,7 @@ namespace
             memset(item, 0, sizeof(itemDef_s));
 
             item->window.name = ConvertString(commonItem.m_name);
-            item->text = ConvertString(commonItem.m_text);
+            item->text = commonItem.m_text ? m_memory.Dup(commonItem.m_text->c_str()) : nullptr;
             ApplyFlag(item->itemFlags, commonItem.m_text_save_game, ITEM_FLAG_SAVE_GAME_INFO);
             ApplyFlag(item->itemFlags, commonItem.m_text_cinematic_subtitle, ITEM_FLAG_CINEMATIC_SUBTITLE);
             item->window.group = ConvertString(commonItem.m_group);

src/ObjLoading/Parsing/Menu/Domain/CommonItemDef.h

@@ -5,6 +5,7 @@
 #include "Parsing/Simple/Expression/ISimpleExpression.h"
 
 #include <map>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -92,7 +93,7 @@ namespace menu
         };
 
         std::string m_name;
-        std::string m_text;
+        std::optional<std::string> m_text;
         bool m_text_save_game = false;
         bool m_text_cinematic_subtitle = false;
         std::string m_group;
@@ -106,7 +107,7 @@ namespace menu
         int m_border = 0;
         double m_border_size = 0;
         int m_owner_draw = 0;
-        int m_owner_draw_flags = 0;
+        unsigned m_owner_draw_flags = 0;
         int m_align = 0;
         int m_text_align = 0;
         double m_text_align_x = 0;

src/ObjLoading/Parsing/Menu/Domain/CommonMenuDef.h

@@ -24,10 +24,11 @@ namespace menu
         CommonColor m_fore_color = CommonColor(1.0, 1.0, 1.0, 1.0);
         CommonColor m_border_color;
         CommonColor m_focus_color;
+        CommonColor m_disable_color;
         CommonColor m_outline_color;
         std::string m_background;
         int m_owner_draw = 0;
-        int m_owner_draw_flags = 0;
+        unsigned m_owner_draw_flags = 0;
         std::string m_sound_loop;
         std::unique_ptr<ISimpleExpression> m_sound_loop_exp;
         double m_fade_clamp = 0;

src/ObjLoading/Parsing/Menu/Domain/MenuFeatureLevel.h

@@ -4,6 +4,7 @@ namespace menu
 {
     enum class FeatureLevel
     {
+        IW3,
         IW4,
         IW5
     };

src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.cpp

@@ -1,5 +1,7 @@
 #include "MenuExpressionMatchers.h"
 
+#include "Game/IW3/IW3.h"
+#include "Game/IW3/MenuConstantsIW3.h"
 #include "Game/IW4/IW4.h"
 #include "Game/IW4/MenuConstantsIW4.h"
 #include "Game/IW5/IW5.h"
@@ -48,11 +50,29 @@ std::unique_ptr<SimpleExpressionMatchers::matcher_t> MenuExpressionMatchers::Par
     });
 }
 
-const std::map<std::string, size_t>& MenuExpressionMatchers::GetBaseFunctionMapForFeatureLevel(const FeatureLevel featureLevel)
+const std::unordered_map<std::string, size_t>& MenuExpressionMatchers::GetBaseFunctionMapForFeatureLevel(const FeatureLevel featureLevel)
 {
+    if (featureLevel == FeatureLevel::IW3)
+    {
+        static std::unordered_map<std::string, size_t> iw3FunctionMap;
+        static bool iw3FunctionMapInitialized = false;
+
+        if (!iw3FunctionMapInitialized)
+        {
+            for (size_t i = IW3::OP_FIRSTFUNCTIONCALL; i < std::extent_v<decltype(IW3::g_expFunctionNames)>; i++)
+            {
+                std::string functionName(IW3::g_expFunctionNames[i]);
+                utils::MakeStringLowerCase(functionName);
+                iw3FunctionMap.emplace(std::make_pair(std::move(functionName), i));
+            }
+        }
+
+        return iw3FunctionMap;
+    }
+
     if (featureLevel == FeatureLevel::IW4)
     {
-        static std::map<std::string, size_t> iw4FunctionMap;
+        static std::unordered_map<std::string, size_t> iw4FunctionMap;
         static bool iw4FunctionMapInitialized = false;
 
         if (!iw4FunctionMapInitialized)
@@ -69,7 +89,7 @@ const std::map<std::string, size_t>& MenuExpressionMatchers::GetBaseFunctionMapF
     }
     if (featureLevel == FeatureLevel::IW5)
     {
-        static std::map<std::string, size_t> iw5FunctionMap;
+        static std::unordered_map<std::string, size_t> iw5FunctionMap;
         static bool iw5FunctionMapInitialized = false;
 
         if (!iw5FunctionMapInitialized)

src/ObjLoading/Parsing/Menu/Matcher/MenuExpressionMatchers.h

@@ -4,15 +4,12 @@
 #include "Parsing/Simple/Expression/SimpleExpressionMatchers.h"
 
 #include <memory>
+#include <unordered_map>
 
 namespace menu
 {
     class MenuExpressionMatchers final : public SimpleExpressionMatchers
     {
-        const MenuFileParserState* m_state;
-
-        static const std::map<std::string, size_t>& GetBaseFunctionMapForFeatureLevel(FeatureLevel featureLevel);
-
     public:
         MenuExpressionMatchers();
         explicit MenuExpressionMatchers(const MenuFileParserState* state);
@@ -20,5 +17,10 @@ namespace menu
     protected:
         std::unique_ptr<matcher_t> ParseOperandExtension(const supplier_t* labelSupplier) const override;
         std::unique_ptr<ISimpleExpression> ProcessOperandExtension(SequenceResult<SimpleParserValue>& result) const override;
+
+    private:
+        const MenuFileParserState* m_state;
+
+        static const std::unordered_map<std::string, size_t>& GetBaseFunctionMapForFeatureLevel(FeatureLevel featureLevel);
     };
 } // namespace menu

src/ObjLoading/Parsing/Menu/MenuFileReader.cpp

@@ -39,6 +39,9 @@ void MenuFileReader::SetupDefinesProxy()
     defines->AddDefine(DefinesStreamProxy::Define("PC", "1"));
     switch (m_feature_level)
     {
+    case FeatureLevel::IW3:
+        defines->AddDefine(DefinesStreamProxy::Define("FEATURE_LEVEL_IW3", "1"));
+        break;
     case FeatureLevel::IW4:
         defines->AddDefine(DefinesStreamProxy::Define("FEATURE_LEVEL_IW4", "1"));
         break;

src/ObjLoading/Parsing/Menu/Sequence/EventHandlerSetScopeSequences.cpp

@@ -281,7 +281,7 @@ namespace
             AddMatchers({
                 create
                     .Or({
-                        create.Numeric(),
+                        create.ScriptStrictNumeric(),
                         create.String(),
                         create.Identifier(),
                         create.Type(SimpleParserValueType::CHARACTER),
@@ -928,6 +928,15 @@ EventHandlerSetScopeSequences::EventHandlerSetScopeSequences(std::vector<std::un
 void EventHandlerSetScopeSequences::AddSequences(const FeatureLevel featureLevel, const bool permissive) const
 {
     AddSequence(std::make_unique<SequenceSkipEmptyStatements>());
+
+    // IW3 stores event handlers as opaque script strings rather than structured handlers.
+    if (featureLevel == FeatureLevel::IW3)
+    {
+        AddSequence(std::make_unique<SequenceCloseBlock>());
+        AddSequence(std::make_unique<SequenceSkipScriptToken>());
+        return;
+    }
+
     // If else and stuff
 
     // Creating factory with no label supplier. Cannot use labels with it.

src/ObjLoading/Parsing/Menu/Sequence/GlobalScopeSequences.cpp

@@ -109,7 +109,8 @@ GlobalScopeSequences::GlobalScopeSequences(std::vector<std::unique_ptr<MenuFileP
 void GlobalScopeSequences::AddSequences(const FeatureLevel featureLevel, const bool permissive) const
 {
     AddSequence(std::make_unique<SequenceCloseBlock>());
-    AddSequence(std::make_unique<SequenceFunctionDef>());
+    if (featureLevel != FeatureLevel::IW3)
+        AddSequence(std::make_unique<SequenceFunctionDef>());
     AddSequence(std::make_unique<SequenceMenuDef>());
     AddSequence(std::make_unique<SequenceLoadMenu>());
 }

src/ObjLoading/Parsing/Menu/Sequence/ItemScopeSequences.cpp

@@ -24,7 +24,7 @@ namespace
 
     class ItemScopeOperations
     {
-        inline static const CommonItemFeatureType IW4_FEATURE_TYPE_BY_TYPE[0x18]{
+        inline static const CommonItemFeatureType IW3_IW4_FEATURE_TYPE_BY_TYPE[0x18]{
             CommonItemFeatureType::EDIT_FIELD,  // ITEM_TYPE_TEXT
             CommonItemFeatureType::NONE,        // ITEM_TYPE_BUTTON
             CommonItemFeatureType::NONE,        // ITEM_TYPE_RADIOBUTTON
@@ -78,32 +78,34 @@ namespace
             CommonItemFeatureType::EDIT_FIELD,  // ITEM_TYPE_PASSWORDFIELD
         };
 
-    public:
-        static void SetItemType(CommonItemDef& item, const FeatureLevel featureLevel, const TokenPos& pos, const int type)
+        static CommonItemFeatureType GetFeatureTypeForItemType(const FeatureLevel featureLevel, const TokenPos& pos, const int type)
         {
-            if (type < 0)
-                throw ParsingException(pos, "Invalid item type");
-
-            if (item.m_feature_type != CommonItemFeatureType::NONE)
-                throw ParsingException(pos, "Item type has already been set");
-
-            item.m_type = type;
-
             switch (featureLevel)
             {
+            case FeatureLevel::IW3:
             case FeatureLevel::IW4:
-                if (static_cast<unsigned>(type) >= std::extent_v<decltype(IW4_FEATURE_TYPE_BY_TYPE)>)
+                if (static_cast<unsigned>(type) >= std::extent_v<decltype(IW3_IW4_FEATURE_TYPE_BY_TYPE)>)
                     throw ParsingException(pos, "Invalid item type");
-                item.m_feature_type = IW4_FEATURE_TYPE_BY_TYPE[static_cast<unsigned>(type)];
-                break;
+                return IW3_IW4_FEATURE_TYPE_BY_TYPE[static_cast<unsigned>(type)];
 
             case FeatureLevel::IW5:
             default:
                 if (static_cast<unsigned>(type) >= std::extent_v<decltype(IW5_FEATURE_TYPE_BY_TYPE)>)
                     throw ParsingException(pos, "Invalid item type");
-                item.m_feature_type = IW5_FEATURE_TYPE_BY_TYPE[static_cast<unsigned>(type)];
-                break;
+                return IW5_FEATURE_TYPE_BY_TYPE[static_cast<unsigned>(type)];
             }
+        }
+
+    public:
+        static void SetItemType(CommonItemDef& item, const FeatureLevel featureLevel, const TokenPos& pos, const int type)
+        {
+            const auto featureType = GetFeatureTypeForItemType(featureLevel, pos, type);
+
+            if (item.m_feature_type != CommonItemFeatureType::NONE)
+                throw ParsingException(pos, "Item type has already been set");
+
+            item.m_type = type;
+            item.m_feature_type = featureType;
 
             switch (item.m_feature_type)
             {
@@ -130,9 +132,16 @@ namespace
                 throw ParsingException(pos, "Item must have be listbox to use this declaration");
         }
 
-        static void EnsureHasEditFieldFeatures(const CommonItemDef& item, const TokenPos& pos)
+        static void EnsureHasEditFieldFeatures(CommonItemDef& item, const FeatureLevel featureLevel, const TokenPos& pos)
         {
-            if (item.m_feature_type != CommonItemFeatureType::EDIT_FIELD || !item.m_edit_field_features)
+            // Due to default item types, edit field capabilities might not have been initialized
+            if (item.m_feature_type == CommonItemFeatureType::NONE
+                && GetFeatureTypeForItemType(featureLevel, pos, item.m_type) == CommonItemFeatureType::EDIT_FIELD)
+            {
+                item.m_feature_type = CommonItemFeatureType::EDIT_FIELD;
+                item.m_edit_field_features = std::make_unique<CommonItemFeaturesEditField>();
+            }
+            else if (item.m_feature_type != CommonItemFeatureType::EDIT_FIELD || !item.m_edit_field_features)
                 throw ParsingException(pos, "Item must have be edit field to use this declaration");
         }
 
@@ -360,7 +369,7 @@ namespace
         {
             assert(state->m_current_item);
 
-            ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos());
+            ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, state->m_feature_level, result.NextCapture(CAPTURE_FIRST_TOKEN).GetPos());
             state->m_current_item->m_dvar = MenuMatcherFactory::TokenTextValue(result.NextCapture(CAPTURE_DVAR_NAME));
             state->m_current_item->m_edit_field_features->m_def_val = MenuMatcherFactory::TokenNumericExpressionValue(state, result);
             state->m_current_item->m_edit_field_features->m_min_val = MenuMatcherFactory::TokenNumericExpressionValue(state, result);
@@ -455,8 +464,8 @@ namespace
         static constexpr auto CAPTURE_FIRST_TOKEN = 1;
         static constexpr auto CAPTURE_COLUMN_COUNT = 2;
 
-        static constexpr const char* SYNTAX_IW4 = "<xpos> <width> <maxChars> [alignment]";
-        static constexpr auto BASE_COLUMN_COUNT_IW4 = 3;
+        static constexpr const char* SYNTAX_IW3_IW4 = "<xpos> <width> <maxChars> [alignment]";
+        static constexpr auto BASE_COLUMN_COUNT_IW3_IW4 = 3;
 
         static constexpr const char* SYNTAX_IW5 = "<xpos> <ypos> <width> <height> <maxChars> [alignment]";
         static constexpr auto BASE_COLUMN_COUNT_IW5 = 5;
@@ -478,7 +487,7 @@ namespace
         void ProcessMatch(MenuFileParserState* state, SequenceResult<SimpleParserValue>& result) const override
         {
             assert(state->m_current_item);
-            assert(state->m_feature_level == FeatureLevel::IW4 || state->m_feature_level == FeatureLevel::IW5);
+            assert(state->m_feature_level == FeatureLevel::IW3 || state->m_feature_level == FeatureLevel::IW4 || state->m_feature_level == FeatureLevel::IW5);
 
             const auto& firstToken = result.NextCapture(CAPTURE_FIRST_TOKEN);
             ItemScopeOperations::EnsureHasListboxFeatures(*state->m_current_item, firstToken.GetPos());
@@ -491,10 +500,10 @@ namespace
             size_t baseColumnCount;
             const char* syntax;
             bool hasHeightValues;
-            if (state->m_feature_level == FeatureLevel::IW4)
+            if (state->m_feature_level == FeatureLevel::IW3 || state->m_feature_level == FeatureLevel::IW4)
             {
-                baseColumnCount = BASE_COLUMN_COUNT_IW4;
-                syntax = SYNTAX_IW4;
+                baseColumnCount = BASE_COLUMN_COUNT_IW3_IW4;
+                syntax = SYNTAX_IW3_IW4;
                 hasHeightValues = false;
             }
             else
@@ -1151,25 +1160,29 @@ void ItemScopeSequences::AddSequences(const FeatureLevel featureLevel, const boo
     AddSequence(std::make_unique<GenericStringPropertySequence>("localvar",
                                                                 [](const MenuFileParserState* state, const TokenPos& pos, const std::string& value)
                                                                 {
-                                                                    ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, pos);
+                                                                    ItemScopeOperations::EnsureHasEditFieldFeatures(
+                                                                        *state->m_current_item, state->m_feature_level, pos);
                                                                     state->m_current_item->m_edit_field_features->m_local_var = value;
                                                                 }));
     AddSequence(std::make_unique<GenericIntPropertySequence>("maxChars",
                                                              [](const MenuFileParserState* state, const TokenPos& pos, const int value)
                                                              {
-                                                                 ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, pos);
+                                                                 ItemScopeOperations::EnsureHasEditFieldFeatures(
+                                                                     *state->m_current_item, state->m_feature_level, pos);
                                                                  state->m_current_item->m_edit_field_features->m_max_chars = value;
                                                              }));
     AddSequence(std::make_unique<GenericIntPropertySequence>("maxPaintChars",
                                                              [](const MenuFileParserState* state, const TokenPos& pos, const int value)
                                                              {
-                                                                 ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, pos);
+                                                                 ItemScopeOperations::EnsureHasEditFieldFeatures(
+                                                                     *state->m_current_item, state->m_feature_level, pos);
                                                                  state->m_current_item->m_edit_field_features->m_max_paint_chars = value;
                                                              }));
     AddSequence(std::make_unique<GenericKeywordPropertySequence>("maxCharsGotoNext",
                                                                  [](const MenuFileParserState* state, const TokenPos& pos)
                                                                  {
-                                                                     ItemScopeOperations::EnsureHasEditFieldFeatures(*state->m_current_item, pos);
+                                                                     ItemScopeOperations::EnsureHasEditFieldFeatures(
+                                                                         *state->m_current_item, state->m_feature_level, pos);
                                                                      state->m_current_item->m_edit_field_features->m_max_chars_goto_next = true;
                                                                  }));
 

src/ObjLoading/Parsing/Menu/Sequence/MenuScopeSequences.cpp

@@ -309,6 +309,11 @@ void MenuScopeSequences::AddSequences(const FeatureLevel featureLevel, const boo
                                                                {
                                                                    state->m_current_menu->m_focus_color = value;
                                                                }));
+    AddSequence(std::make_unique<GenericColorPropertySequence>("disablecolor",
+                                                               [](const MenuFileParserState* state, const TokenPos&, const CommonColor value)
+                                                               {
+                                                                   state->m_current_menu->m_disable_color = value;
+                                                               }));
     AddSequence(std::make_unique<GenericColorPropertySequence>("outlinecolor",
                                                                [](const MenuFileParserState* state, const TokenPos&, const CommonColor& value)
                                                                {