private void BoardChoice(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
BoardHexagon control = (BoardHexagon)sender;
int choice = this.board[control];
game.ChooseTurn(choice, this.playerId);
foreach (int i in this.choiceList)
{
int p = i;
this.board[i].Dispatcher.BeginInvoke(
(Action)(() =>
{
this.board[p].SetTileType(TileType.board);
this.board[p].MouseLeftButtonDown -= BoardChoice;
}));
}
control.SetTileType(TileType.board);
UpdateBoard();
lock (semaphor)
{
Monitor.Pulse(semaphor);
}
}
private void InitializeBoard()
{
HexagonTileSerializable[] boardData = game.RetrieveBoardData();
foreach (HexagonTileSerializable tile in boardData)
{
BoardHexagon element = this.GetBoardTile(tile.X, tile.Y, tile.TileType);
this.board.Add(tile.Id, element);
}
}
private void ReplaceEditSpot(HexagonTile tile)
{
BoardHexagon control = hexagonList[tile];
control.MouseLeftButtonDown -= AddHexagonTile;
control.MouseLeftButtonDown += AddNewColour;
control.MouseRightButtonDown += RemoveHexagonTile;
tile.TileType = TileType.board;
tile.TileValue = defaultTileValue;
control.SetTileType(TileType.board);
}
private ITileControl GetBoardTile(double x, double y)
{
BoardHexagon board = new BoardHexagon();
Board.Children.Add(board);
board.SetTileType(TileType.board);
Canvas.SetLeft(board, x);
Canvas.SetTop(board, y);
return board;
}
private void SetDisplayProperties(BoardHexagon boardTile)
{
if (this.displayBoneStructure)
{
boardTile.ShowLinks(true);
boardTile.ShowTileValues(false);
}
else
{
boardTile.ShowLinks(false);
boardTile.ShowTileValues(true);
}
}
private ITileControl GetBoardTile(double x, double y, TileType tileType)
{
BoardHexagon element = new BoardHexagon();
element.SetTileType(tileType);
Board.Children.Add(element);
Canvas.SetLeft(element, x);
Canvas.SetTop(element, y);
return((ITileControl)element);
}
private ITileControl GetBoardTile(double x, double y)
{
BoardHexagon board = new BoardHexagon();
Board.Children.Add(board);
board.SetTileType(TileType.board);
Canvas.SetLeft(board, x);
Canvas.SetTop(board, y);
return(board);
}
void ChooseTurn(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
BoardHexagon control = (BoardHexagon)sender;
control.CurrentTile.TileType = this.turnOrder[this.currentTurn];
control.SetTileType(this.turnOrder[this.currentTurn]);
TurnTilesToCurrentColor(control.CurrentTile);
control.MouseLeftButtonDown -= ChooseTurn;
InitNextTurn();
e.Handled = true;
}
private BoardHexagon GetBoardTile(double x, double y, TileType tileType)
{
BoardHexagon element = new BoardHexagon();
element.SetTileType(tileType);
Board.Children.Add(element);
Canvas.SetLeft(element, x);
Canvas.SetTop(element, y);
element.ShowLinks(false);
return(element);
}
private void AddPropertyToColour(object sender, MouseButtonEventArgs e)
{
if (currentSelection != null && currentSelection.TileType == TileType.none)
{
BoardHexagon control = (BoardHexagon)sender;
if (currentSelection is Fortress)
{
ColorToAdd.Children.Clear();
control.ShowFortress(true);
hexagonList[control].Fortress = true;
}
}
}
private void InitializeBoard()
{
BoardSerializable boardData = this.webservice.RetrieveBoardData(this.gameId);
this.MyFortresses = boardData.FortressesPerPlayer;
this.SetFortressesDisplay();
foreach (HexagonTileSerializable tile in boardData.ActiveTileList)
{
BoardHexagon element = this.GetBoardTile(tile.X, tile.Y, tile.TileType, tile.TileValue);
element.ShowFortress(tile.Fortress);
this.board.Add(tile.Id, element);
}
}
private BoardHexagon GetEditTile(double x, double y)
{
BoardHexagon editTile = new BoardHexagon();
editTile.MouseLeftButtonDown += AddHexagonTile;
Board.Children.Add(editTile);
Canvas.SetLeft(editTile, x);
Canvas.SetTop(editTile, y);
editTile.SetTileType(TileType.none);
SetDisplayProperties(editTile);
return(editTile);
}
private void RemoveColouredTile(object sender, MouseButtonEventArgs e)
{
BoardHexagon control = (BoardHexagon)sender;
control.MouseRightButtonDown -= RemoveColouredTile;
control.MouseLeftButtonDown -= AddPropertyToColour;
control.MouseLeftButtonDown += AddNewColour;
control.MouseRightButtonDown += RemoveHexagonTile;
control.SetTileType(TileType.board);
control.ShowFortress(false);
hexagonList[control].TileType = TileType.board;
CreateMappings();
}
private void BoardChoice(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
BoardHexagon control = (BoardHexagon)sender;
int choice = this.board[control];
game.ChooseTurn(choice, Guid.NewGuid());
foreach (int i in this.choiceList)
{
this.board[i].SetTileType(TileType.board);
this.board[i].MouseLeftButtonDown -= BoardChoice;
}
control.SetTileType(this.currentColor);
InitializeTurn();
}
private BoardHexagon GetBoardTile(double x, double y)
{
BoardHexagon boardTile = new BoardHexagon();
boardTile.MouseLeftButtonDown += AddNewColour;
boardTile.MouseRightButtonDown += RemoveHexagonTile;
Board.Children.Add(boardTile);
boardTile.SetTileType(TileType.board);
Canvas.SetLeft(boardTile, x);
Canvas.SetTop(boardTile, y);
SetDisplayProperties(boardTile);
return(boardTile);
}
public void LoadSaveData(BoardSerializable boardData)
{
Dictionary <HexagonTileSerializable, HexagonTile> mapping = new Dictionary <HexagonTileSerializable, HexagonTile>();
this.hexagonList.Clear();
this.Board.Children.Clear();
foreach (HexagonTileSerializable serializedTile in boardData.ActiveTileList)
{
HexagonTile tile = new HexagonTile()
{
TileType = serializedTile.TileType,
};
if (tile.TileType != TileType.none)
{
mapping.Add(serializedTile, tile);
this.hexagonList.Add(tile);
BoardHexagon board = (BoardHexagon)this.GetBoardTile(serializedTile.X, serializedTile.Y);
tile.Visual = board;
board.SetTileType(tile.TileType);
board.ShowLinks(false);
}
}
foreach (HexagonTile tile in hexagonList)
{
MapUpTile(tile);
}
foreach (HexagonTile tile in hexagonList)
{
tile.Visual.SetLinkCount();
}
this.SetTurn();
}
private void BoardChoice(object sender, System.Windows.Input.MouseButtonEventArgs e)
{
BoardHexagon control = (BoardHexagon)sender;
int choice = this.board[control];
if (!this.FortressSelected)
{
this.webservice.ChooseTurn(this.gameId, this.playerId, choice);
}
else
{
this.webservice.ChooseFortressedTurn(this.gameId, this.playerId, choice);
this.MyFortresses--;
}
this.FortressSelected = false;
this.DisplayFortressSelected();
foreach (int i in this.choiceList)
{
int p = i;
this.board[i].Dispatcher.BeginInvoke(
(Action)(() =>
{
this.board[p].SetTileType(TileType.board);
this.board[p].MouseLeftButtonDown -= BoardChoice;
}));
}
control.SetTileType(TileType.board);
UpdateBoard();
lock (semaphor)
{
Monitor.Pulse(semaphor);
}
}
private void AddNewColour(object sender, MouseButtonEventArgs e)
{
if (currentSelection != null && currentSelection.TileType != TileType.none)
{
ColorToAdd.Children.Clear();
BoardHexagon control = (BoardHexagon)sender;
HexagonTile tile = hexagonList[control];
if (tile.TileType != TileType.none)
{
ReplaceBoardWithColour(tile);
hexagonList[tile].SetLinkCount(tile.LinkCount);
ClearStatus();
}
else
{
throw new Exception("This tile must be active!");
}
}
CreateMappings();
}
private void AddHexagonTile(object sender, MouseButtonEventArgs e)
{
BoardHexagon control = sender as BoardHexagon;
HexagonTile tile = hexagonList[control];
if (tile != null)
{
this.ReplaceEditSpot(tile);
}
if (tile.North == null)
{
tile.North = new HexagonTile()
{
TileType = TileType.none,
South = tile,
TileValue = 0,
};
AddEditSpot(tile.North, tile.X, tile.Y - yFull);
}
if (tile.South == null)
{
tile.South = new HexagonTile()
{
TileType = TileType.none,
North = tile,
TileValue = 0,
};
AddEditSpot(tile.South, tile.X, tile.Y + yFull);
}
if (tile.NorthWest == null)
{
tile.NorthWest = new HexagonTile()
{
TileType = TileType.none,
SouthEast = tile,
TileValue = 0,
};
AddEditSpot(tile.NorthWest, tile.X - xMarge, tile.Y - yMarge);
}
if (tile.NorthEast == null)
{
tile.NorthEast = new HexagonTile()
{
TileType = TileType.none,
SouthWest = tile,
TileValue = 0,
};
AddEditSpot(tile.NorthEast, tile.X + xMarge, tile.Y - yMarge);
}
if (tile.SouthWest == null)
{
tile.SouthWest = new HexagonTile()
{
TileType = TileType.none,
NorthEast = tile,
TileValue = 0,
};
AddEditSpot(tile.SouthWest, tile.X - xMarge, tile.Y + yMarge);
}
if (tile.SouthEast == null)
{
tile.SouthEast = new HexagonTile()
{
TileType = TileType.none,
NorthWest = tile,
TileValue = 0,
};
AddEditSpot(tile.SouthEast, tile.X + xMarge, tile.Y + yMarge);
}
MapUpTile(tile.North);
MapUpTile(tile.NorthWest);
MapUpTile(tile.NorthEast);
MapUpTile(tile.South);
MapUpTile(tile.SouthWest);
MapUpTile(tile.SouthEast);
hexagonList[tile.North].SetLinkCount(tile.North.LinkCount);
hexagonList[tile.NorthWest].SetLinkCount(tile.NorthWest.LinkCount);
hexagonList[tile.NorthEast].SetLinkCount(tile.NorthEast.LinkCount);
hexagonList[tile.South].SetLinkCount(tile.South.LinkCount);
hexagonList[tile.SouthEast].SetLinkCount(tile.SouthEast.LinkCount);
hexagonList[tile.SouthWest].SetLinkCount(tile.SouthWest.LinkCount);
hexagonList[tile].SetLinkCount(tile.LinkCount);
CreateMappings();
}
private ITileControl GetBoardTile(double x, double y, TileType tileType)
{
BoardHexagon element = new BoardHexagon();
element.SetTileType(tileType);
Board.Children.Add(element);
Canvas.SetLeft(element, x);
Canvas.SetTop(element, y);
return (ITileControl)element;
}
private void RemoveHexagonTile(object sender, MouseButtonEventArgs e)
{
BoardHexagon tileControl = sender as BoardHexagon;
HexagonTile tile = hexagonList[tileControl];
HexagonTile[] neighbours =
new[] {
tile.North,
tile.NorthEast,
tile.NorthWest,
tile.South,
tile.SouthEast,
tile.SouthWest,
};
ReplaceBoardTile(tile);
foreach (HexagonTile neighbour in neighbours)
{
if (CanBeRemoved(neighbour))
{
DetachTile(neighbour);
Board.Children.Remove(hexagonList[neighbour]);
hexagonList.Remove(neighbour);
}
}
if (CanBeRemoved(tile))
{
DetachTile(tile);
Board.Children.Remove(hexagonList[tile]);
hexagonList.Remove(tile);
}
if (tile.North != null)
{
hexagonList[tile.North].SetLinkCount(tile.North.LinkCount);
}
if (tile.NorthWest != null)
{
hexagonList[tile.NorthWest].SetLinkCount(tile.NorthWest.LinkCount);
}
if (tile.NorthEast != null)
{
hexagonList[tile.NorthEast].SetLinkCount(tile.NorthEast.LinkCount);
}
if (tile.South != null)
{
hexagonList[tile.South].SetLinkCount(tile.South.LinkCount);
}
if (tile.SouthEast != null)
{
hexagonList[tile.SouthEast].SetLinkCount(tile.SouthEast.LinkCount);
}
if (tile.SouthWest != null)
{
hexagonList[tile.SouthWest].SetLinkCount(tile.SouthWest.LinkCount);
}
hexagonList[tile].SetLinkCount(tile.LinkCount);
CreateMappings();
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
int hexCurrent = 0;
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
BoardHexagon hex = new BoardHexagon();
Canvas.SetLeft(hex, (i * hexWidth) + hexCurrent);
Canvas.SetTop(hex, j * hexHeight);
TheBoard.Children.Add(hex);
elements.Add(hex);
}
if (hexCurrent == 0)
{
hexCurrent += hexOffset;
}
else
{
hexCurrent = 0;
}
}
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
// left top
if (j > 0)
{
CrossSection leftTop = new CrossSection()
{
link1 = elements[((j - 1) * width) + i],
link2 = elements[(j * width) + i],
};
this.crossSections.Add(leftTop);
CreateLine(leftTop);
}
// right top
//if ((i < width - 1)&&(j>0))
//{
// CrossSection rightTop = new CrossSection()
// {
// link1 = elements[((j - 1) * width) + i+1],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(rightTop);
// CreateLine(rightTop);
//}
// left bottom
//if (j < height - 1)
//{
// CrossSection leftTop = new CrossSection()
// {
// link1 = elements[((j + 1) * width) + i],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(leftTop);
// CreateLine(leftTop);
//}
// right bottom
//if ((j < height - 1)&&(i<width-1))
//{
// CrossSection leftTop = new CrossSection()
// {
// link1 = elements[((j + 1) * width) + i+1],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(leftTop);
// CreateLine(leftTop);
//}
}
}
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
int hexCurrent = 0;
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
BoardHexagon hex = new BoardHexagon();
Canvas.SetLeft(hex, (i * hexWidth) + hexCurrent);
Canvas.SetTop(hex, j * hexHeight);
TheBoard.Children.Add(hex);
elements.Add(hex);
}
if (hexCurrent == 0)
{
hexCurrent += hexOffset;
}
else
{
hexCurrent = 0;
}
}
for (int j = 0; j < height; j++)
{
for (int i = 0; i < width; i++)
{
// left top
if (j > 0)
{
CrossSection leftTop = new CrossSection()
{
link1 = elements[((j - 1) * width) + i],
link2 = elements[(j * width) + i],
};
this.crossSections.Add(leftTop);
CreateLine(leftTop);
}
// right top
//if ((i < width - 1)&&(j>0))
//{
// CrossSection rightTop = new CrossSection()
// {
// link1 = elements[((j - 1) * width) + i+1],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(rightTop);
// CreateLine(rightTop);
//}
// left bottom
//if (j < height - 1)
//{
// CrossSection leftTop = new CrossSection()
// {
// link1 = elements[((j + 1) * width) + i],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(leftTop);
// CreateLine(leftTop);
//}
// right bottom
//if ((j < height - 1)&&(i<width-1))
//{
// CrossSection leftTop = new CrossSection()
// {
// link1 = elements[((j + 1) * width) + i+1],
// link2 = elements[(j * width) + i],
// };
// this.crossSections.Add(leftTop);
// CreateLine(leftTop);
//}
}
}
}
public void LoadSaveData(BoardSerializable boardData)
{
Dictionary <HexagonTileSerializable, HexagonTile> mapping = new Dictionary <HexagonTileSerializable, HexagonTile>();
this.hexagonList.Clear();
this.Board.Children.Clear();
this.Fortresses.Text = boardData.FortressesPerPlayer.ToString();
foreach (HexagonTileSerializable serializedTile in boardData.ActiveTileList)
{
HexagonTile tile = new HexagonTile()
{
Id = serializedTile.Id,
TileType = serializedTile.TileType,
X = serializedTile.X,
Y = serializedTile.Y,
TileValue = serializedTile.TileValue,
Fortress = serializedTile.Fortress,
};
mapping.Add(serializedTile, tile);
BoardHexagon board = null;
switch (tile.TileType)
{
case TileType.none:
board = (BoardHexagon)this.GetEditTile(serializedTile.X, serializedTile.Y);
board.SetTileType(tile.TileType);
board.SetTileValue(tile.TileValue);
board.ShowFortress(tile.Fortress);
this.hexagonList.Add(tile, board);
break;
case TileType.board:
board = (BoardHexagon)this.GetBoardTile(serializedTile.X, serializedTile.Y);
board.SetTileType(tile.TileType);
this.hexagonList.Add(tile, board);
board.SetTileValue(tile.TileValue);
board.ShowFortress(tile.Fortress);
break;
case TileType.blue:
case TileType.red:
case TileType.yellow:
board = (BoardHexagon)this.GetBoardTile(serializedTile.X, serializedTile.Y, tile.TileType);
board.SetTileType(tile.TileType);
board.SetTileValue(tile.TileValue);
board.ShowFortress(tile.Fortress);
this.hexagonList.Add(tile, board);
break;
}
}
foreach (HexagonTile tile in hexagonList)
{
MapUpTile(tile);
}
foreach (HexagonTile tile in hexagonList)
{
hexagonList[tile].SetLinkCount(tile.LinkCount);
}
CreateMappings();
}
