void UpdateMatrixGrid()
    {
        string ourNiceGrid = "";

        //Debug.Log ("Updating " + transform.gameObject.name);
        for (int y = 0; y < MatrixGrid.column; ++y)
        {
            ourNiceGrid += "\n";
            for (int x = 0; x < MatrixGrid.row; ++x)
            {
                if (MatrixGrid.grid[x, y])
                {
                    ourNiceGrid += MatrixGrid.grid[x, y].position;
                }
                else
                {
                    ourNiceGrid += 0;
                };

                //if (MatrixGrid.grid [x, y] != null) {
                //	if (MatrixGrid.grid [x, y].parent = transform) {
                ///		MatrixGrid.grid [x, y] = null;
                //	}
                //}
            }
        }
        //print (ourNiceGrid);

        foreach (Transform child in transform)
        {
            Vector2 v = MatrixGrid.RoundVector(child.position);
            MatrixGrid.grid [(int)v.x, (int)v.y] = child;
        }
    }
Esempio n. 2
0
        public static void GetSubMatrix(MatrixGrid grid, Point cell)
        {
            var matrixPair = matricesView.Where(e => e.Value == grid).ToList()[0];
            var matrix     = matrixPair.Key.GetSubMatrix(cell);

            CreateMatrix(matrix);
        }
    bool IsValidGridPosition()
    {
        //Debug.Log(transform.childCount);
        string childInfo = "";

        foreach (Transform child in transform)
        {
            Vector2 v = MatrixGrid.RoundVector(child.position);
            childInfo += gameObject.name + "::" + child.name + " = " + v + "\n";
            if (!MatrixGrid.IsInsideBorder(v))
            {
                print("INVALID, Stopping... FInal Child Info from: " + gameObject.name);
                print("\n" + childInfo);

                return(false);
            }

            //if (MatrixGrid.grid [(int)v.x, (int)v.y] != null
            //&& MatrixGrid.grid [(int)v.x, (int)v.y].parent != child
            // ) {
            //	Debug.Log("Second thing failed it");
            //	Debug.Log (MatrixGrid.grid[(int)v.x, (int)v.y]);
            //	Debug.Log (MatrixGrid.grid[(int)v.x, (int)v.y].parent);
            //	Debug.Log (transform);
            //return false;
            //}
        }
        print(childInfo);
        return(true);
    }
Esempio n. 4
0
 void Awake()
 {
     MatrixGrid.InitializeGrid();
     oldRandomBlock = 7;
     isBlockPlaced  = true;
     boolArray      = "";
 }
Esempio n. 5
0
        public static void Insert(MatrixGrid oldGrid, MatrixGrid newGrid)
        {
            var matrixPair = matricesView.Where(e => e.Value == oldGrid).ToList()[0];
            var matrix     = matricesView.Where(e => e.Value == newGrid).ToList()[0].Key;
            var side       = oldGrid.side;
            var parent     = oldGrid.Parent;

            matricesView.Remove(matrixPair);
            matrices.Remove(matrixPair.Key);
            //DeleteMatrix(oldGrid);

            var newMatrix = (Matrix <T>)matrix.Clone();

            var grid = CreateMatrixGrid(newMatrix);

            grid.GridSizeChanged = oldGrid.GridSizeChanged;
            matrices.Add(newMatrix);
            matricesView.Add(new KeyValuePair <Matrix <T>, MatrixGrid>(newMatrix, grid));
            grid.Parent   = parent;
            grid.side     = side;
            grid.GridSize = grid.GridSize;
            oldGrid.Dispose();
            var oldMatrix = matrixPair.Key;

            Matrix <T> .Copy(newMatrix, oldMatrix);
        }
Esempio n. 6
0
    void UpdateMatrixGrid()
    {
        for (int y = 0; y < MatrixGrid.column; ++y)
        {
            for (int x = 0; x < MatrixGrid.row; ++x)
            {
                if (MatrixGrid.grid[x, y] != null)
                {
                    if (MatrixGrid.grid[x, y] == transform)
                    {
                        MatrixGrid.grid[x, y] = null;
                    }
                }
            }
        }
        foreach (Transform child in transform)
        {
            Vector2 v = MatrixGrid.RoundVector(child.position);
            MatrixGrid.grid[(int)v.x, (int)v.y] = child;
        }
        FindObjectOfType <Score>().IncreaseScore(1);

        /*for (int y = MatrixGrid.column-1; y >= 0 ; --y)
         * {
         *  string s = "";
         *  for (int x = 0; x < MatrixGrid.row; ++x)
         *  {
         *      if (MatrixGrid.grid[x, y] != null)
         *          s += " " + 0;
         *      else s += " 8";
         *
         *  }
         *  Debug.Log(s);
         * }*/
    }
