private void SnapToNearestRailPoint()
{
List <(RailNode, RailNode)> currentRails = RailManager.GetRails();
if (currentRails == null)
{
return;
}
float distanceRecord = Vector3.Distance(currentRails[0].Item1.transform.position, this.transform.position);
RailNode closestRail = currentRails[0].Item1;
foreach ((RailNode, RailNode)rail in currentRails)
{
if (Vector3.Distance(rail.Item1.transform.position, this.transform.position) < distanceRecord)
{
closestRail = rail.Item1;
}
if (Vector3.Distance(rail.Item2.transform.position, this.transform.position) < distanceRecord)
{
closestRail = rail.Item2;
}
}
if (closestRail == null)
{
return;
}
//this.transform.position = closestRail.transform.position;
this.currentNearestRailPoint = closestRail;
}
// Update is called once per frame
void Update()
{
if (_reachedEnd)
{
return;
}
_realSpeed = Mathf.MoveTowards(_realSpeed, Speed, Acceleration * Time.deltaTime);
if (_realSpeed != 0)
{
_railProgress += Time.deltaTime * _realSpeed;
while (_railProgress > 1.0f)
{
_railProgress -= 1;
_previousNode = _currentNode;
_currentNode = _currentNode.NextNode;
if (_currentNode == null || _currentNode.NextNode == null || _currentNode.NextNode.NextNode == null)
{
_reachedEnd = true;
return;
}
}
_lastRailPosition = Position;
Position = GetPosition(_previousNode, _railProgress, Tau);
Direction = (Position - _lastRailPosition).normalized;
}
}
public override void Start()
{
base.Start();
RailManager rm = GameManager.Instance.RailManager;
int index = Random.Range(0, RailManager.NumRails);
// List<int> availableRails = Enumerable.Range(0, 3).ToList();
ConnectToRail(rm.GetRail(index));
for (int i = 0; i < AttachedRail.RailSegmentPositions.Count - 1; i++)
{
var screenPos = mainCamera.Camera.WorldToViewportPoint(AttachedRail.RailSegmentPositions[i + 1]);
if (screenPos.x > 0 && screenPos.y > 0 && screenPos.x < 1 && screenPos.y < 1)
{
RailIndex = AttachedRail.FindIndex(AttachedRail.RailSegmentPositions[i]);
break;
}
}
RailNode nextPosition = AttachedRail.GetTargetRailNode(RailIndex);
transform.position = nextPosition.Position;
if (!nextPosition.Valid)
{
StartFreeMovement();
}
else
{
target = nextPosition;
}
child = transform.GetChild(0);
}
public RailEdge NewInstance(RailNode from, RailNode to, bool isOutbound)
{
var obj = Instantiate(template);
obj.isTemplate = false;
obj.IsOutbound = isOutbound;
obj.From = from;
obj.To = to;
from.OutEdge.Add(obj);
to.InEdge.Add(obj);
obj.Arrow = to.transform.position - from.transform.position;
obj.transform.position = Vector3.Lerp(from.transform.position, to.transform.position, 0.5f);
if (IsView)
{
obj.GetComponent <MeshRenderer>().enabled = true;
obj.GetComponent <MeshRenderer>().material.color = (isOutbound) ? Color.black : Color.gray;
obj.transform.localScale = new Vector3(0.02f, obj.Arrow.magnitude / 2, 0.02f);
obj.transform.localRotation = Quaternion.Euler(0f, 0f, Vector3.SignedAngle(Vector3.up, obj.Arrow, Vector3.forward));
}
obj.ForwardPart = factory.NewRailPart(obj, true);
obj.BackPart = factory.NewRailPart(obj, false);
listener.Fire(EventType.CREATED, obj);
List <RailEdge>[] adj = { from.InEdge, from.OutEdge, to.InEdge, to.OutEdge };
Array.ForEach(adj, list => list
.FindAll(re => re != this)
.ForEach(re => listener.Fire(EventType.MODIFIED, re)));
return(obj);
}
public void StartRail(Vector3 pos)
{
var action = new StartRailAction(factory, TailNode, (prev) => { TailNode = prev; });
TailNode = action.Act(pos);
Actions.AddLast(action);
}
public float ExtendRail(Vector3 pos)
{
var action = new ExtendRailAction(TailNode, (prev) => { TailNode = prev; });
TailEdge = action.Act(pos);
TailNode = TailEdge.To;
Actions.AddLast(action);
return(Vector3.Magnitude(TailEdge.Arrow));
}
private void Awake()
{
OutEdge = new List <RailEdge>();
InEdge = new List <RailEdge>();
if (isTemplate)
{
template = this;
}
}
void DrawGizmoLineFromNodes(RailNode node0, RailNode node1, RailNode node2, RailNode node3)
{
Vector3 p0 = node0.transform.position;
Vector3 p1 = node1.transform.position;
Vector3 p2 = node2.transform.position;
Vector3 p3 = node3.transform.position;
DrawGizmoLineFromPoints(p0, p1, p2, p3, SegmentResolution);
}
private Vector3 GetPosition(RailNode startNode, float time, float tau)
{
// Start here:
// Need to check all nodes from startNode.NextNode... 3 nodes out are all non-null.
// If any of them is null, set position to....current position? That's the hacky way of doing it.
// It should be the position of startNode.NextNode.
return(MathExt.CatmullRom2(startNode.transform.position, startNode.NextNode.transform.position, startNode.NextNode.NextNode.transform.position, startNode.NextNode.NextNode.NextNode.transform.position, time, Tau));
}
private int GetTargetFromNodes(RailNode[] rnodes, Vector3 collisionPosition)
{
var sortedNodes = rnodes.OrderBy(n => Vector2.Distance(n.Position, collisionPosition)).ToList();
RailNode selectedNode = sortedNodes.Count > 1 && sortedNodes[1].index > sortedNodes[0].index ? sortedNodes[1] : sortedNodes[0];
var nodeIndex = nodes.LastIndexOf(selectedNode);
return(nodeIndex < 0 ? 0 : nodeIndex);
}
public void BuildStation()
{
var action = new BuildStationAction(TailNode, TailPlatform, (prevNode, prevPlatform) =>
{
TailNode = prevNode;
TailPlatform = prevPlatform;
});
TailPlatform = action.Act();
Actions.AddLast(action);
}
public void Init()
{
Rail middleRail = GameManager.Instance.RailManager.GetRail(1);
targetNode = middleRail.LastNode;
target1 = targetNode.Position + targetNode.Normal * maxDistance;
target2 = targetNode.Position - targetNode.Normal * maxDistance;
moveSpeed = Random.Range(18, 25);
moveSpeed *= Mathf.Sign(Random.value - 0.5f);
}
void DrawGizmoForAllNodes(RailNode node, Dictionary <RailNode, RailNode> visited)
{
if (node == null || visited.ContainsKey(node))
{
return;
}
visited.Add(node, node);
DrawGizmoLineForNode(node, visited);
DrawGizmoForAllNodes(node.SuccessorNode1, visited);
DrawGizmoForAllNodes(node.SuccessorNode2, visited);
}
public Platform NewInstance(RailNode on, Station st)
{
var obj = Instantiate(template);
obj.isTemplate = false;
obj.On = on;
on.StandsOver = obj;
obj.transform.position = on.transform.position;
obj.BelongsTo = st;
st.AddPlatform(obj);
obj.Depts = new LinkedList <DeptTask>();
obj.InQueue = new LinkedList <Human>();
obj.OutQueue = new LinkedList <Human>();
obj.router = new RouterImpl(obj);
listener.Fire(EventType.CREATED, obj);
return(obj);
}
public virtual void FreeMovement()
{
GravitySpeed = GravitySpeed + Gravity * Time.deltaTime;
if (Mathf.Abs(GravitySpeed) > 40f)
{
GravitySpeed = 40f * Mathf.Sign(Gravity);
}
RailNode camTarget = mainCamera.Anchor.target;
Vector2 direction = Utils.AngleToVector(mainCamera.Anchor.transform.localRotation.eulerAngles.z);
Vector2 normal = direction.Rotate(90);
Vector3 diff = direction * RailSpeed + normal * GravitySpeed + mainCamera.Anchor.LastDiff;
var newPosition = transform.position + diff * Time.deltaTime;
transform.position = newPosition;
}
public void SpawnRailWithRechargeMarker(float size, float spawnAngleDiff, int segIndex)
{
RailSegment r = CreateRailSegment(size, spawnAngleDiff, segIndex);
r.SetCorrupted(false);
OnRailRechargeMarker marker = OnRailRechargeMarker.Create();
marker.Init();
RailNode n = r.Nodes[r.Nodes.Length / 2];
marker.transform.position = new Vector3(n.Position.x, n.Position.y, -1f);
marker.transform.localRotation = Quaternion.Euler(0, 0, Utils.VectorToAngle(n.Direction));
marker.AttachedRailSegment = r;
r.RechargeMarker = marker;
previousRailSegment = r;
}
// Use this for initialization
void Start()
{
Asserter.NotNull(StartNode, "RailCrawler.Start:StartNode is null");
Asserter.NotNull(StartNode.NextNode, "RailCrawler.Start:StartNode.NextNode is null");
Asserter.NotNull(StartNode.NextNode.NextNode, "RailCrawler.Start:StartNode.NextNode.NextNode is null");
Asserter.NotNull(StartNode.NextNode.NextNode.NextNode, "RailCrawler.StartNode.NextNode.NextNode.NextNode is null");
_previousNode = StartNode;
_currentNode = StartNode.NextNode;
_lastRailPosition = StartNode.transform.position;
Vector3 startingPoint = GetPosition(_previousNode, 0, Tau);
Vector3 nextPoint = GetPosition(_previousNode, 0.0166667f, Tau);
Direction = (nextPoint - startingPoint).normalized;
Position = startingPoint;
}
public override void SetTarget()
{
RailNode nextPosition = AttachedRail.GetTargetRailNode(RailIndex);
target = nextPosition;
var dist = Vector2.Distance(transform.position, target.Position);
var angle = Vector2.SignedAngle(transform.position - target.Position, target.Direction) * Mathf.Deg2Rad;
distanceToTarget = dist * Mathf.Abs(Mathf.Cos(angle));
distanceToCenter = dist * Mathf.Sin(angle);
targetRotation = target.Direction;
while (target.SegmentIndex > this.segmentIndex)
{
segmentIndex++;
GameManager.Instance.RailManager.AddRail();
}
}
public virtual void SetTarget()
{
RailNode nextPosition = AttachedRail.GetTargetRailNode(RailIndex);
if (nextPosition.Valid)
{
target = nextPosition;
var dist = Vector2.Distance(transform.position, target.Position);
var angle = Vector2.SignedAngle(transform.position - target.Position, target.Direction) * Mathf.Deg2Rad;
distanceToTarget = dist * -Mathf.Cos(angle);
distanceToCenter = dist * Mathf.Sin(angle);
}
else
{
OverranRail();
}
}
public TestUtils()
{
storage = new GameObject().AddComponent <ModelStorage>();
listener = new GameObject().AddComponent <ModelListener>();
factory = new GameObject().AddComponent <ModelFactory>();
var co = new GameObject();
co.AddComponent <SpriteRenderer>();
factory.c = c = co.AddComponent <Company>();
var ro = new GameObject();
ro.AddComponent <SpriteRenderer>();
factory.r = r = ro.AddComponent <Residence>();
factory.rn = rn = new GameObject().AddComponent <RailNode>();
factory.re = re = new GameObject().AddComponent <RailEdge>();
var rpo = new GameObject();
rpo.AddComponent <MeshRenderer>();
factory.rp = rp = rpo.AddComponent <RailPart>();
var sto = new GameObject();
sto.AddComponent <SpriteRenderer>();
factory.st = st = sto.AddComponent <Station>();
factory.p = p = new GameObject().AddComponent <Platform>();
factory.g = g = new GameObject().AddComponent <Gate>();
var to = new GameObject();
to.AddComponent <SpriteRenderer>();
factory.t = t = to.AddComponent <Train>();
var ho = new GameObject();
ho.AddComponent <SpriteRenderer>();
factory.h = h = ho.AddComponent <Human>();
var ureso = new GameObject();
ures = ureso.AddComponent <UserResource>();
var transo = new GameObject();
trans = transo.AddComponent <Transport>();
var routeo = new GameObject();
route = routeo.AddComponent <Route>();
route.trans = trans;
c.listener = r.listener = rn.listener = re.listener = rp.listener = st.listener = p.listener = g.listener = t.listener = h.listener = ures.listener = trans.listener = route.listener = listener;
c.storage = r.storage = rn.storage = re.storage = rp.storage = st.storage = p.storage = g.storage = t.storage = h.storage = ures.storage = trans.storage = route.storage = storage;
r.factory = rn.factory = re.factory = st.factory = ures.factory = factory;
t.resource = trans.resource = route.resource = ures;
}
public ExtendRailAction(RailNode prev, RollbackFn fn)
{
prevTail = prev;
rollback = fn;
}
public Platform Act(RailNode rn)
{
platform = rn.BuildStation();
return(platform);
}
public BuildStationAction(RailNode tail, Platform tailP, RollbackFn fn)
{
prevTail = tail;
prevPlatform = tailP;
rollback = fn;
}
public RailNode[] CalculateNodes(float size, float spawnAngleDiff, Vector3 lastRailSpawnPosition, Vector3 currentPosition, bool corrupted, int segIndex)
{
SegmentIndex = segIndex;
float totalDistance = Vector3.Distance(lastRailSpawnPosition, currentPosition);
float distFactor = (totalDistance / size);
ModifiedNumNodes = (int)(NumNodes * distFactor);
Nodes = new RailNode[ModifiedNumNodes - 1];
Vector2[] pcPoints = new Vector2[ModifiedNumNodes * 2];
Vector3[] positions = new Vector3[ModifiedNumNodes];
Vector3[] vertices = new Vector3[ModifiedNumNodes * 2];
RailNode lastNode = parentRail?.LastNode;
bool lastNodeValid = lastNode != null;
Vector2 lastPosition = lastRailSpawnPosition;
Vector2 pivot;
if (lastNodeValid)
{
pivot = lastRailSpawnPosition + lastNode.Direction * totalDistance;
}
else
{
Vector2 center = (currentPosition + lastRailSpawnPosition) / 2f;
Vector2 overallNormal = ((Vector2)(currentPosition - lastRailSpawnPosition).normalized).Rotate(90);
pivot = center + overallNormal * distFactor * -Mathf.Pow(spawnAngleDiff / 25f, 3);
}
for (int i = 0; i < ModifiedNumNodes; i++)
{
Vector2 rd, normal, newPosition;
float pct = i / ((float)(ModifiedNumNodes - 1));
if (lastNodeValid)
{
newPosition = Vector2.Lerp(lastRailSpawnPosition, currentPosition, pct) * pct +
Vector2.Lerp(lastRailSpawnPosition, pivot, pct) * (1 - pct);
}
else
{
newPosition = Utils.QuadraticBezier(lastRailSpawnPosition, currentPosition, pivot, pct);
}
positions[i] = newPosition;
if (i > 0)
{
rd = (newPosition - lastPosition).normalized;
normal = rd.Rotate(90);
Nodes[i - 1] = new RailNode(segIndex, i, newPosition, rd, normal, corrupted, true);
}
else
{
if (lastNodeValid)
{
rd = lastNode.Direction;
normal = lastNode.Normal;
}
else
{
var nextPosition = Utils.QuadraticBezier(lastRailSpawnPosition, currentPosition, pivot, pct + (1 / ((float)ModifiedNumNodes - 1)));
rd = (nextPosition - newPosition).normalized;
normal = rd.Rotate(90);
}
}
vertices[i] = newPosition + normal * Width;
vertices[i + ModifiedNumNodes] = newPosition - normal * Width;
pcPoints[i] = newPosition + normal * Width * 0.6f;
pcPoints[pcPoints.Length - (i + 1)] = newPosition - normal * Width * 0.6f;
//Debug.DrawRay(newPosition, rd/2f, Color.green, 2);
//Debug.DrawRay(newPosition, normal, Color.cyan, 2);
lastPosition = newPosition;
}
pc.points = pcPoints;
Mesh m = new Mesh();
m.vertices = vertices;
//m.uv =
List <int> tris = new List <int>();
for (int i = 0; i < ModifiedNumNodes - 1; i++)
{
tris.AddRange(new int [] {
i, i + 1, i + ModifiedNumNodes,
i + ModifiedNumNodes + 1, i + ModifiedNumNodes, i + 1
});
}
m.triangles = tris.ToArray();
m.RecalculateNormals();
mf.sharedMesh = m;
return(Nodes);
}
public RailNode Act(Vector3 pos)
{
rn = factory.NewRailNode(pos);
return(rn);
}
public StartRailAction(ModelFactory f, RailNode prev, RollbackFn fn)
{
factory = f;
prevTail = prev;
rollback = fn;
}
void DrawGizmoLineForNode(RailNode node, Dictionary <RailNode, RailNode> visited)
{
// Draw the 8 possible iterations of this path given alt routes which are:
// Main Main Main Main
// Main Main Main Alt
// Main Main Alt Main
// Main Main Alt Alt
// Main Alt Main Main
// Main Alt Main Alt
// Main Alt Alt Main
// Main Alt Alt Alt
if (node == null)
{
return;
}
RailNode node1, node2, node3;
node1 = node.SuccessorNode1;
if (node1 != null)
{
node2 = node1.SuccessorNode1;
if (node2 != null)
{
node3 = node2.SuccessorNode1;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
node3 = node2.SuccessorNode2;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
}
node2 = node1.SuccessorNode2;
if (node2 != null)
{
node3 = node2.SuccessorNode1;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
node3 = node2.SuccessorNode2;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
}
}
node1 = node.SuccessorNode2;
if (node1 != null)
{
node2 = node1.SuccessorNode1;
if (node2 != null)
{
node3 = node2.SuccessorNode1;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
node3 = node2.SuccessorNode2;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
}
node2 = node1.SuccessorNode2;
if (node2 != null)
{
node3 = node2.SuccessorNode1;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
node3 = node2.SuccessorNode2;
if (node3 != null)
{
DrawGizmoLineFromNodes(node, node1, node2, node3);
}
}
}
}
public RailEdge NewRailEdge(RailNode from, RailNode to, bool isOutbound)
{
return(re.NewInstance(from, to, isOutbound));
}
public Platform NewPlatform(RailNode on, Station s)
{
return(p.NewInstance(on, s));
}
public void SetNearestRailNode(RailNode newNearestNode)
{
this.switchedToEndpoint = true;
this.currentNearestRailPoint = newNearestNode;
}
