public UndoRedoAction(BoardItem item, UndoRedoType type, object ParamA, object ParamB)
{
this.item = item;
this.type = type;
this.ParamA = ParamA;
this.ParamB = ParamB;
}
public JsonResult AddNewBoardItem(BoardItem boardItem)
{
boardItem.BoardStructure = boardItem.BoardStructure;
//TODO: change to current user
boardItem.UserId = 1;
boardItem.BoardImageUrl = "iboard-new-empty.jpg";
BoardDbContext.BoardItems.Add(boardItem);
var isSuccess = BoardDbContext.SaveChanges() > 0;
return Json(isSuccess);
}
public JsonResult DeleteBoardItem(BoardItem boardItem)
{
var currentBoardItem = BoardDbContext.BoardItems.FirstOrDefault(b => b.Id == boardItem.Id && b.UserId == 1);
var isSuccess = false;
if (currentBoardItem != null)
{
BoardDbContext.BoardItems.Remove(currentBoardItem);
isSuccess = BoardDbContext.SaveChanges() > 0;
}
return Json(isSuccess);
}
/// <summary>
/// Destroys items in a given shape.
/// </summary>
/// <returns>Points of destroyed items.</returns>
/// <param name="refBoard">Reference to the game board.</param>
/// <param name="centerX">X-coord of the shape centre.</param>
/// <param name="centerY">Y-coord of the shape centre.</param>
public ArrayList ApplyBonus(BoardItem[,] refBoard, int centerX, int centerY)
{
switch (bonusShape) {
case BonusShape.Cross:
return DestroyItemsInCrossShape(refBoard, centerX, centerY);
}
return null;
}
public static UndoRedoAction ItemZChanged(BoardItem item, int oldZ, int newZ)
{
return new UndoRedoAction(item, UndoRedoType.ItemZChanged, oldZ, newZ);
}
public static UndoRedoAction ItemsUnlinked(BoardItem parent, BoardItem child, Point distance)
{
return(new UndoRedoAction(parent, UndoRedoType.ItemsUnlinked, child, distance));
}
public void SetHeldInfo(MapleDrawableInfo newInfo)
{
lock (Board.ParentControl)
{
Clear();
if (newInfo.Image == null)
((MapleExtractableInfo)newInfo).ParseImage();
currAddedInfo = newInfo;
currAddedObj = newInfo.CreateInstance(Board.SelectedLayer, Board, X + currAddedInfo.Origin.X - newInfo.Image.Width / 2, Y + currAddedInfo.Origin.Y - newInfo.Image.Height / 2, 50, false);
Board.BoardItems.Add(currAddedObj, false);
BindItem(currAddedObj, new Microsoft.Xna.Framework.Point(newInfo.Origin.X - newInfo.Image.Width / 2, newInfo.Origin.Y - newInfo.Image.Height / 2));
state = MouseState.StaticObjectAdding;
}
}
public override void ReleaseItem(BoardItem item)
{
lock (Board.ParentControl)
{
if (BoundItems.ContainsKey(item))
{
BoundItems.Remove(item);
item.Parent = item.tempParent;
item.tempParent = null;
}
}
}
public void Clear()
{
lock (Board.ParentControl)
{
if (currAddedObj != null)
{
currAddedObj.RemoveItem(null);
currAddedObj = null;
}
if (state == MouseState.Ropes || state == MouseState.Tooltip)
{
if (state == MouseState.Ropes)
((RopeAnchor)BoundItems.Keys.ElementAt(0)).RemoveItem(null);
else
((ToolTipDot)BoundItems.Keys.ElementAt(0)).ParentTooltip.RemoveItem(null);
}
else if (state == MouseState.Footholds && connectedLines.Count > 0)
{
FootholdLine fh = (FootholdLine)connectedLines[0];
fh.Remove(false, null);
Board.BoardItems.FootholdLines.Remove(fh);
}
else if (state == MouseState.Clock)
{
List<BoardItem> items = BoundItems.Keys.ToList();
foreach (BoardItem item in items)
{
item.RemoveItem(null);
}
}
InputHandler.ClearBoundItems(Board);
InputHandler.ClearSelectedItems(Board);
IsDown = false;
}
}
public Chair(Board board, BoardItem.SerializationForm json)
: base(board, json)
{
}
/// <summary>
/// Performs game update and touch and mouse input.
/// </summary>
void Update()
{
// Back button.
if (Input.GetKeyDown(KeyCode.Escape))
Application.Quit();
// Wait for all animations to finish - TODO optimize.
if (!ItemsIdle()) {
return;
}
// ------ Game Update -------
switch (gameState) {
// Check if move has been valid.
case GameState.MoveCheck:
if (match3.CheckMove(selObj1.X, selObj1.Y, selObj2.X, selObj2.Y)) {
// Move has been valid, swap objects (animation has only changed real positions).
SwapObjects(selObj1, selObj2, false);
possibleHighlightObj.renderer.enabled = false;
gameState = GameState.MatchOrPossibleGet;
}
else {
// Move hasn't been valid, animate items back.
selObj1.AnimateMove(selObj2.transform.position, swapAnimSpeed);
selObj2.AnimateMove(selObj1.transform.position, swapAnimSpeed);
gameState = GameState.Idle;
}
// Clear selection.
selObj1 = null;
selObj2 = null;
break;
// Get matches or possible moves (and check for game over).
case GameState.MatchOrPossibleGet:
// Get matches.
ArrayList matches = match3.GetMatches();
if (matches.Count == 0) {
// No matches found, check for possible moves.
ArrayList possibleMoves = match3.GetPossibleMoves();
if (possibleMoves.Count > 0) {
// There are some possible moves, highlight one of them (by random).
Match3.Point p = possibleMoves[Random.Range(0, possibleMoves.Count)] as Match3.Point;
ShowPossibleMove(p.x, p.y);
gameState = GameState.Idle;
}
else {
// No possible moves found, game is over.
gameState = GameState.GameOver;
}
}
else {
// Matches found.
foreach (ArrayList match in matches) {
foreach (Match3.Point p in match) {
// Animate destroy of matched items.
boardAll[p.x, p.y].AnimateDestroy(destroyAnimSpeed);
}
}
gameState = GameState.ItemGenerateAndDrop;
}
break;
// Generate new items and perform drop.
case GameState.ItemGenerateAndDrop:
// Get drop swaps of existing items.
ArrayList dropSwaps = match3.GetDropSwaps();
// Begin drop animations and swap items data.
foreach (Match3.Point[] p in dropSwaps) {
BoardItem bi1 = boardAll[p[0].x, p[0].y];
BoardItem bi2 = boardAll[p[1].x, p[1].y];
bi1.AnimateMove(GetPosOnBoard(p[1].x, p[1].y), dropAnimSpeed);
SwapObjects(bi1, bi2, false); // Swap without positions.
}
// Get positions of destroyed items (already dropped) and generate new ones.
ArrayList destroyed = match3.GetDestroyedItemsAndGenerateNew();
int lastX = -1, firstDestroyedY = -1;
// Destroy old items, create new ones (above the board) and begin drop animations of them.
foreach (Match3.Point p in destroyed) {
Destroy(boardAll[p.x, p.y].gameObject);
// Get y-coord where to put new items above the board (array is sorted,
// going through every column from left to right, bottom to top.
if (p.x != lastX) {
// New column.
firstDestroyedY = p.y;
lastX = p.x;
}
// Create item with adjusted y-position.
BoardItem clone = CreateBoardItem(p.x, p.y, 0, boardSizeY - firstDestroyedY);
// Begin move animation to the right position.
clone.AnimateMove(GetPosOnBoard(p.x, p.y), dropAnimSpeed);
}
// Check for the new matches.
gameState = GameState.MatchOrPossibleGet;
break;
}
// ----------- Input ----------
// Touch input.
if (Input.touchCount == 1) {
Touch touch = Input.GetTouch(0);
switch (touch.phase) {
case TouchPhase.Began:
MyMouseDown(touch.position);
break;
case TouchPhase.Moved:
MyMouseMove(touch.position);
break;
case TouchPhase.Ended:
case TouchPhase.Canceled:
MyMouseUp(touch.position);
break;
}
}
// Mouse input.
else {
if (Input.GetMouseButtonDown(0)) {
MyMouseDown(Input.mousePosition);
}
else if (Input.GetAxis("Mouse X") != 0 || Input.GetAxis("Mouse Y") != 0) {
MyMouseMove(Input.mousePosition);
}
else if (Input.GetMouseButtonUp(0)) {
MyMouseUp(Input.mousePosition);
}
}
}
/// <summary>
/// Swaps board items - coords, positions, names and updates the boardAll array.
/// </summary>
/// <param name='f'>First item.</param>
/// <param name='s'>Second item.</param>
/// <param name='positions'>If <c>false</c>, real positions are not swapped.</param>
void SwapObjects(BoardItem f, BoardItem s, bool positions = true)
{
// Swap coord properties (position on the board).
int tmpX = f.X; f.X = s.X; s.X = tmpX;
int tmpY = f.Y; f.Y = s.Y; s.Y = tmpY;
// Swap positions (real position in the world).
if (positions) {
Vector3 pos = f.transform.position;
f.transform.position = s.transform.position;
s.transform.position = pos;
}
// Swap names.
string name = f.transform.name;
f.transform.name = s.transform.name;
s.transform.name = name;
// Swap references in array.
BoardItem bi = boardAll[f.X, f.Y];
boardAll[f.X, f.Y] = boardAll[s.X, s.Y];
boardAll[s.X, s.Y] = bi;
}
/// <summary>
/// Called on touch ended/mouse up; resets first selected board item.
/// </summary>
/// <param name='position'>Touch/mouse position.</param>
void MyMouseUp(Vector2 position)
{
if (selObj1) {
selObj1.ResetColor();
selObj1 = null;
}
}
/// <summary>
/// Called on touch/mouse moved; performs swap of board items.
/// </summary>
/// <param name='position'>Touch/mouse position.</param>
void MyMouseMove(Vector2 position)
{
if (!selObj1)
return;
Vector2 dragVec = position - dragOrigin;
if (dragVec.sqrMagnitude >= dragLength * dragLength) {
// Drag detected, perform item swap.
int x1 = selObj1.X;
int y1 = selObj1.Y;
int x2 = x1;
int y2 = y1;
DragDirection dir = GetDragDirFromVec(dragVec);
switch (dir) {
case DragDirection.Left:
x2--;
break;
case DragDirection.Right:
x2++;
break;
case DragDirection.Up:
y2++;
break;
case DragDirection.Down:
y2--;
break;
}
if (x2 >= 0 && x2 < boardSizeX && y2 >= 0 && y2 < boardSizeY) {
selObj2 = boardAll[x2, y2];
// Start swap animation.
selObj1.AnimateMove(selObj2.transform.position, swapAnimSpeed);
selObj2.AnimateMove(selObj1.transform.position, swapAnimSpeed);
gameState = GameState.MoveCheck;
}
selObj1.ResetColor();
}
}
/// <summary>
/// Called on touch began/mouse down; selects board item.
/// </summary>
/// <param name='position'>Touch/mouse position.</param>
void MyMouseDown(Vector2 position)
{
RaycastHit hitInfo = new RaycastHit();
if (Physics.Raycast(Camera.main.ScreenPointToRay(position), out hitInfo)) {
// Save selected object.
selObj1 = hitInfo.transform.gameObject.GetComponent(typeof(BoardItem)) as BoardItem;
// Null if it is not a BoardItem.
if (selObj1) {
selObj1.renderer.material.color *= 1.5f;
dragOrigin = position;
}
}
else {
selObj1 = null;
}
}
public static UndoRedoAction ItemZChanged(BoardItem item, int oldZ, int newZ)
{
return(new UndoRedoAction(item, UndoRedoType.ItemZChanged, oldZ, newZ));
}
private void parentBoard_ShortcutKeyPressed(Board selectedBoard, bool ctrl, bool shift, bool alt, Keys key)
{
lock (parentBoard)
{
if (parentBoard == null || parentBoard.SelectedBoard == null)
{
return;
}
OnUserInteraction();
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 XNA.Point(1, 0)));
}
}
break;
case Keys.Right:
foreach (BoardItem item in selectedBoard.SelectedItems)
{
if (!item.BoundToSelectedItem(selectedBoard))
{
item.X++;
actions.Add(CreateItemUndoMoveAction(item, new XNA.Point(-1, 0)));
}
}
break;
case Keys.Up:
foreach (BoardItem item in selectedBoard.SelectedItems)
{
if (!item.BoundToSelectedItem(selectedBoard))
{
item.Y--;
actions.Add(CreateItemUndoMoveAction(item, new XNA.Point(0, 1)));
}
}
break;
case Keys.Down:
foreach (BoardItem item in selectedBoard.SelectedItems)
{
if (!item.BoundToSelectedItem(selectedBoard))
{
item.Y++;
actions.Add(CreateItemUndoMoveAction(item, new XNA.Point(0, -1)));
}
}
break;
case Keys.Delete:
switch (selectedBoard.Mouse.State)
{
case MouseState.Selection:
bool askedVr = false, askedMm = false;
List <BoardItem> selectedItems = selectedBoard.SelectedItems.ToList(); // Dupe the selection list
foreach (BoardItem item in selectedItems)
{
if (item is ToolTipDot || item is MiscDot)
{
continue;
}
else if (item is VRDot)
{
if (!askedVr)
{
askedVr = true;
if (MessageBox.Show("This will remove the map's VR. This is not undoable, you must re-add VR from the map's main menu. Continue?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
selectedBoard.VRRectangle.RemoveItem(null);
}
}
}
else if (item is MinimapDot)
{
if (!askedMm)
{
askedMm = true;
if (MessageBox.Show("This will remove the map's minimap. This is not undoable, you must re-add the minimap from the map's main menu. Continue?", "Confirm", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.Yes)
{
selectedBoard.MinimapRectangle.RemoveItem(null);
}
}
}
else
{
item.RemoveItem(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, 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.Items)
{
if ((selectedBoard.EditedTypes & item.Type) == item.Type)
{
if (item is LayeredItem)
{
LayeredItem li = (LayeredItem)item;
if (li.CheckIfLayerSelected(selectedBoard.GetUserSelectionInfo()))
{
item.Selected = true;
}
}
else
{
item.Selected = true;
}
}
}
}
clearRedo = false;
break;
case Keys.X: // Cut
if (ctrl && selectedBoard.Mouse.State == MouseState.Selection)
{
Clipboard.SetData(SerializationManager.HaClipboardData,
selectedBoard.SerializationManager.SerializeList(selectedBoard.SelectedItems.Cast <ISerializableSelector>()));
int selectedItemIndex = 0;
while (selectedBoard.SelectedItems.Count > selectedItemIndex)
{
BoardItem item = selectedBoard.SelectedItems[selectedItemIndex];
if (item is ToolTipDot || item is MiscDot || item is VRDot || item is MinimapDot)
{
selectedItemIndex++;
}
else
{
item.RemoveItem(actions);
}
}
break;
}
break;
case Keys.C: // Copy
if (ctrl)
{
Clipboard.SetData(SerializationManager.HaClipboardData,
selectedBoard.SerializationManager.SerializeList(selectedBoard.SelectedItems.Cast <ISerializableSelector>()));
}
break;
case Keys.V: // Paste
if (ctrl && Clipboard.ContainsData(SerializationManager.HaClipboardData))
{
List <ISerializable> items;
try
{
items = selectedBoard.SerializationManager.DeserializeList((string)Clipboard.GetData(SerializationManager.HaClipboardData));
}
catch (SerializationException de)
{
MessageBox.Show(de.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
catch (Exception e)
{
MessageBox.Show(string.Format("An error occurred: {0}", e.ToString()), "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
bool needsLayer = false;
// Make sure we dont have any tS conflicts
string tS = null;
foreach (ISerializable item in items)
{
if (item is TileInstance)
{
TileInstance tile = (TileInstance)item;
string currtS = ((TileInfo)tile.BaseInfo).tS;
if (currtS != tS)
{
if (tS == null)
{
tS = currtS;
}
else
{
MessageBox.Show("Clipboard contains two tiles with different tile sets, cannot paste.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
}
}
if (item is IContainsLayerInfo)
{
needsLayer = true;
}
}
if (needsLayer && (selectedBoard.SelectedLayerIndex < 0 || selectedBoard.SelectedPlatform < 0))
{
MessageBox.Show("Layered items in clipboard and no layer/platform selected, cannot paste.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
if (tS != null && selectedBoard.SelectedLayer.tS != null && tS != selectedBoard.SelectedLayer.tS)
{
MessageBox.Show("Clipboard contains tile in a different set than the current selected layer, cannot paste.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Calculate offsetting
XNA.Point minPos = new XNA.Point(int.MaxValue, int.MaxValue);
XNA.Point maxPos = new XNA.Point(int.MinValue, int.MinValue);
foreach (ISerializable item in items)
{
if (item is BoardItem)
{
BoardItem bi = (BoardItem)item;
if (bi.Left < minPos.X)
{
minPos.X = bi.Left;
}
if (bi.Top < minPos.Y)
{
minPos.Y = bi.Top;
}
if (bi.Right > maxPos.X)
{
maxPos.X = bi.Right;
}
if (bi.Bottom > maxPos.Y)
{
maxPos.Y = bi.Bottom;
}
}
else if (item is Rope)
{
Rope r = (Rope)item;
int x = r.FirstAnchor.X;
int minY = Math.Min(r.FirstAnchor.Y, r.SecondAnchor.Y);
int maxY = Math.Max(r.FirstAnchor.Y, r.SecondAnchor.Y);
if (x < minPos.X)
{
minPos.X = x;
}
if (x > maxPos.X)
{
maxPos.X = x;
}
if (minY < minPos.Y)
{
minPos.Y = minY;
}
if (maxY > maxPos.Y)
{
maxPos.Y = maxY;
}
}
}
XNA.Point center = new XNA.Point((maxPos.X + minPos.X) / 2, (maxPos.Y + minPos.Y) / 2);
XNA.Point offset = new XNA.Point(selectedBoard.Mouse.X - center.X, selectedBoard.Mouse.Y - center.Y);
// Add the items
ClearSelectedItems(selectedBoard);
List <UndoRedoAction> undoPipe = new List <UndoRedoAction>();
foreach (ISerializable item in items)
{
item.AddToBoard(undoPipe);
item.PostDeserializationActions(true, offset);
}
selectedBoard.BoardItems.Sort();
selectedBoard.UndoRedoMan.AddUndoBatch(undoPipe);
}
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.S:
if (ctrl)
{
parentBoard.OnExportRequested();
}
break;
case Keys.O:
if (ctrl)
{
parentBoard.OnLoadRequested();
}
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;
case Keys.W:
if (ctrl)
{
parentBoard.OnCloseTabRequested();
}
break;
case Keys.Tab:
if (ctrl)
{
parentBoard.OnSwitchTabRequested(shift);
}
break;
}
if (actions.Count > 0)
{
selectedBoard.UndoRedoMan.AddUndoBatch(actions);
}
if (clearRedo)
{
selectedBoard.UndoRedoMan.RedoList.Clear();
}
}
}
private UndoRedoAction CreateItemUndoMoveAction(BoardItem item, XNA.Point posChange)
{
if (item is BackgroundInstance)
return UndoRedoManager.BackgroundMoved((BackgroundInstance)item, new XNA.Point(((BackgroundInstance)item).BaseX + posChange.X, ((BackgroundInstance)item).BaseY + posChange.Y), new XNA.Point(((BackgroundInstance)item).BaseX, ((BackgroundInstance)item).BaseY));
else
return UndoRedoManager.ItemMoved(item, new XNA.Point(item.X + posChange.X, item.Y + posChange.Y), new XNA.Point(item.X, item.Y));
}
private void parentBoard_LeftMouseDown(Board selectedBoard, BoardItem item, BoardItem selectedItem, XNA.Point realPosition, XNA.Point virtualPosition, bool selectedItemHigher)
{
lock (parentBoard)
{
OnUserInteraction();
if (ClickOnMinimap(selectedBoard, realPosition) && selectedBoard.Mouse.State == MouseState.Selection)
{
//ClearSelectedItems(selectedBoard);
selectedBoard.Mouse.MinimapBrowseOngoing = true;
HandleMinimapBrowse(selectedBoard, realPosition);
}
else if (selectedBoard.Mouse.State == MouseState.Selection)
{
//handle drag-drop, multiple selection and all that
bool ctrlDown = (Control.ModifierKeys & Keys.Control) == Keys.Control;
if (item == null && selectedItem == null) //drag-selection is starting
{
if (!ctrlDown)
{
ClearSelectedItems(selectedBoard);
}
selectedBoard.Mouse.MultiSelectOngoing = true;
selectedBoard.Mouse.MultiSelectStart = virtualPosition;
}
else //Single click on item
{
BoardItem itemToSelect = null;
bool itemAlreadySelected = false;
if (item == null) // If user didn't click on any non-selected item, we want to keep selectedItem as our bound item
{
itemToSelect = selectedItem;
itemAlreadySelected = true;
}
else if (selectedItem == null) // We are guaranteed (item != null) at this point, so just select item
{
itemToSelect = item;
}
else if (!selectedItemHigher) // item needs to be selected but there is already a selectedItem; only switch selection if the selectedItem is not higher
{
itemToSelect = item;
}
else // Otherwise, just mark selectedItem as the item we are selecting
{
itemToSelect = selectedItem;
itemAlreadySelected = true;
}
if (!itemAlreadySelected && !ctrlDown) // If we are changing selection and ctrl is not down, clear current selected items
{
ClearSelectedItems(selectedBoard);
}
if (ctrlDown) // If we are clicking an item and ctrl IS down, we need to toggle its selection
{
itemToSelect.Selected = !itemToSelect.Selected;
}
else // Otherwise, mark the item as selected (if it's already selected nothing will happen) and bind it to the mouse to start drag-drop action
{
itemToSelect.Selected = true;
selectedBoard.Mouse.SingleSelectStarting = true;
selectedBoard.Mouse.SingleSelectStart = virtualPosition;
//BindAllSelectedItems(selectedBoard); // not binding selected items here because we will bind them after significant movement
}
}
}
}
}
public override void BindItem(BoardItem item, Microsoft.Xna.Framework.Point distance)
{
lock (Board.ParentControl)
{
if (BoundItems.ContainsKey(item))
return;
BoundItems[item] = distance;
item.tempParent = item.Parent;
item.Parent = this;
}
}
private void parentBoard_LeftMouseUp(Board selectedBoard, BoardItem target, BoardItem selectedTarget, XNA.Point realPosition, XNA.Point virtualPosition, bool selectedItemHigher)
{
lock (parentBoard)
{
OnUserInteraction();
if (selectedBoard.Mouse.State == MouseState.Selection)//handle drag-drop selection end
{
ClearBoundItems(selectedBoard);
}
else if (selectedBoard.Mouse.State == MouseState.StaticObjectAdding ||
selectedBoard.Mouse.State == MouseState.RandomTiles ||
selectedBoard.Mouse.State == MouseState.Chairs ||
selectedBoard.Mouse.State == MouseState.Ropes ||
selectedBoard.Mouse.State == MouseState.Tooltip ||
selectedBoard.Mouse.State == MouseState.Clock) //handle clicks that are meant to add an item to the board
{
selectedBoard.Mouse.PlaceObject();
}
else if (selectedBoard.Mouse.State == MouseState.Footholds)
{
selectedBoard.Mouse.TryConnectFoothold();
}
}
}
public void PlaceObject()
{
lock (Board.ParentControl)
{
if (state == MouseState.StaticObjectAdding || state == MouseState.RandomTiles)
{
List<UndoRedoAction> undoPipe = new List<UndoRedoAction>();
currAddedObj.OnItemPlaced(undoPipe);
Board.UndoRedoMan.AddUndoBatch(undoPipe);
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);
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);
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);
Board.BoardItems.Add(currAddedObj, false);
BindItem(currAddedObj, new Microsoft.Xna.Framework.Point());
}
else if (state == MouseState.Ropes)
{
int count = BoundItems.Count;
RopeAnchor anchor = (RopeAnchor)BoundItems.Keys.ElementAt(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;
ToolTipDot dot = (ToolTipDot)BoundItems.Keys.ElementAt(0);
ReleaseItem(dot);
if (count == 1)
{
List<UndoRedoAction> undoPipe = new List<UndoRedoAction>();
dot.ParentTooltip.OnItemPlaced(undoPipe);
Board.UndoRedoMan.AddUndoBatch(undoPipe);
CreateTooltip();
}
}
else if (state == MouseState.Clock)
{
int count = BoundItems.Count;
List<BoardItem> items = BoundItems.Keys.ToList();
Clock clock = null;
foreach (BoardItem item in items)
{
if (item is Clock)
{
clock = (Clock)item;
}
}
foreach (BoardItem item in items)
{
ReleaseItem(item);
}
List<UndoRedoAction> undoPipe = new List<UndoRedoAction>();
clock.OnItemPlaced(undoPipe);
Board.UndoRedoMan.AddUndoBatch(undoPipe);
CreateClock();
}
}
}
public UndoRedoAction(BoardItem item, UndoRedoType type, object ParamA, object ParamB, object ParamC)
: this(item, type, ParamA, ParamB)
{
this.ParamC = ParamC;
}
public void SetChairMode()
{
lock (Board.ParentControl)
{
Clear();
currAddedObj = new Chair(Board, X, Y);
Board.BoardItems.Add(currAddedObj, false);
BindItem(currAddedObj, new Microsoft.Xna.Framework.Point());
state = MouseState.Chairs;
}
}
public static UndoRedoAction ItemMoved(BoardItem item, Point oldPos, Point newPos)
{
return new UndoRedoAction(item, UndoRedoType.ItemMoved, oldPos, newPos);
}
private void parentBoard_MouseDoubleClick(Board selectedBoard, BoardItem target, XNA.Point realPosition, XNA.Point virtualPosition)
{
lock (parentBoard)
{
OnUserInteraction();
if (ClickOnMinimap(selectedBoard, realPosition)) return;
if (target != null)
{
ClearSelectedItems(selectedBoard);
target.Selected = true;
parentBoard.EditInstanceClicked(target);
}
else if (selectedBoard.Mouse.State == MouseState.Footholds)
{
selectedBoard.Mouse.CreateFhAnchor();
}
}
}
private void parentBoard_LeftMouseDown(Board selectedBoard, BoardItem item, BoardItem selectedItem, XNA.Point realPosition, XNA.Point virtualPosition, bool selectedItemHigher)
{
lock (parentBoard)
{
OnUserInteraction();
if (ClickOnMinimap(selectedBoard, realPosition) && selectedBoard.Mouse.State == MouseState.Selection)
{
//ClearSelectedItems(selectedBoard);
selectedBoard.Mouse.MinimapBrowseOngoing = true;
HandleMinimapBrowse(selectedBoard, realPosition);
}
else if (selectedBoard.Mouse.State == MouseState.Selection)
{
//handle drag-drop, multiple selection and all that
bool ctrlDown = (Control.ModifierKeys & Keys.Control) == Keys.Control;
if (item == null && selectedItem == null) //drag-selection is starting
{
if (!ctrlDown)
{
ClearSelectedItems(selectedBoard);
}
selectedBoard.Mouse.MultiSelectOngoing = true;
selectedBoard.Mouse.MultiSelectStart = virtualPosition;
}
else //Single click on item
{
BoardItem itemToSelect = null;
bool itemAlreadySelected = false;
if (item == null) // If user didn't click on any non-selected item, we want to keep selectedItem as our bound item
{
itemToSelect = selectedItem;
itemAlreadySelected = true;
}
else if (selectedItem == null) // We are guaranteed (item != null) at this point, so just select item
{
itemToSelect = item;
}
else if (!selectedItemHigher) // item needs to be selected but there is already a selectedItem; only switch selection if the selectedItem is not higher
{
itemToSelect = item;
}
else // Otherwise, just mark selectedItem as the item we are selecting
{
itemToSelect = selectedItem;
itemAlreadySelected = true;
}
if (!itemAlreadySelected && !ctrlDown) // If we are changing selection and ctrl is not down, clear current selected items
{
ClearSelectedItems(selectedBoard);
}
if (ctrlDown) // If we are clicking an item and ctrl IS down, we need to toggle its selection
{
itemToSelect.Selected = !itemToSelect.Selected;
}
else // Otherwise, mark the item as selected (if it's already selected nothing will happen) and bind it to the mouse to start drag-drop action
{
itemToSelect.Selected = true;
selectedBoard.Mouse.SingleSelectStarting = true;
selectedBoard.Mouse.SingleSelectStart = virtualPosition;
//BindAllSelectedItems(selectedBoard); // not binding selected items here because we will bind them after significant movement
}
}
}
}
}
public static UndoRedoAction ItemDeleted(BoardItem item)
{
return new UndoRedoAction(item, UndoRedoType.ItemDeleted, null, null);
}
private void parentBoard_RightMouseClick(Board selectedBoard, BoardItem rightClickTarget, XNA.Point realPosition, XNA.Point virtualPosition, MouseState mouseState)
{
lock (parentBoard)
{
OnUserInteraction();
if (mouseState == MouseState.Selection)
{
ClearBoundItems(selectedBoard);
if (ClickOnMinimap(selectedBoard, realPosition)) return;
if (rightClickTarget == null)
return;
if (!rightClickTarget.Selected)
ClearSelectedItems(selectedBoard);
rightClickTarget.Selected = true;
BoardItemContextMenu bicm = new BoardItemContextMenu(parentBoard, selectedBoard, rightClickTarget);
bicm.Menu.Show(parentBoard.PointToScreen(new System.Drawing.Point(realPosition.X, realPosition.Y)));
}
else parentBoard.InvokeReturnToSelectionState();
}
}
public static UndoRedoAction ItemsUnlinked(BoardItem parent, BoardItem child, Point distance)
{
return new UndoRedoAction(parent, UndoRedoType.ItemsUnlinked, child, distance);
}
public JsonResult SaveBoardItem(BoardItem boardItem)
{
var currentBoardItem = BoardDbContext.BoardItems.FirstOrDefault(b => b.Id == boardItem.Id && b.UserId == 1);
var isSuccess = false;
if (currentBoardItem != null)
{
currentBoardItem.Title = boardItem.Title;
currentBoardItem.Description = boardItem.Description;
currentBoardItem.IsShowProfile = boardItem.IsShowProfile;
if (currentBoardItem.BoardStructure != boardItem.BoardStructure && !string.IsNullOrWhiteSpace(boardItem.BoardStructure))
{
currentBoardItem.BoardStructure = boardItem.BoardStructure;
ImageHelpers.CombineImages(currentBoardItem.BoardStructure, Server.MapPath("~/App_Data/"),
currentBoardItem.Id.ToString());
currentBoardItem.BoardImageUrl = currentBoardItem.Id.ToString() + ".PNG";
}
isSuccess = BoardDbContext.SaveChanges() > 0;
}
return Json(isSuccess);
}
/// <summary>
/// Makes new board and initializes new game.
/// </summary>
/// <param name='boardSizeX'>Board width.</param>
/// <param name='boardSizeY'>Board height.</param>
/// <param name='variousItemCount'>Various item count.</param>
public void MakeNewBoard(int boardSizeX, int boardSizeY, int variousItemCount)
{
board = new BoardItem[boardSizeX, boardSizeY];
this.boardSizeX = boardSizeX;
this.boardSizeY = boardSizeY;
this.variousItemCount = variousItemCount;
score = 0;
int generateCount = 0;
// Valid board generation.
while (true) {
// Fill the board with random items.
for (int y = 0; y < boardSizeY; y++) {
for (int x = 0; x < boardSizeX; x++) {
board[x, y] = new BoardItem(0, variousItemCount);
}
}
generateCount++;
// Check for existing matches.
if (LookForMatches(false).Count > 0) {
continue;
}
// Check if there is at least one possible move for the player.
ArrayList possibles = LookForPossibles(false);
if (possibles.Count == 0) {
continue;
}
// Suitable board found.
break;
}
Debug.Log("Board re-generated: " + (generateCount - 1).ToString() + "x");
gameState = GameState.GamePlaying;
}
public JsonResult UpdateBoardItem(BoardItem boardItem)
{
var currentBoardItem = BoardDbContext.BoardItems.FirstOrDefault(b => b.Id == boardItem.Id && b.UserId == 1);
var isSuccess = false;
if (currentBoardItem != null)
{
currentBoardItem.Title = boardItem.Title;
currentBoardItem.Description = boardItem.Description;
isSuccess = BoardDbContext.SaveChanges() > 0;
}
return Json(isSuccess);
}
/// <summary>
/// Destroys items in a cross shape.
/// </summary>
/// <returns>Points of destroyed items.</returns>
/// <param name="refBoard">Reference to the game board.</param>
/// <param name="centerX">X-coord of the shape centre.</param>
/// <param name="centerY">Y-coord of the shape centre.</param>
public ArrayList DestroyItemsInCrossShape(BoardItem[,] refBoard, int centerX, int centerY)
{
ArrayList destroyed = new ArrayList();
// X-line.
for (int x = centerX - itemCountX; x <= centerX + itemCountX; x++) {
if (x >= 0 && x < refBoard.GetLength(0)) {
if (!refBoard[x, centerY].destroyed) {
refBoard[x, centerY].destroyed = true;
destroyed.Add(new Point(x, centerY));
}
}
}
// Y-line.
for (int y = centerY - itemCountY; y <= centerY + itemCountY; y++) {
if (y >= 0 && y < refBoard.GetLength(1)) {
if (!refBoard[centerX, y].destroyed) {
refBoard[centerX, y].destroyed = true;
destroyed.Add(new Point(centerX, y));
}
}
}
return destroyed;
}
/// Construtor.
/// <param name="name">Name.</param>
/// <param name="color">color</param>
/// <param name="boardItem">Item.</param>
public Players(string name, ConsoleColor color, BoardItem boardItem)
{
this.Name = name;
this.Color = color;
this.BoardItem = boardItem;
}