Esempio n. 7
0
    void Update()
    {
        if (!gameover && MatrixGrid.IsInsideBorder(MatrixGrid.RoundVector(transform.position)))
        {
            if (Input.GetKeyDown(KeyCode.LeftArrow) || Input.GetKeyDown(KeyCode.A))
            {
                transform.position += new Vector3(-1, 0, 0);
                if (IsValidGridPosition())
                {
                }
                else
                {
                    transform.position += new Vector3(1, 0, 0);
                }
            }
            else if (Input.GetKeyDown(KeyCode.KeypadPlus) || Input.GetKeyDown(KeyCode.Equals))
            {
                FindObjectOfType <Speed>().SpeedUp();
                Debug.Log("SpeedUp");
            }

            else if (Input.GetKeyDown(KeyCode.KeypadMinus) || Input.GetKeyDown(KeyCode.Minus))
            {
                FindObjectOfType <Speed>().SpeedDown();
            }
            else if (Input.GetKeyDown(KeyCode.RightArrow) || Input.GetKeyDown(KeyCode.D))
            {
                transform.position += new Vector3(1, 0, 0);
                if (IsValidGridPosition())
                {
                }
                else
                {
                    transform.position += new Vector3(-1, 0, 0);
                }
            }
            else if (Input.GetKeyDown(KeyCode.Space))
            {
                transform.Rotate(new Vector3(0, 0, -90));

                if (IsValidGridPosition())
                {
                }
                else
                {
                    transform.Rotate(new Vector3(0, 0, 90));
                }
            }

            else if (Input.GetKeyDown(KeyCode.DownArrow) || Input.GetKeyDown(KeyCode.S) || Time.time - lastFall >= tick)
            {
                GameObjectDown();
                lastFall = Time.time;
            }
        }
        else if (Input.GetKeyDown(KeyCode.R) && gameover)
        {
            Restart();
        }
    }
Esempio n. 8
0
        public static void PrintToFile(MatrixGrid grid)
        {
            var matrix = matricesView.Where(e => e.Value == grid).ToList()[0].Key;

            using (var SFD = new SaveFileDialog())
            {
                SFD.FileName = grid.MatrixName;
                SFD.Filter   = "Text files(*.txt)|*.txt|All files(*.*)|*.*";
                DialogResult result = SFD.ShowDialog();
                if (result == DialogResult.Cancel)
                {
                    return;
                }
                string filename = SFD.FileName;
                string text     = "";
                for (int i = 0; i < matrix.rowsCount; i++)
                {
                    for (int j = 0; j < matrix.columnsCount; j++)
                    {
                        text += matrix[i, j].ToString() + ((j == matrix.columnsCount - 1)? "":" ");
                    }
                    text += '\n';
                }
                File.WriteAllText(filename, text);
            }
        }
Esempio n. 9
0
 void GameObjectDown()
 {
     transform.position += new Vector3(0, -1, 0);
     if (IsValidGridPosition())
     {
         countofsteps++;
     }
     else
     {
         if (countofsteps > 0)
         {
             transform.position += new Vector3(0, 1, 0);
             UpdateMatrixGrid();
             MatrixGrid.DeleteWholeRows();
             FindObjectOfType <Spawner>().SpawnRandom(SpawnerNext.index);
             enabled = false;
         }
         else
         {
             transform.position += new Vector3(0, 1, 0);
             gameover            = true;
             FindObjectOfType <GameOver>().ShowGameOver();
             //Debug.Log("game over");
         }
     }
 }
