public void Init()
{
var logger = new Mock <ILog>();
logger.Setup(log => log.Error(It.IsAny <string>()));
var discriminator = new StandartTokenDiscriminator(logger.Object);
calculator = new StandartCalculator(discriminator);
}
public StandartFormulaMonitor(Container container)
{
_container = container;
StatusManager = _container.GetInstance <IFormulaStatusManager>();
FormulaCalculator = _container.GetInstance <IFormulaCalculator>();
ThreadPool.QueueUserWorkItem(Observe <CreatedMonitor>, created.IsActive);
ThreadPool.QueueUserWorkItem(Observe <UpdatedMonitor>, updated.IsActive);
ThreadPool.QueueUserWorkItem(Observe <DeletedMonitor>, deleted.IsActive);
}
public AttackCommandHandler(
IPlayerStore playerStore,
IRandom random,
IFormulaCalculator calculator,
IOptions <AttackOptions> options)
: base(playerStore, random)
{
_calculator = calculator;
_options = options.Value;
}
public Population(IFormulaCalculator calculator)
{
Osobi = new List <Unit>();
TempPopulation = new List <decimal>();
Pars = new List <Para>();
Formula = calculator;
Min = Formula.Min;
Max = Formula.Max;
GensCount = Formula.Gens;
GenerateLen();
GenerateNew(Formula.StartCount);
}
public Population(IFormulaCalculator calculator)
{
Osobi = new List<Unit>();
TempPopulation = new List<decimal>();
Pars=new List<Para>();
Formula=calculator;
Min = Formula.Min;
Max = Formula.Max;
GensCount = Formula.Gens;
GenerateLen();
GenerateNew(Formula.StartCount);
}
public BotCommandHandler(
IPlayerStore playerStore,
IRandom random,
IFormulaCalculator calculator,
IOptions <AttackOptions> attackOptions,
IOptions <PurchaseWeaponOptions> purchaseWeaponOptions,
IOptions <PurchaseHealingOptions> purchaseHealingOptions
) : base(playerStore, random)
{
_calculator = calculator;
_attackOptions = attackOptions.Value;
_purchaseWeaponHandlerOptions = purchaseWeaponOptions.Value;
_purchaseHealingHandlerOptions = purchaseHealingOptions.Value;
}
private static AttackCommandHandler CreateSut(
Player player = null,
IPlayerStore playerStore = null,
IRandom random = null,
IFormulaCalculator calculator = null,
AttackOptions options = null)
{
player = player ?? PlayerFixture.CreateDefaultPlayer();
playerStore = playerStore ?? Substitute.For <IPlayerStore>();
playerStore.GetPlayer().Returns(player);
random = random ?? Substitute.For <IRandom>();
calculator = calculator ?? Substitute.For <IFormulaCalculator>();
var optionsSnapshot = Substitute.For <IOptionsSnapshot <AttackOptions> >();
optionsSnapshot.Value.Returns(options ?? new AttackOptions());
return(new AttackCommandHandler(playerStore, random, calculator, optionsSnapshot));
}
public abstract Task SearchAsync(IRepository <ServerFormula> repository, IFormulaCalculator formulaCalculator, IFormulaStatusManager statusManage);
public override async Task SearchAsync(IRepository <ServerFormula> repository, IFormulaCalculator formulaCalculator, IFormulaStatusManager statusManager)
{
this.repository = repository;
this.formulaCalculator = formulaCalculator;
this.statusManager = statusManager;
var observerFormulas = await repository.GetAllAsync(f => f.Status == FormulaStatus.Waiting ||
f.Status == FormulaStatus.ErrorRequirements ||
f.Status == FormulaStatus.InProgress,
tracking : true,
withRequired : true);
await ManageStatus(observerFormulas, FormulaStatus.InProgress); //Формулы теперь в самом процессе расчета
await ProcessInProgress(observerFormulas);
//Успешно завершаем формулы, которые не отпали с ошибками
await ManageStatus(observerFormulas.Where(f => f.Status == FormulaStatus.InProgress), FormulaStatus.Success);
}
public override async Task SearchAsync(IRepository <ServerFormula> repository, IFormulaCalculator formulaCalculator, IFormulaStatusManager statusManager)
{
this.repository = repository;
this.formulaCalculator = formulaCalculator;
this.statusManager = statusManager;
var observerFormulas = await repository.GetAllAsync(f => f.Status == FormulaStatus.Deleted,
tracking : true,
withEncapsulated : true,
withRequired : true);
foreach (var formula in observerFormulas)
{
//Всех зависящих теперь нужно пересчитывать
await ManageStatus(formula.Encapsulated, FormulaStatus.ErrorRequirements);
formula.Required.Clear(); //Избавляемся от зависимостией
await repository.DeleteAsync(formula.FormulaId); //И можно спокойно удаляться
}
await repository.SaveAsync();
}
public void RegisterCalculator <T>(IFormulaCalculator <T> checker) where T : IFormula
{
_formula.RegisterCalculator(checker);
}
public override async Task SearchAsync(IRepository <ServerFormula> repository, IFormulaCalculator formulaCalculator, IFormulaStatusManager statusManager)
{
this.repository = repository;
this.formulaCalculator = formulaCalculator;
this.statusManager = statusManager;
var observerFormulas = await repository.GetAllAsync(f => f.Status == FormulaStatus.Updated,
tracking : true,
withEncapsulated : true,
withRequired : true);
foreach (var formula in observerFormulas)
{
//Говорим, что всех зависимых тоже нужно будем пересчитать
await ManageStatus(formula.Encapsulated, FormulaStatus.Updated);
formula.Required.Clear();
}
await ManageStatus(observerFormulas, FormulaStatus.Waiting); // И ждем пересчета
await repository.SaveAsync();
}
