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

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

программный приложение игра балда

Сетевые игры (игры с сетевой структурой) являются разделом теории игр, который изучает как методы формирования связей между игроками в конфликтно-управляемых системах, так и правила определения выигрышей игроков с учётом этих связей. В основном выделяют три подхода к формированию связей между игроками: стратегический, кооперативный и динамический.

При стратегическом подходе сетевую игру можно рассматривать как классическую игру в нормальной форме: каждый игрок независимо выбирает свою стратегию (множество игроков, с которыми он в данный момент желает установить связь и множество игроков, с которыми он связи не устанавливает). В результате выбора формируется сетевая структура, которая и определяет выигрыши игроков.

В кооперативном варианте сетевой игры основной проблемой является выбор правила распределения суммарного выигрыша игроков между собой при некоторой наперед заданной или сформированной самими игроками сетевой структуре. В качестве одного из таких правил распределения можно рассмотреть вектор Шепли (классическое решение теории кооперативных игр), построенный специальным образом с учётом сетевой структуры взаимодействия.

При рассмотрении динамического подхода предполагается, что сетевая структура может пересматриваться игроками поочередно согласно некоторому порядку очередности ходов. Принимающий решение игрок может исключить из сети не приносящую ему выгоды связь, либо предложить другим игрокам взаимовыгодные связи.

«Балда» — лингвистическая настольная игра для 2—4 игроков, в которой необходимо составлять слова с помощью букв, добавляемых определённым образом на квадратное игровое поле. В наиболее популярном варианте игры, который имеет множество компьютерных реализаций, слова составляются посредством переходов от буквы к букве под прямым углом.

1. Общие сведения, обзор аналогов и формирование требований к проектируемому программному средству

1.1 Общие сведения об игре «Балда»

В наиболее популярном варианте игровое поле представляет собой 25-клеточную квадратную таблицу, ячейки/клетки центральной строки которой содержат по одной букве, а строка целиком — произвольное 5-буквенное нарицательное имя существительное в именительном падеже и единственном числе (множественном числе, если слово не имеет единственного числа). Размеры поля, расположение и длина слова могут варьироваться, тем не менее количество пустых клеток в начале игры должно быть чётным, чтобы у обоих игроков было одинаковое количество ходов/слов.

Во время своего хода игрок может добавить букву в клетку, примыкающую по вертикали/горизонтали (в варианте «Королевский квадрат» также по диагонали) к заполненной клетке таким образом, чтобы получалась неразрывная и не самопересекающаяся прямоугольная ломаная («змейка») из клетки с добавленной буквой и других заполненных клеток, представляющая собой слово (соответствующее описанным выше требованиям), или пропустить ход (если оба игрока трижды подряд пропускают ход, то фиксируется ничья). В течение игры должны соблюдаться также следующие правила:

Игроки ходят по очереди (в варианте «Королевский квадрат» для двух игроков ходы двойные, то есть игрок, если не пропускает ход, добавляет подряд две буквы в разные клетки).

Каждая клетка содержит только одну букву, каждая буква в составленном слове приносит игроку одно очко.

Слово должно содержаться хотя бы в одном толковом или энциклопедическом словаре (или энциклопедии), при этом запрещаются аббревиатуры, слова с уменьшительно-ласкательными (банька, дочурка, ножик) и размерно-оценочными суффиксами (домина, зверюга, ножища), если такие слова не имеют специального значения, а также слова, не входящие в состав русского литературного языка, то есть вульгаризмы, диалектизмы и жаргонизмы (имеющие словарные пометы вульг., диал., обл., жарг. и аналогичные, например, сокращённые названия соответствующих регионов).

Слова в одной игре повторяться не могут, даже если это омонимы (в варианте «Королевский квадрат» запрещается составление слов, уже образовавшихся на игровом поле, даже если они не были составлены ни одним из игроков).

Игра заканчивается тогда, когда-либо заполнены все клетки, либо невозможно составить очередное слово согласно указанным выше правилам. Выигрывает тот игрок, который наберёт большее количество очков, кроме случая ничьи после троекратного пропуска хода обоими игроками.

Рисунок 1.1.1 Игра «Балда». Главное игровое поле.

1.2 Обзор аналогов

1. Андройд-приложения «King Square».

Рисунок 1.2.1 Загрузка приложения King Square

Приложение King Square устанавливается на Андройд платформу.

Имеет возможность выбора режима и размера поля. Так же имеет возможность ввода начального слова.

Сетевое взаимодействие осуществляется через сеть-интернет.

Рисунок 1.2.2 Конфигурация игры приложения King Square.

Игра имеет приятный интерфейс. Выделение слова осуществляется через нажатие и ведение по сенсорносу экрану.

Рисунок 1.2.3 Конфигурация игры приложения King Square.

1.3 Требования к проектируемому программному средству

Назначение разработки

Целью разработки приложения является создание приложения, которое представляет собой сетевую игру «Балда» где пользователи могут играть на одном компьютере, либо по сети.

Выполняемые функции

· Выбор режима игры. Доступные режимы:

1. Игра на одном компьютере.

2. Сетевая игра.

· При создании комнаты для игры пользователь может выбрать количество игроков и размер матрицы для ввода слов.

· Приложение может выступать в качестве клиента и сервера одновременно.

· С приложением одновременно могут работать несколько пользователей.

Входные данные

В качестве входных данных используются аутентификационные данные пользователя, команды взаимодействия с интерфейсом.

Выходные данные

В качестве выходных данных используются скачиваемые файлы, описания файлов.

Требования к составу и параметрам технических средств

· Процессор: рекомендуемая частота — 1.0 ГГц и выше.

· ОЗУ: не менее 512 Мб.

· Жесткий диск: 32-bit — не менее 850 Мб, 64-bit — не менее 2 Гб.

Требования к программной совместимости

На компьютере, на котором будет работать приложение, должно быть установлено следующее программное обеспечение:

