public void AddNewDomino(DominoModel domino)
{
if (!HasDominoToPlace())
{
Dominos.Add(domino);
}
}
public void TryAddDomino(DominoModel domino, DominoModel edgeDomino)
{
var edge = edgeDomino == PreviousDomino ? EdgeToAdd.Left : EdgeToAdd.Right;
switch (edge)
{
case EdgeToAdd.Left:
{
MovePrevDomino(domino);
Dominos.Prepend(domino);
TableCollectionDominoAdded?.Invoke(domino);
LeftNumber = domino.First == LeftNumber ? domino.Second : domino.First;
break;
}
case EdgeToAdd.Right:
{
MoveNextDomino(domino);
Dominos.Add(domino);
TableCollectionDominoAdded?.Invoke(domino);
RightNumber = domino.First == RightNumber ? domino.Second : domino.First;
break;
}
}
}
private void TableDominosCollection_TableCollectionDominoAdded(DominoModel domino)
{
if (Dominos.Contains(domino))
{
Dominos.Remove(domino);
}
}
private int LaterPryd(DominoModel domino)
{
var availableDominosWithoutSelected = GetAvailableDominos().Where(d => !d.Equals(domino)).ToList();
var counter = 0;
counter = availableDominosWithoutSelected.Exists(d => d.First == domino.First || d.Second == domino.First) ?
++counter : counter;
counter = availableDominosWithoutSelected.Exists(d => d.First == domino.Second || d.Second == domino.Second) ?
++counter : counter;
return(counter);
}
private bool IsOnlyMove(out DominoModel domino)
{
var availableDominos = GetAvailableDominos();
if (availableDominos.Count == 1)
{
domino = availableDominos.Single();
return(true);
}
domino = null;
return(false);
}
public void AddToRight(DominoModel domino)
{
if (IsDominoOkForRight(domino))
{
if (RightNumber != domino.First)
{
domino.SwapValues();
}
RightNumber = domino.Second;
Dominos.Add(domino);
}
}
public void AddToLeft(DominoModel domino)
{
if (IsDominoOkForLeft(domino))
{
if (LeftNumber != domino.Second)
{
domino.SwapValues();
}
LeftNumber = domino.First;
Dominos.Insert(0, domino);
}
}
private GameStatusModel GetGameStatus()
{
HashSet <DominoModel> historySet = new HashSet <DominoModel>();
foreach (DominoController domino in history.horizontalDominoes)
{
historySet.Add(Utility.DominoControllerToDominoModel(domino));
}
foreach (DominoController domino in history.verticalDominoes)
{
historySet.Add(Utility.DominoControllerToDominoModel(domino));
}
HashSet <DominoModel> playerSet = new HashSet <DominoModel>();
foreach (DominoController domino in dominoControllers)
{
playerSet.Add(Utility.DominoControllerToDominoModel(domino));
}
DominoModel left = null;
DominoModel right = null;
DominoModel upper = null;
DominoModel lower = null;
if (history.horizontalDominoes.Count > 0)
{
DominoController domino = history.horizontalDominoes[0];
left = Utility.DominoControllerToDominoModel(domino);
}
if (history.horizontalDominoes.Count > 0)
{
DominoController domino = history.horizontalDominoes[history.horizontalDominoes.Count - 1];
right = Utility.DominoControllerToDominoModel(domino);
}
if (history.verticalDominoes.Count > 0)
{
DominoController domino = history.verticalDominoes[0];
upper = Utility.DominoControllerToDominoModel(domino);
}
if (history.verticalDominoes.Count > 0)
{
DominoController domino = history.verticalDominoes[history.verticalDominoes.Count - 1];
lower = Utility.DominoControllerToDominoModel(domino);
}
return(new Model.GameStatusModel(historySet, playerSet, left, right, upper, lower));
}
public TableDominoResourceCollection(DominoModel startDomino)
{
TopDominos = GetHorizontalBackDominos().ToList();
TopDominos[3].ImageResource = $"Images/_{startDomino.First}h{startDomino.Second}_.png";
Dominos = new List <DominoModel>
{
startDomino
};
PreviousDomino = TopDominos[2];
_isPrevHorizontal = true;
NextDomino = TopDominos[4];
_isNextHorizontal = true;
LeftNumber = startDomino.First;
RightNumber = startDomino.Second;
BottomDominos = GetHorizontalBackDominos().ToList();
LeftDominos = GetVerticalBackDominos().ToList();
RightDominos = GetVerticalBackDominos().ToList();
}
private void MoveNextDomino(DominoModel domino)
{
var notEdgeSide = domino.First == RightNumber ? domino.Second : domino.First;
if (TopDominos.Exists(d => d == NextDomino))
{
domino.ImageResource = $"Images/_{RightNumber}h{notEdgeSide}_.png";
if (TopDominos.Last() == NextDomino)
{
TopDominos[6] = domino;
NextDomino = RightDominos.First();
_isNextHorizontal = false;
}
else
{
var nextDominoIndex = TopDominos.FindIndex(d => d == NextDomino);
TopDominos[nextDominoIndex] = domino;
NextDomino = TopDominos[nextDominoIndex + 1];
}
}
else if (LeftDominos.Exists(d => d == NextDomino))
{
domino.ImageResource = $"Images/_{notEdgeSide}v{RightNumber}_.png";
if (LeftDominos.First() == NextDomino)
{
LeftDominos[0] = domino;
NextDomino = TopDominos.First();
_isNextHorizontal = true;
}
else
{
var nextDominoIndex = LeftDominos.FindIndex(d => d == NextDomino);
LeftDominos[nextDominoIndex] = domino;
NextDomino = LeftDominos[nextDominoIndex - 1];
}
}
else if (RightDominos.Exists(d => d == NextDomino))
{
domino.ImageResource = $"Images/_{RightNumber}v{notEdgeSide}_.png";
if (RightDominos.Last() == NextDomino)
{
RightDominos[6] = domino;
NextDomino = BottomDominos.Last();
_isNextHorizontal = true;
}
else
{
var nextDominoIndex = RightDominos.FindIndex(d => d == NextDomino);
RightDominos[nextDominoIndex] = domino;
NextDomino = RightDominos[nextDominoIndex + 1];
}
}
else if (BottomDominos.Exists(d => d == NextDomino))
{
domino.ImageResource = $"Images/_{notEdgeSide}h{RightNumber}_.png";
if (BottomDominos.First() == NextDomino)
{
BottomDominos[0] = domino;
NextDomino = LeftDominos.Last();
_isNextHorizontal = false;
}
else
{
var nextDominoIndex = BottomDominos.FindIndex(d => d == NextDomino);
BottomDominos[nextDominoIndex] = domino;
NextDomino = BottomDominos[nextDominoIndex - 1];
}
}
}
public bool IsDominoOkForLeft(DominoModel dominoModel)
{
return(LeftNumber == dominoModel.First || LeftNumber == dominoModel.Second);
}
public bool IsDominoOkForRight(DominoModel dominoModel)
{
return(RightNumber == dominoModel.First || RightNumber == dominoModel.Second);
}
private bool GetPressureCalculatedWithTable(out DominoModel domino)
{
/*var edgeValues = new List<byte> { _logicService.TableRightNumber, _logicService.TableLeftNumber };
* _logicService.MyDominos.Join(edgeValues, d=>d.First, d=>d, (a, b)=> new {First = a. })*/
var dictionary = new SortedDictionary <int, int>();
_logicService.MyDominos.ForEach(d =>
{
if (dictionary.ContainsKey(d.First))
{
dictionary[d.First]++;
}
else
{
dictionary.Add(d.First, 1);
}
if (dictionary.ContainsKey(d.Second))
{
dictionary[d.Second]++;
}
else
{
dictionary.Add(d.Second, 1);
}
});
_logicService.TableDominos.ForEach(d =>
{
if (dictionary.ContainsKey(d.First))
{
dictionary[d.First]++;
}
if (dictionary.ContainsKey(d.Second))
{
dictionary[d.Second]++;
}
});
DominoModel result = null;
dictionary.Where(p => p.Value >= 6).ToList().ForEach(d =>
{
var availableDominos = GetAvailableDominos(d.Key);
if (availableDominos.Count != 0)
{
result = availableDominos.LastOrDefault();
}
});
if (result != null)
{
domino = result;
return(true);
}
domino = null;
return(false);
}
