public void TestMethod1()
{
int nBuildings = 3;
Point[] buildings = new Point[nBuildings];
//buildings[0] = new Point(-5,-3);
//buildings[1] = new Point(-9, 2);
//buildings[2] = new Point(3, -4);
buildings[0] = new Point(1, 2);
buildings[1] = new Point(0, 0);
buildings[2] = new Point(2, 2);
int widthDistance = buildings.Max(_ => _.X) - buildings.Min(_ => _.X);
var average = buildings.Average(_ => _.Y);
var yPos = (long) buildings.Select(p => new Tuple<int, double>(p.Y, Math.Abs(p.Y - average))).OrderBy(_ => _.Item2).First().Item1;
var dist = buildings.Select(p => Math.Abs((p.Y - yPos))).Sum();
var totalDistance = (long)widthDistance + dist;
Assert.AreEqual(4,totalDistance);
}
public static void Exécute(TextReader input, TextWriter output)
{
int N = int.Parse(input.ReadLine());
Point[] points = new Point[N];
for (int i = 0; i < N; i++)
{
string[] inputs = input.ReadLine().Split(' ');
int X = int.Parse(inputs[0]);
int Y = int.Parse(inputs[1]);
points[i].y = Y;
points[i].x = X;
}
if (N == 1)
{
output.WriteLine("0");
return;
}
var y = points.Select(x => x.y).ToArray();
var xs = points.Select(x => x.x).ToArray();
var sorted = points.OrderBy(x => x.y).ToArray();
var middle = sorted.Length / 2;
int minY = sorted[middle - 1].y;
int maxY = sorted[middle].y;
points = points.OrderBy(x => x.x).ToArray();
long upValue = Len(y, minY);
long downValue = Len(y, maxY);
while (minY < maxY - 1)
{
int mid = (minY + maxY) / 2;
long midValue = Len(y, mid);
if (upValue < downValue)
{
maxY = mid;
downValue = midValue;
}
else
{
minY = mid;
upValue = midValue;
}
}
// Write an action using Console.WriteLine()
// To debug: Console.Error.WriteLine("Debug messages...");
output.WriteLine(Math.Min(upValue, downValue) + xs.Max() - xs.Min());
}
private void pictureBox1_Paint(object sender, PaintEventArgs e)
{
int fontSize = 8;
int xPitch = 60;
int yPitch = 30;
if (matrix != null)
{
pictureBox1.Size = new Size(70 + 60 * matrix.GetLength(1), 70 + 30 * matrix.GetLength(0));
for (int i = 0; i < matrix.GetLength(0); ++i)
{
for (int j = 0; j < matrix.GetLength(1); ++j)
{
e.Graphics.DrawString(matrix[i, j].ToString("F0"), new Font("メイリオ", fontSize), Brushes.Black,
new RectangleF(50 + xPitch * i, 50 + yPitch * j, 50, 20), new StringFormat()
{
Alignment = StringAlignment.Center
});
}
}
var points = new Point[] {
new Point(50 - 20 + 10, 50 - 10),
new Point(50 - 20, 50 - 10),
new Point(50 - 20, 50 - 10 + yPitch * matrix.GetLength(0) + 5),
new Point(50 - 20 + 10, 50 - 10 + yPitch * matrix.GetLength(0) + 5)
};
e.Graphics.DrawLines(Pens.Black, points);
points = points.Select(x => new Point(x.X + xPitch * matrix.GetLength(1) + 30, x.Y)).ToArray();
points[0].X -= 20;
points[3].X -= 20;
e.Graphics.DrawLines(Pens.Black, points);
}
}
public Point[] PossibleCoordsToMoveTo()
{
if (Piece == null)
{
return(new Point[0]);
}
int xDir = Piece.PColor == PieceColor.RED ? 1 : -1;
var gotoCoords = new Point[0];
switch (Piece.Type)
{
case PieceType.Herzmuschel:
gotoCoords = new Point[] { new Point(xDir, -1), new Point(xDir, 1) };
break;
case PieceType.Moewe:
gotoCoords = new Point[] { new Point(1, 0), new Point(-1, 0), new Point(0, 1), new Point(0, -1) };
break;
case PieceType.Robbe:
gotoCoords = new Point[] { new Point(-1, 2), new Point(1, 2), new Point(-2, 1), new Point(2, 1), new Point(-1, -2), new Point(1, -2), new Point(-2, -1), new Point(2, -1) };
break;
case PieceType.Seestern:
gotoCoords = new Point[] { new Point(xDir, 0), new Point(1, 1), new Point(-1, 1), new Point(1, -1), new Point(-1, -1) };
break;
}
return(gotoCoords.Select(x => new Point(x.X + X, x.Y + Y)).ToArray());
}
private static string DrawOrientationSquares(string result, int circleThickness)
{
var points = new Point[] {
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2, CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2, CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness),
};
string pts = string.Join(" ", points.Select(x => x.X.ToString().Replace(",", ".") + " , " + x.Y.ToString().Replace(",", ".")));
result += "<polygon points =\"" + pts + "\"" + " style =\"fill:black\" />";
points = new Point[] {
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 1, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 1, CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 1, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
};
pts = string.Join(" ", points.Select(x => x.X.ToString().Replace(",", ".") + " , " + x.Y.ToString().Replace(",", ".")));
result += "<polygon points =\"" + pts + "\"" + " style =\"fill:black\" />";
points = new Point[] {
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness * 2, CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 1 + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * 0 + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * 1),
};
pts = string.Join(" ", points.Select(x => x.X.ToString().Replace(",", ".") + " , " + x.Y.ToString().Replace(",", ".")));
result += "<polygon points =\"" + pts + "\"" + " style =\"fill:black\" />";
return(result);
}
protected override void OnSpellEffect(Spell spell)
{
var targetPos = (TilePosition)((TerrainEntity)spell.Targets[0][0]).Position;
Point[] area = new Point[]
{
new Point(1, 1),
new Point(-1, -1),
new Point(-1, 1),
new Point(1, -1),
new Point(0, 0),
new Point(0, 1),
new Point(0, -1),
new Point(1, 0),
new Point(-1, 0)
};
TilePosition[] tileArea = area.Select(pos => new TilePosition(targetPos.Point + pos)).ToArray();
foreach (TilePosition tile in tileArea)
{
var targets = this.World.GetEntities(tile).OfType <UnitEntity>();
foreach (UnitEntity target in targets)
{
if (target.Module <HealthModule>().IsDead())
{
if (targets.Count() == 1)
{
var unit = new ZombieUnit(this.Owner);
spell.RunAction(new AddEntityAction(unit, tile.GenerateSpawn()));
}
spell.RunAction(new RemoveEntityAction(target));
}
}
}
}
public static System.Windows.Point[] GetPoints(Control control, bool relative = false)
{
if (control == null)
{
throw new ArgumentNullException(nameof(control));
}
var pos = relative
? Point.Empty
// Get control position on the screen
: control.PointToScreen(System.Drawing.Point.Empty);
var pointsToCheck =
new Point[]
{
// Top-Left.
pos,
// Top-Right.
new Point(pos.X + control.Width - 1, pos.Y),
// Bottom-Left.
new Point(pos.X, pos.Y + control.Height - 1),
// Bottom-Right.
new Point(pos.X + control.Width - 1, pos.Y + control.Height - 1),
// Middle-Centre.
new Point(pos.X + control.Width / 2, pos.Y + control.Height / 2)
};
return(pointsToCheck.Select(x => new System.Windows.Point(x.X, x.Y)).ToArray());
}
protected override void OnSpellEffect(Spell spell)
{
var targetPos = spell.Controller.Hero.PositionAs <TilePosition>();
Point[] area = new Point[]
{
new Point(1, 1),
new Point(-1, -1),
new Point(-1, 1),
new Point(1, -1),
new Point(0, 1),
new Point(0, -1),
new Point(1, 0),
new Point(-1, 0)
};
TilePosition[] tileArea = area.Select(pos => new TilePosition(targetPos.Point + pos)).ToArray();
foreach (TilePosition tile in tileArea)
{
var targets = this.World.GetEntities(tile).OfType <UnitEntity>();
foreach (UnitEntity target in targets)
{
target.Module <AttackModule>().Damage += 2;
}
}
}
protected override void OnSpellEffect(Spell spell)
{
var targetPos = (TilePosition)((TerrainEntity)spell.Targets[0][0]).Position;
Point[] area = new Point[]
{
new Point(1, 1),
new Point(-1, -1),
new Point(-1, 1),
new Point(1, -1),
new Point(0, 1),
new Point(0, -1),
new Point(1, 0),
new Point(-1, 0),
new Point(0, 0)
};
TilePosition[] tileArea = area.Select(pos => new TilePosition(targetPos.Point + pos)).ToArray();
foreach (TilePosition tile in tileArea)
{
var targets = this.World.GetEntities(tile).OfType <UnitEntity>();
foreach (UnitEntity target in targets)
{
spell.RunAction(target, new DealDamageToUnitAction(target, 3));
}
}
}
private void Form2_Paint(object sender, PaintEventArgs e)
{
if (matrix != null)
{
for (int i = 0; i < matrix.GetLength(0); ++i)
{
for (int j = 0; j < matrix.GetLength(1); ++j)
{
e.Graphics.DrawString(matrix[i, j].ToString("F0"), new Font("メイリオ", 8), Brushes.Black,
new RectangleF(50 + 60 * i, 180 + 30 * j, 50, 20), new StringFormat()
{
Alignment = StringAlignment.Center
});
}
}
var points = new Point[] {
new Point(50 - 20 + 10, 180 - 10),
new Point(50 - 20, 180 - 10),
new Point(50 - 20, 180 - 10 + 30 * matrix.GetLength(0) + 5),
new Point(50 - 20 + 10, 180 - 10 + 30 * matrix.GetLength(0) + 5)
};
e.Graphics.DrawLines(Pens.Black, points);
points = points.Select(x => new Point(x.X + 60 * matrix.GetLength(1) + 30, x.Y)).ToArray();
points[0].X -= 20;
points[3].X -= 20;
e.Graphics.DrawLines(Pens.Black, points);
}
}
protected override void OnSpellEffect(Spell spell)
{
var targetPos = (TilePosition)((TerrainEntity)spell.Targets[0][0]).Position;
Point[] area = new Point[]
{
new Point(1,1),
new Point(-1,-1),
new Point(-1,1),
new Point(1,-1),
new Point(0,0),
new Point(0,1),
new Point(0,-1),
new Point(1,0),
new Point(-1,0)
};
TilePosition[] tileArea = area.Select(pos => new TilePosition(targetPos.Point + pos)).ToArray();
foreach (TilePosition tile in tileArea)
{
var targets = this.World.GetEntities(tile).OfType<UnitEntity>();
foreach (UnitEntity target in targets)
if (target.Module<HealthModule>().IsDead())
{
if (targets.Count() == 1)
{
var unit = new ZombieUnit(this.Owner);
spell.RunAction(new AddEntityAction(unit, tile.GenerateSpawn()));
}
spell.RunAction(new RemoveEntityAction(target));
}
}
}
private static int calculateMedianYCoordinate(Point[] locations)
{
int[] orderedYCoordinatesOfLocations = locations.Select(location => location.Y).OrderBy(yCoordinate => yCoordinate).ToArray();
int medianIndex = locations.Count() / 2;
int medianY = orderedYCoordinatesOfLocations[medianIndex];
return medianY;
}
public static Tuple<Point, Vector> Compute(Point[] points)
{
var avgX = points.Select(p => p.X).Average();
var avgY = points.Select(p => p.Y).Average();
var shifted = points.Select(p => p - new Vector(avgX, avgY));
var mvSample = new MultivariateSample(2);
foreach (var p in shifted)
mvSample.Add(p.X, p.Y);
var pca = mvSample.PrincipalComponentAnalysis();
var firstComponentVector = pca.Component(0).NormalizedVector();
return Tuple.Create(
new Point(avgX, avgY),
new Vector(firstComponentVector[0], firstComponentVector[1]));
}
private bool IsLoadingScreen(Bitmap bitmap)
{
var warframeLogoPoints = new Point[] { new Point(1885, 1964), new Point(1956, 1973), new Point(2003, 2000), new Point(2022, 1985), new Point(2080, 1970), new Point(2116, 2003), new Point(2122, 1977), new Point(2209, 2003) };
var notWarframeLogoPoints = new Point[] { new Point(1900, 1969), new Point(1927, 1968), new Point(1956, 1999), new Point(1994, 1977), new Point(2037, 1996), new Point(2069, 1977), new Point(2100, 1996) };
var warframePointsPresent = !warframeLogoPoints.Any(p => bitmap.GetPixel(p.X, p.Y).GetBrightness() < 0.95);
var notWarframePointsDark = notWarframeLogoPoints.Select(p => bitmap.GetPixel(p.X, p.Y).GetBrightness()).Average() < 0.9;
return(warframePointsPresent && notWarframePointsDark);
}
public MazeGenerationResults Generate()
{
var results = new MazeGenerationResults();
var targets = new Dictionary <Point, bool>();
var offsets = new Point(new int[2]).GetAllOffsets();
foreach (var cell in InnerMap.Cells)
{
var cellNeighbors = offsets.Select(x => x + cell.Key);
foreach (var cellNeighbor in cellNeighbors)
{
var neighborIsAlive = Map.CellExists(cellNeighbor);
targets[cellNeighbor] = neighborIsAlive;
}
targets[cell.Key] = true;
}
foreach (var target in targets)
{
var targetNeighbours = offsets.Select(x => x + target.Key);
var aliveTargetNeighbours = offsets.Where(x => Map.CellExists(x));
var aliveNeighbourCount = aliveTargetNeighbours.Count();
if (target.Value) // Alive
{
if (DieIf.Contains(aliveNeighbourCount))
{
InnerMap.RemoveCell(target.Key);
results.Results.Add(new MazeGenerationResult(target.Key, CellState.Empty, CellDisplayState.Path));
}
}
else // Dead
{
if (BornIf.Contains(aliveNeighbourCount))
{
InnerMap.SetCell(new Cell(CellState.Filled, CellDisplayState.Wall), target.Key);
results.Results.Add(new MazeGenerationResult(target.Key, CellState.Filled, CellDisplayState.Wall));
}
}
}
return(results);
}
private void Log(Point[] points)
{
var template =
@"Shortest Path Request
Points:
{0}
";
var data = string.Format(template, string.Join("\n", points.Select(p => p.ToString()).ToArray()));
logService.Write(ShortestPath.Core.Domain.Persisted.Log.LogType.SEARCH, data);
}
static void Main(string[] args)
{
Point[] arr = new Point[15].Select(x => x = new Point()).ToArray();
Console.WriteLine("Points:\n"
+ string.Join("\n", arr.Select(x => x.ToString())));
Console.WriteLine("\nPoints in first octant:\n"
+ string.Join("\n", arr.Where(x => x.InFirstOctant())));
Console.ReadLine();
}
public static Point[] SmoothPoints(Point[] points, Func<double[], double[]> scalarSmooth)
{
Contract.Requires(points != null);
Contract.Requires(scalarSmooth != null);
Contract.Ensures(Contract.Result<Point[]>() != null);
Contract.Ensures(Contract.Result<Point[]>().Length != points.Length);
var x = points.Select(p => p.X).ToArray();
var y = points.Select(p => p.Y).ToArray();
x = scalarSmooth(x);
y = scalarSmooth(y);
var n = points.Length;
var result =
Enumerable.Range(0, n)
.Select(i => new Point(x[i], y[i]))
.ToArray();
return result;
}
public void Send(Point[] points)
{
using (var client = new Producer(_router))
{
var messages = points.Select(x =>
{
var pointToString = _formatter.PointToString(x);
return new Message(pointToString);
}).ToArray();
client.SendMessageAsync("InfluxCapacitor", messages).Wait();
}
}
private void Timer_Tick(object sender, EventArgs e)
{
ViewPortModel.Children.Where(o => o.GetName() == "Aircraft").ToList().ForEach(el =>
{
Matrix3D aircraftPosition = (el as ModelVisual3D).Children[0].GetTransform();
ViewPortModel.Children.Where(o => o.GetType().Equals(typeof(BoxVisual3D))).ToList().ForEach(box =>
{
Matrix3D boxPosition = box.GetTransform();
Rect3D boxBounds = (box as BoxVisual3D).Model.Bounds;
Point[] p = new Point[4];
p[0] = new Point(boxPosition.OffsetX - (boxBounds.SizeX * 100) / 2, boxPosition.OffsetY + (boxBounds.SizeY * 100) / 2);
p[1] = new Point(boxPosition.OffsetX - (boxBounds.SizeX * 100) / 2, boxPosition.OffsetY - (boxBounds.SizeY * 100) / 2);
p[2] = new Point(boxPosition.OffsetX + (boxBounds.SizeX * 100) / 2, boxPosition.OffsetY + (boxBounds.SizeY * 100) / 2);
p[3] = new Point(boxPosition.OffsetX + (boxBounds.SizeX * 100) / 2, boxPosition.OffsetY - (boxBounds.SizeY * 100) / 2);
bool xy = pnpoly(4, p.Select(point => (float)point.X).ToArray(), p.Select(point => (float)point.Y).ToArray(), (float)aircraftPosition.OffsetX, (float)aircraftPosition.OffsetY);
Point[] p2 = new Point[4];
p2[0] = new Point(boxPosition.OffsetX - (boxBounds.SizeX * 100) / 2, boxPosition.OffsetZ + (boxBounds.SizeZ * 100) / 2);
p2[1] = new Point(boxPosition.OffsetX - (boxBounds.SizeX * 100) / 2, boxPosition.OffsetZ - (boxBounds.SizeZ * 100) / 2);
p2[2] = new Point(boxPosition.OffsetX + (boxBounds.SizeX * 100) / 2, boxPosition.OffsetZ + (boxBounds.SizeZ * 100) / 2);
p2[3] = new Point(boxPosition.OffsetX + (boxBounds.SizeX * 100) / 2, boxPosition.OffsetZ - (boxBounds.SizeZ * 100) / 2);
bool xz = pnpoly(4, p2.Select(point => (float)point.X).ToArray(), p2.Select(point => (float)point.Y).ToArray(), (float)aircraftPosition.OffsetX, (float)aircraftPosition.OffsetZ);
if (xy && xz)
{
Debug.WriteLine("Collision");
}
});
}
);
}
//TODO: Improve getting center coordinate
public static SphereNode ByThreePoints(Point point1, Point point2, Point point3)
{
var points = new Point[3] {
point1, point2, point3
};
using (Polygon pol = Polygon.ByPoints(points))
using (Point c = pol.Center())
{
var center = new double[3] {
c.X, c.Y, c.Z
};
double radius = points.Select(pt => c.DistanceTo(pt)).Max();
return(new SphereNode(center, radius));
}
}
/// <summary>
/// Clears the clusters.
/// </summary>
/// <param name="listOfClusters">The list of clusters.</param>
private IList <RecognizedObject> FindNewCenters(IList <Cluster> listOfClusters)
{
Point[] newCentres = new Point[listOfClusters.Count];
for (int i = 0; i < listOfClusters.Count; i++)
{
newCentres[i] = new Point(listOfClusters[i].ItemsList.Select(item => item.CalculatedCenter.X).Average(),
listOfClusters[i].ItemsList.Select(item => item.CalculatedCenter.Y).Average());
}
return(newCentres.Select(item => new RecognizedObject
{
Center = item
})
.ToList());
}
public static string DrawSVGPoligonsfromSegments(BaseSegment[] segments, string pattern)
{
string result = string.Empty;
int circleThickness = 10;
result += "<?xml version=\"1.0\" encoding=\"utf-8\"?><!DOCTYPE svg> <svg width =\"" + (CONSTS.DEFAULT_MARKER_DIAMETER + circleThickness * 2) + "\" height =\"" + (CONSTS.DEFAULT_MARKER_DIAMETER + circleThickness * 2) + "\" >";
int center = (CONSTS.DEFAULT_MARKER_DIAMETER + circleThickness * 2) / 2;
result += "<rect width= \"" + (CONSTS.DEFAULT_MARKER_DIAMETER + circleThickness * 2) + "\" height=\"" + (CONSTS.DEFAULT_MARKER_DIAMETER + circleThickness * 2) + "\" fill = \"none\" stroke = \"black\" stroke-width = \"" + circleThickness + "\"/>";
result = DrawOrientationCircles(result, circleThickness);
int idx = 0;
foreach (var item in segments)
{
if (item == null || item.Points == null || item.Points[0] == null)
{
continue;
}
var points = new Point[] {
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[0].X + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[0].Y + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[1].X + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[1].Y + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[2].X + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[2].Y + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[3].X + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[3].Y + circleThickness),
new Point(CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[0].X + circleThickness, CONSTS.DEFAULT_MARKER_DIAMETER * item.Points[0].Y + circleThickness),
};
string pts = string.Join(" ", points.Select(x => x.X.ToString().Replace(",", ".") + " , " + x.Y.ToString().Replace(",", ".")));
if (pattern[idx].Equals('1'))
{
result += "<polygon points =\"" + pts + "\"" + " style =\"fill:black\" />";
}
else
{
result += "<polygon points =\"" + pts + "\"" + " style =\"fill:none\" />";
}
idx++;
}
result += "</svg>";
return(result);
}
private static Geometry GetDiamondGeometry()
{
Point[] points = new Point[] {
new Point(0, s_itemSize.Height / 2),
new Point(s_itemSize.Width / 2, s_itemSize.Height),
new Point(s_itemSize.Width, s_itemSize.Height / 2),
new Point(s_itemSize.Width / 2, 0)
};
PathSegmentCollection psc = new PathSegmentCollection(
points.Select(point => new LineSegment(point, true)).OfType <PathSegment>());
PathFigure pf = new PathFigure(points[0], psc, true);
PathGeometry geometry = new PathGeometry(new PathFigure[] { pf }, FillRule.EvenOdd, null);
return(geometry);
}
static void Main(string[] args)
{
Console.WriteLine("==== Part 1 & 2 ====");
var foos = LoadMap("input.txt");
maxX = foos.Max(f => f.Position.X);
maxY = foos.Max(f => f.Position.Y);
fieldLookup = foos.ToDictionary(f => f.Position);
Console.WriteLine($"maxX: {maxX}, maxY: {maxY}");
var slopes = new Point[] { new Point(1, 1), new Point(3, 1), new Point(5, 1), new Point(7, 1), new Point(1, 2) };
var result1 = slopes
.Select(s => CountTrees(s))
.Peak()
.Aggregate(1, (a, b) => a * b);
Console.WriteLine($"Part2-Result: {result1}");
}
public bool IsChatCollapsed(Bitmap screen)
{
//Already moved down pixels
var lightPixelsLower = new Point[] { new Point(151, 2115), new Point(158, 2136), new Point(166, 2115), new Point(173, 2124), new Point(171, 2136) };
var darkPixelsLower = new Point[] { new Point(156, 2120), new Point(168, 2131), new Point(172, 2110), new Point(146, 2118), new Point(176, 2133) };
var isLowerAndCollapsed = !lightPixelsLower.Any(p => screen.GetPixel(p.X, p.Y).ToHsv().Value <= 0.3f) &&
!darkPixelsLower.Any(p => screen.GetPixel(p.X, p.Y).ToHsv().Value >= 0.15f);
if (isLowerAndCollapsed)
{
return(true);
}
//Not yet moved down pixels
var lightPixelsHigher = lightPixelsLower.Select(p => new Point(p.X, p.Y - 27));
var darkPixelsHigher = darkPixelsLower.Select(p => new Point(p.X, p.Y - 27));
var isHigherAndCollapsed = !lightPixelsHigher.Any(p => screen.GetPixel(p.X, p.Y).ToHsv().Value <= 0.3f) &&
!darkPixelsHigher.Any(p => screen.GetPixel(p.X, p.Y).ToHsv().Value >= 0.15f);
return(isLowerAndCollapsed || isHigherAndCollapsed);
}
public void DrawPolyline(Point[] points)
{
_canvas.DrawLines(Pens.Black, points.Select(p => GetTranslatedPoint(p))
.Select(p => new PointF((p.X / 200.0f) * zoom, (p.Y / 200.0f) * zoom))
.ToArray());
//var pointsString = new StringBuilder();
//var firstPoint = GetTranslatedPoint(points[0]);
//pointsString.AppendLine("ctx.beginPath();");
//pointsString.AppendLine(string.Format("ctx.moveTo({0}, {1});", firstPoint.X / 1000, -firstPoint.Y / 1000));
//for (int i = 1; i < points.Length; i++)
//{
// var currentPoint = GetTranslatedPoint(points[i]);
// pointsString.AppendLine(string.Format("ctx.lineTo({0}, {1});", currentPoint.X / 1000, -currentPoint.Y / 1000));
//}
//pointsString.AppendLine("ctx.stroke();");
//AppendTextToOutput(pointsString.ToString());
}
protected override void OnSpellEffect(Spell spell)
{
var targetPos = spell.Controller.Hero.PositionAs<TilePosition>();
Point[] area = new Point[]
{
new Point(1,1),
new Point(-1,-1),
new Point(-1,1),
new Point(1,-1),
new Point(0,1),
new Point(0,-1),
new Point(1,0),
new Point(-1,0)
};
TilePosition[] tileArea = area.Select(pos => new TilePosition(targetPos.Point + pos)).ToArray();
foreach (TilePosition tile in tileArea)
{
var targets = this.World.GetEntities(tile).OfType<UnitEntity>();
foreach (UnitEntity target in targets)
target.Module<AttackModule>().Damage += 2;
}
}
public void PutManyRectangles_AndTagCloudIsCircularity(int rectanglesCount)
{
circularCloudLayouter = new CircularTagsCloudLayouter();
const int randomRange = 200;
var random = new Random(randomRange);
for (var i = 0; i < rectanglesCount; i++)
{
rectangleSizes.Add(new Size(1 + random.Next(randomRange), 1 + random.Next(randomRange)));
}
double maxDistanceFromCenter = 0;
double tagCloudSquare = 0;
for (var i = 0; i < rectanglesCount; i++)
{
var rectangle = circularCloudLayouter.PutNextRectangle(rectangleSizes[i]);
var vertices = new Point[]
{
new Point(rectangle.Left, rectangle.Bottom),
new Point(rectangle.Left, rectangle.Top),
new Point(rectangle.Right, rectangle.Bottom),
new Point(rectangle.Right, rectangle.Top),
};
var theMostFarVertexFromCenter = vertices
.Select((x) => CalcDistanceBetweenPoints(cloudCenter, x))
.Max();
maxDistanceFromCenter = Math.Max(maxDistanceFromCenter,
theMostFarVertexFromCenter);
tagCloudSquare += rectangleSizes[i].Width * rectangleSizes[i].Height;
}
var circleArea = Math.PI * maxDistanceFromCenter * maxDistanceFromCenter;
var squaresRatio = tagCloudSquare / circleArea;
squaresRatio.Should().BeGreaterOrEqualTo(0.3);
}
private void DrawWireframeDrill()
{
Gl.glColor3f(0, 0, 0);
Gl.glLineWidth(1);
Rotate rotate = new Rotate();
Point tPoint = new Point();
Point tPoint2 = new Point();
Point[] arr1;// = new Point[64];
// SetupArray(arr1);
Point[] arr2 = new Point[64];
SetupArray(arr2);
// O = Math.PI * 1 / 180;
double h, dH, H, tH, t2H, L2, dL;
int i, j;
int Q = (int)(_form1.O1 * 180 / Math.PI + 5);
h = _form1.R1 / Math.Tan(_form1.O1);
H = _form1.Array[_form1.ActQuant / 2].Y;
dH = (2 * H) / (Q - 1);
t2H = -H;
L2 = t2H / h;
rotate.SetRotate(L2, 0, 0, 1);
for (j = 0; j < _form1.ActQuant; j++)
{
rotate.TransformPoint(_form1.ArraySv[j], arr2[j]);
}
dL = Math.Atan(_form1.ArraySv[0].Y / _form1.ArraySv[0].X);
dL = (Math.PI - dL) * 2 / (12 - 1);
for (i = 0; i < Q; i++)
{
tH = t2H;
t2H = -H + (i + 1) * dH;
L2 = t2H / h;
// CopyArray(arr1, arr2);
arr1 = arr2.Select(o => o.Clone()).ToArray();
rotate.SetRotate(L2, 0, 0, 1);
for (j = 0; j < _form1.ActQuant; j++)
{
rotate.TransformPoint(_form1.ArraySv[j], arr2[j]);
}
Gl.glBegin(Gl.GL_LINE_STRIP);
for (j = 0; j < _form1.ActQuant; j++)
{
Gl.glVertex3d(arr1[j].X, arr1[j].Y, tH);
}
Gl.glEnd();
Gl.glBegin(Gl.GL_LINE_STRIP);
for (j = 0; j < 12; j++)
{
rotate.SetRotate(dL * j, 0, 0, 1);
rotate.TransformPoint(arr1[0], tPoint);
Gl.glVertex3d(tPoint.X, tPoint.Y, tH);
}
Gl.glEnd();
if (i < (Q - 1))
{
Gl.glBegin(Gl.GL_LINES);
for (j = 0; j < _form1.ActQuant; j++)
{
Gl.glVertex3d(arr1[j].X, arr1[j].Y, tH);
Gl.glVertex3d(arr2[j].X, arr2[j].Y, t2H);
}
Gl.glEnd();
Gl.glBegin(Gl.GL_LINES);
for (j = 0; j < 12; j++)
{
rotate.SetRotate(dL * j, 0, 0, 1);
rotate.TransformPoint(arr1[0], tPoint);
rotate.TransformPoint(arr2[0], tPoint2);
Gl.glVertex3d(tPoint.X, tPoint.Y, tH);
Gl.glVertex3d(tPoint2.X, tPoint2.Y, t2H);
}
Gl.glEnd();
}
}
}
public OctavePlot(Point[] points)
{
dataX = Embrace(String.Join(",", points.Select(d => d.X.ToString(cul))));
dataY = Embrace(String.Join(",", points.Select(d => d.Y.ToString(cul))));
}
private static Point calculateGiantsMedianPoint(Point[] giants)
{
var giantXs = giants.Select(g => g.X).OrderBy(x => x);
var medianX = (giantXs.Count() % 2 == 0)
? giantXs.Skip(giantXs.Count() / 2 - 1).Take(2).Sum() / 2
: giantXs.Skip((giantXs.Count() - 1) / 2).First();
var giantYs = giants.Select(g => g.Y).OrderBy(y => y);
var medianY = (giantYs.Count() % 2 == 0)
? giantYs.Skip(giantYs.Count() / 2 - 1).Take(2).Sum() / 2
: giantYs.Skip((giantYs.Count() - 1) / 2).First();
var target = new Point { X = medianX, Y = medianY };
return target;
}
public int[] GetIDsFromCells(Point[] cell)
{
return cell.Select(value => this.GetIDFromCell(value)).ToArray();
}
public static Polygon2D[] GetPolyUnion(Point[][] polygons)
{
if (polygons.Length == 0)
{
return new Polygon2D[] { new Polygon2D(new Point[0]) };
}
else if (polygons.Length == 1)
{
return new Polygon2D[] { new Polygon2D(polygons[0]) };
}
// See which edges are intersecting
EdgeIntersection[] intersections = GetIntersections(polygons);
if (intersections.Length == 0)
{
return polygons.Select(o => new Polygon2D(o)).ToArray();
}
// Divide into islands of polygons
var islands = GetIslands(polygons, intersections);
List<Polygon2D> retVal = new List<Polygon2D>();
// Union each island independently
foreach (PolygonIsland island in islands)
{
if (island.Polygons.Length == 1)
{
retVal.Add(new Polygon2D(island.Polygons[0])); // there is only one polygon in this island (no intersections)
}
else
{
retVal.AddRange(MergeIsland(island)); // the island might actually be several polygons butted up next to each other
}
}
// Exit Function
return retVal.ToArray();
}
/*public static Point[] Interpolate(Point[] points, float[] xi)
{
var interpolatedvalues = new List<Point>();
points = points.OrderBy(x => x.X).ToArray();
//Assumes inorder enumerables
var i = 0;
foreach (var xValue in xi)
{
while (points[i].X < xValue)
{
i++;
if (i >= points.Length)
break;
}
if (i >= points.Length)
break;
if (Math.Abs(points[i].X - xValue) < Double.Epsilon)
{
interpolatedvalues.Add(points[i]);
}
else
{
var x0 = 0d;
var y0 = 0d;
if (i > 0)
{
x0 = points[i - 1].X;
y0 = points[i - 1].Y;
}
var x1 = points[i].X;
var y1 = points[i].Y;
var yValue = y0 * (xValue - x1) / (x0 - x1) + y1 * (xValue - x0) / (x1 - x0);
interpolatedvalues.Add(new Point(xValue, yValue));
}
}
return interpolatedvalues.OrderBy(x => x.X).ToArray();
}*/
public static Point[] Interpolate(Point[] points, float[] xi)
{
var interpolatedPoints = new Point[xi.Length];
for (var i = 0; i < xi.Length; i++)
{
interpolatedPoints[i] = new Point(xi[i], Interp1(points.Select(x => x.X).ToList(), points.Select(x => x.Y).ToList(), xi[i]));
}
return interpolatedPoints;
}
public IDrawingGraphics FillPolygon(Point[] points)
{
this.Graphics.FillPolygon(this.state.CurrentBrush, points.Select((p) => new Point(CalculateX(p.X), CalculateY(p.Y))).ToArray());
return this;
}
private void Log(Point[] points, bool cacheHit)
{
var template =
@"Road Time Request
Cache:
{0}
Points:
{1}
";
var data = string.Format(template, cacheHit ? "hit" : "miss", string.Join("\n", points.Select(p => p.ToString()).ToArray()));
logService.Write(ShortestPath.Core.Domain.Persisted.Log.LogType.ROAD_TIME_QUERY, data);
}
public static IControl Line(Point <Points> start, Point <Points> end, Stroke stroke)
{
return(Line(start.Select(Observable.Return), end.Select(Observable.Return), stroke));
}
private string[] PathWithRotation(Point nextRoom, int rotation, Point to, int distance, List<Direction> testedDirections, Point[] rocks)
{
string[] path;
Rotate(nextRoom, rotation);
var direction = nextStepOf(RoomTypeAt(nextRoom), nextRoom.Position);
if (testedDirections.Contains(direction))
{
Console.Error.WriteLine("Exiting room " + nextRoom + " at " + nextRoom.Position + " has already been tested.");
path = null; //Already tested, so short circuit
}
else
{
testedDirections.Add(direction);
//Console.Error.WriteLine("Testing " + nextRoom + " from " + nextRoom.Position + " as tile #" + RoomTypeAt(nextRoom));
if (!IsValidEntry(nextRoom))
{
path = null;
}
else
{
var newRocks = rocks.Select(rock =>
{
var newRock = rock + nextStepOf(RoomTypeAt(rock), rock.Position);
Console.Error.WriteLine("Rock moved from " + rock + " to " + newRock);
return newRock;
}).ToArray();
path = TestPaths(nextRoom, to, distance, newRocks);
}
}
Rotate(nextRoom, 4 - rotation);
return path;
}
private static Geometry GetDiamondGeometry()
{
Point[] points = new Point[]{
new Point(0, s_itemSize.Height / 2),
new Point(s_itemSize.Width / 2, s_itemSize.Height),
new Point(s_itemSize.Width, s_itemSize.Height / 2),
new Point(s_itemSize.Width / 2, 0)};
PathSegmentCollection psc = new PathSegmentCollection(
points.Select(point => new LineSegment(point, true)).OfType<PathSegment>());
PathFigure pf = new PathFigure(points[0], psc, true);
PathGeometry geometry = new PathGeometry(new PathFigure[] { pf }, FillRule.EvenOdd, null);
return geometry;
}
private static Point[] GetPolygon(Point center, Point[] polygon, double percent)
{
return polygon.
Select(o =>
{
Vector displace = o - center;
displace *= percent;
return center + displace;
}).
ToArray();
}
//TODO: This method is too simple. There could be multiple polygons each with their own holes
private static Polygon2D[] MergeIslandSprtFindAHoles(Point[][] polygons)
{
if (polygons.Length < 2)
{
throw new ArgumentException("At least two polygons need to be passed to this method: " + polygons.Length.ToString());
}
// Find the parent, the rest will be holes
int parentIndex = MergeIslandSprtFindAHolesSprtParent(polygons);
if (parentIndex < 0)
{
// Didn't find a parent. Return each as its own polygon
//TODO: These are likely touching. Try to do a better job of coming up with a single polygon
return polygons.Select(o => new Polygon2D(o)).ToArray();
}
List<Point[]> holes = new List<Point[]>(polygons);
holes.RemoveAt(parentIndex);
return new Polygon2D[] { new Polygon2D(polygons[parentIndex], holes.ToArray()) };
}
public static Point GetCentroid(Point[] points)
{ return Point.Truncate(PolygonF.GetCentroid(points.Select(p => new PointF((float)p.X, (float)p.Y)).ToArray())); }
private void MainForm_Paint(object sender, PaintEventArgs e)
{
e.Graphics.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
e.Graphics.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
e.Graphics.FillRectangle(Brushes.White, e.ClipRectangle);
Point[] corners = new Point[]
{
new Point(0, 0),
new Point(0, scale),
new Point(scale, 0),
new Point(scale, scale),
};
Point3D[] projectedCorners = corners
.Select(p => Project(GetAxisPoint(p.X, p.Y)))
.ToArray();
int[] indices = Enumerable
.Range(0, 4)
.OrderBy(i => projectedCorners[i].z)
.ToArray();
int fl = projectedCorners[indices[0]].x < projectedCorners[indices[1]].x ? indices[0] : indices[1];
int fr = indices[0] + indices[1] - fl;
int nl = projectedCorners[indices[2]].x < projectedCorners[indices[3]].x ? indices[2] : indices[3];
int nr = indices[2] + indices[3] - nl;
if (projectedCorners[fl].x <= projectedCorners[nl].x && projectedCorners[fr].x <= projectedCorners[nr].x)
{
PaintPart(corners[fr], corners[nl], e.Graphics);
}
else if (projectedCorners[fl].x >= projectedCorners[nl].x && projectedCorners[fr].x >= projectedCorners[nr].x)
{
PaintPart(corners[fl], corners[nr], e.Graphics);
}
else
{
int vx = (corners[fr].X - corners[fl].X) / scale;
int vy = (corners[fr].Y - corners[fl].Y) / scale;
int ux = (corners[nl].X - corners[fl].X) / scale;
int uy = (corners[nl].Y - corners[fl].Y) / scale;
int ms = -1;
for (int i = 0; i < scale; i++)
{
int cvx1 = vx * i;
int cvx2 = vx * (i + 1);
int cvy1 = vy * i;
int cvy2 = vy * (i + 1);
Point cfl = new Point(corners[fl].X + cvx1, corners[fl].Y + cvy1);
Point cfr = new Point(corners[fl].X + cvx2, corners[fl].Y + cvy2);
Point cnl = new Point(corners[nl].X + cvx1, corners[nl].Y + cvy1);
Point cnr = new Point(corners[nl].X + cvx2, corners[nl].Y + cvy2);
Point3D pcfl = Project(GetAxisPoint(cfl.X, cfl.Y));
Point3D pcfr = Project(GetAxisPoint(cfr.X, cfr.Y));
Point3D pcnl = Project(GetAxisPoint(cnl.X, cnl.Y));
Point3D pcnr = Project(GetAxisPoint(cnr.X, cnr.Y));
ms = i;
break;
}
if (ms != 1)
{
for (int u = 0; u < scale; u++)
{
Point ufl = new Point(corners[fl].X + u * ux, corners[fl].Y + u * uy);
Point ufr = new Point(corners[fr].X + u * ux, corners[fr].Y + u * uy);
Point unl = new Point(corners[fl].X + (u + 1) * ux, corners[fl].Y + (u + 1) * uy);
Point unr = new Point(corners[fr].X + (u + 1) * ux, corners[fr].Y + (u + 1) * uy);
Point cfl = new Point(ufl.X + ms * vx, ufl.Y + ms * vy);
Point cfr = new Point(ufl.X + (ms + 1) * vx, ufl.Y + (ms + 1) * vy);
Point cnl = new Point(unl.X + ms * vx, unl.Y + ms * vy);
Point cnr = new Point(unl.X + (ms + 1) * vx, unl.Y + (ms + 1) * vy);
PaintPart(ufl, cnl, e.Graphics);
PaintPart(ufr, cnr, e.Graphics);
PaintPart(cfl, cnr, e.Graphics);
}
}
}
Line(new Point3D(0, 0, 0), new Point3D(1, 0, 0), e.Graphics, Pens.Red);
Line(new Point3D(0, 0, 0), new Point3D(0, 1, 0), e.Graphics, Pens.Green);
Line(new Point3D(0, 0, 0), new Point3D(0, 0, 1), e.Graphics, Pens.Blue);
}
Sprite CreateSprite(Mobs ID, Enum state)
{
Point size;
Point[] animation;
string spritesheet = "Sprites/Enimies2";
bool themeOffset = true;
switch (ID)
{
case Mobs.goomba:
size = new Point(16, 16);
animation = new Point[] { new Point(0, 16), new Point(16, 16) };
break;
case Mobs.GreenFlyingKoopa:
case Mobs.greenKoopa:
switch ((KoopaEnum)state)
{
case KoopaEnum.FLYING:
size = new Point(16, 24);
animation = new Point[] { new Point(128, 8), new Point(144, 8) };
break;
case KoopaEnum.WALKING:
size = new Point(16, 24);
animation = new Point[] { new Point(96, 8), new Point(112, 8) };
break;
case KoopaEnum.IN_SHELL:
case KoopaEnum.IN_SHELL_MOVING:
size = new Point(16, 16);
animation = new Point[] { new Point(160, 16) };
break;
case KoopaEnum.IN_SHELL_TRANSITION:
size = new Point(16, 16);
animation = new Point[] { new Point(176, 16) };
break;
default:
return(NullSprite.Instance);
}
break;
case Mobs.RedFlyingKoopa:
case Mobs.redKoopa:
if (offsets[Theme].Y != 128)
{
switch ((KoopaEnum)state)
{
case KoopaEnum.FLYING:
size = new Point(16, 24);
animation = new Point[] { new Point(128, 72), new Point(144, 72) };
break;
case KoopaEnum.WALKING:
size = new Point(16, 24);
animation = new Point[] { new Point(96, 72), new Point(112, 72) };
break;
case KoopaEnum.IN_SHELL:
case KoopaEnum.IN_SHELL_MOVING:
size = new Point(16, 16);
animation = new Point[] { new Point(160, 80) };
break;
case KoopaEnum.IN_SHELL_TRANSITION:
size = new Point(16, 16);
animation = new Point[] { new Point(176, 80) };
break;
default:
return(NullSprite.Instance);
}
}
else
{
switch ((KoopaEnum)state)
{
case KoopaEnum.FLYING:
size = new Point(16, 24);
animation = new Point[] { new Point(128, 168), new Point(144, 168) };
break;
case KoopaEnum.WALKING:
size = new Point(16, 24);
animation = new Point[] { new Point(96, 168), new Point(112, 168) };
break;
case KoopaEnum.IN_SHELL:
case KoopaEnum.IN_SHELL_MOVING:
size = new Point(16, 16);
animation = new Point[] { new Point(160, 176) };
break;
case KoopaEnum.IN_SHELL_TRANSITION:
size = new Point(16, 16);
animation = new Point[] { new Point(176, 176) };
break;
default:
return(NullSprite.Instance);
}
}
themeOffset = false;
break;
case Mobs.HammerBro:
switch ((BroEnum)state)
{
case BroEnum.THROWING:
animation = new[] { new Point(352, 8), new Point(368, 8) };
break;
case BroEnum.JUMPING:
animation = new[] { new Point(336, 8) };
break;
case BroEnum.WALKING:
animation = new[] { new Point(320, 8), new Point(336, 8) };
break;
default:
return(NullSprite.Instance);
}
size = new Point(16, 24);
break;
case Mobs.PiranhaPlant:
size = new Point(16, 24);
animation = new Point[] { new Point(191, 8), new Point(208, 8) };
break;
case Mobs.BulletBill:
size = new Point(16, 16);
animation = new Point[] { new Point(560, 16) };
break;
case Mobs.SuperBill:
case Mobs.FakeBill:
size = new Point(16, 16);
animation = new Point[] { new Point(576, 16) };
themeOffset = false;
break;
case Mobs.FatBill:
size = new Point(64, 64);
animation = new Point[] { new Point(0, 0) };
spritesheet = "Sprites/BanzaiBillL";
themeOffset = false;
break;
case Mobs.TurboBill:
size = new Point(16, 16);
animation = new Point[] { new Point(576, 48) };
themeOffset = false;
break;
case Mobs.SpinyEgg:
size = new Point(16, 16);
animation = new Point[] { new Point(448, 80), new Point(464, 80) };
themeOffset = false;
break;
case Mobs.Spiny:
size = new Point(16, 16);
animation = new Point[] { new Point(480, 80), new Point(496, 80) };
themeOffset = false;
break;
case Mobs.Lakitu:
size = new Point(16, 24);
animation = new Point[] { new Point(416, 8) };
themeOffset = false;
break;
case Mobs.LakituThrow:
size = new Point(16, 24);
animation = new Point[] { new Point(432, 8) };
themeOffset = false;
break;
case Mobs.BooChase:
spritesheet = ("Sprites/BooChase");
size = new Point(16, 16);
animation = new Point[] { new Point(0, 0) };
themeOffset = false;
break;
case Mobs.BooHiddn:
spritesheet = ("Sprites/BooHide");
size = new Point(16, 16);
animation = new Point[] { new Point(0, 0) };
themeOffset = false;
break;
case Mobs.Bowser:
size = new Point(32, 32);
themeOffset = false;
switch ((BowserEnum)state)
{
case BowserEnum.Breathing:
animation = new Point[] { new Point(655, 0) };
break;
case BowserEnum.Walking:
animation = new Point[] { new Point(720, 0), new Point(752, 0) };
break;
case BowserEnum.Dashing:
animation = new Point[] { new Point(720, 0), new Point(752, 0) };
break;
default:
animation = new Point[] { new Point(720, 0) };
break;
}
break;
case Mobs.AIBowser:
size = new Point(32, 32);
themeOffset = false;
switch ((BowserEnum)state)
{
case BowserEnum.Breathing:
animation = new Point[] { new Point(655, 33) };
break;
case BowserEnum.Walking:
animation = new Point[] { new Point(720, 33), new Point(752, 33) };
break;
case BowserEnum.Dashing:
animation = new Point[] { new Point(720, 33), new Point(752, 33) };
break;
default:
animation = new Point[] { new Point(720, 33) };
break;
}
break;
default:
return(NullSprite.Instance);
}
if (themeOffset)
{
animation = animation.Select(p => p + offsets[Theme]).ToArray();
}
return(new Sprite(Content.Load <Texture2D>(spritesheet), size, animation));
}