· .Net Framework 4.5

1.4 Постановка задачи

В рамках данного курсового проекта необходимо разработать программное средство, представляющее собой сетевую игру «Балда». Это приложение должно выполнять функции, описанные в пункте 1.3.

2. Анализ требований к ПС и разработка функциональных требований

2.1 Обоснование выбора технологий

Платформа.NET Framework состоит из общеязыковой среды выполнения (среды CLR) и библиотеки классов.NET Framework. Основой платформы.NET Framework является среда CLR. Среду выполнения можно считать агентом, который управляет кодом во время выполнения и предоставляет основные службы, такие как управление памятью, управление потоками и удаленное взаимодействие. При этом накладываются условия строгой типизации и другие виды проверки точности кода, обеспечивающие безопасность и надежность. Фактически основной задачей среды выполнения является управление кодом. Код, который обращается к среде выполнения, называют управляемым кодом, а код, который не обращается к среде выполнения, называют неуправляемым кодом. Библиотека классов является комплексной объектно-ориентированной коллекцией допускающих повторное использование типов, которые применяются для разработки приложений — начиная с обычных приложений, запускаемых из командной строки, и приложений с графическим интерфейсом пользователя (GUI), и заканчивая приложениями, использующими последние технологические возможности ASP.NET, такие как Web Forms и веб-службы XML.

Класс TcpClient запрашивает данные из ресурса в интернете по протоколу TCP. Методы и свойства TcpClient резюмируют сведения для создания Socket для запроса и получения данных по протоколу TCP. Поскольку подключение к удаленному устройство представлено в виде потока, данные можно считывать и записывать с платформой.NET Framework потокметоды обработки. Протокол TCP устанавливает соединение с удаленной конечной точкой, а затем пользами, соединение отправлять и получать пакеты данных. Протокол TCP отвечает за обеспечение, что пакеты данных отправлены к конечной точке, и сборка, когда они поступают в правильном порядке.

Чтобы установить подключение TCP, необходимо знать адрес устройства сети при размещении службы, и необходимо знать TCP-порт, служба использует для обмена данными.

TcpListener используется для контроля портов для входящих запросов, а затем создать или Сокет или TcpClient, которое управляет подключением клиенту. МетодStart входит прослушивание, а метод Stop отключить прослушивание порта. Метод AcceptTcpClient принимает запросы входящего подключения и создает TcpClientдля обработки запроса, а метод AcceptSocket принимает запросы входящего подключения и создает Сокет для обработки запроса.

В следующем примере показано создание сервер времени сети с помощью монитора TcpListener на TCP-порт 13. При получении запроса входящего подключения, сервер отвечает времени текущей датой и временем из хоста-сервера.

2.2 Спецификация функциональных требований

Работа программы с точки зрения пользователя представлена на EDF0 диаграмме.

Основные этапы функционирования системы.

1. Создание комнаты.

Пользователь на этом этапе выбирает тип игры, количество пользователей и размер матрицы. Создаётся комната. В зависимости от выбранного типа игры производятся настройка прослушивания порта приложения (по умолчанию это 1986). Входные данные этапа — запрос пользователя на начало игры. Выходные данные — выбранный тип игры, параметры игры.

2. Ожидание оппонентов. На этапе ожидания оппонентов поьлзователь ожидает когда друние пользователи подключатся к созданной комнате. Если выбран сетевой режим игры, то этот этап пропускается и управление переходит к этапу «Процесс игры». Входные данные — выбранный тип комнаты. Выходнве данные — список участников.

3. Процесс игры На этом этапе пользователи поочерёдно добавляют буквы на матрицу, выбирают слова, подтверждают их выбор. Процесс продолжается пока в матрице слов есть свободные клетки. Входные данные — список участников, конфигурационные настройки. Выходные данные — заполненная матрица и статистика игроков.

4. Подведение итогов игры.

На этом этапе поднимается статистика выбранных слов. Производится подсчёт букв. Игрок, набравший наибольшее количество букв становится победителем. Входные данные — заполненная матрица и статистика игроков. Выходные данные — результаты игры (имя победителя).

3. Основные классы приложения и их описание

Взаимодействие игровой логики и логики отображения с целью поддержания инкапсуляции происходит при помощи делегатов.

4. Тестирование приложения

Приложение тестировалось на компьютерах следующих конфигураций:

· Intel Core i5−3470 (3.2 GHz), 8 Gb RAM, 500 Gb HDD.

· AMD A8−4500M (1,9 GHz), 6 Gb RAM, 500 Gb HDD.

Тестирование производилось с помощью дополнительно разработанного клиентского приложения.

На каждой из машин было установлено все требуемое программное обеспечение. На этих системах приложение работало быстро, без зависаний.

Все исключительные ситуации в приложении перехватываются и корректно возвращают пользователю соответствующие коды ответов.

Приложение работает стабильно, падений и критических ошибок замечено не было.

Тестирование режима на игры на одном компьютере

Тестирование сетевого режима на игры

5. Руководство пользователя

Разработанное приложение является одновременно и клиентским и серверным. При загрузке приложения появляется форма.

Рисунок 5.1. Внешний вид приложения

Можно выбрать два варианта игры: Игра на одном компьютере и игра на по сети.

При выборе игры на одном компьютере появляется форма настройки комнаты.

Рисунок 5.2 Настройки комнаты

На данном этапе можно указать количество игроков принимающих участие в игре и размер матрицы.

При нажатии кнопки ОК появляется форма для ввода имён пользователей.

Рисунок 5.3. Форма ввода имён пользователей

Затем происходит старт игры. Появляется матрица для выбора букв и ввода слов.

Рисунок 5.4. Выбор ячейки для вставки буквы

В соответствии с правилами можно выбрать только соседнюю ячейку для вставки букв. Затем с клавиатуры набирается буква и нажимается метка «Принять».

