public IAction PrepareInstance(IAction action, IAlgorithmContext algorithmContext)
{
if (action is IContextInitializable contextInitializable)
{
contextInitializable.Initialize(algorithmContext);
}
if (action is IScenariosAccess scenarioAccessObj)
{
scenarioAccessObj.SetTargetScenario(_scenarioRepository.Scenarios.FirstOrDefault(x => x.Id.Equals(((IScenariosAccess)action).TargetScenarioId)));
}
if (action is IUsersGeolocationAccess geolocationAccessObj)
{
geolocationAccessObj.SetNeedTargets(() => _usersRepository.Users.ToArray());
}
if (action is IMessagesSender messagesSender)
{
messagesSender.SetNeedTargets(() => _usersRepository.Users.ToArray());
}
if (action is IScenariosEnumerator scenariosEnumerator)
{
var scenariosActionSource = new ScenarioActionSource(_usersRepository.SystemUser, ScenarioStartupSource.OtherScenario, ScenarioAction.Execute);
scenariosEnumerator.SetCasts(() =>
_scenarioRepository
.Scenarios
.Where(x =>
x.IsAccessAvailable(scenariosActionSource))
.Select(x => x.CreateCast())
.ToArray());
}
return(action);
}
protected override void _runAlgorithm(IAlgorithmContext context)
{
DungeonTiles workingTiles = context.D.Tiles;
bool[,] algMask = context.Mask;
_ctx = context;
if (this.WallStrategy == WallFormation.Tiles)
{
throw new NotImplementedException();
}
bool[,] existingDataMask = new bool[workingTiles.Height, workingTiles.Width];
for (int y = 0; y < workingTiles.Height; ++y)
{
for (int x = 0; x < workingTiles.Width; ++x)
{
existingDataMask[y, x] = algMask[y, x] && (workingTiles[y, x].Physics == Tile.MoveType.Wall);
}
}
// Prime the dungeon tiles by opening them all up (as appropriate).
// "Ignore" shouldn't wipe existing data, but...
switch (BuildStrategy)
{
case ExistingDataHandling.Ignore:
case ExistingDataHandling.Avoid:
workingTiles.SetAllToo(Tile.MoveType.Open_HORIZ, existingDataMask);
break;
case ExistingDataHandling.Overwrite:
workingTiles.SetAllToo(Tile.MoveType.Open_HORIZ, algMask);
break;
default:
throw new NotImplementedException();
}
// Run algorithm with the appropriate mask
// ... "Ignore" SHOULD build walls over existing data
Rectangle startRegion = new Rectangle(0, 0, workingTiles.Width, workingTiles.Height);
switch (BuildStrategy)
{
case ExistingDataHandling.Avoid:
this.Divide(workingTiles, startRegion, existingDataMask, algMask, context.R);
break;
case ExistingDataHandling.Ignore:
case ExistingDataHandling.Overwrite:
this.Divide(workingTiles, startRegion, algMask, algMask, context.R);
break;
default:
throw new NotImplementedException();
}
_ctx = null;
}
protected override void _runAlgorithm(IAlgorithmContext context)
{
DungeonTiles workingDungeon = context.D.Tiles;
ISet <Tile> deadEnds = new HashSet <Tile>();
for (int i = 0; i < this.FillPasses; ++i)
{
for (int y = 0; y < workingDungeon.Height; ++y)
{
for (int x = 0; x < workingDungeon.Width; ++x)
{
if (!context.Mask[y, x] || workingDungeon[y, x].Physics == Tile.MoveType.Wall)
{
continue;
}
bool physicsDeadEnd = (workingDungeon[y, x].Physics.SidesOpened() == 1);
bool adjacentsdeadEnd = (workingDungeon.GetAdjacentOpensFor(x, y) == 1);
if (!physicsDeadEnd && !adjacentsdeadEnd)
{
continue;
}
workingDungeon[y, x].Physics = workingDungeon[y, x].Physics.CloseOff(Tile.MoveType.Open_HORIZ);
}
}
workingDungeon.Parent.CreateGroup(deadEnds);
}
}
static void MakeAWithdrawl(IAlgorithmContext context)
{
Console.WriteLine("Enter amount: ");
string input = Console.ReadLine();
if (double.TryParse(input, out var amount))
{
Console.WriteLine();
Console.WriteLine("Opening Balance");
Console.WriteLine(context.Balance.ToString("C", context.Culture));
Console.WriteLine();
IAlgorithmOutput output = context.Withdraw(amount);
Console.WriteLine("Input");
Console.WriteLine(amount.ToString("C", context.Culture));
Console.WriteLine("Output");
Console.WriteLine(output.Output);
Console.WriteLine("Balance");
Console.WriteLine(context.Balance.ToString("C", context.Culture));
}
else
{
Console.WriteLine("Couldn't parse input...");
}
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_action = (CancelExecutionAction)actionHolder.Action;
action1View.Refresh(actionHolder, algoContext);
}
public static IConstructorElement Create(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
IConstructorElement element;
if (actionHolder.Action is ExecuteAction)
{
element = new ExecuteActionView();
}
else if (actionHolder.Action is SetReturnValueAction)
{
element = new ReturnScenarioValueView();
}
else if (actionHolder.Action is IfAction)
{
element = new IfActionView();
}
else if (actionHolder.Action is WhileAction)
{
element = new WhileActionView();
}
else if (actionHolder.Action is CancelExecutionAction)
{
element = new CancelExecutionActionView();
}
else
{
throw new NotImplementedException();
}
element.Refresh(actionHolder, algoContext);
return(element);
}
protected override void _runAlgorithm(IAlgorithmContext context)
{
// Find all dead ends and do a depth-first search for the first tile
// that has greater than two openings, and build a weighted list of
// dead-end halls
throw new NotImplementedException();
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_checkerAction = (CheckerAction)actionHolder.Action;
textBlock.Text = _checkerAction.ComparisonType.Caption;
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_pair = (CheckerOperatorPair)ActionHolder.Action;
operatorView.Refresh(actionHolder, algoContext);
actionView.Refresh(new ActionHolder((IAction)_pair.Checker), algoContext);
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_action = (WhileAction)actionHolder.Action;
actionView.Refresh(new ActionHolder(_action.Action), algoContext);
checkerView.Refresh(new ActionHolder(_action.Checker), algoContext);
}
public ExecutionContext(IAlgorithmContext algorithmContext, string input, string previousValue, OutputChangedDelegates output, SafeCancellationToken cancellationTokenSource)
{
OutputChanged = output;
CancellationTokenSource = cancellationTokenSource;
AlgorithmContext = algorithmContext;
Input = input;
PreviousValue = previousValue;
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
AlgorithmContext = algoContext;
ActionHolder = actionHolder;
Model = new ActionModel();
Model.Refresh(ActionHolder);
DataContext = Model;
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_action = (ExecuteAction)actionHolder.Action;
action1View.Refresh(_action.MasterActionHolder, algoContext);
action2View.Refresh(_action.InputValue, algoContext);
Action2EqualizeToAction1();
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_action = (IfAction)actionHolder.Action;
actionIfView.Refresh(new ActionHolder(_action.ActionIf), algoContext);
actionElseView.Refresh(new ActionHolder(_action.ActionElse), algoContext);
checkerView.Refresh(new ActionHolder(_action.Checker), algoContext);
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_action = (SetReturnValueAction)actionHolder.Action;
action1View.Refresh(actionHolder, algoContext);
action2View.Refresh(_action.InputValue, algoContext);
action2View.MasterAction = _action;
}
public ExecutionContext(IAlgorithmContext algorithmContext, string input, string previousValue, OutputChangedDelegates output, ExecutionContext parentContext, SafeCancellationToken cancellationTokenSource)
{
OutputChanged = output;
AlgorithmContext = algorithmContext;
Input = input;
PreviousValue = previousValue;
CancellationTokenSource = cancellationTokenSource;
ParentContext = parentContext;
ExecutionNesting = ParentContext.ExecutionNesting + 1;
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
AlgorithmContext = algoContext;
ActionHolder = actionHolder;
_action = (CheckerAction)actionHolder.Action;
action1View.Refresh(_action.TargetAction1Holder, algoContext);
action2View.Refresh(_action.TargetAction2Holder, algoContext);
comparisonView.Refresh(actionHolder, algoContext);
Action2EqualizeToAction1();
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
_operatorPair = (CheckerOperatorPair)actionHolder.Action;
tbOperator1.Text
= _operatorPair.Operator == LogicalOperator.And || _operatorPair.Operator == LogicalOperator.AndNot ? "И" : "ИЛИ";
tbOperator2.Text
= _operatorPair.Operator == LogicalOperator.AndNot || _operatorPair.Operator == LogicalOperator.OrNot ? "НЕ" : string.Empty;
}
#pragma warning restore 67
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
AlgorithmContext = algoContext;
ActionHolder = actionHolder;
_action = (ComplexCheckerAction)actionHolder.Action;
Children.Clear();
foreach (var pair in _action.CheckerOperations)
{
Insert(pair);
}
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
ActionHolder = actionHolder;
AlgorithmContext = algoContext;
if (Model == null)
{
Model = new ActionModel();
DataContext = Model;
}
Model.Refresh(ActionHolder);
}
public void Refresh(ActionHolder actionHolder, IAlgorithmContext algoContext)
{
AlgorithmContext = algoContext;
ActionHolder = actionHolder;
_action = (ComplexAction)actionHolder.Action;
Children.Clear();
foreach (var holder in _action.ActionHolders)
{
Insert(holder);
}
}
/// <see cref="InfestationAlgorithmBase._runAlgorithm(IAlgorithmContext)"/>
protected override void _runAlgorithm(IAlgorithmContext context)
{
Library _l = context.L;
Dungeon _d = context.D;
Random _r = context.R;
// Add one thing to each group in the dungeon
foreach (TileGroupInfo group in _d.Groups.Where(grp => context.Mask.ContainsAny(grp.Tiles)))
{
InfestationInfo randomItem = _l.AllInfestations.Where(info => info.Category == InfestationType.Item)
.Random(_r);
_d.Infestations.Associate(group, randomItem);
}
}
protected override void _runInternal(IAlgorithmContext context)
{
foreach (var cb in this.Callbacks)
{
foreach (var alg in Algorithms)
{
alg.AttachCallback(cb);
}
}
foreach (IAlgorithm alg in Algorithms)
{
alg.Run(context);
this.RunCallbacks(context);
}
}
public IAction CreateInstance(Type type, IAlgorithmContext algorithmContext)
{
var action = (IAction)Activator.CreateInstance(type);
PrepareInstance(action, algorithmContext);
if (action is ExecuteAction executeAction)
{
executeAction.InputValue.Action = CoreActions.Utils.Default(action.ValueType);
}
else if (action is SetReturnValueAction setReturnValueAction)
{
setReturnValueAction.InputValue.Action = CoreActions.Utils.Default(algorithmContext.ValueType);
}
return(action);
}
protected override void _runAlgorithm(IAlgorithmContext context)
{
context.D.Tiles.SetAllToo(Tile.MoveType.Wall, context.Mask);
foreach (var cb in this.Callbacks)
{
RoomBuilder?.AttachCallback(cb);
MazeCarver?.AttachCallback(cb);
DeadEndFiller?.AttachCallback(cb);
}
RoomBuilder?.Run(context);
this.RunCallbacks(context);
MazeCarver?.Run(context);
this.RunCallbacks(context);
DeadEndFiller?.Run(context);
this.RunCallbacks(context);
}
public IAction PrepareInstance(IAction action, IAlgorithmContext algorithmContext)
{
if (action is IContextInitializable contextInitializable)
{
contextInitializable.Initialize(algorithmContext);
}
if (action is IScenariosAccess scenarioAccessObj)
{
scenarioAccessObj.SetTargetScenario(_scenarioRepository.Scenarios.FirstOrDefault(x => x.Id.Equals(((IScenariosAccess)action).TargetScenarioId)));
}
if (action is IUsersGeolocationAccess geolocationAccessObj)
{
geolocationAccessObj.SetNeedTargets(() => _usersRepository.Users.ToArray());
}
if (action is IMessagesSender messagesSender)
{
messagesSender.SetNeedTargets(() => _usersRepository.Users.ToArray());
}
return(action);
}
/// <see cref="AlgorithmBase._runInternal(IAlgorithmContext)"/>
protected override void _runInternal(IAlgorithmContext context)
{
if (context == null)
{
throw new ArgumentNullException("Can't infest without any context!");
}
if (context.D == null)
{
throw new ArgumentNullException("Can't infest nothing!");
}
if (context.Mask == null)
{
context.Mask = context.D.Tiles.DefaultMask;
}
if (context.L == null || context.L.AllInfestations == null || context.L.AllInfestations.Count == 0)
{
// We have nothing to do if there is nothing to infest with
return;
}
_runAlgorithm(context);
}
protected override void _runAlgorithm(IAlgorithmContext context)
{
throw new NotImplementedException();
}
protected override void _runInternal(IAlgorithmContext context)
{
return;
}
/// <summary> /// Runs the internal Infestation Algorithm, after the base implementation takes care of any /// common parameter checking. Implementor can assume the context is valid. /// </summary> /// <param name="context">The context in which this Algorithm is to be run.</param> protected abstract void _runAlgorithm(IAlgorithmContext context);
