Игра "Балда" с поддержкой работы по сети

public PlayerGameStatistic GameStatistic { get; set; }

private Player activePlayer;

#region GameLogicFlags

public bool IsCellSelectionExpected { get; set; }

public bool IsLetterSelectionExpected { get; set; }

public bool IsWordSelectionExpected { get; set; }

public bool IsSelectedNetworkGameMode { get; set; }

public bool IsWordSelected { get; set; }

private bool IsPreviousInvalid;

#endregion

#region GameLogicDelegates

public DisplayMatrixCells DisplayCells { private get; set; }

public DisplayMatrixCells DisplayCellAsLight { private get; set; }

public DisplayMessage DisplayCurrentWord { private get; set; }

public DisplayMessage DisplayCurrentPlayerName { private get; set; }

public DisplayMessage DisplayCurrentGuide { private get; set; }

public DisplayMessage DisplayCurrentError { private get; set; }

public DispalyAction AddWordConfirmationButtons { private get; set; }

public DispalyAction RemoveConfirmationLabels { private get; set; }

public DispalyAction AddLetterConfirmationButtons { private get; set; }

public ConditionAction IsWordExist { private get; set; }



#endregion

public void CreateGameLogicObjects()

{

CreateLogicCells();

CreatePlayersObjects();

SelectedCellsForWord = new List<LogicCell>();

}

private void CreatePlayersObjects()

{

Players = new List<Player>();

for (int i = 1; i <= Settings.PlayerCount; i++)

{

Players.Add(new Player {Number = i, Name = String.Empty});

}

GameStatistic = new PlayerGameStatistic(Players);

}

private void CreateLogicCells()

{

LogicCells = new List<LogicCell>();

for (int i = 1; i <= Settings.MatrixSize; i++)

{

for (int j = 1; j <= Settings.MatrixSize; j++)

{

LogicCells.Add(new LogicCell

{

X = i,

Y = j,

Letter = String.Empty

});

}

}

var middleRowIndex = Settings.MatrixSize / 2 + 1;

MainWordLogicCells = new List<LogicCell>();

LogicCells.Where(cell => cell.Y == middleRowIndex)

.ToList()

.ForEach(cell => { MainWordLogicCells.Add(cell);

cell.IsMainWorldCell = true;

});

}

public void SetFirstWord(String mainWord)

{

if (mainWord.Length!= Settings.MatrixSize)

{

throw new Exception("Start wold more then matrix size");

}

var mainWorldBuilder = new StringBuilder(mainWord);

for (int i = 0; i < Settings.MatrixSize; i++)

{

MainWordLogicCells[i].Letter = mainWorldBuilder[i].ToString();

DisplayCells(MainWordLogicCells);

}

}

public void StartGame()

{

activePlayer = Players.First(pl => pl.Number == 1);

SetCellCelectionStage();

}

public bool TrySelectCellForInsertingLetter(LogicCell logCell)

{

if (!String.IsNullOrEmpty(logCell.Letter))

{

DisplayCurrentError(GamePlayMessages.CellMustBeEmpty);

return false;

}

if (!IsOneOfNeigborsContainsLetter(logCell))

{

DisplayCurrentError(GamePlayMessages.NeighborMustContainLetter);

return false;

}

selectedCell = logCell;

DisplayCellAsLight(new List<LogicCell> { logCell });

DisplayCurrentError(String.Empty);

DisplayCurrentGuide(GamePlayMessages.InsertLetter);

return true;

}

public bool LetterIsValidForInserting(string letter)

{

return true;

}



public void SetLetterToCell(string letter)

{

selectedCell.Letter = letter;

IsLetterSelectionExpected = false;

IsWordSelectionExpected = false;

DisplayCells(new List<LogicCell>{selectedCell});

DisplayCurrentWord(letter);

SetAcceptLetterStage();

}

public bool IsLogicCellValidForWordSelection(LogicCell logCell)

{

if (SelectedCellsForWord!= null)

{

if (String.IsNullOrEmpty(logCell.Letter))

{

IsPreviousInvalid = true;

return false;

}

if (SelectedCellsForWord.Contains(logCell) && (SelectedCellsForWord.Last()!= logCell))

{

{

HandleDoubleCellInWordSelection(logCell);

IsPreviousInvalid = false;

DisplayCurrentWord(GetCurentSelectedWord());

}

return false;

}

if (SelectedCellsForWord.Contains(logCell) && (SelectedCellsForWord.Last() == logCell))

{

return false;

}

if (SelectedCellsForWord.Count!= 0)

{

if (!IsLogicCellsNeighbors(logCell,SelectedCellsForWord.Last()))

{

return false;

}

}

}

return true;

}

private bool IsLogicCellsNeighbors(LogicCell firstCell, LogicCell secondCell)

{

if ((firstCell == null) || (secondCell == null))

{

return false;

}

var neighbors = GetNeighborsForCell(firstCell);

return neighbors.Contains(secondCell);

}



