public void Move()
{
if (IsOutside)
{
return;
}
if (CompEngine)
{
step = CompEngine.EngineStep;
}
else
{
step = 0;
}
for (int i = 0; i < Quantity; i++)
{
CompCar = Cars [i];
if (i == 0)
{
CompCar.MoveByPath(step);
CompCar.BogeyLeft.CalcCompositionPosition(CompCar, CompCar.BogeyLeft.Offset);
CompCar.BogeyRight.CalcCompositionPosition(CompCar, CompCar.BogeyRight.Offset);
}
else
{
CompCar.CalcCompositionPosition(Cars [i - 1], Constants.RS_OFFSET);
CompCar.BogeyLeft.CalcCompositionPosition(CompCar, CompCar.BogeyLeft.Offset);
CompCar.BogeyRight.CalcCompositionPosition(CompCar, CompCar.BogeyRight.Offset);
}
}
}
public void SetCarsToBackSide(float position, int carNum)
{
RollingStock rs = GetCar(carNum);
//clear engine
if (rs.IsEngine)
{
rs.Engine.IsActive = false;
rs.Engine.IsPlayer = false;
}
//clear all connections
ClearConnections(rs);
//release prev TC
tempTC = rs.OwnTrackCircuit;
// set new TPU
rs.OwnTrack = TrackPath.Instance.GetTrackPathUnitByName(Constants.TRACK_BACKSIDE);
// set new TC
rs.OwnTrackCircuit = rs.OwnTrack.TrackCircuit;
// release prev tracks
ReleaseStartTracks(rs, tempTC);
//set position
rs.OwnPosition = position;
//set bogeys the same trackpathunit
rs.ResetBogeys();
CompositionManager.Instance.FormCompositionOnBackSide(rs);
IndicationManager.Instance.UpdateCouplerIndication();
}
public TrainCar SubCar(Train train, string wagonFilePath, int length)
{
Console.WriteLine("Will substitute with your existing stocks\n.");
try
{
char type = 'w';
if (wagonFilePath.ToLower().Contains(".eng"))
{
type = 'e';
}
string newWagonFilePath = SubMissingCar(length, type);
TrainCar car = RollingStock.Load(Simulator, train, newWagonFilePath);
car.CarLengthM = length;
car.RealWagFilePath = wagonFilePath;
Simulator.Confirmer?.Information(MPManager.Catalog.GetString("Missing car, have substituted with other one."));
return(car);
}
catch (Exception error)
{
Console.WriteLine(error.Message + "Substitution failed, will ignore it\n.");
return(null);
}
}
public async Task <ActionResult <RollingStockModel> > Create(RollingStockModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
// TODO: Validate road, road + road number combo
// TODO: Validate rs type and rs class
var rollingStock = new RollingStock
{
RoadId = model.RoadId,
RoadNumber = model.RoadNumber,
Notes = model.Notes,
Slug = model.Slug, // TODO: auto generate = road marks + road number
RollingStockTypeId = model.RollingStockTypeId,
RollingStockClassId = model.RollingStockClassId,
Details = model.Details,
Plate = model.Plate,
MaxGrossWeight = model.MaxGrossWeight,
LoadLimit = model.LoadLimit,
DryCapacity = model.DryCapacity,
ExteriorDimensions = model.ExteriorDimensions,
InteriorDimensions = model.InteriorDimensions
};
await _rollingStockRepository.CreateAsync(rollingStock);
model = _mapper.Map <RollingStockModel>(rollingStock);
return(CreatedAtAction(nameof(GetById), new { id = rollingStock.Id }, model));
}
private void ClearConnections(RollingStock rs)
{
if (rs.RSConnection.IsConnectedRight)
{
rs.RSConnection.RemoveConnection();
}
}
public void PutOneCarOnBackTrack(RollingStock car)
{
int num = car.Number;
int count = car.BackSidePosition;
SetCarsToBackSide(count * 100, num);
}
public void UpdateCargoIcon(RollingStock rs)
{
if (CarUI.activeSelf)
{
CargoIcon.SetIcon(rs);
}
}
// 7 - oil
// 6 - wood
// 2 - goods
// 0 - passengers
// -1 - Empty
public void SetIcon(RollingStock rs)
{
if (rs.CarProperties.IsLoaded)
{
commodityNumber = rs.CarProperties.commodityNumber;
if (commodityNumber == 7)
{
img.sprite = WithOil;
}
else if (commodityNumber == 6)
{
img.sprite = WithWood;
}
else if (commodityNumber == 2)
{
img.sprite = WithGoods;
}
else if (commodityNumber == 0)
{
img.sprite = WithPassengers;
}
}
else
{
img.sprite = Empty;
}
}
public void FormCompositionOnBackSide(RollingStock _car)
{
// cache old comp
Composition oldComposition = _car.RSComposition.CarComposition;
// if it is last car
if (_car.RSComposition.NumInComposition == oldComposition.Quantity - 1)
{
oldComposition.IsActive = false;
}
//delete car from comp
oldComposition.Cars [_car.RSComposition.NumInComposition] = null;
oldComposition.Quantity -= 1;
//delete comp engine
oldComposition.CompEngine = null;
// make new comp
Composition carComposition = Compositions[GetFreeCompositionSlotNum(1)];
//clear engine
carComposition.CompEngine = null;
_car.RSComposition.CarComposition = carComposition;
_car.RSComposition.NumInComposition = 0;
carComposition.Quantity = 1;
carComposition.Cars [0] = _car;
carComposition.LeftCar = _car;
carComposition.RightCar = _car;
// Make it mainCar
_car.RSComposition.IsMainCar = true;
carComposition.MainCar = _car;
carComposition.IsOutside = true;
TrackPath.Instance.GetTrackPath(carComposition.MainCar);
carComposition.Instantiate();
}
public void UpdateCompositionsAfterUncoupling(RollingStock rightCar)
{
// cache old comp num
Composition startComposition = rightCar.RSComposition.CarComposition;
Composition rightComposition;
// Get newComposition
int newCompQuantity = startComposition.Quantity - rightCar.RSComposition.NumInComposition;
//find comp slot
rightComposition = Compositions [GetFreeCompositionSlotNum(newCompQuantity)];
// clear engines
rightComposition.CompEngine = null;
startComposition.CompEngine = null;
//set Quantity to new comp
rightComposition.Quantity = newCompQuantity;
// take all cars after uncoupled car
int count = 0;
int num = rightCar.RSComposition.NumInComposition;
for (int i = 0; i < startComposition.Quantity; i++)
{
if (i >= num)
{
// put all cars after coupler to new comp
rightComposition.Cars [count] = startComposition.Cars [i];
// set Num in comp
rightComposition.Cars [count].RSComposition.NumInComposition = count;
// set new comp to cars after coupler
rightComposition.Cars [count].RSComposition.CarComposition = rightComposition;
// set engine to right comp
CheckEngineToComp(rightComposition, startComposition.Cars [i].Engine);
//delete old cars
startComposition.Cars [i] = null;
count++;
}
else
{
// set engine to startComposition comp
CheckEngineToComp(startComposition, startComposition.Cars [i].Engine);
}
}
// set Quantity to old comp
startComposition.Quantity = num;
// set pos of car after coupler
rightCar.RSComposition.NumInComposition = 0;
//Set main Car to new comp
rightCar.RSComposition.IsMainCar = true;
rightComposition.MainCar = rightCar;
// set left and right cars
rightComposition.LeftCar = rightCar;
rightComposition.RightCar = rightComposition.Cars [count - 1];
startComposition.RightCar = startComposition.Cars [startComposition.Quantity - 1];
// stop engine
StopEngine(rightComposition.CompEngine);
StopEngine(startComposition.CompEngine);
//make comp not outside
rightComposition.IsOutside = false;
UpdatePath();
}
private void ReleaseStartTracks(RollingStock _rs, TrackCircuit _tc)
{
if (_tc != null)
{
_tc.RemoveCars(_rs.BogeyLeft);
_tc.RemoveCars(_rs.BogeyRight);
}
}
private void Awake()
{
OwnTransform = gameObject.GetComponent <Transform>();
RollingStock = GetComponentInParent <RollingStock>();
OwnEngine = RollingStock.GetComponent <Engine>();
bogeyPos = Offset > 0 ? 1 : -1;
IsRightBogey = bogeyPos == 1 ? true : false;
}
private void Awake()
{
engine = GetComponent <Engine> ();
rSConnection = GetComponent <RSConnection> ();
rsComposition = GetComponent <RSComposition> ();
engineT = GetComponent <Transform> ();
car = GetComponent <RollingStock> ();
}
public virtual void OnTriggerEnter(Collider collider)
{
rs = collider.GetComponent <RollingStock> ();
direction = rs.Translation > 0 ? 1 : -1;
if (CheckViolation(direction))
{
print(rs.name + " falt signal " + signal.name);
GameManager.Instance.GameOver();
}
}
private void ClearPath(RollingStock car)
{
if (car.OwnPath != null)
{
for (int i = car.FirstTrackIndex; i <= car.LastTrackIndex; i++)
{
car.OwnPath [i] = null;
}
}
}
public void SetUnactiveRS(int rsNum)
{
RollingStock car = GetCar(rsNum);
car.BogeyLeft.OwnTrackCircuit = null;
car.BogeyRight.OwnTrackCircuit = null;
car.BogeyLeft.ProvidePresence();
car.BogeyRight.ProvidePresence();
rsGO = car.gameObject;
rsGO.SetActive(false);
}
public void SetActiveRS(int rsNum)
{
rsGO = GetCar(rsNum).gameObject;
rs = GetCar(rsNum);
rsGO.SetActive(true);
if (rs.IsEngine)
{
rs.OwnEngine = rs.Engine;
rs.Engine.IsActive = true;
}
}
public void FormCompositionsAfterSettingCars(RollingStock [] _cars, RollingStock activeEngine)
{
for (int i = 0; i < _cars.Length; i++)
{
// we take only cars from left
if (_cars [i].RSConnection.LeftCar == null) // it means that it is still Maincar
{
RollingStock car = _cars [i];
Composition thisCarComposition = car.RSComposition.CarComposition;
// set engine
if (activeEngine != null)
{
thisCarComposition.CompEngine = activeEngine.Engine;
thisCarComposition.CompEngine.IsActive = true;
}
else
{
thisCarComposition.CompEngine = null;
}
//it is in first position now
car.RSComposition.NumInComposition = 0;
int count = 1;
//it is next car now
rightConnection = car.RSConnection.RightCar;
while (rightConnection != null)
{
// define num in comp
rightConnection.RSComposition.NumInComposition = count;
// comp of connected cars is not active
rightConnection.RSComposition.CarComposition.IsActive = false;
// set cars comp to each next car
rightConnection.RSComposition.CarComposition = thisCarComposition;
// place of each next car in comp
thisCarComposition.Cars [count] = rightConnection.RollingStock;
// each next car is not main now
rightConnection.RSComposition.IsMainCar = false;
// take next car
rightConnection = rightConnection.RightCar;
count++;
}
thisCarComposition.Quantity = count;
thisCarComposition.LeftCar = car;
thisCarComposition.RightCar = thisCarComposition.Cars [count - 1];
thisCarComposition.IsOutside = false;
TrackPath.Instance.GetTrackPath(thisCarComposition.MainCar);
}
}
}
// Return Destination
// 0 - Bravo
// 1 - Charlie
// 2 - AlfaS
public void SetIcon(RollingStock rs)
{
returnNumber = rs.CarProperties.ReturnPoint;
if (returnNumber == 0)
{
img.sprite = Bravo;
}
else if (returnNumber == 1)
{
img.sprite = Charlie;
}
else if (returnNumber == 2)
{
img.sprite = Alfa;
}
}
//commodity
// 7 - oil
// 6 - wood
// 2 - goods
// 0 - passengers
// Return Destination
// 0 - Bravo
// 1 - Charlie
// 2 - Alfa
private void Awake()
{
rollingStock = GetComponent <RollingStock> ();
commodity = GetComponentInChildren <Commodity> ();
if (commodity)
{
IsWaggon = true;
CalcCommodity(GetComponent <RollingStock> ().Number);
}
else
{
commodityNumber = -1;
}
CalcReturnPoint();
}
public void GetTrackPath(RollingStock car)
{
PathMade++;
ClearPath(car);
// if we change swithces in indication mode
if (IndicationManager.Instance.IsPathIndicate)
{
IndicationManager.Instance.TurnPathIndicationOff();
IndicationManager.Instance.IsPathIndicate = true;
}
SetEachPathClosePaths();
TrackPathUnit currentTrack = car.OwnTrack;
tempLeft = currentTrack.LeftTrackPathUnit;
tempRight = currentTrack.RightTrackPathUnit;
count = Constants.PATHS_NUM / 2;
countLeft = count;
countRight = count;
TrackPathUnit [] pathOwn = new TrackPathUnit [Constants.PATHS_NUM];
pathOwn [count] = currentTrack;
while (tempLeft != null || tempRight != null)
{
if (tempLeft != null)
{
pathOwn[countLeft - 1] = tempLeft;
countLeft--;
tempLeft = tempLeft.LeftTrackPathUnit;
}
if (tempRight != null)
{
pathOwn [countRight + 1] = tempRight;
countRight++;
tempRight = tempRight.RightTrackPathUnit;
}
}
car.SetPathToRS(pathOwn, countLeft, countRight);
PathMade--;
// if all paths of all compositions are made
if (PathMade == 0)
{
print("PathMade");
EventManager.PathUpdated();
}
}
public void SetCarsPosition(string trackName, float position, int [] carsNums, int activeEngine = 0)
{
RollingStock [] cars = new RollingStock [carsNums.Length];
RollingStock rs = GetCar(carsNums [0]);
RollingStock actEng = GetCar(activeEngine);
// fill array of cars
cars [0] = rs;
//clear all connections
ClearConnections(rs);
//release prev TC
tempTC = rs.OwnTrackCircuit;
rs.OwnTrack = TrackPath.Instance.GetTrackPathUnitByName(trackName);
rs.OwnTrackCircuit = rs.OwnTrack.TrackCircuit;
ReleaseStartTracks(rs, tempTC);
//set position
rs.OwnPosition = position;
//set bogeys the same trackpathunit
rs.ResetBogeys();
// if one car no need
for (int i = 1; i < carsNums.Length; i++)
{
//take previous car
rs = GetCar(carsNums [i - 1]);
// get next car
RollingStock rightCar = GetCar(carsNums [i]);
// fill array of cars
cars [i] = rightCar;
//clear all connections
ClearConnections(rightCar);
//release prev TC
tempTC = rightCar.OwnTrackCircuit;
rightCar.OwnTrack = rs.OwnTrack;
rightCar.OwnTrackCircuit = rs.OwnTrack.TrackCircuit;
ReleaseStartTracks(rightCar, tempTC);
rs.RSConnection.InitConnection(rightCar.RSConnection);
rightCar.ResetBogeys();
}
CompositionManager.Instance.FormCompositionsAfterSettingCars(cars, actEng);
IndicationManager.Instance.UpdateCouplerIndication();
}
public void UpdateCompositionsAfterCoupling(RollingStock leftCar, RollingStock rightCar)
{
// cach new composition
Composition leftComposition = leftCar.RSComposition.CarComposition;
// cach old composition
Composition rightComposition = rightCar.RSComposition.CarComposition;
// clear maincar from right comp
rightCar.RSComposition.IsMainCar = false;
// get left comp last car number
int leftCompQuantity = leftComposition.Quantity;
// get right comp Quantity
int rightCompQuantity = rightComposition.Quantity;
// add cars from right to left comp
int count = 0;
for (int i = 0; i < rightCompQuantity + leftCompQuantity; i++)
{
if (i >= leftCompQuantity)
{
leftComposition.Cars [i] = rightComposition.Cars [count];
// set new comp to cars after coupler
leftComposition.Cars [i].RSComposition.CarComposition = leftComposition;
// set num in composition
leftComposition.Cars [i].RSComposition.NumInComposition = i;
// delete cars from right comp
rightComposition.Cars [count] = null;
count++;
}
}
// set right car to new comp
leftComposition.RightCar = leftComposition.Cars [count];
// set Quantity to new comp
leftComposition.Quantity = rightCompQuantity + leftCompQuantity;
// define engines
CheckEngineToComp(leftComposition, leftComposition.CompEngine, rightComposition.CompEngine);
//clear right comp
ClearComposition(rightComposition);
// stop engine
if (leftComposition.CompEngine)
{
leftComposition.CompEngine.HandlerZero();
}
UpdatePath();
}
private void SetViewer(RollingStock rs)
{
Viewer.SetText(rs.Number.ToString());
if (rs.IsEngine)
{
Viewer.SetLocoUI();
Viewer.SetEngine(rs.Engine);
Viewer.SetEngineForSpeed(rs.Engine);
// to set camera taget
EventManager.ThrottleChanged();
}
else
{
Viewer.SetCarUI(rs);
rs.Model.HighLightCarOutline();
}
Viewer.SetIcon(rs);
Viewer.SetReturnPoint(rs);
}
public void TrainBuild()
{
int time = TimeManager.Instance.TimeValue [0];
if (time == StartTime && time == 1)
{
if (startTrack.TrackCircuit.HasCarPresence)
{
print("Game Over. Track is not free");
}
CarsHolder.SetCarsPosition(startTrack.name, 1000, Cars, intEngine);
trainEngine = engine;
// cache maincar
mainCar = trainEngine.EngineRS.RSComposition.CarComposition.MainCar;
IsActive = true;
EventManager.SignalChanged();
trainEngine.EngineAI.MoveWithDirection(TrainDirection * Constants.MAX_THROTTLE);
}
}
private void SetCameraPosition()
{
if (engine.InstructionsHandler == 0)
{
OffsetX = 0;
}
else if (engine.InstructionsHandler > 0)
{
OffsetX = 100;
Target = composition.CarComposition.RightCar;
targetTransform = Target.transform;
}
else if (engine.InstructionsHandler < 0)
{
OffsetX = -100;
Target = composition.CarComposition.LeftCar;
targetTransform = Target.transform;
}
}
public void RollingStockListener(Collider collider)
{
if (collider.CompareTag("Engine"))
{
HitEngine = collider.GetComponent <Engine> ();
if (!HitEngine.IsPlayer)
{
TempEngine = PlayerEngine;
TempEngine.IsPlayer = false;
//set outlines
TempEngine.EngineRS.Model.DefaultOutline();
PlayerEngine = HitEngine;
PlayerEngine.IsActive = true;
PlayerEngine.IsPlayer = true;
ccc.Target = PlayerEngine.EngineRS;
ccc.UpdateCameraTarget();
IndicationManager.Instance.engine = PlayerEngine;
SetPlayerEngineInComposition();
}
SetViewer(PlayerEngine.EngineRS);
PlayerEngine.EngineRS.Model.HighLightEngineOutline();
if (tempRollingStock != null)
{
tempRollingStock.Model.DefaultOutline();
tempRollingStock = null;
}
EventManager.EngineChanged();
}
else if (collider.CompareTag("RollingStock"))
{
rollingStock = collider.GetComponent <RollingStock> ();
SetViewer(rollingStock);
if (tempRollingStock != null && !tempRollingStock.Equals(rollingStock))
{
tempRollingStock.Model.DefaultOutline();
}
tempRollingStock = rollingStock;
}
}
public void AddPlayers(MSGPlayer player, OnlinePlayer p)
{
if (Players.ContainsKey(player.user))
{
return;
}
if (MPManager.Client != null && player.user == MPManager.Client.UserName)
{
return; //do not add self//WARNING: may need to worry about train number here
}
if (p == null)
{
p = new OnlinePlayer(null, null);
}
p.url = player.url;
p.LeadingLocomotiveID = player.leadingID;
p.con = MPManager.Simulator.BasePath + "\\TRAINS\\CONSISTS\\" + player.con;
p.path = MPManager.Simulator.RoutePath + "\\PATHS\\" + player.path;
Train train = new Train(MPManager.Simulator);
train.TrainType = Train.TRAINTYPE.REMOTE;
if (MPManager.IsServer()) //server needs to worry about correct train number
{
}
else
{
train.Number = player.num;
}
if (player.con.Contains("tilted"))
{
train.IsTilting = true;
}
int direction = player.dir;
train.travelled = player.Travelled;
train.TrainMaxSpeedMpS = player.trainmaxspeed;
if (MPManager.IsServer())
{
try
{
#if ACTIVITY_EDITOR
AIPath aiPath = new AIPath(MPManager.Simulator.TDB, MPManager.Simulator.TSectionDat, p.path, MPManager.Simulator.TimetableMode, MPManager.Simulator.orRouteConfig);
#else
AIPath aiPath = new AIPath(MPManager.Simulator.TDB, MPManager.Simulator.TSectionDat, p.path);
#endif
}
catch (Exception) { MPManager.BroadCast((new MSGMessage(player.user, "Warning", "Server does not have path file provided, signals may always be red for you.")).ToString()); }
}
try
{
train.RearTDBTraveller = new Traveller(MPManager.Simulator.TSectionDat, MPManager.Simulator.TDB.TrackDB.TrackNodes, player.TileX, player.TileZ, player.X, player.Z, direction == 1 ? Traveller.TravellerDirection.Forward : Traveller.TravellerDirection.Backward);
}
catch (Exception e)
{
if (MPManager.IsServer())
{
MPManager.BroadCast((new MSGMessage(player.user, "Error", "MultiPlayer Error：" + e.Message)).ToString());
}
else
{
throw new Exception();
}
}
for (var i = 0; i < player.cars.Length; i++)// cars.Length-1; i >= 0; i--) {
{
string wagonFilePath = MPManager.Simulator.BasePath + @"\trains\trainset\" + player.cars[i];
TrainCar car;
try
{
car = RollingStock.Load(MPManager.Simulator, train, wagonFilePath);
car.CarLengthM = player.lengths[i] / 100.0f;
}
catch (Exception error)
{
Console.WriteLine(error.Message);
car = MPManager.Instance().SubCar(train, wagonFilePath, player.lengths[i]);
}
if (car == null)
{
continue;
}
car.Flipped = player.flipped[i] != 0;
car.CarID = player.ids[i];
if (car is MSTSWagon w)
{
w.SignalEvent((player.pantofirst == 1 ? PowerSupplyEvent.RaisePantograph : PowerSupplyEvent.LowerPantograph), 1);
w.SignalEvent((player.pantosecond == 1 ? PowerSupplyEvent.RaisePantograph : PowerSupplyEvent.LowerPantograph), 2);
w.SignalEvent((player.pantothird == 1 ? PowerSupplyEvent.RaisePantograph : PowerSupplyEvent.LowerPantograph), 3);
w.SignalEvent((player.pantofourth == 1 ? PowerSupplyEvent.RaisePantograph : PowerSupplyEvent.LowerPantograph), 4);
}
}
if (train.Cars.Count == 0)
{
throw (new Exception("The train of player " + player.user + " is empty from "));
}
p.Username = player.user;
train.ControlMode = Train.TRAIN_CONTROL.EXPLORER;
train.CheckFreight();
train.InitializeBrakes();
bool canPlace = true;
Train.TCSubpathRoute tempRoute = train.CalculateInitialTrainPosition(ref canPlace);
if (tempRoute.Count == 0 || !canPlace)
{
MPManager.BroadCast((new MSGMessage(p.Username, "Error", "Cannot be placed into the game")).ToString());//server will broadcast this error
throw new InvalidDataException("Remote train original position not clear");
}
train.SetInitialTrainRoute(tempRoute);
train.CalculatePositionOfCars();
train.ResetInitialTrainRoute(tempRoute);
train.CalculatePositionOfCars();
train.AITrainBrakePercent = 100;
//if (MPManager.Instance().AllowedManualSwitch) train.InitializeSignals(false);
for (int iCar = 0; iCar < train.Cars.Count; iCar++)
{
var car = train.Cars[iCar];
if (car.CarID == p.LeadingLocomotiveID)
{
train.LeadLocomotive = car;
(train.LeadLocomotive as MSTSLocomotive).Headlight = player.headlight;
(train.LeadLocomotive as MSTSLocomotive).UsingRearCab = player.frontorrearcab == "R" ? true : false;
}
if (car is MSTSLocomotive && MPManager.IsServer())
{
MPManager.Instance().AddOrRemoveLocomotive(player.user, train.Number, iCar, true);
}
}
if (train.LeadLocomotive == null)
{
train.LeadNextLocomotive();
p.LeadingLocomotiveID = train.LeadLocomotive?.CarID ?? "NA";
}
if (train.LeadLocomotive != null)
{
train.Name = train.GetTrainName(train.LeadLocomotive.CarID);
}
else if (train.Cars != null && train.Cars.Count > 0)
{
train.Name = train.GetTrainName(train.Cars[0].CarID);
}
else if (player?.user != null)
{
train.Name = player.user;
}
if (MPManager.IsServer())
{
train.InitializeSignals(false);
}
p.Train = train;
Players.Add(player.user, p);
MPManager.Instance().AddOrRemoveTrain(train, true);
}
public void SetCarUI(RollingStock rs)
{
LocoUI.SetActive(false);
CarUI.SetActive(true);
UpdateCargoIcon(rs);
}
public void SetReturnPoint(RollingStock rs)
{
RSReturnDestination.SetIcon(rs);
}
static void Main(string[] args)
{
RollingStock rollingStock = new RollingStock()
{
new Diesel()
{
Model = "Diesel E56",
BuildDate = new DateTime(2010,5,12),
EnginePower = 30000,
MaxSpeed = 150,
SpeedUp = 4.1,
Weight = 3000
},
new Coach()
{
Model = "Coach C605",
BuildDate = new DateTime(2005, 1, 19),
Weight = 2000,
CoachSeats = 38,
CoachType = PassengerCarsType.Second
},
new BaggageCar()
{
Model = "Baggage B605",
BuildDate = new DateTime(2010, 4, 1),
Weight = 2000,
CoachSeats = 45,
BaggageQuantity = 111,
CoachType = PassengerCarsType.First
},
new Coach()
{
Model = "Coach C609",
BuildDate = new DateTime(2005, 1, 19),
Weight = 2000,
CoachSeats = 38,
CoachType = PassengerCarsType.First
},
new BaggageCar()
{
Model = "Baggage B610",
BuildDate = new DateTime(2010, 4, 1),
Weight = 2000,
CoachSeats = 45,
BaggageQuantity = 111,
CoachType = PassengerCarsType.Third
},
new DiningCar()
{
Model = "Dining E57",
BuildDate = new DateTime(2010,5,12),
DeanerSeats = 20,
Weight = 3000
},
};
foreach (var i in rollingStock)
{
Console.WriteLine("{0}, {1}", i.Model, i.Builder);
}
Console.WriteLine("\n GetCoachItemByNumber()");
foreach (var i in rollingStock.GetCoachItemByNumber(1, 100))
{
Console.WriteLine("{0}, {1}", i.Model, i.Builder);
}
Console.WriteLine("\n GetCoachSeatsSum()");
Console.WriteLine("{0}", rollingStock.GetCoachSeatsSum());
Console.WriteLine("\n GetBaggagSeatsSum()");
Console.WriteLine("{0}", rollingStock.GetBaggageQuantitySum());
Console.WriteLine("\n SortByCoachType()");
foreach (var i in rollingStock.Sort(new TrainItemComparerBySeatsCount()))
{
Console.WriteLine("{0}, {1}", i.Model, i.Builder);
}
Console.ReadKey();
}
