Exemple #1
0
 public Board(Point mapSize, Point centerPoint, MultiBoard parent/*, ItemTypes ApplicationSettings.visibleTypes*/)
 {
     this.mapSize = mapSize;
     this.centerPoint = centerPoint;
     this.parent = parent;
     undoRedoMan = new UndoRedoManager(this);
     parent.Boards.Add(this);
     mouse = new Mouse(this);
 }
Exemple #2
0
        private void parentBoard_ShortcutKeyPressed(Board selectedBoard, bool ctrl, bool shift, bool alt, Keys key)
        {
            List <UndoRedoAction> actions = new List <UndoRedoAction>();

            if (key == Keys.ControlKey || key == Keys.ShiftKey || key == Keys.Menu /*ALT key*/)
            {
                return;
            }
            bool clearRedo = true;

            switch (key)
            {
            case Keys.Left:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    if (!item.BoundToSelectedItem(selectedBoard))
                    {
                        item.X--;
                        actions.Add(CreateItemUndoMoveAction(item, new Point(1, 0)));
                    }
                }
                break;

            case Keys.Right:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    if (!item.BoundToSelectedItem(selectedBoard))
                    {
                        item.X++;
                        actions.Add(CreateItemUndoMoveAction(item, new Point(-1, 0)));
                    }
                }
                break;

            case Keys.Up:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    if (!item.BoundToSelectedItem(selectedBoard))
                    {
                        item.Y--;
                        actions.Add(CreateItemUndoMoveAction(item, new Point(0, 1)));
                    }
                }
                break;

            case Keys.Down:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    if (!item.BoundToSelectedItem(selectedBoard))
                    {
                        item.Y++;
                        actions.Add(CreateItemUndoMoveAction(item, new Point(0, -1)));
                    }
                }
                break;

            case Keys.Delete:
                switch (selectedBoard.Mouse.State)
                {
                case MouseState.Selection:
                    int selectedItemIndex = 0;
                    while (selectedBoard.SelectedItems.Count > selectedItemIndex)
                    {
                        BoardItem item = selectedBoard.SelectedItems[selectedItemIndex];
                        if (item is ToolTipDot)
                        {
                            selectedItemIndex++;
                        }
                        else
                        {
                            item.RemoveItem(ref actions);
                        }
                    }
                    break;

                case MouseState.RandomTiles:
                case MouseState.StaticObjectAdding:
                case MouseState.Chairs:
                case MouseState.Ropes:
                    parentBoard.InvokeReturnToSelectionState();
                    break;

                case MouseState.Footholds:
                    while (selectedBoard.Mouse.connectedLines.Count > 0 && selectedBoard.Mouse.connectedLines[0].FirstDot.connectedLines.Count > 0)
                    {
                        selectedBoard.Mouse.connectedLines[0].FirstDot.connectedLines[0].Remove(false, ref actions);
                    }
                    break;
                }
                break;

            case Keys.F:
                if (ctrl)
                {
                    foreach (BoardItem item in selectedBoard.SelectedItems)
                    {
                        if (item is IFlippable)
                        {
                            ((IFlippable)item).Flip = !((IFlippable)item).Flip;
                            actions.Add(UndoRedoManager.ItemFlipped((IFlippable)item));
                        }
                    }
                }
                break;

            case Keys.Add:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    item.Z += UserSettings.zShift;
                    actions.Add(UndoRedoManager.ItemZChanged(item, item.Z - UserSettings.zShift, item.Z));
                }
                selectedBoard.BoardItems.Sort();
                break;

            case Keys.Subtract:
                foreach (BoardItem item in selectedBoard.SelectedItems)
                {
                    item.Z -= UserSettings.zShift;
                    actions.Add(UndoRedoManager.ItemZChanged(item, item.Z + UserSettings.zShift, item.Z));
                }
                selectedBoard.BoardItems.Sort();
                break;

            case Keys.A:
                if (ctrl)
                {
                    foreach (BoardItem item in selectedBoard.BoardItems)
                    {
                        if ((ApplicationSettings.editedTypes & item.Type) == item.Type)
                        {
                            item.Selected = true;
                        }
                    }
                }
                clearRedo = false;
                break;

            case Keys.Z:
                if (ctrl && selectedBoard.UndoRedoMan.UndoList.Count > 0)
                {
                    selectedBoard.UndoRedoMan.Undo();
                }
                clearRedo = false;
                break;

            case Keys.Y:
                if (ctrl && selectedBoard.UndoRedoMan.RedoList.Count > 0)
                {
                    selectedBoard.UndoRedoMan.Redo();
                }
                clearRedo = false;
                break;

            case Keys.Escape:
                if (selectedBoard.Mouse.State == MouseState.Selection)
                {
                    ClearBoundItems(selectedBoard);
                    ClearSelectedItems(selectedBoard);
                    clearRedo = false;
                }
                else if (selectedBoard.Mouse.State == MouseState.Footholds)
                {
                    selectedBoard.Mouse.Clear();
                }
                else
                {
                    parentBoard.InvokeReturnToSelectionState();
                }
                break;

            default:
                clearRedo = false;
                break;
            }
            if (actions.Count > 0)
            {
                selectedBoard.UndoRedoMan.AddUndoBatch(actions);
            }
            if (clearRedo)
            {
                selectedBoard.UndoRedoMan.RedoList.Clear();
            }
        }
