public GWPosition <PositionData, ActionData> CreateNewPosition(GWAction <PositionData, ActionData> action)
{
var newPosition = new GWPosition <PositionData, ActionData>(
ExecuteAction(action), action.Position.Depth + 1, action.Position.CategoryPath);
return(newPosition);
}
public PreSolution(GWPosition <PositionData, ActionData> position, LinkedList <RunItem <PositionData, ActionData, CheckpointData> > runItemPath)
{
Position = position;
if (runItemPath.NotNullOrEmpty())
{
RunItemPath.AddRange(runItemPath);
}
}
public void AddPosition(GWPosition <PositionData, ActionData> position)
{
var insertionIndex = mainResultsList.SortedInsertPos(position, MaxResultsCount, this);
if (insertionIndex < Feedback.Length)
{
NewFeed.Enter(new ResultCenterFeed <PositionData, ActionData>(position, insertionIndex, Feedback[insertionIndex]));
}
}
public override void AddBranchingPoint(GWPosition <PositionData, ActionData> position)
{
var score = Program.Random.NextDouble();
branchingPoints.SortedInsert(new AgO <GWPosition <PositionData, ActionData>, double>(position, score), (ago) => ago.Data2);
if (branchingPoints.Count > BufferSize)
{
branchingPoints.RemoveLast();
}
}
public CategoryEvaluation Evaluate(GWPosition <PositionData, ActionData> position)
{
var evaluation = EvaluateInternal(position);
if (evaluation.BestPossibleScore <= currentBestScore)
{
evaluation.CanImproveBestResult = false;
}
return(evaluation);
}
internal void EndPositionDiscovered(GWPosition <PositionData, ActionData> position)
{
CurrentPosition.IsEndPosition = true;
CurrentPosition.Score = EndPositionEvaluator.Evaluate(CurrentPosition);
if (BestResult == null || CurrentPosition.Score > BestResult.Score)
{
BestResult = CurrentPosition;
NewBestResult.Enter(BestResult);
}
}
internal void EndPositionDiscovered(GWPosition <PositionData, ActionData> position)
{
if (position.IsEndPosition)
{
CategoryEvaluationLogic.AddPositionFound(position);
position.Score = EndPositionEvaluator.Evaluate(position);
if (BestResult == null || position.Score > BestResult.Score)
{
BestResult = position;
NewBestResult.Enter(position);
}
}
}
public RunItem(GWPosition <PositionData, ActionData> position, Action <RunItem <PositionData, ActionData, CheckPointType> > onTargetReached, ActionHandling <PositionData, ActionData> actionHandling, double[] weights, int multiEvaluationOptions)
{
MultiEvaluationOptions = multiEvaluationOptions;
Id = Program.Random.Next();
OnTargetReached = onTargetReached;
ActionHandling = actionHandling;
Weights = weights;
if (Weights == null)
{
Weights = new double[actionHandling.ActionEvaluators.Count()];
for (int i = 0; i < actionHandling.ActionEvaluators.Count(); i++)
{
Weights[i] = Program.Random.NextDouble();
}
}
PreSolutions.Add(new PreSolution <PositionData, ActionData, CheckPointType>(new GWPosition <PositionData, ActionData>(position.Data.Clone(), position.Depth + 1, position.CategoryPath), null));
}
internal IEnumerable <GWPosition <PositionData, ActionData> > ExecuteMandatoryActions(GWPosition <PositionData, ActionData> position)
{
var mandatoryActions = FindMandatoryActions(position);
if (mandatoryActions.NullOrEmpty())
{
yield return(position);
}
else
{
foreach (var action in mandatoryActions)
{
var clonePos = new GWPosition <PositionData, ActionData>(position.Data.Clone(), position.Depth, position.CategoryPath);
action.Position = clonePos;
ExecuteAction(action);
yield return(clonePos);
}
}
}
public int Compare(GWPosition <PositionData, ActionData> x, GWPosition <PositionData, ActionData> y)
{
for (int level = 0; level < Evaluators.Length; level++)
{
double scoreX = 0, scoreY = 0;
foreach (var evaluator in Evaluators[level])
{
scoreX += evaluator.Weight * evaluator.Evaluate(x);
scoreY += evaluator.Weight * evaluator.Evaluate(y);
}
if (scoreX > scoreY)
{
return(1);
}
if (scoreX < scoreY)
{
return(-1);
}
}
return(0);
}
public void AddPositionFound(GWPosition <PositionData, ActionData> position)
{
positionsFound.Add(position);
currentBestScore = Math.Max(currentBestScore, Evaluate(position).EstimatedScore);
}
private CategoryEvaluation EvaluateCategory(GWPosition <PositionData, ActionData> pos)
{
var score = CategoryEvaluationLogic.Evaluate(pos);
return(score);
}
public ResultCenterFeed(GWPosition <PositionData, ActionData> item, int rank, double food)
{
Item = item;
Food = food;
Rank = rank;
}
public override void RemoveBranchingPoint(GWPosition <PositionData, ActionData> position)
{
branchingPoints.RemoveWhere(ago => ago.Data1.Equals(position));
}
public GWCrossroad(GWPosition <PositionData, ActionData> position)
{
Position = position;
PositionDataCopy = position.Data.Clone();
}
public abstract bool ReachTarget(GWPosition <PositionData> position);
internal void Work()
{
try
{
//prepare
CurrentPosition = new GWPosition <PositionData, ActionData>(InputConverter.Convert(Input), 0, null);
//CurrentPositions.AddLast(CurrentPosition);
var isnewPosition = true;
while (CurrentPosition != null && DateTime.Now - StartTime < ComputationTime)
{
NodesVisited++;
//foreach (var position in CurrentPositions)
{
//gather options:
var options = new LinkedList <GWAction <PositionData, ActionData> >();
if (CurrentPosition.HasInitActions)
{
//options.AddRange(CurrentPosition.UndiscoveredActions);
}
else
{
foreach (var actionFinder in ActionFinders)
{
var foundOptions = actionFinder.FindActions(CurrentPosition);
options.AddRange(foundOptions);
//TODO: filter double actions (from several actionFinders)
}
if (options.NullOrEmpty())
{
//discovery of ending position
EndPositionDiscovered(CurrentPosition);
}
else
{
foreach (var actionEvaluator in ActionEvaluators)
{
actionEvaluator.Weight = Program.Random.NextDouble();
}
int tempNr = 0;
foreach (var option in options)
{
option.TempNumber = tempNr;
tempNr++;
}
//evaluateOptions
int EachEvaluatorOptions = 5;
//int Branches = 50;
var optionsScore = new double[options.Count];
foreach (var actionEvaluator in ActionEvaluators)
{
var bestOptions = new LinkedList <GWAction <PositionData, ActionData> >();
foreach (var option in options)
{
option.Score = actionEvaluator.Evaluate(option) * actionEvaluator.Weight;
bestOptions.SortedInsert(option, EachEvaluatorOptions, o => o.Score);
}
var bestOptionsList = bestOptions.ToList();
for (int i = 0; i < bestOptionsList.Count; i++)
{
optionsScore[bestOptionsList[i].TempNumber] += (EachEvaluatorOptions - i) * actionEvaluator.Weight;
}
}
foreach (var option in options)
{
option.Score = optionsScore[option.TempNumber];
}
//CurrentPosition.AddActions(options.MaxEntries(o => o.Score, Branches));
}
}
if (options.NullOrEmpty())
{
//this position is fully discovered
BranchingPointsControlUnit.RemoveBranchingPoint(CurrentPosition);
CurrentPosition = BranchingPointsControlUnit.GetNextBranchingPoint();
isnewPosition = false;
}
else
{
if (isnewPosition)
{
BranchingPointsControlUnit.AddBranchingPoint(CurrentPosition);
}
var bestOption = options.MaxEntry(op => op.Score);
//execute best Option
//var bestOption = ordered_options.First();
var newPosition = ActionExecuter.CreateNewPosition(bestOption);
foreach (var evaluator in PositionEvaluators)
{
newPosition.Score += evaluator.Evaluate(newPosition);
}
//newPosition.Parents.AddLast(CurrentPosition);
//CurrentPosition.Children.AddLast(newPosition);
//CurrentPosition.UndiscoveredActions.Remove(bestOption);
//CurrentPosition.DiscoveredActions.AddLast(new AgO<GWAction<PositionData, ActionData>, GWPosition<PositionData, ActionData>>(bestOption, null));
//CurrentPosition.DiscoveredActions.AddLast(new AgO<GWAction<PositionData, ActionData>, GWPosition<PositionData, ActionData>>(bestOption, newPosition));
CurrentPosition = newPosition;
isnewPosition = true;
}
}
}
}
catch (Exception e)
{
Log.Error(e);
}
}
protected abstract IEnumerable <GWAction <PositionData, ActionData> > FindMandatoryActions(GWPosition <PositionData, ActionData> position);
public override double Evaluate(GWPosition <PositionData, ActionData> position)
{
return(Evaluation(position.Data));
}
public abstract double Evaluate(GWPosition <PositionData, ActionData> position);
public abstract LinkedList <GWAction <PositionData, ActionData> > FindActions(GWPosition <PositionData, ActionData> position);
public abstract void RemoveBranchingPoint(GWPosition <PositionData, ActionData> position);
protected abstract CategoryEvaluation EvaluateInternal(GWPosition <PositionData, ActionData> position);
public GWAction(GWPosition <PositionData, ActionData> position, ActionData actiondata, bool hasImpactOnTarget)
{
HasImpactOnTarget = hasImpactOnTarget;
Position = position;
Data = actiondata;
}
public PreSolution(GWPosition <PositionData, ActionData> position)
{
Position = position;
}
public abstract int Categorize(GWPosition <PositionData, ActionData> position);
