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);
}
}
}
