示例#1
0
        public static void Init()
        {
            if (!TryLoadData(out _lineData))
            {
                Utils.Log((object)"Loading default transport line data.");
                NetManager       instance1 = Singleton <NetManager> .instance;
                TransportManager instance2 = Singleton <TransportManager> .instance;
                int length = instance2.m_lines.m_buffer.Length;
                for (ushort index = 0; index < length; ++index)
                {
                    if (instance2.m_lines.m_buffer[index].Complete)
                    {
                        _lineData[index].TargetVehicleCount = TransportLineUtil.CountLineActiveVehicles(index, out int _);
                    }
                    else
                    {
                        _lineData[index].TargetVehicleCount =
                            OptionsWrapper <Settings> .Options.DefaultVehicleCount;
                    }
                    _lineData[index].BudgetControl = OptionsWrapper <Settings> .Options.BudgetControl;
                    _lineData[index].Depot         = DepotUtil.GetClosestDepot((ushort)index,
                                                                               instance1.m_nodes.m_buffer[(int)instance2.m_lines.m_buffer[index].GetStop(0)].m_position);
                    _lineData[index].Unbunching = OptionsWrapper <Settings> .Options.Unbunching;
                }
            }
            SerializableDataExtension.instance.EventSaveData +=
                new SerializableDataExtension.SaveDataEventHandler(OnSaveData);

            _init = true;
        }
示例#2
0
        public static void Postfix(ushort __state)
        {
            var lineID = __state;

            if (!CachedTransportLineData._init || (SimulationManager.instance.m_currentFrameIndex & 4095U) >= 3840U ||
                !TransportManager.instance.m_lines.m_buffer[lineID].Complete)
            {
                return;
            }

            var stops1 = TransportManager.instance.m_lines.m_buffer[lineID].m_stops;
            var stop1  = stops1;

            do
            {
                CachedNodeData.m_cachedNodeData[stop1].StartNewWeek();
                stop1 = TransportLine.GetNextStop(stop1);
            } while (stops1 != stop1 && stop1 != 0);

            var itemClass = TransportManager.instance.m_lines.m_buffer[lineID].Info.m_class;
            var prefabs   =
                VehiclePrefabs.instance.GetPrefabs(itemClass.m_service, itemClass.m_subService, itemClass.m_level);
            var amount = 0;

            TransportLineUtil.CountLineActiveVehicles(lineID, out _, (num3) =>
            {
                var prefabData = Array.Find(prefabs,
                                            item => item.PrefabDataIndex ==
                                            VehicleManager.instance.m_vehicles.m_buffer[num3].Info.m_prefabDataIndex);
                if (prefabData == null)
                {
                    return;
                }
                amount += prefabData.MaintenanceCost;
                CachedVehicleData.m_cachedVehicleData[num3].StartNewWeek(prefabData.MaintenanceCost);
            });
            if (amount != 0)
            {
                Singleton <EconomyManager> .instance.FetchResource(EconomyManager.Resource.Maintenance, amount,
                                                                   TransportManager.instance.m_lines.m_buffer[lineID].Info.m_class);
            }
        }
示例#3
0
        public static int CalculateTargetVehicleCount(ushort lineID)
        {
            var instance = TransportManager.instance;
            int targetVehicleCount;

            if (CachedTransportLineData._lineData[lineID].BudgetControl ||
                instance.m_lines.m_buffer[lineID].Info.m_class.m_service == ItemClass.Service.Disaster)
            {
                targetVehicleCount = instance.m_lines.m_buffer[lineID].CalculateTargetVehicleCount();
                CachedTransportLineData.SetTargetVehicleCount(lineID, targetVehicleCount);
            }
            else
            {
                targetVehicleCount = CachedTransportLineData.GetTargetVehicleCount(lineID);
            }

            var activeVehicles = TransportLineUtil.CountLineActiveVehicles(lineID, out _);

            for (var i = activeVehicles; i < targetVehicleCount - CachedTransportLineData.EnqueuedVehiclesCount(lineID); i++)
            {
                CachedTransportLineData.EnqueueVehicle(lineID, CachedTransportLineData.GetRandomPrefab(lineID));
            }
            return(targetVehicleCount);
        }