Exemple #1
0
        internal void OnDespawn()
        {
#if DEBUG
            if (GlobalConfig.Instance.Debug.Switches[9])
            {
                Log._Debug($"VehicleState.OnDespawn({vehicleId} called: {this}");
            }
#endif
            if ((flags & Flags.Spawned) == Flags.None)
            {
#if DEBUG
                if (GlobalConfig.Instance.Debug.Switches[9])
                {
                    Log._Debug($"VehicleState.OnDespawn({vehicleId}): Vehicle is not spawned.");
                }
#endif
                return;
            }

            Constants.ManagerFactory.ExtCitizenInstanceManager.ResetInstance(CustomPassengerCarAI.GetDriverInstanceId(vehicleId, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId]));

            Unlink();

            currentSegmentId        = 0;
            currentStartNode        = false;
            currentLaneIndex        = 0;
            lastAltLaneSelSegmentId = 0;
            recklessDriver          = false;

            nextSegmentId = 0;
            nextLaneIndex = 0;

            totalLength = 0;
            //velocity = 0;
            //sqrVelocity = 0;

            flags &= ~Flags.Spawned;

#if DEBUG
            if (GlobalConfig.Instance.Debug.Switches[9])
            {
                Log._Debug($"VehicleState.OnDespawn({vehicleId}) finished: {this}");
            }
#endif
        }
Exemple #2
0
        public override void OnLevelLoaded(LoadMode mode)
        {
            base.OnLevelLoaded(mode);
            if (mode == LoadMode.LoadGame || mode == LoadMode.NewGame)
            {
                ReplacePathManager();
                CustomCarAI.RedirectCalls(m_redirectionStates);
                CustomPassengerCarAI.RedirectCalls(m_redirectionStates);
                CustomCargoTruckAI.RedirectCalls(m_redirectionStates);

                if (Instance == null)
                {
                    Instance = this;
                }

                UI = ToolsModifierControl.toolController.gameObject.AddComponent <UIBase>();
                TrafficPriority.leftHandDrive = Singleton <SimulationManager> .instance.m_metaData.m_invertTraffic == SimulationMetaData.MetaBool.True;
                RoadCustomizerTool            = AddTool <CSL_Traffic.RoadCustomizerTool>(ToolsModifierControl.toolController);
                ToolsModifierControl.SetTool <DefaultTool>();
            }
        }
Exemple #3
0
        public ExtCitizenInstance GetDriverExtInstance()
        {
            /*if (DriverInstanceId == 0) {
             *      DriverInstanceId = CustomPassengerCarAI.GetDriverInstance(VehicleId, ref Singleton<VehicleManager>.instance.m_vehicles.m_buffer[VehicleId]);
             * }
             #if DEBUG
             * else {
             *      ushort liveDriverInstId = CustomPassengerCarAI.GetDriverInstance(VehicleId, ref Singleton<VehicleManager>.instance.m_vehicles.m_buffer[VehicleId]);
             *      if (liveDriverInstId != DriverInstanceId) {
             *              Log.Error($"Driver citizen instance mismatch for vehicle {VehicleId}: True driver: {liveDriverInstId} Stored driver: {DriverInstanceId}");
             *              DriverInstanceId = liveDriverInstId;
             *      }
             * }
             #endif
             */

            ushort driverInstanceId = CustomPassengerCarAI.GetDriverInstance(VehicleId, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[VehicleId]);

            if (driverInstanceId != 0)
            {
                return(ExtCitizenInstanceManager.Instance.GetExtInstance(driverInstanceId));
            }
            return(null);
        }
