public void CreateGameTest()
{
//Arrange
GameController gameController = new GameController();
IGameDBIF gameDB = new GameDB();
IGameTableDBIF gameTableDB = new GameTableDB();
List <GameTableModel> gameTables = (List <GameTableModel>)gameTableDB.GetAll();
GameTableModel gameTable = null;
bool found = false;
Game game = new Game();
//Act
if (gameTables.Count > 0)
{
for (int i = 0; i < gameTables.Count && !found; i++)
{
if (gameController.GetByTableId(gameTables[i].Id) == null)
{
gameTable = gameTables[i];
found = true;
}
}
game.gameTable = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTable);
gameController.CreateGame(game);
}
GameModel gameModel = gameController.GetByTableId(gameTable.Id);
//Assert
Assert.IsNotNull(gameModel);
//Cleanup
gameDB.Delete(gameModel);
}
public void InsertTest()
{
//Arrange
gameTableDB = new GameTableDB();
bool found = false;
var table = new GameTableModel("TestTable");
table.DeckId = 2;
//Act
gameTableDB.Insert(table);
List <GameTableModel> gameTables = gameTableDB.GetAll().ToList();
for (int i = 0; i < gameTables.Count && !found; i++)
{
if (gameTables[i].TableName == table.TableName)
{
table.Id = gameTables[i].Id;
}
}
var tableT = gameTableDB.GetById(table.Id);
//Assert
Assert.AreEqual(table.TableName, tableT.TableName);
//Cleanup
gameTableDB.Delete(table);
}
public void DeleteTest()
{
//Arrange
GameTableServiceAccess gameTableServiceAccess = new GameTableServiceAccess();
CGUserModel userModel = new CGUserModel {
Id = "Test",
Email = "*****@*****.**",
UserName = "******"
};
GameTableModel tableModel = null;
gameTableServiceAccess.CreateGameTable(userModel, "TestTable");
List <GameTableModel> tables = gameTableServiceAccess.GetAll();
foreach (var table in tables)
{
if (table.TableName == "TestTable")
{
tableModel = table;
}
}
bool res = false;
//Act
res = gameTableServiceAccess.Delete(tableModel.Id);
//Assert
Assert.IsTrue(res);
}
public void Delete(GameTableModel table)
{
using (SqlConnection connection = new SqlConnection(conString)) {
connection.Open();
var sql = "DELETE FROM GameTable WHERE id = @id;";
connection.Execute(sql, table);
}
}
public void Insert(GameTableModel gameTable)
{
using (SqlConnection connection = new SqlConnection(conString)) {
connection.Open();
var sql = "INSERT INTO GameTable (tableName, seats, deckId) VALUES (@TableName, @seats, @DeckId)";
connection.Execute(sql, gameTable);
}
}
public void UpdateGameTableSeats(GameTableModel table, int seats)
{
var sql = "UPDATE GameTable SET seats = seats - @seats WHERE id = @id;";
using (SqlConnection connection = new SqlConnection(conString)) {
connection.Execute(sql, new { id = table.Id, seats = seats });
}
}
public int GetGameTableSeats(GameTableModel table)
{
var sql = "SELECT seats FROM GameTable WHERE id = @id;";
using (SqlConnection connection = new SqlConnection(conString)) {
return(connection.Query <int>(sql, table).SingleOrDefault());
}
}
public void Update(GameTableModel table)
{
using (SqlConnection connection = new SqlConnection(conString)) {
connection.Open();
var sql = "UPDATE GameTable SET tableName = @tableName, seats = @seats WHERE id = @id;";
connection.Execute(sql, table);
}
}
public GameTableModel CreateGameTable(CGUserModel userModel, string tableName)
{
using (GameTableManagementServiceClient proxy = new GameTableManagementServiceClient()) {
GameTableModel tableModel = null;
CGUser user = GameTableModelConverter.ConvertFromClientUserToServiceUser(userModel);
tableModel = GameTableModelConverter.ConvertFromServiceGameTableToClientGameTable(proxy.CreateGameTable(user, tableName));
return(tableModel);
}
}
public void UpdateTableSeats(CGUserModel user, int amount)
{
IGameTableDBIF gameTableDB = new GameTableDB();
GameTableModel gameTable = gameTableDB.GetById(user.TableID);
if (gameTable != null)
{
gameTableDB.UpdateGameTableSeats(gameTable, amount);
}
}
public static GameTableModel ConvertFromGameTableToGameTableModel(GameTable gameTable)
{
GameTableModel gameTableModel = new GameTableModel()
{
DeckId = gameTable.Deck.Id,
Id = gameTable.Id,
seats = gameTable.seats,
TableName = gameTable.TableName
};
return(gameTableModel);
}
public static Game ConvertFromGameModelToGame(GameModel gameModel)
{
IGameTableDBIF gameTableDB = new GameTableDB();
GameTableModel gameTableModel = gameTableDB.GetById(gameModel.GameTableId);
Game game = new Game()
{
Id = gameModel.Id,
gameTable = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTableModel)
};
return(game);
}
/* This method is called when a user want to join a GameTable.
* It checks wether or notthe table is already full and if it is the user cannot join the table.
* if a user is successfull in joining a table, a seat is subtracted from the seat count,
* such that the it can keep track of how many users have joined the table
*/
public GameTable JoinGameTable(CGUser user, GameTable chosenTable)
{
if (user == null || chosenTable == null)
{
throw new ArgumentNullException();
}
else
{
GameTable databaseTable = null;
GameTableModel modelTable = null;
CGUserModel userModel = CGUserConverter.ConvertFromCGUserToCGUserModel(user);
//Checking if the user is already sitting at the table and returning it without modifying if so.
for (int i = 0; i < chosenTable.Users.Count; i++)
{
if (userModel.UserName == chosenTable.Users[i].UserName)
{
return(chosenTable);
}
}
TransactionOptions transOptions = new TransactionOptions();
transOptions.IsolationLevel = IsolationLevel.ReadUncommitted;
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.Required, transOptions)) {
//Checking if the user is sitting at another table.
if (userModel.TableID != 0 && userModel.TableID != chosenTable.Id)
{
modelTable = gameTableDB.GetById(userModel.TableID);
}
//Getting the table from the database for later comparison.
databaseTable = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTableDB.GetById(chosenTable.Id));
//Optimistically handling concurrency by checking if the seats available at the chosen table
//are the same as the seats available in the database, if not we throw an exception.
if (chosenTable.seats == databaseTable.seats && databaseTable.seats > 0)
{
userManagement.UpdateUserTableId(user, databaseTable.Id);
databaseTable.Users.Add(user);
UpdateGameTableSeats(databaseTable, 1);
//If the user was sitting at another table we free up the seat.
if (modelTable != null)
{
gameTableDB.UpdateGameTableSeats(modelTable, -1);
}
}
else
{
throw new Exception("Table busy");
}
Thread.Sleep(2000);
scope.Complete();
}
return(databaseTable);
}
}
public void GetbyIdTest()
{
gameTableDB = new GameTableDB();
GameTableModel table = null, table2 = null;
List <GameTableModel> gameTables = gameTableDB.GetAll().ToList();
if (gameTables.Count > 0)
{
table = gameTables[0];
}
table2 = gameTableDB.GetById(table.Id);
Assert.AreEqual(table2.Id, table.Id);
}
public void GetGameTableSeatsTest()
{
List <GameTableModel> gameTables = gameTableDB.GetAll().ToList();
GameTableModel table = null;
if (gameTables.Count > 0)
{
table = gameTables[0];
}
int seats = gameTableDB.GetGameTableSeats(table);
Assert.IsTrue(0 <= seats && seats <= 4);
}
public static GameTable ConvertFromGameTableModelToGameTable(GameTableModel tableModel)
{
CGUserDB cGUserDB = new CGUserDB();
DeckDB deckDB = new DeckDB();
GameTable gameTable = new GameTable()
{
Id = tableModel.Id,
seats = tableModel.seats,
TableName = tableModel.TableName,
Users = CGUserConverter.ConvertFromListOfCGUserModelToListOfCGUser(cGUserDB.GetUserByTableId(tableModel.Id)),
Deck = DeckConverter.ConvertFromDeckModelToDeck(deckDB.GetById(tableModel.DeckId))
};
return(gameTable);
}
public void GetByIdTest()
{
//Arrange
GameTableServiceAccess gameTableServiceAccess = new GameTableServiceAccess();
GameTableModel gameTable = null, gameTable2 = null;
List <GameTableModel> tables = gameTableServiceAccess.GetAll();
if (tables.Count > 0)
{
gameTable = tables[0];
}
//Act
gameTable2 = gameTableServiceAccess.GetById(gameTable.Id);
//Assert
Assert.AreEqual(gameTable.TableName, gameTable2.TableName);
}
private void GameTableListBox_SelectedIndexChanged_1(object sender, EventArgs e)
{
labelDelete.Text = "";
string gameTableText = GameTableListBox.Text;
string id = gameTableText.Substring(0, 4);
int tableId = Int32.Parse(id);
GameTableIdTextBox.Text = id;
GameTableModel gt = gameTableController.GetById(tableId);
if (gt != null)
{
//GameTableIdTextBox.Text = "" + gt.Id;
GameTableNameTextBox.Text = gt.TableName;
var users = gt.Users;
UpdatePlayersListBox(users);
}
}
public GameTable CreateGameTable(CGUser user, string tableName)
{
if (user == null || tableName == null)
{
throw new ArgumentNullException();
}
else
{
GameTableModel tableModel = new GameTableModel()
{
TableName = tableName,
DeckId = 2,
seats = 4
};
gameTableDB.Insert(tableModel);
GameTable table = GameTableConverter.ConvertFromGameTableModelToGameTable(gameTableDB.GetGameTableByTableName(tableName));
return(JoinGameTable(user, table));
}
}
/// <summary>
/// Wysyła informacje dla gracza jakie karty on posiada
/// </summary>
public void SendPlayerCards(PlayerModel player)
{
//Pobieramy _client dla user
var _player = GameTableModel.GetPlayer(player.User);
if (_player.Cards != null)
{
CardShowupAction cardActionPlayer = new CardShowupAction()
{
Cards = _player.Cards,
Stage = GameTableModel.Stage,
CreatedAt = DateTime.Now,
Player = _player
};
//Wysylamy wiadomosc tylko do niego
if (player.User.IsOnline())
{
player.User.GetClient().OnGameActionTrigger(GameTableModel, cardActionPlayer);
}
}
}
public void DeleteTest()
{
gameTableDB = new GameTableDB();
List <GameTableModel> gameTables = gameTableDB.GetAll().ToList();
bool found = false;
GameTableModel table = new GameTableModel {
DeckId = 2,
TableName = "TestTable"
};
for (int i = 0; i < gameTables.Count && !found; i++)
{
if (gameTables[i].TableName == table.TableName)
{
table.Id = gameTables[i].Id;
}
}
var table1 = gameTableDB.GetById(table.Id);
gameTableDB.Delete(table);
table = gameTableDB.GetById(table.Id);
Assert.IsNull(table);
}
public void GetUserByTableIdTest()
{
//Arrange
cgUserDB = new CGUserDB();
GameTableDB gameTableDB = new GameTableDB();
var table = new GameTableModel("TestTable");
table.DeckId = 2;
table.seats = 4;
//Act
gameTableDB.Insert(table);
table = gameTableDB.GetGameTableByTableName("TestTable");
GameTable gameTable = GameTableConverter.ConvertFromGameTableModelToGameTable(table);
gameTable.Users.Add(CGUserConverter.convertFromCGUserModelToCGUser(cgUserDB.GetById("Test")));
CGUserModel testUser = cgUserDB.GetById("Test");
cgUserDB.UpdateUserTableId(testUser, table.Id);
List <CGUserModel> foundUser = cgUserDB.GetUserByTableId(table.Id);
Assert.AreEqual(testUser.UserName, foundUser[0].UserName);
gameTableDB.Delete(table);
}
public void UpdateTest()
{
//Arrange
gameTableDB = new GameTableDB();
List <GameTableModel> gameTables = gameTableDB.GetAll().ToList();
GameTableModel table = null;
if (gameTables.Count > 0)
{
table = gameTables[0];
}
var name = table.TableName;
//Act
table.TableName = "GameTableUpdate";
gameTableDB.Update(table);
var table2 = gameTableDB.GetGameTableByTableName("GameTableUpdate");
//Assert
Assert.AreNotEqual(name, table2.TableName);
//Cleanup
table.TableName = name;
gameTableDB.Update(table);
}
private void InitializeStage()
{
Console.WriteLine("InitializeStage()");
StageGameProcess = new StageProcess(this);
StageGameProcess.Initialize();
StageGameProcess.OnStageChangeEvent += (stage) =>
{
Console.WriteLine("OnStageChangeEvent()");
Thread.Sleep(100);
List <CardModel> cards = new List <CardModel>();
switch (stage)
{
case Enums.Stage.Flop:
this.SendDealerMessage("Rozkładam flopa.");
cards.Add(Helper.Pop <CardModel>(GameTypeHandler.CardList));
cards.Add(Helper.Pop <CardModel>(GameTypeHandler.CardList));
cards.Add(Helper.Pop <CardModel>(GameTypeHandler.CardList));
break;
case Enums.Stage.Turn:
this.SendDealerMessage("Rozkładam turn.");
cards.Add(Helper.Pop <CardModel>(GameTypeHandler.CardList));
break;
case Enums.Stage.River:
this.SendDealerMessage("Rozkładam river.");
cards.Add(Helper.Pop <CardModel>(GameTypeHandler.CardList));
break;
}
Console.WriteLine("Rozdanie kart na stole = " + stage.ToString());
//Zapisuje zebrane karty do pamieci
GameTableModel.TableCardList = GameTableModel.TableCardList.Concat(cards).ToList();
//Przekazujemy karty publice
CardTableAction cardAction = new CardTableAction()
{
CreatedAt = DateTime.Now,
Cards = cards,
Stage = GameTableModel.Stage
};
GameTableModel.ActionHistory.Add(cardAction);
Thread.Sleep(1500);
};
StageGameProcess.OnStageProcessFinishEvent += () =>
{
Console.WriteLine("OnStageProcessFinishEvent");
if (GameTableModel.PlayerHavingPlayStatus().Count == 1)
{
//Wygrywa jeden gracz
var playerWinner = GameTableModel.PlayerHavingPlayStatus().FirstOrDefault();
playerWinner.Stack += GameTableModel.TablePot;
var message = "Gracz " + playerWinner.User.Username + " wygrywa główną pulę " + CurrencyFormat.Get(GameTableModel.Currency, GameTableModel.TablePot) + " ponieważ reszta graczy spasowała karty.";
Console.WriteLine(message);
this.SendDealerMessage(message);
GameTableModel.ShowSystemMessage("Wygrywa " + playerWinner.User.Username, message);
Thread.Sleep(2000);
GameTableModel.HideSystemMessage();
}
else
{
//Showdown
StageShowdown stageShowdown = new StageShowdown(this);
stageShowdown.OnShowdownWinnerEvent += (evaluatorItem) =>
{
Console.WriteLine("points: " + evaluatorItem.Points + " (kicker points: " + evaluatorItem.KickerPoints + ")");
};
stageShowdown.ShowdownStart();
stageShowdown.ShowdownPotDistribution();
}
Thread.Sleep(100);
GameTableModel.ShowSystemMessage("Zakończenie rozdania", "Nowe rozdanie zostanie rozpoczęte za 4 sekundy");
Console.WriteLine("Zakończenie gry na stole " + this.GameTableModel.Name);
Thread.Sleep(3600);
GameTableModel.HideSystemMessage();
BaseFinished();
if (OnGameFinishedEvent != null)
{
OnGameFinishedEvent(this);
}
IsFinished = true;
};
}
/// <summary>
/// Inicjalizuje handlery dla list i elementów modelu stołu etc.
/// </summary>
private void AfterInitialize()
{
GameTableModel.ActionHistory.CollectionChanged += new NotifyCollectionChangedEventHandler(
(object sender, NotifyCollectionChangedEventArgs e) =>
{
if (e.NewItems != null)
{
foreach (Object item in e.NewItems)
{
if (item is BetAction)
{
var betAction = (BetAction)item;
//Odejmujemy od salda gracza
PlayerModel _player = GameTableModel.PlayersList.FirstOrDefault(p => p.User.ID == betAction.Player.User.ID);
if (this.GameTableModel.Currency == Enums.CurrencyType.VIRTUAL)
{
betAction.Bet = Math.Round(betAction.Bet, 0);
}
else
{
betAction.Bet = Math.Round(betAction.Bet, 2);
}
//Sprawdzenie stacka usera, max. kwota == player.stack
if (betAction.Bet > _player.Stack)
{
betAction.Bet = _player.Stack;
}
//Dodajemy do póli stołu
GameTableModel.TablePot += betAction.Bet;
//Odejmujemy saldo
_player.Stack -= betAction.Bet;
if (betAction.Action == Enums.ActionPokerType.Fold)
{
if (_player.Status.HasFlag(PlayerModel.PlayerStatus.INGAME))
{
_player.Status &= ~PlayerModel.PlayerStatus.INGAME;
}
_player.Status |= PlayerModel.PlayerStatus.FOLDED;
//Aktualizujemy mozliwosc akcji (powrot do gry)
this.SendAvailableAction(_player.User);
}
Console.WriteLine("Gracz " + betAction.Player.User.Username + " wykonał " + betAction.Action.ToString() + " kwota " + betAction.Bet);
}
else if (item is CardTableAction)
{
var actionEntry = (CardTableAction)item;
Console.WriteLine("Nowe karty na stole (" + actionEntry.Cards.Count() + ")");
}
else if (item is CardShowupAction)
{
var actionEntry = (CardShowupAction)item;
Console.WriteLine("Gracz " + actionEntry.Player.User.Username + " pokazuje karty");
}
else if (item is CardHideupAction)
{
var actionEntry = (CardHideupAction)item;
Console.WriteLine("Gracz " + actionEntry.Player.User.Username + " chowa karty");
}
else if (item is CardBacksideAction)
{
//Wysyłamy do wszystkich przy stole
//if (_client != null)
// _client.ClientProxy.OnPlayerShowcards(Game.GameTableModel, player, playerCards);
var actionEntry = (CardBacksideAction)item;
Console.WriteLine("Gracz " + actionEntry.Player.User.Username + " otrzymuje karty");
}
else if (item is TablePotAction)
{
var actionEntry = (TablePotAction)item;
PlayerModel _player = GameTableModel.PlayersList.FirstOrDefault(p => p.User.ID == actionEntry.Player.User.ID);
_player.Stack += actionEntry.Pot;
Console.WriteLine("Gracz otrzymuje kwote: " + actionEntry.Pot);
}
//Wysyłamy podjęcie akcji przez użytkownika do obserwatorów
foreach (UserModel user in GameTableModel.WatchingList.ToList())
{
//Pobieramy _client dla user
var _c = user.GetClient();
//Wysylamy wiadomosc do wszystkich o danej akcji
if (_c != null)
{
_c.OnGameActionTrigger(GameTableModel, (BaseAction)item);
}
}
}
}
}
);
GameTableModel.PlayersList.CollectionChanged += new NotifyCollectionChangedEventHandler(
(object sender, NotifyCollectionChangedEventArgs e) =>
{
Console.WriteLine("PlayersList.CollectionChanged");
foreach (UserModel user in GameTableModel.GetWatchingExceptPlayers())
{
this.SendAvailableAction(user);
}
//Wysłanie informacji o nowym graczu
if (e.NewItems != null)
{
foreach (Object item in e.NewItems)
{
var player = item as PlayerModel;
Task.Factory.StartNew(() =>
{
foreach (UserModel user in GameTableModel.WatchingList)
{
user.GetClient().OnGamePlayerSitdown(GameTableModel, player);
}
});
}
}
}
);
GameTableModel.WatchingList.CollectionChanged += new NotifyCollectionChangedEventHandler(
(object sender, NotifyCollectionChangedEventArgs e) =>
{
Console.WriteLine("WatchingList.CollectionChanged");
if (e.NewItems != null)
{
foreach (Object item in e.NewItems)
{
//Wysłanie obecnego stanu gry dla użytkownika czyli stołu wraz z danymi kart i listy graczy
this.DoSendTableHitory(item as UserModel);
//Wysyła możliwą akcję
this.SendAvailableAction(item as UserModel);
//Wysyła karty o ile gracz jest w grze
var player = GameTableModel.GetPlayer(item as UserModel);
if (player != null)
{
this.SendPlayerCards(player);
}
}
}
}
);
}
