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; }