Example #1
0
        static public Color GetColorFromType(Tetromino_Type type)
        {
            switch (type)
            {
            case Tetromino_Type.O:
                return(Color.Yellow);

            case Tetromino_Type.I:
                return(Color.Cyan);

            case Tetromino_Type.T:
                return(Color.Purple);

            case Tetromino_Type.L:
                return(Color.Orange);

            case Tetromino_Type.J:
                return(Color.Blue);

            case Tetromino_Type.S:
                return(Color.Green);

            case Tetromino_Type.Z:
                return(Color.Red);

            case Tetromino_Type.Hl:
                return(new Color(200, 200, 200));

            case Tetromino_Type.Hh:
                return(new Color(254, 254, 254));

            default:
                return(new Color(10, 10, 10));
            }
        }
Example #2
0
        public Tetromino(Tetromino_Type type)
        {
            tetroType = type;

            switch (tetroType)
            {
            case Tetromino_Type.O:
                l_tetro = TetrominoFactory.Tetromino_O;
                break;

            case Tetromino_Type.I:
                l_tetro = TetrominoFactory.Tetromino_I;
                break;

            case Tetromino_Type.T:
                l_tetro = TetrominoFactory.Tetromino_T;
                break;

            case Tetromino_Type.L:
                l_tetro = TetrominoFactory.Tetromino_L;                         // TODO
                break;

            case Tetromino_Type.J:
                l_tetro = TetrominoFactory.Tetromino_J;                         // TODO
                break;

            case Tetromino_Type.S:
                l_tetro = TetrominoFactory.Tetromino_S;                         // TODO
                break;

            case Tetromino_Type.Z:
                l_tetro = TetrominoFactory.Tetromino_Z;                         // TODO
                break;

            default:
                break;
            }
        }
Example #3
0
        public void Rotate(int direction)
        {
            if (TetrominoQueue.ElementAt(0).tetroType != Tetromino_Type.O)
            {
                int newr = -1;
                if (direction > 0 && rotation >= TetrominoQueue.ElementAt(0).l_tetro.GetLength(0) - 1)
                {
                    newr = 0;
                }
                else if (direction > 0)
                {
                    newr = rotation + 1;
                }
                else if (direction < 0 && rotation <= 0)
                {
                    newr = TetrominoQueue.ElementAt(0).l_tetro.GetLength(0) - 1;
                }
                else if (direction < 0)
                {
                    newr = rotation - 1;
                }

                if (newr >= 0)
                {
                    // TODO: this but better?
                    Kick_Offsets ko = Kick_Offsets.N;
                    switch (rotation)
                    {
                    case 0:
                        switch (newr)
                        {
                        case 1:
                            ko = Kick_Offsets.ZR;
                            break;

                        case 3:
                            ko = Kick_Offsets.ZL;
                            break;
                        }
                        break;

                    case 1:
                        switch (newr)
                        {
                        case 2:
                            ko = Kick_Offsets.RZ;
                            break;

                        case 0:
                            ko = Kick_Offsets.RT;
                            break;
                        }
                        break;

                    case 2:
                        switch (newr)
                        {
                        case 3:
                            ko = Kick_Offsets.TR;
                            break;

                        case 1:
                            ko = Kick_Offsets.TL;
                            break;
                        }
                        break;

                    case 3:
                        switch (newr)
                        {
                        case 0:
                            ko = Kick_Offsets.LT;
                            break;

                        case 2:
                            ko = Kick_Offsets.LZ;
                            break;
                        }
                        break;
                    }
                    if (ko >= 0)
                    {
                        Tetromino_Type tt          = TetrominoQueue.ElementAt(0).tetroType;
                        int            offsetindex = -1;
                        int            x           = -1;
                        int            y           = -1;
                        // TODO: hardcoded 5 kick checks
                        for (int i = 0; i < 5; i++)
                        {
                            switch (tt)
                            {
                            case Tetromino_Type.I:
                                x = currentX + IKickTable[(int)ko, i, 0];
                                y = currentY + IKickTable[(int)ko, i, 1];
                                break;

                            default:
                                x = currentX + JLSTZKickTable[(int)ko, i, 0];
                                y = currentY + JLSTZKickTable[(int)ko, i, 1];
                                break;
                            }
                            if (CanMove(TetrominoQueue.ElementAt(0), x, y, newr))
                            {
                                offsetindex = i;
                                break;
                            }
                        }
                        if (offsetindex >= 0)
                        {
                            switch (tt)
                            {
                            case Tetromino_Type.I:
                                currentX += IKickTable[(int)ko, offsetindex, 0];
                                currentY += IKickTable[(int)ko, offsetindex, 1];
                                break;

                            default:
                                currentX += JLSTZKickTable[(int)ko, offsetindex, 0];
                                currentY += JLSTZKickTable[(int)ko, offsetindex, 1];
                                break;
                            }
                            rotation = newr;
                            // Reset move clock means infinite clock if a piece can rotate
                            moveClock = 0;
                        }
                    }
                }
            }
        }
Example #4
0
 static public void DrawTetro(SpriteBatch spriteBatch, Texture2D texture, Tetromino_Type type, int x, int y)
 {
     spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.AlphaBlend);
     spriteBatch.Draw(texture, new Rectangle(G.FieldOffsetX + x * G.TetrominoWidth, G.FieldOffsetY + y * G.TetrominoHeight, G.TetrominoWidth, G.TetrominoHeight), GetColorFromType(type));
     spriteBatch.End();
 }
Example #5
0
 public Tetromino(Tetromino og)
 {
     this.l_tetro   = og.l_tetro;
     this.tetroType = og.tetroType;
 }