Exemple #4
0
        public void ResetStuckEntities()
        {
            Log.Info($"UtilityManager.RemoveStuckEntities() called.");

            bool wasPaused = Singleton <SimulationManager> .instance.ForcedSimulationPaused;

            if (!wasPaused)
            {
                Log.Info($"UtilityManager.RemoveStuckEntities(): Pausing simulation.");
                Singleton <SimulationManager> .instance.ForcedSimulationPaused = true;
            }

            Log.Info($"UtilityManager.RemoveStuckEntities(): Waiting for all paths.");
            Singleton <PathManager> .instance.WaitForAllPaths();

            Log.Info($"UtilityManager.RemoveStuckEntities(): Resetting citizen instances that are waiting for a path.");
            for (uint citizenInstanceId = 1; citizenInstanceId < CitizenManager.MAX_INSTANCE_COUNT; ++citizenInstanceId)
            {
                //Log._Debug($"UtilityManager.RemoveStuckEntities(): Processing instance {citizenInstanceId}.");
                if ((Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_flags & CitizenInstance.Flags.WaitingPath) != CitizenInstance.Flags.None)
                {
                    CitizenAI ai = Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].Info.m_citizenAI;

                    if (Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_path != 0u)
                    {
                        Log.Info($"Resetting stuck citizen instance {citizenInstanceId} (waiting for path)");

                        Singleton <PathManager> .instance.ReleasePath(Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_path);

                        Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_path = 0u;
                    }
                    Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_flags &= ~(CitizenInstance.Flags.WaitingTransport | CitizenInstance.Flags.EnteringVehicle | CitizenInstance.Flags.BoredOfWaiting | CitizenInstance.Flags.WaitingTaxi | CitizenInstance.Flags.WaitingPath);
                }
                else
                {
#if DEBUG
                    if (Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_path == 0 &&
                        (Singleton <CitizenManager> .instance.m_instances.m_buffer[citizenInstanceId].m_flags & CitizenInstance.Flags.Character) != CitizenInstance.Flags.None)
                    {
                        Log._Debug($"Found potential floating citizen instance: {citizenInstanceId} Source building: {Singleton<CitizenManager>.instance.m_instances.m_buffer[citizenInstanceId].m_sourceBuilding} Target building: {Singleton<CitizenManager>.instance.m_instances.m_buffer[citizenInstanceId].m_targetBuilding} Distance to target position: {(Singleton<CitizenManager>.instance.m_instances.m_buffer[citizenInstanceId].GetLastFramePosition() - (Vector3)Singleton<CitizenManager>.instance.m_instances.m_buffer[citizenInstanceId].m_targetPos).magnitude}");
                    }
#endif
                }
            }

            Log.Info($"UtilityManager.RemoveStuckEntities(): Resetting vehicles that are waiting for a path.");
            for (uint vehicleId = 1; vehicleId < VehicleManager.MAX_VEHICLE_COUNT; ++vehicleId)
            {
                //Log._Debug($"UtilityManager.RemoveStuckEntities(): Processing vehicle {vehicleId}.");
                if ((Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_flags & Vehicle.Flags.WaitingPath) != 0)
                {
                    if (Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_path != 0u)
                    {
                        Log.Info($"Resetting stuck vehicle {vehicleId} (waiting for path)");

                        Singleton <PathManager> .instance.ReleasePath(Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_path);

                        Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_path = 0u;
                    }
                    Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_flags &= ~Vehicle.Flags.WaitingPath;
                }
            }

            Log.Info($"UtilityManager.RemoveStuckEntities(): Resetting vehicles that are parking and where no parked vehicle is assigned to the driver.");
            for (uint vehicleId = 1; vehicleId < VehicleManager.MAX_VEHICLE_COUNT; ++vehicleId)
            {
                //Log._Debug($"UtilityManager.RemoveStuckEntities(): Processing vehicle {vehicleId}.");
                if ((Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_flags & Vehicle.Flags.Parking) != 0)
                {
                    ushort driverInstanceId = CustomPassengerCarAI.GetDriverInstanceId((ushort)vehicleId, ref Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId]);
                    uint   citizenId        = Singleton <CitizenManager> .instance.m_instances.m_buffer[(int)driverInstanceId].m_citizen;
                    if (citizenId != 0u && Singleton <CitizenManager> .instance.m_citizens.m_buffer[citizenId].m_parkedVehicle == 0)
                    {
                        Log.Info($"Resetting vehicle {vehicleId} (parking without parked vehicle)");
                        Singleton <VehicleManager> .instance.m_vehicles.m_buffer[vehicleId].m_flags &= ~Vehicle.Flags.Parking;
                    }
                }
            }

            if (!wasPaused)
            {
                Log.Info($"UtilityManager.RemoveStuckEntities(): Unpausing simulation.");
                Singleton <SimulationManager> .instance.ForcedSimulationPaused = false;
            }
        }