Exemple #3
0
 public void PlaceObject()
 {
     if (state == MouseState.StaticObjectAdding || state == MouseState.RandomTiles)
     {
         Board.UndoRedoMan.AddUndoBatch(new List <UndoRedoAction>()
         {
             UndoRedoManager.ItemAdded(currAddedObj)
         });
         //Board.BoardItems.Add(currAddedObj.CreateInstance(Board.Layers[Board.SelectedLayerIndex], Board, x, y, 50, false, false));
         currAddedObj.BeforeAdding = false;
         ReleaseItem(currAddedObj);
         if (currAddedObj is LayeredItem)
         {
             int highestZ = 0;
             foreach (LayeredItem item in Board.BoardItems.TileObjs)
             {
                 if (item.Z > highestZ)
                 {
                     highestZ = item.Z;
                 }
             }
             currAddedObj.Z = highestZ;
             Board.BoardItems.Sort();
         }
         if (state == MouseState.StaticObjectAdding)
         {
             currAddedObj = currAddedInfo.CreateInstance(Board.SelectedLayer, Board, X + currAddedInfo.Origin.X - currAddedInfo.Image.Width / 2, Y + currAddedInfo.Origin.Y - currAddedInfo.Image.Height / 2, 50, false, true);
         }
         else
         {
             currAddedObj = tileRandomList[NextInt32(tileRandomList.Length)].CreateInstance(Board.SelectedLayer, Board, X + currAddedInfo.Origin.X - currAddedInfo.Image.Width / 2, Y + currAddedInfo.Origin.Y - currAddedInfo.Image.Height / 2, 50, false, true);
         }
         Board.BoardItems.Add(currAddedObj, false);
         BindItem(currAddedObj, new Microsoft.Xna.Framework.Point(currAddedInfo.Origin.X - currAddedInfo.Image.Width / 2, currAddedInfo.Origin.Y - currAddedInfo.Image.Height / 2));
     }
     else if (state == MouseState.Chairs)
     {
         Board.UndoRedoMan.AddUndoBatch(new List <UndoRedoAction> {
             UndoRedoManager.ItemAdded(currAddedObj)
         });
         ReleaseItem(currAddedObj);
         currAddedObj = new Chair(Board, X, Y, true);
         Board.BoardItems.Add(currAddedObj, false);
         BindItem(currAddedObj, new Microsoft.Xna.Framework.Point());
     }
     else if (state == MouseState.Ropes)
     {
         int      count = BoundItems.Count;
         object[] keys  = new object[count];
         BoundItems.Keys.CopyTo(keys, 0);
         RopeAnchor anchor = (RopeAnchor)keys[0];
         ReleaseItem(anchor);
         if (count == 1)
         {
             Board.UndoRedoMan.AddUndoBatch(new List <UndoRedoAction> {
                 UndoRedoManager.RopeAdded(anchor.ParentRope)
             });
             CreateRope();
         }
     }
     else if (state == MouseState.Tooltip)
     {
         int      count = BoundItems.Count;
         object[] keys  = new object[count];
         BoundItems.Keys.CopyTo(keys, 0);
         ToolTipDot dot = (ToolTipDot)keys[0];
         ReleaseItem(dot);
         if (count == 1)
         {
             Board.UndoRedoMan.AddUndoBatch(new List <UndoRedoAction> {
                 UndoRedoManager.ItemAdded(dot.ParentTooltip)
             });
             CreateTooltip();
         }
     }
 }