Esempio n. 1
0
        public void UpdateCell(CPos cell)
        {
            var uv   = cell.ToMPos(Map);
            var tile = Map.MapResources.Value[uv];

            ResourceType type;

            if (Resources.TryGetValue(tile.Type, out type))
            {
                Tiles[uv] = new CellContents
                {
                    Type    = type,
                    Variant = ChooseRandomVariant(type),
                };

                Map.CustomTerrain[uv] = Tileset.GetTerrainIndex(type.Info.TerrainType);
            }
            else
            {
                Tiles[uv]             = CellContents.Empty;
                Map.CustomTerrain[uv] = byte.MaxValue;
            }

            // Ingame resource rendering is a giant hack (#6395),
            // so we must also touch all the neighbouring tiles
            Dirty.Add(cell);
            foreach (var d in CVec.Directions)
            {
                Dirty.Add(cell + d);
            }
        }
Esempio n. 2
0
        public Form1(string filepath)
        {
            InitializeComponent();
            //make sure the file path is not null before intializing the spreadsheet
            if (filepath != null)
            {
                spread    = new Spreadsheet(filepath, s => true, s => s.ToUpper(), "ps6");
                this.Text = filepath;
                fileName  = filepath;
                saved     = true;
            }

            //initializing the state of the spreadsheet by
            // setting the selection to the first cell
            spreadsheetPanel1.SetSelection(0, 0);

            // Setting the textbox for the name to A1
            CellName.Text = "A1";

            // Displaying the cells
            DisplayPanelOnOpen(spreadsheetPanel1);

            //Adding the displayControlsOnSelection as a listener to the event handler for the panel
            spreadsheetPanel1.SelectionChanged += DisplayControlsOnSelection;

            // adding the function pd_PrintPage to the event handler pd.PrintPage, so that pd_PrintPage will be called
            // when the event is triggered.
            pd.PrintPage += new PrintPageEventHandler(pd_PrintPage);

            // Setting the cursor to the textbox for cell contents.
            CellContents.Select();
        }
Esempio n. 3
0
        /// <summary>
        /// Pasting into the CellContents textbook if it is selected.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void pasteToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (CellContents.Focused)
            {
                CellContents.Paste();
            }
        }
Esempio n. 4
0
        /// <summary>
        /// Cutting the CellContents textbox if it is selected
        /// Called on the click of the cut in the menu.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>

        private void cutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (CellContents.Focused)
            {
                CellContents.Cut();
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="Cell"/> class.
 /// </summary>
 /// <param name="name">The name of the cell. <seealso cref="Name"/>.</param>
 /// <param name="location">The location of the cell. <seealso cref="Location"/></param>
 /// <param name="level">The level where the cell is located. <seealso cref="Level"/></param>
 /// <param name="contents">The contents of this cell. <seealso cref="CellContents"/>/param>
 public Cell(string name, Location location, Level level, CellContents contents)
     : this(name, location, level)
 {
     /* Add to this cell. */
     CellContents = contents;
     /* Make sure the content knows where it is. */
     contents.Cell = this;
 }
Esempio n. 6
0
    private void CreateUnit(FlatHexPoint point, GameObject prefab, CellContents owner)
    {
        GameObject newUnit = Instantiate(prefab, Map [point], Quaternion.identity) as GameObject;

        Unit unit = newUnit.GetComponent <Unit> ();

        grid [point].contents = owner;

        grid [point].unit         = unit;
        grid [point].isAccessible = false;
    }
Esempio n. 7
0
        public void ShouldProvideAMechanismToOpenItself()
        {
            var cell1 = new Cell(new CellContents(false), new Position(0, 0));
            var expectedContents1 = new CellContents(false);

            Assert.AreEqual(expectedContents1, cell1.Open());

            var cell2 = new Cell(new CellContents(true), new Position(0, 0));
            var expectedContents2 = new CellContents(true);

            Assert.AreEqual(expectedContents2, cell2.Open());
        }
Esempio n. 8
0
        /// <summary>
        /// users can still click-select cells
        /// </summary>
        /// <remarks>
        /// This is actually trickier than it seems. We need to update the
        /// cell value and cell content txt boxes, update col,row,
        /// and ensure that focus is passed to the panel.
        /// Deselecting should release(write) the edit box text to the cell
        /// </remarks>
        /// <param name="sender"></param>
        private void Panel_SelectionChanged(SpreadsheetPanel sender)
        {
            Panel.GetSelection(out col, out row);


            CellNameBox.Text = this.ColRow_To_string(col, row);

            CellVal.Text = this.PrintableValue(sheetModel.GetCellValue(CellNameBox.Text));

            string To_cell_content_box;

            Panel.GetValue(col, row, out To_cell_content_box);
            CellContents.Text = To_cell_content_box;
            CellContents.Select(0, CellContents.Text.Length);



            this.Panel.Select();
            PanelFocus = true;
        }
Esempio n. 9
0
        /// <summary>
        /// I'm using this event to handle arrow keys. probably bad practice...
        /// oh well
        /// </summary>
        /// <param name="msg">I don't know what this does</param>
        /// <param name="keyData">Data about the keypress</param>
        /// <returns>a boolean...for obvious reasons...</returns>
        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if (PanelFocus)
            {
                switch (keyData)
                {
                case Keys.Down:
                    Panel.SetSelection(col, ++row);
                    this.Panel_SelectionChanged(Panel);
                    break;

                case Keys.Up:
                    Panel.SetSelection(col, --row);
                    this.Panel_SelectionChanged(Panel);
                    break;

                case Keys.Left:
                    Panel.SetSelection(--col, row);
                    this.Panel_SelectionChanged(Panel);
                    break;

                case Keys.Right:
                    Panel.SetSelection(++col, row);
                    this.Panel_SelectionChanged(Panel);
                    break;

                default:
                    PanelFocus         = false;
                    CellContents.Text += new string((char)keyData, 1);
                    CellContents.Select(CellContents.Text.Length, 0);
                    //Panel.SetValue(col, row, CellContents.Text);
                    break;
                }
                this.CellContents.Select();
                return(true);
            }
            return(base.ProcessCmdKey(ref msg, keyData));
        }
