public OptionSelectedCondition(OptionSelectedCondition src)
: base(src._lineNumber, src._linePosition)
{
Source = src.Source; // can share paths, but not resolved references
Require = src.Require;
Prohibit = src.Prohibit;
}
public DocTagCondition(DocTagCondition src)
: base(src._lineNumber, src._lineNumber)
{
Source = src.Source; // can share paths, but not resolved references
DocTag = src.DocTag;
Require = src.Require;
Prohibit = src.Prohibit;
}
public PhotoCountCondition(PhotoCountCondition src)
: base(src._lineNumber, src._linePosition)
{
Source = src.Source; // can share paths, but not resolved references
Context = src.Context;
RefType = src.RefType;
RefId = src.RefId;
Minimum = src.Minimum;
Maximum = src.Maximum;
}
public static Population CreatePopulation(Path.Path path, int populationSize)
{
var pathList = new List <Path.Path>();
for (int i = 0; i < populationSize; ++i)
{
pathList.Add(path.Shuffle());
}
return(new Population(pathList));
}
/// <summary>
/// Resolve a path into zero or more concrete objects. The returned
/// list is sorted by ordinal.
/// </summary>
/// Resolution into an object involves a call into the database.
internal List <T> ResolveMany <T>(Path.Path path, Reference context) where T : class, IContentSource
{
List <Reference> references = ResolveMany(path, context);
List <string> ids = references.Select(r => r.Id).ToList();
return(_unitOfWork.Repository <T>()
.Query(t => ids.Contains(t.Id))
.Get()
.ToList());
}
/// <summary>
/// Resolve a path into zero or one concrete object.
/// </summary>
/// Resolution into an object involves a call into the database.
/// <exception cref="AmbiguousPathException"></exception>
internal T ResolveOne <T>(Path.Path path, Reference context) where T : class, IContentSource
{
Reference reference = ResolveOne(path, context);
if (reference == null)
{
return(null);
}
return(ResolveOne <T>(reference));
}
public void findTest()
{
IFinder finder = new Permutation(CreateGraph());
Path.Path path = finder.FindPath(_places[0]);
Assert.AreEqual("A", path.Steps[0].StartPlace.Id);
Assert.AreEqual("B", path.Steps[1].StartPlace.Id);
Assert.AreEqual("C", path.Steps[2].StartPlace.Id);
Assert.AreEqual("D", path.Steps[3].StartPlace.Id);
Assert.AreEqual("A", path.Steps[3].EndPlace.Id);
}
public LivingObject()
: base()
{
this.healthPoints = 20;
this.maxHealthPoints = 20;
this.aggroRange = 300;
this.isDead = false;
tasks = new List<LivingObjectTask>();
aggroSystem = new Task.Aggro.AggroSystem<LivingObject>();
MovementSpeed = 1f;
currentTask = null;
this.canBeEffected = true;
this.interactions = new List<LivingObjectInteraction>();
this.path = null;
}
public LivingObject()
: base()
{
this.healthPoints = 20;
this.maxHealthPoints = 20;
this.aggroRange = 300;
this.isDead = false;
tasks = new List <LivingObjectTask>();
aggroSystem = new Task.Aggro.AggroSystem <LivingObject>();
MovementSpeed = 1f;
currentTask = null;
this.canBeEffected = true;
this.interactions = new List <LivingObjectInteraction>();
this.path = null;
}
private async Task MarkEatTo(Path.Path path, bool ignoreValidateMovement)
{
if (CurrentChessPiece != null)
{
if (CurrentChessPiece.IsWhite() != path.StartCell.CurrentChessPiece?.IsWhite() &&
(ignoreValidateMovement || await Board.ValidateMovement(path.StartCell, this)))
{
CanEatHere.Add(path);
}
return;
}
if (Movements[path.GetNextStep()] != null)
{
await Movements[path.GetStep()].MarkEatTo(path, ignoreValidateMovement);
}
}
private async Task MarkMoveTo(Path.Path path, bool ignoreValidateMovement)
{
if (CurrentChessPiece != null)
{
return;
}
if (ignoreValidateMovement || await Board.ValidateMovement(path.StartCell, this))
{
CanMoveHere.Add(path);
}
if (Movements[path.GetNextStep()] != null)
{
await Movements[path.GetStep()].MarkMoveTo(path, ignoreValidateMovement);
}
}
/// <summary>
/// Resolve a path into zero or one reference.
/// </summary>
/// Resolution into a reference is done in the in-memory
/// document structure, and does not call into the database.
/// <exception cref="AmbiguousPathException"></exception>
internal Reference ResolveOne(Path.Path path, Reference context)
{
List <Reference> resolved = path.Resolve(context, _resolver);
switch (resolved.Count)
{
case 0:
return(null);
case 1:
return(resolved[0]);
default:
throw new AmbiguousPathException(
$"Path resolves to {resolved.Count} objects",
path.ToString(), context.ToString(), path.LineNumber, path.LinePosition);
}
}
public static void Save(Graph.Graph graph, Path.Path path)
{
using StreamWriter outputFile = new StreamWriter("../../../../../Result/result.txt");
foreach (var pathPart in path.Steps)
{
if (graph.ChosenPlaces.Exists(item => item.Id.Equals(pathPart.StartPlace.Id)))
{
outputFile.Write($"{pathPart.StartPlace.Name}\n->");
}
}
outputFile.WriteLine(path.EndPlace.Name);
outputFile.Write("Czas:");
if (!path.TotalLength.Days.Equals(0))
{
outputFile.Write($"{path.TotalLength.Days} dni ");
}
outputFile.WriteLine($" {path.TotalLength.Hours} godzin {path.TotalLength.Minutes} minut");
outputFile.WriteLine($"Koszt: {path.Cost} zł");
}
private async Task CheckJumpEatTo(Path.Path path, bool ignoreValidateMovement)
{
if (path.GetNextStep() == Movement.Direction.Final)
{
if (CurrentChessPiece == null && (ignoreValidateMovement || await Board.ValidateMovement(path.StartCell, this)))
{
CanMoveHere.Add(path);
}
else if (CurrentChessPiece?.IsWhite() != path.StartCell.CurrentChessPiece?.IsWhite() &&
(ignoreValidateMovement ||
await Board.ValidateMovement(path.StartCell, this)))
{
CanEatHere.Add(path);
}
return;
}
if (Movements[path.GetStep()] != null)
{
await Movements[path.GetStep()].CheckJumpEatTo(path, ignoreValidateMovement);
}
}
private Path.Path CreatePath(List <Place> places)
{
Path.Path?outPath = new Path.Path();
List <Path.Path?> innerPath = new List <Path.Path>();
for (int j = 0; j < places.Count - 1; j++)
{
string id = places[j].Id + "|" + places[j + 1].Id;
innerPath.Add(_allPaths.AllPathsList[id]);
}
if (!innerPath.Contains(null))
{
foreach (var path in innerPath)
{
outPath.Steps.AddRange(path.Steps);
outPath.ChosenSteps.Add(new Edge(path.StarPlace, path.EndPlace, path.TotalLength, path.Cost));
}
}
return(outPath);
}
/// <summary>
/// Resolve a path into zero or more references. The
/// returned list is sorted by ordinal.
/// </summary>
/// Resolution into a reference is done in the in-memory
/// document structure, and does not call into the database.
internal List <Reference> ResolveMany(Path.Path path, Reference context)
{
return(path.Resolve(context, _resolver));
}
