public void gettasks() { roottask = null; task = null; if (roottask == null) { roottask = new RootTask(); } itemData = JsonMapper.ToObject(tasksData.text); int n = itemData["tasks"].Count; for (int i = 0; i < n; i++) { task = new Task(); task.id = int.Parse(itemData["tasks"][i]["id"].ToString()); task.tasktitle = itemData["tasks"][i]["tasktitle"].ToString(); task.creationdate = itemData["tasks"][i]["creationdate"].ToString(); task.idCategory = int.Parse(itemData["tasks"][i]["idCategory"].ToString()); task.idTicket = int.Parse(itemData["tasks"][i]["idTicket"].ToString()); task.category = itemData["tasks"][i]["category"].ToString(); task.tickettitle = itemData["tasks"][i]["tickettitle"].ToString(); task.taskOwner = taskOwnerManager.callreadTaskOwner(int.Parse(itemData["tasks"][i]["id"].ToString())); roottask.tasks.Add(task); } }
//this is also called when train is stopped in the station and then started internal void OnDestinationReached(VehicleStationLocation station, RootTask task) { if (Vehicle.Schedule.TraverseOrder == VehicleScheduleTraverseOrder.BackAndForth) { _measurement = null; return; } if (_measurement is TravelMeasurement measurement) { if (task.Behavior == RootTaskBehavior.NonStop) { return; } measurement.Finish(task); } if (!_measurementInvalidated) { _measurement = new StationLoadingMeasurement(this, task); } else { _measurementInvalidated = false; } }
/** marks task data for overwrite with next new data (all old data will be discarded when new data are added) */ public void MarkForOverwrite(RootTask task) { if (_data.TryGetValue(task, out DurationDataSet dataSet)) { dataSet.MarkForOverwrite(); } }
public virtual void Clear(RootTask task) { if (_data.TryGetValue(task, out DurationDataSet dataSet)) { dataSet.Clear(); } }
internal void OnScheduleChanged(RootTask task, bool minorChange) { Snapshot newSnapshot = new Snapshot(Vehicle.Schedule); SnapshotComparsion comparsion = _lastSnapshot.CompareWithNewer(newSnapshot); bool isChanged = comparsion.IsDifference || _lastSnapshot.Count != newSnapshot.Count; if (isChanged) { if (_durationPerStation == null) { _durationPerStation = new DurationsPerStationsContainer(this); } else { _durationPerStation.NewTimes(this); } Manager <VehicleScheduleDataManager> .Current.InvalidateDurationPerStation(); } if (comparsion.IsDifference) //in comparsion there aren't any new tasks, it is only difference in old tasks { var invalidateMeasurement = false; foreach (var removedTask in comparsion.removed) { _travelData.Remove(removedTask); _stationLoadingData.Remove(removedTask); if (_measurement != null && _measurement.Task == removedTask) { invalidateMeasurement = true; } } foreach (var changedTask in comparsion.changed) { _stationLoadingData.MarkForOverwrite(changedTask); if (_measurement is StationLoadingMeasurement measurement && measurement.Task == changedTask) { invalidateMeasurement = true; } } foreach (var travelChangedTask in comparsion.incomingRouteChange) { _travelData.Clear(travelChangedTask); if (_measurement is TravelMeasurement) { invalidateMeasurement = true; } } if (invalidateMeasurement) { OnMeasurementInvalidated(); } } _lastSnapshot = newSnapshot; if (isChanged) { FillUnknownTimes(); } _capacity?.MarkDirty(); OnDataChanged(task, false); //do not notify route - when schedule is changed, OnScheduleChanged event will be called for each vehicle in the route }
public TaskSnapshot(RootTask task, int index) { this.task = task; location = task.Destination.VehicleStationLocation; version = VehicleScheduleHelper.Current.GetRootTaskVersion(task); nonstop = task.Behavior == RootTaskBehavior.NonStop; this.index = index; }
public void UnsubscribeTaskDataChanged(RootTask task, Action <VehicleScheduleData, RootTask> handler) { if (_taskDataChanged.TryGetValue(task, out Action <VehicleScheduleData, RootTask> akce)) { akce -= handler; _taskDataChanged[task] = akce; } }
public void Add(RootTask task, TimeSpan duration, float?distance) { base.Add(task, duration); if (distance != null) { _distanceData[task] = distance.Value; } }
internal static Measurement Read(StateBinaryReader reader, VehicleSchedule schedule, VehicleScheduleData data) { RootTask task = schedule.GetTasks()[reader.ReadInt()]; Measurement result = MeasurementSurrogate.Read(reader, data, task); result.DoRead(reader, schedule, data); return(result); }
public LispParser.Node BuildParseTree() { LispParser.MethodNode node = new LispParser.MethodNode("BehaviourTree"); node.Add("Name", Name, true); node.Add("RunningTaskHysterisis", RunningTaskHysterisis); node.Add(RootTask.BuildParseTree()); return(node); }
protected DurationDataSet GetOrCreateDataSetForTask(RootTask task) { if (!_data.ContainsKey(task)) { _data.Add(task, new DurationDataSet(_bufferSize)); } return(_data[task]); }
static private void RootTask_MoveSubTask_pof(RootTask __instance) { Vehicle vehicle = __instance.Vehicle; if (vehicle) { Current.OnScheduleChanged(vehicle, __instance); } }
static private void VehicleSchedule_AddTask_pof(VehicleSchedule __instance, RootTask task) { Vehicle vehicle = __instance.Vehicle; if (vehicle) { Current.OnScheduleChanged(vehicle, task); } }
public int GetRootTaskVersion(RootTask rootTask) { if (getRootTaskVersionFunc == null) { MethodInfo minf = typeof(RootTask).GetMethod("GetVersion", BindingFlags.NonPublic | BindingFlags.Instance); getRootTaskVersionFunc = (Func <RootTask, int>)Delegate.CreateDelegate(typeof(Func <RootTask, int>), minf); } return(getRootTaskVersionFunc(rootTask)); }
public IReadOnlyDictionary <Item, TransferData> GetTransfers(RootTask task) { Invalidate(); if (_transfers.TryGetValue(task, out TaskTransfers transfer)) { return(transfer.Transfers); } return(null); }
static private void RootTask_SkipSubTask_pof(RootTask __instance) { Vehicle vehicle = __instance.Vehicle; if (vehicle) { Current.OnMeasurementInvalidated(vehicle); } }
static private void RootTask_SetDestinationAndNotifyRoute_pof(RootTask __instance, VehicleDestination destination, VehicleDestination __state) { Vehicle vehicle = __instance.Vehicle; if (vehicle) { bool minor = (__state != null && __state.VehicleStationLocation.VehicleStation == destination.VehicleStationLocation.VehicleStation); Current.OnScheduleChanged(vehicle, __instance, minor, true); } }
protected virtual void DoRead(StateBinaryReader reader, VehicleSchedule schedule) { int count = reader.ReadInt(); for (int i = 0; i < count; i++) { int taskIndex = reader.ReadInt(); RootTask task = schedule.GetTasks()[taskIndex]; _data.Add(task, DurationDataSet.Read(reader)); } }
protected ProgressBar(string description, bool cancelable, bool silent) { if (silent) { Parent = new SilentRootTask(); } else { Parent = new RootTask(description, cancelable); } }
public Snapshot(VehicleSchedule schedule) { ImmutableList <RootTask> tasks = schedule.GetTasks(); int count = tasks.Count; for (int i = 0; i < count; i++) { RootTask task = tasks[i]; _taskSnapshots.Add(new TaskSnapshot(task, i)); } }
/* handler will be called only when own schedule data is changed, not data of another vehicles in the same route */ public void SubscribeTaskDataChanged(RootTask task, Action <VehicleScheduleData, RootTask> handler) { if (!_taskDataChanged.TryGetValue(task, out Action <VehicleScheduleData, RootTask> akce)) { _taskDataChanged.Add(task, handler); } else { akce -= handler; akce += handler; _taskDataChanged[task] = akce; } }
public void UpdateValues(VehicleScheduleData data, RootTask _) { if (data != _scheduleData) { throw new ArgumentException("Schedule data is not for this ScheduleTotalIndicator"); } Locale locale = LazyManager <LocaleManager> .Current.Locale; IReadOnlyDictionary <Item, TransferData> routeTotalTransfers = null; if (_capacityIndicator != null) { _lastTotalTransfers = data.Capacity.GetTotalTransfers(); routeTotalTransfers = RouteTotalTransfers; } int itemsLimit = routeTotalTransfers != null ? 7 : 10; _lastTransfersPerStation = null; _lastMonthMultiplier = data.ScheduleMonthlyMultiplier; _lastTotalTime = data.ScheduleAvereageDuration; _lastInaccurate = _lastTotalTime is { Estimated : true }; _lastInaccurate = false; if (_text != null) { itemsLimit = routeTotalTransfers != null ? 3 : 5; if (_lastTotalTime != null) { _lastInaccurate = _lastTotalTime.Estimated; _text.text = locale.GetString("schedule_stopwatch/days_hours").Format(((int)_lastTotalTime.Duration.TotalDays).ToString("N0"), _lastTotalTime.Duration.Hours.ToString("N0")); if (_lastInaccurate) { _text.color = Color.gray; } else { _text.color = Color.black; } } else { _text.text = locale.GetString("schedule_stopwatch/unknown").ToUpper(); } } if (_capacityIndicator != null) { _lastTotalTransfers = data.Capacity.GetTotalTransfers(); _capacityIndicator.UpdateItems(_lastTotalTransfers, _lastMonthMultiplier, routeTotalTransfers, itemsLimit: itemsLimit, transfDirection: TransferDirection.unloading); } }
/** iterates through tasks that do not have nonstop behaviour nonstop */ public IEnumerable <RootTask> GetNonNonstopTasks(Vehicle vehicle) { ImmutableList <RootTask> tasks = vehicle.Schedule.GetTasks(); int count = tasks.Count; for (int i = 0; i < count; i++) { RootTask task = tasks[i]; if (task.Behavior != RootTaskBehavior.NonStop) { yield return(task); } } yield break; }
public IReadOnlyDictionary <Item, TransferData> GetTransfers(RootTask task) { if (task.Vehicle.Route != route) { throw new ArgumentException("Wrong route in the tasks vehicle", "task"); } IReadOnlyDictionary <Item, TransferData> result; if (!_transfers.TryGetValue(task.GetIndex(), out result)) { result = Manager <VehicleScheduleDataManager> .Current[task.Vehicle]?.Capacity.GetRouteTaskTransfers(task); _transfers.Add(task.GetIndex(), result); } return(result); }
private void CallDataChangedEvents(RootTask task) { dataChanged?.Invoke(this, task); if (task == null) { foreach (Action <VehicleScheduleData, RootTask> action in _taskDataChanged.Values) { action?.Invoke(this, null); } } else if (_taskDataChanged.TryGetValue(task, out Action <VehicleScheduleData, RootTask> action)) { action?.Invoke(this, task); } }
public void Initialize(RootTask task, VehicleScheduleData data, Settings settings) { Task = task; _scheduleData = data; transform.name = "StopWatchDuration"; Transform timeIndicator = transform.Find("TimeIndicator"); if (settings.ShowIndividualTaskTimes) { _travelTimeText = timeIndicator.Find("TravelTimeText").GetComponent <Text>(); _loadingTimeText = timeIndicator.Find("LoadingTimeText").GetComponent <Text>(); Tooltip.For( timeIndicator, LazyManager <LocaleManager> .Current.Locale.GetString("schedule_stopwatch/task_times_hint") ); } else { timeIndicator.gameObject.SetActive(false); } if (settings.ShowIndividualLoadingCapacity) { _loadingCapIcon = transform.Find("LoadingCapacityIcon"); _loadCapacityIndicator = transform.Find("CargoCapacityLoad").GetComponent <CargoCapacityIndicator>(); _loadCapacityIndicator.Initialize(null, null); Tooltip.For( _loadCapacityIndicator, () => GetCapacityTooltipText(), null ); } if (settings.ShowIndividualUnloadingCapacity) { _unloadCapacityIndicator = transform.Find("CargoCapacityUnload").GetComponent <CargoCapacityIndicator>(); _unloadingCapIcon = transform.Find("UnloadingCapacityIcon"); _unloadCapacityIndicator.Initialize(null, null); Tooltip.For( _unloadCapacityIndicator, () => GetCapacityTooltipText(), null ); } transform.gameObject.SetActive(true); }
public DurationData GetAverageDuration(RootTask task) { if (!_data.TryGetValue(task, out DurationDataSet dataSet)) { return(null); } TimeSpan?average = dataSet.Average; if (!average.HasValue) { return(null); } DurationData durationData = new DurationData(average.Value, dataSet.Estimated); return(durationData); }
//called only when route has more than one vehicle public void CallDataChangedEventsForRoute(RootTask task) { VehicleRoute route = Vehicle.Route; if (route?.Vehicles.Count > 1) { int?taskIndex = task?.GetIndex(); VehicleScheduleDataManager manager = Manager <VehicleScheduleDataManager> .Current; foreach (Vehicle vehicle in route.Vehicles.ToArray()) { RootTask localTask = taskIndex != null?vehicle.Schedule.GetTasks()[taskIndex.Value] : null; manager[vehicle]?.CallDataChangedEvents(localTask); } } }
private void OnScheduleChanged(Vehicle vehicle, RootTask task, bool minorChange = false, bool notifyRoute = false) { if (notifyRoute && vehicle.Route != null) { ImmutableList <Vehicle> vehicles = vehicle.Route.Vehicles; for (int i = 0; i < vehicles.Count; i++) { ScheduleChanged?.Invoke(vehicles[i], task, minorChange); // NotificationUtils.ShowVehicleHint(vehicles[i], "OnScheduleChanged" + (minorChange ? " minor" : "")); } } else { ScheduleChanged?.Invoke(vehicle, task, minorChange); // NotificationUtils.ShowVehicleHint(vehicle, "OnScheduleChanged" + (minorChange ? " minor" : "")); } }
static private void RootTask_SetCurrentTask_pof(RootTask __instance, int ____subTaskIndex) { Vehicle vehicle = __instance.Vehicle; if (vehicle && ____subTaskIndex == 0) { VehicleStationLocation vehicleStation = __instance.Destination?.VehicleStationLocation; if (vehicleStation != null) { Current.OnDestinationReached(vehicle, vehicleStation, __instance); } else { Current.OnMeasurementInvalidated(vehicle); } } }