Cleanup Lua plugin implementation.

* Move the UI code out of the plugin logic.
* Add types where needed.
* Move into game package.
* Improve error handling.
* Simplify settings behavior.
* Don't load disabled plugins.
* Remove knowledge of non-base plugins from game generation.

Fixes https://github.com/Khopa/dcs_liberation/issues/311

game/game.py

@@ -3,7 +3,7 @@ import math
 import random
 import sys
 from datetime import date, datetime, timedelta
-from typing import Any, Dict, List
+from typing import Dict, List
 
 from dcs.action import Coalition
 from dcs.mapping import Point
@@ -15,6 +15,7 @@ from game import db
 from game.db import PLAYER_BUDGET_BASE, REWARDS
 from game.inventory import GlobalAircraftInventory
 from game.models.game_stats import GameStats
+from game.plugins import LuaPluginManager
 from gen.ato import AirTaskingOrder
 from gen.conflictgen import Conflict
 from gen.flights.ai_flight_planner import CoalitionMissionPlanner
@@ -29,7 +30,6 @@ from .event.frontlineattack import FrontlineAttackEvent
 from .factions.faction import Faction
 from .infos.information import Information
 from .settings import Settings
-from plugin import LuaPluginManager
 from .weather import Conditions, TimeOfDay
 
 COMMISION_UNIT_VARIETY = 4
@@ -226,11 +226,8 @@ class Game:
             return event and event.name and event.name == self.player_name
 
     def on_load(self) -> None:
+        LuaPluginManager.load_settings(self.settings)
         ObjectiveDistanceCache.set_theater(self.theater)
-        
-        # set the settings in all plugins
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.setSettings(self.settings)
 
         # Save game compatibility.
 

game/operation/operation.py

@@ -14,6 +14,7 @@ from dcs.translation import String
 from dcs.triggers import TriggerStart
 from dcs.unittype import UnitType
 
+from game.plugins import LuaPluginManager
 from gen import Conflict, FlightType, VisualGenerator
 from gen.aircraft import AIRCRAFT_DATA, AircraftConflictGenerator, FlightData
 from gen.airfields import AIRFIELD_DATA
@@ -28,7 +29,6 @@ from gen.kneeboard import KneeboardGenerator
 from gen.radios import RadioFrequency, RadioRegistry
 from gen.tacan import TacanRegistry
 from gen.triggergen import TRIGGER_RADIUS_MEDIUM, TriggersGenerator
-from plugin import LuaPluginManager
 from theater import ControlPoint
 from .. import db
 from ..debriefing import Debriefing
