Ejemplo n.º 1
0
    public static PlacementCheckResult GetIntersections(GridTransform transform)
    {
        PlacementCheckResult result = new PlacementCheckResult();

        List <Point> occupiedPoints = transform.GetOccupiedTiles().ToList();

        foreach (Machine m1 in GetInstance().m_machines)
        {
            List <Point> intersections = m1.GetOccupiedTiles().Intersect(occupiedPoints).ToList();

            if (intersections.Count > 0)
            {
                result._intersectingMachines.Add(m1);
                result._intersectingPoints.AddRange(intersections);
            }
        }

        foreach (Conveyor c in GetInstance().m_conveyors)
        {
            List <Point> intersections = c.GetOccupiedTiles().Intersect(occupiedPoints).ToList();

            if (intersections.Count > 0)
            {
                result._intersectingConveyors.Add(c);
                result._intersectingPoints.AddRange(intersections);
            }
        }

        return(result);
    }
Ejemplo n.º 2
0
    void BuildRaycast()
    {
        Ray        ray = cam.ScreenPointToRay(Input.mousePosition);
        RaycastHit hitInfo;

        if (Physics.Raycast(ray, out hitInfo, Mathf.Infinity, groundLayerMask))
        {
            groundPos = hitInfo.point;

            SelectedNodes = GridTransform.GetNodes(
                groundPos,
                NowObjectToBuild.Dimensions.x,
                NowObjectToBuild.Dimensions.y,
                GetRotation().eulerAngles.y);

            if (OldNodes == null)
            {
                OldNodes = SelectedNodes;
            }

            if (SelectedNodes != null)
            {
                if (SelectedNodes != OldNodes)
                {
                    highlight.Enable();
                }

                Node aNode = SelectedNodes.First();
                Node bNode = SelectedNodes.Last();

                Quaternion rotation = GetRotation();

                if (aNode != null && bNode != null)
                {
                    Vector3 position = GridTransform.CenterVector3FromCoords(aNode.coords, bNode.coords);

                    if (!GridTransform.IsBlocked(SelectedNodes, NowObjectToBuild.ObjType))
                    {
                        highlight.PlaceHighlight(position, rotation);
                    }
                    else
                    {
                        highlight.PlaceHighlight(position, rotation, blockedMaterial);
                    }
                }
                else
                {
                    highlight.Disable();
                }

                OldNodes = SelectedNodes;
            }
        }

        else
        {
            SelectedNodes = null;
            highlight.Disable();
        }
    }
 private void Start()
 {
     particleEmmitersController = GameObject.Find("ParticleEmmiters").GetComponent <ParticleEmmitersController>();
     player        = GameObject.Find("Player").GetComponent <PlayerController>();
     enemiesList   = GameObject.Find("Enemies").GetComponent <EnemiesList>();
     gridTransform = GetComponent <GridTransform>();
 }
Ejemplo n.º 4
0
    private void PrivateEnable()
    {
        GridTransform gTransform = gameObject.AddComponent <GridTransform>();

        gTransform.Events = new GridEventHandlers((x) => OnGridCollision(x));
        gTransform.Warp(GridSystem.GetNode((int)transform.position.x, (int)transform.position.y));

        transform.position = gTransform.Target;

        GameObject quad = GameObject.CreatePrimitive(PrimitiveType.Quad);

        quad.transform.SetParent(transform, false);
        quad.transform.localPosition = Vector3.back * 0.01f;

        Material chestMat = new Material(Shader.Find("Unlit/Transparent"));

        chestMat.SetTexture("_MainTex", Resources.Load <Texture>("Sprites/Chest"));
        quad.GetComponent <MeshRenderer>().material = chestMat;

        arrow = new GameObject("Arrow");
        GameObject aQuad = GameObject.CreatePrimitive(PrimitiveType.Quad);

        aQuad.transform.SetParent(arrow.transform, false);
        aQuad.transform.localPosition = Vector3.back * 0.11f;
        aQuad.transform.localScale    = Vector3.one * 3f;

        Material arrowMat = new Material(Shader.Find("Unlit/Transparent"));

        arrowMat.SetTexture("_MainTex", Resources.Load <Texture>("Sprites/Arrow"));
        aQuad.GetComponent <MeshRenderer>().material = arrowMat;

        SoundController.PlaySound(Player.Instance.transform.position, "Sounds/ChestOpen");
    }
