/// <summary>
/// Processes new move. Adds it to game logic and UI
/// </summary>
/// <param name="currNode">New node</param>
/// <param name="parentNode">Parent node</param>
/// <param name="parentTileSide">Parent tile side</param>
/// <param name="childTileSide">Child tile side</param>
private void AddNewMove(Node currNode, Node parentNode, Side parentTileSide, Side childTileSide)
{
try {
var point = _tileModelControler.GameTableTileModels.Find(x => x.CurrentNode == parentNode).Connector(parentTileSide);
var t = _tileModelControler.AddTileToGame(currNode, point, parentTileSide, childTileSide);
if (_gameLogic.IsPlayerTurn) // if not player's turn
{
t.Rect.Fill = Brushes.DarkGreen;
}
var selectedTile = _tileModelControler.UserBaseTileModels.Find(x => x.CurrentNode == _newTile.CurrentNode);
Background.Children.Remove(selectedTile);
_tileModelControler.UserBaseTileModels.Remove(selectedTile);
_newTile.CurrentNode = null;
AiTilesCountLabel.Content = _gameLogic.AiTiles.Count;
StockTileCountLable.Content = _gameLogic.TileBase.Count;
}
catch { }
}
private Node Go(Tile tile, Node parentNode, Side parentTileSide, List<Tile> tiles)
{
var newMove = GameMoves.NewMove(tile, parentNode, parentTileSide);
tiles.Remove(tile);
IsPlayerTurn = !IsPlayerTurn;
movesCount++;
return newMove;
}
public Node PlayerMoves(Tile tile, Node node, Side tileSide)
{
if (IsPlayerTurn)
{
var n = Go(tile, node, tileSide, PlayerTiles);
Scoring.CheckGameState(GameMoves, TileBase, PlayerTiles, AiTiles);
return n;
}
else { throw new Exception("Is not player's turn"); }
}
/// <summary>
/// Add tile to game table
/// </summary>
/// <param name="node">New node</param>
/// <param name="point">Point of parent side</param>
/// <param name="parentTileSide">Parent sile side</param>
/// <param name="childTileSide">Child tile side</param>
/// <returns>Added tile model</returns>
public TileModel AddTileToGame(Node node, Point point, Side parentTileSide, Side childTileSide)
{
TileModel tileModel = new TileModel();
SetTileParameters(tileModel,node, point, parentTileSide, childTileSide);
_parentGrid.Children.Add(tileModel);
GameTableTileModels.Add(tileModel);
return tileModel;
}
/// <summary>
/// Set tilemodel centr coords and its rotating angle
/// </summary>
/// <param name="tileModel">Tilemodel which is applied parametrs to</param>
/// <param name="node">Node parameter</param>
/// <param name="point">Point of parent side</param>
/// <param name="parentTileSide">Parent sile side</param>
/// <param name="childTileSide">Child tile side</param>
/// <returns></returns>
private TileModel SetTileParameters(TileModel tileModel, Node node, Point point, Side parentTileSide, Side childTileSide)
{
tileModel.CurrentNode = node;
int angle = 0;
if (parentTileSide != Side.Center)
{
angle = 2 - ((int)parentTileSide) + ((int)childTileSide);
}
tileModel.Angle = angle%4;
var offset = tileModel.OffsetVector(childTileSide);
point.X = point.X - offset.X;
point.Y = point.Y - offset.Y;
tileModel.Center = point;
return tileModel;
}
/// <summary>
/// Add tile to user interface on exact coords
/// </summary>
/// <param name="tile">New tile</param>
/// <param name="point">Point on the table</param>
public void AddTileToUserBase(Tile tile, Point point)
{
TileModel tileModel = new TileModel();
var node = new Node { CurrentTile = tile };
tileModel.CurrentNode = node;
tileModel.Center = point;
tileModel.MouseDown += TileModel_MouseDown;
UserBaseTileModels.Add(tileModel);
_parentGrid.Children.Add(tileModel);
}
public Side GetMatchSide(Node parentNode, Node childNode, Side parentTileSide)
{
var tile = childNode.CurrentTile;
Side childSide = Side.Center;
if (!parentNode.CurrentTile.IsDouble() && (parentTileSide == Side.Left || parentTileSide == Side.Right))
{
throw new Exception("Does not match");
}
if (childNode.CurrentTile.IsDouble())
{
childSide = Side.Left;
}
else
{
if (parentNode.CurrentTile.IsDouble())
{
var value = parentNode.CurrentTile.TopEnd;
if (value == tile.TopEnd)
{
childSide = Side.Top;
}
if (value == tile.BottomEnd)
{
childSide = Side.Bottom;
}
}
else if (parentTileSide == Side.Top)
{
var value = parentNode.CurrentTile.TopEnd;
if (value == tile.TopEnd)
{
childSide = Side.Top;
}
if (value == tile.BottomEnd)
{
childSide = Side.Bottom;
}
}
else if (parentTileSide == Side.Bottom)
{
var value = parentNode.CurrentTile.BottomEnd;
if (value == tile.TopEnd)
{
childSide = Side.Top;
}
if (value == tile.BottomEnd)
{
childSide = Side.Bottom;
}
}
else
{
throw new Exception("Does not match");
}
}
return childSide;
}
public Node FirstMove(Tile tile)
{
var newNode = new Node { CurrentTile = tile };
root = newNode;
return newNode;
}
public void AddNewNode(Node newNode, Side tileSide)
{
switch (tileSide)
{
case Side.Top:
TopNode = newNode;
break;
case Side.Bottom:
BottomNode = newNode;
break;
case Side.Left:
LeftNode = newNode;
break;
case Side.Right:
RigthtNode = newNode;
break;
}
}
private List<Node> LeaveSearchingRecursion(List<KeyValuePair<Side, Node>> NeighbourNodes, Node parentNode)
{
var leaves = new List<Node>();
foreach (var node in NeighbourNodes)
{
var childNeighbourNodes = node.Value.AvailableNeighbourNodes;
childNeighbourNodes.Remove(childNeighbourNodes.Find(x => x.Value == parentNode));
if (childNeighbourNodes.Count == 0 )
{
leaves.Add(node.Value);
}
else if (node.Value.CurrentTile.IsDouble() && childNeighbourNodes.Count < 3)
{
leaves.Add(node.Value);
leaves.AddRange(LeaveSearchingRecursion(childNeighbourNodes, node.Value));
}
else
{
leaves.AddRange(LeaveSearchingRecursion(childNeighbourNodes, node.Value));
}
}
return leaves;
}
public Node NewMove(Tile tile, Node parentNode, Side parentTileSide)
{
var childNode = new Node { CurrentTile = tile };
Side childSide = GetMatchSide(parentNode, childNode, parentTileSide);
parentNode.AddNewNode(childNode, parentTileSide);
childNode.AddNewNode(parentNode, childSide);
childNode.ParentNode = parentNode;
return childNode;
}
/// <summary>
/// Executes at click on tile from base
/// </summary>
/// <param name="node"></param>
private void _tileModelControler_TilePicked(Node node)
{
_newTile.CurrentNode = node;
}
/// <summary>
/// Executes when game logic goes instead of user
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="childNode">Child node</param>
/// <param name="parentSide">Parent tile side</param>
/// <param name="childSide">Child tile side</param>
private void _gameLogic_PlayerMovesEnent(Node parentNode, Node childNode, Side parentSide, Side childSide)
{
var b = _tileModelControler.GameTableTileModels.Find(x => x.CurrentNode == parentNode).Angle;
parentSide = (Side)((4 - b + (int)parentSide) % 4);
AddNewMove(childNode, parentNode, parentSide, childSide);
}
/// <summary>
/// Executes when game logic goes instead of PC
/// </summary>
/// <param name="parentNode">Parent node</param>
/// <param name="childNode">Child node</param>
/// <param name="parentSide">Parent tile side</param>
/// <param name="childSide">Child tile side</param>
private void _gameLogic_AImovesEnent(Node parentNode, Node childNode, Side parentSide, Side childSide)
{
Thread.Sleep(100); //delay before move
var b = _tileModelControler.GameTableTileModels.Find(x => x.CurrentNode == parentNode).Angle;
parentSide = (Side)((4 - b + (int)parentSide) % 4);
AddNewMove(childNode, parentNode, parentSide , childSide);
}
/// <summary>
/// Finds available points to connect new tile
/// </summary>
/// <param name="mouse">Current mouse coordinates</param>
/// <param name="tile">New tile</param>
private void HelpToConnect(Point mouse, Tile tile)
{
if (_gameLogic.IsPlayerTurn)
{
//get match free connectors
var connectors = GetLeavesConnectors(_gameLogic.GameMoves.Leaves).Where(x =>
x.ParentTileModel.CurrentNode.CurrentTile.GetSideValue(x.ConnectorSide) == tile.TopEnd ||
x.ParentTileModel.CurrentNode.CurrentTile.GetSideValue(x.ConnectorSide) == tile.BottomEnd).ToList();
foreach (var item in connectors)
{
var point = item.ConnectorPoint;
Background.Children.Add(new Ellipse { Margin = new Thickness(point.X - 4, point.Y - 4, 0, 0), Fill = Brushes.OrangeRed, Width = 8, Height = 8, VerticalAlignment = VerticalAlignment.Top, HorizontalAlignment = HorizontalAlignment.Left });
}
if (connectors.Count > 0)
{
var points = connectors.Select(x => x.ConnectorPoint).ToList();
var vectors = points.Select(x => (x - mouse)).ToList(); //Vector from mouse to connector
var minLength = points.Select(x => (x - mouse).Length).Min();
var minVectors = vectors.Find(x => x.Length == minLength);
if (minLength <= 70)
{
_nearConnector = connectors.Find(x => x.ConnectorPoint == (mouse + minVectors));
var point = _nearConnector.ConnectorPoint;
var childNode = new Node { CurrentTile = tile };
var parentTileSide = _nearConnector.ConnectorSide;
var childTileSide = _gameLogic.GameMoves.GetMatchSide(_nearConnector.ParentTileModel.CurrentNode, childNode, parentTileSide);
int angle = (2 + _nearConnector.ParentTileModel.Angle - ((int)parentTileSide) + ((int)childTileSide)) % 4;
var offset = _newTile.OffsetVector(childTileSide);
point.X = point.X - offset.X;
point.Y = point.Y - offset.Y;
_newTile.Angle = angle;
_newTile.Center = point;
_newTile.Visibility = Visibility.Visible;
}
else
{
_nearConnector = null;
_newTile.Visibility = Visibility.Hidden;
}
}
else
{
_nearConnector = null;
_newTile.Visibility = Visibility.Hidden;
}
}
}