Esempio n. 10
0
        /// <summary>
        /// Creates a file dialog that allows an existing file to be opened in the same window
        /// It will clear the contents of the existing window, and populate the window with the contents
        /// of the spreadsheet to be opened.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void openFileDialog1_FileOk(object sender, CancelEventArgs e)
        {
            try
            {
                // getting the filename from the file dialog
                string filePath = openFileDialog1.FileName;

                // emptying the spreadsheet
                spreadsheetPanel1.Clear();

                //creating a new spreadsheet from the specified file path
                spread = new Spreadsheet(filePath, s => true, s => s.ToUpper(), "ps6");

                this.Text = filePath;

                // updating the name of the spreadsheet window
                fileName = filePath;
                saved    = true;

                // setting the displays of the input boxes at the top
                DisplayControlsOnSelection(spreadsheetPanel1);

                // setting the display of the panels
                DisplayPanelOnOpen(spreadsheetPanel1);

                // adding the DisplayControlsOnSelection to event handler for the spreadsheet panel
                spreadsheetPanel1.SelectionChanged += DisplayControlsOnSelection;

                // setting the cursor to the CellContents input box
                CellContents.Select();
            }
            catch
            {
                MessageBox.Show("There was an error opening the file.  Please make sure that the filepath is correct, and that the file is a valid spreadsheet file.");
            }
        }
 /// <summary>
 /// Tries to the set the cell contents.
 /// </summary>
 /// <param name="contents">The contents to place in the cell.</param>
 /// <returns><code>true</code> if the specified contents
 /// was able to be placed in this cell; <code>false</code> otherwise.</returns>
 public virtual bool TrySetContents(CellContents contents)
 {
     if (CanEnter)
     {
         contents.Cell.RemoveContents();
         /* Add to this cell. */
         CellContents = contents;
         /* Make sure the content knows where it is. */
         contents.Cell = this;
         OnPropertyChanged("CellContents");
         return true;
     }
     return false;
 }
Esempio n. 12
0
 public override void Initialize()
 {
     base.Initialize();
     Size         = Constants.DefaultZeroSize;
     CellContents = new CellContents();
 }