Затем происходит выбор слова.

Рисунок 5.5. Выбор слова

Затем слово одобряется. Ход переходит следующему пользователю. Так происходит пока вся матрица не становится заполненной. После этого подводится итог игры и выводится сообщение о победителе.

Рисунок 5.6. Выбор слова

Заключение

В результате работы над курсовым проектом было создано программное средство, представляющее собой сетевую игру «Балда». Игра имеет дружественный интерфейс, два режима работы, высокую надёжность и производительность.

Стоит отметить, что в данном приложении не реализованы все возможности игры «Балда», а только наиболее важные. Тем не менее этого набора хватает для полноценной работы с игрой.

В ходе работы над курсовым проектом мной были изучены средства платформы.Net по работе с сетью и по работе с многопоточными приложениями, т.к. приложение подобного типа требует параллельной работы с несколькими пользователями, а также технология TCPClient и TCPListener.

В ходе работы так же укрепил знания по технологиями.Net таким, как WinForms, сереализация объектов в Xml.

Приложение было сделано в соответствии с принципами ООП. Широко использовалась событийная модель и делегаты.

Список использованных источников

1. Герберт Шилдт. Полный справочник по С# — М.: Издательский дом «Вильямс», 2004. — 752 с.

2. Эндрю Троелсен. Язык программирования C# 2010 и платформа.NET 4.0 — M.: Вильямс, 2010. —1392 c.

3. Мэтью Мак-Дональд C# для профессионалов - М.: Издательский дом «Вильямс», 2010. — 656 с.

4. Википедия [Электронный ресурс]. — Электронные данные. — Режим доступа: http://ru.wikipedia.org/wiki/

5. WPF — Windows Presentation Foundatin[Электронный ресурс]. — Электронные данные. — Режим доступа: http://professorweb.ru/my/WPF/base_WPF/level1/info_WPF.php

6. Windows Presentation Foundation[Электронный ресурс]. — Электронные данные. — Режим доступа: http://msdn.microsoft.com/ru-ru/library/ms754130.aspx

Приложение

Листинг класса NegotiationManager.

using System;

using System.Collections.Generic;

using System. Drawing;

using System. Linq;

using System. Text;

using System.Threading.Tasks;

using System.Windows.Forms;

using BaldaClient. DisplayLogic;

using BaldaClient. NetworkManagment;

using BaldaClient. SettingsManagment;

using BaldaGameLogic. Delegates;

using BaldaGameLogic. GameLogic;

using BaldaGameLogic. GameModel;

namespace BaldaClient. Negotiation

{

public class NegotiationManager

{

#region GameManagment

private GameLogicManager gameLogicManager;

private DisplayManager displayManager;

private NetworkManager networkManager;

public SettingsManager SettingsManager { get; set; }

public GameLogicControls GameLogicControls { get; set; }

public bool IsProcessServer { get; set; }

public BaldaAplicationForm MainForm

{

get;

set;

}

public String ProcessUserName { get; set; }

private LogicCell previousLogicCell;

#endregion

#region GameLogicFlags

public bool IsCellSelectionExpected

{

get { return gameLogicManager. IsCellSelectionExpected; }

set { gameLogicManager. IsCellSelectionExpected = value; }

}

public bool IsLetterSelectionExpected

{

get { return gameLogicManager. IsLetterSelectionExpected; }

set { gameLogicManager. IsLetterSelectionExpected = value; }

}

public bool IsWordSelectionExpected

{

get { return gameLogicManager. IsWordSelectionExpected; }

set { gameLogicManager. IsWordSelectionExpected = value; }

}

public bool IsSelectedNetworkGameMode

{

get { return gameLogicManager. IsSelectedNetworkGameMode; }

set { gameLogicManager. IsSelectedNetworkGameMode = value; }

}

#endregion

public List Players

{

get { return gameLogicManager. Players; }

set { gameLogicManager. Players = value; }

}

public List TempPlayerList { get; set; }

public NegotiationManager (BaldaAplicationForm mainForm)

{

MainForm = mainForm;

gameLogicManager = new GameLogicManager ();

networkManager = new NetworkManager (this);

}

public void AddPlayerToTempPlayerList (String userName)

{

if (TempPlayerList == null)

{

TempPlayerList = new List ();

}

if (TempPlayerList.FirstOrDefault (pl => pl.Name == userName) == null)

{

var number = TempPlayerList. Count + 1;

TempPlayerList.Add (new Player{Name = userName, Number = number});

}

if (gameLogicManager.Settings.PlayerCount == TempPlayerList. Count)

{

gameLogicManager.Players = TempPlayerList;

MainForm.CreateAllPlayersNameControls ();

}

}

private void BindGameManagers ()

{

gameLogicManager.DisplayCells = displayManager. DisplayCells;

gameLogicManager.DisplayCellAsLight = displayManager. DisplayCellsAsLight;

gameLogicManager.DisplayCurrentWord = displayManager. DispalyCurrentWord;

gameLogicManager.DisplayCurrentPlayerName = displayManager. DisplayCurrentPlayerName;

gameLogicManager.DisplayCurrentGuide = displayManager. DisplayCurrentGuide;

gameLogicManager.DisplayCurrentError = displayManager. DisplayCurrentError;

gameLogicManager.AddWordConfirmationButtons =

GameLogicControls.GameForm.CreateWordConfirmationLabels;

gameLogicManager.RemoveConfirmationLabels = GameLogicControls.GameForm.RemoveConfirmationLabels;

gameLogicManager.AddLetterConfirmationButtons = GameLogicControls.GameForm.AddLetterConfirmationLabels;

}

public void ConfigureGame ()

{

ConfigureGameSettings ();

gameLogicManager.CreateGameLogicObjects ();

}

public void ConfigureGameSettings ()

{

gameLogicManager.Settings = SettingsManager. GameLogicSettings;

}

public void StartGame ()

{

gameLogicManager.StartGame ();

displayManager.DrawFullMatrix ();

SetFirstWord («БАЛДА»);

}

private void SetFirstWord (string word)

{

gameLogicManager.SetFirstWord (word);

}

public void TrySelectCell (int xCor, int yCor)

{

var logicCell = displayManager. GetLogicCellByCor (xCor, yCor);

if (logicCell≠ null)

{

if (gameLogicManager.TrySelectCellForInsertingLetter (logicCell))

{

IsLetterSelectionExpected = true;

IsCellSelectionExpected = false;

}

}

}

public void SetLetterToCell (string letter)

{

if (gameLogicManager.LetterIsValidForInserting (letter))

{

gameLogicManager.SetLetterToCell (letter);

}

}

public void TryAddNextCellToWordSelection (int xCor, int yCor)

{

var logicCell = displayManager. GetLogicCellByCor (xCor, yCor);

if (logicCell≠ null && previousLogicCell≠ logicCell)

{

previousLogicCell = logicCell;

if (gameLogicManager.IsLogicCellValidForWordSelection (logicCell))

{

gameLogicManager.AddCellToWordSelection (logicCell);

}

}

}

public void StopWordSelection ()

{

gameLogicManager.StopWordSelection ();

}

public void ConfigureDisplaySettings ()

{

displayManager =

new DisplayManager (GameLogicControls, SettingsManager. DisplaySettings, gameLogicManager. LogicCells);

BindGameManagers ();

}

public void CancelSelectedWord ()

{

gameLogicManager.CancelSelectedWord ();

}

public void AcceptLetter ()

{

gameLogicManager.AcceptLetter ();

}

public void CancelLetter ()

{

gameLogicManager.CancelLetter ();

}

public void AcceptWord ()

{

gameLogicManager.AcceptWord ();

}

public void CreateGameRoom (String userName)

{

IsProcessServer = true;

ProcessUserName = userName;

networkManager.CreateGameRoom ();

networkManager.ConnectToServer («localhost», userName);

}

public void ConnectToRoom (String ipString, String userName)

{

networkManager.ConnectToServer (ipString, userName);

networkManager.SendUserInformation (userName);

}

public void ConfigureGameParameters (List players, int size)

{

var gameLogicSettings = new GameSettings

{

MatrixSize = size,

PlayerCount = players. Count

};

var settingsManager = new SettingsManager

{

GameLogicSettings = gameLogicSettings,

DisplaySettings = new DisplaySettings

{

cellBackgroundColor = Color. Black,

cellBorderColor = Color. Chartreuse,

selectedCellBackroundColor = Color. Bisque,

cellLetterColor = Color. DarkOrange,

StartWorldTextColor = Color. Aqua,

MatrixCellSize = 360 / gameLogicSettings. MatrixSize — 2,

MatrixCellBorderWidth = 2

}

};

SettingsManager = settingsManager;

ConfigureGame ();

Players = players;

MainForm.CreateAllPlayersNameControls ();

}

}

}

