Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Move CreateInPool from AI to Pools #783

Merged
merged 1 commit into from
Feb 27, 2023
+140 −47
Merged

Move CreateInPool from AI to Pools #783

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
43 changes: 1 addition & 42 deletions Source/Orts.Simulation/Simulation/AIs/AI.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1159,54 +1159,13 @@ private bool AddToWorldTT(TTTrain thisTrain, List<TTTrain> nextTrains)
int presentTime = Convert.ToInt32(Math.Floor(clockTime));
TimetablePool thisPool = Simulator.PoolHolder.Pools[thisTrain.CreateInPool];

int PoolStorageState = (int)TTTrain.PoolAccessState.PoolInvalid;
thisTrain.TCRoute.TCRouteSubpaths[0] = thisPool.CreateInPool(thisTrain, out PoolStorageState, false);
thisTrain.ValidRoute[0] = new Train.TCSubpathRoute(thisTrain.TCRoute.TCRouteSubpaths[0]);
thisTrain.TCRoute.activeSubpath = 0;
int PoolStorageState = thisPool.CreateInPool(thisTrain, nextTrains);

// if no storage available - abondone train
if (PoolStorageState < 0)
{
Trace.TraceInformation("Train : " + thisTrain.Name + " : no storage room available in pool : " + thisPool.PoolName + " ; engine not created");
return (endPreRun);
}

// use stored traveller
thisTrain.PoolStorageIndex = PoolStorageState;
thisTrain.RearTDBTraveller = new Traveller(thisPool.StoragePool[thisTrain.PoolStorageIndex].StoragePathTraveller);

// if storage available check for other engines on storage track
if (thisPool.StoragePool[thisTrain.PoolStorageIndex].StoredUnits.Count > 0)
{
int lastTrainNumber = thisPool.StoragePool[thisTrain.PoolStorageIndex].StoredUnits[thisPool.StoragePool[thisTrain.PoolStorageIndex].StoredUnits.Count - 1];
TTTrain lastTrain = thisTrain.GetOtherTTTrainByNumber(lastTrainNumber);
if (lastTrain == null)
{
lastTrain = thisTrain.Simulator.GetAutoGenTTTrainByNumber(lastTrainNumber);
}
if (lastTrain != null)
{
thisTrain.CreateAhead = String.Copy(lastTrain.Name).ToLower();
}
}

tempRoute = thisTrain.CalculateInitialTTTrainPosition(ref validPosition, nextTrains);

if (validPosition)
{
thisTrain.SetInitialTrainRoute(tempRoute);
thisTrain.CalculatePositionOfCars();
for (int i = 0; i < thisTrain.Cars.Count; i++)
thisTrain.Cars[i].WorldPosition.XNAMatrix.M42 -= 1000;
thisTrain.ResetInitialTrainRoute(tempRoute);

// set train route and position so proper position in pool can be calculated
thisTrain.UpdateTrainPosition();

// add unit to pool
thisPool.AddUnit(thisTrain, false);
validPosition = thisTrain.PostInit(false); // post init train but do not activate
}
}

