private void CreateRoomLoop1()
{
string pass = "******";
string email = "*****@*****.**";
string name = "99999" + Thread.CurrentThread.ManagedThreadId.ToString();
int id = UserBridge.RegisterUser(name, pass, email);
Assert.True(id != -1);
Assert.True(UserBridge.LoginUser(name, pass));
int RoomID;
List <int> roomIDS = new List <int>();
for (int i = 8850000; i < 8850100; i++)
{
RoomID = GameBridge.CreateGameRoom(id, 100);
roomIDS.Add(RoomID);
}
for (int i = 0; i < roomIDS.Count; i++)
{
GameBridge.DoAction(id, CommunicationMessage.ActionType.Leave, 0, roomIDS[i]);
}
Assert.True(UserBridge.LogoutUser(id));
UserBridge.DeleteUser(name, pass);
}
public void CallTestGood()
{
int roomId = CreateGameWith3Users();
Assert.True(GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, 10, roomId));
CleanUp(roomId);
}
public static void GameOver(this GameBridge gameUI, bool win, bool force = false)
{
if (win)
{
++SharedRefs.OnlineWin;
}
else
{
++SharedRefs.OnlineLose;
}
if (SharedRefs.Mode == Constants.GameMode.Online)
{
gameUI.scoreText.text = $"{SharedRefs.OnlineLose}:{SharedRefs.OnlineWin}";
}
if (SharedRefs.OnlineLose + SharedRefs.OnlineWin != 3 && !force)
{
SharedRefs.OnlineWaiting = 5;
return;
}
if (force)
{
SharedRefs.ErrorFlag = true;
gameUI.gameOverText.text = "回到首页";
}
gameUI.gameOverMask.SetActive(true);
}
public void RaiseTestBad()
{
int roomId = CreateGameWith3Users();
Assert.False(GameBridge.DoAction(_userId2, CommunicationMessage.ActionType.Bet, -100, roomId));
CleanUp(roomId);
}
public void FoldTestGood()
{
int roomId = CreateGameWith3Users();
GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Fold, 0, roomId);
var players = GameBridge.GetPlayersInRoom(roomId);
Assert.AreEqual(3, players.Count);
Assert.True(players.Exists(p =>
{
var user = p.user;
return(user.Id() == UserId && !p.isPlayerActive);
}));
Assert.True(players.Exists(p =>
{
var user = p.user;
return(user.Id() == _userId2 && p.isPlayerActive);
}));
Assert.True(players.Exists(p =>
{
var user = p.user;
return(user.Id() == _userId3 && p.isPlayerActive);
}));
CleanUp(roomId);
}
public void ListLimitGamesByPrefTestGood()
{
//delete all users and games
//RestartSystem();
SetupUser1();
var limitGames = GameBridge.GetGamesByGameMode(GameMode.Limit);
int numLimitBefore = limitGames == null ? 0 : limitGames.Count;
int roomId1 = GameBridge.CreateGameRoomWithPref(UserId, 10, false, GameMode.Limit,
2, 8, 1, 1);
Assert.True(roomId1 != -1);
RegisterUser2();
var noLimitGames = GameBridge.GetGamesByGameMode(GameMode.NoLimit);
int numNoLimitBefore = noLimitGames == null ? 0 : noLimitGames.Count;
int roomId2 = GameBridge.CreateGameRoomWithPref(_userId2, 10, false, GameMode.NoLimit,
2, 8, 1, 1);
Assert.True(roomId2 != -1);
limitGames = GameBridge.GetGamesByGameMode(GameMode.Limit);
int numLimitAfter = limitGames == null ? 0 : limitGames.Count;
noLimitGames = GameBridge.GetGamesByGameMode(GameMode.NoLimit);
int numNoLimitAfter = noLimitGames == null ? 0 : noLimitGames.Count;
Assert.AreEqual(numNoLimitAfter, numNoLimitBefore + 1);
Assert.AreEqual(numLimitAfter, numLimitBefore + 1);
CleanUp(roomId1);
CleanUp(roomId2);
}
public void RaiseTestSad()
{
int roomId = CreateGameWith3Users();
//bet is too small
Assert.False(GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, 9, roomId));
CleanUp(roomId);
}
public void CheckTestGood()
{
//RestartSystem();
var roomId = CreateGameWith3Users();
Assert.True(GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, 100, roomId));
CleanUp(roomId);
}
public void UserAddToRoomAsPlayerAllMoneyTestGood()
{
int roomId = CreateGameWith3Users();
Assert.True(GameBridge.IsUserInRoom(UserId, roomId));
Assert.Contains(roomId, UserBridge.GetUsersGameRooms(UserId));
CleanUp(roomId);
}
public void CreateGameTestBad()
{
int roomId = GameBridge.CreateGameRoom(UserId, -1);
Assert.True(roomId == -1);
Assert.False(GameBridge.DoesRoomExist(roomId));
CleanUp(roomId);
}
public void CallTestBad()
{
//RestartSystem();
var roomId = CreateGameWith3Users();
Assert.False(GameBridge.DoAction(_userId2, CommunicationMessage.ActionType.Bet, -10, roomId)); //neg amount
CleanUp(roomId);
}
public void CallTestSad()
{
//RestartSystem();
var roomId = CreateGameWith3Users();
var money = UserBridge.GetUserMoney(UserId);
Assert.False(GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, money + 1, roomId));
CleanUp(roomId);
}
public void CheckTestSad()
{
var roomId = CreateGameWith3Users();
UserBridge.ReduceUserMoney(UserId, 100000000 - 1); //so user does not have enough money
//cant raise not eungh money
Assert.False(GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, 0, roomId));
CleanUp(roomId);
}
public void FoldTestBad()
{
//RestartSystem();
int roomId = CreateGameWith3Users();
GameBridge.DoAction(_userId2, CommunicationMessage.ActionType.Fold, -1, roomId);
Assert.True(GameBridge.GetPlayersInRoom(roomId).Exists(p => p.user.Id() == _userId2));
CleanUp(roomId);
}
private void doAction1()
{
for (int i = 0; i < 1000; i++)
{
GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Join, 100, RoomId);
GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Bet, 1, RoomId);
GameBridge.DoAction(UserId, CommunicationMessage.ActionType.Join, 100, RoomId);
}
}
private void doAction3()
{
for (int i = 0; i < 1000; i++)
{
GameBridge.DoAction(_userId3, CommunicationMessage.ActionType.Fold, -1, RoomId);
GameBridge.DoAction(_userId3, CommunicationMessage.ActionType.Bet, 0, RoomId);
GameBridge.DoAction(_userId3, CommunicationMessage.ActionType.Join, 100, RoomId);
}
}
public void CheckTestBad()
{
//RestartSystem();
var roomId = CreateGameWith3Users();
//cant raise not his turn
Assert.False(GameBridge.DoAction(_userId2, CommunicationMessage.ActionType.Bet, 0, roomId));
CleanUp(roomId);
}
private Player GetInGamePlayerFromUser(IUser user, int roomId)
{
foreach (Player player in GameBridge.GetPlayersInRoom(roomId))
{
if (player.user.Id() == user.Id())
{
return(player);
}
}
return(null);
}
public void CreateGameWithPrefTestBad()
{
RoomId = -1;
SetupUser1();
Assert.True(RoomId == -1);
Assert.False(UserBridge.getUserById(UserId) == null);
RoomId = GameBridge.CreateGameRoomWithPref(UserId, 10, false, GameMode.PotLimit, 0, 0, -1, 0);
Assert.True(RoomId == -1);
Assert.False(GameBridge.DoesRoomExist(RoomId));
CleanUp(RoomId);
}
public void CreateGameWithPrefTestGood()
{
UserId = new Random().Next();
RegisterUserToDB(UserId);
RoomId = -1;
Assert.True(RoomId == -1);
RoomId = GameBridge.CreateGameRoomWithPref(UserId, 100, true, GameMode.Limit, 2, 8, 0, 10);
Assert.True(RoomId != -1);
Assert.True(GameBridge.DoesRoomExist(RoomId));
Assert.AreEqual(1, GameBridge.GetPlayersInRoom(RoomId).Count);
Assert.AreEqual(UserId, GameBridge.GetPlayersInRoom(RoomId).First().user.Id());
CleanUp(RoomId);
}
public void ListActiveGamesTestGood()
{
//delete all users and games, register user1
// //RestartSystem();
SetupUser1();
RoomId = -1;
Assert.True(RoomId == -1);
Assert.True(UserBridge.IsThereUser(UserId));
RoomId = GameBridge.CreateGameRoom(UserId, 10);
RegisterUser2();
Assert.True(UserBridge.IsThereUser(UserId));
Assert.True(UserBridge.IsThereUser(_userId2));
Assert.GreaterOrEqual(GameBridge.ListAvailableGamesByUserRank(_userId2).Count, 1);
CleanUp(RoomId);
}
public void CreateGameTestGood()
{
////RestartSystem();
RoomId = -1;
//SetupUser1();
UserId = new Random().Next();
RegisterUserToDB(UserId);
Assert.False(UserBridge.getUserById(UserId) == null);
RoomId = GameBridge.CreateGameRoom(UserId, 100);
Assert.True(RoomId != -1);
Assert.True(GameBridge.DoesRoomExist(RoomId));
Assert.AreEqual(1, GameBridge.GetPlayersInRoom(RoomId).Count);
Assert.AreEqual(UserId, GameBridge.GetPlayersInRoom(RoomId).First().user.Id());
CleanUp(RoomId);
}
public void ListSpectatableGamesTestSad()
{
//delete all users and games, register user1
//RestartSystem();
int id = SetupUser1();
var spectateableGamesBefore = GameBridge.ListSpectateableRooms();
int numBefore = spectateableGamesBefore == null ? 0 : spectateableGamesBefore.Count;
int roomId = GameBridge.CreateGameRoomWithPref(id, 10, false, GameMode.Limit,
2, 8, 1, 1);
Assert.True(roomId != -1);
var spectateableGamesAfter = GameBridge.ListSpectateableRooms();
int numAfter = spectateableGamesBefore == null ? 0 : spectateableGamesAfter.Count;
Assert.AreEqual(numBefore, numAfter);
CleanUp(roomId);
}
public void ListSpectatableGamesTestGood()
{
//delete all users and games, register user1
//RestartSystem();
SetupUser1();
var games = GameBridge.ListSpectateableRooms();
int numOfGamesBefore = games == null ? 0 : games.Count;
int roomId = GameBridge.CreateGameRoomWithPref(UserId, 10, true, GameMode.Limit, 2, 8, 1, 1);
Assert.True(roomId != -1);
games = GameBridge.ListSpectateableRooms();
int numOfGamesAfter = games == null ? 0 : games.Count;
var spec = GameBridge.ListSpectateableRooms();
Assert.AreEqual(numOfGamesBefore + 1, numOfGamesAfter);
Assert.True(spec.Exists(game => game.Id == roomId));
CleanUp(roomId);
}
public void ViewReplayTestGood()
{
//create a game to be replayd
//RestartSystem();
SetupUser1();
CreateGameWithUser1();
RegisterUser(_userId2, _user2Name, _user2Pw, _user2EmailGood);
IUser user2 = UserBridge.getUserById(_userId2);
user2.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId2, RoomId, user2.Money()));
GameBridge.StartGame(UserId, RoomId);
// UserBridge.RemoveUserFromRoom(UserId, RoomId);
var replays = ReplayBridge.ViewReplay(RoomId, 0, UserId);
Assert.GreaterOrEqual(6, replays.Count); //join, 2 call, leave, lose, win
}
public void Initialize(IServiceCollection serviceCollection)
{
if (serviceCollection == null)
{
throw new ArgumentNullException(nameof(serviceCollection));
}
_gameBridge = GameBridge.CreateBridge(BridgeDataReceiver);
serviceCollection.AddSingleton <IBridge>(_gameBridge);
serviceCollection.AddSingleton(this);
//Expose as both to get the implementation
serviceCollection.AddSingleton <ClientNetworking>();
serviceCollection.AddSingleton <IClientNetworking>(provider => provider.GetRequiredService <ClientNetworking>());
serviceCollection.AddSingleton <ClientEntities>();
}
public void DoActionLoadTest1()
{
//RestartSystem();
SetupUser1();
CreateGameWithUser1();
RegisterUser(_userId2, _user2Name, _user2Pw, _user2EmailGood);
IUser user2 = UserBridge.getUserById(_userId2);
user2.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId2, RoomId, user2.Money()));
RegisterUser(_userId3, _user3Name, _user3Pw, _user3EmailGood);
IUser user3 = UserBridge.getUserById(_userId3);
user3.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId3, RoomId, user3.Money()));
GameBridge.StartGame(UserId, RoomId);
IUser user1 = UserBridge.getUserById(UserId);
Player player1 = GetInGamePlayerFromUser(user1, RoomId);
Player player2 = GetInGamePlayerFromUser(user2, RoomId);
Player player3 = GetInGamePlayerFromUser(user3, RoomId);
//bomb the game
Thread thread1 = new Thread(new ThreadStart(doAction1));
Thread thread2 = new Thread(new ThreadStart(doAction2));
Thread thread3 = new Thread(new ThreadStart(doAction3));
thread1.Start();
thread2.Start();
thread3.Start();
Thread.Sleep(3); //let the threads work
//wait for threads
thread1.Join();
thread2.Join();
thread3.Join();
Assert.True(GameBridge.GetPlayersInRoom(RoomId).Contains(player1));
Assert.True(GameBridge.GetPlayersInRoom(RoomId).Contains(player2));
Assert.True(GameBridge.GetPlayersInRoom(RoomId).Contains(player3));
Assert.True(player2.isPlayerActive);
Assert.True(player3.isPlayerActive);
}
public void ListGamesByPrefTestBad()
{
//delete all users and games
//RestartSystem();
SetupUser1();
var games = GameBridge.GetGamesByGameMode(GameMode.PotLimit);
int numOfGamesBefore = games == null ? 0 : games.Count;
RoomId = GameBridge.CreateGameRoomWithPref(UserId, 10, false, GameMode.Limit, 2, 8, 1, 1);
Assert.True(RoomId != -1);
RegisterUser2();
int roomId2 = GameBridge.CreateGameRoomWithPref(_userId2, 10, false, GameMode.NoLimit, 2, 8, 1, 1);
Assert.True(roomId2 != -1);
games = GameBridge.GetGamesByGameMode(GameMode.PotLimit);
int numOfGamesAfter = games == null ? 0 : games.Count;
Assert.AreEqual(numOfGamesBefore, numOfGamesAfter);
CleanUp(RoomId);
CleanUp(roomId2);
}
public void GetReplayableGamesTestGood()
{
//create a game to be replayd
//RestartSystem();
SetupUser1();
CreateGameWithUser1();
RegisterUser(_userId2, _user2Name, _user2Pw, _user2EmailGood);
IUser user2 = UserBridge.getUserById(_userId2);
user2.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId2, RoomId, user2.Money()));
RegisterUser(_userId3, _user3Name, _user3Pw, _user3EmailGood);
IUser user3 = UserBridge.getUserById(_userId3);
user3.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId3, RoomId, user3.Money()));
GameBridge.StartGame(UserId, RoomId);
System.Threading.Thread.Sleep(5000);
UserBridge.RemoveUserFromRoom(UserId, RoomId);
UserBridge.RemoveUserFromRoom(_userId2, RoomId);
UserBridge.RemoveUserFromRoom(_userId3, RoomId);
Assert.True(ReplayBridge.GetReplayableGames(RoomId, 0, _userId3)._actions.Count >= 1);
}
private int CreateGameWith3Users()
{
UserId = SetupUser1();
IUser user1 = UserBridge.getUserById(UserId);
user1.AddMoney(100000000);
int roomId = new Random().Next();
CreateGame(roomId, UserId, 100, true, GameMode.NoLimit, 2, 8, 0, 10);
_userId2 = new Random().Next();
RegisterUser(_userId2, _user2Name + _userId2, _user2Pw, _user2EmailGood);
IUser user2 = UserBridge.getUserById(_userId2);
user2.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId2, roomId, user2.Money()));
_userId3 = new Random().Next();
RegisterUser(_userId3, _user3Name + _userId3, _user3Pw, _user3EmailGood);
IUser user3 = UserBridge.getUserById(_userId3);
user3.AddMoney(1000);
Assert.True(UserBridge.AddUserToGameRoomAsPlayer(_userId3, roomId, user3.Money()));
GameBridge.StartGame(UserId, roomId);
return(roomId);
}
