private void Initialize()
{
var dim = 2 * MapRadius + 1;
InitCells(dim, dim);
Width = dim * UNITS_PER_TILE;
Height = dim * UNITS_PER_TILE;
_spriteDictionary = new LRUSpriteDictionary((dim + 1) * (dim + 1));
_renderGrid = new RenderGrid(_cells.ToArray(), dim, dim);
_loadedPosition = new ProjectedPosition(MapRadius, MapRadius, ZoomLevel, 0, 0);
_position = new Vector3();
}
public override void Render(RenderGrid grid, Stream stream)
{
int width = Settings.CellSize / 2 * (grid.RowCount + grid.ColumnCount) + Settings.Margin * 2;
int height = Settings.CellSize / 4 * (grid.RowCount + grid.ColumnCount) + Settings.Margin * 2;
using (var image = new Image <Rgba32>(width, height))
{
image.Mutate();
image.Mutate(context =>
{
var fullArea = new Rectangle(0, 0, width, height);
foreach (AreaRenderer backgroundRenderer in BackgroundRenderers)
{
backgroundRenderer.Render(context, fullArea);
}
for (int columnIndex = grid.ColumnCount - 1; columnIndex >= 0; --columnIndex)
{
for (int rowIndex = 0; rowIndex < grid.RowCount; ++rowIndex)
{
RenderCell cell = grid[rowIndex, columnIndex];
var cellArea = new Rectangle(
TranslateCoordWithMargin((cell.Column + cell.Row) * Settings.CellSize / 2),
TranslateCoordWithMargin((grid.ColumnCount - cell.Column - 1 + cell.Row) * Settings.CellSize / 4),
Settings.CellSize,
Settings.CellSize / 2);
if (cell.RenderType == RenderType.Ground)
{
foreach (CellRenderer groundRenderer in GroundRenderers)
{
groundRenderer.Render(context, cellArea, cell);
}
}
if (cell.RenderType == RenderType.Wall)
{
foreach (CellRenderer wallRenderer in WallRenderers)
{
wallRenderer.Render(context, cellArea, cell);
}
}
}
}
});
image.Save(stream, ImageFormats.Png);
}
}
public void should_render_cell_with_tags()
{
var grid = new Grid(1, 1);
const string tagValue = "value";
grid[0, 0].Tags["key"] = tagValue;
var renderGrid = new RenderGrid(grid);
// | n-w | n | n-e |
// | w | c | e |
// | s-w | s | s-e |
Assert.Equal(tagValue, renderGrid[1, 1].GetTag("key"));
}
public void Write3D(Stream stream)
{
RenderGrid renderGrid = ComplexMazeFixture.Create();
var factory = new TestComponentFactory();
var renderer = new Fake3DGameLevelRenderer(
factory.CreateBackgroundRenderers(),
factory.CreateGroundRenderers(),
factory.CreateWallRenderers(),
factory.CreateSettings());
using (renderer)
{
renderer.Render(renderGrid, stream);
}
}
public void should_render_multiple_columns()
{
var grid = new Grid(1, 2);
grid[0, 0].Link(grid[0, 1]);
var renderGrid = new RenderGrid(grid);
var expectedRenderGrid = new[, ]
{
{ "W,SE", "W,EW", "W,EW", "W,EW", "W,SW" },
{ "W,NS", "G,E", "G,EW", "G,W", "W,NS" },
{ "W,NE", "W,EW", "W,EW", "W,EW", "W,NW" }
};
Assert.Equal(expectedRenderGrid, RenderToArray(renderGrid));
}
private void HandlePointerPressed(object sender, PointerRoutedEventArgs e)
{
// Don't interact if any of the animations are still running
if (_sw1.IsRunning || _sw1.IsRunning)
{
return;
}
RenderGrid.CapturePointer(e.Pointer);
_swipeStartPoint = e.GetCurrentPoint(RenderGrid).Position;
// Position the bubble at the same height as the touch
_verticalReveal = (float)(_swipeStartPoint.Y / _rootSize.Height) * VerticalRevealFactor;
_sw0.Restart();
_swipeDir = SwipeDirection.None;
_isPointerDown = true;
}
static string[,] RenderToArray(RenderGrid renderGrid)
{
var result = new string[renderGrid.RowCount, renderGrid.ColumnCount];
for (int rowIndex = 0; rowIndex < renderGrid.RowCount; ++rowIndex)
{
for (int columnIndex = 0; columnIndex < renderGrid.ColumnCount; ++columnIndex)
{
RenderCell cell = renderGrid[rowIndex, columnIndex];
char renderType = cell.RenderType.ToString().First();
string direction = CreateDirectionString(cell.Direction);
result[rowIndex, columnIndex] = $"{renderType},{direction}";
}
}
return(result);
}
public override void Render(RenderGrid grid, Stream stream)
{
int width = CalculateDimension(grid.ColumnCount);
int height = CalculateDimension(grid.RowCount);
using (var image = new Image <Rgba32>(width, height))
{
image.Mutate();
image.Mutate(context =>
{
var fullArea = new Rectangle(0, 0, width, height);
foreach (AreaRenderer backgroundRenderer in BackgroundRenderers)
{
backgroundRenderer.Render(context, fullArea);
}
foreach (RenderCell cell in grid.GetCells())
{
var cellArea = new Rectangle(
TranslateCoordWithMargin(cell.Column * Settings.CellSize),
TranslateCoordWithMargin(cell.Row * Settings.CellSize),
Settings.CellSize,
Settings.CellSize);
if (cell.RenderType == RenderType.Ground)
{
foreach (CellRenderer groundRenderer in GroundRenderers)
{
groundRenderer.Render(context, cellArea, cell);
}
}
if (cell.RenderType == RenderType.Wall)
{
foreach (CellRenderer wallRenderer in WallRenderers)
{
wallRenderer.Render(context, cellArea, cell);
}
}
}
});
image.Save(stream, ImageFormats.Png);
}
}
public void should_render_single_cell()
{
var grid = new Grid(1, 1);
var renderGrid = new RenderGrid(grid);
// | n-w | n | n-e |
// | w | c | e |
// | s-w | s | s-e |
Assert.Equal(3, renderGrid.RowCount);
Assert.Equal(3, renderGrid.ColumnCount);
var expectedRenderGrid = new[, ]
{
{ "W,SE", "W,EW", "W,SW" },
{ "W,NS", "G,U", "W,NS" },
{ "W,NE", "W,EW", "W,NW" }
};
Assert.Equal(expectedRenderGrid, RenderToArray(renderGrid));
}
public abstract void Render(RenderGrid grid, Stream stream);
private void HandlePointerReleased(object sender, PointerRoutedEventArgs e)
{
if (!_isPointerDown)
{
return;
}
RenderGrid.ReleasePointerCapture(e.Pointer);
_isPointerDown = false;
_isSwiping = false;
_sw0.Stop();
// If it is not a valid swipe no need to go further
if (_swipeDir == SwipeDirection.None)
{
return;
}
var currPoint = e.GetCurrentPoint(RenderGrid).Position;
if (currPoint.X.IsCloseTo(_swipeStartPoint.X))
{
return;
}
var currSwipeDir = currPoint.X > _swipeStartPoint.X ? SwipeDirection.Right : SwipeDirection.Left;
if (_swipeDir != currSwipeDir)
{
_revealPercent = _swipeDir == SwipeDirection.Left ? SwipeRightEnd : SwipeLeftEnd;
_currOffsetX = _swipeDir == SwipeDirection.Left ? MaxOffsetX : MinOffsetX;
}
else
{
// Since the user has completed interaction for the current swipe, check if it is a valid swipe.
// If yes, then animate the shape to its final destination otherwise animate to return to its
// initial location.
var diffX = Math.Abs(currPoint.X - _swipeStartPoint.X);
var swipePercent = Math.Min((float)(diffX * 2 / _rootSize.Width), 1f);
var isValidSwipe = (swipePercent > SwipeThreshold) ||
((_sw0.ElapsedMilliseconds < SwipeThresholdDuration.TotalMilliseconds) &&
((float)diffX > SwipeDistanceThreshold));
slideDirection = SlideDirection.RightToLeft;
var durationPercent = isValidSwipe ? (1 - swipePercent) : swipePercent;
_a0 = TimeSpan.FromMilliseconds(Math.Max(1, DefaultGeometryAnimDuration * durationPercent));
_a1 = TimeSpan.FromMilliseconds(Math.Max(1, DefaultOffsetAnimDuration * swipePercent));
switch (_swipeDir)
{
case SwipeDirection.Left:
_swipeStartX = swipePercent;
_startOffsetX = Lerp(MaxOffsetX, MinOffsetX, EaseOut(swipePercent));
if (isValidSwipe)
{
_swipeEndX = SwipeLeftEnd;
// Update to the next valid index
_nextLeftIndex = _selectedIndex <= 2 ? -1 : _selectedIndex - 1;
_nextRightIndex = _selectedIndex;
_endOffsetX = MinOffsetX;
}
else
{
_swipeEndX = SwipeRightEnd;
_endOffsetX = MaxOffsetX;
_nextLeftIndex = _swipeLeftIndex;
_nextRightIndex = _swipeRightIndex;
}
break;
case SwipeDirection.Right:
_swipeStartX = 1 - swipePercent;
_startOffsetX = Lerp(MinOffsetX, MaxOffsetX, EaseOut(swipePercent));
if (isValidSwipe)
{
_swipeEndX = SwipeRightEnd;
// Update to the next valid index
_nextLeftIndex = _selectedIndex;
_nextRightIndex = _selectedIndex >= MaxLayerCount ? -1 : _selectedIndex + 1;
_endOffsetX = MaxOffsetX;
}
else
{
_swipeEndX = SwipeLeftEnd;
_endOffsetX = MinOffsetX;
_nextLeftIndex = _swipeLeftIndex;
_nextRightIndex = _swipeRightIndex;
}
break;
}
_sw1.Start();
_sw2.Start();
}
}
