public static void Demo2b_ImprovedLinear(this GameBoard board)
{
var linearStrategy = new ChutesAndLadders.Strategy.Linear.Engine();
var improvedLinearStrategy1 = new ChutesAndLadders.Strategy.Rules.Engine("Improved Linear 1");
improvedLinearStrategy1.AddTakeLadderRules(28, 84);
improvedLinearStrategy1.AddTakeLadderRules(80, 100);
var improvedLinearStrategy2 = new ChutesAndLadders.Strategy.Rules.Engine("Improved Linear 2");
improvedLinearStrategy2.AddTakeLadderRules(28, 84);
improvedLinearStrategy2.AddTakeLadderRules(80, 100);
improvedLinearStrategy2.AddTakeChuteRules(98, 78);
// This is the shortest path, which should give the same results
// as "Take All Ladders" if all games started from 0
var improvedLinearStrategy3 = new ChutesAndLadders.Strategy.Rules.Engine("Improved Linear 3");
improvedLinearStrategy3.AddTakeLadderRules(1, 38);
improvedLinearStrategy3.AddTakeLadderRules(51, 67);
improvedLinearStrategy3.AddTakeLadderRules(71, 91);
var player1 = new Player("Player 1", linearStrategy);
var player2 = new Player("Player 2", improvedLinearStrategy1);
var player3 = new Player("Player 3", improvedLinearStrategy2);
var player4 = new Player("Player 4", improvedLinearStrategy3);
var players = new Player[] { player1, player2, player3, player4 };
var engine = new SimulationCollection();
engine.RunSimulations(players, 30000, true);
}
private void startSimulationButton_Click(object sender, EventArgs e)
{
#if false
SimulationCollection simulations = new SimulationCollection(this.Model);
Technique.AddAll(simulations);
foreach (Target target in this.Targets)
{
GlobalSimulationContext globalContext = new GlobalSimulationContext(target);
SimulationContext initialContext = new SimulationContext(globalContext);
Simulator simulator = Simulator.CreateControlledCodeExecutionSimulator(simulations, initialContext);
simulator.Run();
resultsGridView.Rows.Add(new object[] {
globalContext,
target.Hardware.FullSymbol,
target.OperatingSystem.FullSymbol,
target.Application.FullSymbol,
target.Violation.FullSymbol,
globalContext.SimulationCount > 0 ? globalContext.CompletedSimulationContexts.Max(x => x.Exploitability) : 0,
globalContext.SimulationCount > 0 ? globalContext.CompletedSimulationContexts.Average(x => x.Exploitability) : 0,
globalContext.SimulationCount
});
}
#endif
}
/// <summary>
/// Find the first match in the given collection.
/// </summary>
/// <param name="simulations">The collection of simulations. Can be null or empty. </param>
/// <param name="path"></param>
/// <param name="headers"></param>
/// <returns></returns>
public Simulation Match(SimulationCollection simulations, System.Net.Http.HttpMethod method, string path, string query, IEnumerable<Header> headers)
{
if (null == simulations) return null;
if (simulations.Count() == 0) return null;
var matches = simulations.Where(f => Matches(f, method, path, query, headers) == true);
var match = matches.FirstOrDefault();
return match;
}
public static void GameActionOutput_SmallSample(this GameBoard board)
{
var randomStrategy = new ChutesAndLadders.Strategy.Random.Engine();
var player1 = new Player("Player 1", randomStrategy);
var player2 = new Player("Player 2", randomStrategy);
var player3 = new Player("Player 3", randomStrategy);
var player4 = new Player("Player 4", randomStrategy);
var player5 = new Player("Player 5", randomStrategy);
var player6 = new Player("Player 6", randomStrategy);
var players = new Player[] { player1, player2, player3, player4, player5, player6 };
var engine = new SimulationCollection();
var results = engine.RunSimulations(players, 60000, false, @".\");
}
public static void Demo2a_RulesEngine(this GameBoard board)
{
var linearStrategy = new ChutesAndLadders.Strategy.Rules.Engine();
var greedyRulesStrategy = new ChutesAndLadders.Strategy.GreedyRules.Engine();
var ladderRulesStrategy = new ChutesAndLadders.Strategy.TakeAllLadders.Engine();
var player1 = new Player("Player 1", linearStrategy);
var player2 = new Player("Player 2", greedyRulesStrategy);
var player3 = new Player("Player 3", ladderRulesStrategy);
var players = new Player[] { player1, player2, player3 };
var engine = new SimulationCollection();
engine.RunSimulations(players, 30000, true);
}
public static void Demo1a_GreedyAlgorithm(this GameBoard board)
{
var greedyStrategy = new ChutesAndLadders.Strategy.Greedy.Engine();
var badStrategy = new ChutesAndLadders.Strategy.AgressivelyBad.Engine();
var linearStrategy = new ChutesAndLadders.Strategy.Linear.Engine();
var player1 = new Player("Player 1", greedyStrategy);
var player2 = new Player("Player 2", badStrategy);
var player3 = new Player("Player 3", linearStrategy);
var players = new Player[] { player1, player2, player3 };
var engine = new SimulationCollection();
engine.RunSimulations(players, 30000, true);
}
public static void Demo3c_GeneticSuperiority(this GameBoard board)
{
var greedyStrategy = new ChutesAndLadders.Strategy.Greedy.Engine();
var linearStrategy = new ChutesAndLadders.Strategy.Linear.Engine();
var geneticStrategy = new ChutesAndLadders.Strategy.Rules.Engine("Best Found");
geneticStrategy.AddBestStrategyRules();
var player1 = new Player("Player 1", greedyStrategy);
var player2 = new Player("Player 2", linearStrategy);
var player3 = new Player("Player 3", geneticStrategy);
var players = new Player[] { player1, player2, player3 };
var engine = new SimulationCollection();
engine.RunSimulations(players, 100000, true);
}
public static void Demo3b_GeneticEvolution(this GameBoard board)
{
const int maxGenerations = 300;
const int simulationsPerGeneration = 1200;
const double misspellingRate = 0.05;
var basicGeneticStrategy = new ChutesAndLadders.Strategy.Genetic.Engine();
var player1 = new Player("Player 1", basicGeneticStrategy.Evolve(misspellingRate));
var player2 = new Player("Player 2", basicGeneticStrategy.Evolve(misspellingRate));
var player3 = new Player("Player 3", basicGeneticStrategy.Evolve(misspellingRate));
var player4 = new Player("Player 4", basicGeneticStrategy.Evolve(misspellingRate));
var player5 = new Player("Player 5", basicGeneticStrategy.Evolve(misspellingRate));
var player6 = new Player("Player 6", basicGeneticStrategy.Evolve(misspellingRate));
var players = new Player[] { player1, player2, player3, player4, player5, player6 };
var engine = new SimulationCollection();
int mostWins = 0;
int generationCount = 0;
while (generationCount < maxGenerations)
{
players = engine.RunSimulations(players, simulationsPerGeneration).Players.ToArray();
// Create the next generation of Players/Strategies
// by evolving based on the strategies of the top 2 players
var bestPlayers = players.OrderByDescending(p => p.WinCount).Take(2);
if (bestPlayers.First().WinCount > mostWins)
{
mostWins = bestPlayers.First().WinCount;
Console.WriteLine($"Generation {generationCount} (most wins {mostWins}):");
}
player1 = new Player("Player 1", bestPlayers.First().Strategy);
player2 = new Player("Player 2", bestPlayers.Last().Strategy);
player3 = new Player("Player 3", (player1.Strategy as ChutesAndLadders.Strategy.Genetic.Engine).Evolve());
player4 = new Player("Player 4", (player1.Strategy as ChutesAndLadders.Strategy.Genetic.Engine).Evolve());
player5 = new Player("Player 5", (player1.Strategy as ChutesAndLadders.Strategy.Genetic.Engine).Evolve());
player6 = new Player("Player 6", (player2.Strategy as ChutesAndLadders.Strategy.Genetic.Engine).Evolve());
players = new Player[] { player1, player2, player3, player4, player5, player6 };
generationCount++;
}
// Run the original (linear) strategy against the best one found genetically
var rootStrategy = new ChutesAndLadders.Strategy.Genetic.Engine("GeneticRoot");
var finalStrategy = players.OrderByDescending(p => p.WinCount).First().Strategy as ChutesAndLadders.Strategy.Genetic.Engine;
var p1 = new Player("Player 1", finalStrategy);
var p2 = new Player("Player 2", finalStrategy);
var p3 = new Player("Player 3", finalStrategy);
var p4 = new Player("Player 4", rootStrategy);
var p5 = new Player("Player 5", rootStrategy);
var p6 = new Player("Player 6", rootStrategy);
var finalPlayers = new Player[] { p1, p2, p3, p4, p5, p6 };
engine.RunSimulations(finalPlayers, simulationsPerGeneration, true);
Console.WriteLine($"{finalStrategy.Name} rules:");
Console.WriteLine(finalStrategy.ContrastWith(rootStrategy));
}
/// <summary>
/// Returns all matches in the order in which they were added.
/// </summary>
/// <param name="simulations">The collection of simulations. Can be null or empty. </param>
/// <param name="content"></param>
/// <param name="method"></param>
/// <param name="path"></param>
/// <param name="headers"></param>
/// <returns></returns>
public IEnumerable<Simulation> Matches(SimulationCollection simulations, HttpContent content, System.Net.Http.HttpMethod method, string path, string query, IEnumerable<Header> headers)
{
IEnumerable<Simulation> matches = new List<Simulation>();
if (null == simulations) return matches;
if (simulations.Count() == 0) return matches;
matches = simulations.Where(f => Matches(f, content, method, path, query, headers) == true);
return matches;
}
/// <summary>
/// Returns all matches in the order in which they were added.
/// </summary>
/// <param name="simulations">The collection of simulations. Can be null or empty. </param>
/// <param name="method"></param>
/// <param name="path"></param>
/// <param name="headers"></param>
/// <returns></returns>
public IEnumerable<Simulation> Matches(SimulationCollection simulations, System.Net.Http.HttpMethod method, string path, string query, IEnumerable<Header> headers)
{
return Matches(simulations, null, method, path, query, headers);
}
internal static SimulationCollection EmbedRelations(this SimulationCollection collection,
HttpRequest request, IEmbeddedRelationsSchema schema, UserManager <Model.User> userManager) =>
EmbedRelations <SimulationCollection, SimulationResource>(collection, request, schema, userManager);
public static void Evolution(int maxGenerations, int simulationsPerGeneration,
double misspellingRate, Func <int, int, int, Task> updateDelegate = null)
{
var players = new PlayerCollectionBuilder()
.Add("Player 1", new ChutesAndLadders.Strategy.Genetic.Engine())
.Add("Player 2", new ChutesAndLadders.Strategy.Genetic.Engine())
.Add("Player 3", new ChutesAndLadders.Strategy.Genetic.Engine())
.Add("Player 4", new ChutesAndLadders.Strategy.Genetic.Engine())
.Add("Player 5", new ChutesAndLadders.Strategy.Genetic.Engine())
.Add("Player 6", new ChutesAndLadders.Strategy.Genetic.Engine())
.Build();
var engine = new SimulationCollection();
int mostWins = 0;
int generationCount = 0;
int evolutionCount = 0;
while (generationCount < maxGenerations)
{
generationCount++;
players = engine.RunSimulations(players, simulationsPerGeneration).Players.ToArray();
// Create the next generation of Players/Strategies
// by evolving based on the strategies of the top 2 players
var bestPlayers = players.OrderByDescending(p => p.WinCount).Take(2);
if (bestPlayers.First().WinCount > mostWins)
{
mostWins = bestPlayers.First().WinCount;
Console.WriteLine($"Generation {generationCount} (most wins {mostWins}):");
evolutionCount++;
}
if (updateDelegate != null)
{
updateDelegate.Invoke(generationCount, mostWins, evolutionCount);
}
var bestStrategy = bestPlayers.First().Strategy;
var runnerUpStrategy = bestPlayers.Last().Strategy;
players = new PlayerCollectionBuilder()
.Add("Player 1", bestStrategy)
.Add("Player 2", runnerUpStrategy)
.Add("Player 3", (bestStrategy as Strategy.Genetic.Engine).CrossoverWith(runnerUpStrategy as Strategy.Genetic.Engine))
.Add("Player 4", (bestStrategy as Strategy.Genetic.Engine).Evolve())
.Add("Player 5", (bestStrategy as Strategy.Genetic.Engine).Evolve())
.Add("Player 6", (runnerUpStrategy as Strategy.Genetic.Engine).Evolve())
.Build();
}
// Run the linear strategy against the best one found genetically
var rootStrategy = new ChutesAndLadders.Strategy.Genetic.Engine("GeneticRoot");
// rootStrategy.LoadLinearDNA();
rootStrategy.LoadBestPathDNA();
var finalStrategy = players.OrderByDescending(p => p.WinCount).First().Strategy as Strategy.Genetic.Engine;
new SimulationCollectionBuilder()
.AddPlayer("Player 1", finalStrategy)
.AddPlayer("Player 2", finalStrategy)
.AddPlayer("Player 3", finalStrategy)
.AddPlayer("Player 4", rootStrategy)
.AddPlayer("Player 5", rootStrategy)
.AddPlayer("Player 6", rootStrategy)
.MaxExecutionCount(simulationsPerGeneration)
.OutputResults(true)
.Run();
Console.WriteLine($"{finalStrategy.Name} rules:");
Console.WriteLine(finalStrategy.ContrastWith(rootStrategy));
}
