Exemplo n.º 1
0
        public static void StoreAll()
        {
            DefaultOptions.Clear();
            for (uint i = 0; i < PrefabCollection <VehicleInfo> .PrefabCount(); i++)
            {
                DefaultOptions.Store(PrefabCollection <VehicleInfo> .GetPrefab(i));
            }

            DebugUtils.Log("Default values stored");
        }
Exemplo n.º 2
0
        public static void ResetVehicleDataConfig()
        {
            // Checking for conflicts
            DefaultOptions.CheckForConflicts();

            // Update existing vehicles
            SimulationManager.instance.AddAction(VehicleOptions.UpdateCapacityUnits);
            SimulationManager.instance.AddAction(VehicleOptions.UpdateBackEngines);

            Logging.Message("Vehicle Configuration reset");
        }
Exemplo n.º 3
0
        public static void ResetConfig()
        {
            // Checking for conflicts
            DefaultOptions.CheckForConflicts();

            // Update existing vehicles
            new EnumerableActionThread(VehicleOptions.UpdateCapacityUnits);
            new EnumerableActionThread(VehicleOptions.UpdateBackEngines);

            DebugUtils.Log("Configuration reset");
        }
Exemplo n.º 4
0
        /// <summary>
        /// Called when the level (game, map editor, asset editor) is loaded
        /// </summary>
        public override void OnLevelLoaded(LoadMode mode)
        {
            try
            {
                // Is it an actual game ?
                if (mode != LoadMode.LoadGame && mode != LoadMode.NewGame && mode != LoadMode.NewGameFromScenario)
                {
                    DefaultOptions.Clear();
                    Logging.Error("AVO Incompatible GameMode " + mode);
                    return;
                }

                AdvancedVehicleOptions.isGameLoaded = true;

                if (instance != null)
                {
                    GameObject.DestroyImmediate(instance.gameObject);
                }

                instance = new GameObject("AdvancedVehicleOptions").AddComponent <AdvancedVehicleOptions>();

                try
                {
                    DefaultOptions.BuildVehicleInfoDictionary();
                    VehicleOptions.Clear();
                    Logging.Message("UIMainPanel created");
                }
                catch
                {
                    Logging.Error("Could not create UIMainPanel");

                    if (instance != null)
                    {
                        GameObject.Destroy(instance.gameObject);
                    }

                    return;
                }

                //new EnumerableActionThread(BrokenAssetsFix);
            }
            catch (Exception e)
            {
                if (instance != null)
                {
                    GameObject.Destroy(instance.gameObject);
                }
                Logging.LogException(e);
            }
        }
        /// <summary>
        /// Called when the level (game, map editor, asset editor) is loaded
        /// </summary>
        public override void OnLevelLoaded(LoadMode mode)
        {
            try
            {
                // Is it an actual game ?
                if (mode != LoadMode.LoadGame && mode != LoadMode.NewGame)
                {
                    DefaultOptions.Clear();
                    return;
                }

                AdvancedVehicleOptionsUID.isGameLoaded = true;

                if (instance != null)
                {
                    GameObject.DestroyImmediate(instance.gameObject);
                }

                instance = new GameObject("AdvancedVehicleOptionsUID").AddComponent <AdvancedVehicleOptionsUID>();

                try
                {
                    DefaultOptions.BuildVehicleInfoDictionary();
                    VehicleOptions.Clear();
                    DebugUtils.Log("UIMainPanel created");
                }
                catch
                {
                    DebugUtils.Log("Could not create UIMainPanel");

                    if (instance != null)
                    {
                        GameObject.Destroy(instance.gameObject);
                    }

                    return;
                }

                //new EnumerableActionThread(BrokenAssetsFix);
            }
            catch (Exception e)
            {
                if (instance != null)
                {
                    GameObject.Destroy(instance.gameObject);
                }
                DebugUtils.LogException(e);
            }
        }
        /// <summary>
        /// Init the configuration
        /// </summary>
        public static void InitConfig()
        {
            // Store modded values
            DefaultOptions.StoreAllModded();

            if (config.data != null)
            {
                config.DataToOptions();

                // Remove unneeded options
                List <VehicleOptions> optionsList = new List <VehicleOptions>();

                for (uint i = 0; i < config.options.Length; i++)
                {
                    if (config.options[i] != null && config.options[i].prefab != null)
                    {
                        optionsList.Add(config.options[i]);
                    }
                }

                config.options = optionsList.ToArray();
            }
            else if (File.Exists(m_fileName))
            {
                // Import config
                ImportConfig();
                return;
            }
            else
            {
                DebugUtils.Log("No configuration found. Default values will be used.");
            }

            // Checking for new vehicles
            CompileVehiclesList();

            // Checking for conflicts
            DefaultOptions.CheckForConflicts();

            // Update existing vehicles
            new EnumerableActionThread(VehicleOptions.UpdateCapacityUnits);
            new EnumerableActionThread(VehicleOptions.UpdateBackEngines);

            DebugUtils.Log("Configuration initialized");
            LogVehicleListSteamID();
        }
