public void processMatchup(EvaluationTask task)
{
Console.WriteLine($"Thread {Thread.CurrentThread.ManagedThreadId}, evaluates games {task.game_number + 1} of " +
$"({this.agents[task.idx_player_1].AgentAuthor}, {this.agents[task.idx_player_2].AgentAuthor}), " +
$"({this.decks[task.idx_deck_1].deckname}, {this.decks[task.idx_deck_2].deckname})");
AbstractAgent player1 = Activator.CreateInstance(agents[task.idx_player_1].AgentClass) as AbstractAgent;
AbstractAgent player2 = Activator.CreateInstance(agents[task.idx_player_2].AgentClass) as AbstractAgent;
GameConfig gameConfig = new GameConfig
{
StartPlayer = 1,
Player1HeroClass = decks[task.idx_deck_1].cardclass,
Player2HeroClass = decks[task.idx_deck_2].cardclass,
Player1Deck = decks[task.idx_deck_1].cards,
Player2Deck = decks[task.idx_deck_1].cards,
};
GameStats gameStats = null;
while (gameStats == null || (gameStats.PlayerA_Wins == 1) == (gameStats.PlayerB_Wins == 1))
{
var gameHandler = new POGameHandler(gameConfig, player1, player2);
gameHandler.PlayGames(1);
gameStats = gameHandler.getGameStats();
}
results[task.idx_player_1, task.idx_player_2, task.idx_deck_1, task.idx_deck_2].addResult(
gameStats.PlayerA_Wins == 1,
gameStats.PlayerB_Wins == 1,
gameStats.PlayerA_Exceptions == 1,
gameStats.PlayerB_Exceptions == 1
);
}
public static void TestPOGameMyAgent(int count, CardClass player, CardClass opponent, List <Card> playerDeck, List <Card> opponentDeck, AbstractAgent opponentAgent)
{
Console.WriteLine("Setup gameConfig");
var gameConfig = new GameConfig()
{
StartPlayer = -1,
Player1HeroClass = player,
Player2HeroClass = opponent,
Player1Deck = playerDeck,
Player2Deck = opponentDeck,
FillDecks = false,
Shuffle = true,
Logging = true
};
Console.WriteLine("Setup POGameHandler");
AbstractAgent player1 = new MCTSAgent();
AbstractAgent player2 = opponentAgent;
var gameHandler = new POGameHandler(gameConfig, player1, player2, repeatDraws: false);
Console.WriteLine("Simulate Games");
gameHandler.PlayGames(nr_of_games: count, addResultToGameStats: true, debug: false);
GameStats gameStats = gameHandler.getGameStats();
Console.WriteLine(player + " vs " + opponent);
gameStats.printResults();
Console.WriteLine("Test successful");
}
public static void TestPOGame(int numberOfRuns, int startPlayer, AbstractAgent p1, AbstractAgent p2, CardClass p1HeroClass, CardClass p2HeroClass, List <Card> p1Deck, List <Card> p2Deck, bool train = false)
{
Console.WriteLine("Setup gameConfig");
var gameConfig = new GameConfig()
{
StartPlayer = startPlayer,
Player1HeroClass = p1HeroClass,
Player2HeroClass = p2HeroClass,
Player1Deck = p1Deck,
Player2Deck = p2Deck,
FillDecks = false,
Shuffle = true,
Logging = true
};
Console.WriteLine("Setup POGameHandler");
var gameHandler = new POGameHandler(gameConfig, p1, p2, repeatDraws: false);
Console.WriteLine("Simulate Games");
//gameHandler.PlayGame();
gameHandler.PlayGames(nr_of_games: numberOfRuns, addResultToGameStats: true, debug: false);
GameStats gameStats = gameHandler.getGameStats();
gameStats.printResults();
Console.WriteLine("Writing results to the file");
//TODO: write the results here
String wins = "";
for (int i = 0; i < gameStats.PlayerA_Wins; i++)
{
wins += "1";
}
for (int i = 0; i < numberOfRuns - gameStats.PlayerA_Wins; i++)
{
wins += "2";
}
//write the results
if (train)
{
string outputFile = "/home/tobias/Develop/Java/CrushingBots/data/TRAINING_results.txt";
using (StreamWriter sw = File.AppendText(outputFile))
{
sw.Write(wins);
}
Console.WriteLine("Test successful");
//Console.ReadLine();
}
Console.WriteLine("Test successful");
//Console.ReadLine();
}
/// <summary>
/// plays the game, a function to reduce repeated code.
/// </summary>
/// <param name="gameConfig"></param>
/// <param name="player1"></param>
/// <param name="player2"></param>
internal static void playGame(GameConfig gameConfig, AbstractAgent player1, AbstractAgent player2)
{
var gameHandler = new POGameHandler(gameConfig, player1, player2, debug: false);
gameHandler.PlayGames(100);
GameStats gameStats = gameHandler.getGameStats();
gameStats.printResults();
}
public static ICommand Create(AbstractAgent agent)
{
OffsetPositionFromTargetMapElement command = new OffsetPositionFromTargetMapElement
{
agent = agent,
monoBehaviour = agent
};
return(command);
}
public static ICommand Create(AbstractAgent agent)
{
MoveToTargetLocation command = new MoveToTargetLocation
{
agent = agent,
monoBehaviour = agent
};
return(command);
}
private static PlayableAgent SetupPlayer()
{
StringBuilder help = new StringBuilder();
help.AppendLine("<---------- Player Setup ---------->");
help.AppendLine("Choose player deck and agent");
help.AppendLine("Available decks: AggroPirateWarrior, MidrangeBuffPaladin, MidrangeJadeShaman, MidrangeSecretHunter, " +
"MiraclePirateRogue, RenoKazakusDragonPriest, RenoKazakusMage");
help.AppendLine("Available agents: RandomAgent, GreedyAgent, BeamSearchAgent, DynamicLookaheadAgent, MCTSAgent");
help.Append("Example: AggroPirateWarrior BeamSearchAgent");
string input = ReadFromConsole(help.ToString());
PlayableAgent agent = new PlayableAgent();
if (String.IsNullOrWhiteSpace(input))
{
return(agent);
}
List <string> parsedInput = input.Split(' ').ToList();
if (parsedInput.Count >= 2)
{
agent.SetDeck(parsedInput[0]);
var assembly = Assembly.GetExecutingAssembly();
try
{
var type = assembly.GetTypes()
.First(t => t.Name == parsedInput[1]);
if (parsedInput[1] == "MCTSAgent")
{
agent.Agent = GetParamsForAgent();
}
else
{
AbstractAgent agentInstance = (AbstractAgent)Activator.CreateInstance(type);
agent.Agent = agentInstance;
}
}
catch (Exception e)
{
Console.WriteLine("Invalid agent name. Using default agent");
}
}
else
{
Console.WriteLine("Not enough parameters. Using default deck and agent.");
}
return(agent);
}
public AgentTournament(AbstractAgent agentAI, int agentId)
{
this.agentAI = agentAI;
this.agentId = agentId;
finalWins = 0;
leagueWins = 0;
stageWins = 0;
leagueTurns = 0;
stageTurns = 0;
finalTurns = 0;
}
public static ICommand Create(AbstractAgent agent)
{
BroadcastAdvertisement command = new BroadcastAdvertisement
{
advertisingMapElement = agent,
excludeReceiver = agent,
monoBehaviour = agent
};
return(command);
}
/// <summary>
/// Creates a moltable object.
/// </summary>
/// <param name="agent">The agent whose traits will be passed</param>
/// <param name="spawnable">The object to be spawned when molting. Usually the agent</param>
/// <param name="moltPercefntage">The percentage that the spawned object will grow in size</param>
/// <returns></returns>
public static IMoltable Create(AbstractAgent agent, ISpawnable spawnable, float moltPercefntage = defaultMoltPercentage)
{
AgentMolter agentMolter = new AgentMolter
{
abstractAgent = agent,
spawnable = spawnable,
moltPercentage = moltPercefntage
};
return(agentMolter);
}
public POGameHandler(GameConfig gameConfig, AbstractAgent player1, AbstractAgent player2, bool setupHeroes = true, bool repeatDraws = false)
{
this.gameConfig = gameConfig;
this.setupHeroes = setupHeroes;
this.player1 = player1;
player1.InitializeAgent();
this.player2 = player2;
player2.InitializeAgent();
gameStats = new GameStats();
}
public POGameHandler(GameConfig gameConfig, AbstractAgent player1, AbstractAgent player2, bool setupHeroes = true, string debugMode = "")
{
//NumGames = numGames;
//GamesPlayed = gamesPlayed;
_gameConfig = gameConfig;
_setupHeroes = setupHeroes;
_player1 = player1;
_player1.InitializeAgent();
_player2 = player2;
_player2.InitializeAgent();
//gameStats = new GameStats(gameConfig.Player1Name, gameConfig.Player2Name);
_debugMode = debugMode;
}
public POGameHandler(GameConfig gameConfig, AbstractAgent player1, AbstractAgent player2, bool setupHeroes = true, bool debug = false)
{
this.gameConfig = gameConfig;
this.setupHeroes = setupHeroes;
this.player1 = player1;
player1.InitializeAgent();
this.player2 = player2;
player2.InitializeAgent();
gameStats = new GameStats();
this.debug = debug;
// empty the logfile
File.WriteAllText(Directory.GetCurrentDirectory() + @"\dump.log", "Starting new Log\n");
}
public void setUp()
{
Map <List <Percept>, Action> perceptSequenceActions = new Map <List <Percept>, Action>();
perceptSequenceActions.Add(createPerceptSequence(new DynamicPercept(
"key1", "value1")), ACTION_1);
perceptSequenceActions.Add(createPerceptSequence(new DynamicPercept(
"key1", "value1"), new DynamicPercept("key1", "value2")),
ACTION_2);
perceptSequenceActions.Add(createPerceptSequence(new DynamicPercept(
"key1", "value1"), new DynamicPercept("key1", "value2"),
new DynamicPercept("key1", "value3")), ACTION_3);
agent = new MockAgent(new TableDrivenAgentProgram(
perceptSequenceActions));
}
private void Initialize(POGame game)
{
switch (game.CurrentPlayer.HeroClass)
{
case CardClass.WARRIOR:
subAgent = new WarriorSubAgent();
break;
case CardClass.MAGE:
subAgent = new MageSubAgent();
break;
// default: just let subAgent be null so it skips the code for the "main" agent
}
initialized = true;
}
private static void Main(string[] args)
{
Console.WriteLine("Setup gameConfig");
//todo: rename to Main
/*GameConfig gameConfig = new GameConfig
* {
* StartPlayer = 1,
* Player1HeroClass = CardClass.MAGE,
* Player1Deck = Decks.RenoKazakusMage,
* // Player1Deck = Decks.AggroPirateWarrior,
* // Player1Deck = Decks.MidrangeJadeShaman,
* Player2HeroClass = CardClass.MAGE,
* Player2Deck = Decks.RenoKazakusMage,
* // Player2Deck = Decks.AggroPirateWarrior,
* // Player2Deck = Decks.MidrangeJadeShaman,
* FillDecks = true,
* Logging = true
* };*/
int numberOfFights = 10;
int gamesPerFight = 100;
for (int i = 0; i < numberOfFights; i++)
{
Console.WriteLine("Setup POGameHandler");
AbstractAgent player1 = new Galahad();
AbstractAgent player2 = GetRandomAgent();
Console.WriteLine("Fight " + i + " out of " + numberOfFights + " ==> " + player1.ToString() + " vs. " + player2.ToString());
GameConfig randomGameConfig = GetRandomGameConfig();
Console.WriteLine(randomGameConfig.Player1HeroClass.ToString() + " vs. " + randomGameConfig.Player2HeroClass.ToString());
var gameHandler = new POGameHandler(GetRandomGameConfig(), player1, player2, debug: true);
gameHandler.PlayGames(gamesPerFight);
GameStats gameStats = gameHandler.getGameStats();
gameStats.printResults();
Console.WriteLine(randomGameConfig.Player1HeroClass.ToString() + " vs. " + randomGameConfig.Player2HeroClass.ToString());
player1.FinalizeAgent();
}
Console.WriteLine("Test successful");
Process.Start(@"powershell", $@"-c (New-Object Media.SoundPlayer 'E:\music\sampleTracks\taylor_swift_goat.wav').PlaySync();");
Console.ReadLine();
}
public static void AgentDuel(int count, PlayableAgent player, PlayableAgent opponent, bool saveLogs = false)
{
Console.WriteLine("Setup gameConfig");
var gameConfig = new GameConfig()
{
StartPlayer = -1,
Player1HeroClass = player.AgentClass,
Player2HeroClass = opponent.AgentClass,
Player1Deck = player.Deck,
Player2Deck = opponent.Deck,
FillDecks = false,
Shuffle = true,
Logging = true
};
//Console.WriteLine("Setup POGameHandler");
AbstractAgent player1 = player.Agent;
AbstractAgent player2 = opponent.Agent;
var gameHandler = new POGameHandler(gameConfig, player1, player2, repeatDraws: false);
Console.WriteLine("Simulate Games");
gameHandler.PlayGames(nr_of_games: count, addResultToGameStats: true, debug: false);
GameStats gameStats = gameHandler.getGameStats();
if (saveLogs)
{
try
{
string path = "log.txt";
using (StreamWriter sw = File.CreateText(path))
{
gameStats.GameInfoLogs.ForEach(log => log.ForEach(logEntry => sw.WriteLine(logEntry)));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
Console.WriteLine(player.AgentClass + " vs " + opponent.AgentClass);
gameStats.printResults();
Console.WriteLine("Duel successful");
}
/// <summary>
/// plays all games that are required for the competition. My deck against all other three. It plays 100 matches and 100 matched (mirrored) for each opponent deck.
/// </summary>
/// <param name="gameConfig"></param>
/// <param name="player1"></param>
/// <param name="player2"></param>
/// <param name="decks"></param>
internal static void SimulateAllGames(GameConfig gameConfig, AbstractAgent player1, AbstractAgent player2, Dictionary <string, List <Card> > decks)
{
foreach (KeyValuePair <string, List <Card> > deck in decks)
{
Console.WriteLine("-> RenokazakusMage (me) vs " + deck.Key);
gameConfig.Player2Deck = deck.Value;
playGame(gameConfig, player1, player2);
Console.WriteLine("-> Mirror:" + deck.Key + " vs RenokazakusMage (me)");
playGame(gameConfig, player2, player1);
Console.WriteLine("");
}
Console.WriteLine(" -----------------------------");
}
/// <summary>
/// 更新agent，更新元胞（驾驶），调用服务
/// </summary>
public override void UpdateStatus()
{
//更新异步agent，如果有的话
for (int i = 0; i < this.asynAgents.Count; i++)
{
AbstractAgent visitor = this.asynAgents[i];
visitor.VisitUpdate(this); //.VisitUpdate();
}
var mobileNode = this.Mobiles.First;
//update mobile on a lane one by one
while (mobileNode != null)
{
var mobile = mobileNode.Value;
//mobile is possibaly be deleted
mobile.Run(this as StaticOBJ);
mobileNode = mobileNode.Next;
}
this.ServeMobiles();
base.UpdateStatus(); //基类调用了OnStatusChanged 进行绘图服务
}
public void setUp() {
env = new XYEnvironment(10, 12);
a = new MockAgent();
env.addObjectToLocation(a, new XYLocation(3, 4));
}
public void Run(int numGenerations, List <TyDeckHeroPair> myDeck, List <TyDeckHeroPair> enemyDeck, AbstractAgent enemyAgent)
{
var myDeckName = TyDeckHeroPair.GetDeckListPrint(myDeck);
var enemyDeckName = TyDeckHeroPair.GetDeckListPrint(enemyDeck);
FileName = myDeckName + "Vs" + enemyDeckName + "_" + enemyAgent.GetType().Name;
while (File.Exists(FileName + ".txt"))
{
FileName += "0";
}
WriteGlobalToFile();
TyDebug.LogInfo(FileName);
TyDebug.LogInfo("Generations: " + numGenerations);
for (int step = 0; step < numGenerations; step++)
{
var startDate = DateTime.Now;
Train(_currentPopulation, myDeck, enemyDeck, enemyAgent);
var children = GiveBirth(SelectFittest(_currentPopulation), _random, step + 1);
Train(children, myDeck, enemyDeck, enemyAgent);
_currentPopulation = MixPopulations(_currentPopulation, children, step + 1);
Log("Generation " + (step));
LogPopulation(_currentPopulation);
var diff = DateTime.Now.Subtract(startDate);
Log("Generation took " + diff.Minutes + " min, " + diff.Seconds + " s");
WriteCurrentToFile(FileName + ".txt");
_csvLog.WriteToFiles(FileName);
}
}
private void ComputeFitness(TyWeightsLearner learner, List <TyDeckHeroPair> myDeck, List <TyDeckHeroPair> enemyDeck, AbstractAgent enemyAgent)
{
learner.BeforeLearn();
TyMatchSetup training = new TyMatchSetup(TycheAgent.GetLearningAgent(learner.Weights), enemyAgent);
training.RunRounds(myDeck, enemyDeck, Rounds, MatchesPerRound);
learner.AfterLearn(training.TotalPlays, training.Agent0Wins);
}
private void Train(List <TyWeightsLearner> learners, List <TyDeckHeroPair> myDeck, List <TyDeckHeroPair> enemyDeck, AbstractAgent enemyAgent)
{
for (int i = 0; i < learners.Count; i++)
{
var childLearner = learners[i];
childLearner.Weights.Clamp(MIN_WEIGHT, MAX_WEIGHT);
for (int j = 0; j < NUM_TRAININGS; j++)
{
ComputeFitness(childLearner, myDeck, enemyDeck, enemyAgent);
}
}
}
private static void Main(string[] args)
{
Console.WriteLine("Setup gameConfig");
AbstractAgent agent1 = null;
AbstractAgent agent2 = null;
if (args[0].Equals("EVA"))
{
Console.WriteLine("EVA loaded for agent 1");
agent1 = new EVA();
((EVA)agent1).InitializeAgent();
}
else if (args[0].Equals("AlvaroAgent"))
{
agent1 = new AlvaroAgent();
((AlvaroAgent)agent1).InitializeAgent();
}
if (args[3].Equals("EVA"))
{
Console.WriteLine("EVA loaded for agent 2");
agent2 = new EVA();
((EVA)agent2).InitializeAgent();
}
else if (args[3].Equals("AlvaroAgent"))
{
agent2 = new AlvaroAgent();
((AlvaroAgent)agent2).InitializeAgent();
}
Console.WriteLine("Agents loaded!");
var gameConfig = new GameConfig()
{
StartPlayer = -1, // set to -1 should randomize starting player every game
// Player1HeroClass = CardClass.MAGE,
// Player2HeroClass = CardClass.MAGE,
FillDecks = true,
Shuffle = true,
Logging = false,
Player1HeroClass = stringToCardClass(args[2]),
Player2HeroClass = stringToCardClass(args[5]),
// FillDecks = false,
// Logging = false,
Player1Deck = stringToDeck(args[1]),
Player2Deck = stringToDeck(args[4]) //RenoKazakusMage
};
int numGames = Int32.Parse(args[6]);
Console.WriteLine("Setup POGameHandler");
var gameHandler = new POGameHandler(gameConfig, agent1, agent2, repeatDraws: false);
Console.WriteLine("Simulate Games");
//gameHandler.PlayGame();
gameHandler.PlayGames(nr_of_games: numGames, addResultToGameStats: true, debug: false);
GameStats gameStats = gameHandler.getGameStats();
gameStats.printResults();
Console.WriteLine("Player 1: " + args[0] + " with deck " + args[1]);
Console.WriteLine("Player 2: " + args[3] + " with deck " + args[4]);
Console.WriteLine("Test successful");
// Console.ReadLine();
}
/// <summary>
/// Removes an agent from the register list. DOES NOT destroy the agent object, this should be taken care of by the script calling this function.
/// </summary>
/// <param name="a">The agent to remove</param>
public void DeregisterAgent(AbstractAgent a)
{
_agents.Remove(a);
}
/// <summary>
/// Adds and agent to the register list.
/// </summary>
/// <param name="a">The agent to add</param>
public void RegisterAgent(AbstractAgent a)
{
_agents.Add(a);
}
public TyMatchSetup(AbstractAgent agent0, AbstractAgent agent1)
{
this._agent0 = agent0;
this._agent1 = agent1;
}
