RailTrackSpeedIncreaser

using System;
using System.Collections.Generic;
using ICities;
using UnityEngine;
using ColossalFramework.UI;

namespace RailTrackSpeedIncreaser
{
    public class Mod : LoadingExtensionBase, IUserMod
    {
        private static readonly string _version = "2.2.1";
        private static readonly string _prefix = "RTSI: ";
        private static readonly string _format = "{0} track max speed: {1} km/h";

        private Dictionary<ItemClass.SubService, float> _subServiceSpeedMap = new Dictionary<ItemClass.SubService, float>()
        {
            { ItemClass.SubService.PublicTransportMetro, 11.25f },
            { ItemClass.SubService.PublicTransportTrain, 11.25f }
        };
        private Dictionary<NetInfo, float> _prefabSpeedMap = new Dictionary<NetInfo, float>();
        private bool _ingame = false;

        #region IUserMod
        public string Name
        {
            get { return "Rail Track Speed Increaser " + _version; }
        }

        public string Description
        {
            get { return "Increases the speed of metro and train tracks."; }
        }
        #endregion

        #region OnSettingsUI
        private UISlider AddSlider(UIHelperBase parent, string text, ItemClass.SubService subService, string playerPerf)
        {
            var defaultValue = PlayerPrefs.GetFloat(playerPerf, _subServiceSpeedMap[subService]);
            _subServiceSpeedMap[subService] = defaultValue;
            defaultValue *= 40f;
            var uIPanel = ((parent as UIHelper).self as UIComponent).AttachUIComponent(UITemplateManager.GetAsGameObject("OptionsSliderTemplate")) as UIPanel;
            var uILabel = uIPanel.Find<UILabel>("Label");
            uILabel.text = string.Format(_format, text, defaultValue);
            uILabel.autoSize = true;
            uILabel.wordWrap = false;
            var uISlider = uIPanel.Find<UISlider>("Slider");
            uISlider.minValue = 10;
            uISlider.maxValue = 450;
            uISlider.stepSize = 10;
            uISlider.value = defaultValue;
            uISlider.eventValueChanged += (sender, value) =>
            {
                uILabel.text = string.Format(_format, text, value);
                value /= 40;
                PlayerPrefs.SetFloat(playerPerf, value);
                _subServiceSpeedMap[subService] = value;
                if (_ingame)
                    UpdateSpeeds(subService);
            };
            return uISlider;
        }

        public void OnSettingsUI(UIHelperBase helper)
        {
            var group = helper.AddGroup("Settings");
            var metro = AddSlider(group, "Metro", ItemClass.SubService.PublicTransportMetro, "RTSI_METRO");
            var train = AddSlider(group, "Train", ItemClass.SubService.PublicTransportTrain, "RTSI_TRAIN");
        }
        #endregion

        #region LoadingExtensionBase
        public override void OnLevelLoaded(LoadMode mode)
        {
            if (mode != LoadMode.LoadGame && mode != LoadMode.NewGame)
                return;

            UpdateSpeeds();

            _ingame = true;
        }

        public override void OnLevelUnloading()
        {
            _ingame = false;
            if (_prefabSpeedMap.Count > 0)
            {
                foreach (var item in _prefabSpeedMap)
                {
                    try
                    {
                        Debug.Log(_prefix + "Reverting speed of " + item.Key.name + " to " + item.Value);
                        item.Key.m_averageVehicleLaneSpeed = item.Value;

                        for (int i = 0; i < item.Key.m_lanes.Length; i++)
                        {
                            var lane = item.Key.m_lanes[i];
                            if (lane != null && lane.m_laneType == NetInfo.LaneType.Vehicle)
                            {
                                lane.m_speedLimit = item.Value;
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Debug.LogWarning(_prefix + "Could not revert rail track speed. " + e.Message + Environment.NewLine + e.StackTrace);
                    }
                }
                _prefabSpeedMap.Clear();
            }
        }
        #endregion

        private void UpdateSpeeds(ItemClass.SubService subService = ItemClass.SubService.None)
        {
            var count = PrefabCollection<NetInfo>.PrefabCount();
            for (int i = 0; i < count; i++)
            {
                try
                {
                    var prefab = PrefabCollection<NetInfo>.GetPrefab((uint)i);
                    if (prefab == null)
                        continue;

                    var prefabSubService = prefab.GetSubService();
                    var flag = false;

                    if (subService == ItemClass.SubService.None)
                        flag = prefab.name.Contains("Track") && (prefabSubService == ItemClass.SubService.PublicTransportMetro || prefabSubService == ItemClass.SubService.PublicTransportTrain);
                    else
                        flag = prefab.name.Contains("Track") && prefabSubService == subService;

                    if (flag)
                    {
                        if (prefab.m_lanes == null)
                            continue;

                        var maxSpeed = _subServiceSpeedMap[prefabSubService];
                        if (!_ingame)
                        {
                            _prefabSpeedMap.Add(prefab, prefab.m_averageVehicleLaneSpeed);
                            Debug.Log(_prefix + "Increasing speed of " + prefab.name + " to " + maxSpeed);
                        }

                        for (int j = 0; j < prefab.m_lanes.Length; j++)
                        {
                            var lane = prefab.m_lanes[j];
                            if (lane != null && lane.m_laneType == NetInfo.LaneType.Vehicle)
                            {
                                lane.m_speedLimit = maxSpeed;
                            }
                        }
                        prefab.m_averageVehicleLaneSpeed = maxSpeed;
                    }
                }
                catch (Exception e)
                {
                    Debug.LogWarning(_prefix + "Could not increase rail track speed. " + e.Message + Environment.NewLine + e.StackTrace);
                }
            }
        }
    }
}