@@ -473,9 +473,10 @@ dcsLiberation.TargetPoints = {
         self.current_mission.triggerrules.triggers.append(trigger)
 
         # Inject Plugins Lua Scripts and data
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.injectScripts(self)
-            plugin.injectConfiguration(self)
+        for plugin in LuaPluginManager.plugins():
+            if plugin.enabled:
+                plugin.inject_scripts(self)
+                plugin.inject_configuration(self)
 
         self.assign_channels_to_flights(airgen.flights,
                                         airsupportgen.air_support)

game/plugins/__init__.py

@@ -0,0 +1,2 @@
+from .luaplugin import LuaPlugin
+from .manager import LuaPluginManager

game/plugins/luaplugin.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+import json
+import logging
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, TYPE_CHECKING
+
+from game.settings import Settings
+
+if TYPE_CHECKING:
+    from game.operation.operation import Operation
+
+
+class LuaPluginWorkOrder:
+
+    def __init__(self, parent_mnemonic: str, filename: str, mnemonic: str,
+                 disable: bool) -> None:
+        self.parent_mnemonic = parent_mnemonic
+        self.filename = filename
+        self.mnemonic = mnemonic
+        self.disable = disable
+
+    def work(self, operation: Operation) -> None:
+        if self.disable:
+            operation.bypass_plugin_script(self.mnemonic)
+        else:
+            operation.inject_plugin_script(self.parent_mnemonic, self.filename,
+                                           self.mnemonic)
+
+
+class PluginSettings:
+    def __init__(self, identifier: str, enabled_by_default: bool) -> None:
+        self.identifier = identifier
+        self.enabled_by_default = enabled_by_default
+        self.settings = Settings()
+        self.initialize_settings()
+
+    def set_settings(self, settings: Settings):
+        self.settings = settings
+        self.initialize_settings()
+
+    def initialize_settings(self) -> None:
+        # Plugin options are saved in the game's Settings, but it's possible for
+        # plugins to change across loads. If new plugins are added or new
+        # options added to those plugins, initialize the new settings.
+        self.settings.initialize_plugin_option(self.identifier,
+                                               self.enabled_by_default)
+
+    @property
+    def enabled(self) -> bool:
+        return self.settings.plugin_option(self.identifier)
+
+    def set_enabled(self, enabled: bool) -> None:
+        self.settings.set_plugin_option(self.identifier, enabled)
+
+
+class LuaPluginOption(PluginSettings):
+    def __init__(self, identifier: str, name: str,
+                 enabled_by_default: bool) -> None:
+        super().__init__(identifier, enabled_by_default)
+        self.name = name
+
+
+@dataclass(frozen=True)
+class LuaPluginDefinition:
+    identifier: str
+    name: str
+    present_in_ui: bool
+    enabled_by_default: bool
+    options: List[LuaPluginOption]
+    work_orders: List[LuaPluginWorkOrder]
+    config_work_orders: List[LuaPluginWorkOrder]
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> LuaPluginDefinition:
+        data = json.loads(path.read_text())
+
+        options = []
+        for option in data.get("specificOptions"):
+            option_id = option["mnemonic"]
+            options.append(LuaPluginOption(
+                identifier=f"{name}.{option_id}",
+                name=option.get("nameInUI", name),
+                enabled_by_default=option.get("defaultValue")
+            ))
+
+        work_orders = []
+        for work_order in data.get("scriptsWorkOrders"):
+            work_orders.append(LuaPluginWorkOrder(
+                name, work_order.get("file"), work_order["mnemonic"],
+                work_order.get("disable", False)
+            ))
+        config_work_orders = []
+        for work_order in data.get("configurationWorkOrders"):
+            config_work_orders.append(LuaPluginWorkOrder(
+                name, work_order.get("file"), work_order["mnemonic"],
+                work_order.get("disable", False)
+            ))
+
+        return cls(
+            identifier=name,
+            name=data["nameInUI"],
+            present_in_ui=not data.get("skipUI", False),
+            enabled_by_default=data.get("defaultValue", False),
+            options=options,
+            work_orders=work_orders,
+            config_work_orders=config_work_orders
+        )
+
+
+class LuaPlugin(PluginSettings):
+
+    def __init__(self, definition: LuaPluginDefinition) -> None:
+        self.definition = definition
+        super().__init__(self.definition.identifier,
+                         self.definition.enabled_by_default)
+
+    @property
+    def name(self) -> str:
+        return self.definition.name
+
+    @property
+    def show_in_ui(self) -> bool:
+        return self.definition.present_in_ui
+
+    @property
+    def options(self) -> List[LuaPluginOption]:
+        return self.definition.options
+
+    @classmethod
+    def from_json(cls, name: str, path: Path) -> Optional[LuaPlugin]:
+        try:
+            definition = LuaPluginDefinition.from_json(name, path)
+        except KeyError:
+            logging.exception("Required plugin configuration value missing")
+            return None
+
+        return cls(definition)
+
+    def set_settings(self, settings: Settings):
+        super().set_settings(settings)
+        for option in self.definition.options:
+            option.set_settings(self.settings)
+
+    def inject_scripts(self, operation: Operation) -> None:
+        for work_order in self.definition.work_orders:
+            work_order.work(operation)
+
+    def inject_configuration(self, operation: Operation) -> None:
+        # inject the plugin options
+        if self.options:
+            option_decls = []
+            for option in self.options:
+                enabled = str(option.enabled).lower()
+                name = option.identifier
+                option_decls.append(
+                    f"    dcsLiberation.plugins.{name} = {enabled}")
+
+            joined_options = "\n".join(option_decls)
+
+            lua = textwrap.dedent(f"""\
+                -- {self.identifier} plugin configuration.
+
+                if dcsLiberation then
+                    if not dcsLiberation.plugins then
+                        dcsLiberation.plugins = {{}}
+                    end
+                    dcsLiberation.plugins.{self.identifier} = {{}}
+                    {joined_options}
+                end
+
+            """)
+
+            operation.inject_lua_trigger(
+                lua, f"{self.identifier} plugin configuration")
+
+        for work_order in self.definition.config_work_orders:
+            work_order.work(operation)

game/plugins/manager.py

@@ -0,0 +1,50 @@
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from game.settings import Settings
+from game.plugins.luaplugin import LuaPlugin
+
+
+class LuaPluginManager:
+    _plugins_loaded = False
+    _plugins: Dict[str, LuaPlugin] = {}
+
+    @classmethod
+    def _load_plugins(cls) -> None:
+        plugins_path = Path("resources/plugins")
+
+        path = plugins_path / "plugins.json"
+        if not path.exists():
+            raise RuntimeError(f"{path} does not exist. Cannot continue.")
+
+        logging.info(f"Reading plugins list from {path}")
+
+        data = json.loads(path.read_text())
+        for name in data:
+            plugin_path = plugins_path / name / "plugin.json"
+            if not plugin_path.exists():
+                raise RuntimeError(
+                    f"Invalid plugin configuration: required plugin {name} "
+                    f"does not exist at {plugin_path}")
+            logging.info(f"Loading plugin {name} from {plugin_path}")
+            plugin = LuaPlugin.from_json(name, plugin_path)
+            if plugin is not None:
+                cls._plugins[name] = plugin
+        cls._plugins_loaded = True
+
+    @classmethod
+    def _get_plugins(cls) -> Dict[str, LuaPlugin]:
+        if not cls._plugins_loaded:
+            cls._load_plugins()
+        return cls._plugins
+
+    @classmethod
+    def plugins(cls) -> List[LuaPlugin]:
+        return list(cls._get_plugins().values())
+
+    @classmethod
+    def load_settings(cls, settings: Settings) -> None:
+        for plugin in cls.plugins():
+            plugin.set_settings(settings)

game/settings.py

@@ -1,4 +1,5 @@
-from plugin import LuaPluginManager
+from typing import Dict
+
 
 class Settings:
 
@@ -40,15 +41,30 @@ class Settings:
         self.perf_culling_distance = 100
 
         # LUA Plugins system
-        self.plugins = {}
-        for plugin in LuaPluginManager().getPlugins():
-            plugin.setSettings(self)
+        self.plugins: Dict[str, bool] = {}
 
         # Cheating
         self.show_red_ato = False
 
         self.never_delay_player_flights = False
 
+    @staticmethod
+    def plugin_settings_key(identifier: str) -> str:
+        return f"plugins.{identifier}"
+
+    def initialize_plugin_option(self, identifier: str,
+                                 default_value: bool) -> None:
+        try:
+            self.plugin_option(identifier)
+        except KeyError:
+            self.set_plugin_option(identifier, default_value)
+
+    def plugin_option(self, identifier: str) -> bool:
+        return self.plugins[self.plugin_settings_key(identifier)]
+
+    def set_plugin_option(self, identifier: str, enabled: bool) -> None:
+        self.plugins[self.plugin_settings_key(identifier)] = enabled
+
     def __setstate__(self, state) -> None:
         # __setstate__ is called with the dict of the object being unpickled. We
         # can provide save compatibility for new settings options (which