public async Task Get_Cooperator_Players_Strategies()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
players = simulationServce.GetPlayersStrategies(players);
bool badPlayers = players.Where(p => p.StrategyId != cooperator.Id).Any();
Assert.IsFalse(badPlayers);
}
static void Main(string[] args)
{
IDiceService diceService = new DiceService();
IRulesService rulesService = new RulesService(diceService);
var rules = rulesService.GetRules(ERules.Percentage);
IStrategyService strategyService = new StrategyService(rules);
IVillage village = new Village(diceService, strategyService, rules);
IList <ICharacter> fighters = new List <ICharacter>();
for (int i = 0; i < 200; i++)
{
var character = village.GetFighter(EFighterClass.Warrior);
fighters.Add(character);
}
for (int i = 0; i < 10; i++)
{
var character = village.GetFighter(EFighterClass.Ranger);
fighters.Add(character);
}
IArena arena = new ClassicArena(fighters);
arena.StartFight();
}
public async Task Get_Strategies_By_Id_Count_Equal_Distinct_Strategies()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
List <Strategy> allStrategies = await strategyService.GetAllStrategies();
Strategy cheater = allStrategies.Where(s => s.Name == "Simple Cheater").FirstOrDefault();
Strategy cooperator = allStrategies.Where(s => s.Name == "Simple Cooperator").FirstOrDefault();
List <Player> players = new List <Player>();
for (int i = 0; i < 5; i++)
{
players.Add(new Player()
{
StrategyId = cheater.Id
});
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
var strategies = strategyService.GetStrategiesById(players.Select(p => p.StrategyId).ToList());
Assert.AreEqual(2, strategies.Count);
}
public async Task Should_Coop_Vs_Cheater()
{
var repositoryMock = new Mock <IStrategyRepository>();
StrategyService strategyService = new StrategyService(repositoryMock.Object);
Player player = ConditionalPlayers.GetCheaterVsCooperator();
string enemyId = Guid.NewGuid().ToString();
List <PlayerMove> moves = new List <PlayerMove>()
{
new PlayerMove()
{
PlayerId = player.Id, Type = MoveType.Cooperate
},
new PlayerMove()
{
PlayerId = enemyId, Type = MoveType.Cheat
}
};
var rounds = new List <Round>()
{
new Round()
{
PlayersMoves = moves
},
new Round()
{
PlayersMoves = moves
},
};
PlayerMove move = await strategyService.GetNextMoveAsync(player, rounds);
Assert.AreEqual(MoveType.Cooperate, move.Type);
}
public MacdMAStrategy()
{
_jobService = new JobService();
_watchlistService = new WatchlistService();
_userSessionService = new UserSessionService();
_strategyService = new StrategyService();
}
private Execution MakeTrade(Order order)
{
string strategyName = new StrategyService().FindStrategyById(order.StrategyId).Name;
if (strategyName == "IOC")
{
IOCStrategy ioc = new IOCStrategy();
return(ioc.buyorsell(order));
}
else if (strategyName == "MRKT")
{
MarketPriceStrategy mk = new MarketPriceStrategy();
return(mk.buyorsell(order));
}
else if (strategyName == "FOK")
{
FOKStrategy fok = new FOKStrategy();
return(fok.buyorsell(order));
}
else if (strategyName == "GTC")
{
GTCStrategy gtcStrategy = new GTCStrategy();
return(gtcStrategy.buyorsell(order));
}
else
{
return(null);
}
}
public async Task Winner_Score_Is_Total_Score()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
Simulation simulation = await simulationServce.Run(players);
GameSettings gameSettings = gameSettingsProvider.GetGameSettings();
int totalScore = gameSettings.TotalRounds
* (gameSettings.CooperateModifier + gameSettings.MoveModifier)
* (players.Count - 1);
Assert.AreEqual(totalScore, simulation.Winner.Score);
}
public async Task Run_Once_When_Consistent()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var simulationRepository = new SimulationRepository(connection);
var gameService = new GameService(strategyService, gameSettingsProvider);
var populationService = new PopulationService(gameService);
//TODO: simplify /\
var simulationServce = new SimulationService(simulationRepository, populationService,
strategyService, new SimulationSettingsProvider());
Strategy cooperator = await strategyRepository
.GetByNameAsync(NoMemoryStrategies.GetSimpleCooperator().Name);
var players = new List <Player>();
for (int i = 0; i < 10; i++)
{
players.Add(new Player()
{
StrategyId = cooperator.Id
});
}
Simulation simulation = await simulationServce.Run(players);
Assert.IsNotNull(simulation.Winner);
Assert.AreEqual(1, simulation.PopulationsCompleated);
}
public async Task Get_Strategies_By_Id_Count_Equal_All_Strategies()
{
var strategyRepository = new StrategyRepository(connection);
var strategyService = new StrategyService(strategyRepository);
var strategiesIds = strategyService.GetAllStrategies().Result.Select(s => s.Id).ToList();
var strategies = strategyService.GetStrategiesById(strategiesIds);
Assert.AreEqual(strategiesIds.Count, strategies.Count);
}
public async Task Should_Cheat_Vs_Cooperator()
{
var repositoryMock = new Mock <IStrategyRepository>();
StrategyService strategyService = new StrategyService(repositoryMock.Object);
Player player = ConditionalPlayers.GetCheaterVsCooperator();
PlayerMove move = await strategyService.GetNextMoveAsync(player, GetCoopHistory(Guid.NewGuid().ToString(), player.Id));
Assert.AreEqual(MoveType.Cheat, move.Type);
}
public async Task Copycat_Should_Cooperate()
{
var repositoryMock = new Mock <IStrategyRepository>();
StrategyService strategyService = new StrategyService(repositoryMock.Object);
Player player = BasicPlayers.GetCheaterPlayer();
PlayerMove move = await strategyService.GetNextMoveAsync(player, GetCoopHistory(player.Id, Guid.NewGuid().ToString()));
Assert.AreEqual(MoveType.Cheat, move.Type);
}
public void TestAddOrder()
{
Trader trader = new TraderService().FindTraderById(1);
Strategy strategy = new StrategyService().FindStrategyById(1);
OrderBook orderBook = new OrderBookService().FindOrderBookById(1);
Order order = new Order {
DateTime = DateTime.Now, Execution = null, IsBuy = true, Price = 12.3, Quantity = 12, Trader = trader
};
new OrderService().AddOrder(order);
}
public StrategiesViewModel(StrategyService strategies, MarketService markets, AccountService accounts, SettingService settings)
{
Model = strategies;
_markets = markets;
_accounts = accounts;
_settings = settings;
AddCommand = new RelayCommand(() => DoAddStrategy(), () => !IsBusy);
ImportCommand = new RelayCommand(() => DoImportStrategies(), () => !IsBusy);
ExportCommand = new RelayCommand(() => DoExportStrategies(), () => !IsBusy);
SelectedChangedCommand = new RelayCommand <ITreeViewModel>((vm) => DoSelectedChanged(vm), true);
DataFromModel();
}
public async Task <IActionResult> EditStrategy([FromBody] StrategyModel request)
{
try
{
var service = new StrategyService(_dbContext, _mapper);
service.EditStrategy(request);
await _dbContext.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
private static void StrategyPattern()
{
try
{
var service = new StrategyService(new VostokDocumentCreator());
service.CheckDocument();
Console.WriteLine(service.GetDocumentParamsAsString());
service = new StrategyService(new VodafoneDocumentCreator("2"));
service.CheckDocument();
Console.WriteLine(service.GetDocumentParamsAsString());
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public async Task <IActionResult> AddStrategy([FromBody] StrategyModel request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var service = new StrategyService(_dbContext, _mapper);
var user = await _userManager.GetApplicationUserAsync(User);
service.AddStrategy(user, request);
await _dbContext.SaveChangesAsync();
return(Ok());
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public async void Building(string unitsel)
{
// In-memory database only exists while the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <ApplitactionDbContext>()
.UseSqlite(connection)
.Options;
//var context = new ApplitactionDbContext(options);
using (var context = new ApplitactionDbContext(options))
{
context.Database.EnsureCreated();
}
using (var context = new ApplitactionDbContext(options))
{
var g = new Strategy_game.Models.Game();
var c = new Strategy_game.Models.Country()
{
CountryName = "zzzz", Gold = 1000
};
var a = new Strategy_game.Models.Archer()
{
OwnerCountry = c, Counter = 2
};
var h = new Strategy_game.Models.Horseman()
{
OwnerCountry = c, Counter = 2
};
var s = new Strategy_game.Models.Elite()
{
OwnerCountry = c, Counter = 2
};
var f = new Strategy_game.Models.Farm()
{
OwnerCountry = c, Counter = 4
};
var b = new Strategy_game.Models.Barrack()
{
OwnerCountry = c, Counter = 2
};
context.Games.Add(g);
context.Countries.Add(c);
context.Archers.Add(a);
context.Horsemans.Add(h);
context.Elites.Add(s);
context.Farms.Add(f);
context.Barracks.Add(b);
context.SaveChanges();
var ch = context.Countries.FirstOrDefaultAsync(d => d.CountryName == "zzzz").Result;
//var casd = context.Countries.FirstOrDefaultAsync();
var p = new Platoon()
{
Owner = ch,
Archers = new Archer()
{
Counter = 150
},
Horsemans = new Horseman()
{
Counter = 150
},
Soldiers = new Elite()
{
Counter = 150
},
};
context.Platoons.Add(p);
context.SaveChanges();
}
using (var context = new ApplitactionDbContext(options))
{
var service = new UnitBuildingSetterService(context);
var service_strat = new StrategyService(context);
//service.DoOneRound();
var from = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "zzzz").Result;
var resultfarm = context.Farms.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "zzzz").Result;
var resultbarrack = context.Barracks.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "zzzz").Result;
if (unitsel == "Farm")
{
await service.buyB(resultfarm.BuildingId, from);
Assert.Equal(4, resultfarm.Counter);
Assert.Equal(5, resultfarm.Builder);
Assert.Equal(1000 - 200, from.Gold);
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
Assert.Equal(0, resultfarm.Builder);
Assert.Equal(5, resultfarm.Counter);
}
if (unitsel == "Barrack")
{
await service.buyB(resultbarrack.BuildingId, from);
Assert.Equal(2, resultbarrack.Counter);
Assert.Equal(5, resultbarrack.Builder);
Assert.Equal(1000 - 1000, from.Gold);
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
service_strat.DoOneRound();
Assert.Equal(0, resultbarrack.Builder);
Assert.Equal(3, resultbarrack.Counter);
}
}
}
finally
{
connection.Close();
}
}
public void LoserCountry(int x, int y)
{
// In-memory database only exists while the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <ApplitactionDbContext>()
.UseSqlite(connection)
.Options;
//var context = new ApplitactionDbContext(options);
using (var context = new ApplitactionDbContext(options))
{
context.Database.EnsureCreated();
}
using (var context = new ApplitactionDbContext(options))
{
var g = new Strategy_game.Models.Game();
var c = new Strategy_game.Models.Country()
{
CountryName = "zzzz"
};
var a = new Strategy_game.Models.Archer()
{
OwnerCountry = c, Counter = 2
};
var h = new Strategy_game.Models.Horseman()
{
OwnerCountry = c, Counter = 2
};
var s = new Strategy_game.Models.Elite()
{
OwnerCountry = c, Counter = 2
};
var f = new Strategy_game.Models.Farm()
{
OwnerCountry = c, Counter = 4
};
var b = new Strategy_game.Models.Barrack()
{
OwnerCountry = c, Counter = 2
};
var c2 = new Strategy_game.Models.Country()
{
CountryName = "cccc"
};
var a2 = new Strategy_game.Models.Archer()
{
OwnerCountry = c2, Counter = 10
};
var h2 = new Strategy_game.Models.Horseman()
{
OwnerCountry = c2, Counter = 10
};
var s2 = new Strategy_game.Models.Elite()
{
OwnerCountry = c2, Counter = 10
};
var f2 = new Strategy_game.Models.Farm()
{
OwnerCountry = c2, Counter = 12
};
var b2 = new Strategy_game.Models.Barrack()
{
OwnerCountry = c2, Counter = 2
};
context.Games.Add(g);
context.Countries.Add(c);
context.Archers.Add(a);
context.Horsemans.Add(h);
context.Elites.Add(s);
context.Farms.Add(f);
context.Barracks.Add(b);
context.Countries.Add(c2);
context.Archers.Add(a2);
context.Horsemans.Add(h2);
context.Elites.Add(s2);
context.Farms.Add(f2);
context.Barracks.Add(b2);
context.SaveChanges();
var ch = context.Countries.FirstOrDefaultAsync(d => d.CountryName == "zzzz").Result;
var ch2 = context.Countries.FirstOrDefaultAsync(d => d.CountryName == "cccc").Result;
//var casd = context.Countries.FirstOrDefaultAsync();
var p = new Platoon()
{
Owner = ch,
Archers = new Archer()
{
Counter = 150
},
Horsemans = new Horseman()
{
Counter = 150
},
Soldiers = new Elite()
{
Counter = 150
},
Intent = ch2.CountryId,
};
context.Platoons.Add(p);
Assert.NotEqual(0, ch.CountryId);
context.SaveChanges();
}
using (var context = new ApplitactionDbContext(options))
{
var service = new StrategyService(context);
service.DoOneRound();
var p = context.Platoons
.Include(pts => pts.Archers)
.Include(pts => pts.Horsemans)
.Include(pts => pts.Soldiers)
.Include(pts => pts.Owner).FirstOrDefaultAsync().Result;
//service.DoOneRound();
var from = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "zzzz").Result;
var to = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "cccc").Result;
var ra = context.Archers.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
var rh = context.Horsemans.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
var rs = context.Elites.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
Assert.Equal(150, to.Gold);
Assert.Equal(290, from.Gold);
Assert.Equal(1440, from.Potatoes);
Assert.Equal(800, to.Potatoes);
Assert.Equal(9, ra.Counter);
Assert.Equal(9, rh.Counter);
Assert.Equal(9, rs.Counter);
Assert.Equal(0, p.Intent);
Assert.Equal(150, p.Archers.Counter);
Assert.Equal(150, p.Horsemans.Counter);
Assert.Equal(150, p.Soldiers.Counter);
}
}
finally
{
connection.Close();
}
}
public void WarUpgrades(int x1, int x2, string upgrade, bool val)
{
// In-memory database only exists while the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <ApplitactionDbContext>()
.UseSqlite(connection)
.Options;
//var context = new ApplitactionDbContext(options);
using (var context = new ApplitactionDbContext(options))
{
context.Database.EnsureCreated();
}
using (var context = new ApplitactionDbContext(options))
{
var g = new Strategy_game.Models.Game();
var c = new Strategy_game.Models.Country()
{
CountryName = "zzzz"
};
var a = new Strategy_game.Models.Archer()
{
OwnerCountry = c, Counter = 2
};
var h = new Strategy_game.Models.Horseman()
{
OwnerCountry = c, Counter = 2
};
var s = new Strategy_game.Models.Elite()
{
OwnerCountry = c, Counter = 2
};
var f = new Strategy_game.Models.Farm()
{
OwnerCountry = c, Counter = 4
};
var b = new Strategy_game.Models.Barrack()
{
OwnerCountry = c, Counter = 2
};
var c2 = new Strategy_game.Models.Country()
{
CountryName = "cccc"
};
var a2 = new Strategy_game.Models.Archer()
{
OwnerCountry = c2, Counter = 2
};
var h2 = new Strategy_game.Models.Horseman()
{
OwnerCountry = c2, Counter = 2
};
var s2 = new Strategy_game.Models.Elite()
{
OwnerCountry = c2, Counter = 2
};
var f2 = new Strategy_game.Models.Farm()
{
OwnerCountry = c2, Counter = 12
};
var b2 = new Strategy_game.Models.Barrack()
{
OwnerCountry = c2, Counter = 2
};
if (upgrade == "wall")
{
c2.Wall = val;
}
if (upgrade == "strategy")
{
c.Commander = val;
}
if (upgrade == "tacticianDef")
{
c2.Tactican = val;
}
if (upgrade == "tacticianAtk")
{
c.Tactican = val;
}
if (upgrade == "tactician")
{
c2.Tactican = val;
}
context.Games.Add(g);
context.Countries.Add(c);
context.Archers.Add(a);
context.Horsemans.Add(h);
context.Elites.Add(s);
context.Farms.Add(f);
context.Barracks.Add(b);
context.Countries.Add(c2);
context.Archers.Add(a2);
context.Horsemans.Add(h2);
context.Elites.Add(s2);
context.Farms.Add(f2);
context.Barracks.Add(b2);
context.SaveChanges();
var ch = context.Countries.FirstOrDefaultAsync(d => d.CountryName == "zzzz").Result;
var ch2 = context.Countries.FirstOrDefaultAsync(d => d.CountryName == "cccc").Result;
//var casd = context.Countries.FirstOrDefaultAsync();
var p = new Platoon()
{
Owner = ch,
Archers = new Archer()
{
Counter = 6
},
Horsemans = new Horseman()
{
Counter = 6
},
Soldiers = new Elite()
{
Counter = 6
},
Intent = ch2.CountryId,
};
context.Platoons.Add(p);
Assert.NotEqual(0, ch.CountryId);
context.SaveChanges();
}
using (var context = new ApplitactionDbContext(options))
{
var service = new StrategyService(context);
service.DoOneRound();
var p = context.Platoons
.Include(pts => pts.Archers)
.Include(pts => pts.Horsemans)
.Include(pts => pts.Soldiers)
.Include(pts => pts.Owner).FirstOrDefaultAsync().Result;
//service.DoOneRound();
var from = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "zzzz").Result;
var to = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "cccc").Result;
var ra = context.Archers.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
var rh = context.Horsemans.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
var rs = context.Elites.Include(Ra => Ra.OwnerCountry).FirstOrDefaultAsync(C => C.OwnerCountry.CountryName == "cccc").Result;
//(300,140,640,10,0,15)
Assert.Equal(x1, to.Gold);
Assert.Equal(x2, from.Gold);
Assert.Equal(0, p.Intent);
}
}
finally
{
connection.Close();
}
}
public void UpgradeForPotatoes(bool x1, int x2, string x3)
{
// In-memory database only exists while the connection is open
var connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
try
{
var options = new DbContextOptionsBuilder <ApplitactionDbContext>()
.UseSqlite(connection)
.Options;
//var context = new ApplitactionDbContext(options);
using (var context = new ApplitactionDbContext(options))
{
context.Database.EnsureCreated();
}
using (var context = new ApplitactionDbContext(options))
{
var c = new Strategy_game.Models.Country()
{
CountryName = "zzzz",
Potatoes = 500,
};
var g = new Strategy_game.Models.Game();
if (x3 == "tractor")
{
c.Tractor = x1;
}
else
{
c.Combine = x1;
}
var a = new Strategy_game.Models.Archer()
{
OwnerCountry = c, Counter = 2
};
var h = new Strategy_game.Models.Horseman()
{
OwnerCountry = c, Counter = 2
};
var s = new Strategy_game.Models.Elite()
{
OwnerCountry = c, Counter = 2
};
var f = new Strategy_game.Models.Farm()
{
OwnerCountry = c, Counter = 4
};
var b = new Strategy_game.Models.Barrack()
{
OwnerCountry = c, Counter = 2
};
context.Games.Add(g);
context.Countries.Add(c);
context.Archers.Add(a);
context.Horsemans.Add(h);
context.Elites.Add(s);
context.Farms.Add(f);
context.Barracks.Add(b);
context.SaveChanges();
}
using (var context = new ApplitactionDbContext(options))
{
var service = new StrategyService(context);
service.DoOneRound();
var from = context.Countries.FirstOrDefaultAsync(C => C.CountryName == "zzzz").Result;
Assert.Equal(x2, from.Potatoes);
}
}
finally
{
connection.Close();
}
}
public CountryController(ApplicationDbContext dbContext, StrategyService service)
{
_service = service;
}