private List<LogicCell> GetNeighborsForCell(LogicCell logicCell)

{

var high = GetCellByLogicCor(logicCell.X, logicCell.Y + 1);

var low = GetCellByLogicCor(logicCell.X, logicCell.Y - 1);

var left = GetCellByLogicCor(logicCell.X - 1, logicCell.Y);

var right = GetCellByLogicCor(logicCell.X + 1, logicCell.Y);

var list = new List<LogicCell>();

if (high!=null) list.Add(high);

if (low!= null) list.Add(low);

if (left!= null) list.Add(left);

if (right!= null) list.Add(right);

return list;

}

private bool IsOneOfNeigborsContainsLetter(LogicCell logicCell)

{

var flag=false;

GetNeighborsForCell(logicCell).ForEach(lc =>

{

if (lc!= null)

{

if (!String.IsNullOrEmpty(lc.Letter))

{

flag = true;

}

}

});

return flag;

}



private LogicCell GetCellByLogicCor(int x, int y)

{

return LogicCells.FirstOrDefault(lc => (lc.X == x) && (lc.Y == y));

}

private void HandleDoubleCellInWordSelection(LogicCell cell)

{

var index = SelectedCellsForWord.IndexOf(cell);

var temp = SelectedCellsForWord.Take(index+1).ToList();

for (int i = index+1; i < SelectedCellsForWord.Count; i++)

{

DisplayCells(new List<LogicCell>{SelectedCellsForWord[i]});

}

SelectedCellsForWord = temp;

}

public void AddCellToWordSelection(LogicCell logicCell)

{

SelectedCellsForWord.Add(logicCell);

DisplayCellAsLight(new List<LogicCell>(){logicCell});

DisplayCurrentWord(GetCurentSelectedWord());

}

private string GetCurentSelectedWord()

{

var selectedWord = String.Empty;

SelectedCellsForWord.ForEach(cell=>selectedWord += cell.Letter);

return selectedWord;

}

public void StopWordSelection()

{

if (IsSelectedWordContainsSelectedCell())

{

SetAcceptWordStage();

}

else

{

DisplayCurrentError(GamePlayMessages.WordMustContainSelectedCell);

}

}

private bool IsSelectedWordContainsSelectedCell()

{

if (SelectedCellsForWord!= null)

{

if (SelectedCellsForWord.Count!= 0)

{

if (selectedCell!= null)

{

return SelectedCellsForWord.Contains(selectedCell);

}

}

}

return false;

}

#region GamePlayAction

public void CancelSelectedWord()

{

RemoveConfirmationLabels();

DisplayCells(SelectedCellsForWord);

SelectedCellsForWord = null;

selectedWord = String.Empty;

SetAcceptLetterStage();

}

public void CancelLetter()

{

selectedCell.Letter = String.Empty;

DisplayCells(new List<LogicCell>{selectedCell});

selectedCell = null;

SetCellCelectionStage();

}

public void AcceptLetter()

{

SetWordSelectionStage();

}

public void AcceptWord()

{

GameStatistic.SetWordToPlayer(activePlayer, selectedWord);

RemoveConfirmationLabels();

DisplayCells(SelectedCellsForWord);

SelectedCellsForWord = null;

SetNextActivePlayer();

SetCellCelectionStage();

}

#endregion

#region SetGamePlayStage

private void SetWordSelectionStage()

{

RemoveConfirmationLabels();

SelectedCellsForWord = new List<LogicCell>();

IsWordSelectionExpected = true;

DisplayCurrentWord(String.Empty);

DisplayCurrentGuide(GamePlayMessages.SelectWord);

DisplayCurrentError(String.Empty);

}

private void SetCellCelectionStage()

{

RemoveConfirmationLabels();

IsCellSelectionExpected = true;

DisplayCurrentPlayerName(activePlayer.Name);

DisplayCurrentGuide(GamePlayMessages.SelectCellForLetter);

DisplayCurrentError(String.Empty);

DisplayCurrentWord(String.Empty);

}



private void SetAcceptLetterStage()

{

RemoveConfirmationLabels();

AddLetterConfirmationButtons();

DisplayCurrentWord(selectedCell.Letter);

DisplayCurrentGuide(GamePlayMessages.AcceptLetter);

DisplayCurrentError(String.Empty);

}

private void SetAcceptWordStage()

{

IsWordSelectionExpected = false;

selectedWord = GetCurentSelectedWord();

DisplayCurrentWord(selectedWord);

DisplayCurrentError(String.Empty);

DisplayCurrentGuide(GamePlayMessages.AcceptWord);

AddWordConfirmationButtons();

}

#endregion

private void SetNextActivePlayer()

{

var index = Players.IndexOf(activePlayer);

if (index == (Players.Count - 1))

{

activePlayer = Players.First();

}

else

{

activePlayer = Players[index + 1];

}

DisplayCurrentPlayerName(activePlayer.Name);

}

}

}

Размещено на Allbest.ru