private static PlayerData CreateDefaultPlayerData(string aiType, int depth, string name)
{
PlayerWrapper player = new PlayerWrapper(aiType, depth);
string player_name = player.Register(name);
Console.WriteLine("Sucessfully registered default player: " + player_name);
return(new PlayerData(player, player_name));
}
public void JsonCommand(JToken jtoken, List <JToken> jTokenList)
{
//Register Players
if (!_isSet_player1)
{
_isSet_player1 = true;
_player1.Register(jtoken.ToObject <string>());
jTokenList.Add(JToken.Parse(JsonConvert.SerializeObject(_referee.AssignPlayer())));
}
else if (!_isSet_player2)
{
_isSet_player2 = true;
_player2.Register(jtoken.ToObject <string>());
jTokenList.Add(JToken.Parse(JsonConvert.SerializeObject(_referee.AssignPlayer())));
}
//Play out the match
else
{
string play = jtoken.ToObject <string>();
try
{
jTokenList.Add(JToken.Parse(JsonConvert.SerializeObject(_referee.GetBoardHistory())));
if (play == "pass")
{
_referee.Pass();
}
else
{
_referee.Play(play);
}
}
catch (RefereeException)
{
List <PlayerWrapper> victors = _referee.GetVictors();
List <string> names = new List <string>();
foreach (PlayerWrapper victor in victors)
{
names.Add(victor.GetName());
}
jTokenList.Add(JToken.Parse(JsonConvert.SerializeObject(names.ToArray())));
throw new RefereeException("Game has ended");
}
}
}
public string Register(string name, string aiType = "human")
{
if (_player1 == null)
{
_player1 = new PlayerWrapper(false);
_player1.Register(name, aiType);
_player1.ReceiveStones("B");
_current_player = _player1;
return("B");
}
else if (_player2 == null)
{
_player2 = new PlayerWrapper(false);
_player2.Register(name, aiType);
_player2.ReceiveStones("W");
return("W");
}
throw new InvalidOperationException("Invalid call to Register in Referee: Cannot register more than two players");
}
public string Register(string name)
{
if (_players_set == 0)
{
_player1.Register(name);
_player1.ReceiveStones("B");
_current_player = _player1;
_players_set++;
return("B");
}
else if (_players_set == 1)
{
_player2.Register(name);
_player2.ReceiveStones("W");
_players_set++;
return("W");
}
throw new InvalidOperationException("Invalid call to Register in Referee: Cannot register more than two players");
}
/* Given two UNREGISTERED players and the size of the game board, administers a game between the two players using referee
* Returns a sorted list of strings containing the victor(s)
* if a player is a remote player, the name given in function for that player doesn't matter
*/
public static List <string> AdministerSingleGame(PlayerWrapper player1, string name1, PlayerWrapper player2, string name2, int size)
{
try
{
player1.Register(name1); //Assign player 2
}
catch (Exception e)
{
if (e is JsonSerializationException || e is ArgumentException || e is SocketException || e is WrapperException || e is JsonReaderException)
{
List <string> victor = new List <string>();
victor.Add(name2);
return(victor);
}
else
{
throw;
}
}
try
{
player2.Register(name2); //Assign player 2
}
catch (Exception e)
{
if (e is JsonSerializationException || e is ArgumentException || e is SocketException || e is WrapperException || e is JsonReaderException)
{
List <string> victor = new List <string>();
victor.Add(name1);
return(victor);
}
else
{
throw;
}
}
RefereeWrapper referee = new RefereeWrapper(player1, player2, size);
List <string> victors = referee.RefereeGame(name1, name2);
return(victors);
}
/* TestDriver for assignment 6
* Simulates a game using the referee and keeps track of referee's outputs
* Once referee terminates due to the game ending, an illegal move, or no more inputs
* writes all outputs of referee to console
*/
public static void Main(string[] args)
{
string console = "";
string input;
bool _player1_set = false;
bool _player2_set = false;
//Read from console
while ((input = Console.ReadLine()) != null)
{
console += input;
}
//Parse console input
List <JToken> jTokenList = ParsingHelper.ParseJson(console);
List <JToken> finalList = new List <JToken>();
PlayerWrapper player1 = new PlayerWrapper("human");
PlayerWrapper player2 = new PlayerWrapper("human");
RefereeAdapter referee = new RefereeAdapter(player1, player2);
foreach (JToken jtoken in jTokenList)
{
try
{
if (!_player1_set)
{
finalList.Add(JToken.Parse(JsonConvert.SerializeObject(
player1.Register(jTokenList[0].ToObject <string>()))));
_player1_set = true;
}
else if (!_player2_set)
{
finalList.Add(JToken.Parse(JsonConvert.SerializeObject(
player2.Register(jTokenList[1].ToObject <string>()))));
_player2_set = true;
}
else
{
try
{
referee.JsonCommand(jtoken, finalList);
}
catch (RefereeException)
{
break;
}
}
}
catch
{
break;
}
}
Console.WriteLine(JsonConvert.SerializeObject(finalList));
Console.ReadLine();
}
public static List <PlayerRanking> AdministerTournament(string tournament_type, int _number_of_remote_players,
int port, string path, int board_size = 9)
{
//locals and initialization
string goPlayer = File.ReadAllText(path);
JObject playerJObject = JsonConvert.DeserializeObject <JObject>(goPlayer);
int depth = playerJObject["depth"].ToObject <int>();
string aiType = playerJObject["aiType"].ToObject <string>();
List <PlayerData> players = new List <PlayerData>();
for (int i = 0; i < _number_of_remote_players; i++)
{
try
{
PlayerWrapper player = new PlayerWrapper(Socket);
Console.WriteLine("Successfully connected player" + i);
Console.Write("Trying to register player" + i + ": ");
string player_name = player.Register("default player" + i);
Console.WriteLine("Sucessfully registered player: " + player_name);
players.Add(new PlayerData(player, player_name));
}
catch (Exception e)
{
if (e is JsonSerializationException || e is ArgumentException || e is SocketException || e is WrapperException || e is JsonReaderException)
{
Console.WriteLine("Unsuccessful registration of player " + i);
players[i].Disqualify();
}
}
}
if (Math.Log(_number_of_remote_players, 2) != 0)
{
double additional_players = Math.Pow(2, Math.Ceiling(Math.Log(_number_of_remote_players, 2))) - _number_of_remote_players;
int player_num = players.Count;
for (int i = 0; i < additional_players; i++)
{
players.Add(Admin.CreateDefaultPlayerData(aiType, depth, "default player " + player_num));
player_num++;
}
}
else if (_number_of_remote_players == 1)
{
players.Add(Admin.CreateDefaultPlayerData(aiType, depth, "default player " + 1));
}
else if (_number_of_remote_players < 1)
{
players.Add(Admin.CreateDefaultPlayerData(aiType, depth, "default player " + 0));
players.Add(Admin.CreateDefaultPlayerData(aiType, depth, "default player " + 1));
}
switch (tournament_type)
{
case "cup":
Console.WriteLine("start cup game");
return(AdministerSingleElimination(players, board_size, aiType, depth));
case "league":
Console.WriteLine("starting league game");
return(AdministerRoundRobin(players, board_size, aiType, depth));
default:
throw new AdminException("Invalid tournament type in Admin: " + tournament_type);
}
}
