private void DoScheduledWork(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); schedule.WorkStatus = WorkStatus.Working; if (currentBuilding == schedule.WorkBuilding && schedule.CurrentState != ResidentState.AtSchoolOrWork) { CitizenProxy.SetVisitPlace(ref citizen, citizenId, 0); CitizenProxy.SetLocation(ref citizen, Citizen.Location.Work); return; } #if DEBUG string citizenDesc = GetCitizenDesc(citizenId, ref citizen); #else const string citizenDesc = null; #endif if (residentAI.StartMoving(instance, citizenId, ref citizen, currentBuilding, schedule.WorkBuilding)) { if (schedule.CurrentState != ResidentState.AtHome) { // The start moving method will register a departure from any building to work, // but we are only interested in the 'home->work' route. schedule.DepartureTime = default; } var citizenAge = CitizenProxy.GetAge(ref citizen); if (workBehavior.ScheduleLunch(ref schedule, citizenAge)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{citizenDesc} is going from {currentBuilding} to school/work {schedule.WorkBuilding} and will go to lunch at {schedule.ScheduledStateTime}"); } else { workBehavior.ScheduleReturnFromWork(ref schedule, citizenAge); Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{citizenDesc} is going from {currentBuilding} to school/work {schedule.WorkBuilding} and will leave work at {schedule.ScheduledStateTime}"); } } else { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted to go to work from {currentBuilding} but can't, will try once again next time"); schedule.Schedule(ResidentState.Unknown); } }
private bool ScheduleWork(ref CitizenSchedule schedule, ref TCitizen citizen) { ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); if (!workBehavior.ScheduleGoToWork(ref schedule, currentBuilding, simulationCycle)) { return(false); } Log.Debug($" - Schedule work at {schedule.ScheduledStateTime}"); float timeLeft = (float)(schedule.ScheduledStateTime - TimeInfo.Now).TotalHours; if (timeLeft <= PrepareToWorkHours) { // Just sit at home if the work time will come soon Log.Debug($" - Work time in {timeLeft} hours, preparing for departure"); return(true); } if (timeLeft <= MaxTravelTime) { if (schedule.CurrentState != ResidentState.AtHome) { Log.Debug($" - Work time in {timeLeft} hours, returning home"); schedule.Schedule(ResidentState.AtHome, default); return(true); } // If we have some time, try to shop locally. if (ScheduleShopping(ref schedule, ref citizen, true)) { Log.Debug($" - Work time in {timeLeft} hours, trying local shop"); } else { Log.Debug($" - Work time in {timeLeft} hours, doing nothing"); } return(true); } return(false); }
private bool ProcessCurrentState(ref CitizenSchedule schedule, ref TCitizen citizen) { switch (schedule.CurrentState) { case ResidentState.Shopping: return(ProcessCitizenShopping(ref schedule, ref citizen)); case ResidentState.Relaxing: return(ProcessCitizenRelaxing(ref schedule, ref citizen)); case ResidentState.Visiting: return(ProcessCitizenVisit(ref schedule, ref citizen)); case ResidentState.InShelter: return(ProcessCitizenInShelter(ref schedule, ref citizen)); } return(false); }
private void DoScheduledHome(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort homeBuilding = CitizenProxy.GetHomeBuilding(ref citizen); if (homeBuilding == 0) { Log.Debug($"WARNING: {GetCitizenDesc(citizenId, ref citizen)} is in corrupt state: want to go home with no home building. Releasing the poor citizen."); CitizenMgr.ReleaseCitizen(citizenId); schedule = default; return; } ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); CitizenProxy.RemoveFlags(ref citizen, Citizen.Flags.Evacuating); CitizenProxy.SetVisitPlace(ref citizen, citizenId, 0); residentAI.StartMoving(instance, citizenId, ref citizen, currentBuilding, homeBuilding); schedule.Schedule(ResidentState.Unknown, default); Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} is going from {currentBuilding} back home"); }
private bool RescheduleVisit(ref CitizenSchedule schedule, ref TCitizen citizen, ushort currentBuilding) { switch (schedule.ScheduledState) { case ResidentState.Shopping: case ResidentState.Relaxing: case ResidentState.Visiting: break; default: return(false); } if (IsBadWeather()) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(0, ref citizen)} quits a visit because of bad weather (see next line for citizen ID)"); schedule.Schedule(ResidentState.AtHome, default); return(true); } if (IsBuildingNoiseRestricted(currentBuilding, currentBuilding)) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(0, ref citizen)} quits a visit because of NIMBY policy (see next line for citizen ID)"); schedule.Schedule(ResidentState.Unknown, default); return(true); } uint stayChance = spareTimeBehavior.GetGoOutChance( CitizenProxy.GetAge(ref citizen), schedule.WorkShift, schedule.CurrentState == ResidentState.Shopping); if (!Random.ShouldOccur(stayChance)) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(0, ref citizen)} quits a visit because of time (see next line for citizen ID)"); schedule.Schedule(ResidentState.AtHome, default); return(true); } return(false); }
private bool RescheduleVisit(ref CitizenSchedule schedule, uint citizenId, ref TCitizen citizen, ushort currentBuilding) { switch (schedule.ScheduledState) { case ResidentState.Shopping: case ResidentState.Relaxing: case ResidentState.Visiting: break; default: return(false); } if (schedule.CurrentState != ResidentState.Shopping && WeatherInfo.IsBadWeather) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} quits a visit because of bad weather"); schedule.Schedule(ResidentState.AtHome); return(true); } if (buildingAI.IsNoiseRestricted(currentBuilding, currentBuilding)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} quits a visit because of NIMBY policy"); schedule.Schedule(ResidentState.Unknown); return(true); } Citizen.AgeGroup age = CitizenProxy.GetAge(ref citizen); uint stayChance = schedule.CurrentState == ResidentState.Shopping ? spareTimeBehavior.GetShoppingChance(age) : spareTimeBehavior.GetRelaxingChance(age, schedule.WorkShift, schedule.WorkStatus == WorkStatus.OnVacation); if (!Random.ShouldOccur(stayChance)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} quits a visit because of time"); schedule.Schedule(ResidentState.AtHome); return(true); } return(false); }
private void DoScheduledLunch(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); #if DEBUG string citizenDesc = GetCitizenDesc(citizenId, ref citizen); #else string citizenDesc = null; #endif ushort lunchPlace = MoveToCommercialBuilding(instance, citizenId, ref citizen, LocalSearchDistance); if (lunchPlace != 0) { Log.Debug(TimeInfo.Now, $"{citizenDesc} is going for lunch from {currentBuilding} to {lunchPlace}"); workBehavior.ScheduleReturnFromLunch(ref schedule); } else { Log.Debug(TimeInfo.Now, $"{citizenDesc} wanted to go for lunch from {currentBuilding}, but there were no buildings close enough"); workBehavior.ScheduleReturnFromWork(ref schedule, CitizenProxy.GetAge(ref citizen)); } }
private void DoScheduledShopping(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); if (schedule.Hint == ScheduleHint.LocalShoppingOnly) { schedule.Schedule(ResidentState.Unknown, default); ushort shop = MoveToCommercialBuilding(instance, citizenId, ref citizen, LocalSearchDistance); if (shop == 0) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted go shopping, but didn't find a local shop"); } else { if (TimeInfo.IsNightTime) { schedule.Hint = ScheduleHint.NoShoppingAnyMore; } Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} goes shopping at a local shop {shop}"); } } else { uint moreShoppingChance = spareTimeBehavior.GetShoppingChance(CitizenProxy.GetAge(ref citizen)); ResidentState nextState = schedule.Hint != ScheduleHint.NoShoppingAnyMore && Random.ShouldOccur(moreShoppingChance) ? ResidentState.Shopping : ResidentState.Unknown; schedule.Schedule(nextState, default); if (schedule.CurrentState != ResidentState.Shopping) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} in state {schedule.CurrentState} wanna go shopping and schedules {nextState}, heading to a random shop, hint = {schedule.Hint}"); residentAI.FindVisitPlace(instance, citizenId, currentBuilding, residentAI.GetShoppingReason(instance)); } } }
private void DoScheduledWork(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); schedule.WorkStatus = WorkStatus.Working; schedule.DepartureToWorkTime = default; if (currentBuilding == schedule.WorkBuilding && schedule.CurrentState != ResidentState.AtSchoolOrWork) { CitizenProxy.SetVisitPlace(ref citizen, citizenId, 0); CitizenProxy.SetLocation(ref citizen, Citizen.Location.Work); return; } if (residentAI.StartMoving(instance, citizenId, ref citizen, currentBuilding, schedule.WorkBuilding)) { if (schedule.CurrentState == ResidentState.AtHome) { schedule.DepartureToWorkTime = TimeInfo.Now; } Citizen.AgeGroup citizenAge = CitizenProxy.GetAge(ref citizen); if (workBehavior.ScheduleLunch(ref schedule, citizenAge)) { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} is going from {currentBuilding} to school/work {schedule.WorkBuilding} and will go to lunch at {schedule.ScheduledStateTime}"); } else { workBehavior.ScheduleReturnFromWork(ref schedule, citizenAge); Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} is going from {currentBuilding} to school/work {schedule.WorkBuilding} and will leave work at {schedule.ScheduledStateTime}"); } } else { Log.Debug(TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted to go to work from {currentBuilding} but can't, will try once again next time"); schedule.Schedule(ResidentState.Unknown, default); } }
private bool ScheduleShopping(ref CitizenSchedule schedule, ref TCitizen citizen, bool localOnly) { if (!CitizenProxy.HasFlags(ref citizen, Citizen.Flags.NeedGoods) || IsBadWeather()) { return(false); } if (!Random.ShouldOccur(spareTimeBehavior.GetGoOutChance(CitizenProxy.GetAge(ref citizen), schedule.WorkShift, true))) { return(false); } if (TimeInfo.IsNightTime || localOnly || Random.ShouldOccur(Config.LocalBuildingSearchQuota)) { schedule.Hint = ScheduleHint.LocalShoppingOnly; } else { schedule.Hint = ScheduleHint.None; } schedule.Schedule(ResidentState.Shopping, default); return(true); }
private bool ProcessCitizenVisit(ref CitizenSchedule schedule, uint citizenId, ref TCitizen citizen) { return(RescheduleVisit(ref schedule, citizenId, ref citizen, CitizenProxy.GetVisitBuilding(ref citizen))); }
private bool DoScheduledRelaxing(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { // Relaxing was already scheduled last time, but the citizen is still at school/work or in shelter. // This can occur when the game's transfer manager can't find any activity for the citizen. // In that case, move back home. if ((schedule.CurrentState == ResidentState.AtSchoolOrWork || schedule.CurrentState == ResidentState.InShelter) && schedule.LastScheduledState == ResidentState.Relaxing) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted relax but is still at work or in shelter. No relaxing activity found. Now going home."); return(false); } ushort buildingId = CitizenProxy.GetCurrentBuilding(ref citizen); switch (schedule.Hint) { case ScheduleHint.RelaxAtLeisureBuilding: schedule.Schedule(ResidentState.Unknown); ushort leisure = MoveToLeisureBuilding(instance, citizenId, ref citizen, buildingId); if (leisure == 0) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted relax but didn't find a leisure building"); return(false); } Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} heading to a leisure building {leisure}"); return(true); case ScheduleHint.AttendingEvent: ushort eventBuilding = schedule.EventBuilding; schedule.EventBuilding = 0; ICityEvent cityEvent = EventMgr.GetCityEvent(eventBuilding); if (cityEvent == null) { Log.Debug(LogCategory.Events, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanted attend an event at '{eventBuilding}', but there was no event there"); } else if (StartMovingToVisitBuilding(instance, citizenId, ref citizen, eventBuilding)) { schedule.Schedule(ResidentState.Unknown, cityEvent.EndTime); Log.Debug(LogCategory.Events, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} wanna attend an event at '{eventBuilding}', will return at {cityEvent.EndTime}"); return(true); } schedule.Schedule(ResidentState.Unknown); return(false); case ScheduleHint.RelaxNearbyOnly: Vector3 currentPosition = CitizenMgr.GetCitizenPosition(CitizenProxy.GetInstance(ref citizen)); ushort parkBuildingId = BuildingMgr.FindActiveBuilding(currentPosition, LocalSearchDistance, ItemClass.Service.Beautification); if (StartMovingToVisitBuilding(instance, citizenId, ref citizen, parkBuildingId)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} heading to a nearby entertainment building {parkBuildingId}"); schedule.Schedule(ResidentState.Unknown); return(true); } schedule.Schedule(ResidentState.Unknown); DoScheduledHome(ref schedule, instance, citizenId, ref citizen); return(true); } uint relaxChance = spareTimeBehavior.GetRelaxingChance( CitizenProxy.GetAge(ref citizen), schedule.WorkShift, schedule.WorkStatus == WorkStatus.OnVacation); relaxChance = AdjustRelaxChance(relaxChance, ref citizen); ResidentState nextState = Random.ShouldOccur(relaxChance) ? ResidentState.Relaxing : ResidentState.Unknown; schedule.Schedule(nextState); if (schedule.CurrentState != ResidentState.Relaxing || Random.ShouldOccur(FindAnotherShopOrEntertainmentChance)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} in state {schedule.CurrentState} wanna relax and then schedules {nextState}, heading to an entertainment building."); residentAI.FindVisitPlace(instance, citizenId, buildingId, residentAI.GetEntertainmentReason(instance)); } #if DEBUG else { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} continues relaxing in the same entertainment building."); } #endif return(true); }
private bool ProcessCitizenMoving(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen) { ushort instanceId = CitizenProxy.GetInstance(ref citizen); ushort vehicleId = CitizenProxy.GetVehicle(ref citizen); if (instanceId == 0) { if (vehicleId == 0) { if (CitizenProxy.GetVisitBuilding(ref citizen) != 0) { CitizenProxy.SetVisitPlace(ref citizen, citizenId, 0); } if (CitizenProxy.HasFlags(ref citizen, Citizen.Flags.MovingIn)) { CitizenMgr.ReleaseCitizen(citizenId); schedule = default; } else { CitizenProxy.SetLocation(ref citizen, Citizen.Location.Home); CitizenProxy.SetArrested(ref citizen, false); schedule.Schedule(ResidentState.Unknown); } } return(true); } if (vehicleId == 0 && !CitizenProxy.HasFlags(ref citizen, Citizen.Flags.Evacuating) && CitizenMgr.IsAreaEvacuating(instanceId)) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} was on the way, but the area evacuates. Finding an evacuation place."); schedule.Schedule(ResidentState.Unknown); schedule.DepartureTime = default; TransferMgr.AddOutgoingOfferFromCurrentPosition(citizenId, residentAI.GetEvacuationReason(instance, 0)); return(true); } ushort targetBuilding = CitizenMgr.GetTargetBuilding(instanceId); bool headingToWork = targetBuilding == CitizenProxy.GetWorkBuilding(ref citizen); if (vehicleId != 0 && schedule.DepartureTime != default) { float maxTravelTime = headingToWork ? abandonCarRideToWorkDurationThreshold : abandonCarRideDurationThreshold; if ((TimeInfo.Now - schedule.DepartureTime).TotalHours > maxTravelTime) { buildingAI.RegisterReachingTrouble(targetBuilding); if (targetBuilding == CitizenProxy.GetHomeBuilding(ref citizen)) { return(true); } Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} cancels the trip because of traffic jam"); schedule.Schedule(ResidentState.Relaxing); schedule.Hint = ScheduleHint.RelaxNearbyOnly; schedule.CurrentState = ResidentState.InTransition; return(false); } } if (headingToWork) { return(true); } ItemClass.Service targetService = BuildingMgr.GetBuildingService(targetBuilding); if (targetService == ItemClass.Service.Beautification && WeatherInfo.IsBadWeather) { Log.Debug(LogCategory.Movement, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} cancels the trip to a park due to bad weather"); schedule.Schedule(ResidentState.AtHome); schedule.CurrentState = ResidentState.InTransition; return(false); } return(true); }
private void ExecuteCitizenSchedule(ref CitizenSchedule schedule, TAI instance, uint citizenId, ref TCitizen citizen, bool noReschedule) { if (ProcessCurrentState(ref schedule, citizenId, ref citizen) && schedule.ScheduledState == ResidentState.Unknown && !noReschedule) { Log.Debug(LogCategory.Schedule, TimeInfo.Now, $"{GetCitizenDesc(citizenId, ref citizen)} will re-schedule now"); // If the state processing changed the schedule, we need to update it UpdateCitizenSchedule(ref schedule, citizenId, ref citizen); } if (TimeInfo.Now < schedule.ScheduledStateTime) { return; } if (schedule.CurrentState == ResidentState.AtHome && IsCitizenVirtual(instance, ref citizen, ShouldRealizeCitizen)) { Log.Debug(LogCategory.Simulation, $" *** Citizen {citizenId} is virtual this time"); schedule.Schedule(ResidentState.Unknown); return; } bool executed; switch (schedule.ScheduledState) { case ResidentState.AtHome: DoScheduledHome(ref schedule, instance, citizenId, ref citizen); executed = true; break; case ResidentState.AtSchoolOrWork: DoScheduledWork(ref schedule, instance, citizenId, ref citizen); executed = true; break; case ResidentState.Shopping when schedule.WorkStatus == WorkStatus.Working: DoScheduledLunch(ref schedule, instance, citizenId, ref citizen); executed = true; break; case ResidentState.Shopping: executed = DoScheduledShopping(ref schedule, instance, citizenId, ref citizen); break; case ResidentState.Relaxing: executed = DoScheduledRelaxing(ref schedule, instance, citizenId, ref citizen); break; case ResidentState.InShelter: DoScheduledEvacuation(ref schedule, instance, citizenId, ref citizen); executed = true; break; default: return; } if (!executed && (schedule.CurrentState == ResidentState.AtSchoolOrWork || schedule.CurrentState == ResidentState.InShelter)) { schedule.Schedule(ResidentState.Unknown); DoScheduledHome(ref schedule, instance, citizenId, ref citizen); } }
private bool UpdateCitizenSchedule(ref CitizenSchedule schedule, uint citizenId, ref TCitizen citizen) { // If the game changed the work building, we have to update the work shifts first ushort workBuilding = CitizenProxy.GetWorkBuilding(ref citizen); if (schedule.WorkBuilding != workBuilding || (workBuilding == 0 && schedule.WorkShift != WorkShift.Unemployed)) { schedule.WorkBuilding = workBuilding; workBehavior.UpdateWorkShift(ref schedule, CitizenProxy.GetAge(ref citizen)); if (schedule.CurrentState == ResidentState.AtSchoolOrWork && schedule.ScheduledStateTime == default) { // When enabling for an existing game, the citizens that are working have no schedule yet schedule.Schedule(ResidentState.Unknown, TimeInfo.Now.FutureHour(schedule.WorkShiftEndHour)); } else if (schedule.WorkBuilding == 0 && (schedule.ScheduledState == ResidentState.AtSchoolOrWork || schedule.WorkStatus == WorkStatus.Working)) { // This is for the case when the citizen becomes unemployed while at work schedule.Schedule(ResidentState.Unknown); } Log.Debug(LogCategory.Schedule, $"Updated work shifts for citizen {citizenId}: work shift {schedule.WorkShift}, {schedule.WorkShiftStartHour} - {schedule.WorkShiftEndHour}, weekends: {schedule.WorksOnWeekends}"); } if (schedule.ScheduledState != ResidentState.Unknown) { return(false); } Log.Debug(LogCategory.Schedule, TimeInfo.Now, $"Scheduling for {GetCitizenDesc(citizenId, ref citizen)}..."); if (schedule.WorkStatus == WorkStatus.Working) { schedule.WorkStatus = WorkStatus.None; } DateTime nextActivityTime = todayWakeUp; if (schedule.CurrentState != ResidentState.AtSchoolOrWork && workBuilding != 0 && schedule.WorkStatus != WorkStatus.OnVacation) { if (ScheduleWork(ref schedule, ref citizen)) { return(true); } if (schedule.ScheduledStateTime > nextActivityTime) { nextActivityTime = schedule.ScheduledStateTime; } } if (ScheduleShopping(ref schedule, ref citizen, false)) { Log.Debug(LogCategory.Schedule, $" - Schedule shopping"); return(true); } if (ScheduleRelaxing(ref schedule, citizenId, ref citizen)) { Log.Debug(LogCategory.Schedule, $" - Schedule relaxing"); return(true); } if (schedule.CurrentState == ResidentState.AtHome) { if (Random.ShouldOccur(StayHomeAllDayChance)) { if (nextActivityTime < TimeInfo.Now) { nextActivityTime = todayWakeUp.FutureHour(Config.WakeUpHour); } } else { nextActivityTime = default; } #if DEBUG if (nextActivityTime <= TimeInfo.Now) { Log.Debug(LogCategory.Schedule, $" - Schedule idle until next scheduling run"); } else { Log.Debug(LogCategory.Schedule, $" - Schedule idle until {nextActivityTime}"); } #endif schedule.Schedule(ResidentState.Unknown, nextActivityTime); } else { Log.Debug(LogCategory.Schedule, $" - Schedule moving home"); schedule.Schedule(ResidentState.AtHome); } return(true); }
private ScheduleAction UpdateCitizenState(ref TCitizen citizen, ref CitizenSchedule schedule) { if (schedule.CurrentState == ResidentState.Ignored) { return(ScheduleAction.Ignore); } if (CitizenProxy.HasFlags(ref citizen, Citizen.Flags.DummyTraffic)) { schedule.CurrentState = ResidentState.Ignored; return(ScheduleAction.Ignore); } Citizen.Location location = CitizenProxy.GetLocation(ref citizen); if (location == Citizen.Location.Moving) { if (CitizenMgr.InstanceHasFlags( CitizenProxy.GetInstance(ref citizen), CitizenInstance.Flags.OnTour | CitizenInstance.Flags.TargetIsNode, true)) { // Guided tours are treated as visits schedule.CurrentState = ResidentState.Visiting; schedule.Hint = ScheduleHint.OnTour; return(ScheduleAction.ProcessState); } return(ScheduleAction.ProcessTransition); } ushort currentBuilding = CitizenProxy.GetCurrentBuilding(ref citizen); if (currentBuilding == 0) { schedule.CurrentState = ResidentState.Unknown; return(ScheduleAction.ProcessState); } ItemClass.Service buildingService = BuildingMgr.GetBuildingService(currentBuilding); if (BuildingMgr.BuildingHasFlags(currentBuilding, Building.Flags.Evacuating) && buildingService != ItemClass.Service.Disaster) { schedule.CurrentState = ResidentState.Evacuation; schedule.Schedule(ResidentState.InShelter); return(ScheduleAction.ProcessState); } switch (location) { case Citizen.Location.Home: schedule.CurrentState = ResidentState.AtHome; return(ScheduleAction.ProcessState); case Citizen.Location.Work: if (buildingService == ItemClass.Service.Disaster && CitizenProxy.HasFlags(ref citizen, Citizen.Flags.Evacuating)) { schedule.CurrentState = ResidentState.InShelter; return(ScheduleAction.ProcessState); } if (CitizenProxy.GetVisitBuilding(ref citizen) == currentBuilding && schedule.WorkStatus != WorkStatus.Working) { // A citizen may visit their own work building (e.g. shopping), // but the game sets the location to 'work' even if the citizen visits the building. goto case Citizen.Location.Visit; } schedule.CurrentState = ResidentState.AtSchoolOrWork; return(ScheduleAction.ProcessState); case Citizen.Location.Visit: switch (buildingService) { case ItemClass.Service.Beautification: case ItemClass.Service.Monument: case ItemClass.Service.Tourism: case ItemClass.Service.Commercial when BuildingMgr.GetBuildingSubService(currentBuilding) == ItemClass.SubService.CommercialLeisure && schedule.WorkStatus != WorkStatus.Working: schedule.CurrentState = ResidentState.Relaxing; return(ScheduleAction.ProcessState); case ItemClass.Service.Commercial: schedule.CurrentState = ResidentState.Shopping; return(ScheduleAction.ProcessState); case ItemClass.Service.Disaster when CitizenProxy.HasFlags(ref citizen, Citizen.Flags.Evacuating): schedule.CurrentState = ResidentState.InShelter; return(ScheduleAction.ProcessState); } schedule.CurrentState = ResidentState.Visiting; return(ScheduleAction.ProcessState); } return(ScheduleAction.Ignore); }
/// <summary>Updates the citizen's work shift parameters in the specified citizen's <paramref name="schedule"/>.</summary> /// <param name="schedule">The citizen's schedule to update the work shift in.</param> /// <param name="citizenAge">The age of the citizen.</param> public void UpdateWorkShift(ref CitizenSchedule schedule, Citizen.AgeGroup citizenAge) { if (schedule.WorkBuilding == 0 || citizenAge == Citizen.AgeGroup.Senior) { schedule.UpdateWorkShift(WorkShift.Unemployed, 0, 0, worksOnWeekends: false); return; } ItemClass.Service service = buildingManager.GetBuildingService(schedule.WorkBuilding); ItemClass.SubService subService = buildingManager.GetBuildingSubService(schedule.WorkBuilding); float workBegin, workEnd; WorkShift workShift = schedule.WorkShift; switch (citizenAge) { case Citizen.AgeGroup.Child: case Citizen.AgeGroup.Teen: workShift = WorkShift.First; workBegin = config.SchoolBegin; workEnd = config.SchoolEnd; break; case Citizen.AgeGroup.Young: case Citizen.AgeGroup.Adult: if (workShift == WorkShift.Unemployed) { workShift = GetWorkShift(GetBuildingWorkShiftCount(service, subService)); } workBegin = config.WorkBegin; workEnd = config.WorkEnd; break; default: return; } switch (workShift) { case WorkShift.First when HasExtendedFirstWorkShift(service, subService): float extendedShiftBegin = service == ItemClass.Service.Education ? Math.Min(config.SchoolBegin, config.WakeUpHour) : config.WakeUpHour; workBegin = Math.Min(EarliestWakeUp, extendedShiftBegin); break; case WorkShift.Second: workBegin = workEnd; workEnd = 0; break; case WorkShift.Night: workEnd = workBegin; workBegin = 0; break; } schedule.UpdateWorkShift(workShift, workBegin, workEnd, IsBuildingActiveOnWeekend(service, subService)); }