Ejemplo n.º 5
0
 void OnPlayToggle(bool playing)
 {
     UseChunkLoading = !playing;
     foreach (BeatmapObjectContainer c in LoadedContainers)
     {
         c.SafeSetActive(true);
     }
     obstacleRenderer = GridTransform.GetComponentsInChildren <Renderer>();
     if (playing)
     {
         foreach (Renderer g in obstacleRenderer)
         {
             if (g.materials.First().GetFloat("_CircleRadius") != 6.27f)
             {
                 g.materials.First().SetFloat("_CircleRadius", 6.27f);
             }
         }
     }
     else
     {
         foreach (Renderer g in obstacleRenderer)
         {
             if (g.materials.First().GetFloat("_CircleRadius") != 999)
             {
                 g.materials.First().SetFloat("_CircleRadius", 999);
             }
         }
     }
 }
Ejemplo n.º 6
0
 private void OnGridCollision(GridTransform other)
 {
     if (other.GetComponent <Player>() != null)
     {
         CEventSystem.BroadcastEvent(EventChannel.gameState, EventSubChannel.none, new GameOverEvent());
     }
 }
Ejemplo n.º 7
0
 private void OnGridCollision(GridTransform other)
 {
     if (other.GetComponent <Player>() != null)
     {
         Destroy(gameObject);
         CEventSystem.BroadcastEvent(EventChannel.gameState, EventSubChannel.none, new GameState.WinLevelEvent());
     }
 }
Ejemplo n.º 8
0
 /// <summary>
 /// Connect a grid transform to this node, and execute it's events
 /// </summary>
 /// <param name="transform"></param>
 public void AddTransform(GridTransform transform)
 {
     foreach (var t in connectedTransforms)
     {
         t.Events.OnCollision(transform);
     }
     connectedTransforms.Add(transform);
 }
Ejemplo n.º 9
0
    private void Start()
    {
        //InvokeRepeating("Move", 0.3f,0.3f);
        //grid = MoveTut.CreateAGrid().ToList();
        gridTransform = gameObject.AddComponent <GridTransform>();

        gridTransform.Warp(GridSystem.GetNode(0, 0));
    }
Ejemplo n.º 10
0
 void Awake()
 {
     gridTransform = gameObject.AddComponent <GridTransform>();
     //This created a new GridEventHandlers class, and assigned the optional
     //parameter OnCollision to equal the method OnGridCollision in this class
     gridTransform.Warp(GridSystem.GetNode(20, 20));
     transform.position   = gridTransform.Target;
     gridTransform.Events = new GridEventHandlers(OnCollision: OnGridCollision);
 }
 void OnGridCollision(GridTransform other)
 {
     //determite if the thing I collided with is the player
     if (other.GetComponent <gridTut>() != null)
     {
         //if it is, destory my gameobject
         Destroy(gameObject);
     }
 }
Ejemplo n.º 12
0
 void OnGridCollision(GridTransform other)
 {
     //Determine if the thing I collided with is the player
     if (other.GetComponent <TutorialGridEntity>() != null)
     {
         //If it is, destroy my gameObject
         Destroy(gameObject);
     }
 }
 void Awake()
 {
     gridTransform = gameObject.AddComponent <GridTransform>();
     //created a new grideventhandlers class and assigne the optional
     // parameter oncollision to equal the method OnGridCollision in
     //this class
     //gridTransform.Warp(GridSystem.GetNode(10, 10));
     gridTransform.Events = new GridEventHandlers(OnCollision: OnGridCollision);
     gridTransform.Warp(GridSystem.GetNode(5, 5));
 }
Ejemplo n.º 14
0
    private void Awake()
    {
        myGridTransform = GetComponent <GridTransform>();
        enemiesList     = GameObject.Find("Enemies").GetComponent <EnemiesList>();

        deathScreen.SetActive(false);

        healthBar.MaxHp = health;
        healthBar.Hp    = health;
    }
Ejemplo n.º 15
0
    private void Start()
    {
        //Create a grid using the method created in part 1
        //This will be available on github

        //Add a grid transform to the object for grid movement
        gridTransform = gameObject.AddComponent <GridTransform>();

        //Warp the grid transform to the first space on the grid (lower left corner)
        gridTransform.Warp(GridSystem.GetNode(0, 0));
    }