Exemplo n.º 7
0
/// Import the configuration file
        public static void ImportVehicleDataConfig()
        {
            if (!File.Exists(m_VehicleSettingsFile))
            {
                Logging.Message("Vehicle Configuration file not found.");
                return;
            }

            config.Deserialize(m_VehicleSettingsFile);

            if (config.options == null)
            {
                Logging.Message("Vehicle Configuration empty. Default values will be used.");
            }
            else
            {
                // Remove unneeded options
                List <VehicleOptions> optionsList = new List <VehicleOptions>();

                for (uint i = 0; i < config.options.Length; i++)
                {
                    if (config.options[i] != null && config.options[i].prefab != null)
                    {
                        optionsList.Add(config.options[i]);
                    }
                }

                config.options = optionsList.ToArray();
            }

            // Checking for new vehicles
            CompileVehiclesList();

            // Checking for conflicts
            DefaultOptions.CheckForConflicts();

            // Update existing vehicles
            SimulationManager.instance.AddAction(VehicleOptions.UpdateCapacityUnits);
            SimulationManager.instance.AddAction(VehicleOptions.UpdateBackEngines);

            Logging.Message("Vehicle Configuration imported from Filename: " + m_VehicleSettingsFile);
            LogVehicleListSteamID();
        }
        /// <summary>
        /// Called when the level is unloaded
        /// </summary>
        public override void OnLevelUnloading()
        {
            try
            {
                DebugUtils.Log("Restoring default values");
                DefaultOptions.RestoreAll();
                DefaultOptions.Clear();

                if (instance != null)
                {
                    GameObject.Destroy(instance.gameObject);
                }

                AdvancedVehicleOptionsUID.isGameLoaded = false;
            }
            catch (Exception e)
            {
                DebugUtils.LogException(e);
            }
        }
        public override void OnLoadData()
        {
            if (ToolManager.instance.m_properties.m_mode != ItemClass.Availability.Game)
            {
                return;
            }

            // Storing default values ASAP (before any mods have the time to change values)
            DefaultOptions.StoreAll();

            if (!serializableDataManager.EnumerateData().Contains(ID))
            {
                return;
            }
            var data = serializableDataManager.LoadData(ID);

            using (var ms = new MemoryStream(data))
            {
                AdvancedVehicleOptionsUID.config.data = DataSerializer.Deserialize <Configuration>(ms, DataSerializer.Mode.Memory).data;
            }
        }
Exemplo n.º 10
0
        public static void Restore(VehicleInfo prefab)
        {
            if (prefab == null)
            {
                return;
            }

            VehicleOptions options = new VehicleOptions();

            options.SetPrefab(prefab);

            DefaultOptions stored = m_default[prefab.name];

            if (stored == null)
            {
                return;
            }

            options.enabled            = stored.m_enabled;
            options.addBackEngine      = stored.m_addBackEngine;
            options.maxSpeed           = stored.m_maxSpeed;
            options.acceleration       = stored.m_acceleration;
            options.braking            = stored.m_braking;
            options.turning            = stored.m_turning;
            options.springs            = stored.m_springs;
            options.dampers            = stored.m_dampers;
            options.leanMultiplier     = stored.m_leanMultiplier;
            options.nodMultiplier      = stored.m_nodMultiplier;
            options.useColorVariations = stored.m_useColorVariations;
            options.color0             = stored.m_color0;
            options.color1             = stored.m_color1;
            options.color2             = stored.m_color2;
            options.color3             = stored.m_color3;
            options.capacity           = stored.m_capacity;
            prefab.m_placementStyle    = stored.m_placementStyle;
        }
