Example #1
0
    public TetrisPiece CreatePiece(TetrisPiece.PieceType type)
    {
        TetrisPiece tetrisPiece = this.tetrisPieceFactory.Create();

        tetrisPiece.Init(type);
        //TetrisPiece tetrisPiece = this.tetrisPieceFactory.Generate(TetrisPiece.PieceType.I);
        tetrisPiece.position.row = 0;
        tetrisPiece.position.col = 3;

        RenderPiece(tetrisPiece);

        currentFallingPiece = tetrisPiece;

        return(tetrisPiece);
    }
Example #2
0
    public GameObject UseResourceCard(TetrisPiece.PieceType pieceType, TetrisPiece.ResourceType resourceType)
    {
        List <TetrisPiece.Square> squares = new List <TetrisPiece.Square>();

        squares.Clear();

        if (pieceType == TetrisPiece.PieceType.RandomNonDot)
        {
            return(UseResourceCard((TetrisPiece.PieceType)Random.Range(3, 9), resourceType));
        }
        if (pieceType == TetrisPiece.PieceType.Random)
        {
            return(UseResourceCard((TetrisPiece.PieceType)Random.Range(2, 9), resourceType));
        }
        squares = TetrisHandler.Instance.pieceDictionary[pieceType];


        switch (resourceType)
        {
        case TetrisPiece.ResourceType.Randomized:

            TetrisPiece.ResourceType primary   = (TetrisPiece.ResourceType)Random.Range(1, 4);
            TetrisPiece.ResourceType secondary = (TetrisPiece.ResourceType)Random.Range(1, 4);

            for (int i = 0; i < squares.Count; i++)
            {
                if (Random.Range(0, 100) < 50)
                {
                    squares[i].resourceType = primary;
                }
                else
                {
                    squares[i].resourceType = secondary;
                }
            }

            break;

        case TetrisPiece.ResourceType.Air:
            for (int i = 0; i < squares.Count; i++)
            {
                squares[i].resourceType = TetrisPiece.ResourceType.Air;
            }
            break;

        case TetrisPiece.ResourceType.Metal:
            for (int i = 0; i < squares.Count; i++)
            {
                squares[i].resourceType = TetrisPiece.ResourceType.Metal;
            }
            break;

        case TetrisPiece.ResourceType.Fuel:
            for (int i = 0; i < squares.Count; i++)
            {
                squares[i].resourceType = TetrisPiece.ResourceType.Fuel;
            }
            break;

        case TetrisPiece.ResourceType.Flexible:
            for (int i = 0; i < squares.Count; i++)
            {
                squares[i].resourceType = TetrisPiece.ResourceType.Flexible;
            }
            break;
        }

        GameObject ParentObject = new GameObject();

        ParentObject.transform.position = Vector3.zero;
        ParentObject.AddComponent <TetrisParent>().squares = squares.Select(square => new TetrisPiece.Square()
        {
            xOffset = square.xOffset, yOffset = square.yOffset, resourceType = square.resourceType
        }).ToList();;
        ParentObject.GetComponent <TetrisParent>().isRepair = squares.Count == 1;
        foreach (TetrisPiece.Square square in squares)
        {
            GameObject cube = Instantiate <GameObject>(Resources.Load <GameObject>("Prefabs/TetrisCube"));

            cube.transform.SetParent(ParentObject.transform);

            cube.transform.localPosition = new Vector3(square.yOffset, square.xOffset);
            cube.GetComponent <TetrisTag>().ResourceType = square.resourceType;

            cube.GetComponent <Renderer>().material.SetFloat("_Type", (int)square.resourceType);
        }



        return(ParentObject);
    }
Example #3
0
    public void Init(TetrisPiece.PieceType type)
    {
        switch (type)
        {
        case TetrisPiece.PieceType.I:
            FillCell(
                new int[, ] {
                { 0, 0, 0, 0 },
                { 1, 1, 1, 1 },
                { 0, 0, 0, 0 },
                { 0, 0, 0, 0 }
            });
            break;

        case TetrisPiece.PieceType.J:
            FillCell(
                new int[, ] {
                { 1, 0, 0 },
                { 1, 1, 1 },
                { 0, 0, 0 }
            });
            break;

        case TetrisPiece.PieceType.L:
            FillCell(
                new int[, ] {
                { 0, 0, 1 },
                { 1, 1, 1 },
                { 0, 0, 0 }
            });
            break;

        case TetrisPiece.PieceType.O:
            FillCell(
                new int[, ] {
                { 1, 1 },
                { 1, 1 },
            });
            break;

        case TetrisPiece.PieceType.S:
            FillCell(
                new int[, ] {
                { 0, 1, 1 },
                { 1, 1, 0 },
                { 0, 0, 0 }
            });
            break;

        case TetrisPiece.PieceType.T:
            FillCell(
                new int[, ] {
                { 0, 1, 0 },
                { 1, 1, 1 },
                { 0, 0, 0 }
            });
            break;

        case TetrisPiece.PieceType.Z:
            FillCell(
                new int[, ] {
                { 1, 1, 0 },
                { 0, 1, 1 },
                { 0, 0, 0 }
            });
            break;
        }
    }