Ejemplo n.º 16
0
    public override void OnEnter()
    {
        base.OnEnter();

        if (_selectedMachine != null)
        {
            UiManager.SetMoveOptionsPanelEnabled(true);
            UiManager.SetMoveConfirmButtonEnabled(true);
            _initialTile     = _selectedMachine.GetCenterTile();
            _targetTransform = new GridTransform(_selectedMachine._gridTransform);
            _targetTransform.SetCenterTile(_initialTile);
        }
    }
Ejemplo n.º 17
0
    void Start()
    {
        yDeltaRotation = transform.rotation.eulerAngles.y;

        newPos      = transform.position;
        newRotation = transform.rotation;

        maxZoomSize = cam.orthographicSize;
        newZoom     = cam.orthographicSize;
        zoomStep    = (maxZoomSize - minZoomSize) / zoomSteps;

        top    = GridTransform.FromCoordsToVector3(WorldManager.Instance.Grid.lastNode.coords);
        bottom = GridTransform.FromCoordsToVector3(WorldManager.Instance.Grid.firstNode.coords);
    }
Ejemplo n.º 18
0
    private void Awake()
    {
        int x = (int)(transform.position.x - 0.5f);
        int y = (int)(transform.position.y - 0.5f);

        GridNode node = GridSystem.GetNode(x, y);

        GameObject    newObject     = Instantiate(prefab);
        GridTransform gridTransform = newObject.GetComponent <GridTransform>();

        if (gridTransform != null && node != null)
        {
            gridTransform.Warp(node);
            newObject.transform.position = gridTransform.Target;
        }
    }
Ejemplo n.º 19
0
    private TailPiece Init(Player player, GridTransform leader)
    {
        this.leader = leader;

        gridTransform        = gameObject.AddComponent <GridTransform>();
        gridTransform.Events = new GridEventHandlers(OnCollision: OnGridCollision);
        gridTransform.Warp(leader.CurrentNode);

        tweener            = gameObject.AddComponent <LinearTweener>();
        tweener.autoTarget = () => gridTransform.Target;
        tweener.speed      = player.speed;

        GameObject.CreatePrimitive(PrimitiveType.Quad).transform.SetParent(transform);
        transform.position = leader.transform.position;
        return(this);
    }
Ejemplo n.º 20
0
    private void Start()
    {
        childRight = MakeChild("childRight", Vector2.right);
        childUp    = MakeChild("childUp", Vector2.up);
        childOne   = MakeChild("childOne", Vector2.one);

        gridTransform = gameObject.GetComponent <GridTransform>();
        gridRight     = childRight.AddComponent <GridTransform>();
        gridUp        = childUp.AddComponent <GridTransform>();
        gridOne       = childOne.AddComponent <GridTransform>();

        gridTransforms = new GridTransform[] { gridTransform, gridRight, gridUp, gridOne };

        foreach (var gTransform in gridTransforms)
        {
            gTransform.Events = new GridEventHandlers(OnCollision: (x) => OnGridCollision(x));
        }

        tweener            = gameObject.AddComponent <LinearTweener>();
        tweener.speed      = 10f;
        tweener.autoTarget = () => gridTransform.Target;

        //gridTransform.Warp(GridSystem.GetNode((int)transform.position.x, (int)transform.position.y));

        CEventSystem.BroadcastEvent(EventChannel.gameState, EventSubChannel.none, new GameState.EnemySpawnEvent());

        animationParent = new GameObject("animationParent");
        animationParent.transform.SetParent(transform, false);
        animationParent.transform.localPosition = new Vector3(0.5f, -0.5f, 0f);

        animationChild      = GameObject.CreatePrimitive(PrimitiveType.Quad);
        animationChild.name = "AnimationChild";
        animationChild.transform.SetParent(animationParent.transform, false);
        animationChild.transform.localPosition = Vector2.up;
        animationChild.transform.localScale    = new Vector3(2f, 2f, 1f);

        Sprite[] sheet = Resources.LoadAll <Sprite>("Sprites/slime-sprite-sheet-FINAL-PNG");

        front = textureFromSprite(sheet[8]);
        right = textureFromSprite(sheet[5]);
        left  = textureFromSprite(sheet[2]);
        back  = textureFromSprite(sheet[11]);

        mat = new Material(Shader.Find("Unlit/Transparent"));
        mat.SetTexture("_MainTex", front);
        animationChild.GetComponent <MeshRenderer>().material = mat;
    }