Esempio n. 13
0
        public TablixCell CreateCell(string fieldName, uint? colSpan, uint? rowSpan,bool hidden)
        {
            TextboxType textbox = null;
            if (hidden)
            {
                textbox = CreateTextbox(fieldName, true);
            }
            else
            {
                textbox = CreateTextbox(fieldName);
            }
            var cellContents = new CellContents() { Textbox = textbox };
            if (colSpan != null && colSpan > 1)
            {
                cellContents.ColSpan = colSpan;
            }
            if (rowSpan != null && rowSpan > 1)
            {
                cellContents.RowSpan = rowSpan;
            }

            var cell = new TablixCell
                           {
                               CellContents = cellContents.Create(),
                               IsEmpty = false,
                               HasSetValue = true
                           };

            return cell;
        }
Esempio n. 14
0
        public TablixMembersType CreateMs(TablixMembersType parent, bool isStart, bool isRow)
        {
            if (isStart)
            {
                _level = 0;
            }
            var limit = isRow ? this.Columns.Count : this.Rows.Count;
            var tablixMember = new TablixMember();
            if ((!isRow && _level == limit - 1) || (isRow && _level==0))
            {
                tablixMember.Visibility = new Visibility() {Hidden = "true"}.Create();
                var group = new Group { GroupExpressions = new GroupExpressionsType() {GroupExpression=new string[]{""} } };
                tablixMember.Group = group.Create(isRow?"RowGroup":"ColumnGroup");
            }

            var heaer = new TablixHeader();
            var contents = new CellContents() { Textbox = CreateTextbox("",true) }.Create();
            heaer.CellContents = new CellContentsType[] { contents };
            string size = isRow ? this.Columns[_level].Width : this.Rows[_level].Height;
            heaer.Size = new string[] { size };
            tablixMember.TablixHeader = heaer.Create();

            _level++;
            if (_level < limit)
            {
                tablixMember.TablixMembers = CreateMs(new TablixMembersType(), false, isRow);
            }
            parent.TablixMember = new TablixMemberType[] { tablixMember.Create() };

            return parent;
        }