Exemplo n.º 11
0
/// <summary>
/// Init the Vehicle Data Configuration (not the Mod Configuration)A
/// </summary>
        public static void InitVehicleDataConfig()
        {
            // Store modded values
            DefaultOptions.StoreAllModded();

            if (config.data != null)
            {
                config.DataToOptions();

                // Remove unneeded options
                List <VehicleOptions> optionsList = new List <VehicleOptions>();

                for (uint i = 0; i < config.options.Length; i++)
                {
                    if (config.options[i] != null && config.options[i].prefab != null)
                    {
                        optionsList.Add(config.options[i]);
                    }
                }

                config.options = optionsList.ToArray();
            }
            else if (File.Exists(m_VehicleSettingsFile))
            {
                // Import config from Standard Filename
                ImportVehicleDataConfig();
                return;
            }
            else
            {
                // If Configuration has not been found, try to find the old config file
                if (File.Exists(m_OldConfigFileName))

                {
                    Logging.Message("Old vehicle configuration file found. Importing  old values and converting to Filename: " + Path.Combine(m_OldSettingsDir, m_OldConfigFileName));

                    m_VehicleSettingsFile = m_OldConfigFileName;

                    // Import config from Old Filename and export to the new filename
                    ImportVehicleDataConfig();

                    m_VehicleSettingsFile = Path.Combine(m_UserSettingsDir, m_VehicleConfigFileName);
                    config.Serialize(m_VehicleSettingsFile);

                    Logging.Message("Old vehicle configuration file converted to new file. New Filename: " + m_VehicleSettingsFile);

                    return;
                }

                else
                {
                    // No config file has been found at all...
                    Logging.Message("No vehicle configuration found. Default values will be used.");
                }
            }

            // Checking for new vehicles
            CompileVehiclesList();

            // Checking for conflicts
            DefaultOptions.CheckForConflicts();

            // Update existing vehicles
            SimulationManager.instance.AddAction(VehicleOptions.UpdateCapacityUnits);
            SimulationManager.instance.AddAction(VehicleOptions.UpdateBackEngines);

            Logging.Message("Vehicle Configuration initialized");
            LogVehicleListSteamID();
        }
Exemplo n.º 12
0
        public static void CheckForConflicts()
        {
            StringBuilder conflicts = new StringBuilder();

            foreach (string name in m_default.Keys)
            {
                VehicleOptions options = new VehicleOptions();
                options.SetPrefab(m_prefabs[name]);

                DefaultOptions modded = m_modded[name];
                DefaultOptions stored = m_default[name];

                StringBuilder details = new StringBuilder();

                if (modded.m_enabled != stored.m_enabled && options.enabled == stored.m_enabled)
                {
                    options.enabled = modded.m_enabled;
                    details.Append("enabled, ");
                }
                if (modded.m_addBackEngine != stored.m_addBackEngine && options.addBackEngine == stored.m_addBackEngine)
                {
                    options.addBackEngine = modded.m_addBackEngine;
                    details.Append("back engine, ");
                }
                if (modded.m_maxSpeed != stored.m_maxSpeed && options.maxSpeed == stored.m_maxSpeed)
                {
                    options.maxSpeed = modded.m_maxSpeed;
                    details.Append("max speed, ");
                }
                if (modded.m_acceleration != stored.m_acceleration && options.acceleration == stored.m_acceleration)
                {
                    options.acceleration = modded.m_acceleration;
                    details.Append("acceleration, ");
                }
                if (modded.m_braking != stored.m_braking && options.braking == stored.m_braking)
                {
                    options.braking = modded.m_braking;
                    details.Append("braking, ");
                }
                if (modded.m_turning != stored.m_turning && options.turning == stored.m_turning)
                {
                    options.turning = modded.m_turning;
                    details.Append("turning, ");
                }
                if (modded.m_springs != stored.m_springs && options.springs == stored.m_springs)
                {
                    options.springs = modded.m_springs;
                    details.Append("springs, ");
                }
                if (modded.m_dampers != stored.m_dampers && options.dampers == stored.m_dampers)
                {
                    options.dampers = modded.m_dampers;
                    details.Append("dampers, ");
                }
                if (modded.m_leanMultiplier != stored.m_leanMultiplier && options.leanMultiplier == stored.m_leanMultiplier)
                {
                    options.leanMultiplier = modded.m_leanMultiplier;
                    details.Append("leanMultiplier, ");
                }
                if (modded.m_nodMultiplier != stored.m_nodMultiplier && options.nodMultiplier == stored.m_nodMultiplier)
                {
                    options.nodMultiplier = modded.m_nodMultiplier;
                    details.Append("nodMultiplier, ");
                }
                if (modded.m_capacity != stored.m_capacity && options.capacity == stored.m_capacity)
                {
                    options.capacity = modded.m_capacity;
                    details.Append("capacity, ");
                }

                if (details.Length > 0)
                {
                    details.Length -= 2;
                    conflicts.AppendLine(options.name + ": " + details);
                }
            }

            if (conflicts.Length > 0)
            {
                VehicleOptions.UpdateTransfertVehicles();
                DebugUtils.Log("Conflicts detected (this message is harmless):" + Environment.NewLine + conflicts);
            }
        }