Ejemplo n.º 21
0
    private void OnGridCollision(GridTransform other)
    {
        GreenSlime slime = other.GetComponentInParent <GreenSlime>();

        if (slime == this)
        {
            return;
        }

        Player player = other.GetComponent <Player>();

        if (player != null)
        {
            Destroy(gameObject);
            CEventSystem.BroadcastEvent(EventChannel.gameState, EventSubChannel.none, new GrowEvent(GameState.SnakeGrowCount));
            CEventSystem.BroadcastEvent(EventChannel.gameState, EventSubChannel.none, new GameState.EnemyDestroyedEvent());
        }
    }
Ejemplo n.º 22
0
    public override void SortObjects()
    {
        obstacleRenderer = GridTransform.GetComponentsInChildren <Renderer>();
        LoadedContainers = LoadedContainers.OrderBy(x => x.objectData._time).ToList();
        uint id = 0;

        for (int i = 0; i < LoadedContainers.Count; i++)
        {
            if (LoadedContainers[i].objectData is BeatmapObstacle)
            {
                BeatmapObstacle noteData = (BeatmapObstacle)LoadedContainers[i].objectData;
                noteData.id = id;
                LoadedContainers[i].gameObject.name = "Obstacle " + id;
                id++;
            }
        }
        UseChunkLoading = true;
    }
Ejemplo n.º 23
0
        public void Mix()
        {
            Random rnd = new Random();

            GridTransform[] trans = new GridTransform[5] {
                Transpose, SwapRows, SwapColumns, SwapRowsArea, SwapColumnsArea
            };

            GridTransform doTrans      = Reset;
            int           transformCnt = rnd.Next(Byte.MaxValue, Byte.MaxValue * 10);

            for (int i = 0; i < transformCnt; i++)
            {
                doTrans += trans[rnd.Next(int.MaxValue) % 5];
            }

            doTrans();
        }
Ejemplo n.º 24
0
    private void Start()
    {
        //Add dependant components
        gridTransform = gameObject.GetComponent<GridTransform>();
        if(gridTransform == null)
        {
            gridTransform = gameObject.AddComponent<GridTransform>();

            //Warp the player to the grid
            var gridNode = GridSystem.GetNode(0, 0);
            gridTransform.Warp(gridNode);
        }

        Sprite[] sprites = Resources.LoadAll<Sprite>("Sprites/SnakeSprites");

        quad = GameObject.CreatePrimitive(PrimitiveType.Quad);
        quad.transform.SetParent(transform);
        quad.transform.localPosition = Vector3.zero;

        headMat = new Material(Shader.Find("Unlit/Transparent"));
        headMat.SetTexture("_MainTex", textureFromSprite(sprites[0]));
        quad.GetComponent<MeshRenderer>().material = headMat;

        bodyMat = new Material(Shader.Find("Unlit/Transparent"));
        bodyMat.SetTexture("_MainTex", textureFromSprite(sprites[1]));

        tailMat = new Material(Shader.Find("Unlit/Transparent"));
        tailMat.SetTexture("_MainTex", textureFromSprite(sprites[2]));

        keyboardController = gameObject.AddComponent<PlayerKeyboardController>();
        tweener = gameObject.AddComponent<LinearTweener>();
        //Set the auto target for the tweener
        tweener.autoTarget = () => gridTransform.Target;
        tweener.speed = speed;

        //Add camera system
        GameObject.Find("Main Camera").AddComponent<CameraControl>();

        Grow();
    }
Ejemplo n.º 25
0
    /// <summary>
    /// Function we call to create a new grid for the currently loaded room
    /// </summary>
    public void CreateGrid()
    {
        //Sets the nodes size to the tile sizes states in RoomController
        gridTransform = GameController.Main.roomController.gridInfo;
        //Sets room to the GameController
        room = GameController.Main.currentRoom;
        //Sets the grids width to the rooms width
        gridSizeX = room.width;
        //sets the grids height to the rooms height
        gridSizeY = room.height;

        grid = new Node[gridSizeX, gridSizeY];
        //For every point on the grid x axis...
        for (int x = 0; x < gridSizeX; x++)
        {
            //for every point on the grids y axis...
            for (int y = 0; y < gridSizeY; y++)
            {
                grid[x, y] = new Node(false, Vector3.zero, x, y);
            }
        }
    }