public abstract class FtpCommandParserBase

{

protected readonly Dictionary> CommandHandlers =

new Dictionary>

{

{ FtpCommand. Abor, (parser, s) => parser. AborCommandHandler (s) },

{ FtpCommand. Cdup, (parser, s) => parser. CdupCommandHandler (s) },

{ FtpCommand. Cwd, (parser, s) => parser. CwdCommandHandler (s) },

{ FtpCommand. Dele, (parser, s) => parser. DeleCommandHandler (s) },

{ FtpCommand. List, (parser, s) => parser. ListCommandHandler (s) },

{ FtpCommand. Mdtm, (parser, s) => parser. MdtmCommandHandler (s) },

{ FtpCommand. Mkd, (parser, s) => parser. MkdCommandHandler (s) },

{ FtpCommand. Nlst, (parser, s) => parser. NlstCommandHandler (s) },

{ FtpCommand. Noop, (parser, s) => parser. NoopCommandHandler (s) },

{ FtpCommand. Pass, (parser, s) => parser. PassCommandHandler (s) },

{ FtpCommand. Pasv, (parser, s) => parser. PasvCommandHandler (s) },

{ FtpCommand. Port, (parser, s) => parser. PortCommandHandler (s) },

{ FtpCommand. Pwd, (parser, s) => parser. PwdCommandHandler (s) },

{ FtpCommand. Quit, (parser, s) => parser. QuitCommandHandler (s) },

{ FtpCommand. Rein, (parser, s) => parser. ReinCommandHandler (s) },

{ FtpCommand. Retr, (parser, s) => parser. RetrCommandHandler (s) },

{ FtpCommand. Rmd, (parser, s) => parser. RmdCommandHandler (s) },

{ FtpCommand. Rnfr, (parser, s) => parser. RnfrCommandHandler (s) },

{ FtpCommand. Rnto, (parser, s) => parser. RntoCommandHandler (s) },

{ FtpCommand. Size, (parser, s) => parser. SizeCommandHandler (s) },

{ FtpCommand. Stor, (parser, s) => parser. StorCommandHandler (s) },

{ FtpCommand. Stou, (parser, s) => parser. StouCommandHandler (s) },

{ FtpCommand. User, (parser, s) => parser. UserCommandHandler (s) }

};

#region Command delegates

public virtual Action AborCommand { get; set; }

public virtual Action CdupCommand { get; set; }

public virtual Action CwdCommand { get; set; }

public virtual Action DeleCommand { get; set; }

public virtual Action ListCommand { get; set; }

public virtual Action MdtmCommand { get; set; }

public virtual Action MkdCommand { get; set; }

public virtual Action NlstCommand { get; set; }

public virtual Action NoopCommand { get; set; }

public virtual Action PassCommand { get; set; }

public virtual Action PasvCommand { get; set; }

public virtual Action PortCommand { get; set; }

public virtual Action PwdCommand { get; set; }

public virtual Action QuitCommand { get; set; }

public virtual Action ReinCommand { get; set; }

public virtual Action RetrCommand { get; set; }

public virtual Action RmdCommand { get; set; }

public virtual Action RnfrCommand { get; set; }

public virtual Action RntoCommand { get; set; }

public virtual Action SizeCommand { get; set; }

public virtual Action StorCommand { get; set; }

public virtual Action StouCommand { get; set; }

public virtual Action UserCommand { get; set; }

#endregion

#region Command handlers

protected abstract void AborCommandHandler (string parameters);

protected abstract void CdupCommandHandler (string parameters);

protected abstract void CwdCommandHandler (string parameters);

protected abstract void DeleCommandHandler (string parameters);

protected abstract void ListCommandHandler (string parameters);

protected abstract void MdtmCommandHandler (string parameters);

protected abstract void MkdCommandHandler (string parameters);

protected abstract void NlstCommandHandler (string parameters);

protected abstract void NoopCommandHandler (string parameters);

protected abstract void PassCommandHandler (string parameters);

protected abstract void PasvCommandHandler (string parameters);

protected abstract void PortCommandHandler (string parameters);

protected abstract void PwdCommandHandler (string parameters);

protected abstract void QuitCommandHandler (string parameters);

protected abstract void ReinCommandHandler (string parameters);

protected abstract void RetrCommandHandler (string parameters);

protected abstract void RmdCommandHandler (string parameters);

protected abstract void RnfrCommandHandler (string parameters);

protected abstract void RntoCommandHandler (string parameters);

protected abstract void SizeCommandHandler (string parameters);

protected abstract void StorCommandHandler (string parameters);

protected abstract void StouCommandHandler (string parameters);

protected abstract void UserCommandHandler (string parameters);

#endregion

#region Methods

public abstract void Parse (string message);

#endregion

}

