public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> onMatchFound)
{
var q = queryFn(x, y) >> lowerLimit;
if (q == 0)
{
return(false);
}
var result = false;
for (var i = lowerLimit; i <= limit; i += 1)
{
if ((q & 1) == 1)
{
var context = contextFn(x, y, i);
if (tileExists[i])
{
onMatchFound(SpritePosition.Whole, tiles[i], context);
result = true;
}
}
q >>= 1;
}
return(result);
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
if (!Matcher(x, y))
{
return(false);
}
var context = ContextProvider(x, y);
neighbourPositions = GridNavigator.NavigateNeighbours(new MapCoordinate(x, y), neighbourPositions);
bool matchedOne = false;
for (var i = 1; i < positions.Length; i++)
{
var mc = neighbourPositions[i - 1];
if (Matcher(mc.X, mc.Y) && tileExists[i])
{
resultCollector(SpritePosition.Whole, tiles[i], context);
matchedOne = true;
}
}
if (!matchedOne)
{
// isolated tile ..
if (tileExists[0])
{
resultCollector(SpritePosition.Whole, tiles[0], context);
}
}
return(true);
}
public PlotOperation(ITileMatcher <TRenderTile, TContext> matcher,
RenderType renderType,
IRenderCallback <TRenderTile, TContext> renderer = null)
{
this.matcher = matcher;
adapter = new RendererAdapter <TRenderTile, TContext>(renderType, renderer);
onMatchFound = adapter.MatchFound;
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
coordinates = GridNavigator.NavigateCardinalNeighbours(new MapCoordinate(x, y), coordinates);
var n = Matches(coordinates[(int)Direction.Up]);
var e = Matches(coordinates[(int)Direction.Right]);
var s = Matches(coordinates[(int)Direction.Down]);
var w = Matches(coordinates[(int)Direction.Left]);
bool result = false;
if (n)
{
if (e)
{
if (tileExists[1])
{
resultCollector(SpritePosition.Whole, tiles[1], ContextProvider(x, y));
}
result = true;
}
if (w)
{
if (tileExists[0])
{
resultCollector(SpritePosition.Whole, tiles[0], ContextProvider(x, y));
}
result = true;
}
}
if (s)
{
if (e)
{
if (tileExists[2])
{
resultCollector(SpritePosition.Whole, tiles[2], ContextProvider(x, y));
}
result = true;
}
if (w)
{
if (tileExists[3])
{
resultCollector(SpritePosition.Whole, tiles[3], ContextProvider(x, y));
}
result = true;
}
}
return(result);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> onMatchFound)
{
if (filterCondition(x, y))
{
return(matcher.Match(x, y, onMatchFound));
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContextTarget> onMatchFound)
{
void Collect(SpritePosition pos, TRenderTile result, TContextSource context)
{
onMatchFound(pos, result, Convert(x, y, result, context));
}
return(parent.Match(x, y, Collect));
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
if (tileExists && Matcher(x, y))
{
resultCollector(SpritePosition.Whole, tile, ContextProvider(x, y));
return(true);
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
var result = false;
for (var i = 0; i < matchers.Count; i++)
{
var m = matchers[i];
result |= m.Match(x, y, resultCollector);
}
return(result);
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
// The current tile is not a land tile. If it is an ocean tile, we can test
// whether one of the cardinal neighbours is a river that flows into the
// ocean.
if (!selfMatcher(x, y))
{
return(false);
}
coordinates = GridNavigator.NavigateCardinalNeighbours(new MapCoordinate(x, y), coordinates);
if (Matches(coordinates[CardinalIndex.North.AsInt()]))
{
if (northTileExists)
{
resultCollector(SpritePosition.Whole, northTile, ContextProvider(x, y));
}
return(true);
}
if (Matches(coordinates[CardinalIndex.East.AsInt()]))
{
if (eastTileExists)
{
resultCollector(SpritePosition.Whole, eastTile, ContextProvider(x, y));
}
return(true);
}
if (Matches(coordinates[CardinalIndex.South.AsInt()]))
{
if (southTileExists)
{
resultCollector(SpritePosition.Whole, southTile, ContextProvider(x, y));
}
return(true);
}
if (Matches(coordinates[CardinalIndex.West.AsInt()]))
{
if (westTileExists)
{
resultCollector(SpritePosition.Whole, westTile, ContextProvider(x, y));
}
return(true);
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> onMatchFound)
{
var sourceTile = readMap(x, y);
if (mapper(sourceTile, out TRenderTile mapResult, out TContext context))
{
onMatchFound(SpritePosition.Whole, mapResult, context);
return(true);
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
// we need to run both matchers regardless of the result. Both selected tiles will be overlaid on to each other.
var cardinalMatch = cardinalTileSelector.Match(x, y, resultCollector);
var diagonalMatch = diagonalTileSelector.Match(x, y, resultCollector);
if (cardinalMatch || diagonalMatch)
{
return(true);
}
return(isolatedTileMatcher.Match(x, y, resultCollector));
}
public bool Match(int x, int y, TileResultCollector <TTile, TContext> onMatchFound)
{
var key = keyFn(x, y);
if (matchers.TryGetValue(key, out ITileMatcher <TTile, TContext> m))
{
if (m.Match(x, y, onMatchFound))
{
return(true);
}
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TTile, IItem> onMatchFound)
{
bool matched = false;
foreach (var item in gd.QueryItems(x, y))
{
var name = item.ItemType.Name;
if (tiles.TryFind(name, out TTile tile))
{
matched = true;
onMatchFound(SpritePosition.Whole, tile, item);
}
}
return(matched);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
if (matcher(x, y, out TFactor factor))
{
var b = choiceKeys.BinarySearch(factor, comparer);
if (b < 0)
{
b = ~b - 1;
if (b < 0)
{
return(false);
}
}
var tile = choiceValues[b];
resultCollector(SpritePosition.Whole, tile, contextProvider(x, y));
return(true);
}
return(false);
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
if (!selfMatcher(x, y))
{
return(false);
}
neighbours = GridNavigator.NavigateNeighbours(new MapCoordinate(x, y), neighbours);
var idx = MatchAsFlag(neighbours[NeighbourIndex.NorthEast.AsInt()]) << 0;
idx += MatchAsFlag(neighbours[NeighbourIndex.SouthEast.AsInt()]) << 1;
idx += MatchAsFlag(neighbours[NeighbourIndex.SouthWest.AsInt()]) << 2;
idx += MatchAsFlag(neighbours[NeighbourIndex.NorthWest.AsInt()]) << 4;
if (tagExists[idx])
{
resultCollector(SpritePosition.Whole, tags[idx], ContextProvider(x, y));
}
return(true);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> onMatchFound)
{
var en = keyFn(x, y);
if (en == null)
{
return(false);
}
bool found = false;
foreach (var data in en)
{
if (mapper(data, out TRenderTile result, out TContext context))
{
onMatchFound(SpritePosition.Whole, result, context);
found = true;
}
}
return(found);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
NavigateForDownwardRenderDirection(x, y, out MapCoordinate coordA,
out MapCoordinate coordB,
out MapCoordinate coordC,
out MapCoordinate coordD);
if (matchers.Match(coordA.X, coordA.Y, out ITileTagEntrySelection matchA) &&
matchers.Match(coordB.X, coordB.Y, out ITileTagEntrySelection matchB) &&
matchers.Match(coordC.X, coordC.Y, out ITileTagEntrySelection matchC) &&
matchers.Match(coordD.X, coordD.Y, out ITileTagEntrySelection matchD))
{
var linearIndex = CellMapTileSelectorKey.LinearIndexOf(matchA, matchB, matchC, matchD);
if (tileExists[linearIndex])
{
var tile = tiles[linearIndex];
resultCollector(SpritePosition.CellMap, tile, contextProvider(x, y));
return(true);
}
}
return(false);
}
public override bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
if (!selfMatcher(x, y))
{
return(false);
}
Coordinates = GridNavigator.NavigateCardinalNeighbours(new MapCoordinate(x, y), Coordinates);
int idx = 0;
idx += MatchAsFlag(Coordinates[CardinalIndex.North.AsInt()]);
idx += MatchAsFlag(Coordinates[CardinalIndex.East.AsInt()]) << 1;
idx += MatchAsFlag(Coordinates[CardinalIndex.South.AsInt()]) << 2;
idx += MatchAsFlag(Coordinates[CardinalIndex.West.AsInt()]) << 3;
if (tagExists[idx])
{
resultCollector(SpritePosition.Whole, tags[idx], ContextProvider(x, y));
return(true);
}
return(false);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector)
{
mapCoords = gridNavigator.NavigateCardinalNeighbours(new MapCoordinate(x, y), mapCoords);
var blendSelf = isBlending(x, y);
var retval = false;
for (var i = 0; i < mapCoords.Length; i++)
{
var c = mapCoords[i];
if (!blendSelf && !isBlending(c.X, c.Y))
{
continue;
}
var mq = mapQuery(c.X, c.Y);
if (mq != null && registry.TryFind(mq, directions[i], out var tile))
{
resultCollector(SpritePosition.Whole, tile, contextProvider(x, y));
retval = true;
}
}
return(retval);
}
public bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> tile)
{
if (!selfMatcher(x, y))
{
return(false);
}
neighbours = GridNavigator.NavigateNeighbours(new MapCoordinate(x, y), neighbours);
for (var index = 0; index < selectors.Length; index++)
{
var d = selectors[index];
var idx = 0;
idx += MatchAsFlag(neighbours[d.SelectorCoordinates[0]]) << 0;
idx += MatchAsFlag(neighbours[d.SelectorCoordinates[1]]) << 1;
idx += MatchAsFlag(neighbours[d.SelectorCoordinates[2]]) << 2;
if (d.TryGet(idx, out var tileName))
{
tile(d.Position.MapToPosition(), tileName, contextProvider(x, y));
}
}
return(true);
}
public bool Match(int x, int y, TileResultCollector <TMatchedTile, TMatchedContext> onMatchFound)
{
return(false);
}
public abstract bool Match(int x, int y, TileResultCollector <TRenderTile, TContext> resultCollector);
