public void AddLaneFlags(UIPanel parent, LaneData lane, NetLaneExt.Flags mask)
{
try {
LogCalled("parent", lane.LaneID, mask);
AddSpacePanel(parent, 6);
var laneContainer = AddPanel(parent);
laneContainer.padding = laneContainer.autoLayoutPadding = new RectOffset();
var caption = LaneCaptionButton.Add(laneContainer, lane);
var lanePanel = AddPanel(laneContainer);
caption.SetTarget(lanePanel);
foreach (var flag in mask.ExtractPow2Flags())
{
LaneFlagToggle.Add(lanePanel, lane.LaneID, flag);
}
laneContainer.eventMouseEnter += (_, __) => HighlighLaneID = lane.LaneID;
laneContainer.eventMouseLeave += (_, __) => {
if (HighlighLaneID == lane.LaneID)
{
HighlighLaneID = 0;
}
};
laneContainer.atlas = TextureUtil.Ingame;
laneContainer.backgroundSprite = "MenuPanelInfo";
} catch (Exception ex) {
Log.Exception(ex);
}
}
public double GetCenterLineY(LaneData[] lanes, DeviceData[] devs, Size panelSize)
{
if (lanes == null || lanes.Length <= 0)
return 200;
return panelSize.Height /2;
}
public static LaneCaptionButton Add(UIPanel parent, LaneData lane)
{
var ret = parent.AddUIComponent <LaneCaptionButton>();
ret.lane_ = lane;
return(ret);
}
// Start is called before the first frame update
void Start()
{
travelDistance = LevelData.LevelInstance.GetComponent <Grid>().cellSize.x *
LevelData.LevelInstance.transform.localScale.x;
platformObject = null;
currentLane = null;
parentController = PlayerController.playerInstance.GetComponent <PlayerController>();
maxHeight = transform.position.y;
}
public override void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
base.RenderOverlay(cameraInfo);
if (SelectedSegmentID != 0 && SelectedNodeID != 0)
{
HighlightSegmentEnd(cameraInfo, SelectedSegmentID, SelectedNodeID, Color.white);
}
else if (SelectedNodeID != 0)
{
RenderUtil.DrawNodeCircle(cameraInfo, Color.white, SelectedNodeID, true);
}
else if (SelectedSegmentID != 0)
{
RenderUtil.RenderSegmnetOverlay(cameraInfo, SelectedSegmentID, Color.white, true);
}
if (flagsPanel_ && flagsPanel_.HighlighLaneID != 0)
{
var laneData = new LaneData(flagsPanel_.HighlighLaneID);
RenderUtil.RenderLaneOverlay(cameraInfo, laneData, Color.yellow, false);
}
if (!HoverValid)
{
return;
}
Color color;
if (Input.GetMouseButton(0))
{
color = GetToolColor(true, false);
}
else if (HoverHasFlags())
{
color = GetToolColor(false, false);
}
else
{
color = GetToolColor(false, true);
}
if (SegmentMode)
{
RenderUtil.RenderSegmnetOverlay(cameraInfo, HoveredSegmentID, color, true);
}
else if (NodeMode)
{
RenderUtil.DrawNodeCircle(cameraInfo, color, HoveredNodeID, true);
}
else if (SegmentEndMode)
{
HighlightSegmentEnd(cameraInfo, HoveredSegmentID, HoveredNodeID, color);
}
}
// pass in segmentID for the sake of MOM lane problem.
public void UpdateLane(LaneData lane, ushort segmentID)
{
Assertion.AssertEqual(LaneData.LaneID, lane.LaneID, "lane id");
if (lane.Lane.m_segment != 0 && lane.Lane.m_segment != segmentID)
{
Log.Error($"lane segment mismatch: {LaneData} parentSegment:{segmentID}");
}
lane.Lane.m_segment = segmentID; // fix MOM lane issue
try {
LaneData = lane;
bool parkingAllowed = LaneData.LaneInfo.m_laneType == NetInfo.LaneType.Parking;
if (PMan != null)
{
parkingAllowed &= PMan.IsParkingAllowed(LaneData.SegmentID, LaneData.LaneInfo.m_finalDirection);
}
m_flags = m_flags.SetFlags(Flags.ParkingAllowed, parkingAllowed);
ExtVehicleType mask = 0;
if (VRMan != null)
{
mask = VRMan.GetAllowedVehicleTypes(
segmentId: segmentID,
segmentInfo: segmentID.ToSegment().Info,
laneIndex: (uint)LaneData.LaneIndex,
laneInfo: LaneData.LaneInfo,
busLaneMode: VehicleRestrictionsMode.Configured);
}
m_flags = m_flags.SetFlags(Flags.Car, VRMan.IsPassengerCarAllowed(mask));
m_flags = m_flags.SetFlags(Flags.SOS, VRMan.IsEmergencyAllowed(mask));
m_flags = m_flags.SetFlags(Flags.Bus, VRMan.IsBusAllowed(mask));
m_flags = m_flags.SetFlags(Flags.CargoTruck, VRMan.IsCargoTruckAllowed(mask));
m_flags = m_flags.SetFlags(Flags.Taxi, VRMan.IsTaxiAllowed(mask));
m_flags = m_flags.SetFlags(Flags.Service, VRMan.IsServiceAllowed(mask));
m_flags = m_flags.SetFlags(Flags.CargoTrain, VRMan.IsCargoTrainAllowed(mask));
m_flags = m_flags.SetFlags(Flags.PassengerTrain, VRMan.IsPassengerTrainAllowed(mask));
if (SLMan != null)
{
SpeedLimit = (SLMan as SpeedLimitManager).GetGameSpeedLimit(LaneData.LaneID);
}
else
{
SpeedLimit = lane.LaneInfo.m_speedLimit;
}
//TODO lane connections
//Log.Debug("NetLaneExt.UpdateLane() result: " + this);
} catch (Exception ex) {
Log.Exception(ex, this.ToString(), false);
throw ex;
}
}
public static float GetLaneSpeedLimit(this LaneData lane)
{
if (SLMan != null)
{
return((SLMan as SpeedLimitManager).GetGameSpeedLimit(lane.LaneID));
}
else
{
return(lane.LaneInfo.m_speedLimit);
}
}
public CreepWave(LaneData laneData)
{
LaneData = laneData;
PreviousPoint = laneData.Points.ElementAt(0);
NextPoint = laneData.Points.ElementAt(1);
timeAdded = Time = Game.GameTime;
if (laneData.LanePosition == LanePosition.Middle)
{
speedUpdated = true;
}
}
// Nathan wrote this
// loads a saved lane's data
public void loadLaneAtts(LaneData savedLane)
{
// just need to reassign each of the lane's attributes (position, width, stripes, etc.)
// not sure we need position (the lanes will be inserted either way, and should all be
// the correct type and in the correct order without resetting this)
// also not sure we need to set type, max/min width, or the booleans
// as these should all be set properly by inserting the saved lane type
// the only true variables are the width and the stripes
setLaneWidth(savedLane.loadLaneWidth());
// stripes could be a little more complicated
// first, load in the data for both stripes
StripeData leftStripeData = savedLane.loadStripeData("left");
StripeData rightStripeData = savedLane.loadStripeData("right");
// if the stripes are not null, load in their data
// otherwise, just set their orientation to null
if (leftStripeData != null)
{
// subcase: not sure if we need it, but just in case
if (leftStripe != null)
{
Stripe leftStripeScriptReference = (Stripe)leftStripe.GetComponent("Stripe");
leftStripeScriptReference.loadStripeAtts(leftStripeData);
}
else
{
Debug.Log("This almost certainly should never happen. INSIDE WEIRD LOADING CASE.");
}
}
else
{
setStripeOrientation(null, "left");
}
if (rightStripeData != null)
{
// again, not sure we need this subcase
if (rightStripe != null)
{
Stripe rightStripeScriptReference = (Stripe)rightStripe.GetComponent("Stripe");
rightStripeScriptReference.loadStripeAtts(rightStripeData);
}
else
{
Debug.Log("This almost certainly should never happen. INSIDE WEIRD LOADING CASE.");
}
}
else
{
setStripeOrientation(null, "right");
}
}
// has single transition which merges into another lane.
internal static bool IsMergesUnique(this LaneData lane)
{
var transitions = GetForwardTransisions(lane.LaneID, lane.StartNode);
if (transitions.Count() != 1)
{
return(false); // not single transition
}
var transition = transitions.First();
var targetBackwardTransitions = GetBackwardTransisions(transition.laneId, transition.startNode);
return(targetBackwardTransitions.Count() >= 2); // merge
}
void Start()
{
if (LaneDataManager.laneDatas == null)
{
LaneDataManager.laneDatas = new List <LaneData>();
}
if (laneData == null)
{
laneData = new LaneData();
LaneDataManager.laneDatas.Add(laneData);
}
}
public SwitchingLanes(Vehicle vehicle, LaneData lane1, LaneData lane2, VehicleData vehicleData, HingeJoint hinge, Rigidbody carBody, int currTargetIndex, float currSpeed)
{
this.vehicle = vehicle;
this.lane1 = lane1;
this.lane2 = lane2;
this.vehicleData = vehicleData;
this.hinge = hinge;
this.hingeRb = hinge.GetComponent <Rigidbody>();
this.carBody = carBody;
this.hingeTransform = hinge.transform;
this.currTargetIndex = currTargetIndex;
this.currSpeed = currSpeed;
}
/// <summary>
/// Gets the used lane flags for the input lane (not all the lanes of the NetInfo)
/// </summary>
public static NetLaneExt.Flags GetUsedCustomFlagsLane(LaneData lane)
{
NetLaneExt.Flags mask = 0;
var props = (lane.LaneInfo.m_laneProps?.m_props).EmptyIfNull();
foreach (var prop in props)
{
var metadata = prop.GetMetaData();
if (metadata != null)
{
mask |= (metadata.LaneFlags.Required | metadata.LaneFlags.Forbidden);
}
}
return(mask & NetLaneExt.Flags.CustomsMask);
}
public static int CountTargetConnections(LaneData sourceLane, LaneData[] TargetLanes)
{
int ret = 0;
foreach (var targetLane in TargetLanes)
{
if (LaneConnectionManager.Instance.AreLanesConnected(
sourceLaneId: sourceLane.LaneID,
targetLaneId: targetLane.LaneID,
sourceStartNode: sourceLane.StartNode))
{
ret++;
}
}
return(ret);
}
public void AddLaneFlags(UIPanel container, LaneData lane, NetLaneExt.Flags mask)
{
try {
LogCalled(container, lane.LaneID, mask);
AddSpacePanel(container, 6);
var laneContainer = LanePanelCollapsable.Add(container, lane, mask);
laneContainer.eventMouseEnter += (_, __) => HighlighLaneID = lane.LaneID;
laneContainer.eventMouseLeave += (_, __) => {
if (HighlighLaneID == lane.LaneID)
{
HighlighLaneID = 0;
}
};
} catch (Exception ex) {
Log.Exception(ex);
}
}
public LaneData OffsetSpline(float offset, float detail)
{
List <Vector3> offsetCurve = new List <Vector3>();
float refPointCount = ControlPointCount * detail;
for (int i = 0; i < refPointCount + 1; i++)
{
float t = (float)i / refPointCount;
Vector3 generatePointRef = GetPoint(t) + transform.position;
Vector3 offsetPoint = generatePointRef + Quaternion.Euler(0, -90, 0) * GetDirection(t) * offset;
offsetPoint.y = generatePointRef.y;
offsetCurve.Add(offsetPoint);
}
LaneData offsetSpline = new LaneData(offsetCurve.ToArray());
return(offsetSpline);
}
// splits into multiple lanes at least one of which has only one transion to it.
internal static bool IsSplitsUnique(this LaneData lane)
{
var transitions = GetForwardTransisions(lane.LaneID, lane.StartNode);
if (transitions.Count() < 2)
{
return(false); // not split
}
// any target lane that has only one transition to it?
foreach (var transition in transitions)
{
var targetBackwardTransitions = GetBackwardTransisions(transition.laneId, transition.startNode);
if (targetBackwardTransitions.Count() == 1)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Determines if there is any lane connection from source lane to target segment.
/// </summary>
public static bool IsLaneConnectedToSegment(LaneData sourceLane, ushort targetSegmentID)
{
ushort sourceSegmentID = sourceLane.SegmentID;
ushort nodeID = sourceSegmentID.ToSegment().GetSharedNode(targetSegmentID);
bool sourceStartNode = NetUtil.IsStartNode(sourceSegmentID, nodeID);
bool targetStartNode = NetUtil.IsStartNode(targetSegmentID, nodeID);
var targetLanes = NetUtil.IterateLanes(
targetSegmentID,
!targetStartNode,// going away from start node.
LaneConnectionManager.LANE_TYPES,
LaneConnectionManager.VEHICLE_TYPES);
foreach (LaneData targetLane in targetLanes)
{
if (LaneConnectionManager.Instance.AreLanesConnected(sourceLane.LaneID, targetLane.LaneID, sourceStartNode))
{
return(true);
}
}
return(false);
}
public static LanePanelCollapsable Add(UIComponent parent, LaneData lane, NetLaneExt.Flags mask)
{
Log.Called();
Assertion.AssertNotNull(parent, "parent");
var ret = parent.AddUIComponent <LanePanelCollapsable>();
Assertion.AssertNotNull(ret, "laneContainer");
var caption = LaneCaptionButton.Add(ret, lane);
var innerPanel = AddPanel(ret);
caption.SetTarget(innerPanel);
innerPanel.name = "lanePanel";
foreach (var flag in mask.ExtractPow2Flags())
{
LaneFlagToggle.Add(innerPanel, lane.LaneID, flag);
}
return(ret);
}
public Driving(
Vehicle vehicle,
LaneData lane,
HingeJoint hinge,
VehicleData vehicleData,
int currTargetIndex,
float currSpeed,
Tuple <ParticleSystem, ParticleSystem> smokeFX)
{
//Components
this.vehicle = vehicle;
this.lane = lane;
this.hinge = hinge;
this.hingeRb = hinge.GetComponent <Rigidbody>();
this.hingeTransform = hinge.transform;
this.vehicleData = vehicleData;
this.smokeFX = smokeFX;
//Initial values
this.currTargetIndex = currTargetIndex;
CurrSpeed = currSpeed;
}
void OnTriggerEnter2D(Collider2D collision)
{
if (collision.gameObject.tag == "Enemy")
{
Die();
}
if (collision.gameObject.tag == "Platform")
{
platformObject = collision.GetComponent <TravellingObject>();
}
if (collision.gameObject.tag == "Lane")
{
currentLane = collision.GetComponent <LaneData>();
}
if (collision.gameObject.tag == "Objective")
{
ObjectiveCompleted();
}
}
// Nathan wrote this
// class constructor
// road is the road object in the development environment
public RoadData(Road road)
{
// store the environment as an EnvironmentData variable
Buildings buildingScriptReference = road.getBuildingsReference();
buildingsIndex = buildingScriptReference.getBuildingIndex();
// store the fog variables
FogControl fogControlScriptReference = road.getFogControl();
fogDistance = fogControlScriptReference.getFogDistance();
// store the lighting intensities
BrightnessControl[] lightScripts = road.getLights();
for (int i = 0; i < lightScripts.Length; i++)
{
lightIntensities[i] = lightScripts[i].getBrightness();
}
// store the lanes as a list of LaneData
LinkedList <GameObject> roadLanes = road.getLanes();
// store the lanes
foreach (GameObject lane in roadLanes)
{
BasicLane laneScriptRef = (BasicLane)lane.GetComponent("BasicLane");
LaneData indLaneData = null;
// if we have a non-vehicle lane, create the independent lane data with a prop manager
if (!laneScriptRef.isVehicleLane())
{
PropManager propManagerRef = lane.GetComponent <PropManager>();
indLaneData = new LaneData(laneScriptRef, propManagerRef);
}
else
{
indLaneData = new LaneData(laneScriptRef);
}
laneData.Add(indLaneData);
}
}
public void PopulateData()
{
laneData.Clear();
mapLaneSegData.Clear();
foreach (Transform child in laneDataHolder)
{
if (child == null)
{
return;
}
mapLaneSegData.AddRange(child.GetComponentsInChildren <MapLaneSegmentBuilder>());
}
foreach (var mapLaneData in mapLaneSegData)
{
LaneData tempData = new LaneData();
foreach (var localPos in mapLaneData.segment.targetLocalPositions)
{
tempData.data.Add(mapLaneData.transform.TransformPoint(localPos));
}
laneData.Add(tempData);
}
}
public List <LaneData> GetLastPallets(int ramp)
{
try
{
using (var dc = new EntitiesWMS())
{
string loc = $"W:32:{ramp:d2}";
var laneOrd = dc.Places
.Where(p => p.PlaceID.StartsWith(loc))
.OrderBy(p => p.PlaceID).ThenBy(p => p.Time)
.ToList();
var lanes = laneOrd
.GroupBy(
(by) => by.PlaceID,
(key, group) => new
{
Place = group.FirstOrDefault(),
Count = group.Count()
})
.ToList();
var List = new List <LaneData>();
foreach (var p in lanes)
{
LaneData laneData = null;
if (p.Place != null)
{
var tu = dc.TUs.FirstOrDefault(pp => pp.TU_ID == p.Place.TU_ID);
SKUData sku = null;
if (tu != null)
{
sku = new SKUData {
SKU = tu.SKU_ID, SKUBatch = tu.Batch, SKUQty = tu.Qty
}
}
;
var cmd = dc.Commands
.Where(pp => pp.TU_ID == p.Place.TU_ID && pp.Target.StartsWith("W:32"))
.Join(dc.Orders,
c => c.Order_ID,
o => o.ID,
(c, o) => new { c.ID, o.SubOrderID, o.SubOrderName, o.Status })
.OrderByDescending(pp => pp.ID)
.FirstOrDefault();
SubOrderData so = null;
if (cmd != null)
{
so = new SubOrderData {
SubOrderID = cmd.SubOrderID, SubOrderName = cmd.SubOrderName
}
}
;
string[] split = p.Place.PlaceID.Split(':');
laneData = new LaneData
{
LaneID = Int32.Parse(split[2]) % 10,
Count = p.Count,
FirstTUID = p.Place.TU_ID,
SKU = sku,
Suborder = so
};
}
List.Add(laneData);
}
return(List);
}
}
catch (Exception e)
{
throw new Exception(string.Format("{0}.{1}: {2}", this.GetType().Name, (new StackTrace()).GetFrame(0).GetMethod().Name, e.Message));
}
}
/*
*
* 701-->(19)==(1)===(2)==========================================(3)===(4)====================================(5)
* \\ \\ \\
* \\ \\ \\
* (6) (7) (8)
* || || ||
* || || ||
* || || ||
* || || ||
* || || ||
* (9) (10) (11)
* \\ // //
* \\ // //
* (12)================(13) (14)================(15)===(16)=================================(17)
* \\ //
* \\ //
* (18)
* ||
* ||
* 801
*/
public static void CreateNetworkTopology(NetworkData network, List <NodeData> nodes, List <LinkData> links)
{
network.NumLinks = 0;
const int XcoordStart = 5;
const int YcoordStart = 5;
const int EntryLinkLength = 250;
const int ExitLinkLength = 500;
const int IntersectionX = 6;
const int IntersectionY = 6;
const int LongLinkLength = 1000;
const int ShortLinkLength = LongLinkLength / 2 - 2 * IntersectionX;
const float GradePct_Left = 0;
const float GradePct_Right = 0;
const float GradePct_Down = 0;
const float GradePct_DownLeft = 0;
const float GradePct_DownRight = 0;
const float FlowSpeed = 51.3f; //35 mi/h * 1.467
List <float> EnteringPctTrucks = new List <float> {
100, 0, 0, 0, 0
};
List <float> EnteringDriverTypePcts = new List <float> {
5, 8, 10, 12, 15, 15, 12, 10, 8, 5
};
float[] MinEntryHeadway = new float[] { 2.0f, 2.5f, 3.0f, 3.5f };
bool UsePctTurnsByFleet = true;
float[] TurningPcts = new float[3];
List <float[]> PctTurnsAtLinkEnd = new List <float[]>();
// connector node
network.NumNodes++;
LinkConnectorNode NewConnectorNode = new LinkConnectorNode(1, NodeType.LinkConnector, 0, XcoordStart + EntryLinkLength, YcoordStart);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(2, NodeType.LinkConnector, 1, XcoordStart + EntryLinkLength + 2 * IntersectionX, YcoordStart);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(3, NodeType.LinkConnector, 2, XcoordStart + EntryLinkLength + 2 * IntersectionX + LongLinkLength, YcoordStart);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(4, NodeType.LinkConnector, 3, XcoordStart + EntryLinkLength + 2 * IntersectionX + LongLinkLength + 2 * IntersectionX, YcoordStart - IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(5, NodeType.LinkConnector, 4, XcoordStart + EntryLinkLength + 2 * IntersectionX + LongLinkLength + 2 * IntersectionX + LongLinkLength, YcoordStart - IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(6, NodeType.LinkConnector, 5, XcoordStart + EntryLinkLength + IntersectionX, YcoordStart + 2 * IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(7, NodeType.LinkConnector, 6, XcoordStart + EntryLinkLength + IntersectionX + LongLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(8, NodeType.LinkConnector, 7, XcoordStart + EntryLinkLength + IntersectionX + LongLinkLength + 2 * IntersectionX + LongLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(9, NodeType.LinkConnector, 8, XcoordStart + EntryLinkLength + IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(10, NodeType.LinkConnector, 9, XcoordStart + EntryLinkLength + IntersectionX + LongLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(11, NodeType.LinkConnector, 10, XcoordStart + EntryLinkLength + IntersectionX + LongLinkLength + 2 * IntersectionX + LongLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(12, NodeType.LinkConnector, 11, XcoordStart + EntryLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(13, NodeType.LinkConnector, 12, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(14, NodeType.LinkConnector, 13, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 4 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(15, NodeType.LinkConnector, 14, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 4 * IntersectionX + ShortLinkLength, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(16, NodeType.LinkConnector, 15, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 4 * IntersectionX + ShortLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(17, NodeType.LinkConnector, 16, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 4 * IntersectionX + ShortLinkLength + 2 * IntersectionX + LongLinkLength, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(18, NodeType.LinkConnector, 17, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY + IntersectionY);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// connector node
network.NumNodes++;
NewConnectorNode = new LinkConnectorNode(19, NodeType.LinkConnector, 18, XcoordStart + EntryLinkLength / 2, YcoordStart);
nodes.Add(NewConnectorNode);
network.NodeIdList.Add(NewConnectorNode.Id);
// entry node
network.NumNodes++;
EntryNode NewEntryNode = new EntryNode(701, NodeType.Entry, 19, XcoordStart, YcoordStart, 70119, 1, MinEntryHeadway, 400, 400, EnteringPctTrucks, EnteringDriverTypePcts, false, 100, FlowSpeed);
nodes.Add(NewEntryNode);
network.NodeIdList.Add(NewEntryNode.Id);
// exit node
network.NumNodes++;
ExitNode NewExitNode = new ExitNode(801, NodeType.Exit, 20, XcoordStart + EntryLinkLength + 2 * IntersectionX + ShortLinkLength + 2 * IntersectionX, YcoordStart + 2 * IntersectionY + LongLinkLength + IntersectionY + IntersectionY + ExitLinkLength);
nodes.Add(NewExitNode);
network.NodeIdList.Add(NewExitNode.Id);
// link 1->2
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
LinkData NewLink = new LinkData(0, nodes[0], nodes[1], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 2, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 191, 0, 0, 23, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[1].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[1].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 2, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[1].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 2, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 2->3
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 67, 33 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(1, nodes[1], nodes[2], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 2, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 12, 0, 0, 34, 37, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[1].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[1].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 2, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[1].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[0].Type = LaneType.AuxFull;
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 3->4
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(2, nodes[2], nodes[3], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 23, 0, 0, 45, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 4->5
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 0, 100 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(3, nodes[3], nodes[4], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 34, 0, 0, 0, 58, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 0, 1);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 1->6
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(4, nodes[0], nodes[5], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownRight, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 191, 0, 69, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[0].PositionX, nodes[0].PositionY + 6, nodes[0].PositionX + 6, nodes[0].PositionY + 6, nodes[0].PositionX + 6, nodes[0].PositionY + 12);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 3->7
network.NumLinks++;
NewLink = new LinkData(5, nodes[2], nodes[6], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownRight, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 23, 0, 710, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[2].PositionX, nodes[2].PositionY + 6, nodes[2].PositionX + 6, nodes[2].PositionY + 6, nodes[2].PositionX + 6, nodes[2].PositionY + 12);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 5->8
network.NumLinks++;
NewLink = new LinkData(6, nodes[4], nodes[7], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownRight, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 45, 0, 811, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[4].PositionX, nodes[4].PositionY, nodes[4].PositionX + 6, nodes[4].PositionY, nodes[4].PositionX + 6, nodes[4].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 6->9
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 100, 0, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(7, nodes[5], nodes[8], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Down, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 16, 0, 912, 0, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Left);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(1, 0, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 7->10
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 0, 100 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(8, nodes[6], nodes[9], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Down, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 37, 0, 0, 0, 1015, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 0, 1);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 8->11
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 0, 100 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(9, nodes[7], nodes[10], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Down, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 58, 0, 0, 0, 1117, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 0, 1);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 9->12
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 100, 0, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(10, nodes[8], nodes[11], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownRight, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 69, 0, 0, 0, 1213, 0, TravelDirection.LeftTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[8].PositionX, nodes[8].PositionY, nodes[8].PositionX, nodes[8].PositionY + 6, nodes[8].PositionX + 6, nodes[8].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 10->15
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(11, nodes[9], nodes[14], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownLeft, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 710, 0, 1514, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[9].PositionX, nodes[9].PositionY, nodes[9].PositionX, nodes[9].PositionY + 6, nodes[9].PositionX - 6, nodes[9].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 11->17
network.NumLinks++;
NewLink = new LinkData(12, nodes[10], nodes[16], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownLeft, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 811, 0, 0, 0, 1716, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[10].PositionX, nodes[10].PositionY, nodes[10].PositionX, nodes[10].PositionY + 6, nodes[10].PositionX - 6, nodes[10].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 12->13
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 0, 100 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(13, nodes[11], nodes[12], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 912, 0, 0, 0, 0, 1318, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 0, 1);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 15->14
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 100, 0, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(14, nodes[14], nodes[13], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Left, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 1615, 1015, 1418, 0, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Left);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(1, 0, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 16->15
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(15, nodes[15], nodes[14], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Left, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 1716, 0, 0, 1514, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 17->16
network.NumLinks++;
NewLink = new LinkData(16, nodes[16], nodes[15], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Left, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 1117, 0, 1615, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 13->18
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 0, 100 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(17, nodes[12], nodes[17], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_DownRight, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 1213, 0, 18801, 0, TravelDirection.RightTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[12].PositionX, nodes[12].PositionY, nodes[12].PositionX + 6, nodes[12].PositionY, nodes[12].PositionX + 6, nodes[12].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 14->18
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 100, 0, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(18, nodes[13], nodes[17], LinkType.ArterialConnector, LinkCurveType.Bezier, GradePct_Left, FlowSpeed, 1, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 1514, 0, 0, 0, 18801, 0, TravelDirection.LeftTurn, FreeFlowSpeedMethod.Measured, TwoLaneLinkPassingDesignation.NotAllowed, TwoLaneLinkPassingRule.None, nodes[13].PositionX, nodes[13].PositionY, nodes[13].PositionX - 6, nodes[13].PositionY, nodes[13].PositionX - 6, nodes[13].PositionY + 6);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 2, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// link 19->1
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 50, 50 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(19, nodes[18], nodes[0], LinkType.ArterialConnector, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 2, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 70119, 0, 0, 12, 16, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Right);
NewLink.Lanes[1].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[1].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 2, 0);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 1);
NewLink.Lanes[1].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 2, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// entry link
PctTurnsAtLinkEnd = new List <float[]>();
for (int k = 0; k <= 4; k++)
{
TurningPcts = new float[] { 0, 100, 0 };
PctTurnsAtLinkEnd.Add(TurningPcts);
}
network.NumLinks++;
NewLink = new LinkData(20, nodes[19], nodes[18], LinkType.ArterialEntry, LinkCurveType.Linear, GradePct_Right, FlowSpeed, 2, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 0, 0, 0, 0, 191, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[1].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 1, 0);
NewLink.Lanes[1].ConnectingLaneIdsDownstream = LaneData.SetConnectingLaneIds(0, 2, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
// exit link
network.NumLinks++;
NewLink = new LinkData(21, nodes[17], nodes[20], LinkType.ArterialExit, LinkCurveType.Linear, 0, FlowSpeed, 2, UsePctTurnsByFleet, PctTurnsAtLinkEnd, 1318, 0, 1418, 0, 0, 0, TravelDirection.Straight);
NewLink.Lanes[0].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[1].AllowedTurnMovements.Add(MovementDirectionCode.Through);
NewLink.Lanes[0].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(0, 0, 1);
NewLink.Lanes[1].ConnectingLaneIdsUpstream = LaneData.SetConnectingLaneIds(1, 0, 0);
links.Add(NewLink);
network.LinkIdList.Add(NewLink.Id);
}
public static bool IsSpeedLane(this LaneData lane) => lane.LaneInfo.m_laneType.IsFlagSet(SpeedLimitManager.LANE_TYPES) && lane.LaneInfo.m_vehicleType.IsFlagSet(SpeedLimitManager.VEHICLE_TYPES);
internal static void RenderOverlay(RenderManager.CameraInfo cameraInfo)
{
//Log.DebugWait($"Managers_RenderOverlay.Postfix(): LaneIndex={LaneIndex} Info={Info}");
if (HoveredInfo is NetInfo.Lane laneInfo)
{
for (ushort segmentID = 1; segmentID < NetManager.MAX_SEGMENT_COUNT; ++segmentID)
{
if (!NetUtil.IsSegmentValid(segmentID))
{
continue;
}
var m_lanes = segmentID.ToSegment().Info.m_lanes;
int laneIndex = m_lanes.IndexOf(laneInfo);
if (laneIndex < 0)
{
continue;
}
uint laneID = NetUtil.GetlaneID(segmentID, laneIndex);
LaneData lane = new LaneData(laneID, laneIndex);
RenderUtil.RenderLaneOverlay(cameraInfo, lane, Color.yellow);
}
}
while (SegmentQueue.Count > 0)
{
var item = SegmentQueue.Dequeue();
Color color = item.TurnAround ? ORANGE : Color.yellow;
RenderUtil.RenderSegmnetOverlay(cameraInfo, item.SegmentID, color);
}
while (NodeQueue.Count > 0)
{
var item = NodeQueue.Dequeue();
bool end = item.NodeID.ToNode().m_flags.IsFlagSet(NetNode.Flags.End);
if (item.IsBendNode || end)
{
RenderUtil.DrawNodeCircle(cameraInfo, Color.yellow, item.NodeID);
}
else if (item.IsDC)
{
DrawDC(cameraInfo, item.SegmentID, item.SegmentID2, item.NodeID);
}
else
{
HighlightSegmentEnd(cameraInfo, item.SegmentID, item.NodeID, Color.yellow);
}
}
while (PropQueue.Count > 0)
{
var item = PropQueue.Dequeue();
PropTool.RenderOverlay(
cameraInfo, item.Prop, item.Pos, item.Scale, item.Angle, Color.yellow);
}
while (TreeQueue.Count > 0)
{
var item = TreeQueue.Dequeue();
TreeTool.RenderOverlay(cameraInfo, item.Tree, item.Pos, item.Scale, Color.yellow);
}
}
public LaneMarkerPoint(LaneData laneData1, LaneData laneData2, bool start)
{
ref NetLane lane1 = ref laneData1.LaneID.ToLane();
private LaneData GetBeforeLane(LaneData lane)
{
var index = -1;
for(var i = 0; i < mLanes.Length; i++)
{
if(mLanes[i] == lane)
{
index = i;
break;
}
}
if(index == -1)
{
return null;
}
return mLanes[index];
}
public static IntersectionData NewIntersection(List <TimerData> Timers, int numThruLanes, AnalysisMode ProjectAnalMode, int crossStreetWidth)
{
List <ApproachData> newApproaches = new List <ApproachData>();
List <LaneGroupData> newLaneGroups = new List <LaneGroupData>();
List <LaneData> newLanes;
List <SignalPhaseData> Phases = new List <SignalPhaseData>();
// Intersection Signal Data
//Example problem specifies permitted left turn for NB LT. Use protected until permitted delay calculations are implemented.
SignalPhaseData WBLSignalPhase = new SignalPhaseData(nemaPhaseId: 1, nemaMvmtId: NemaMovementNumbers.WBLeft, phaseType: PhasingType.Protected, greenTime: 20, yellowTime: 3, allRedTime: 1, startUpLostTime: 2, timer: Timers[0]);
SignalPhaseData EBLSignalPhase = new SignalPhaseData(5, NemaMovementNumbers.EBLeft, PhasingType.Protected, 20, 3, 1, 2, Timers[1]);
SignalPhaseData EBTSignalPhase = new SignalPhaseData(2, NemaMovementNumbers.EBThru, PhasingType.Protected, 45, 3, 1, 2, Timers[2]);
SignalPhaseData WBTSignalPhase = new SignalPhaseData(6, NemaMovementNumbers.WBThru, PhasingType.Protected, 45, 3, 1, 2, Timers[3]);
SignalPhaseData NBLSignalPhase = new SignalPhaseData(3, NemaMovementNumbers.NBLeft, PhasingType.Protected, 8, 3, 1, 2, Timers[4]);
SignalPhaseData SBLSignalPhase = new SignalPhaseData(7, NemaMovementNumbers.SBLeft, PhasingType.Protected, 8, 3, 1, 2, Timers[5]);
SignalPhaseData SBTSignalPhase = new SignalPhaseData(4, NemaMovementNumbers.SBThru, PhasingType.Protected, 35, 3, 1, 2, Timers[6]);
SignalPhaseData NBTSignalPhase = new SignalPhaseData(8, NemaMovementNumbers.NBThru, PhasingType.Protected, 35, 3, 1, 2, Timers[7]);
Phases.Add(WBLSignalPhase);
Phases.Add(EBTSignalPhase);
Phases.Add(NBLSignalPhase);
Phases.Add(SBTSignalPhase);
Phases.Add(EBLSignalPhase);
Phases.Add(WBTSignalPhase);
Phases.Add(SBLSignalPhase);
Phases.Add(NBTSignalPhase);
LaneData[] numLeftLanes = new LaneData[1];
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "NB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.NBThru, TravelDirection.Northbound, newLanes, NBTSignalPhase, arvType: 3));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "NB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.NBLeft, TravelDirection.Northbound, newLanes, NBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(1, TravelDirection.Northbound, "NB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "EB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.EBThru, TravelDirection.Eastbound, newLanes, EBTSignalPhase, arvType: 4));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "EB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.EBLeft, TravelDirection.Eastbound, newLanes, EBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(2, TravelDirection.Eastbound, "EB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "SB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.SBThru, TravelDirection.Southbound, newLanes, SBTSignalPhase, arvType: 3));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "SB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.SBLeft, TravelDirection.Southbound, newLanes, SBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(3, TravelDirection.Southbound, "SB", 0, newLaneGroups));
newLaneGroups = new List <LaneGroupData>();
newLanes = CreateLanes(numThruLanes, 0);
newLaneGroups.Add(new LaneGroupData(1, "WB Thru+Right", LaneMovementsAllowed.ThruRightShared, NemaMovementNumbers.WBThru, TravelDirection.Westbound, newLanes, WBTSignalPhase, arvType: 4));
newLanes = CreateLanes(numThruLanes, numThruLanes);
newLaneGroups.Add(new LaneGroupData(2, "WB Left", LaneMovementsAllowed.LeftOnly, NemaMovementNumbers.WBLeft, TravelDirection.Westbound, newLanes, WBLSignalPhase, arvType: 3));
newApproaches.Add(new ApproachData(4, TravelDirection.Westbound, "WB", 0, newLaneGroups));
SignalCycleData newSignalData = new SignalCycleData(SigControlType.Pretimed, 124, Phases);
IntersectionData newIntersection = new IntersectionData(1, AreaType.LargeUrbanized, ArterialClass.ClassI, newApproaches, newSignalData, ProjectAnalMode, crossStreetWidth);
return(newIntersection);
}
