Mod.cs

using Colossal.IO.AssetDatabase;
using Colossal.Logging;
using Colossal.Serialization.Entities;
using DisableAccidents.ModSettings;
using Game;
using Game.Modding;
using Game.Prefabs;
using Game.SceneFlow;
using Unity.Collections;
using Unity.Entities;

namespace DisableAccidents
{
    public class Mod : IMod
    {
        public static ILog log = LogManager.GetLogger($"{nameof(DisableAccidents)}").SetShowsErrorsInUI(false);

        internal static Setting m_Setting;

        public void OnLoad(UpdateSystem updateSystem)
        {
            log.Info(nameof(OnLoad));

            m_Setting = new Setting(this);
            m_Setting.RegisterInOptionsUI();
            GameManager.instance.localizationManager.AddSource("en-US", new LocaleEN(m_Setting));
            AssetDatabase.global.LoadSettings(nameof(DisableAccidents), m_Setting);
            m_Setting.Apply();

            updateSystem.UpdateAt<NoTrafficAccidentsSystem>(SystemUpdatePhase.ModificationEnd);
            updateSystem.UpdateAt<InitialSettingsApplySystem>(SystemUpdatePhase.ModificationEnd);
        }

        public void OnDispose()
        {
            log.Info(nameof(OnDispose));
            if (m_Setting != null)
            {
                m_Setting.UnregisterInOptionsUI();
                m_Setting = null;
                Setting.Instance = null;
            }
        }
    }

    public partial class InitialSettingsApplySystem : GameSystemBase
    {
        protected override void OnCreate()
        {
            base.OnCreate();
            this.Enabled = true;
        }

        protected override void OnUpdate()
        {
            if (Setting.Instance != null)
            {
                var accidentSystem = EntityManager.World.GetOrCreateSystemManaged<NoTrafficAccidentsSystem>();
                accidentSystem.ForceUpdate(
                    Setting.Instance.ModEnabled,
                    Setting.Instance.ModEnabled ? 0f : (Setting.Instance.AccidentProbability / 100f)
                );
                this.Enabled = false;
            }
        }
    }

    public partial class NoTrafficAccidentsSystem : GameSystemBase
    {
        private PrefabSystem m_PrefabSystem;
        private EntityQuery m_AccidentPrefabQuery;
        private bool m_LastEnabledState;
        private float m_LastMultiplier;

        protected override void OnCreate()
        {
            base.OnCreate();

            m_PrefabSystem = World.GetOrCreateSystemManaged<PrefabSystem>();
            m_AccidentPrefabQuery = GetEntityQuery(
                ComponentType.ReadOnly<EventData>(),
                ComponentType.ReadOnly<TrafficAccidentData>(),
                ComponentType.Exclude<Locked>()
            );

            RequireForUpdate(m_AccidentPrefabQuery);
        }

        public void ForceUpdate(bool currentEnabled, float multiplier)
        {
            m_LastEnabledState = currentEnabled;
            m_LastMultiplier = multiplier;
            UpdateAccidentProbabilities(currentEnabled, multiplier);
        }

        protected override void OnUpdate()
        {
            bool currentEnabled = Setting.Instance?.ModEnabled ?? false;
            float currentMultiplier = currentEnabled ? 0f : (Setting.Instance?.AccidentProbability ?? 100) / 100f;

            if (currentEnabled != m_LastEnabledState || currentMultiplier != m_LastMultiplier)
            {
                m_LastEnabledState = currentEnabled;
                m_LastMultiplier = currentMultiplier;
                UpdateAccidentProbabilities(currentEnabled, currentMultiplier);
            }
        }

        private void UpdateAccidentProbabilities(bool disableAccidents, float multiplier)
        {
            Mod.log.Info($"Setting accident probabilities to {(disableAccidents ? 0f : multiplier * 100f):0}% of vanilla");
            using var accidentPrefabs = m_AccidentPrefabQuery.ToEntityArray(Allocator.Temp);
            foreach (var prefab in accidentPrefabs)
            {
                if (!m_PrefabSystem.GetPrefab<PrefabBase>(prefab).TryGet(out TrafficAccident accident))
                {
                    continue;
                }

                var data = EntityManager.GetComponentData<TrafficAccidentData>(prefab);
                data.m_OccurenceProbability = disableAccidents ? 0f : accident.m_OccurrenceProbability * multiplier;
                EntityManager.SetComponentData(prefab, data);
            }
        }

        protected override void OnGameLoadingComplete(Purpose purpose, GameMode mode)
        {
            base.OnGameLoadingComplete(purpose, mode);
            bool currentEnabled = Setting.Instance?.ModEnabled ?? false;
            float currentMultiplier = currentEnabled ? 0f : (Setting.Instance?.AccidentProbability ?? 100) / 100f;
            ForceUpdate(currentEnabled, currentMultiplier);
        }
    }
}