public void Init(TilePropagator propagator)
{
pathTileSet = propagator.CreateTileSet(Exits.Keys);
endPointTileSet = EndPointTiles != null?propagator.CreateTileSet(EndPointTiles) : null;
graph = CreateEdgedGraph(propagator.Topology);
var tileRotation = TileRotation ?? new TileRotation();
actualExits = new Dictionary <Tile, ISet <Direction> >();
foreach (var kv in Exits)
{
foreach (var rot in tileRotation.RotationGroup)
{
if (tileRotation.Rotate(kv.Key, rot, out var rtile))
{
Direction Rotate(Direction d)
{
return(TopoArrayUtils.RotateDirection(propagator.Topology.Directions, d, rot));
}
var rexits = new HashSet <Direction>(kv.Value.Select(Rotate));
actualExits[rtile] = rexits;
}
}
}
tilesByExit = actualExits
.SelectMany(kv => kv.Value.Select(e => Tuple.Create(kv.Key, e)))
.GroupBy(x => x.Item2, x => x.Item1)
.ToDictionary(g => g.Key, propagator.CreateTileSet);
}
public static AdjacentModel.Adjacency Rotate(AdjacentModel.Adjacency adjacency, Rotation rotation, DirectionSet directions, TileRotation tileRotation)
{
return(new AdjacentModel.Adjacency
{
Src = tileRotation.Rotate(adjacency.Src, rotation).ToArray(),
Dest = tileRotation.Rotate(adjacency.Dest, rotation).ToArray(),
Direction = TopoArrayUtils.RotateDirection(directions, adjacency.Direction, rotation),
});
}
public void Init(TilePropagator propagator)
{
ISet <Tile> actualEndPointTiles;
if (TileRotation != null)
{
actualExits = new Dictionary <Tile, ISet <Direction> >();
foreach (var kv in Exits)
{
foreach (var rot in TileRotation.RotationGroup)
{
if (TileRotation.Rotate(kv.Key, rot, out var rtile))
{
Direction Rotate(Direction d)
{
return(TopoArrayUtils.RotateDirection(propagator.Topology.AsGridTopology().Directions, d, rot));
}
var rexits = new HashSet <Direction>(kv.Value.Select(Rotate));
actualExits[rtile] = rexits;
}
}
}
actualEndPointTiles = EndPointTiles == null ? null : new HashSet <Tile>(TileRotation.RotateAll(EndPointTiles));
}
else
{
actualExits = Exits;
actualEndPointTiles = EndPointTiles;
}
pathTileSet = propagator.CreateTileSet(Exits.Keys);
pathSelectedTracker = propagator.CreateSelectedTracker(pathTileSet);
endPointTileSet = EndPointTiles != null?propagator.CreateTileSet(actualEndPointTiles) : null;
endPointSelectedTracker = EndPointTiles != null?propagator.CreateSelectedTracker(endPointTileSet) : null;
graph = CreateEdgedGraph(propagator.Topology);
tilesByExit = actualExits
.SelectMany(kv => kv.Value.Select(e => Tuple.Create(kv.Key, e)))
.GroupBy(x => x.Item2, x => x.Item1)
.ToDictionary(g => g.Key, propagator.CreateTileSet);
trackerByExit = tilesByExit
.ToDictionary(kv => kv.Key, kv => propagator.CreateSelectedTracker(kv.Value));
Check(propagator, true);
}
public EdgedPathView(EdgedPathSpec spec, TilePropagator propagator)
{
if (spec.TileRotation != null)
{
exits = new Dictionary <Tile, ISet <Direction> >();
foreach (var kv in spec.Exits)
{
foreach (var rot in spec.TileRotation.RotationGroup)
{
if (spec.TileRotation.Rotate(kv.Key, rot, out var rtile))
{
Direction Rotate(Direction d)
{
return(TopoArrayUtils.RotateDirection(propagator.Topology.AsGridTopology().Directions, d, rot));
}
var rexits = new HashSet <Direction>(kv.Value.Select(Rotate));
exits[rtile] = rexits;
}
}
}
endPointTiles = spec.RelevantTiles == null ? null : new HashSet <Tile>(spec.TileRotation.RotateAll(spec.RelevantTiles));
}
else
{
exits = spec.Exits;
endPointTiles = spec.RelevantTiles;
}
pathTileSet = propagator.CreateTileSet(exits.Keys);
pathSelectedTracker = propagator.CreateSelectedTracker(pathTileSet);
Graph = CreateEdgedGraph(propagator.Topology);
this.propagator = propagator;
this.topology = propagator.Topology;
var nodesPerIndex = GetNodesPerIndex();
CouldBePath = new bool[propagator.Topology.IndexCount * nodesPerIndex];
MustBePath = new bool[propagator.Topology.IndexCount * nodesPerIndex];
tileSetByExit = exits
.SelectMany(kv => kv.Value.Select(e => Tuple.Create(kv.Key, e)))
.GroupBy(x => x.Item2, x => x.Item1)
.ToDictionary(g => g.Key, propagator.CreateTileSet);
trackerByExit = tileSetByExit
.ToDictionary(kv => kv.Key, kv => propagator.CreateSelectedTracker(kv.Value));
hasEndPoints = spec.RelevantCells != null || spec.RelevantTiles != null;
if (hasEndPoints)
{
CouldBeRelevant = new bool[propagator.Topology.IndexCount * nodesPerIndex];
MustBeRelevant = new bool[propagator.Topology.IndexCount * nodesPerIndex];
endPointIndices = spec.RelevantCells == null ? null :
spec.RelevantCells.Select(p => propagator.Topology.GetIndex(p.X, p.Y, p.Z)).ToList();
endPointTileSet = endPointTiles != null?propagator.CreateTileSet(endPointTiles) : null;
endPointSelectedTracker = endPointTiles != null?propagator.CreateSelectedTracker(endPointTileSet) : null;
}
else
{
CouldBeRelevant = CouldBePath;
MustBeRelevant = MustBePath;
endPointTileSet = pathTileSet;
}
}