public class FtpCommandParser: FtpCommandParserBase

{

#region Fields

private readonly Action _onUnsupportedCommand;

#endregion

#region ctor

public FtpCommandParser (Action onUnsupportedCommandAction = null)

{

if (onUnsupportedCommandAction == null)

_onUnsupportedCommand = c => { throw new UnsupportedFtpCommandException (c); };

else

_onUnsupportedCommand = onUnsupportedCommandAction;

}

#endregion

#region Methods

#region Public methods

public override void Parse (string message)

{

message = message. Trim (' ', 'n', 'r', 't');

if (string.IsNullOrEmpty (message))

return;

string[] parts = message. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

FtpCommand ftpCommand;

if (!FtpCommandHelper.Commands.TryGetValue (parts[0], out ftpCommand))

throw new UnknownFtpCommandException (parts[0]);

CommandHandlers[ftpCommand](this, string. Join (««, parts. Skip (1)));

}

#endregion

#region Private methods

private void InvokeCommand (FtpCommand command, Action commandAction)

{

if (commandAction≠ null)

commandAction ();

else

_onUnsupportedCommand (command);

}

private void InvokeCommand (FtpCommand command, Action commandAction, string parameter)

{

if (commandAction≠ null)

{

if (parameter == null)

throw new IncorrectFtpCommandFormatException (command);

commandAction (parameter);

}

else

_onUnsupportedCommand (command);

}

#endregion

#region FtpCommandParserBase

#region Command handlers

protected override void AborCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Abor, AborCommand);

}

protected override void CdupCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Cdup, CdupCommand);

}

protected override void CwdCommandHandler (string parameters)

{

string[] args = parameters. Split (new []{' '}, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Cwd, CwdCommand, args. Length > 0? args[0]: null);

}

protected override void DeleCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Dele, DeleCommand, args. Length > 0? args[0]: null);

}

protected override void ListCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.List, ListCommand, args. Length > 0? args[0]: string. Empty);

}

protected override void MdtmCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Mdtm, MdtmCommand, args. Length > 0? args[0]: null);

}

protected override void MkdCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Mkd, MkdCommand, args. Length > 0? args[0]: null);

}

protected override void NlstCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Nlst, NlstCommand, args. Length > 0? args[0]: string. Empty);

}

protected override void NoopCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Noop, NoopCommand);

}

protected override void PassCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Pass, PassCommand, args. Length > 0? args[0]: null);

}

protected override void PasvCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Pasv, PasvCommand);

}

protected override void PortCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] {','}, StringSplitOptions. RemoveEmptyEntries);

if (args.Length < 6)

throw new IncorrectFtpCommandFormatException (FtpCommand.Port);

if (PortCommand == null)

{

_onUnsupportedCommand (FtpCommand.Port);

return;

}

long address = 0;

int port = 0;

for (int i = 0; i < 6; i++)

{

byte part;

if (!byte.TryParse (args[i], out part))

throw new IncorrectFtpCommandFormatException (FtpCommand.Port);

if (i < 4)

address += part << (8 * i);

else

port = port * 256 + part;

}

PortCommand (address, port);

}

protected override void PwdCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Pwd, PwdCommand);

}

protected override void QuitCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Quit, QuitCommand);

}

protected override void ReinCommandHandler (string parameters)

{

InvokeCommand (FtpCommand.Rein, ReinCommand);

}

protected override void RetrCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Retr, RetrCommand, args. Length > 0? args[0]: null);

}

protected override void RmdCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Rmd, RmdCommand, args. Length > 0? args[0]: null);

}

protected override void RnfrCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Rnfr, RnfrCommand, args. Length > 0? args[0]: null);

}

protected override void RntoCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Rnto, RntoCommand, args. Length > 0? args[0]: null);

}

protected override void SizeCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Size, SizeCommand, args. Length > 0? args[0]: null);

}

protected override void StorCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Stor, StorCommand, args. Length > 0? args[0]: null);

}

protected override void StouCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.Stou, StouCommand, args. Length > 0? args[0]: string. Empty);

}

