/// <summary>
/// Helper method that instantiates pieces on the correct nodes as well as saves said pieces in a private array per player.
/// </summary>
/// <param name="players"> The current player that owns the pieces. </param>
/// <param name="piecePrefab">A prefab reference to create said pieces. </param>
private static void PlacePieces(IPlayer player, PieceObject piecePrefab)
{
if (player == null)
{
return;
}
if (player.CurrentTeam == null || player.CurrentTeam.Team == Team.Empty)
{
return;
}
List <Piece> playerPieces = new List <Piece> ();
Transform parent = new GameObject($"{player}'s pieces").transform;
foreach (var node in player.CurrentTeam.TeamBase)
{
if (node.BelongsTo == player.CurrentTeam.Team)
{
node.StoredPiece = new Piece(piecePrefab, TeamGenerator.SetColorBasedOnTeam(player.CurrentTeam.Team), node, player.CurrentTeam.Team, parent);
//Piece.CreatePiece (piecePrefab, TeamGenerator.SetColorBasedOnTeam (player.CurrentTeam.Team), node, player.CurrentTeam.Team);
playerPieces.Add(node.StoredPiece);
}
}
player.CurrentTeam.TeamsPieces = playerPieces;
}
public void GenerateTeams_GivenThreePlayers_PerfectSolutionsExist_PerfectSolutionFound(
int p1, int g1,
int p2, int g2,
int p3, int g3)
{
IShuffler shuffler = A.Fake <IShuffler>();
TeamGenerator teamGenerator = new TeamGenerator(shuffler);
Player player1 = new Player()
{
Id = 1, Name = "Name1", Points = p1, GamesPlayed = g1
};
Player player2 = new Player()
{
Id = 2, Name = "Name2", Points = p2, GamesPlayed = g2
};
Player player3 = new Player()
{
Id = 3, Name = "Name3", Points = p3, GamesPlayed = g3
};
List <Player> selectedPlayers = new List <Player> {
player1, player2, player3
};
var result = teamGenerator.GenerateTeams(selectedPlayers);
var r1 = (double)p1 / g1;
var r2 = (double)p2 / g2;
var r3 = (double)p3 / g3;
double expected = (r1 + r2 + r3) / 2;
result.Item1.Sum(p => p.PointsPerGame).Should().Be(expected);
result.Item2.Sum(p => p.PointsPerGame).Should().Be(expected);
}
public void GenerateTeams_GivenFourPlayers_PerfectSolutionsExist_PerfectSolutionFound(
int p1, int g1,
int p2, int g2,
int p3, int g3,
int p4, int g4)
{
IShuffler shuffler = A.Fake <IShuffler>();
TeamGenerator teamGenerator = new TeamGenerator(shuffler);
Player player1 = new Player()
{
Id = 1, Name = "Name1", Points = p1, GamesPlayed = g1
};
Player player2 = new Player()
{
Id = 2, Name = "Name2", Points = p2, GamesPlayed = g2
};
Player player3 = new Player()
{
Id = 3, Name = "Name3", Points = p3, GamesPlayed = g3
};
Player player4 = new Player()
{
Id = 4, Name = "Name4", Points = p4, GamesPlayed = g4
};
List <Player> selectedPlayers = new List <Player> {
player1, player2, player3, player4
};
var result = teamGenerator.GenerateTeams(selectedPlayers);
result.Item1.Sum(p => p.PointsPerGame).Should().Be(1);
result.Item2.Sum(p => p.PointsPerGame).Should().Be(1);
}
private static void RemoveFunction(TeamGenerator generator, string[] cmdArgs)
{
var teamName = cmdArgs[1];
if (!generator.ThereIsSuchATeam(teamName))
{
Console.WriteLine(ExceptionMessages.MissingTeamException(teamName));
return;
}
var playerName = cmdArgs[2];
generator.RemovePlayerToTheTeam(teamName, playerName);
}
static IPlayer OnCreatingPlayer(GameManager.GameMode.Match.Player player, TeamGenerator team)
{
GameManager.GameMode.Match.Player newPlayer = player;
Team playerTeam = newPlayer.playerTeam;
switch (playerTeam)
{
case Team.Empty:
return(null);
}
IPlayer iPlayer = CreatePlayer(newPlayer, team);
return(iPlayer);
}
/// <summary>
/// Handle the selection of a specific team generator, defaulted to Random
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
private ITeamGenerator SelectGeneratorByGeneratorType(GeneratorType type)
{
ITeamGenerator generator = new TeamGenerator();
switch (type)
{
case GeneratorType.Random:
generator = new TeamGenerator();
break;
case GeneratorType.Manual:
case GeneratorType.None:
break;
}
return(generator);
}
static void Main()
{
var teamName = "";
var playerName = "";
var generator = new TeamGenerator();
string input;
while ((input = Console.ReadLine()) != "END")
{
var args = input.Split(';');
var command = args[0];
try
{
switch (command)
{
case "Team":
teamName = args.Last();
generator.AddTeam(teamName);
break;
case "Add":
teamName = args[1];
var playerArgs = args.Skip(2).ToArray();
var player = ParsePlayer(playerArgs);
generator.AddPlayerToTeam(player, teamName);
break;
case "Remove":
teamName = args[1];
playerName = args[2];
generator.RemovePlayerFromTeam(playerName, teamName);
break;
case "Rating":
teamName = args.Last();
generator.PrintTeamRatings(teamName);
break;
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
}
/// <summary>
/// Starts the game with an x amount of players using set parameters as well as helper methods to properly create an exact amount of players.
/// </summary>
/// <param name="players">An array of data that tells the method what team the current player is, what color is its opponent and if said player is a computer or not.</param>
/// <param name="oddAmmPlayers">A boolean that checks if the amount of desiredPlayers is odd. Set this to true if you want odd amounts of players (3,5,7, ect).</param>
/// <param name="piecePrefab">A prefab reference to the piece gameObject in order to be created. </param>
/// <param name="modes">A reference to the Gamemodes enum, which is being used to see if the current mode is GameModes.Debug</param>
/// <returns>A jaggered array of all players (first and second players). </returns>
public static IPlayer[] StartNewGame(GameManager.GameMode gameMode, PieceObject piecePrefab)
{
List <IPlayer> allPlayers = new List <IPlayer> ();
TeamGenerator[] teams = new TeamGenerator[15];
for (int t = 0; t < teams.Length; t++)
{
teams[t] = new TeamGenerator();
teams[t].Team = (Team)(t);
// Debug.Log($"{(Team)(t)} at {t} using {t}");
List <Node> nodeList = new List <Node> ();
for (int y = 0; y < BoardManager.originalBoard.GetLength(0); y++)
{
for (int x = 0; x < BoardManager.originalBoard.GetLength(1); x++)
{
Node node = BoardManager.originalBoard[y, x];
if (gameMode.matches.Length == 2)
{
node.BelongsTo = (node.BelongsTo == Team.BigRed || node.BelongsTo == Team.BigRedToOrange || node.BelongsTo == Team.BigMagentaToRed) ? Team.Red : node.BelongsTo;
node.BelongsTo = (node.BelongsTo == Team.BigBlue || node.BelongsTo == Team.BigGreenToBlue || node.BelongsTo == Team.BigBlueToYellow) ? Team.Blue : node.BelongsTo;
}
else
{
node.BelongsTo = (node.BelongsTo == Team.BigRed || node.BelongsTo == Team.BigRedToOrange || node.BelongsTo == Team.BigMagentaToRed) ? Team.Unoccupied : node.BelongsTo;
node.BelongsTo = (node.BelongsTo == Team.BigBlue || node.BelongsTo == Team.BigGreenToBlue || node.BelongsTo == Team.BigBlueToYellow) ? Team.Unoccupied : node.BelongsTo;
}
if (node.BelongsTo == teams[t].Team)
{
nodeList.Add(node);
}
}
}
teams[t].TeamBase = nodeList.ToArray();
}
for (int i = 0; i < gameMode.matches.Length; i++)
{
GameManager.GameMode.Match.Player newPlayer = gameMode.matches[i].player;
//Debug.Log($"using {i} to spawn this player ({teams[(int)newPlayer.playerTeam - 2].Team})");
IPlayer _newPlayer = OnCreatingPlayer(newPlayer, teams[(int)newPlayer.playerTeam]);
PlacePieces(_newPlayer, piecePrefab);
allPlayers.Add(_newPlayer);
}
return(allPlayers.ToArray());
}
private static void AddFunction(TeamGenerator generator, string[] cmdArgs)
{
var teamName = cmdArgs[1];
if (!generator.ThereIsSuchATeam(teamName))
{
Console.WriteLine(ExceptionMessages.MissingTeamException(teamName));
return;
}
var playerName = cmdArgs[2];
var endurance = int.Parse(cmdArgs[3]);
var sprint = int.Parse(cmdArgs[4]);
var dribble = int.Parse(cmdArgs[5]);
var passing = int.Parse(cmdArgs[6]);
var shooting = int.Parse(cmdArgs[7]);
var player = new Player(playerName, endurance, sprint, dribble, passing, shooting);
generator.AddPlayerToTheTeam(teamName, player);
}
public void GenerateTeams_GivenOddPlayers_EvenSplitReturned_Team1WithMorePlayers(int numberOfPlayers)
{
IShuffler shuffler = A.Fake <IShuffler>();
TeamGenerator teamGenerator = new TeamGenerator(shuffler);
List <Player> selectedPlayers = new List <Player>();
for (int i = 1; i <= numberOfPlayers; i++)
{
selectedPlayers.Add(new Player()
{
Id = i, Name = "Name" + i, Points = 1, GamesPlayed = 1
});
}
var result = teamGenerator.GenerateTeams(selectedPlayers);
result.Item1.Count().Should().Be((numberOfPlayers + 1) / 2);
result.Item2.Count().Should().Be((numberOfPlayers - 1) / 2);
}
protected void ASPxButton1_Click(object sender, EventArgs e)
{
int numPlayers = 20;
int nbrOfTeams = 20 / 2;
int rounds = 3;
List <Player> players = new List <Player>();
for (int i = 1; i <= numPlayers; i++)
{
Player player = new Player
{
Name = "Person " + i.ToString()
};
players.Add(player);
}
Tournament tournament = new Tournament(rounds);
ExtensionMethods.Shuffle(players);
for (int i = 0; i < rounds; i++)
{
TournamentRound round = new TournamentRound("Round : " + (i + 1).ToString());
List <Team> teams = TeamGenerator.GenerateTeams(players, nbrOfTeams);
round.Teams = teams;
round.Matches = MatchGenerator.GenerateMatches(teams, teams.Count / 2);
tournament.Rounds.Add(round);
}
ASPxListBox1.DataSource = tournament.Rounds[0].Matches;
ASPxListBox1.TextField = "Name";
ASPxListBox1.DataBind();
ASPxListBox2.DataSource = tournament.Rounds[1].Matches;
ASPxListBox2.TextField = "Name";
ASPxListBox2.DataBind();
ASPxListBox3.DataSource = tournament.Rounds[2].Matches;
ASPxListBox3.TextField = "Name";
ASPxListBox3.DataBind();
}
static void Init()
{
TeamGenerator window = (TeamGenerator)EditorWindow.GetWindow(typeof(TeamGenerator));
window.Show();
}
static IPlayer CreatePlayer(GameManager.GameMode.Match.Player player, TeamGenerator team)
{
IPlayer newPlayer = (player.isComputer) ? CompPlayer.CreatePlayer(player.playerTeam, team) : HumanPlayer.CreatePlayer(player.playerTeam, team);
return(newPlayer);
}
private static void RatingFunction(TeamGenerator generator, string[] cmdArgs)
{
var teamName = cmdArgs[1];
Console.WriteLine($"{teamName} - {Math.Round(generator.ShowStat(teamName))}");
}
private static void TeamFunction(TeamGenerator generator, string[] cmdArgs)
{
var teamName = cmdArgs[1];
generator.AddTeam(teamName);
}
static void Main(string[] args)
{
var generator = new TeamGenerator();
while (true)
{
var cmdArgs = Console.ReadLine().Split(';');
if (cmdArgs[0] == "END")
{
break;
}
switch (cmdArgs[0])
{
case "Add":
{
try
{
AddFunction(generator, cmdArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
}
case "Remove":
{
try
{
RemoveFunction(generator, cmdArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
}
case "Rating":
{
try
{
RatingFunction(generator, cmdArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
}
case "Team":
{
try
{
TeamFunction(generator, cmdArgs);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
break;
}
default:
break;
}
}
}
public void Initialize()
{
_sampleTeam1 = TeamGenerator.GenerateTeam1();
_sampleTeam2 = TeamGenerator.GenerateTeam2();
_manyTeams = TeamGenerator.GenerateManyTeams();
}