Esempio n. 15
0
    private void Update()
    {
        // if we're currently animating, don't update grid state until the display of the grid is caught up ith the current grid state.
        if (GridDisplayer.TweenInProgress())
        {
            return;
        }

        if (primaryTouchInfo.touching && !cellSelected)
        {
            // user is touching inside the grid
            if (primaryTouchInfo.startGridPosition != new Vector2Int(int.MinValue, int.MinValue))
            {
                selectedCell = primaryTouchInfo.startGridPosition;
                cellSelected = true;
                Debug.Log(grid[selectedCell.x, selectedCell.y].cellContent);
            }
        }

        if (!primaryTouchInfo.touching && cellSelected)
        {
            cellSelected = false;
        }

        #region Candy Swapping
        if (shouldGetSwipedCell)
        {
            // user has touched inside the grid
            if (primaryTouchInfo.startGridPosition != new Vector2Int(int.MinValue, int.MinValue))
            {
                int x = primaryTouchInfo.startGridPosition.x + primaryTouchInfo.swipeDirection.x;
                int y = primaryTouchInfo.startGridPosition.y - primaryTouchInfo.swipeDirection.y;

                // user is swiping inside the grid
                if (x < GRID_WIDTH && y < GRID_HEIGHT && x >= 0 && y >= 0)
                {
                    // the cell the player is swiping
                    swipedCell = new Vector2Int(x, y);

                    // swap the cellContent variables of the cells being swapped
                    CellContents temp = grid[swipedCell.x, swipedCell.y].cellContent;
                    grid[swipedCell.x, swipedCell.y].cellContent     = grid[selectedCell.x, selectedCell.y].cellContent;
                    grid[selectedCell.x, selectedCell.y].cellContent = temp;

                    // check for matches
                    List <Vector2Int> matches = new List <Vector2Int>();
                    matches.AddRange(GetMatchesAtCell(swipedCell));
                    matches.AddRange(GetMatchesAtCell(selectedCell));

                    if (matches.Count != 0)
                    {
                        // this is kind of a hack :
                        // Basically, when a GridElement swaps, it deregisters its swap method from its
                        //    current cell and registers it on the new cell. however, since the new
                        //    cell's swap method gets called right after, the first GridElement's swap
                        //    method was being called twice.
                        //    We "solve" this by taking a "snapshot" of the swiped gridcell before the
                        //    first GridElement registers its swap method on it, and calling the swap
                        //    method of this "snapshot". The first GridElement's swap method is only
                        //    called once and still registers itself on the right cell.
                        GridCell swipedCellCopy = grid[swipedCell.x, swipedCell.y];

                        if (grid[selectedCell.x, selectedCell.y].Swap != null)
                        {
                            grid[selectedCell.x, selectedCell.y].Swap(swipedCell);
                        }

                        if (swipedCellCopy.Swap != null)
                        {
                            swipedCellCopy.Swap(selectedCell);
                        }


                        foreach (Vector2Int cell in matches)
                        {
                            if (grid[cell.x, cell.y].Pop != null)
                            {
                                grid[cell.x, cell.y].Pop();
                            }

                            grid[cell.x, cell.y].cellContent = CellContents.empty;
                        }
                        return;
                    }
                    else
                    {
                        // call swap fail event (no need for the above hack since GridElement_Candy's
                        //    SwapFail method doesn't do any registering/deregistering)
                        if (grid[selectedCell.x, selectedCell.y].SwapFail != null)
                        {
                            grid[selectedCell.x, selectedCell.y].SwapFail(swipedCell);
                        }

                        if (grid[swipedCell.x, swipedCell.y].SwapFail != null)
                        {
                            grid[swipedCell.x, swipedCell.y].SwapFail(selectedCell);
                        }


                        // swap cell contents back
                        CellContents temp2 = grid[swipedCell.x, swipedCell.y].cellContent;
                        grid[swipedCell.x, swipedCell.y].cellContent     = grid[selectedCell.x, selectedCell.y].cellContent;
                        grid[selectedCell.x, selectedCell.y].cellContent = temp2;
                    }
                }
            }

            //shouldGetSwipedCell = false;
        }
        #endregion

        #region Candy Falling
        if (GridHasEmptyCells())
        {
            // check for cells i which new candies should be spawned
            for (int i = GRID_WIDTH - 1; i >= 0; --i)
            {
                int topColumnCellYCoord = 0;

                // if the top cell of the column is a hole, go down until we find one that's not
                if (grid[i, topColumnCellYCoord].cellContent == CellContents.hole)
                {
                    for (int j = 0; j < GRID_HEIGHT; ++j)
                    {
                        if (grid[i, j].cellContent == CellContents.hole)
                        {
                            ++topColumnCellYCoord;
                        }
                        else
                        {
                            break;
                        }
                    }
                }

                if (grid[i, topColumnCellYCoord].cellContent == CellContents.empty)
                {
                    // get a random color for the new candy
                    // FIND A BETTER WAY TO DO THIS
                    CellContents color = (CellContents)Random.Range(1, 6);

                    // Call a GridDisplayer Function to spawn in a new candy in the top row cell
                    GridDisplayer.SpawnNewCandy(color, new Vector2Int(i, topColumnCellYCoord));

                    grid[i, topColumnCellYCoord].cellContent = color;
                }
            }

            bool candiesFellThisFrame = false;

            // go backwards throught the grid, starting 1 line above the bottom because we're checking if cells below are emtpy
            for (int j = GRID_HEIGHT - 2; j >= 0; --j)
            {
                for (int i = GRID_WIDTH - 1; i >= 0; --i)
                {
                    if (grid[i, j].cellContent == CellContents.hole)
                    {
                        continue;
                    }

                    // if we find a non empty cell above an empty cell or a hole
                    if ((grid[i, j + 1].cellContent == CellContents.empty || grid[i, j + 1].cellContent == CellContents.hole) && grid[i, j].cellContent != CellContents.empty)
                    {
                        int dist        = 0;
                        int holeCounter = 0;

                        // go down until we find a cell that's above a non empty cell or at the bottom of the grid
                        for (int y = j + 1; y < GRID_HEIGHT; ++y)
                        {
                            if (grid[i, y].cellContent == CellContents.hole)
                            {
                                // if the cell we're checking is a hole, we don't want to add to dist just yet in
                                //    case its holes all the way down, in which case the candy should not drop, so
                                //    we keep a separate counter for holes
                                holeCounter++;
                            }
                            else
                            {
                                dist++;

                                // if we've hit a cell that's not a hole and the holeCounter is greater than 0,
                                //    that means the ccandy can fall down through the holes. we add the holecounter
                                //    to dist and we reset it in case we find more holes lower in the grid.
                                if (holeCounter > 0)
                                {
                                    dist       += holeCounter;
                                    holeCounter = 0;
                                }
                            }

                            if (y < GRID_HEIGHT - 1)
                            {
                                // break if the cell below the one we're checking is not empty and not a hole
                                if (grid[i, y + 1].cellContent != CellContents.empty && grid[i, y + 1].cellContent != CellContents.hole)
                                {
                                    break;
                                }
                            }
                        }

                        // dist is now the number of empty cells between the cell we're at and the next non-empty cell under it
                        // we call Fall on grid[i,j] and pass it dist

                        if (dist > 0)
                        {
                            if (grid[i, j].Fall != null)
                            {
                                grid[i, j].Fall(dist);
                            }

                            grid[i, j + dist].cellContent = grid[i, j].cellContent;
                            grid[i, j].cellContent        = CellContents.empty;

                            candiesFellThisFrame = true;
                        }
                    }
                }
            }

            if (candiesFellThisFrame)
            {
                return;
            }


            //for each grid column i, check if grid[i, 0] is empty. if yes, new candies should be spawned.
            //for (int i = GRID_WIDTH - 1; i >= 0; --i)
            //{
            //    int topColumnCellYCoord = 0;
            //
            //    // if the top cell of the column is a hole, go down until we find one that's not
            //    if (grid[i, topColumnCellYCoord].cellContent == CellContents.hole)
            //    {
            //        for (int j = 0; j < GRID_HEIGHT; ++j)
            //        {
            //            if (grid[i, j].cellContent == CellContents.hole)
            //            {
            //                ++topColumnCellYCoord;
            //            }
            //            else
            //            {
            //                break;
            //            }
            //        }
            //    }
            //
            //    if (grid[i, topColumnCellYCoord].cellContent == CellContents.empty)
            //    {
            //        // "probe" down to see how far down the next non-empty cell is
            //        int dist = 0;
            //        int holeCounter = 0;
            //
            //        for (int j = topColumnCellYCoord+1; j < GRID_WIDTH; ++j)
            //        {
            //            if (grid[i, j].cellContent == CellContents.empty )
            //            {
            //                ++dist;
            //
            //                if (holeCounter > 0)
            //                {
            //                    dist += holeCounter;
            //                    holeCounter = 0;
            //                }
            //            }
            //            else if (grid[i, j].cellContent == CellContents.hole)
            //            {
            //                ++holeCounter;
            //            }
            //            else
            //            {
            //                break;
            //            }
            //        }
            //
            //        // get a random color for the new candy
            //        // FIND A BETTER WAY TO DO THIS
            //        CellContents color = (CellContents)Random.Range(1, 6);
            //
            //        // Call a GridDisplayer Function to spawn in a new candy in the top row cell
            //        GridDisplayer.SpawnNewCandy(color, new Vector2Int(i, topColumnCellYCoord));
            //
            //        // call Fall on this top row cell if dist > 0
            //        if (dist > 0)
            //        {
            //            if (grid[i, 0].Fall != null)
            //                grid[i, 0].Fall(dist);
            //
            //            grid[i, dist].cellContent = color;
            //        }
            //        else
            //        {
            //            grid[i, 0].cellContent = color;
            //        }
            //
            //    }
            //}
        }
        #endregion

        if (!GridHasEmptyCells())
        {
            // check the whole grid for matches and pop them
            // for some reason this doesn't detect 4+ matches sometimes ?
            for (int i = 0; i < GRID_WIDTH; ++i)
            {
                for (int j = 0; j < GRID_HEIGHT; ++j)
                {
                    foreach (Vector2Int cellPos in GetMatchesAtCell(new Vector2Int(i, j)))
                    {
                        if (grid[cellPos.x, cellPos.y].Pop != null)
                        {
                            grid[cellPos.x, cellPos.y].Pop();
                        }
                        grid[cellPos.x, cellPos.y].cellContent = CellContents.empty;
                    }
                }
            }
        }
    }
Esempio n. 16
0
        private Rdl.TablixCellType CreateTablixCell(int i, string fieldName)
        {
            TablixCell cell = new TablixCell();
            //cell.CellContents

            CellContents contents = new CellContents();
            contents.Textbox = CreateTableCellTextbox(i, fieldName);
            cell.CellContents = contents.Create();
            return cell.Create();
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="FloorCell"/> class.
 /// </summary>
 /// <param name="location">The location of the cell.</param>
 /// <param name="level">The level on which the cell is located.</param>
 /// <param name="contents">The contents of this cell.</param>
 public FloorCell(Location location, Level level, CellContents contents)
     : base(cellName, location, level, contents)
 {
 }