public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { var strings = new List <string>(); float maxWidth = 0; foreach ((string name, IStat stat) in InstrumentationBag.Stats) { if (stat.ShouldShow()) { string line = name + ": " + stat.GetDescription(); strings.Add(line); maxWidth = Math.Max(maxWidth, canvas.MeasureText(line, Brushes.Label)); } } var lineGap = 3; var lineHeight = Brushes.Label.TextSize.GetValueOrDefault(); var panelHeight = strings.Count * (lineHeight + lineGap); canvas.Translate(10, height - panelHeight - 40); canvas.DrawRect(0, 0, maxWidth, panelHeight, Brushes.PanelBackground); foreach (string?line in strings) { canvas.DrawText(line, 0, lineHeight, Brushes.Label); canvas.Translate(0, lineGap + lineHeight); } }
public TrackLayoutRenderer(IGameBoard gameBoard, ITrackRenderer trackRenderer, IPixelMapper pixelMapper, ITrackParameters parameters) { _gameBoard = gameBoard; _trackRenderer = trackRenderer; _pixelMapper = pixelMapper; _parameters = parameters; }
public InteractionManager(IEnumerable <IInteractionHandler> handlers, IGame game, IPixelMapper pixelMapper, IGameManager gameManager) { _handler = handlers.Reverse().ToArray(); _game = game; _pixelMapper = pixelMapper; _gameManager = gameManager; }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { canvas.DrawRect(0, 0, pixelMapper.ViewPortWidth, pixelMapper.ViewPortHeight, new PaintBrush { Style = PaintStyle.Fill, Color = TerrainColourLookup.DefaultColour }); if (_terrainMap.IsEmpty()) { return; } // Draw any non-grass cells foreach (Terrain terrain in _terrainMap) { (int x, int y, bool onScreen) = pixelMapper.CoordsToViewPortPixels(terrain.Column, terrain.Row); if (!onScreen) { continue; } Color colour = TerrainColourLookup.GetTerrainColour(terrain); if (colour == TerrainColourLookup.DefaultColour) { continue; } canvas.DrawRect(x, y, pixelMapper.CellSize, pixelMapper.CellSize, new PaintBrush { Style = PaintStyle.Fill, Color = colour }); } _dirty = false; }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { if (_terrainMap.IsEmpty()) { canvas.DrawRect(0, 0, pixelMapper.ViewPortWidth, pixelMapper.ViewPortHeight, new PaintBrush { Style = PaintStyle.Fill, Color = TerrainColourLookup.DefaultColour }); return; } // Draw any non-grass cells foreach (Terrain terrain in _terrainMap) { Color colour = TerrainColourLookup.GetTerrainColour(terrain); (int x, int y) = pixelMapper.CoordsToViewPortPixels(terrain.Column, terrain.Row); canvas.DrawRect(x, y, _gameParameters.CellSize, _gameParameters.CellSize, new PaintBrush { Style = PaintStyle.Fill, Color = colour }); // Debug, this draws coord and height onto cells //canvas.DrawText($"{terrain.Column},{terrain.Row}", x + 2, y + 0.3f * _gameParameters.CellSize, new PaintBrush { Style = PaintStyle.Fill, Color = Colors.Black }); //canvas.DrawText($"{terrain.Height}", x + 2, y + 0.7f * _gameParameters.CellSize, new PaintBrush { Style = PaintStyle.Fill, Color = Colors.Black }); } _dirty = false; }
public PointerTool(ITrainController gameState, IGameBoard gameBoard, IPixelMapper pixelMapper, ILayout <Track> trackLayout) { _gameState = gameState; _gameBoard = gameBoard; _pixelMapper = pixelMapper; _trackLayout = trackLayout; }
public PointerTool(ITrainManager trainManager, IGameBoard gameBoard, IPixelMapper pixelMapper, ILayout <Track> trackLayout) { _trainManager = trainManager; _gameBoard = gameBoard; _pixelMapper = pixelMapper; _trackLayout = trackLayout; }
public void Snapshot_PostSnapshot_SnapshotShoudntChange() { int width = 200; int height = 200; int viewportX = 30; int viewportY = 30; float gameScale = 2.0f; IPixelMapper pixelMapper = new PixelMapper(); pixelMapper.SetViewPortSize(width, height); pixelMapper.AdjustGameScale(gameScale); pixelMapper.SetViewPort(viewportX, viewportY); IPixelMapper actual = pixelMapper.Snapshot(); pixelMapper.AdjustGameScale(0.5f); pixelMapper.SetViewPort(0, 0); Assert.Equal(-viewportX, actual.ViewPortX); Assert.Equal(-viewportY, actual.ViewPortY); Assert.Equal(gameScale, actual.GameScale); Assert.Equal(width, actual.ViewPortWidth); Assert.Equal(height, actual.ViewPortHeight); }
public MainPage(IGame game, IPixelMapper pixelMapper, OrderedList <ITool> tools, OrderedList <ILayerRenderer> layers, OrderedList <ICommand> commands, ITrainController trainControls, ITrackParameters trackParameters, ITrackLayout trackLayout, IGameStorage gameStorage) { this.Title("Trains - " + ThisAssembly.AssemblyInformationalVersion); var controlDelegate = new TrainsDelegate(game, pixelMapper); _miniMapDelegate = new MiniMapDelegate(trackLayout, trackParameters, pixelMapper); this.Body = () => { return(new HStack() { new VStack() { new ToggleButton("Configuration", _configurationShown, () => _configurationShown.Value = !_configurationShown.Value), new Spacer(), _configurationShown ? CreateConfigurationControls(layers) : CreateToolsControls(tools, controlDelegate), new Spacer(), _configurationShown ? null : CreateCommandControls(commands), new Spacer(), new DrawableControl(_miniMapDelegate).Frame(height: 100) }.Frame(100, alignment: Alignment.Top), new VStack() { new TrainControllerPanel(trainControls), new DrawableControl(controlDelegate) } }.FillHorizontal()); }; _timer = new GameTimer(); _timer.Interval = 16; _timer.Elapsed += (s, e) => { game.AdjustViewPortIfNecessary(); ThreadHelper.Run(async() => { await ThreadHelper.SwitchToMainThreadAsync(); controlDelegate.Invalidate(); _miniMapDelegate.Invalidate(); }); }; _timer.Start(); _trackLayout = trackLayout; _gameStorage = gameStorage; }
public Game(IGameBoard gameBoard, OrderedList <ILayerRenderer> boardRenderers, IPixelMapper pixelMapper) { _gameBoard = gameBoard; _boardRenderers = boardRenderers; _pixelMapper = pixelMapper; _renderLayerDrawTimes = _boardRenderers.ToDictionary(x => x, x => InstrumentationBag.Add <ElapsedMillisecondsTimedStat>(x.Name.Replace(" ", "") + "DrawTime")); }
public void Snapshot_NoChanges() { IPixelMapper pixelMapper = new PixelMapper(); IPixelMapper actual = pixelMapper.Snapshot(); AssertSnapshotsSame(pixelMapper, actual); }
public TrainLookaheadRenderer(IGameBoard gameBoard, IPixelMapper pixelMapper, ITrackParameters parameters, ITrainPainter painter, ITimer gameTimer) { _gameBoard = gameBoard; _pixelMapper = pixelMapper; _parameters = parameters; _painter = painter; _gameTimer = gameTimer; }
public TrackLayoutRenderer(ITrackLayout trackLayout, ITrackRenderer trackRenderer, IPixelMapper pixelMapper, ITrackParameters parameters) { _trackLayout = trackLayout; _trackRenderer = trackRenderer; _pixelMapper = pixelMapper; _parameters = parameters; _trackLayout.TracksChanged += (s, e) => _dirty = true; }
public TerrainMapRenderer(ITerrainMap terrainMap, IImageFactory imageFactory, IImageCache imageCache, IPixelMapper pixelMapper) { _terrainMap = terrainMap; _imageFactory = imageFactory; _imageCache = imageCache; _pixelMapper = pixelMapper; _terrainMap.CollectionChanged += (s, e) => _imageCache.SetDirty(this); }
public MiniMapScreen(ITerrainMapRenderer terrainMapRenderer, ILayout <Track> trackLayout, IPixelMapper pixelMapper) { _terrainMapRenderer = terrainMapRenderer; _trackLayout = trackLayout; _pixelMapper = pixelMapper; _trackLayout.CollectionChanged += (s, e) => Changed?.Invoke(this, EventArgs.Empty); _pixelMapper.ViewPortChanged += (s, e) => Changed?.Invoke(this, EventArgs.Empty); }
public MiniMapDelegate(IGameBoard gameBoard, ITrackParameters trackParameters, IPixelMapper pixelMapper) { _gameBoard = gameBoard; _trackParameters = trackParameters; _pixelMapper = pixelMapper; _pixelMapper.ViewPortChanged += (s, e) => _redraw = true; _gameBoard.TracksChanged += (s, e) => _redraw = true; }
public MiniMapDelegate(ILayout trackLayout, IPixelMapper pixelMapper, ITerrainMap terrainMap) { _trackLayout = trackLayout; _pixelMapper = pixelMapper; _terrainMap = terrainMap; _pixelMapper.ViewPortChanged += (s, e) => _redraw = true; _trackLayout.CollectionChanged += (s, e) => _redraw = true; _terrainMap.CollectionChanged += (s, e) => _redraw = true; }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { foreach (Train train in _gameBoard.GetMovables()) { var _paint = new PaintBrush { Color = _painter.GetPalette(train).FrontSectionEndColor with { A = 200 },
public Game(IGameBoard gameBoard, OrderedList <ILayerRenderer> boardRenderers, IPixelMapper pixelMapper, IBitmapFactory bitmapFactory) { _gameBoard = gameBoard; _boardRenderers = boardRenderers; _pixelMapper = pixelMapper; _bitmapFactory = bitmapFactory; _renderLayerDrawTimes = _boardRenderers.ToDictionary(x => x, x => InstrumentationBag.Add <ElapsedMillisecondsTimedStat>(x.Name.Replace(" ", "") + "DrawTime")); _pixelMapper.ViewPortChanged += (s, e) => _needsBufferReset = true; }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { if (_terrainMapRenderer.TryGetTerrainImage(out IImage? terrainImage)) { (Rectangle source, Rectangle destination) = GetSourceAndDestinationRectangles(pixelMapper); canvas.DrawImage(terrainImage, source, destination); } }
public MiniMapDelegate(ITrackLayout trackLayout, ITrackParameters trackParameters, IPixelMapper pixelMapper) { _trackLayout = trackLayout; _trackParameters = trackParameters; _pixelMapper = pixelMapper; _pixelMapper.ViewPortChanged += (s, e) => _redraw = true; _trackLayout.TracksChanged += (s, e) => _redraw = true; }
public void Snapshot_CompareTwoSnapshotsFromSameMapper() { IPixelMapper pixelMapper = new PixelMapper(); IPixelMapper expected = pixelMapper.Snapshot(); IPixelMapper actual = pixelMapper.Snapshot(); AssertSnapshotsSame(expected, actual); }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { if (pixelMapper.CellSize != _lastCellSize) { _cache.Clear(); _lastCellSize = pixelMapper.CellSize; } foreach (T entity in _layout) { (int x, int y, bool onScreen) = pixelMapper.CoordsToViewPortPixels(entity.Column, entity.Row); if (!onScreen) { continue; } canvas.Save(); canvas.Translate(x, y); if (_renderer is ICachableRenderer <T> cachableRenderer) { canvas.ClipRect(new Rectangle(0, 0, pixelMapper.CellSize, pixelMapper.CellSize), false); string key = cachableRenderer.GetCacheKey(entity); if (!_cache.TryGetValue(key, out IImage cachedImage)) { using IImageCanvas imageCanvas = _imageFactory.CreateImageCanvas(pixelMapper.CellSize, pixelMapper.CellSize); float scale = pixelMapper.CellSize / 100.0f; imageCanvas.Canvas.Scale(scale, scale); _renderer.Render(imageCanvas.Canvas, entity); cachedImage = imageCanvas.Render(); _cache[key] = cachedImage; } canvas.DrawImage(cachedImage, 0, 0); } else { float scale = pixelMapper.CellSize / 100.0f; canvas.Scale(scale, scale); _renderer.Render(canvas, entity); } canvas.Restore(); } }
public AdjustGameScaleTests(ITestOutputHelper output) { _pixelMapper = new PixelMapper(); _pixelMapper.SetViewPortSize(ScreenSize, ScreenSize); int centerViewportOffsetX = _pixelMapper.MaxGridWidth / 2 - ScreenSize / 2; int centerViewportOffsetY = _pixelMapper.MaxGridHeight / 2 - ScreenSize / 2; _pixelMapper.SetViewPort(centerViewportOffsetX, centerViewportOffsetY); _output = output; }
private static void AssertSnapshotsSame(IPixelMapper expected, IPixelMapper actual) { Assert.Equal(expected.CellSize, actual.CellSize); Assert.Equal(expected.GameScale, actual.GameScale); Assert.Equal(expected.MaxGridWidth, actual.MaxGridWidth); Assert.Equal(expected.MaxGridHeight, actual.MaxGridHeight); Assert.Equal(expected.ViewPortHeight, actual.ViewPortHeight); Assert.Equal(expected.ViewPortWidth, actual.ViewPortWidth); Assert.Equal(expected.ViewPortX, actual.ViewPortX); Assert.Equal(expected.ViewPortY, actual.ViewPortY); }
public TerrainRenderer(ITerrainMap terrainMap, IPixelMapper pixelMapper, ITrackParameters trackParameters) { _terrainMap = terrainMap; _pixelMapper = pixelMapper; _trackParameters = trackParameters; _paintBrush = new PaintBrush { Color = Colors.LightGray, StrokeWidth = 1, Style = PaintStyle.Stroke }; }
public CoordPixelConverstionTests(ITestOutputHelper output) { _output = output; _pixelMapper = new PixelMapper(); _pixelMapper.SetViewPortSize(ScreenSize, ScreenSize); _pixelMapper.LogData(output); if (DefaultCellSize != _pixelMapper.CellSize) { throw new Exception("Cell size is different than this test expects, these tests assume the DefaultCellSize is " + DefaultCellSize); } }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { var tunnelRoofColour = BuildModeAwareColour(Colors.LightGray); var firstMountain = new Terrain() { Height = Terrain.FirstMountainHeight }; var tunnelBaseColour = BuildModeAwareColour(TerrainMapRenderer.GetTerrainColour(firstMountain)); var entranceColourArray = new[] { tunnelBaseColour, tunnelRoofColour, tunnelBaseColour }; Dictionary <(int column, int row), Tunnel> entrances = new(); foreach (Track track in _trackLayout) { var terrain = _terrainMap.Get(track.Column, track.Row); if (!terrain.IsMountain) { continue; } (int x, int y, _) = pixelMapper.CoordsToViewPortPixels(track.Column, track.Row); // Paint over the tracks with the colour of the terrain. Would be awesome to remove this in future somehow var terrainColour = BuildModeAwareColour(TerrainMapRenderer.GetTerrainColour(terrain)); canvas.DrawRect(x, y, pixelMapper.CellSize, pixelMapper.CellSize, new PaintBrush { Style = PaintStyle.Fill, Color = terrainColour, }); TrackNeighbors trackNeighbours = track.GetConnectedNeighbors(); BuildEntrances(trackNeighbours.Up, Tunnel.Bottom, entrances); BuildEntrances(trackNeighbours.Right, Tunnel.Left, entrances); BuildEntrances(trackNeighbours.Down, Tunnel.Top, entrances); BuildEntrances(trackNeighbours.Left, Tunnel.Right, entrances); var currentCellTunnels = (IsEntrance(trackNeighbours.Up) ? Tunnel.Top : Tunnel.NoTunnels) | (IsEntrance(trackNeighbours.Right) ? Tunnel.Right : Tunnel.NoTunnels) | (IsEntrance(trackNeighbours.Down) ? Tunnel.Bottom : Tunnel.NoTunnels) | (IsEntrance(trackNeighbours.Left) ? Tunnel.Left : Tunnel.NoTunnels); DrawTunnel(canvas, pixelMapper, tunnelRoofColour, tunnelBaseColour, x, y, currentCellTunnels); } foreach (var(col, row, tunnels) in entrances) { DrawEntrance(canvas, pixelMapper, entranceColourArray, col, row, tunnels); } }
public void Render(ICanvas canvas, int width, int height, IPixelMapper pixelMapper) { foreach (Track track in _trackLayout) { if (!track.Happy) { continue; } (int x, int y) = pixelMapper.CoordsToViewPortPixels(track.Column, track.Row); canvas.DrawRect(x, y, _gameParameters.CellSize, _gameParameters.CellSize, _paint); } }
public Task <IPixelMapper> GetMapper(BitmapPixelFormat format) { IPixelMapper returnValue = null; if (format == BitmapPixelFormat.Bgra8) { returnValue = new Bgra8Pixelmapper(); } else { throw new NotSupportedException($"The pixel format {format} is not supported."); } return(Task.FromResult(returnValue)); }