public async ValueTask DrawAll(CanvasWrapper canvas)
{
foreach (IGhost eachGhost in Ghosts)
{
await eachGhost.Draw(canvas);
}
}
/// <summary>
/// Renders an Area chart a canvas. This method is called by the chart class.
/// </summary>
/// <param name="canvasWrapper">wrapper class containing info mation about the canvas and chart</param>
/// <param name="axis">Axis orientation object</param>
/// <param name="minMax">Data for the extreme values</param>
/// <param name="gridPaint">Paint object for the grid lines</param>
public override void RenderChart(CanvasWrapper canvasWrapper, Axis axis, IMinMax minMax)
{
CheckConstructionPolicy(nameof(LineChart));
if (canvasWrapper.NumberPlottedChart < 1)
{
DrawHorizontalLabels(canvasWrapper, axis, minMax);
DrawVerticalLabels(canvasWrapper, axis, minMax);
}
var canvas = canvasWrapper.Canvas;
var path = new SKPath();
var constructionPoints = ConstructionData.ToList();
var firstPoint = ConstructionData.First();
var lastPoint = ConstructionData.Last();
var connectionPoint = new SKPoint(lastPoint.X, firstPoint.Y);
constructionPoints.Add(connectionPoint);
path.MoveTo(constructionPoints.First());
foreach (var point in constructionPoints.Skip(1))
{
path.LineTo(point);
}
path.FillType = SKPathFillType.EvenOdd;
path.Close();
_chartPaint.IsStroke = false;
canvas.DrawPath(path, _chartPaint);
canvasWrapper.NumberPlottedChart += 1;
if (canvasWrapper.CanShowLegend)
{
RenderLegend(canvasWrapper, axis, canvas, PointPlotVariant.AreaChart);
}
}
private void RenderYTickMark(CanvasWrapper canvasWrapper, Axis axis, int counter, SKPoint point, SKRect rect)
{
var yLabel = GetYLabel(OriginalData.ElementAt(counter).Y);
_labelPaint.TextSize = canvasWrapper.LabelTextSize;
axis.DrawAndPositionYTickMark(yLabel, point.Y, rect.Left, _labelPaint);
}
protected void RenderLegend(CanvasWrapper canvasWrapper, Axis axis, SKCanvas canvas,
PointPlotVariant plotVariant)
{
var start = (canvasWrapper.ChartArea.Bottom + 60);
var end = start + (40f * canvasWrapper.NumberPlottedChart);
var leftEdge = canvasWrapper.ChartArea.Left + 10;
float heightPaddingForText = 0;
canvas.Save();
axis.AntiOrientAxis(float.MaxValue);
switch (plotVariant)
{
case PointPlotVariant.LineChart:
_chartPaint.IsStroke = false;
heightPaddingForText = 7;
canvas.DrawLine(leftEdge, end, canvasWrapper.ChartArea.Left + 40, end, _chartPaint);
break;
case PointPlotVariant.ScatterChart:
_chartPaint.IsStroke = false;
heightPaddingForText = 7;
canvas.DrawCircle(leftEdge + 20, end, 7, _chartPaint);
break;
case PointPlotVariant.AreaChart:
heightPaddingForText = 15;
canvas.DrawRect(leftEdge, end, 37, 25, _chartPaint);
break;
default:
break;
}
canvas.Restore();
axis.DrawAndPositionLegend(ChartName, end + heightPaddingForText, leftEdge + 40, _chartPaint);
}
// drawSprite max 7 fruit from max level 21
async ValueTask drawFruit(CanvasWrapper ds)
{
if (_gameStats.IsDemo)
{
return;
}
var highestLevel = Math.Min(
20,
_gameStats.CurrentPlayerStats.LevelStats.LevelNumber);
var lowestLevel = Math.Max(
0,
highestLevel - 6);
var x = 204;
// starting from the right
for (var i = lowestLevel; i <= highestLevel; i++, x -= 16)
{
var item = LevelStats.GetLevelProps(i).Fruit;
_fruit.SetFruitItem(item);
_fruit.Position = new Vector2(x, 10);
await ds.DrawSprite(_fruit, Spritesheet.Reference);
}
}
public async ValueTask Draw(CanvasWrapper session)
{
foreach (var s in _sprites)
{
await s.Draw(session);
}
}
/// <summary>
/// Renders a bar chart on the canvas. This method is called by the Chart class.
/// </summary>
/// <param name="canvasWrapper">wrapper class containing info mation about the canvas and chart</param>
/// <param name="axis">Axis orientation object</param>
/// <param name="minMax">Data for the extreme values</param>
/// <param name="gridPaint">Paint object for the grid lines</param>
public override void RenderChart(CanvasWrapper canvasWrapper, Axis axis, IMinMax minMax)
{
CheckConstructionPolicy(nameof(BarChart));
var drawingSpace = canvasWrapper.ChartArea.Right / ConstructionData.Count() * 0.9;
var rectSpace = (float)drawingSpace / canvasWrapper.NumberOfCharts;
var columnSpace = (float)((canvasWrapper.ChartArea.Right / ConstructionData.Count()) - drawingSpace) / 2;
var pointX = canvasWrapper.ChartArea.Width / ConstructionData.Count();
var counter = 0;
foreach (var point in ConstructionData)
{
var x1 = (pointX * counter) + canvasWrapper.ChartArea.Left + columnSpace +
(canvasWrapper.NumberPlottedChart * rectSpace);
var x2 = x1 + rectSpace - columnSpace;
var rect = new SKRect(x1, point.Y, x2, canvasWrapper.ChartArea.Top);
_chartPaint.IsStroke = IsStroked;
canvasWrapper.Canvas.DrawRect(rect, _chartPaint);
var xLabel = XLabel[counter];
axis.DrawAndPositionXTickMark(xLabel, (x1 + (x2 - x1) / 2),
canvasWrapper.ChartArea.Bottom, _labelPaint);
var yLabel = GetYLabel(OriginalData.ElementAt(counter).Y);
axis.DrawAndPositionYTickMark(yLabel, point.Y, (x1 + (x2 - x1) / 2), _labelPaint);
counter++;
}
canvasWrapper.NumberPlottedChart += 1;
}
public void TestMaui()
{
using (var skBmp = new SkiaSharp.SKBitmap(256, 256, false))
{
using (var skCanvas = new SkiaSharp.SKCanvas(skBmp))
{
using (var mauiCanvas = new Microsoft.Maui.Graphics.Skia.SkiaCanvas())
{
mauiCanvas.Canvas = skCanvas;
var myCanvas = CanvasWrapper.Create(mauiCanvas);
myCanvas.DrawCircle((50, 50), 20, System.Drawing.Color.Red);
myCanvas.DrawRectangle((100, 10), (50, 50), System.Drawing.Color.White, 5, 3);
}
}
using (var memBmp = skBmp.UsingMemoryBitmap())
{
memBmp.AsMemoryBitmap()
.ToMemoryBitmap(Pixel.RGBA32.Format)
.Save("maui.png");
}
}
}
public async ValueTask Draw(CanvasWrapper ds)
{
await ds.SetGlobalAlphaAsync(.5f);
await ds.FillRect(0, 0, 200, 100, Color.DarkSlateGray);
await ds.DrawText($"FPS:{DiagInfo.Fps}", Point.Empty, Color.White);
await ds.DrawText($"Tot time:{DiagInfo.TotalTime:c}", new(50, 00), Color.White);
await ds.DrawText($"Draw count:{DiagInfo.DrawCount:D}", new(0, 15), Color.White);
await ds.DrawText(
$"Update count:{DiagInfo.UpdateCount:D} ({DiagInfo.UpdateCount - DiagInfo.DrawCount:D} more)",
new(0, 30),
Color.White);
await ds.DrawText($"Elapsed:{DiagInfo.Elapsed:g}", new(0, 45), Color.White);
await ds.DrawText($"loop tm taken:{DiagInfo.GameLoopDurationMs:D}", new(0, 60), Color.White);
await ds.DrawText($"max loop tm taken:{DiagInfo.MaxGameLoopDurationMs:D}", new(0, 65), Color.White);
await ds.DrawText($"slow frames:{DiagInfo.SlowElapsedCount:D}", new(0, 80), Color.White);
await ds.SetGlobalAlphaAsync(1f);
}
/// <summary>
/// Renders a line chart a canvas. This method is called by the chart class.
/// </summary>
/// <param name="canvasWrapper">wrapper class containing info mation about the canvas and chart</param>
/// <param name="axis">Axis orientation object</param>
/// <param name="minMax">Data for the extreme values</param>
/// <param name="gridPaint">Paint object for the grid lines</param>
public override void RenderChart(CanvasWrapper canvasWrapper, Axis axis, IMinMax minMax)
{
CheckConstructionPolicy(nameof(LineChart));
var canvas = canvasWrapper.Canvas;
if (canvasWrapper.NumberPlottedChart < 1)
{
DrawHorizontalLabels(canvasWrapper, axis, minMax);
DrawVerticalLabels(canvasWrapper, axis, minMax);
}
_chartPaint.IsStroke = true;
var path = new SKPath();
path.MoveTo(ConstructionData.First());
foreach (var point in ConstructionData.Skip(1))
{
path.LineTo(point);
if (ShowPoints)
{
canvas.DrawCircle(point, PointRadius, _chartPaint);
}
}
canvas.DrawPath(path, _chartPaint);
canvasWrapper.NumberPlottedChart += 1;
if (canvasWrapper.CanShowLegend)
{
RenderLegend(canvasWrapper, axis, canvas, PointPlotVariant.LineChart);
}
}
public async ValueTask Draw(CanvasWrapper canvas)
{
await _blinky.Draw(canvas);
await _pacMan.Draw(canvas);
await _worm.Draw(canvas);
}
public override void applyToCanvas(CanvasWrapper c)
{
base.applyToCanvas(c);
//c.DrawLineUsingActualCoords(P1.X, P1.Y, P2.X, P2.Y);
c.PushActiveLayer();
c.SwitchLayer(CanvasWrapper.LAYER_ALGORITHM);
c.DrawLineUsingIndexes(StartXIndex, StartYIndex, EndXIndex, EndYIndex);
c.PopActiveLayer();
}
public async ValueTask Draw(CanvasWrapper canvas)
{
await _pacMan.Draw(canvas);
await _blinky.Draw(canvas);
await _lookingBlinky.Draw(canvas);
await _snagSprite.Draw(canvas);
}
public async ValueTask Draw(CanvasWrapper canvas)
{
await _maze.Draw(canvas);
await _pacman.Draw(canvas);
await _ghostCollection.DrawAll(canvas);
await canvas.DrawMyText("GAME OVER", TextPoints.GameOverPoint, Colors.Red);
}
public override void RenderChart(CanvasWrapper canvasWrapper, Axis axis, IMinMax minMax)
{
var divisor = 2.5f;
var strokeWidth = 30;
if (canvasWrapper.NumberOfCharts > 6)
{
switch (Device.RuntimePlatform)
{
case Device.WPF:
case Device.GTK:
case Device.macOS:
case Device.UWP: {
divisor = 2.0f;
strokeWidth = 15;
break;
}
default: {
divisor = 1.5f;
strokeWidth = 30;
break;
}
}
;
}
var chartArea = canvasWrapper.ChartArea;
var canvas = canvasWrapper.Canvas;
var radius = Math.Min(chartArea.MidX, chartArea.MidY) / divisor;
radius = radius - (canvasWrapper.NumberPlottedChart * strokeWidth);
_chartPaint.StrokeWidth = strokeWidth;
_chartPaint.Style = SKPaintStyle.Stroke;
var teta = 360 - ((minMax.Ymax - OriginalData.ElementAt(0).Y) / (minMax.Ymax - minMax.Ymin) * 360);
var rect = new SKRect(chartArea.MidX - radius, chartArea.MidY - radius, chartArea.MidX + radius, chartArea.MidY + radius);
var path = new SKPath();
path.AddArc(rect, 90, -teta);
canvas.DrawPath(path, _chartPaint);
_chartPaint.Color = ChartColor.WithAlpha(70);
canvas.DrawCircle(chartArea.MidX, chartArea.MidY, radius, _chartPaint);
canvasWrapper.NumberPlottedChart += 1;
_chartPaint.Color = ChartColor;
ChartName = $"{Label} : {Value}";
RenderLegend(canvasWrapper, axis, canvas, PointPlotVariant.ScatterChart);
}
public async ValueTask Draw(CanvasWrapper session)
{
await _maze.Draw(session);
await _pacman.Draw(session);
if (_step == 0)
{
await _ghostCollection.DrawAll(session);
}
}
//Draw points
protected SKCanvas DisplayPoints(CanvasWrapper canvasWrapper)
{
var canvas = canvasWrapper.Canvas;
_chartPaint.IsStroke = IsStroked;
foreach (var point in ConstructionData)
{
canvas.DrawCircle(point, PointRadius, _chartPaint);
}
return(canvas);
}
async ValueTask drawPlayerText(CanvasWrapper ds, int playerIndex, string text, Vector2 pos)
{
var shouldFlash = _gameStats.AnyonePlaying && !_gameStats.IsGameOver && _gameStats.CurrentPlayerStats.PlayerIndex == playerIndex;
var shouldDraw = !shouldFlash || _tickTock;
if (shouldDraw)
{
await ds.DrawMyText(text, pos, Colors.White);
}
}
// public static async ValueTask DrawSprite(this ISprite sprite, ElementReference spriteSheet)
// {
// if (sprite.Visible)
// {
// spr
// await DrawImage(
// spriteSheet,
// (sprite.Position - sprite.Origin).ToPoint(),
// new Rectangle(sprite.SpriteSheetPos.ToPoint(), sprite.Size));
// }
// }
public static async ValueTask DrawSprite(this CanvasWrapper session,
ISprite sprite,
ElementReference spriteSheet)
{
if (sprite.Visible)
{
await session.DrawImage(
spriteSheet,
(sprite.Position - sprite.Origin).toPoint(),
new Rectangle(sprite.SpriteSheetPos.toPoint(), sprite.Size));
}
}
public async ValueTask Draw(CanvasWrapper session)
{
PlayerStats currentPlayerStats = _gameStats.CurrentPlayerStats;
var gameOverAct = await resolveGameOverAct();
await gameOverAct.Draw(session);
await session.DrawMyText(
currentPlayerStats.PlayerIndex == 0? "PLAYER ONE" : "PLAYER TWO", TextPoints.PlayerTextPoint,
Colors.Cyan);
}
//Renders the x-y labels and the chart legend
private void RenderXYLabelAndLegend(CanvasWrapper canvasWrapper)
{
if (typeof(ISingleValueChart).Equals(typeof(T)
.GetInterface("ISingleValueChart")))
{
XYLableAndLegendForSingleValueChart(canvasWrapper);
}
else
{
XYLableAndLegendForMultiValueChart(canvasWrapper);
}
}
public async ValueTask Draw(CanvasWrapper session)
{
await session.DrawMyText("PUSH START BUTTON", new Vector2(50, 115), Colors.Orange);
var text = _coinBox.Credits < 2 ? "1 PLAYER ONLY" : "1 OR 2 PLAYERS";
await session.DrawMyText(text, new Vector2(70, 145), Colors.Cyan);
await session.DrawMyText("BONUS PAC-MAN FOR 10000 PTS", new Vector2(0, 175), Colors.White);
await session.DrawMyText("(C) 1980 MIDWAY MFG. CO.", new Vector2(15, 190), Colors.White);
}
public async ValueTask Draw(CanvasWrapper ds)
{
if (_gameStats.AnyonePlaying)
{
await drawPlayerLives(ds);
await drawFruit(ds);
}
else
{
await drawCredits(ds);
}
}
public DemoAreaControl()
{
InitializeComponent();
drawCanvas.MouseMove += DrawCanvas_MouseMove;
drawCanvas.MouseLeftButtonUp += DrawCanvas_MouseLeftButtonUp;
CanvasWrapper = new CanvasWrapper(drawCanvas);
associatedAlgorithm = null;
demo = new DemoModel();
}
async ValueTask drawPlayerOneScore(CanvasWrapper ds)
{
await drawPlayerText(ds, 0, "1UP", _playerOneTextPos);
int score = 0;
if (_gameStats.HasPlayerStats(0))
{
score = _gameStats.GetPlayerStats(0).Score;
}
await drawRightAlignedScoreText(ds, score, _scorePos1Up);
}
private void XYLableAndLegendForSingleValueChart(CanvasWrapper canvasWrapper)
{
if (canvasWrapper.ThisIsiOSOrAndroid)
{
Axis.DrawAndPositionLegend(_charts.Count.ToString(), ChartArea.Bottom, ChartArea.Left, _gridPaint,
canvasWrapper.LegendItemSpacing, true);
}
else
{
Axis.DrawAndPositionLegend(_charts.Count.ToString(), YOffset * 2, ChartArea.Left, _gridPaint,
canvasWrapper.LegendItemSpacing, true);
}
return;
}
public override void applyToCanvas(CanvasWrapper c)
{
base.applyToCanvas(c);
//c.DrawLineUsingActualCoords(P1.X, P1.Y, P2.X, P2.Y);
c.PushActiveLayer();
c.SwitchLayer(CanvasWrapper.LAYER_ALGORITHM);
//c.DrawLineUsingIndexes(StartXIndex, StartYIndex, EndXIndex, EndYIndex);
//c.DrawLineUsingValues(StartX, StartY, EndX, EndY);
foreach (var p in Points)
{
c.HighlightPointUsingValues(p.X, p.Y, HighlightLevel);
}
c.PopActiveLayer();
}
//Initiates the rendering of all the charts in the collection
internal void Plot(CanvasWrapper canvasWrapper)
{
ChartArea = canvasWrapper.Converter.Rect;
XOffset = canvasWrapper.Converter.XOffset;
YOffset = canvasWrapper.Converter.YOffset;
_converter = canvasWrapper.Converter;
Axis.OrientAxis(canvasWrapper.Canvas, canvasWrapper.DeviceWidth, canvasWrapper.DeviceHeight, XOffset, YOffset);
_gridPaint.TextSize = canvasWrapper.LabelTextSize * 1.2f;
NormalizeAllDataPoints();
RenderXYLabelAndLegend(canvasWrapper);
SetGrid(canvasWrapper.Canvas, canvasWrapper.GridLines);
canvasWrapper.NumberOfCharts = _charts.Count;
_charts.ForEach(chart => chart.RenderChart(canvasWrapper, Axis, this));
}
async ValueTask drawPlayerLives(CanvasWrapper ds)
{
int x = 0;
for (var i = 0; i < _gameStats.CurrentPlayerStats.LivesRemaining; i++, x += 16)
{
await ds.DrawImage(Spritesheet.Reference,
new Rectangle(x, 0, 16, 16),
new Rectangle(
(int)PacMan.FacingLeftSpritesheetPos.X,
(int)PacMan.FacingLeftSpritesheetPos.Y,
16,
16));
}
}
private void RenderXTickMark(CanvasWrapper canvasWrapper, Axis axis, float x1, float x2, string xLabel)
{
var widthSpace = canvasWrapper.NumberOfCharts == 1 ? (x1 + (x2 - x1) / 2) : (x1 + (x2 - x1));
if (canvasWrapper.ThisIsiOSOrAndroid)
{
axis.DrawAndPositionXTickMark(xLabel, widthSpace,
canvasWrapper.ChartArea.Bottom, _labelPaint);
}
else
{
axis.DrawAndPositionXTickMark(xLabel, widthSpace,
(canvasWrapper.Converter.YOffset * 2) + 4f, _labelPaint);
}
}