Ejemplo n.º 26
0
    void OnDrawGizmos()
    {
        #region Node
        if (SelectedNodes != null)
        {
            Gizmos.color = new Color(0, 1f, 0, 0.35f);

            for (int i = 0; i < SelectedNodes.Length; i++)
            {
                Node n = SelectedNodes[i];

                if (n != null)
                {
                    Vector3 center = GridTransform.FromCoordsToVector3(n.coords);
                    Vector3 size   = Vector3.one;

                    Gizmos.DrawCube(center, size);
                }
            }
        }
        #endregion
    }
Ejemplo n.º 27
0
    void OnDrawGizmos()
    {
        if (showGrid && Application.isPlaying)
        {
            Gizmos.color = Color.blue;

            for (int x = 0; x < xSize; x++)
            {
                for (int z = 0; z < zSize; z++)
                {
                    #region Grid
                    float xOffset, zOffset;
                    if (xSize % 2 == 0)
                    {
                        xOffset = 0.5f;
                    }
                    else
                    {
                        xOffset = 0f;
                    }
                    if (zSize % 2 == 0)
                    {
                        zOffset = 0.5f;
                    }
                    else
                    {
                        zOffset = 0f;
                    }
                    Vector3 rawPosition = GridTransform.FromCoordsToVector3(Grid.gridOfNodes[x, z].coords);
                    Vector3 center      = new Vector3(rawPosition.x + xOffset, worldPlane.localScale.y / 2f, rawPosition.z + zOffset);
                    Vector3 size        = new Vector3(1f, 0f, 1f);

                    Gizmos.DrawWireCube(center, size);
                    #endregion
                }
            }
        }
    }
Ejemplo n.º 28
0
    private void Start()
    {
        //Add dependant components
        gridTransform = gameObject.GetComponent<GridTransform>();
        if(gridTransform == null)
        {
            gridTransform = gameObject.AddComponent<GridTransform>();

            //Warp the player to the grid
            var gridNode = GridSystem.GetNode(0, 0);
            gridTransform.Warp(gridNode);
        }

        GameObject quad = GameObject.CreatePrimitive(PrimitiveType.Quad);
        quad.transform.SetParent(transform);
        quad.transform.localPosition = Vector3.zero;

        keyboardController = gameObject.AddComponent<PlayerKeyboardController>();
        tweener = gameObject.AddComponent<LinearTweener>();
        //Set the auto target for the tweener
        tweener.autoTarget = () => gridTransform.Target;
        tweener.speed = speed;
    }
Ejemplo n.º 29
0
    public void BuildObject(Node[] nodes)
    {
        if (!GridTransform.IsBlocked(nodes, NowObjectToBuild.ObjType))
        {
            Node    aNode    = nodes.First();
            Node    bNode    = nodes.Last();
            Vector3 position = GridTransform.CenterVector3FromCoords(aNode.coords, bNode.coords);

            Object o = GameObject.Instantiate(NowObjectToBuild.Obj, position, GetRotation(), objectsParent).AddComponent <Object>();
            o.thisObjectData = NowObjectToBuild;
            o.SetRandomPalette();
            foreach (Node n in nodes)
            {
                if (o.thisObjectData.ObjType == ObjectType.Building)
                {
                    n.building = o;
                }
                else if (o.thisObjectData.ObjType == ObjectType.Flooring)
                {
                    n.flooring = o;
                }
            }
        }
    }