Esempio n. 10
0
    void moveObject()
    {
        if (Input.GetKeyDown(KeyCode.LeftArrow))
        {
            transform.position += new Vector3(-1, 0, 0);

            if (IsValidGridPosition())
            {
                UpdateMatrixGrid();
            }
            else
            {
                transform.position += new Vector3(1, 0, 0);
            }
        }
        else if (Input.GetKeyDown(KeyCode.RightArrow))
        {
            transform.position += new Vector3(1, 0, 0);

            if (IsValidGridPosition())
            {
                UpdateMatrixGrid();
            }
            else
            {
                transform.position += new Vector3(-1, 0, 0);
            }
        }
        else if (Input.GetKeyDown(KeyCode.UpArrow))
        {
            transform.Rotate(new Vector3(0, 0, -90));

            if (IsValidGridPosition())
            {
                UpdateMatrixGrid();
            }
            else
            {
                transform.Rotate(new Vector3(0, 0, 90));
            }
        }
        else if (Input.GetKeyDown(KeyCode.DownArrow) || Time.time - lastFall >= 1)
        {
            transform.position += new Vector3(0, -1, 0);

            if (IsValidGridPosition())
            {
                UpdateMatrixGrid();
            }
            else
            {
                transform.position += new Vector3(0, 1, 0);
                MatrixGrid.DeleteWholeRows();
                FindObjectOfType <Spawn>().spawnRandom();
                enabled = false;
            }
            lastFall = Time.time;
        }
    }
Esempio n. 11
0
 private void Form1_Load(object sender, EventArgs e)
 {
     Input = new MatrixGrid(InputMatrix);
     Input.AddRow(sender, e);
     AddRowBtn.Click    += Input.AddRow;
     RemoveRowBtn.Click += Input.DeleteRow;
     Output              = new MatrixGrid(OutputMatrix);
 }
Esempio n. 12
0
 public DragDropCommand(MatrixGrid grid)
 {
     this.grid              = grid;
     grid.dragDropExecuted += (o, e) =>
     {
         newGrid = (MatrixGrid)o;
     };
 }
Esempio n. 13
0
 void Update()
 {
     dynamicScore.text = "Your Current Score : " + MatrixGrid.returnPlayerScore().ToString();
     if (TetrisObject.IsGameOver())
     {
         Application.LoadLevel("End screen");
     }
 }
Esempio n. 14
0
        public static ControllerData <T> DeleteMatrix(MatrixGrid mg)
        {
            var matrixPair = matricesView.Where(e => e.Value == mg).ToList()[0];

            matricesView.Remove(matrixPair);
            matrixPair.Key.Dispose();
            matrices.Remove(matrixPair.Key);
            return(new ControllerData <T>(GetData(matrixPair.Key), matrixPair.Key));
        }
 void CheckRowClears()
 {
     MatrixGrid.rowClears = 0;
     for (int i = 0; i < 20; i++)
     {
         if (MatrixGrid.IsRowClear(i))
         {
             MatrixGrid.rowClears++;
         }
     }
 }
 void RotateBlock()
 {
     transform.Rotate(Vector3.forward, curRot);
     foreach (Transform child in transform)
     {
         if (MatrixGrid.CheckPosFilled(Vector3Int.RoundToInt(child.position)))
         {
             transform.Rotate(Vector3.forward, -curRot);
             return;
         }
     }
 }
Esempio n. 17
0
        public static Matrix <T> GetMatrix(MatrixGrid grid)
        {
            var matrixPairs = matricesView.Where(e => e.Value == grid).ToList();

            if (matrixPairs.Count > 0)
            {
                return(matrixPairs[0].Key);
            }
            else
            {
                return(null);
            }
        }
Esempio n. 18
0
        public static void DoDragDrop(MatrixGrid grid)
        {
            if (grid.side != WorkingPanelSide.List)
            {
                var matrixPair = matricesView.Where(e => e.Value == grid).ToList()[0];
                OperationController <T> .DoDragDrop(grid, matrixPair.Key);

                return;
            }


            panel.AllowDrop = false;
            grid.DoDragDrop(grid, DragDropEffects.Copy);
        }
