public FreeThrowsSingleFreePointsProcessor(Domain.Game game,
List <Player> players,
DBService dbService,
ScoreBoardService scoreBoard)
: base(game, players, dbService, scoreBoard)
{
}
public void _180SaveNew(Domain.Game game, Player player)
{
var new180Query = $"INSERT INTO [{Table._180}] ({Column.Player},{Column.Game},{Column.Throw3},{Column.Throw2},{Column.Throw1}, {Column.Timestamp})" +
$" VALUES ('{player.Id}','{game.Id}','{player.HandThrows.Pop().Id}','{player.HandThrows.Pop().Id}','{player.HandThrows.Pop().Id}','{DateTime.Now}')";
ExecuteNonQueryInternal(new180Query);
}
protected ProcessorBase(Domain.Game game,
List <Player> players,
DBService dbService,
ScoreBoardService scoreBoard,
int legs = 0,
int sets = 0)
{
this.dbService = dbService;
this.scoreBoard = scoreBoard;
this.legs = legs;
this.sets = sets;
if (players.Count == 1) // todo maybe do another way cuz ugly
{
players[0].Order = PlayerOrder.First;
}
else
{
players[1].Order = PlayerOrder.Second;
}
Game = game;
Players = players;
PlayerOnThrow = Players.First();
PlayerOnLeg = Players.First();
}
public void StatisticUpdateSetSetsPlayedForPlayer(Domain.Game game)
{
var setSetsPlayedForPlayerQuery = $"UPDATE [{Table.Statistic}] SET [{Column.SetsPlayed}] = {game.Players.Sum(p => p.GameData.SetsWon)} " +
$"WHERE [{Column.Id}] IN (SELECT [{Column.StatisticId}] FROM [{Table.GameStatistic}] " +
$"WHERE [{Column.GameId}] = {game.Id})";
ExecuteNonQueryInternal(setSetsPlayedForPlayerQuery);
}
private void StopGameInternal()
{
Game = null;
detectionService.OnThrowDetected -= OnAnotherThrow;
detectionService.OnStatusChanged -= OnDetectionServiceStatusChanged;
GameProcessor.OnMatchEnd -= OnMatchEnd;
camsDetectionBoard.OnUndoThrowButtonPressed -= OnThrowUndo;
camsDetectionBoard.OnCorrectThrowButtonPressed -= OnThrowCorrect;
}
protected ProcessorBase(Domain.Game game,
ScoreBoardService scoreBoard)
{
this.scoreBoard = scoreBoard;
Game = game;
GameSnapshots = new Stack <GameSnapshot>();
PrepareGame();
}
public int ThrowSaveNew(Throw thrw, Domain.Game game)
{
var newThrowQuery = $"INSERT INTO [{Table.Throws}] ({Column.PlayerId},{Column.GameId},{Column.Sector},{Column.ThrowTypeId},{Column.ThrowResultId},{Column.Number},{Column.Points},{Column.PoiX},{Column.PoiY},{Column.ProjectionResolution},{Column.DateTime})" +
$"VALUES ({thrw.Player.Id},{game.Id},{thrw.Sector},{(int) thrw.Type},{(int) thrw.Result},{thrw.Number}," +
$"{thrw.Points},{thrw.Poi.X.ToString(CultureInfo.InvariantCulture)},{thrw.Poi.Y.ToString(CultureInfo.InvariantCulture)},{thrw.ProjectionResolution},'{thrw.TimeStamp}')";
ExecuteNonQueryInternal(newThrowQuery);
return(Convert.ToInt32(ExecuteScalarInternal($"SELECT MAX({Column.Id}) FROM [{Table.Throws}]")));
}
public void StatisticUpdateAllPlayersSetGameResultAbortedOrError(Domain.Game game)
{
var playersGameStatisticsResultQuery = $"UPDATE [{Table.Statistic}] SET [{Column.GameResultTypeId}] = {(int) game.Result} " +
$"WHERE [{Column.Id}] IN (SELECT [{Column.Id}] FROM [{Table.Statistic}] AS [S] " +
$"INNER JOIN [{Table.GameStatistic}] AS [GS] " +
$"ON [GS].[{Column.GameId}] = {game.Id} " +
$"AND [GS].[{Column.StatisticId}] = [S].[{Column.Id}])";
ExecuteNonQueryInternal(playersGameStatisticsResultQuery);
}
public FreeThrowsDoubleWriteOffPointsProcessor(Domain.Game game,
List <Player> players,
DBService dbService,
ScoreBoardService scoreBoard,
int writeOffPoints)
: base(game, players, dbService, scoreBoard)
{
this.writeOffPoints = writeOffPoints;
players.ForEach(p => p.LegPoints = writeOffPoints);
}
public void StatisticUpdateSetSetsWonForPlayer(Player player, Domain.Game game)
{
var setSetsWonForPlayerQuery = $"UPDATE [{Table.Statistic}] SET [{Column.SetsWon}] = {player.GameData.SetsWon} " +
$"WHERE [{Column.Id}] = (SELECT [{Column.Id}] FROM [{Table.Statistic}] AS [S] " +
$"INNER JOIN [{Table.GameStatistic}] AS [GS] " +
$"ON [GS].[{Column.GameId}] = {game.Id} " +
$"AND [GS].[{Column.StatisticId}] = [S].[{Column.Id}] " +
$"WHERE[{Column.PlayerId}] = {player.Id})";
ExecuteNonQueryInternal(setSetsWonForPlayerQuery);
}
public void _180SaveNew(Hand180 _180Hand, Domain.Game game)
{
var new180Query = $"INSERT INTO [{Table._180}] ({Column.PlayerId},{Column.GameId},{Column.Throw1Id},{Column.Throw2Id},{Column.Throw3Id}, {Column.DateTime})" +
$" VALUES ('{_180Hand.Player.Id}','{game.Id}'," +
$"'{_180Hand.HandThrows.ElementAt(0).Id}'," +
$"'{_180Hand.HandThrows.ElementAt(1).Id}'," +
$"'{_180Hand.HandThrows.ElementAt(2).Id}'," +
$"'{_180Hand.HandThrows.ElementAt(2).TimeStamp}')";
ExecuteNonQueryInternal(new180Query);
}
public static Game From(string playerId, Domain.Game game)
{
return(new Game()
{
ID = game.Id !,
Status = game.Status,
GameType = game.GameType,
IsOpen = game.IsOpen,
AcceptedAt = game.Players.Where(p => p.Id == playerId).Single().AcceptedAt,
StartedAt = game.StartedAt,
EndedAt = game.EndedAt,
});
private void StopGameInternal()
{
Game.EndTimeStamp = DateTime.Now;
SaveGameData();
Game = null;
detectionService.OnThrowDetected -= OnAnotherThrow;
detectionService.OnStatusChanged -= OnDetectionServiceStatusChanged;
GameProcessor.OnMatchEnd -= OnMatchEnd;
scoreBoardService.OnUndoThrowButtonPressed -= OnThrowUndo;
scoreBoardService.OnManualThrowButtonPressed -= OnManualThrow;
}
public async Task <RuntimeResult> GamePortAsync(string name)
{
Domain.Game game = await Database.Games
.FirstOrDefaultAsync(x => x.Name.ToLower() == name.ToLower());
if (game is null)
{
return(new ErrorResult(CommandError.ObjectNotFound, "Game not found"));
}
return(new InfoResult($"{game.Name}'s uses port {game.Port}"));
}
public ClassicDoubleProcessor(Domain.Game game,
List <Player> players,
DBService dbService,
ScoreBoardService scoreBoard,
int legPoints,
int legs,
int sets)
: base(game, players, dbService, scoreBoard, legs, sets)
{
this.legPoints = legPoints;
players.ForEach(p => p.LegPoints = legPoints);
}
public async Task <Domain.Game> UpdateGame(string id, string name, string description)
{
var game = new Domain.Game()
{
Id = id,
Name = name,
Description = description
};
await _gameRepository.Update(game);
return(game);
}
public int GameSaveNew(Domain.Game game)
{
var newGameQuery = $"INSERT INTO [{Table.Games}] ({Column.StartDateTime},{Column.EndDateTime},{Column.GameTypeId})" +
$" VALUES ('{game.StartTimeStamp}','{game.EndTimeStamp}','{(int) game.Type}')";
ExecuteNonQueryInternal(newGameQuery);
var newGameId = Convert.ToInt32(ExecuteScalarInternal($"SELECT MAX({Column.Id}) FROM [{Table.Games}]"));
StatisticSaveNew(newGameId, game.Players);
return(newGameId);
}
public void GameSaveNew(Domain.Game game, List <Player> players)
{
var newGameQuery = $"INSERT INTO [{Table.Games}] ({Column.StartTimestamp},{Column.EndTimestamp},{Column.Type})" +
$" VALUES ('{game.StartTimeStamp}','','{(int) game.Type}')";
ExecuteNonQueryInternal(newGameQuery);
var newGameId = Convert.ToInt32(ExecuteScalarInternal($"SELECT MAX({Column.Id}) FROM [{Table.Games}]"));
game.SetId(newGameId);
StatisticSaveNew(newGameId, players);
}
public async Task <Domain.Game> CreateGame(string name, string description)
{
var game = new Domain.Game
{
Id = GenerateId(),
Name = name,
Description = description,
Phases = CreateInitialPhases()
};
await _gameRepository.Create(game);
return(game);
}
// Выполняет начальную инициализацию игры
protected override void Initialize()
{
// здесь нужно создавать непосредсвенно логическую часть игры, выполнять загрузку данных и т.д
// крч проводить все подготовочные мероприятия
CurrentLogicalGame = Domain.Game.CreateGame();
screenSize = new Vector2(Window.ClientBounds.Width, Window.ClientBounds.Height);
Console.WriteLine(CalculateOffset());
scenes = scenesMaker.GetScenes(CalculateOffset());
Console.WriteLine(screenSize.X);
Console.WriteLine(screenSize.Y);
ChangeCurrentScene(Scenes.MainMenu);
ChangeCurrentScene(Scenes.Univer);
base.Initialize();
}
public async Task <RuntimeResult> StopGameAsync(string name)
{
Domain.Game game = Database.Games
.FirstOrDefault(x => x.Name.ToLower() == name.ToLower());
if (game is null)
{
return(new ErrorResult(CommandError.ObjectNotFound, "Game not found"));
}
await _gameService.StopServer(game, Context);
return(new EmptyResult());
}
public Throw(Player player, Domain.Game game, int sector, ThrowType type, ThrowResult result,
int number, int points, PointF poi, int projectionResolution, int id = -1)
{
Id = id;
Player = player;
Game = game;
Sector = sector;
Type = type;
Result = result;
Number = number;
Points = points;
Poi = poi;
ProjectionResolution = projectionResolution;
TimeStamp = DateTime.Now;
}
public void StatisticUpdateAllPlayersSetGameResultForWinnersAndLosers(Domain.Game game)
{
var winnerGameStatisticsResultQuery = $"UPDATE [{Table.Statistic}] SET [{Column.GameResultTypeId}] = {(int) GameResultType.Win} " +
$"WHERE [{Column.Id}] = (SELECT [{Column.Id}] FROM [{Table.Statistic}] AS [S] " +
$"INNER JOIN [{Table.GameStatistic}] AS [GS] " +
$"ON [GS].[{Column.GameId}] = {game.Id} " +
$"AND [GS].[{Column.StatisticId}] = [S].[{Column.Id}] " +
$"WHERE[{Column.PlayerId}] = {game.Winner.Id})";
var losersGameStatisticsResultQuery = $"UPDATE [{Table.Statistic}] SET [{Column.GameResultTypeId}] = {(int) GameResultType.Loose} " +
$"WHERE [{Column.Id}] IN (SELECT [{Column.Id}] FROM [{Table.Statistic}] AS [S] " +
$"INNER JOIN [{Table.GameStatistic}] AS [GS] " +
$"ON [GS].[{Column.GameId}] = {game.Id} " +
$"AND [GS].[{Column.StatisticId}] = [S].[{Column.Id}] " +
$"WHERE[{Column.PlayerId}] <> {game.Winner.Id})";
ExecuteNonQueryInternal(winnerGameStatisticsResultQuery);
ExecuteNonQueryInternal(losersGameStatisticsResultQuery);
}
public void GameEnd(Domain.Game game,
Player winner = null,
GameResultType gameResultType = GameResultType.NotDefined)
{
var gameEndTimestampQuery = $"UPDATE [{Table.Games}] SET [{Column.EndTimestamp}] = '{DateTime.Now}' " +
$"WHERE [Id] = {game.Id}";
ExecuteNonQueryInternal(gameEndTimestampQuery);
if (gameResultType == GameResultType.Aborted ||
gameResultType == GameResultType.Error)
{
StatisticUpdateAllPlayersSetGameResultAbortedOrError(game.Id, gameResultType);
}
else if (winner != null)
{
StatisticUpdateAllPlayersSetGameResultForWinnersAndLosers(game.Id, winner.Id);
}
}
private void btnNewGame_Click(object sender, EventArgs e)
{
if (String.IsNullOrEmpty(this.tbGameName.Text))
{
MessageBox.Show("Please enter a game name.");
}
else
{
var gameName = this.tbGameName.Text;
var gameAlreadyExists = _dbSession.CreateCriteria <Domain.Game>().List <Domain.Game>()
.Where(x => x.Name == gameName).ToList().Count > 0;
if (gameAlreadyExists)
{
MessageBox.Show("This game already exists.");
}
else
{
try
{
using (var transaction = _dbSession.BeginTransaction())
{
chosenGame = new Domain.Game(gameName);
_dbSession.Save(chosenGame);
transaction.Commit();
}
MessageBox.Show("Game '" + chosenGame.Name + "' created.");;
this.Hide();
}
catch (Exception ex)
{
_logger.Error(ex);
throw;
}
}
}
}
public void StartGame(Player player1,
Player player2,
GameType gameType,
GamePoints gamePoints,
int gameSets,
int gameLegs)
{
var players = new List <Player>();
players.AddIfNotNull(player1);
players.AddIfNotNull(player2);
Game = new Domain.Game(gameType);
dbService.GameSaveNew(Game, players);
switch (gameType)
{
case GameType.FreeThrowsSingle:
switch (gamePoints)
{
case GamePoints.Free:
GameProcessor = new FreeThrowsSingleFreePointsProcessor(Game, players, dbService, scoreBoardService);
scoreBoardService.OpenScoreBoard(gameType, players, "Free throws");
break;
case GamePoints._301:
GameProcessor = new FreeThrowsSingleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 301);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 301", 301);
break;
case GamePoints._501:
GameProcessor = new FreeThrowsSingleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 501);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 501", 501);
break;
case GamePoints._701:
GameProcessor = new FreeThrowsSingleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 701);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 701", 701);
break;
case GamePoints._1001:
GameProcessor = new FreeThrowsSingleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 1001);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 1001", 1001);
break;
default:
throw new ArgumentOutOfRangeException(nameof(gamePoints), gamePoints, null);
}
break;
case GameType.FreeThrowsDouble:
switch (gamePoints)
{
case GamePoints.Free:
GameProcessor = new FreeThrowsDoubleFreePointsProcessor(Game, players, dbService, scoreBoardService);
scoreBoardService.OpenScoreBoard(gameType, players, "Free throws");
break;
case GamePoints._301:
GameProcessor = new FreeThrowsDoubleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 301);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 301", 301);
break;
case GamePoints._501:
GameProcessor = new FreeThrowsDoubleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 501);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 501", 501);
break;
case GamePoints._701:
GameProcessor = new FreeThrowsDoubleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 701);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 701", 701);
break;
case GamePoints._1001:
GameProcessor = new FreeThrowsDoubleWriteOffPointsProcessor(Game, players, dbService, scoreBoardService, 1001);
scoreBoardService.OpenScoreBoard(gameType, players, "Write off 1001", 1001);
break;
}
break;
case GameType.Classic:
switch (gamePoints)
{
case GamePoints._301:
GameProcessor = new ClassicDoubleProcessor(Game, players, dbService, scoreBoardService, 301, gameLegs, gameSets);
scoreBoardService.OpenScoreBoard(gameType, players, $"First to {gameSets}", 301);
break;
case GamePoints._501:
GameProcessor = new ClassicDoubleProcessor(Game, players, dbService, scoreBoardService, 501, gameLegs, gameSets);
scoreBoardService.OpenScoreBoard(gameType, players, $"First to {gameSets}", 501);
break;
case GamePoints._701:
GameProcessor = new ClassicDoubleProcessor(Game, players, dbService, scoreBoardService, 701, gameLegs, gameSets);
scoreBoardService.OpenScoreBoard(gameType, players, $"First to {gameSets}", 701);
break;
case GamePoints._1001:
GameProcessor = new ClassicDoubleProcessor(Game, players, dbService, scoreBoardService, 1001, gameLegs, gameSets);
scoreBoardService.OpenScoreBoard(gameType, players, $"First to {gameSets}", 1001);
break;
}
break;
default:
throw new ArgumentOutOfRangeException();
}
detectionService.OnThrowDetected += OnAnotherThrow;
detectionService.OnStatusChanged += OnDetectionServiceStatusChanged;
GameProcessor.OnMatchEnd += OnMatchEnd;
camsDetectionBoard.OnUndoThrowButtonPressed += OnThrowUndo;
camsDetectionBoard.OnCorrectThrowButtonPressed += OnThrowCorrect;
}
public FreeThrowsDoubleFreePointsProcessor(Domain.Game game,
ScoreBoardService scoreBoard)
: base(game, scoreBoard)
{
}
public FreeThrowsSingleWriteOffPointsProcessor(Domain.Game game,
ScoreBoardService scoreBoard)
: base(game, scoreBoard)
{
}
public ClassicDoubleProcessor(Domain.Game game,
ScoreBoardService scoreBoard)
: base(game, scoreBoard)
{
}
public void StartGame(List <Player> players,
GameType gameType,
GamePoints gamePoints,
int gameSets,
int gameLegs)
{
Game = new Domain.Game(gameType, players, gameLegs, gameSets, gamePoints);
scoreBoardService.OpenScoreBoard(Game);
switch (gameType) // todo ugly-spaghetti
{
case GameType.FreeThrowsSingle:
switch (gamePoints)
{
case GamePoints.Free:
GameProcessor = new FreeThrowsSingleFreePointsProcessor(Game, scoreBoardService);
break;
case GamePoints._301:
case GamePoints._501:
case GamePoints._701:
case GamePoints._1001:
GameProcessor = new FreeThrowsSingleWriteOffPointsProcessor(Game, scoreBoardService);
break;
default:
throw new ArgumentOutOfRangeException(nameof(gamePoints), gamePoints, null);
}
break;
case GameType.FreeThrowsDouble:
switch (gamePoints)
{
case GamePoints.Free:
GameProcessor = new FreeThrowsDoubleFreePointsProcessor(Game, scoreBoardService);
break;
case GamePoints._301:
case GamePoints._501:
case GamePoints._701:
case GamePoints._1001:
GameProcessor = new FreeThrowsDoubleWriteOffPointsProcessor(Game, scoreBoardService);
break;
}
break;
case GameType.Classic:
GameProcessor = new ClassicDoubleProcessor(Game, scoreBoardService);
break;
default:
throw new ArgumentOutOfRangeException();
}
detectionService.OnThrowDetected += OnAnotherThrow;
detectionService.OnStatusChanged += OnDetectionServiceStatusChanged;
GameProcessor.OnMatchEnd += OnMatchEnd;
scoreBoardService.OnUndoThrowButtonPressed += OnThrowUndo;
scoreBoardService.OnManualThrowButtonPressed += OnManualThrow;
}