// clear track and align switches - check state
Expand Down
66 changes: 63 additions & 3 deletions Source/Orts.Simulation/Simulation/Timetables/TTPool.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
// COPYRIGHT 2014 by the Open Rails project.
// COPYRIGHT 2014 by the Open Rails project.
//
// This file is part of Open Rails.
//
Expand Down Expand Up @@ -176,6 +176,7 @@ public struct PoolDetails
{
public Train.TCSubpathRoute StoragePath; // path defined as storage location
public Traveller StoragePathTraveller; // traveller used to get path position and direction
public Traveller StoragePathReverseTraveller; // traveller used if path must be reversed
public string StorageName; // storage name
public List<Train.TCSubpathRoute> AccessPaths; // access paths defined for storage location
public float StorageLength; // available length
Expand Down Expand Up @@ -737,11 +738,70 @@ virtual public bool TestPoolExit(TTTrain train)
//================================================================================================//
/// <summary>
/// Create in pool : create train in pool
/// For this type of pool, a train is created in pool by running it into the pool as would be done on dispose
/// </summary>
/// <param name="train"></param>

virtual public Train.TCSubpathRoute CreateInPool(TTTrain train, out int poolStorageIndex, bool checkAccessPath)
virtual public int CreateInPool(TTTrain train, List<TTTrain> nextTrains)
{
int PoolStorageState = (int)TTTrain.PoolAccessState.PoolInvalid;
train.TCRoute.TCRouteSubpaths[0] = PlaceInPool(train, out PoolStorageState, false);
train.ValidRoute[0] = new Train.TCSubpathRoute(train.TCRoute.TCRouteSubpaths[0]);
train.TCRoute.activeSubpath = 0;

// if no storage available - abondone train
if (PoolStorageState < 0)
{
return (PoolStorageState);
}

// use stored traveller
train.PoolStorageIndex = PoolStorageState;
train.RearTDBTraveller = new Traveller(StoragePool[train.PoolStorageIndex].StoragePathTraveller);

// if storage available check for other engines on storage track
if (StoragePool[train.PoolStorageIndex].StoredUnits.Count > 0)
{
int lastTrainNumber = StoragePool[train.PoolStorageIndex].StoredUnits[StoragePool[train.PoolStorageIndex].StoredUnits.Count - 1];
TTTrain lastTrain = train.GetOtherTTTrainByNumber(lastTrainNumber);
if (lastTrain == null)
{
lastTrain = train.Simulator.GetAutoGenTTTrainByNumber(lastTrainNumber);
}
if (lastTrain != null)
{
train.CreateAhead = String.Copy(lastTrain.Name).ToLower();
}
}

bool validPosition = false;
Train.TCSubpathRoute tempRoute = train.CalculateInitialTTTrainPosition(ref validPosition, nextTrains);

if (validPosition)
{
train.SetInitialTrainRoute(tempRoute);
train.CalculatePositionOfCars();
for (int i = 0; i < train.Cars.Count; i++)
train.Cars[i].WorldPosition.XNAMatrix.M42 -= 1000;
train.ResetInitialTrainRoute(tempRoute);

// set train route and position so proper position in pool can be calculated
train.UpdateTrainPosition();

// add unit to pool
AddUnit(train, false);
validPosition = train.PostInit(false); // post init train but do not activate
}

return (PoolStorageState);
}

//================================================================================================//
/// <summary>
/// Place in pool : place train in pool
/// </summary>
/// <param name="train"></param>

virtual public Train.TCSubpathRoute PlaceInPool(TTTrain train, out int poolStorageIndex, bool checkAccessPath)
{
int tempIndex;
Train.TCSubpathRoute newRoute = SetPoolExit(train, out tempIndex, checkAccessPath);
Expand Down
78 changes: 76 additions & 2 deletions Source/Orts.Simulation/Simulation/Timetables/TTTurntable.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -803,10 +803,84 @@ private float CalculateVectorLength(int firstIndex, int LastIndex, int connectIn

//================================================================================================//
/// <summary>
/// Create in pool : create train in pool, for this type of pool train is created directly on storage path
/// Create in pool : create train in pool
/// </summary>
/// <param name="train"></param>

public override Train.TCSubpathRoute CreateInPool(TTTrain train, out int poolStorageIndex, bool checkAccessPath)
override public int CreateInPool(TTTrain train, List<TTTrain> nextTrains)
{
int PoolStorageState = (int)TTTrain.PoolAccessState.PoolInvalid;
train.TCRoute.TCRouteSubpaths[0] = PlaceInPool(train, out PoolStorageState, false);
train.ValidRoute[0] = new Train.TCSubpathRoute(train.TCRoute.TCRouteSubpaths[0]);
train.TCRoute.activeSubpath = 0;

// if no storage available - abondone train
if (PoolStorageState < 0)
{
return (PoolStorageState);
}

train.PoolStorageIndex = PoolStorageState;

// if no of units is limited to 1, place engine in direction of turntable
if (StoragePool[PoolStorageState].maxStoredUnits.HasValue && StoragePool[PoolStorageState].maxStoredUnits == 1)
{
// use stored traveller
train.RearTDBTraveller = new Traveller(StoragePool[PoolStorageState].StoragePathTraveller);
}

else
{
// use reverse path
train.TCRoute.TCRouteSubpaths[0] = new Train.TCSubpathRoute(train.TCRoute.TCRouteSubpaths[0].ReversePath(train.signalRef));
train.ValidRoute[0] = new Train.TCSubpathRoute(train.TCRoute.TCRouteSubpaths[0]);

train.RearTDBTraveller = new Traveller(StoragePool[PoolStorageState].StoragePathReverseTraveller);

// if storage available check for other engines on storage track
if (StoragePool[PoolStorageState].StoredUnits.Count > 0)
{
int lastTrainNumber = StoragePool[PoolStorageState].StoredUnits[StoragePool[PoolStorageState].StoredUnits.Count - 1];
TTTrain lastTrain = train.GetOtherTTTrainByNumber(lastTrainNumber);
if (lastTrain == null)
{
lastTrain = train.Simulator.GetAutoGenTTTrainByNumber(lastTrainNumber);
}
if (lastTrain != null)
{
train.CreateAhead = String.Copy(lastTrain.Name).ToLower();
}
}
}

bool validPosition = false;
Train.TCSubpathRoute tempRoute = train.CalculateInitialTTTrainPosition(ref validPosition, nextTrains);

if (validPosition)
{
train.SetInitialTrainRoute(tempRoute);
train.CalculatePositionOfCars();
for (int i = 0; i < train.Cars.Count; i++)
train.Cars[i].WorldPosition.XNAMatrix.M42 -= 1000;
train.ResetInitialTrainRoute(tempRoute);

// set train route and position so proper position in pool can be calculated
train.UpdateTrainPosition();

// add unit to pool
AddUnit(train, false);
validPosition = train.PostInit(false); // post init train but do not activate
}

return (PoolStorageState);
}

//================================================================================================//
/// <summary>
/// Place in pool : place train in pool, for this type of pool train is created directly on storage path
/// </summary>

public override Train.TCSubpathRoute PlaceInPool(TTTrain train, out int poolStorageIndex, bool checkAccessPath)
{
Train.TCSubpathRoute newRoute = null;
int storageIndex = -1;
Expand Down