Ejemplo n.º 30
0
        public void TransformTestMethodFive()
        {
            //
            // A simple test adding two transforms built from three points each
            //

            GridTransform fixedTransform = new GridTransform();
            GridTransform movingTransform = new GridTransform();

            GridVector2[] fixedCtrlPoints = new GridVector2[]{ new GridVector2(5, 5),
                                                              new GridVector2(5, 10),
                                                              new GridVector2(5, 15),
                                                              new GridVector2(15, 5),
                                                              new GridVector2(15, 10),
                                                              new GridVector2(15, 15)};
                                        //                      new GridVector2(25, 5),
                                        //                      new GridVector2(25, 10),
                                        //                      new GridVector2(25, 15)};

            GridVector2[] fixedMapPoints = new GridVector2[]{new GridVector2(50, 50),
                                                              new GridVector2(50, 100),
                                                              new GridVector2(50, 150),
                                                              new GridVector2(150, 50),
                                                              new GridVector2(150, 100),
                                                              new GridVector2(150, 150)};
                                        ///                      new GridVector2(250, 50),
                                        ///                      new GridVector2(250, 100),
                                        //                      new GridVector2(250, 150)};

            GridVector2[] movingCtrlPoints = new GridVector2[]{new GridVector2(100, 75),
                                                              new GridVector2(100, 125),
                                                              new GridVector2(100, 175),
                                                              new GridVector2(200, 75),
                                                              new GridVector2(200, 125),
                                                              new GridVector2(200, 175)};
                                     //                         new GridVector2(250, 50),
                                     //                         new GridVector2(250, 100),
                                     //                         new GridVector2(250, 150)};

            GridVector2[] movingMapPoints = new GridVector2[]{ new GridVector2(5, 5),
                                                              new GridVector2(5, 10),
                                                              new GridVector2(5, 15),
                                                              new GridVector2(15, 5),
                                                              new GridVector2(15, 10),
                                                              new GridVector2(15, 15)};
                                     //                         new GridVector2(25, 5),
                                     //                         new GridVector2(25, 10),
                                     //                         new GridVector2(25, 15)};

            List<MappingGridVector2> fixedPoints = new List<MappingGridVector2>(fixedMapPoints.Length);
            List<MappingGridVector2> movingPoints = new List<MappingGridVector2>(movingMapPoints.Length);

            for (int iFixed = 0; iFixed < fixedMapPoints.Length; iFixed++)
            {
                fixedPoints.Add(new MappingGridVector2(fixedCtrlPoints[iFixed], fixedMapPoints[iFixed]));
            }

            for (int iMapped = 0; iMapped < fixedMapPoints.Length; iMapped++)
            {
                movingPoints.Add(new MappingGridVector2(movingCtrlPoints[iMapped], movingMapPoints[iMapped]));
            }

            fixedTransform.mapPoints = fixedPoints.ToArray();
            movingTransform.mapPoints = movingPoints.ToArray();

            movingTransform.Add(fixedTransform);

            MappingGridVector2[] newPoints = movingTransform.mapPoints;

            Debug.Assert(movingTransform.mapPoints.Length == 7);
        }
Ejemplo n.º 31
0
        public void TransformTestMethodTwo()
        {
            //
            // A simple test adding two transforms built from three points each
            //

            GridTransform fixedTransform = new GridTransform();
            GridTransform movingTransform = new GridTransform();

            GridVector2 fixedV1 = new GridVector2(0, 0);
            GridVector2 fixedV2 = new GridVector2(10, 0);
            GridVector2 fixedV3 = new GridVector2(0, 10);
            GridVector2 fixedV4 = new GridVector2(10, 10);

            MappingGridVector2[] fixedPoints = new MappingGridVector2[] {new MappingGridVector2(fixedV1, fixedV1),
                                                                         new MappingGridVector2(fixedV2, fixedV2),
                                                                         new MappingGridVector2(fixedV3, fixedV3),
                                                                         new MappingGridVector2(fixedV4, fixedV4)};

            fixedTransform.mapPoints = fixedPoints;

            GridVector2 movingV1 = new GridVector2(2.5, 2.5);
            GridVector2 movingV2 = new GridVector2(2.5, -7.5);
            GridVector2 movingV3 = new GridVector2(-7.5, 2.5);
            GridVector2 movingV4 = new GridVector2(-8.5, -8.5); //Point four should be removed by the transform

            MappingGridVector2[] movingPoints = new MappingGridVector2[] {new MappingGridVector2(movingV1, movingV1),
                                                                         new MappingGridVector2(movingV2, movingV2),
                                                                         new MappingGridVector2(movingV3, movingV3),
                                                                         new MappingGridVector2(movingV4, movingV4)};

            movingTransform.mapPoints = movingPoints;

            movingTransform.Add(fixedTransform);

            MappingGridVector2[] newPoints = movingTransform.mapPoints;

            Debug.Assert(newPoints[0].ControlPoint.X == 0 && newPoints[0].ControlPoint.Y == 2.5);
            Debug.Assert(newPoints[1].ControlPoint.X == 2.5 && newPoints[1].ControlPoint.Y == 0);
            Debug.Assert(newPoints[2].ControlPoint.X == 2.5 && newPoints[2].ControlPoint.Y == 2.5);
        }
Ejemplo n.º 32
0
 public static TailPiece Create(Player player, GridTransform leader)
 {
     return(new GameObject("TailPiece").AddComponent <TailPiece>().Init(player, leader));
 }
Ejemplo n.º 33
0
 public Transform(Entity parent)
     : base(parent)
 {
     Grid = new GridTransform(this);
     World = new WorldTransform(this);
 }