Esempio n. 19
0
        public static MatrixGrid ExecuteDragDrop(MatrixGrid gridDragDrop)
        {
            var matrixPair     = matricesView.Where(e => e.Value == gridDragDrop).ToList()[0];
            var matrix         = (Matrix <T>)matrixPair.Key.Clone();
            var newGrid        = CreateMatrix(matrix);
            var matrixPairList = matricesView.Where(e => e.Value.side == gridDragDrop.side).ToList();

            if (gridDragDrop.dragDropExecuted != null)
            {
                gridDragDrop.dragDropExecuted.Invoke(newGrid, null);
            }
            newGrid.lines      = matrix.lines;
            newGrid.MatrixName = gridDragDrop.MatrixName;
            return(newGrid);
        }
Esempio n. 20
0
        public void Undo()
        {
            if (isMatrixController)
            {
                if (matrix != null)
                {
                    if (grid.side == WorkingPanelSide.List)
                    {
                        MatrixController <T> .CreateMatrix(matrix);
                    }
                    else
                    {
                        //костыль (:
                        //зато работает!
                        var side = grid.side;
                        grid = MatrixController <T> .CreateMatrix(matrix);

                        OperationController <T> .ExecuteDragDrop(side, grid, opView);

                        MatrixController <T> .DeleteMatrix(matrix);
                    }
                }
            }
            else
            {
                //тоже костыль :(
                opView = OperationController <T> .CreateEmptyOperation();

                var left  = operation.leftMatrix;
                var right = operation.rightMatrix;
                if (left != null)
                {
                    var leftGrid = MatrixController <T> .CreateMatrix(left);

                    OperationController <T> .ExecuteDragDrop(WorkingPanelSide.Left, leftGrid, opView);

                    MatrixController <T> .DeleteMatrix(leftGrid);
                }
                if (right != null)
                {
                    var rightGrid = MatrixController <T> .CreateMatrix(right);

                    OperationController <T> .ExecuteDragDrop(WorkingPanelSide.Right, rightGrid, opView);

                    MatrixController <T> .DeleteMatrix(rightGrid);
                }
            }
        }
Esempio n. 21
0
 bool isValidGridPosition()
 {
     foreach (Transform child in transform)
     {
         Vector2 v = MatrixGrid.RoundVector(child.position);
         if (!MatrixGrid.IsInsideBorder(v))
         {
             return(false);//косание стен
         }
         if (MatrixGrid.grid[(int)v.x, (int)v.y] != null && MatrixGrid.grid[(int)v.x, (int)v.y].parent != transform)
         {
             return(false);//косание другой фигуры
         }
     }
     return(true);
 }
Esempio n. 22
0
        public void Execute()
        {
            if (type == CreationType.Matrix)
            {
                if (data.GetLength(0) != 0 || data.GetLength(1) != 0)
                {
                    grid = MatrixController <T> .CreateMatrix(data);
                }
                grid.MatrixName = name;
            }

            else
            {
                opView = OperationController <T> .CreateEmptyOperation();
            }
        }
Esempio n. 23
0
 bool IsValidGridPosition()
 {
     foreach (Transform child in transform)
     {
         Vector2 v = MatrixGrid.RoundVector(child.position);
         if (!MatrixGrid.IsInsideBorder(v))
         {
             return(false);
         }
         if (MatrixGrid.grid[(int)v.x, (int)v.y] != null && MatrixGrid.grid[(int)v.x, (int)v.y] != transform)
         {
             return(false);
         }
     }
     return(true);
 }
    void CheckBlockPosition()
    {
        if (delayStart + delay > Time.time)
        {
            valid = true;
            foreach (Transform child in transform)
            {
                if (MatrixGrid.CheckPosFilled(Vector3Int.RoundToInt(child.position)))
                {
                    MatrixGrid.gameOver = true;
                    return;
                }
                if (MatrixGrid.ReachedBottom(Vector3Int.RoundToInt(child.position)))
                {
                    valid = false;
                }
            }
            if (valid)
            {
                SoftDrop();
            }

            foreach (Transform child in transform)
            {
                if (MatrixGrid.ReachedBottom(Vector3Int.RoundToInt(child.position)))
                {
                    Spawner.activeBlock = null;
                    //yield return new WaitForSeconds(BlockFallTimer.timer + (14f / 60f));
                    foreach (Transform child2 in transform)
                    {
                        MatrixGrid.Lock(Vector3Int.RoundToInt(child2.position));
                        MatrixGrid.SetGrid(Vector3Int.RoundToInt(child2.position), child2.gameObject);
                    }

                    CheckRowClears();
                    Spawner.isBlockPlaced = true;
                    Destroy(this);
                    break;
                }
            }
        }
    }