protected override void UserCommandHandler (string parameters)

{

string[] args = parameters. Split (new[] { ' ' }, StringSplitOptions. RemoveEmptyEntries);

InvokeCommand (FtpCommand.User, UserCommand, args. Length > 0? args[0]: null);

}

#endregion

#endregion

#endregion

}

Листинг класса FileSystemWorker. cs

public class FileSystemWorker

{

private readonly string _rootDirectory;

private UserRights _userRights;

private FileStream _savingFile;

private FileStream _readingFile;

public const int BufferSize = 1 048 576; //1MB

public FileSystemWorker (string rootDirectory)

{

if (!Directory.Exists (rootDirectory))

throw new DirectoryNotFoundException (rootDirectory);

_rootDirectory = Path. GetFullPath (rootDirectory);

Directory.SetCurrentDirectory (_rootDirectory);

}

public void InitUserRights (UserRights userRights)

{

_userRights = userRights;

}

public void GoToParentDirectory ()

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string currentPath = CheckAndGetCurrentDirectory ();

if (string.Compare (_rootDirectory, currentPath, StringComparison. OrdinalIgnoreCase)≠ 0)

Directory.SetCurrentDirectory (Directory.GetParent (currentPath).FullName);

}

public void GoToRootDirectory ()

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

Directory.SetCurrentDirectory (_rootDirectory);

}

