public override void Awake()
{
base.Awake();
width = WIDTH + PAD * 2;
var panel = AddSubPanel();
panel.width = WIDTH;
var name = panel.AddUIComponent <MenuTextField>();
name.width = WIDTH;
var summary = panel.AddUIComponent <SummaryLabel>();
summary.autoSize = true;
summary.wordWrap = false;
summary.minimumSize = Vector2.zero;
summary.maximumSize = new Vector2(1000, 1000);
name.eventTextChanged += (_, __) => RefreshSummary();
RefreshSummary();
void RefreshSummary()
{
if (name.text.IsNullOrWhiteSpace())
{
summary.text = RoadUtils.GatherEditNames().JoinLines();
}
else
{
summary.text = RoadUtils.RenameEditNet(name.text, true).JoinLines();
}
}
var PanelBottom = AddBottomPanel(panel);
{
var apply = PanelBottom.AddUIComponent <MenuButton>();
apply.text = "Apply";
apply.eventClick += (_, __) => {
RoadUtils.RenameEditNet(name.text, false);
Destroy(this.gameObject);
};
void RefreshAppy() => apply.isEnabled = !name.text.IsNullOrWhiteSpace();
name.eventTextChanged += (_, __) => RefreshAppy();
RefreshAppy();
var close = PanelBottom.AddUIComponent <MenuButton>();
close.text = "Close";
close.eventClick += (_, __) => Destroy(this.gameObject);
}
AddDrag("Rename Road");
verticalSpacing = PAD;
FitChildrenVertically(PAD);
}
/**
* Parse data => call XML file parsing
*/
private List <RoadObject> ParseRoads(XmlNodeList nodeTags, List <long> nodeTagIds, XmlNodeList wayTags)
{
var isRoad = false;
var vehicleType = RoadUtils.VehicleUndefined;
var roadType = 0;
List <RoadObject> roads = new List <RoadObject>();
//find tags in 'way' tag
foreach (XmlNode wayTag in wayTags)
{
//node is 'nd' or 'tag' tags
for (var i = wayTag.ChildNodes.Count - 1; i >= 0; i--)
{
//<nd...> <tag....>
var node = wayTag.ChildNodes[i];
// attributes in 'k=' attribute
if (node.Name.Equals("tag"))
{
var nodeKeyValue = node.Attributes["k"].Value;
//remove tunnels
if (nodeKeyValue.Equals("tunnel"))
{
break;
}
//is object a road? and get its roadType
if (nodeKeyValue.Equals("highway") && node.Attributes["v"] != null)
{
roadType = RoadUtils.GetRoadType(node.Attributes["v"].Value);
isRoad = true;
vehicleType = RoadUtils.VehicleCar;
break;
}
//tram road
if (nodeKeyValue.Equals("railway") && node.Attributes["v"].Value.Equals("tram"))
{
isRoad = true;
vehicleType = RoadUtils.VehicleTram;
break;
}
}
}
if (isRoad)
{
roads.Add(GetCoordinatesById(nodeTags, nodeTagIds, wayTag, vehicleType, roadType));
//reset values for next iteration
isRoad = false;
vehicleType = RoadUtils.VehicleUndefined;
}
}
Debug.Log("Road count: " + roads.Count);
return(roads);
}
/// <summary>
/// Methode zum Erstellen einer CustomEasyRoad.
/// </summary>
/// <param name="car">Das Gameobject des Autos.</param>
/// <param name="road">Die Straße.</param>
/// <param name="minCars">Die Mindestanzahl von Autos auf dem Streckenpart.</param>
/// <param name="maxCars">Die Maximalanzahl von Autos auf dem Streckenpart.</param>
/// <param name="numberOfTracks">Die Anzahl der Spuren.</param>
public CustomEasyRoad(GameObject car, ERRoad road, int minCars, int maxCars, int numberOfTracks)
{
road.SetTag("Street");
this.Road = road;
this.CarsOnLanes = new List <Tuple <GameObject, int> >();
this.CarsPerLane = new Dictionary <int, List <GameObject> >();
for (int i = 0; i < numberOfTracks; i++)
{
List <GameObject> carsOnLane = new List <GameObject>();
CarsPerLane.Add(i, carsOnLane);
}
Vector3[] markers = road.GetSplinePointsCenter();
Vector3[] markersR = road.GetSplinePointsRightSide();
Vector3[] markersL = road.GetSplinePointsLeftSide();
int carCount = Random.Range(minCars, maxCars);
if (carCount > 0)
{
int increment = markers.Length / carCount;
Vector3 look = Vector3.zero;
GameObject newCar = null;
for (int i = 0; i < markers.Length; i += increment)
{
// Die Spur bestimmen
int lane = Random.Range(0, numberOfTracks);
Vector3[] directionMarkers = null;
// Die Richtung des Autos/Lane holen und setzen
if (lane < (numberOfTracks / 2))
{
directionMarkers = markersL;
look = (markers[Mathf.Max(0, i - 1)] - markers[Mathf.Min(markers.Length - 1, i + 1)]);
}
else
{
directionMarkers = markersR;
look = (markers[Mathf.Min(markers.Length - 1, i + 1)] - markers[Mathf.Max(0, i - 1)]);
}
// Den RoadSlerp holen
float roadSlerp = RoadUtils.GetRoadSlerpByLane(numberOfTracks, lane);
// Das Car mit der Richtung und der Spur spawnen
newCar = GameObject.Instantiate(car, Vector3.Slerp(markers[i], directionMarkers[i], roadSlerp) + new Vector3(0, 1, 0), Quaternion.LookRotation(look));
// Das Auto den Listen hinzufügen
this.AddToIndexOnLane(lane, newCar);
CarsOnLanes.Add(new Tuple <GameObject, int>(newCar, numberOfTracks - lane - 1));
}
}
}
public void Populate()
{
Clear();
foreach (string item in selectedItems)
{
AddItem(item, true);
}
foreach (string item in RoadUtils.GetRoadNames())
{
if (!selectedItems.Contains(item))
{
AddItem(item, false);
}
}
}
public static void WierdNodeTest()
{
for (uint i = 0; i < PrefabCollection <NetInfo> .LoadedCount(); ++i)
{
NetInfo info = PrefabCollection <NetInfo> .GetLoaded(i);
if (RoadUtils.IsNormalGroundRoad(info))
{
if (info.GetUncheckedLocalizedTitle() == R6L)
{
info = (info.m_netAI as RoadAI).m_elevatedInfo;
MakeSameNodeSegMat(info);
}
}
}
}
/**
* Create GameObject for road
*/
private void CreateRoadObject(List <RoadObject> roads, Vector3[] roadPointInXyz, int i)
{
var roadType = roads[i].RoadType;
var lineGameObject = new GameObject("road_" + i);
lineGameObject.transform.Rotate(Vector3.right, 90);
lineGameObject.transform.position = roadPointInXyz[0];
lineGameObject.AddComponent <LineRenderer>();
lineGameObject.AddComponent <PolygonCollider2D>();
var lineRenderer = lineGameObject.GetComponent <LineRenderer>();
lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
lineRenderer.startColor = ColorUtils.DefaultRoute;
lineRenderer.endColor = ColorUtils.DefaultRoute;
lineRenderer.alignment = LineAlignment.TransformZ;
lineRenderer.startWidth = RoadUtils.GetRoadWidth(roadType);
lineRenderer.endWidth = RoadUtils.GetRoadWidth(roadType);
lineRenderer.positionCount = roadPointInXyz.Length;
lineRenderer.SetPositions(roadPointInXyz);
}
/**
* Change road colors
*/
public void ChangeRoadColors(bool defaultColor)
{
for (var i = 0; i < Roads.Count; i++)
{
var roadGameObject = GameObject.Find("road_" + i);
var lineRenderer = roadGameObject.GetComponent <LineRenderer>();
Color roadColor;
if (!defaultColor)
{
roadColor = RoadUtils.GetRoadColor(Roads[i].RoadType);
lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
}
else
{
roadColor = ColorUtils.DefaultRoute;
lineRenderer.material = new Material(Shader.Find("Sprites/Default"));
}
lineRenderer.startColor = roadColor;
lineRenderer.endColor = roadColor;
}
}
public void Refresh()
{
if (points.Count < 2)
{
return;
}
transform.localScale = Vector3.one;
if (!gameObject.GetComponent <MeshFilter>())
{
gameObject.AddComponent <MeshFilter>();
}
else
{
if (gameObject.GetComponent <MeshFilter>().sharedMesh != null)
{
DestroyImmediate(gameObject.GetComponent <MeshFilter>().sharedMesh);
}
}
if (!gameObject.GetComponent <MeshRenderer>())
{
gameObject.AddComponent <MeshRenderer>();
}
List <Vector3> v = new List <Vector3>();
List <int> t = new List <int>();
// calculate angles for each line segment, then build out a plane for it
int tri_index = 0;
int segments = connectEnds ? points.Count : points.Count - 1;
theta = new float[segments];
for (int i = 0; i < segments; i++)
{
Vector2 a = points[i + 0].ToXZVector2();
Vector2 b = (connectEnds && i == segments - 1) ? points[0].ToXZVector2() : points[i + 1].ToXZVector2();
bool flip = (a.x > b.x); // ? theta[i] : -theta[i];
Vector3 rght = flip ? new Vector3(0, 0, -1) : new Vector3(0, 0, 1);
Vector3 lft = flip ? new Vector3(0, 0, 1) : new Vector3(0, 0, -1);
theta[i] = RoadMath.AngleRadian(a, b);
// seg a
v.Add(points[i] + rght * roadWidth);
v.Add(points[i] + lft * roadWidth);
// seg b
int u = (connectEnds && i == segments - 1) ? 0 : i + 1;
v.Add(points[u] + rght * roadWidth);
v.Add(points[u] + lft * roadWidth);
// apply angular rotation to points
int l = v.Count - 4;
v[l + 0] = v[l + 0].RotateAroundPoint(points[i + 0], -theta[i]);
v[l + 1] = v[l + 1].RotateAroundPoint(points[i + 0], -theta[i]);
v[l + 2] = v[l + 2].RotateAroundPoint(points[u], -theta[i]);
v[l + 3] = v[l + 3].RotateAroundPoint(points[u], -theta[i]);
t.AddRange(new int[6] {
tri_index + 2,
tri_index + 1,
tri_index + 0,
tri_index + 2,
tri_index + 3,
tri_index + 1
});
tri_index += 4;
}
// join edge vertices
if (points.Count > 2)
{
segments = connectEnds ? v.Count : v.Count - 4;
for (int i = 0; i < segments; i += 4)
{
int p4 = (connectEnds && i == segments - 4) ? 0 : i + 4;
int p5 = (connectEnds && i == segments - 4) ? 1 : i + 5;
int p6 = (connectEnds && i == segments - 4) ? 2 : i + 6;
int p7 = (connectEnds && i == segments - 4) ? 3 : i + 7;
Vector2 leftIntercept;
if (!RoadMath.InterceptPoint(
v[i + 0].ToXZVector2(), v[i + 2].ToXZVector2(),
v[p4].ToXZVector2(), v[p6].ToXZVector2(), out leftIntercept))
{
Debug.LogWarning("Parallel Lines!");
}
Vector2 rightIntercept;
if (!RoadMath.InterceptPoint(
v[i + 1].ToXZVector2(), v[i + 3].ToXZVector2(),
v[p5].ToXZVector2(), v[p7].ToXZVector2(), out rightIntercept))
{
Debug.LogWarning("Parallel lines!");
}
v[i + 2] = leftIntercept.ToVector3();
v[p4] = leftIntercept.ToVector3();
v[i + 3] = rightIntercept.ToVector3();
v[p5] = rightIntercept.ToVector3();
}
}
transform.position = Vector3.zero;
// // center pivot point and set height offset
Vector3 cen = v.Average();
Vector3 diff = cen - transform.position;
transform.position = cen;
for (int i = 0; i < v.Count; i++)
{
v[i] = RoadUtils.GroundHeight(v[i]) + new Vector3(0f, groundOffset, 0f);
v[i] -= diff;
}
Mesh m = new Mesh();
m.vertices = v.ToArray();
m.triangles = t.ToArray();
m.uv = CalculateUV(m.vertices);
m.RecalculateNormals();
gameObject.GetComponent <MeshFilter>().sharedMesh = m;
gameObject.GetComponent <MeshRenderer>().sharedMaterial = mat;
#if UNITY_EDITOR
Unwrapping.GenerateSecondaryUVSet(gameObject.GetComponent <MeshFilter>().sharedMesh);
#endif
}
public void OnSceneGUI()
{
if (road.acceptInput == false)
{
return;
}
Event e = Event.current;
if (e.type == EventType.ValidateCommand)
{
road.Refresh();
SceneView.RepaintAll();
}
if (e.isKey && (e.keyCode == KeyCode.Escape || e.keyCode == KeyCode.Return))
{
road.acceptInput = false;
SceneView.RepaintAll();
}
// Existing point handles
DrawHandleGUI(road.points);
// TODO -- figure out why Handles.PositionHandle is sooo slow when panning
if (!e.alt)
{
for (int i = 0; i < road.points.Count; i++)
{
tp = road.points[i];
road.points[i] = Handles.PositionHandle(road.points[i], Quaternion.identity);
if (tp != road.points[i])
{
Vector3 p = RoadUtils.GroundHeight(road.points[i]);
road.points[i] = p;
road.Refresh();
}
}
}
if (earlyOut)
{
return;
}
// New point placement from here down
int controlID = GUIUtility.GetControlID(FocusType.Passive);
HandleUtility.AddDefaultControl(controlID);
if (e.modifiers != 0 || Tools.current != Tool.Move)
{
if (e.type == EventType.MouseUp && e.button == 0 && Tools.current != Tool.Move && e.modifiers == 0)
{
FindSceneView().ShowNotification(new GUIContent("Tool must be set to 'Move' to place points!", ""));
SceneView.RepaintAll();
}
return;
}
if ((e.type == EventType.MouseDown || e.type == EventType.MouseDrag) && e.button == 0)
{
Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition);
RaycastHit ground = new RaycastHit();
if (Physics.Raycast(ray.origin, ray.direction, out ground))
{
groundPoint = ground.point;
}
}
// Listen for mouse input
if (e.type == EventType.MouseUp && e.button == 0)
{
Ray ray = HandleUtility.GUIPointToWorldRay(e.mousePosition);
RaycastHit ground = new RaycastHit();
if (Physics.Raycast(ray.origin, ray.direction, out ground))
{
groundPoint = ground.point;
AddPoint(groundPoint);
}
}
}
static bool Prefix(string name, ref string __result)
{
__result = RoadUtils.GetUniqueNetInfoName(name);
return(false);
}
