public int CompareTo(object o)
        {
            if (o == null)
            {
                return(1);
            }

            VehicleOptions options = (VehicleOptions)o;

            int delta = category - options.category;

            if (delta == 0)
            {
                if (steamID != null && options.steamID == null)
                {
                    delta = 1;
                }
                else if (steamID == null && options.steamID != null)
                {
                    delta = -1;
                }
            }
            if (delta == 0)
            {
                return(localizedName.CompareTo(options.localizedName));
            }

            return(delta);
        }
示例#2
0
        public static void ClearVehicles(VehicleOptions options, bool parked)
        {
            if (parked)
            {
                if (options == null)
                {
                    new EnumerableActionThread(ActionRemoveParkedAll);
                    return;
                }

                m_removeParkedInfo = options.prefab;
                new EnumerableActionThread(ActionRemoveParked);
            }
            else
            {
                if (options == null)
                {
                    new EnumerableActionThread(ActionRemoveExistingAll);
                    return;
                }

                m_removeInfo = options.prefab;
                new EnumerableActionThread(ActionRemoveExisting);
            }
        }
        private DefaultOptions(VehicleInfo prefab)
        {
            VehicleOptions options = new VehicleOptions();

            options.SetPrefab(prefab);

            m_enabled            = options.enabled;
            m_addBackEngine      = options.addBackEngine;
            m_maxSpeed           = options.maxSpeed;
            m_acceleration       = options.acceleration;
            m_braking            = options.braking;
            m_useColorVariations = options.useColorVariations;
            m_color0             = options.color0;
            m_color1             = options.color1;
            m_color2             = options.color2;
            m_color3             = options.color3;
            m_capacity           = options.capacity;
            m_placementStyle     = options.placementStyle;

            if (prefab.m_trailers != null && prefab.m_trailers.Length > 0)
            {
                m_lastTrailer = prefab.m_trailers[prefab.m_trailers.Length - 1].m_info;
                m_probability = prefab.m_trailers[prefab.m_trailers.Length - 1].m_invertProbability;
            }
        }
        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.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;
        }
        public void DataToOptions()
        {
            if (data == null)
            {
                return;
            }

            options = new VehicleOptions[data.Length];

            for (int i = 0; i < data.Length; i++)
            {
                if (data[i].name == null)
                {
                    continue;
                }

                options[i]                    = new VehicleOptions();
                options[i].name               = data[i].name;
                options[i].enabled            = data[i].enabled;
                options[i].addBackEngine      = data[i].addBackEngine;
                options[i].maxSpeed           = data[i].maxSpeed;
                options[i].acceleration       = data[i].acceleration;
                options[i].braking            = data[i].braking;
                options[i].useColorVariations = data[i].useColorVariations;
                options[i].color0             = data[i].color0;
                options[i].color1             = data[i].color1;
                options[i].color2             = data[i].color2;
                options[i].color3             = data[i].color3;
                options[i].capacity           = data[i].capacity;
            }

            VehicleOptions.UpdateTransfertVehicles();
        }
 public static void RestoreAll()
 {
     foreach (string name in m_default.Keys)
     {
         Restore(m_prefabs[name]);
     }
     VehicleOptions.UpdateTransfertVehicles();
 }
        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_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);
            }
        }
示例#8
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)
                {
                    DefaultOptions.Clear();
                    return;
                }

                AdvancedVehicleOptions.isGameLoaded = true;

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

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

                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);
            }
        }
示例#9
0
        /// <summary>
        /// Check if there are new vehicles and add them to the options list
        /// </summary>
        private static void CompileVehiclesList()
        {
            List <VehicleOptions> optionsList = new List <VehicleOptions>();

            if (config.options != null)
            {
                optionsList.AddRange(config.options);
            }

            for (uint i = 0; i < PrefabCollection <VehicleInfo> .PrefabCount(); i++)
            {
                VehicleInfo prefab = PrefabCollection <VehicleInfo> .GetPrefab(i);

                if (prefab == null || ContainsPrefab(prefab))
                {
                    continue;
                }

                // New vehicle
                VehicleOptions options = new VehicleOptions();
                options.SetPrefab(prefab);

                optionsList.Add(options);
            }

            if (config.options != null)
            {
                DebugUtils.Log("Found " + (optionsList.Count - config.options.Length) + " new vehicle(s)");
            }
            else
            {
                DebugUtils.Log("Found " + optionsList.Count + " new vehicle(s)");
            }

            config.options = optionsList.ToArray();
        }