IExecutionPlan ILift.ProcessRequests(IList <SummonInformation> requests)
{
IsFirstRequestValid(requests);
_executionPlan.Clear();
if (_state == LiftState.Parked &&
IsFirstRequestForCurrentFloor(requests.First()))
{
_executionPlan.Add(requests.First());
requests.RemoveAt(0);
}
TravelDirection direction = GetInitialDirectionOfTravel(requests.First());
var boundaries = _floorConfiguration.GetBoundariesForDirection(direction);
ProcessSummonsRequestSegment(requests, direction, boundaries, true);
if (NeedToRunSameSegmentInOppositeDirection(requests.First(), direction))
{
direction = InverseDirection(direction);
ProcessSummonsRequestSegment(requests, direction, boundaries, false);
}
SwitchBoundaries(ref boundaries);
ProcessSummonsRequestSegment(requests, direction, boundaries, true);
direction = InverseDirection(direction);
boundaries = _floorConfiguration.GetFullRangeBoundariesForDirection(direction);
ProcessSummonsRequestSegment(requests, direction, boundaries, true);
return(_executionPlan);
}
public Split(TravelDirection split1, TravelDirection split2, TravelDirection rotation, PlantTileType type)
{
this.split1 = split1;
this.split2 = split2;
this.rotation = rotation;
this.type = type;
}
private void ChangeMovement()
{
float newMovementType = Mathf.FloorToInt((float)_random.NextDouble() * 10);
if (newMovementType <= 1)
{
_direction = TravelDirection.Straight;
}
else if (newMovementType <= 5)
{
_direction = TravelDirection.Left;
}
else
{
_direction = TravelDirection.Right;
}
float secondsToMoveInDirection;
if (_direction == TravelDirection.Straight)
{
secondsToMoveInDirection = (float)((_random.NextDouble() * LevelSelectData._levelSelect._maxRestTravelTime) + LevelSelectData._levelSelect._minRestTravelTime);
}
else
{
secondsToMoveInDirection = (float)((_random.NextDouble() * LevelSelectData._levelSelect._maxDirectionTravelTime) + LevelSelectData._levelSelect._minDirectionTravelTime);
}
_timeToTravelInDirection = (int)(secondsToMoveInDirection / GameConstants.tunnelSpawnConstantNormal);
}
/// <summary>Check whether the travel plan of the train is valid.</summary>
private void CheckTravelData(double InitializeTime)
{
bool Recalculation = false;
TravelDirection LastDirection = ((TravelStopData)Data[0]).Direction;
for (int i = 1; i < Data.Length; i++)
{
// The deceleration start point must appear after the acceleration end point.
if ((Data[i - 1].AccelerationEndPosition - Data[i].DecelerationStartPosition) * (int)LastDirection > 0)
{
// Reset acceleration and deceleration.
double Delta = Math.Abs(Data[i].Position - Data[i - 1].Position);
if (Delta != 0.0)
{
Data[i - 1].Accelerate = (Math.Pow(Data[i - 1].TargetSpeed, 2.0) - Math.Pow(Data[i - 1].PassingSpeed, 2.0)) / Delta;
Data[i].Decelerate = (Math.Pow(Data[i].PassingSpeed, 2.0) - Math.Pow(Data[i - 1].TargetSpeed, 2.0)) / Delta;
Recalculation = true;
}
}
LastDirection = (Data[i] as TravelStopData)?.Direction ?? LastDirection;
}
// Recreate the operation plan of the train.
if (Recalculation)
{
SetupTravelData(InitializeTime);
}
}
private void SwitchBoundaries(ref Boundaries boundaries)
{
TravelDirection directionForCurrentBoundaries = GetBoundariesDirection(boundaries);
boundaries = _floorConfiguration.GetBoundariesForDirection(directionForCurrentBoundaries == TravelDirection.Up
? TravelDirection.Down
: TravelDirection.Up);
}
private TravelDirection InverseDirection(TravelDirection direction)
{
return(direction == TravelDirection.None
? TravelDirection.None
: direction == TravelDirection.Up
? TravelDirection.Down
: TravelDirection.Up);
}
public void NewArea(string nameScene, TravelDirection direction)
{
travelDirection = direction;
AreaManager.manager.NewArea(); //destroys old area manager
playerPos = new Vector3();
SceneManager.LoadScene(nameScene);
}
private void HandleSummonForBoundaries(IList <SummonInformation> requests, TravelDirection direction, Boundaries boundaries, IList <SummonInformation> selectedSummons)
{
foreach (var summon in requests)
{
if (boundaries.IsExtremum(direction, summon.SummonFloor))
{
selectedSummons.Add(summon);
}
}
}
/// <summary>
/// Parameterized Constructor - To Initialize the data members and properties with private set
/// </summary>
/// <param name="fromCity"></param>
/// <param name="toCity"></param>
/// <param name="onwardDateOfJourney"></param>
/// <param name="returnDateOfJourney"></param>
/// <param name="noOfSeats"></param>
/// <param name="travelClass"></param>
/// <param name="direction"></param>
public SearchInfo(City fromCity, City toCity, DateTime onwardDateOfJourney, DateTime returnDateOfJourney, int noOfSeats, TravelClass travelClass, TravelDirection direction)
{
this.FromCity = fromCity;
this.ToCity = toCity;
this.OnwardDateOfJourney = onwardDateOfJourney;
this.ReturnDateOfJourney = returnDateOfJourney;
this.NoOfSeats = noOfSeats;
this.Class = travelClass;
this.Direction = direction;
}
/// <summary>
/// Adds the search result to the log
/// </summary>
/// <param name="result"></param>
/// <param name="direction"></param>
public void AddSearchResultToLog(TravelDirection direction, SearchResult result)
{
if (schedulesLog.ContainsKey(direction))
{
schedulesLog[direction] = result;
}
else
{
schedulesLog.Add(direction, result);
}
}
// Attempt to grow this bud, taking into account possible collisions with the bounding box,
// existing plants, and the stage. Returns true if the growth was successful, false if the
// bud died after growing.
public bool TryToGrow(TilePlant plant)
{
// If we split, hijack this update to show the new split tile.
if (pendingSplit != null)
{
nextType = pendingSplit.type;
travel = pendingSplit.rotation;
}
plant.UpdateLocation(location, phase, nextType, travel);
var newHeading = GetNewHeading(nextType);
var newLocation = Travel(newHeading);
var newPhase = GetNewPhase();
// If we split, try to grow split1, replace heading for the main bud.
if (pendingSplit != null)
{
var splitDirection = pendingSplit.split1;
var splitLocation = location + GetDirectionVector(splitDirection);
if (!FatalLocation(plant, splitLocation, false))
{
plant.AddBud(new Bud {
location = splitLocation,
travel = splitDirection,
phase = newPhase,
});
plant.UpdateLocation(splitLocation, newPhase, PlantTileType.Bud, splitDirection);
}
newHeading = pendingSplit.split2;
newLocation = Travel(newHeading);
pendingSplit = null;
}
nextType = PlantTileType.Straight; // May be overridden by CheckCollisions.
if (FatalLocation(plant, newLocation, true))
{
return(false);
}
// Needed for checking splitter rotations.
location = newLocation;
travel = newHeading;
phase = newPhase;
CheckForSplitter(plant, newLocation);
plant.UpdateLocation(newLocation, newPhase, PlantTileType.Bud, newHeading);
return(true);
}
public SummonInformation(int currentFloor, TravelDirection direction = TravelDirection.None, SummonInformation triggeringSummon = null)
{
SummonFloor = currentFloor;
Direction = direction;
if (direction == TravelDirection.None)
{
TriggeringSummon = triggeringSummon;
}
else
{
TriggeringSummon = null;
}
}
public static int Offset(TravelDirection travelDirection)
{
int offset = 0;
if (travelDirection == TravelDirection.North || travelDirection == TravelDirection.West)
{
offset = -1;
}
else if (travelDirection == TravelDirection.South || travelDirection == TravelDirection.East)
{
offset = 1;
}
return(offset);
}
public void ChangeLights(TravelDirection direction)
{
if (direction == TravelDirection.North || direction == TravelDirection.South)
{
foreach (var car in Spawner.instance.VerticalCars)
{
car.GetComponent <CarDetection>().SpeedUpCar();
}
Spawner.instance.VerticalCars.Clear();
}
if (direction == TravelDirection.East || direction == TravelDirection.West)
{
foreach (var car in Spawner.instance.HorizontalCars)
{
car.GetComponent <CarDetection>().SpeedUpCar();
}
Spawner.instance.HorizontalCars.Clear();
}
if (IS_CHANGING)
{
WaitLonger(direction);
return;
}
Debug.LogWarning("Changing Lights for " + direction);
switch (direction)
{
case TravelDirection.North:
StartCoroutine(LightTimer(10, 1, NorthLights, SouthLights));
break;
case TravelDirection.East:
StartCoroutine(LightTimer(10, 2, EastLights, WestLights));
break;
case TravelDirection.South:
StartCoroutine(LightTimer(10, 1, NorthLights, SouthLights));
break;
case TravelDirection.West:
StartCoroutine(LightTimer(10, 2, EastLights, WestLights));
break;
}
}
public ArterialData(ServiceVolumeTableFDOT Inputs, List <SegmentData> segments)
{
_artName = "";
_from = "";
_to = "";
_lengthMiles = Inputs.Roadway.FacilityLengthMiles;
_dir = Inputs.Roadway.AnalysisTravelDir;
_area = Inputs.SerVolAreaType;
_class = Inputs.Class;
_segments = segments;
_Dfactor = Inputs.Traffic.DFactor;
_Kfactor = Inputs.Traffic.KFactor;
_thresholds = new ThresholdData();
_results = new ResultsArterialData();
}
public FOWPoint(int px, int py, TravelDirection t, int ptAmount)
{
X = px;
Y = py;
PreviousDirection = t;
bool isDiag = false;
switch (PreviousDirection)
{
case TravelDirection.PX:
X++;
break;
case TravelDirection.NX:
X--;
break;
case TravelDirection.PY:
Y++;
break;
case TravelDirection.NY:
Y--;
break;
case TravelDirection.PXPY:
X++; Y++;
isDiag = true;
break;
case TravelDirection.PXNY:
X++; Y--;
isDiag = true;
break;
case TravelDirection.NXPY:
X--; Y++;
isDiag = true;
break;
case TravelDirection.NXNY:
X--; Y--;
isDiag = true;
break;
}
TravelAmount = ptAmount - (isDiag ? 14 : 10);
}
private Vector3Int GetDirectionVector(TravelDirection dir)
{
switch (dir)
{
case TravelDirection.Up:
return(Vector3Int.up);
case TravelDirection.Down:
return(Vector3Int.up * -1);
case TravelDirection.Left:
return(Vector3Int.right * -1);
// case TravelDirection.Right:
default:
return(Vector3Int.right);
}
}
public void enableSplineMovement(TravelDirection direction, BezierSpline foundSpline)
{
this.enabled = true;
spline = foundSpline;
float speed = 10f;
duration = foundSpline._TotalDistance() / speed;
if (direction == TravelDirection.Forward)
{
progress = 0;
}
else
{
progress = 1f;
}
this.direction = direction;
this.GetComponent <Rigidbody2D>().isKinematic = true;
}
/// <summary>
/// Constructor for creating an Arterial for use with Service Volumes.
/// </summary>
/// <param name="area"></param>
/// <param name="classification"></param>
/// <param name="analysisTravelDir"></param>
/// <param name="segments"></param>
/// <param name="KFactor"></param>
/// <param name="DFactor"></param>
public ArterialData(AreaType area, ArterialClass classification, TravelDirection analysisTravelDir, List <SegmentData> segments, float KFactor, float DFactor)
{
//SetDefaultValues();
//_segments = new List<SegmentData>();
_artName = "";
_from = "";
_to = "";
_lengthMiles = 0;
_dir = analysisTravelDir;
_area = area;
_class = classification;
_segments = segments;
_Dfactor = DFactor;
_Kfactor = KFactor;
_thresholds = new ThresholdData();
_results = new ResultsArterialData();
}
public FOWPoint(int px, int py, TravelDirection t, int ptAmount)
{
X = px;
Y = py;
PreviousDirection = t;
bool isDiag = false;
switch(PreviousDirection) {
case TravelDirection.PX:
X++;
break;
case TravelDirection.NX:
X--;
break;
case TravelDirection.PY:
Y++;
break;
case TravelDirection.NY:
Y--;
break;
case TravelDirection.PXPY:
X++; Y++;
isDiag = true;
break;
case TravelDirection.PXNY:
X++; Y--;
isDiag = true;
break;
case TravelDirection.NXPY:
X--; Y++;
isDiag = true;
break;
case TravelDirection.NXNY:
X--; Y--;
isDiag = true;
break;
}
TravelAmount = ptAmount - (isDiag ? 14 : 10);
}
public static Vehicle Convert(VehicleConfiguration configuration, TravelDirection direction)
{
var random = new Random(DateTime.Now.Millisecond);
var vehicle = new Vehicle()
{
Speed = random.Next(configuration.Speed.Down, configuration.Speed.Up + 1),
PassengersNumber = random.Next(configuration.PassengersNumber.Down, configuration.PassengersNumber.Up + 1),
Weight = random.Next(configuration.Weight.Down, configuration.Weight.Up + 1),
Type = configuration.Type,
Direction = direction,
};
var lengthIndex = random.Next(0, configuration.LenghtList.Count);
vehicle.Length = configuration.LenghtList[lengthIndex];
var icons = configuration.IconsConfiguration.Where(c => c.Direction == direction).ToList();
var iconPathIndex = random.Next(0, icons.Count);
var icon = icons[iconPathIndex];
var bt = new Bitmap(Image.FromFile(icon.Path), icon.Width, icon.Height);
vehicle.Icon = Icon.FromHandle(bt.GetHicon());
return(vehicle);
}
/// <summary>
/// Constructor for creating an Arterial without using Service Volumes.
/// </summary>
/// <param name="area"></param>
/// <param name="classification"></param>
/// <param name="analysisTravelDir"></param>
/// <param name="segments"></param>
public ArterialData(AreaType area, ArterialClass classification, TravelDirection analysisTravelDir, List <SegmentData> segments)
{
//SetDefaultValues();
//_segments = new List<SegmentData>();
_artName = "";
_from = "";
_to = "";
_lengthMiles = 0;
_dir = analysisTravelDir;
_area = area;
_class = classification;
_segments = segments;
_Dfactor = 0.5f;
_Kfactor = 0.1f;
_thresholds = new ThresholdData();
_results = new ResultsArterialData();
//_class = ParmRanges.ArtClassDefault[Convert.ToInt32(_area)];
//_Kfactor = ParmRanges.KfactDefault[Convert.ToInt32(_area)];
//_Dfactor = ParmRanges.DfactDefault[Convert.ToInt32(_area)];
//_maxSerVol = ParmRanges.MaxSerVol[Convert.ToInt32(_area)]; //for other urbanized
}
private void SetRailIndex(double Mileage, TravelDirection Direction, TrackFollower TrackFollower)
{
TrackFollower.TrackIndex = Data.LastOrDefault(x => x.Mileage <= Mileage + (int)Direction * (TrackFollower.TrackPosition - CurrentPosition))?.RailIndex ?? Data[0].RailIndex;
}
private void GetNewState(double Time, out double NewMileage, out double NewPosition, out TravelDirection NewDirection, out bool OpenLeftDoors, out bool OpenRightDoors)
{
double DeltaT;
double DeltaPosition;
OpenLeftDoors = false;
OpenRightDoors = false;
{
// The first point must be TravelStopData.
TravelStopData FirstData = (TravelStopData)Data[0];
NewMileage = FirstData.Mileage;
NewPosition = FirstData.Position;
NewDirection = FirstData.Direction;
if (Time <= FirstData.ArrivalTime)
{
return;
}
if (Time <= FirstData.ClosingDoorsStartTime)
{
OpenLeftDoors = FirstData.OpenLeftDoors;
OpenRightDoors = FirstData.OpenRightDoors;
return;
}
if (Time <= FirstData.DepartureTime)
{
return;
}
// The start point does not slow down. Acceleration only.
if (Time <= FirstData.AccelerationEndTime)
{
DeltaT = Time - FirstData.DepartureTime;
DeltaPosition = 0.5 * FirstData.Accelerate * Math.Pow(DeltaT, 2.0);
NewMileage += DeltaPosition;
NewPosition += (int)NewDirection * DeltaPosition;
return;
}
NewMileage += Math.Abs(FirstData.AccelerationEndPosition - NewPosition);
NewPosition = FirstData.AccelerationEndPosition;
}
for (int i = 1; i < Data.Length; i++)
{
if (Time <= Data[i].DecelerationStartTime)
{
DeltaT = Time - Data[i - 1].AccelerationEndTime;
DeltaPosition = Data[i - 1].TargetSpeed * DeltaT;
NewMileage += DeltaPosition;
NewPosition += (int)NewDirection * DeltaPosition;
return;
}
NewMileage += Math.Abs(Data[i].DecelerationStartPosition - NewPosition);
NewPosition = Data[i].DecelerationStartPosition;
if (Time <= Data[i].ArrivalTime)
{
DeltaT = Time - Data[i].DecelerationStartTime;
DeltaPosition = Data[i - 1].TargetSpeed * DeltaT + 0.5 * Data[i].Decelerate * Math.Pow(DeltaT, 2.0);
NewMileage += DeltaPosition;
NewPosition += (int)NewDirection * DeltaPosition;
return;
}
TravelStopData StopData = Data[i] as TravelStopData;
NewMileage = Data[i].Mileage;
NewPosition = Data[i].Position;
NewDirection = StopData?.Direction ?? NewDirection;
if (Time <= StopData?.ClosingDoorsStartTime)
{
OpenLeftDoors = StopData.OpenLeftDoors;
OpenRightDoors = StopData.OpenRightDoors;
return;
}
// The end point does not accelerate.
if (Time <= Data[i].DepartureTime || i == Data.Length - 1)
{
return;
}
if (Time <= Data[i].AccelerationEndTime)
{
DeltaT = Time - Data[i].DepartureTime;
DeltaPosition = Data[i].PassingSpeed * DeltaT + 0.5 * Data[i].Accelerate * Math.Pow(DeltaT, 2.0);
NewMileage += DeltaPosition;
NewPosition += (int)NewDirection * DeltaPosition;
return;
}
NewMileage += Math.Abs(Data[i].AccelerationEndPosition - NewPosition);
NewPosition = Data[i].AccelerationEndPosition;
}
}
public bool IsExtremum(TravelDirection direction, int value)
{
return(value == GetExtremumForDirection(direction));
}
public int GetExtremumForDirection(TravelDirection direction)
{
return(direction == TravelDirection.Up
? Item2
: Item1);
}
public SatNavModel()
{
CurrentDirection = TravelDirection.North;
CurrentSpeed = 0;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
try
{
long FromCityId = Convert.ToInt64(Request.QueryString["frmid"].ToString());
long ToCityId = Convert.ToInt64(Request.QueryString["toid"].ToString());
string flightclass = Request.QueryString["clss"].ToString();
int td = Convert.ToInt16(Request.QueryString["td"].ToString());
hdnTravelDirection.Value = td.ToString();
lblHeaderDepart.Text = Convert.ToDateTime(Request.QueryString["depart_date"]).ToString("ddd, dd MMM, yyyy");
lblHeaderReturn.Text = Convert.ToDateTime(Request.QueryString["return_date"]).ToString("ddd, dd MMM, yyyy");
TravelDirection traveldirection = (TravelDirection)td;
SearchInfo searchinfo = new SearchInfo();
City fromcity = new City();
searchinfo.OnwardDateOfJourney = Convert.ToDateTime(Request.QueryString["depart_date"]);
searchinfo.ReturnDateOfJourney = Convert.ToDateTime(Request.QueryString["return_date"]);
fromcity.CityId = FromCityId;
City tocity = new City();
tocity.CityId = ToCityId;
TravelClass travelclass = (TravelClass)Enum.Parse(typeof(TravelClass), flightclass);
searchinfo.FromCity = fromcity;
searchinfo.ToCity = tocity;
searchinfo.Class = travelclass;
searchinfo.Direction = traveldirection;
ISearchManager searchmanager = SearchManagerFactory.GetInstance().Create();
SearchLog searchlog = searchmanager.SearchForFlights(searchinfo);
SearchResult searchresult = searchlog.GetSearchResult(TravelDirection.OneWay);
List <TravelSchedule> lstTravelSchedule = searchresult.GetTravelSchedules();
dlOuterOnward.DataSource = lstTravelSchedule;
dlOuterOnward.DataBind();
Session["flightbookingonwardresults"] = lstTravelSchedule;
if (lstTravelSchedule.Count > 0)
{
lblOneWayFromCity.Text = lblHeaderFromCity.Text = lstTravelSchedule[0].GetSchedules()[0].RouteInfo.FromCity.Name;
lblOneWayToCity.Text = lblHeaderToCity.Text = lstTravelSchedule[0].GetSchedules()[0].RouteInfo.ToCity.Name;
}
if (traveldirection == TravelDirection.Return)
{
SearchResult searchresultreturn = searchlog.GetSearchResult(TravelDirection.Return);
List <TravelSchedule> lstTravelScheduleReturn = searchresultreturn.GetTravelSchedules();
dlOuterReturn.DataSource = lstTravelScheduleReturn;
dlOuterReturn.DataBind();
Session["flightbookingreturnresults"] = lstTravelScheduleReturn;
if (lstTravelScheduleReturn.Count > 0)
{
lblReturnFromCity.Text = lstTravelScheduleReturn[0].GetSchedules()[0].RouteInfo.FromCity.Name;
lblReturnToCity.Text = lstTravelScheduleReturn[0].GetSchedules()[0].RouteInfo.ToCity.Name;
}
}
else
{
outbound_div.Style.Add("width", "70%");
return_div.Visible = false;
lblHeaderReturn.Visible = false;
lblHeaderDateSeparator.Visible = false;
}
}
catch
{
Response.Redirect("~/Error.aspx");
}
}
}
protected void btnBook_Click(object sender, EventArgs e)
{
int adults = Convert.ToInt32(Request.QueryString["adults"].ToString());
int td = Convert.ToInt16(Request.QueryString["td"].ToString());
TravelDirection traveldirection = (TravelDirection)td;
List <string> onwardids = new List <string>();
for (int i = 0; i < hdnScheduleOnwardSelectedId.Value.Split('|').Length; i++)
{
onwardids.Add(hdnScheduleOnwardSelectedId.Value.Split('|')[i].ToString());
}
List <TravelSchedule> lstTravelSchedule = (List <TravelSchedule>)Session["flightbookingonwardresults"];
List <Schedule> resultonward = (from t in lstTravelSchedule.SelectMany(schedule => schedule.GetSchedules())
where onwardids.Contains(t.ID.ToString())
select t).ToList();
TravelSchedule objOnwardSchedule = new TravelSchedule();
decimal OnwardCostPerTicket = 0;
decimal OnwardTotalCost = 0;
foreach (Schedule schedule in resultonward)
{
objOnwardSchedule.AddSchedule(schedule);
OnwardCostPerTicket = OnwardCostPerTicket + schedule.GetFlightCosts().FirstOrDefault().CostPerTicket;
}
OnwardTotalCost = OnwardCostPerTicket * adults;
FlightBooking flightbookingonward = new FlightBooking();
flightbookingonward.NoOfSeats = adults;
flightbookingonward.BookingType = BookingTypes.Flight;
FlightClass Class = new FlightClass();
Class.ClassInfo = (TravelClass)Enum.Parse(typeof(TravelClass), Request.QueryString["class"]);
flightbookingonward.Class = Class;
flightbookingonward.TravelScheduleInfo = objOnwardSchedule;
flightbookingonward.DateOfJourney = Convert.ToDateTime(Request.QueryString["depart_date"]);
flightbookingonward.TotalCost = OnwardTotalCost;
if (Membership.GetUser() != null)
{
flightbookingonward.UserName = Membership.GetUser().UserName;
}
else
{
flightbookingonward.UserName = "******";
}
TravelBooking travelbooking = new TravelBooking();
travelbooking.AddBookingForTravel(TravelDirection.OneWay, flightbookingonward);
if (traveldirection == TravelDirection.Return)
{
List <string> retunrids = new List <string>();
for (int i = 0; i < hdnScheduleReturnSelectedId.Value.Split('|').Length; i++)
{
retunrids.Add(hdnScheduleReturnSelectedId.Value.Split('|')[i].ToString());
}
List <TravelSchedule> lstTravelScheduleReturn = (List <TravelSchedule>)Session["flightbookingreturnresults"];
List <Schedule> resultreturn = (from t in lstTravelScheduleReturn.SelectMany(schedule => schedule.GetSchedules())
where retunrids.Contains(t.ID.ToString())
select t).ToList();
TravelSchedule objReturnSchedule = new TravelSchedule();
decimal ReturnTotalCost = 0;
decimal ReturnCostPerTicket = 0;
foreach (Schedule schedule in resultreturn)
{
objReturnSchedule.AddSchedule(schedule);
ReturnCostPerTicket = ReturnCostPerTicket + schedule.GetFlightCosts().FirstOrDefault().CostPerTicket;
}
ReturnTotalCost = ReturnCostPerTicket * adults;
FlightBooking flightbookingreturn = new FlightBooking();
flightbookingreturn.NoOfSeats = adults;
flightbookingreturn.TravelScheduleInfo = objReturnSchedule;
flightbookingreturn.DateOfJourney = Convert.ToDateTime(Request.QueryString["return_date"]);
flightbookingreturn.TotalCost = ReturnTotalCost;
if (Membership.GetUser() != null)
{
flightbookingreturn.UserName = Membership.GetUser().UserName;
}
else
{
flightbookingreturn.UserName = "******";
}
travelbooking.AddBookingForTravel(TravelDirection.Return, flightbookingreturn);
}
Session["travelbooking"] = travelbooking;
Response.Redirect("~/booking/passengers.aspx");
}
private Split GetSplit(string splitter, TravelDirection incoming)
{
switch (incoming)
{
case TravelDirection.Up:
switch (splitter)
{
case "splitter_lr":
return(new Split(TravelDirection.Left, TravelDirection.Right, TravelDirection.Up, PlantTileType.Tee));
case "splitter_lu":
return(new Split(TravelDirection.Left, TravelDirection.Up, TravelDirection.Right, PlantTileType.Tee));
// case "splitter_ur":
default:
return(new Split(TravelDirection.Up, TravelDirection.Right, TravelDirection.Left, PlantTileType.Tee));
}
case TravelDirection.Down:
switch (splitter)
{
case "splitter_lr":
return(new Split(TravelDirection.Left, TravelDirection.Right, TravelDirection.Down, PlantTileType.Tee));
case "splitter_lu":
return(new Split(TravelDirection.Left, TravelDirection.Up, TravelDirection.Down, PlantTileType.Right));
// case "splitter_ur":
default:
return(new Split(TravelDirection.Up, TravelDirection.Right, TravelDirection.Down, PlantTileType.Left));
}
case TravelDirection.Left:
switch (splitter)
{
case "splitter_lr":
return(new Split(TravelDirection.Left, TravelDirection.Right, TravelDirection.Left, PlantTileType.Straight));
case "splitter_lu":
return(new Split(TravelDirection.Left, TravelDirection.Up, TravelDirection.Down, PlantTileType.Tee));
// case "splitter_ur":
default:
return(new Split(TravelDirection.Up, TravelDirection.Right, TravelDirection.Left, PlantTileType.Right));
}
default:
switch (splitter)
{
case "splitter_lr":
return(new Split(TravelDirection.Left, TravelDirection.Right, TravelDirection.Right, PlantTileType.Straight));
case "splitter_lu":
return(new Split(TravelDirection.Left, TravelDirection.Up, TravelDirection.Right, PlantTileType.Left));
// case "splitter_ur":
default:
return(new Split(TravelDirection.Up, TravelDirection.Right, TravelDirection.Down, PlantTileType.Tee));
}
}
}
private void SetDirection(TravelDirection direction)
{
this.travel = direction;
}
private Vector3Int Travel(TravelDirection direction)
{
return(location + GetDirectionVector(direction));
}
