/**/ static bool AnyOffCurveSelected(Data.Segment segment) { return(Enumerable.Any(segment.OffCurves, point => point.IsSelected)); } static void BreakPathsSelection(Data.Layer layer) { var outPaths = new List <Data.Path>(); foreach (var path in Selection.FilterSelection(layer.Paths, invert: true)) { var segmentsList = new List <Data.Segment>(path.Segments); IEnumerable <Data.Segment> iter; if (!(path.IsOpen || AnyOffCurveSelected(segmentsList.First()) )) { int index; for (index = segmentsList.Count - 1; index >= 0; --index) { if (AnyOffCurveSelected(segmentsList[index])) { break; } } if (index <= 0) { // None selected, bring on the original path outPaths.Add(path); continue; } else { iter = Sequence.IterAt(segmentsList, index); } } else { iter = segmentsList; } Data.Path outPath = null; foreach (var segment in iter) { if (AnyOffCurveSelected(segment) || segment.OnCurve.Type == PointType.Move) { if (outPath != null) { outPaths.Add(outPath); } outPath = new Data.Path(); var point = segment.OnCurve.Clone(); point.IsSmooth = false; point.Type = PointType.Move; outPath.Points.Add(point); } else { outPath.Points.AddRange(segment.Points .Select(p => p.Clone()) .ToList()); } } outPaths.Add(outPath); } layer.Paths.Clear(); layer.Paths.AddRange(outPaths); } static void DeletePathsSelection(Data.Layer layer) { if (!TryMergeCurves(layer)) { var outPaths = new List <Data.Path>(); foreach (var path in layer.Paths) { var segments = path.Segments.ToList(); var forwardMove = false; for (int ix = segments.Count - 1; ix >= 0; --ix) { var segment = segments[ix]; var onCurve = segment.OnCurve; if (onCurve.IsSelected) { forwardMove = ix == 0 && onCurve.Type == PointType.Move; segment.Remove(nodeBias: true); } else if (AnyOffCurveSelected(segment)) { segment.ConvertTo(PointType.Line); } } if (path.Points.Count > 0) { if (forwardMove) { segments[0].ConvertTo(PointType.Move); } outPaths.Add(path); } } layer.Paths.Clear(); layer.Paths.AddRange(outPaths); } } static Vector2 SamplePoints(List <Vector2> samples, IList <Vector2> points, bool atStart) { var n = 20; // TODO: adaptive sample count var start = atStart ? 0 : 1; if (points.Count == 4) { for (int i = start; i < n; ++i) { samples.Add(BezierMath.Q(points, (float)i / (n - 1))); } } else { Debug.Assert(points.Count == 2); if (atStart) { samples.Add(points[0]); } samples.Add(points[1]); } return(Vector2.Normalize(atStart ? points[1] - points[0] : points[points.Count - 2] - points[points.Count - 1])); } static bool TryMergeCurves(Data.Layer layer) { var selection = layer.Selection; if (selection.Count == 1 && layer.Selection.First() is Data.Point point) { var path = point.Parent; var segments = path.Segments.ToList(); Data.Segment firstSegment = default; Data.Segment secondSegment = default; var segment = segments.Last(); foreach (var next in segments) { var onCurve = segment.OnCurve; if (onCurve.IsSelected) { if (!(path.IsOpen && path.Points.Last() == onCurve) && onCurve.Type == PointType.Curve || next.OnCurve.Type == PointType.Curve) { firstSegment = segment; secondSegment = next; } } segment = next; } if (!Equals(firstSegment, secondSegment)) { var samples = new List <Vector2>(); var leftTangent = SamplePoints(samples, firstSegment.PointsInclusive .Select(p => p.ToVector2()) .ToArray(), true); var rightTangent = SamplePoints(samples, secondSegment.PointsInclusive .Select(p => p.ToVector2()) .ToArray(), false); var fitPoints = BezierMath.FitCubic(samples, leftTangent, rightTangent, .01f); layer.ClearSelection(); var curveSegment = firstSegment; var otherSegment = secondSegment; if (curveSegment.OnCurve.Type != PointType.Curve) { (curveSegment, otherSegment) = (otherSegment, curveSegment); } var offCurves = curveSegment.OffCurves; offCurves[0].X = RoundToGrid(fitPoints[1].X); offCurves[0].Y = RoundToGrid(fitPoints[1].Y); offCurves[1].X = RoundToGrid(fitPoints[2].X); offCurves[1].Y = RoundToGrid(fitPoints[2].Y); var onCurve = firstSegment.OnCurve; onCurve.X = secondSegment.OnCurve.X; onCurve.Y = secondSegment.OnCurve.Y; curveSegment.OnCurve.IsSmooth = otherSegment.OnCurve.IsSmooth; otherSegment.Remove(); return(true); } } return(false); } /**/ static void ConstrainSmoothPoint(Data.Point p1, Data.Point p2, Data.Point p3, bool handleMovement) { if (p2.IsSelected) { if (p1.Type == PointType.None) { (p1, p3) = (p3, p1); } if (p1.Type != PointType.None) { VectorRotation(p3, p1.ToVector2(), p2.ToVector2()); } } else if (p1.IsSelected != p3.IsSelected) { if (p1.IsSelected) { (p1, p3) = (p3, p1); } if (p1.Type != PointType.None) { VectorProjection(p3, p1.ToVector2(), p2.ToVector2()); } else if (handleMovement) { VectorRotation(p1, p3.ToVector2(), p2.ToVector2()); } } }
static void InterpolateCurve(Data.Point on1, Data.Point off1, Data.Point off2, Data.Point on2, float dx, float dy) { if (on2.IsSelected != on1.IsSelected) { var sign = on1.IsSelected ? -1 : 1; var sdelta = new Vector2(sign * dx, sign * dy); var ondelta = on2.ToVector2() - on1.ToVector2(); var factor = ondelta - sdelta; if (factor.X != 0 && factor.Y != 0) { factor = ondelta / factor; } if (!off1.IsSelected) { off1.X = RoundToGrid(on1.X + factor.X * (off1.X - on1.X)); off1.Y = RoundToGrid(on1.Y + factor.Y * (off1.Y - on1.Y)); } if (!off2.IsSelected) { off2.X = RoundToGrid(on1.X + factor.X * (off2.X - on1.X - sdelta.X)); off2.Y = RoundToGrid(on1.Y + factor.Y * (off2.Y - on1.Y - sdelta.Y)); } } }
static bool IsFlatAngle(Data.Point p0, Data.Point p1, Data.Point p2, float tol = 0.05f) { var p01 = p1.ToVector2() - p0.ToVector2(); var p12 = p2.ToVector2() - p1.ToVector2(); return(Math.Abs(Ops.AngleBetween(p01, p12)) <= tol); }
/// <summary> /// Find the tiles that the players can see /// </summary> public void SpfaEye(Tile t, PlayerMove p) { int[,] dis = new int[Data.MapLen + 1, Data.MapWid + 1]; // the minimum moving distance between Tile t and Tile (i, j) bool[,] visited = new bool[Data.MapLen + 10, Data.MapWid + 10]; // if Tile (i, j) is in Queue q Queue <Data.Point> q = new Queue <Data.Point>(); // the queue used for Spfa algorithm for (int i = 1; i <= Data.MapLen; i++) { for (int j = 1; j <= Data.MapWid; j++) { dis[i, j] = Data.INF; // initialize distance to INFINITY at first visited[i, j] = false; // not in queue } } q.Clear(); // initialize queue dis[t.x, t.y] = 0; // t is the starting tile, distance = 0 q.Enqueue(new Data.Point(t.x, t.y)); // push the tile t into the queue for checking the tiles beside it visited[t.x, t.y] = true; // tile t is in the queue while (q.Count > 0) // queue not empty, updating required { Data.Point u = q.Dequeue(); // get top of the queue visited[u.x, u.y] = false; // point u no longer in queue for (int i = 0; i < 4; i++) // going thru the four tiles around point u { Data.Point v = new Data.Point(u.x + dirx[i], u.y + diry[i]); // calculate the row and column of the point if (ValidTileForMoving(u, v)) // point is valid { if (dis[u.x, u.y] + Data.eyecost[Data.MapType[v.x, v.y]] < dis[v.x, v.y]) // relaxation operation { dis[v.x, v.y] = dis[u.x, u.y] + Data.eyecost[Data.MapType[v.x, v.y]]; // refresh minimum distance if (!visited[v.x, v.y] && dis[v.x, v.y] <= p.maxEyeOfPlayer) // point v not in queue { Data.Point ppush = new Data.Point(v.x, v.y); // v in point form q.Enqueue(ppush); // add v into queue visited[v.x, v.y] = true; // record enqueue operation } } } } } for (int i = 1; i <= Data.MapLen; i++) { for (int j = 1; j <= Data.MapWid; j++) { Init.PointToTile(new Data.Point(i, j)).eyedis = dis[i, j]; if (dis[i, j] <= p.maxEyeOfPlayer) { GameObject tile = Init.PointToTile(new Data.Point(i, j)).gameObject; eyelist.Add(tile.GetComponent <Tile>()); tile.GetComponent <Tile>().insight = true; tile.GetComponent <Tile>().eyedis = dis[i, j]; } } } }
private void Update() { if (data == null || !data.IsReady) { return; } if (data.HasReadToEnd) { Debug.Log("Replay finished"); data = null; if (MousePointerSurrogate != null) { Destroy(MousePointerSurrogate); MousePointerSurrogate = null; } return; } if (timer.ElapsedMilliseconds > nextPoint.dt) { timer.Restart(); previousPoint = nextPoint; currentPoint = previousPoint; nextPoint = data.Next(); } else { currentPoint.MouseChange = false; } float posInterpolation = (float)timer.ElapsedMilliseconds / (float)nextPoint.dt; currentPoint.x = nextPoint.x * posInterpolation + previousPoint.x * (1.0f - posInterpolation); currentPoint.y = nextPoint.y * posInterpolation + previousPoint.y * (1.0f - posInterpolation); FakeTouch(); //Debug.Log(currentPoint.dt.ToString()+","+currentPoint.MouseDown.ToString()+",("+currentPoint.x.ToString("0.0")+","+currentPoint.y.ToString("0.0") +")"); //Debug.Log(currentPoint.dt.ToString()+","+currentPoint.MouseDown.ToString()+",("+currentPoint.x.ToString()+","+currentPoint.y.ToString()+")"); //Debug.Log(Input.mousePosition.ToString()); if (MousePointerSurrogate == null) { MousePointerSurrogate = GameObject.CreatePrimitive(PrimitiveType.Sphere); MousePointerSurrogate.transform.localScale = Vector3.one * 0.5f; } GameObject go = null; //if(currentPoint.MouseChange) // go = GameObject.CreatePrimitive(PrimitiveType.Cube); Vector2 tpos = Camera.main.ScreenToWorldPoint(new Vector3(Experiment.Input.mousePosition.x, Experiment.Input.mousePosition.y, Camera.main.nearClipPlane)); Vector2 rpos = Camera.main.ScreenToWorldPoint(new Vector3(currentPoint.x, currentPoint.y, Camera.main.nearClipPlane)); MousePointerSurrogate.transform.position = tpos; if (go != null) { go.transform.position = rpos; go.transform.localScale = Vector3.one * 0.4f; } }
/// <summary> /// Find the tiles that the players can see and the tiles that the players can move to. /// </summary> public void FindPath(PlayerMove p) { GetCurrentTile(p.gameObject); currentPoint = new Data.Point(currentTile.x, currentTile.y); SpfaEye(currentTile, p); SpfaMove(currentTile, p); p.pathChecked = true; }
public static bool AtOpenBoundary(Data.Point point) { var path = point.Parent; if (path.IsOpen) { return(path.Points[0] == point || path.Points[path.Points.Count - 1] == point); } return(false); }
public static bool TryJoinPath(Data.Layer layer, Data.Point point) { if (Is.AtOpenBoundary(point) && layer.Paths .SelectMany(path => path.Points) .Where(p => p != point && p.X == point.X && p.Y == point.Y) .LastOrDefault() is Data.Point otherPoint) { return(TryJoinPath(layer, point, otherPoint)); } return(false); }
public void Init(string replayFile) { data = new Data(); timer = new System.Diagnostics.Stopwatch(); data.Load(replayFile); previousPoint = data.Next(); currentPoint = previousPoint; nextPoint = data.Next(); timer.Start(); }
public void AddLine(Vector2 to) { var point = new Data.Point( Outline.RoundToGrid(to.X), Outline.RoundToGrid(to.Y), Data.PointType.Line); var last = Path.Points.Last(); if (!(point.X == last.X && point.Y == last.Y)) { Path.Points.Add(point); } }
public static bool TryJoinPath(Data.Layer layer, Data.Point point, Data.Point otherPoint) { if (Is.AtOpenBoundary(point) && Is.AtOpenBoundary(otherPoint)) { JoinPaths(point.Parent, point.Parent.Points.IndexOf(point) == 0, otherPoint.Parent, otherPoint.Parent.Points.IndexOf(otherPoint) == 0, true); return(true); } return(false); }
public Data.Point ToData() { Data.Point point = new Data.Point() { X = this.X, Y = this.Y, Width = this.Width, Height = this.Height, PointId = this.Id, PointListId = this.PointListId, Argb = this.Argb }; return(point); }
static void VectorRotation(Data.Point point, Vector2 a, Vector2 b) { var ab = b - a; var ab_len = ab.Length(); if (ab_len != 0) { var p = point.ToVector2(); var pb_len = (b - p).Length(); var t = (ab_len + pb_len) / ab_len; point.X = RoundToGrid(a.X + t * ab.X); point.Y = RoundToGrid(a.Y + t * ab.Y); } }
static void ConstrainStaticHandles(Data.Point p1, Data.Point p2, Data.Point p3, float dx, float dy) { if (p2.IsSelected && p2.Type != PointType.Move) { if (p1.IsSelected || p3.IsSelected) { if (p1.IsSelected) { (p1, p3) = (p3, p1); } if (!p1.IsSelected && p3.Type == PointType.None) { VectorRotation(p3, p1.ToVector2(), p2.ToVector2()); } } else { if (p2.IsSmooth) { VectorProjection(p2, p1.ToVector2(), p3.ToVector2()); } } } else if (p1.IsSelected != p3.IsSelected) { if (p1.IsSelected) { (p1, p3) = (p3, p1); } if (p3.Type == PointType.None) { if (p2.IsSmooth && p2.Type != PointType.Move) { VectorProjection(p3, p1.ToVector2(), p2.ToVector2()); } else { // XXX: now that we're rounding, this doesn't work so well anymore var rvec = new Vector2(p3.X - dx, p3.Y - dy); VectorProjection(p3, p2.ToVector2(), rvec); } } } }
static void VectorProjection(Data.Point point, Vector2 a, Vector2 b) { var ab = b - a; var l2 = ab.LengthSquared(); if (l2 != 0) { var ap = point.ToVector2() - a; var t = Vector2.Dot(ap, ab) / l2; point.X = RoundToGrid(a.X + t * ab.X); point.Y = RoundToGrid(a.Y + t * ab.Y); } else { point.X = RoundToGrid(a.X); point.Y = RoundToGrid(a.Y); } }
/// <summary> /// Some initiating sequences when a player selects the targetted tile /// </summary> /// <param name="p"></param> /// <param name="t"></param> public void MoveToTile(PlayerMove p, Tile t) // current player; target { p.moving = true; // player is moving t.selected = true; // mark the selected tile halfHeight = p.gameObject.transform.Find("Character").gameObject.GetComponent <Collider>().bounds.extents.y; // obtain halfheight p.currentMoveOfPlayer -= t.movedis; // reduce the moving point of the player Text text = GameObject.Find("Canvas").transform.Find("RequiredMovePointNumber").gameObject.GetComponent <Text>(); text.text = "0 "; // Finding the path from player's current position to the target position targetPoint = new Data.Point(t.x, t.y); pathPoint.Push(targetPoint); path.Push(Init.PointToTile(targetPoint)); Data.Point now = targetPoint; while (now != currentPoint) { Data.Point tmp = now; now = prev[tmp.x, tmp.y]; Init.PointToTile(tmp).parent = Init.PointToTile(now); pathPoint.Push(now); path.Push(Init.PointToTile(now)); } }
/// <summary> /// Find the tiles that the players can move to. /// </summary> public void SpfaMove(Tile t, PlayerMove p) { int[,] dis = new int[Data.MapLen + 10, Data.MapWid + 10]; bool[,] visited = new bool[Data.MapLen + 1, Data.MapWid + 1]; Queue <Data.Point> q = new Queue <Data.Point>(); for (int i = 1; i <= Data.MapLen; i++) { for (int j = 1; j <= Data.MapWid; j++) { dis[i, j] = Data.INF; visited[i, j] = false; prev[i, j] = new Data.Point(0, 0); } } q.Clear(); dis[t.x, t.y] = 0; Data.Point push = new Data.Point(t.x, t.y); q.Enqueue(push); visited[t.x, t.y] = true; while (q.Count > 0) { Data.Point u = q.Dequeue(); visited[u.x, u.y] = false; for (int i = 0; i < 4; i++) { Data.Point v = new Data.Point(u.x + dirx[i], u.y + diry[i]); if (ValidTileForMoving(u, v)) { if (dis[u.x, u.y] + Data.movecost[Data.MapType[v.x, v.y]] < dis[v.x, v.y]) { dis[v.x, v.y] = dis[u.x, u.y] + Data.movecost[Data.MapType[v.x, v.y]]; prev[v.x, v.y] = new Data.Point(u.x, u.y); // Record path if (!visited[v.x, v.y] && dis[v.x, v.y] <= p.currentMoveOfPlayer) { Data.Point ppush = new Data.Point(v.x, v.y); q.Enqueue(ppush); visited[v.x, v.y] = true; } } } } } for (int i = 1; i <= Data.MapLen; i++) { for (int j = 1; j <= Data.MapWid; j++) { GameObject.Find("Row" + i.ToString()).transform.Find("Tile" + j.ToString()).gameObject.GetComponent <Tile>().movedis = dis[i, j]; if (dis[i, j] <= p.currentMoveOfPlayer && Init.PointToTile(new Data.Point(i, j)).insight) { GameObject row = GameObject.Find("Row" + i.ToString()); GameObject tile = row.transform.Find("Tile" + j.ToString()).gameObject; movelist.Add(tile.GetComponent <Tile>()); tile.GetComponent <Tile>().selectable = true; tile.GetComponent <Tile>().movedis = dis[i, j]; } } } }
/// <summary> /// Check if point q exists in map and the height difference of tile p and tile q is smaller than 2. /// </summary> public bool ValidTileForMoving(Data.Point p, Data.Point q) { return(q.x > 0 && q.x <= Data.MapLen && q.y > 0 && q.y <= Data.MapWid && Mathf.Abs(Init.PointToTile(p).gameObject.transform.position.y - Init.PointToTile(q).gameObject.transform.position.y) <= 2); }
public static bool TryTogglePointSmoothness(Data.Point point) { var path = point.Parent; return(TryTogglePointSmoothness(path, path.Points.IndexOf(point))); }
/// <summary> /// Check if a point exist in the map. /// </summary> /// <param name="p"></param> /// <returns></returns> public static bool ValidPoint(Data.Point p) { return(p.x > 0 && p.x <= Data.MapLen && p.y > 0 && p.y <= Data.MapWid); }
public override void OnPointerPressed(DesignCanvas canvas, PointerRoutedEventArgs args) { base.OnPointerPressed(canvas, args); var ptPoint = args.GetCurrentPoint(canvas); if (ptPoint.Properties.IsLeftButtonPressed && canvas.Layer is Data.Layer layer) { var pos = canvas.FromClientPosition(ptPoint.Position); // TODO: should we ignore Anchor/Component etc. here? var tappedItem = canvas.HitTest(pos, testSegments: true); var selPoint = GetSelectedPoint(layer); _screenOrigin = ptPoint.Position; _undoGroup = layer.CreateUndoGroup(); if (tappedItem is Data.Point tappedPoint && tappedPoint.Type != Data.PointType.None) { var tappedPath = tappedPoint.Parent; if (Is.AtOpenBoundary(tappedPoint)) { // If we click a boundary from another boundary, join the paths if (selPoint != null && Is.AtOpenBoundary(selPoint) && AreVisiblyDistinct(canvas, selPoint, tappedPoint)) { var selPath = selPoint.Parent; var selPoints = selPath.Points; if (selPoint.Type == Data.PointType.None) { selPoint.IsSelected = false; selPoints.Pop(); var lastOn = selPoints.Last(); _stashedOffCurve = (selPoint, lastOn.IsSmooth); lastOn.IsSmooth = false; } Outline.JoinPaths(selPath, selPoints[0] == selPoint, tappedPath, tappedPath.Points[0] == tappedPoint); // Drag a control point, except if we're joining a different path (as we're not at boundary // of the resulting path) if (selPath == tappedPath) { _path = selPath; } } // Otherwise reverse the path if needed and we'll drag the boundary point else { if (tappedPoint == tappedPath.Points.First()) { tappedPath.Reverse(); } _path = tappedPath; } } // If we clicked on an inside point, just break its path open. else { TryRemoveTrailingOffCurve(layer); layer.ClearSelection(); Outline.BreakPath(tappedPath, tappedPath.Points.IndexOf(tappedPoint)); } if (selPoint != null) { selPoint.IsSelected = false; } tappedPoint.IsSelected = true; } else if (tappedItem is Data.Segment segment) { var result = segment.ProjectPoint(pos.ToVector2()); if (result.HasValue) { var t = result.Value.Item2; if (!args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift)) { layer.ClearSelection(); } var otherSegment = segment.SplitAt(t); foreach (var point in Enumerable.Concat(segment.Points, otherSegment.OffCurves)) { point.X = Outline.RoundToGrid(point.X); point.Y = Outline.RoundToGrid(point.Y); } _point = segment.OnCurve; _point.IsSelected = true; _undoGroup.Dispose(); _undoGroup = layer.CreateUndoGroup(); } } else { ObserverList <Data.Point> points; Data.PointType type; // Add a point to the current path, if any if (selPoint != null && Is.AtOpenBoundary(selPoint)) { _path = selPoint.Parent; points = _path.Points; var lastPoint = points.Last(); lastPoint.IsSelected = false; if (lastPoint.Type == Data.PointType.None) { points.Pop(); var lastOn = points.Last(); _stashedOffCurve = (lastPoint, lastOn.IsSmooth); lastOn.IsSmooth = false; // For shift origin, always use an onCurve lastPoint = lastOn; } if (args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift)) { pos = ClampToOrigin(pos, new Point(lastPoint.X, lastPoint.Y)); } type = Data.PointType.Line; } // Else just create a new one else { _path = new Data.Path(); points = _path.Points; layer.Paths.Add(_path); type = Data.PointType.Move; } // In any case, unselect all points (*click*) and enable new point layer.ClearSelection(); var x = Outline.RoundToGrid((float)pos.X); var y = Outline.RoundToGrid((float)pos.Y); points.Add(new Data.Point(x, y, type) { IsSelected = true }); } ((App)Application.Current).InvalidateData(); }
public SplitIterator(Data.Point splitPoint) { _splitPoint = splitPoint; }
// Use this for initialization private void Start() { var gen = GameObject.Find("WallCreator").GetComponent <GenerateGenerateWall>(); _destroy = new List <GameObject>(); //This initializes the food object destroy list var activeGoals = E.Get().CurrTrial.trialData.ActiveGoals; var inactiveGoals = E.Get().CurrTrial.trialData.InactiveGoals; var invisibleGoals = E.Get().CurrTrial.trialData.InvisibleGoals; var inactiveSet = new HashSet <int>(inactiveGoals); var invisibleSet = new HashSet <int>(invisibleGoals); var activeSet = new HashSet <int>(activeGoals); var merged = new List <int>(); merged.AddRange(activeGoals); merged.AddRange(inactiveGoals); merged.AddRange(invisibleGoals); Data.Point p = new Data.Point { X = 0, Y = 0, Z = 0 }; foreach (var val in merged) { var goalItem = DS.GetData().Goals[Mathf.Abs(val) - 1]; UnityEngine.Debug.Log(goalItem); // Position is not set in the config file if (goalItem.Position.Count == 0) { p = ReadFromExternal(goalItem.PythonFile); } else { try { p = new Data.Point { X = goalItem.PositionVector.x, Y = goalItem.PositionVector.y, Z = goalItem.PositionVector.z }; } catch (Exception _) { p = new Data.Point { X = goalItem.PositionVector.x, Y = 0.5f, Z = goalItem.PositionVector.z }; } } GameObject prefab; GameObject obj; var spriteName = ""; if (goalItem.Type.ToLower().Equals("3d")) { prefab = (GameObject)Resources.Load("3D_Objects/" + goalItem.Object, typeof(GameObject)); obj = Instantiate(prefab); obj.AddComponent <RotateBlock>(); } else { // Load the "2D" prefab here, so we have the required components prefab = (GameObject)Resources.Load("3D_Objects/" + goalItem.Type.ToUpper(), typeof(GameObject)); obj = Instantiate(prefab); spriteName = goalItem.Object; } obj.transform.Rotate(goalItem.RotationVector); obj.transform.localScale = goalItem.ScaleVector; obj.transform.position = new Vector3(p.X, p.Y, p.Z); obj.AddComponent <PickupSound>(); obj.GetComponent <PickupSound>().Sound = Resources.Load <AudioClip>("Sounds/" + goalItem.Sound); if (!string.IsNullOrEmpty(spriteName)) { var pic = Img2Sprite.LoadNewSprite(DataSingleton.GetData().SpritesPath + spriteName); obj.GetComponent <SpriteRenderer>().sprite = pic; } var color = Data.GetColour(goalItem.Color); try { obj.GetComponent <Renderer>().material.color = color; obj.GetComponent <Renderer>().enabled = !invisibleSet.Contains(val); obj.GetComponent <Collider>().enabled = !inactiveSet.Contains(val); if (activeSet.Contains(val) || invisibleSet.Contains(val)) { obj.tag = "Pickup"; obj.GetComponent <Collider>().isTrigger = true; } } catch (Exception _) { print("Visibility not working"); } _destroy.Add(obj); } GameObject.Find("Participant").GetComponent <PlayerController>().ExternalStart(p.X, p.Z); }
/// <summary> /// Transforms a Point-formed tile to a Tile-formed tile. /// </summary> /// <param name="p"></param> public static Tile PointToTile(Data.Point p) { return(GameObject.Find("Map").transform.Find("Row" + p.x.ToString()).transform.Find("Tile" + p.y.ToString()).gameObject.GetComponent <Tile>()); }