public void ChangeDirecroty (string directory)

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string newPath = Path. Combine (CheckAndGetCurrentDirectory (), directory. TrimStart (new [] { '\', '/' }));

if (!Directory.Exists (newPath))

throw new FileSystemAccessDeniedException ();

Directory.SetCurrentDirectory (newPath);

}

public string CreateDirectory (string directory)

{

if (!_userRights.CanCreate ())

throw new FileSystemAccessDeniedException ();

string path = Path. Combine (CheckAndGetCurrentDirectory (), directory. TrimStart (new[] { '\', '/' }));

if (Directory.Exists (path))

throw new FileSystemException (string.Format («Directory „{0}“ already exists», directory));

try

{

Directory.CreateDirectory (path);

}

catch (IOException ex)

{

throw new FileSystemException (ex.Message.Replace (_rootDirectory, «»));

}

return path. Replace (_rootDirectory, «»);

}

public void RemoveDirectory (string directory)

{

if (!_userRights.CanCreate ())

throw new FileSystemAccessDeniedException ();

string path = Path. Combine (CheckAndGetCurrentDirectory (), directory. TrimStart (new[] { '\', '/' }));

try

{

Directory.Delete (path);

}

catch (IOException)

{

throw new FileSystemAccessDeniedException ();

}

}

public string GetCurrentDirectory ()

{

string path = CheckAndGetCurrentDirectory ().Replace (_rootDirectory, «»);

return Path. IsPathRooted (path)? path: «» + path;

}

public void DeleteFile (string fileName)

{

if (!_userRights.CanCreate ())

throw new FileSystemAccessDeniedException ();

string filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new [] { '\', '/' }));

if (!File.Exists (filePath))

throw new FileSystemAccessDeniedException ();

try

{

File.Delete (filePath);

}

catch (IOException ex)

{

throw new FileSystemException (ex.Message.Replace (_rootDirectory, «»));

}

}

public void RenameFile (string fileName, string newFileName)

{

if (!_userRights.CanCreate ())

throw new FileSystemAccessDeniedException ();

string oldFilePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new[] { '\', '/' }));

if (!File.Exists (oldFilePath))

throw new FileSystemAccessDeniedException ();

string newFilePath = Path. Combine (CheckAndGetCurrentDirectory (), newFileName. TrimStart (new[] { '\', '/' }));

if (File.Exists (newFilePath))

throw new FileSystemException (string.Format («File „{0}“ already exists», newFileName));

try

{

File.Move (oldFilePath, newFilePath);

}

catch (IOException ex)

{

throw new FileSystemException (ex.Message.Replace (_rootDirectory, «»));

}

}

public string BeginWriteFile (string fileName, bool newNameIfExists = false)

{

if (_savingFile≠ null)

throw new Exception («Previous file not saved»);

if (!_userRights.CanUpload ())

throw new FileSystemAccessDeniedException ();

string filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new [] { '\', '/' }));

if (File.Exists (filePath) || string. IsNullOrWhiteSpace (fileName))

{

if (!newNameIfExists)

throw new FileSystemAccessDeniedException ();

fileName = Guid. NewGuid ().ToString ().Substring (0, 8);

filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new [] { '\', '/' }));

}

_savingFile = new FileStream (filePath, FileMode. CreateNew, FileAccess. Write, FileShare. None, BufferSize,

FileOptions.SequentialScan);

return fileName;

}

public void WriteData (byte[] data, int size)

public void EndWriteFile ()

{

if (_savingFile == null)

throw new Exception («File not opened»);

_savingFile.Close ();

_savingFile = null;

}

public void BeginReadFile (string fileName)

{

if (_readingFile≠ null)

throw new Exception («Previous file not closed»);

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new[] { '\', '/' }));

if (!File.Exists (filePath))

throw new FileSystemAccessDeniedException ();

_readingFile = new FileStream (filePath, FileMode. Open, FileAccess. Read, FileShare. Read, BufferSize,

FileOptions.SequentialScan);

}

public int ReadData (byte[] buffer, int size)

if (_readingFile == null

public void EndReadFile ()

{

if (_readingFile == null)

throw new Exception («File not opened»);

_readingFile.Close ();

_readingFile = null;

}

public bool FileExists (string fileName)

{

return File. Exists (Path.Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new[] { '\', '/' })));

}

public bool CanRenameFile ()

{

return _userRights.CanCreate ();

}

public bool CanUploadFile ()

{

return _userRights.CanUpload ();

}

public bool CanDownloadFile ()

{

return _userRights.CanDownload ();

}

public DateTime GetFileModifiedDate (string fileName)

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new[] { '\', '/' }));

if (!File.Exists (filePath))

throw new FileSystemAccessDeniedException ();

return File. GetLastWriteTime (filePath);

}

public long GetFileSize (string fileName)

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string filePath = Path. Combine (CheckAndGetCurrentDirectory (), fileName. TrimStart (new[] { '\', '/' }));

if (!File.Exists (filePath))

throw new FileSystemAccessDeniedException ();

try

{

return new FileInfo (filePath).Length;

}

catch (IOException ex)

{

throw new FileSystemException (ex.Message.Replace (_rootDirectory, «»));

}

}

public string[] GetFileInfo (string fileName, bool onlyNames = false)

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

List files = new List ();

List directories = new List ();

string currentDirectory = CheckAndGetCurrentDirectory ();

string filePath = string. IsNullOrWhiteSpace (fileName)

? currentDirectory

: Path. Combine (currentDirectory, fileName. TrimStart (new[] {'\', '/'}));

if (File.Exists (filePath))

{

files.Add (new FileInfo (filePath));

}

else if (Directory.Exists (filePath))

{

files.AddRange (Directory.GetFiles (filePath).Select (v => new FileInfo (v)));

directories.AddRange (Directory.GetDirectories (filePath).Select (v => new DirectoryInfo (v)));

}

else

{

throw new FileSystemAccessDeniedException ();

}

Func getFileInfo;

Func getDirectoryInfo;

if (onlyNames)

{

getFileInfo =

f => string. Format («t{0}», f.Name.Replace (_rootDirectory, «»));

getDirectoryInfo =

d => string. Format («dirt{0}», d.Name.Replace (_rootDirectory, «»));

}

else

{

getFileInfo =

f => string. Format («t{0}t{1}t{2}», f.Name.Replace (_rootDirectory, «»), f. Length, f. LastWriteTime);

getDirectoryInfo =

d => string. Format («dirt{0}t{1}t{2}», d.Name.Replace (_rootDirectory, «»), «», d. LastWriteTime);

}

List result = new List ();

result.AddRange (

files.Select (

v => getFileInfo (v)));

result.AddRange (

directories.Select (

v => getDirectoryInfo (v)));

return result. ToArray ();

}

private string CheckAndGetCurrentDirectory ()

{

if (!_userRights.CanDownload ())

throw new FileSystemAccessDeniedException ();

string currentDirectory = Directory. GetCurrentDirectory ();

if (!currentDirectory.StartsWith (_rootDirectory))

throw new Exception («Incorrect working directory»);

return currentDirectory;

}

}

Листинг класса DisplayManager

using System;

using System.Collections.Generic;

using System. Drawing;

using System.Drawing.Drawing2D;

using System. Linq;

using System. Text;

using System.Windows.Forms;

using BaldaClient. DisplayModel;

using BaldaGameLogic. GameLogic;

using BaldaGameLogic. GameModel;

namespace BaldaClient. DisplayLogic

{

public class DisplayManager

{

#region Properties for bindings

public GameLogicControls GameControls { get; set; }

#endregion

#region gameLogicFields

private List logicCells;

private List displayCells;

private DisplayCell previousSelectedCell;

private Dictionary cellDictionary;

#endregion

#region forDisplayFields

private int cellBackgroundOffset;

private int cellBackgroundSize;

private int cellTextOffset;

private PictureBox pb;

private Graphics gr;

private Pen pen;

private Brush primaryBrush;

private Brush lightBrush;

private Brush textBrush;

private Font font;

private Label selectedWordLabel;

private DisplaySettings displaySettings;

#endregion

private DisplayCell selectedCellForLetter;

public LogicCell SelectedCellForLetter

{

get { return (selectedCellForLetter≠ null)? selectedCellForLetter. LogicCell: null; }

}

public DisplayManager (GameLogicControls gameLogicControls, DisplaySettings displaySettings, List logiccells)

{

this.GameControls = gameLogicControls;

this.pb = gameLogicControls. pictureBox;

this.selectedWordLabel = gameLogicControls. SelectedWordLabel;

pb.Refresh ();

gr = pb. CreateGraphics ();

this.displaySettings = displaySettings;

pen = new Pen (displaySettings.cellBorderColor, displaySettings. MatrixCellBorderWidth);

primaryBrush = new SolidBrush (displaySettings.cellBackgroundColor);

lightBrush = new SolidBrush (displaySettings.selectedCellBackroundColor);

textBrush = new SolidBrush (displaySettings.cellLetterColor);

font = new Font (FontFamily.GenericMonospace, (displaySettings.MatrixCellSize / 2), FontStyle. Bold);

cellBackgroundOffset = displaySettings. MatrixCellBorderWidth/2;

cellBackgroundSize = displaySettings. MatrixCellSize — displaySettings. MatrixCellBorderWidth;

cellTextOffset = displaySettings. MatrixCellBorderWidth/2 + 6;

logicCells = logiccells;

CreateDisplayCells ();

}

private void CreateDisplayCells ()

{

displayCells = new List ();

cellDictionary = new Dictionary ();

logicCells.ForEach (lc =>

{

var dispayCell = new DisplayCell

{

LogicCell = lc,

offsetX = (lc.X — 1)*displaySettings.MatrixCellSize + cellBackgroundOffset,

offsetY = (lc.Y — 1)*displaySettings.MatrixCellSize + cellBackgroundOffset,

};

displayCells.Add (dispayCell);

cellDictionary.Add (lc, dispayCell);

});

}

public void DrawCell (DisplayCell cell, Brush backGroundBrush)

{

try

{

if (cell≠ null)

{

gr.DrawRectangle (pen, cell. offsetX, cell. offsetY, displaySettings. MatrixCellSize, displaySettings. MatrixCellSize);

gr.FillRectangle (backGroundBrush, cell. offsetX + cellBackgroundOffset, cell. offsetY + cellBackgroundOffset,

cellBackgroundSize, cellBackgroundSize);

if (!String.IsNullOrEmpty (cell.LogicCell.Letter))

gr.DrawString (cell.LogicCell.Letter, font, textBrush, cell. offsetX + cellTextOffset,

cell.offsetY + cellTextOffset);

}

}

catch (Exception ex)

{

throw ex;

}

}

public void DrawLightCell (DisplayCell cell)

{

}

public void DrawFullMatrix ()

{

displayCells.ForEach (cell => DrawCell (cell, primaryBrush));

}

public void DisplayCells (List logCells)

{

logCells.ForEach (lc=> DrawCell (cellDictionary[lc], primaryBrush));

}

public void DisplayCellsAsLight (List logCells)

{

logCells.ForEach (lc => DrawCell (cellDictionary[lc], lightBrush));

}

public bool SelectCellForInsertingLetter (int xCor, int yCor)

{

if (previousSelectedCell≠ null)

{

DrawCell (previousSelectedCell, primaryBrush);

}

LightCellByCor (xCor, yCor);

return true;

}

private void LightCellByCor (int xCor, int yCor)

{

var cell = GetDisplayCellByCor (xCor, yCor);

previousSelectedCell = cell;

DrawCell (cell, lightBrush);

}

private DisplayCell GetDisplayCellByCor (int xCor, int yCor)

{

var logicX = xCor / displaySettings. MatrixCellSize + 1;

var logicY = yCor / displaySettings. MatrixCellSize + 1;

return GetCellByLogicCor (logicX, logicY);

}

private DisplayCell GetCellByLogicCor (int x, int y)

{

return displayCells. FirstOrDefault (cell => (cell.LogicCell.X == x) && (cell.LogicCell.Y == y));

}

public LogicCell GetLogicCellByCor (int x, int y)

{

var logicX = x / displaySettings. MatrixCellSize + 1;

var logicY = y / displaySettings. MatrixCellSize + 1;

var displayCell = GetCellByLogicCor (logicX, logicY);

return (displayCell≠null)? displayCell. LogicCell: null;

}

public void DispalyCurrentWord (string message)

{

selectedWordLabel.Text = message;

}

public void DisplayCurrentPlayerName (string message)

{

GameControls.CurrentPlayerLabel.Text = message;

}

public void DisplayCurrentGuide (string message)

{

GameControls.GuideLabel.Text = message;

}

public void DisplayCurrentError (string message)

{

GameControls.ErrorLabel.Text = message;

}

}

}

using System;

using System.Collections.Generic;

using System. IO;

using System. Linq;

using System.Net;

using System.Net.Sockets;

using System. Text;

using System. Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

public delegate void HandleMassageActivity (String message);

namespace BaldaClient. NetworkModel

{

public class NetworkClient: IDisposable

{

private StreamWriter swSender;

private StreamReader srReceiver;

private TcpClient tcpServer;

private delegate void UpdateLogCallback (string strMessage);

private delegate void CloseConnectionCallback (string strReason);

private Thread thrMessaging;

private IPAddress ipAddr;

private bool Connected;

private HandleMassageActivity HandleMessage;

public NetworkClient (HandleMassageActivity handleMessage)

{

this.HandleMessage = handleMessage;

}

public void ConnectToServer (String ipString, String userName)

{

if (Connected == false)

{

InitializeConnection (ipString, userName);

}

else

{

CloseConnection («Disconnected at user’s request.»);

}

}

private void InitializeConnection (String ipString, String userName)

{

tcpServer = new TcpClient ();

tcpServer.Connect («localhost», 1986);

Connected = true;

swSender = new StreamWriter (tcpServer.GetStream ());

swSender.WriteLine (userName);

swSender.Flush ();

thrMessaging = new Thread (new ThreadStart (ReceiveMessages));

thrMessaging.Start ();

}

private void ReceiveMessages ()

{

srReceiver = new StreamReader (tcpServer.GetStream ());

string ConResponse = srReceiver. ReadLine ();

if (ConResponse[0] == '1')

{

UpdateLog («Connected Successfully!»);

}

else

{

string Reason = «Not Connected: «;

Reason += ConResponse. Substring (2, ConResponse. Length — 2);

UpdateLog (Reason);

return;

}

while (Connected)

{

var newMessage = srReceiver. ReadLine ();

HandleMessage (newMessage);

}

}

private void UpdateLog (string strMessage)

{

Console.WriteLine (strMessage);

}

private void CloseConnection (string Reason)

{

Connected = false;

swSender.Close ();

srReceiver.Close ();

tcpServer.Close ();

}

public void SendMessage (String message)

{

swSender.WriteLine (message);

swSender.Flush ();

}

public void Dispose ()

{

if (Connected == true)

{

Connected = false;

swSender.Close ();

srReceiver.Close ();

tcpServer.Close ();

}

}

}

}

using System;

using System.Collections.Generic;

using System. Linq;

using System. Text;

using BaldaGameLogic. Delegates;

using BaldaGameLogic. GameModel;

namespace BaldaGameLogic. GameLogic

{

public class GameLogicManager

{

public GameSettings Settings { get; set; }

public List LogicCells { get; private set; }

public List MainWordLogicCells { get; private set; }

private LogicCell selectedCell;

public List Players { get; set; }

private List SelectedCellsForWord;

private String selectedWord { get; set; }

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 ();

}

private void CreatePlayersObjects ()

{

Players = new List ();

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 ();

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 ();

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 { 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{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 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 ();

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{SelectedCellsForWord[i]});

}

SelectedCellsForWord = temp;

}

public void AddCellToWordSelection (LogicCell logicCell)

{

SelectedCellsForWord.Add (logicCell);

DisplayCellAsLight (new List (){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{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 ();

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);

}

}

}