Esempio n. 25
0
    bool IsValidGridPostion()
    {
        foreach (Transform child in transform)
        {
            Vector2 v = MatrixGrid.RoundVector(child.position);

            // if object is not inside the boders the return false - i.e. not valid
            if (!MatrixGrid.IsInsideBorder(v))
            {
                return(false);
            }

            // check if block is in the grid, but not part of the group - then not valid
            if (MatrixGrid.grid[(int)v.x, (int)v.y] != null && MatrixGrid.grid[(int)v.x, (int)v.y].parent != transform)
            {
                return(false);
            }
        }
        return(true);
    }
Esempio n. 26
0
        public static ControllerData <T> EditMatrix(MatrixGrid mg)
        {
            var matrixPair = matricesView.Where(e => e.Value == mg).ToList()[0];
            //currentEditMatrix = matrixPair.Key;
            EditMatrix editMatrixForm = new EditMatrix(MatrixEditMode.Edit, matrixPair.Key.rowsCount, matrixPair.Key.columnsCount, matrixPair.Key, matrixPair.Value.MatrixName, true);
            var        dgv            = editMatrixForm.dataGridView1;

            dgv.RowCount    = matrixPair.Key.rowsCount;
            dgv.ColumnCount = matrixPair.Key.columnsCount;
            for (int i = 0; i < matrixPair.Key.rowsCount; i++)
            {
                for (int j = 0; j < matrixPair.Key.columnsCount; j++)
                {
                    dgv[j, i].Value = matrixPair.Key[i, j].ToString();
                }
            }

            editMatrixForm.Show();
            return(new ControllerData <T>(GetData(matrixPair.Key), matrixPair.Key));
        }
Esempio n. 27
0
 void UpdateMatrixGrid()
 {
     for (int y = 0; y < MatrixGrid.column; ++y)
     {
         for (int x = 0; x < MatrixGrid.row; ++x)
         {
             if (MatrixGrid.grid[x, y] != null)
             {
                 if (MatrixGrid.grid[x, y].parent == transform)
                 {
                     MatrixGrid.grid[x, y] = null;
                 }
             }
         }
     }     //removing children
     foreach (Transform child in transform)
     {
         Vector2 v = MatrixGrid.RoundVector(child.position);
         MatrixGrid.grid[(int)v.x, (int)v.y] = child;
     }     // adding new children
 }
Esempio n. 28
0
 void UpdateMatrixGrid()
 {
     for (int y = 0; y < MatrixGrid.column; y++)
     {
         for (int x = 0; x < MatrixGrid.row; x++)
         {
             if (MatrixGrid.grid[x, y] != null)
             {
                 if (MatrixGrid.grid[x, y].parent == transform)
                 {
                     MatrixGrid.grid[x, y] = null;
                 }
             }
         }
     }
     foreach (Transform child in transform)
     {
         Vector2 v = MatrixGrid.RoundVector(child.position);
         MatrixGrid.grid[(int)v.x, (int)v.y] = child;
     }
 }
    bool isValidGridPos()
    {
        foreach (Transform child in transform)
        {
            Vector2 v = MatrixGrid.RoundVector(child.position);

            // Not inside Border?
            if (!MatrixGrid.IsInsideBorder(v))
            {
                return(false);
            }

            // Block in grid cell (and not part of same group)?
            if (MatrixGrid.grid[(int)v.x, (int)v.y] != null &&
                MatrixGrid.grid[(int)v.x, (int)v.y].parent != transform)
            {
                return(false);
            }
        }
        return(true);
    }
Esempio n. 30
0
    private void OnMouseDown()
    {
        if (isMine)
        {
            MatrixGrid.ShowAllMines();
        }
        else
        {
            string[] index = gameObject.name.Split('-');
            int      x     = int.Parse(index[0]);
            int      y     = int.Parse(index[1]);

            ShowNearMinesCount(MatrixGrid.NearMines(x, y));

            MatrixGrid.InvestigateMines(x, y, new bool[GameManager.Instance.Rows, GameManager.Instance.Columns]);

            if (MatrixGrid.IsGameFinished())
            {
                Debug.Log("You won");
            }
        }
    }