/// <summary> /// Gets distance between two points in pixels /// </summary> /// <param name="p1">First point</param> /// <param name="p2">Second point</param> /// <returns>Distance between two points, in pixels</returns> public static double DistanceBetweenPoints(this IMapContext map, PointF p1, PointF p2) { double deltaX = p1.X - p2.X; double deltaY = p1.Y - p2.Y; return(Math.Sqrt(deltaX * deltaX + deltaY * deltaY)); }
private static PointF[] EdgeCrosspoints(IMapContext map, PointF p1, PointF p2) { int width = map.Width; int height = map.Height; PointF p00 = new PointF(0, 0); PointF pW0 = new PointF(width, 0); PointF pWH = new PointF(width, height); PointF p0H = new PointF(0, height); List <PointF?> crossPoints = new List <PointF?>(); // top edge crossPoints.Add(SegmentsIntersection(p1, p2, p00, pW0)); // right edge crossPoints.Add(SegmentsIntersection(p1, p2, pW0, pWH)); // bottom edge crossPoints.Add(SegmentsIntersection(p1, p2, pWH, p0H)); // left edge crossPoints.Add(SegmentsIntersection(p1, p2, p0H, p00)); return(crossPoints.Where(p => p != null).Cast <PointF>().ToArray()); }
public static float Rotate(this IMapContext map, PointF p, CrdsEquatorial eq, double PA) { // Point directed to North celestial pole PointF pNorth = map.Project((eq + new CrdsEquatorial(0, 1)).ToHorizontal(map.GeoLocation, map.SiderealTime)); // Clockwise rotation float inc = LineInclinationY(p, pNorth); if (map.IsInverted) { inc = -90 - inc; } float rotation = (float)(inc - (map.IsMirrored ? -1 : 1) * PA); if (map.IsInverted) { rotation = 90 - rotation; } map.Graphics.TranslateTransform(p.X, p.Y); map.Graphics.RotateTransform(rotation); return(rotation); }
// Ctor : provides Map and mode (combat or not) public SubMapProcessor(IMapContext map, bool inFightMap) { _isInFight = inFightMap; _map = map; _cells = map.Cells.Select(cell => new CellInfo(cell)).ToArray(); SubMapsCount = SubMapFiller(inFightMap); }
public override void Render(IMapContext map) { brushLabel = new SolidBrush(map.GetColor("ColorSolarSystemLabel")); var bodies = planetsCalc.Planets .Where(p => p.Number != Planet.EARTH) .Cast <SolarSystemObject>() .Concat(new[] { sun }) .OrderByDescending(body => body.Ecliptical.Distance) .ToArray(); foreach (var body in bodies) { if (body is Planet planet) { RenderPlanet(map, planet); } else { RenderSun(map); } } RenderMoon(map); if (map.Schema == ColorSchema.Day) { DrawHalo(map); } RenderEarthShadow(map); }
/// <summary> /// Renders constellation borders on the map /// </summary> private void RenderBorders(IMapContext map) { PointF p1, p2; CrdsHorizontal h1, h2; var borders = constellationsCalc.ConstBorders; bool isGround = settings.Get <bool>("Ground"); double coeff = map.DiagonalCoefficient(); Pen penBorder = new Pen(map.GetColor("ColorConstBorders")); foreach (var block in borders) { for (int i = 0; i < block.Count - 1; i++) { h1 = block.ElementAt(i).Horizontal; h2 = block.ElementAt(i + 1).Horizontal; if ((!isGround || h1.Altitude >= 0 || h2.Altitude >= 0) && Angle.Separation(map.Center, h1) < 90 * coeff && Angle.Separation(map.Center, h2) < 90 * coeff) { p1 = map.Project(h1); p2 = map.Project(h2); var points = map.SegmentScreenIntersection(p1, p2); if (points.Length == 2) { map.Graphics.DrawLine(penBorder, points[0], points[1]); } } } } }
private void DrawFovCircle(IMapContext map, float frameSize, FovFrame frame, bool isOuter) { float radius = frameSize * 3600 / 2; float size = map.GetDiskSize(radius); // do not draw frame if its size exceeds screen bounds if (size < Math.Sqrt(map.Width * map.Width + map.Height * map.Height)) { if (isOuter && frame.Shading > 0 && frameSize >= map.ViewAngle / 2) { var circle = new GraphicsPath(); circle.AddEllipse(map.Width / 2 - size / 2, map.Height / 2 - size / 2, size, size); var shading = new Region(new RectangleF(0, 0, map.Width, map.Height)); shading.Exclude(circle); int transparency = (int)(frame.Shading / 100f * 255); var solidBrush = new SolidBrush(Color.FromArgb(transparency, map.GetSkyColor())); map.Graphics.FillRegion(solidBrush, shading); } map.Graphics.DrawEllipse(new Pen(frame.Color.GetColor(map.Schema, map.DayLightFactor)), map.Width / 2 - size / 2, map.Height / 2 - size / 2, size, size); if (isOuter) { float labelWidth = map.Graphics.MeasureString(frame.Label, font).Width; if (labelWidth <= size * 2) { map.Graphics.DrawString(frame.Label, font, new SolidBrush(frame.Color.GetColor(map.Schema, map.DayLightFactor)), new PointF(map.Width / 2, map.Height / 2 + size / 2), format); } } } }
/// <summary> /// Gets size of a point (small filled circle) representing a star or a planet /// or any other celestial object on sky map, depending of its magnitude. /// </summary> /// <param name="mag">Magnitude of a celestial body</param> /// <param name="maxDrawingSize">Maximal allowed drawing diameter, in pixels</param> /// <returns>Size (diameter) of a point in screen pixels</returns> public static float GetPointSize(this IMapContext map, float mag, float maxDrawingSize = 0) { // current magnitude limit float mag0 = map.MagLimit; float size; if (mag > mag0) { size = 0; } else if (maxDrawingSize != 0) { size = Math.Min(maxDrawingSize, mag0 - mag); } else { size = mag0 - mag; } if (map.Schema == ColorSchema.Day) { size *= 1 - map.DayLightFactor; } else if (map.Schema == ColorSchema.White) { size *= 2; } return(size); }
/// <summary> /// Does the rendering logic /// </summary> /// <param name="map">Map instance</param> public override void Render(IMapContext map) { if (IsMeasureToolOn && map.MousePosition != null) { double coeff = map.DiagonalCoefficient(); List <PointF> points = new List <PointF>(); for (int f = 0; f <= 10; f++) { CrdsHorizontal h = Angle.Intermediate(map.MousePosition, MeasureOrigin, f / 10.0); points.Add(map.Project(h)); if (Angle.Separation(h, map.Center) > map.ViewAngle * coeff) { break; } } if (points.Count > 1) { map.Graphics.DrawCurve(new Pen(map.GetColor(Color.White)), points.ToArray()); double angle = Angle.Separation(map.MousePosition, MeasureOrigin); PointF p = map.Project(map.MousePosition); map.Graphics.DrawString(Formatters.MeasuredAngle.Format(angle), fontAngleValue, new SolidBrush(map.GetColor(Color.White)), p.X + 5, p.Y + 5); } } }
public override void Draw(IMapContext map, ISettings settings, DeepSky ds) { if (map.ViewAngle <= Renderer.minZoom) { base.Draw(map, settings, ds); } }
private void DrawLabels(IMapContext map, Track track) { var brushLabel = new SolidBrush(track.Color); double trackStep = track.Step; double stepLabels = track.LabelsStep.TotalDays; double coeff = map.DiagonalCoefficient(); int each = (int)(stepLabels / trackStep); double jd = track.From; for (int i = 0; i < track.Points.Count; i++) { if (i % each == 0 || i == track.Points.Count - 1) { var tp = track.Points[i]; double ad = Angle.Separation(tp.Horizontal, map.Center); if (ad < map.ViewAngle * coeff) { PointF p = map.Project(tp.Horizontal); if (!map.IsOutOfScreen(p)) { map.Graphics.FillEllipse(brushLabel, p.X - 2, p.Y - 2, 4, 4); map.DrawObjectCaption(fontLabel, brushLabel, Formatters.DateTime.Format(new Date(jd, map.GeoLocation.UtcOffset)), p, 4); } } } jd += trackStep; } }
public override void Render(IMapContext map) { if (!settings.Get <bool>("DeepSky")) { return; } var allDeepSkies = deepSkyCalc.DeepSkies; bool isGround = settings.Get <bool>("Ground"); brushCaption = new SolidBrush(map.GetColor("ColorDeepSkyLabel")); int alpha = Math.Max(0, Math.Min((int)(k * map.ViewAngle + b), 255)); Color colorOutline = map.GetColor("ColorDeepSkyOutline"); penOutlineSolid = new Pen(Color.FromArgb(alpha, colorOutline)); penOutlineDashed = new Pen(Color.FromArgb(alpha, colorOutline)); penOutlineDashed.DashStyle = DashStyle.Dash; var deepSkies = allDeepSkies.Where(ds => !ds.Status.IsEmpty() && Angle.Separation(map.Center, ds.Horizontal) < map.ViewAngle); if (isGround) { deepSkies = deepSkies.Where(ds => ds.Horizontal.Altitude + ds.Semidiameter / 3600 > 0); } foreach (var ds in deepSkies) { drawingHandlers[ds.Status].Draw(map, settings, ds); } }
public override void Render(IMapContext map) { Graphics g = map.Graphics; bool isGround = settings.Get <bool>("Ground"); bool showNovae = settings.Get("Stars") && settings.Get <bool>("Novae"); if (!showNovae) { return; } var novae = calc.Novae.Where(m => Angle.Separation(map.Center, m.Horizontal) < map.ViewAngle); if (isGround) { novae = novae.Where(m => m.Horizontal.Altitude >= 0); } var font = SystemFonts.DefaultFont; var brush = new SolidBrush(map.Schema == ColorSchema.White ? Color.Black : Color.White); foreach (var star in novae) { float diam = map.GetPointSize(star.Mag); if ((int)diam > 0) { PointF p = map.Project(star.Horizontal); if (!map.IsOutOfScreen(p)) { if (map.Schema == ColorSchema.White) { g.FillEllipse(Brushes.White, p.X - diam / 2 - 1, p.Y - diam / 2 - 1, diam + 2, diam + 2); } g.FillEllipse(brush, p.X - diam / 2, p.Y - diam / 2, diam, diam); map.AddDrawnObject(star); } } } if (settings.Get <bool>("StarsLabels") && settings.Get <bool>("NovaeLabels") && map.ViewAngle <= limitAllNames) { brushStarNames = new SolidBrush(map.GetColor("ColorStarsLabels")); foreach (var nova in novae) { float diam = map.GetPointSize(nova.Mag); if ((int)diam > 0) { PointF p = map.Project(nova.Horizontal); if (!map.IsOutOfScreen(p)) { DrawStarName(map, p, nova, diam); } } } } }
private void TestBook(IMapContext context, int n) { var large = Book.Factory <Book, Genre, Page, Headnote, Footnote>(n, x => (Genre)x); var json = context.ToJson(large); var newLarge = context.To <Book>(json); AssertBook(large, newLarge); }
private bool IsSegmentContainsBody(IMapContext map, ICollection <CelestialPoint> segment, Track track) { int firstIndex = track.Points.IndexOf(segment.First()); int lastIndex = track.Points.IndexOf(segment.Last()); double from = (double)firstIndex / (track.Points.Count - 1) * track.Duration + track.From; double to = (double)lastIndex / (track.Points.Count - 1) * track.Duration + track.From; return(map.JulianDay > from && map.JulianDay < to); }
// Ctor : provides specific cells and mode (combat or not) public PathFinder(IMapContext map, IEnumerable<Cell> cells, bool fight) { _map = map; _isInFight = fight; _cells = new CellInfo[_map.Cells.Count]; foreach (Cell cell in cells) _cells[cell.Id] = new CellInfo(cell); PathPacker = new MapMovement(_cells); }
public Pathfinder(Map map, IMapContext context, bool throughEntities = true, bool useLogNodeSearch = false) { m_map = map; m_context = context; m_throughEntities = throughEntities; // the dofus client use a bad linear algorithm to find the closest node. // if we use an other sort method the result may be different m_useLogNodeSearch = useLogNodeSearch; }
/// <summary> /// Build a Path instance from the keys sent by the client /// </summary> /// <param name="map"></param> /// <param name="keys"></param> /// <returns></returns> public static Path BuildFromClientCompressedPath(IMapContext map, IEnumerable <short> keys) { IEnumerable <PathElement> path = (from key in keys let cellId = key& 4095 let direction = (DirectionsEnum)((key >> 12) & 7) select new PathElement(map.Cells[cellId], direction)); return(new Path(map, path)); }
public MapRepository(IMapContext context) { this.context = context; using (var mysqlContext = new MapMSSQLContext()) { // Creates the database if not exists mysqlContext.Database.EnsureCreated(); mysqlContext.SaveChanges(); } }
// Ctor : provides Map and mode (combat or not). Beware, use a Fight context un fight, and a Map out of fights public PathFinder(IMapContext map, bool fight) { Debug.Assert(fight && map is Fight || !fight && map is IMap); _isInFight = fight; _map = map; _cells = new CellInfo[map.Cells.Count]; for (int i = 0; i < map.Cells.Count; i++) _cells[i] = new CellInfo(map.Cells[i]); PathPacker = new MapMovement(_cells); }
/// <summary> /// Gets drawing rotation of image, measured clockwise from /// a point oriented to top of the screen towards North ecliptic pole point /// </summary> /// <param name="ecl">Ecliptical coordinates of a central point of a body.</param> /// <returns></returns> public static float GetRotationTowardsEclipticPole(this IMapContext map, CrdsEcliptical ecl) { // Coordinates of center of a body (image) to be rotated PointF p = map.Project(ecl.ToEquatorial(map.Epsilon).ToHorizontal(map.GeoLocation, map.SiderealTime)); // Point directed to North ecliptic pole PointF pNorth = map.Project((ecl + new CrdsEcliptical(0, 1)).ToEquatorial(map.Epsilon).ToHorizontal(map.GeoLocation, map.SiderealTime)); // Clockwise rotation return(LineInclinationY(p, pNorth)); }
/// <summary> /// Draws nova name /// </summary> private void DrawStarName(IMapContext map, PointF point, Nova nova, float diam) { var fontStarNames = settings.Get <Font>("StarsLabelsFont"); // Star has proper name if (map.ViewAngle < limitAllNames && settings.Get <bool>("StarsProperNames") && nova.ProperName != null) { map.DrawObjectCaption(fontStarNames, brushStarNames, nova.ProperName, point, diam); return; } }
// Ctor : provides specific cells and mode (combat or not) public PathFinder(IMapContext map, IEnumerable <Cell> cells, bool fight) { _map = map; _isInFight = fight; _cells = new CellInfo[_map.Cells.Count]; foreach (Cell cell in cells) { _cells[cell.Id] = new CellInfo(cell); } PathPacker = new MapMovement(_cells); }
public override void Render(IMapContext map) { if (settings.Get <bool>("ConstBorders")) { RenderBorders(map); } if (settings.Get <bool>("ConstLabels")) { RenderConstLabels(map); } }
/// <summary> /// Gets drawing rotation of image, measured clockwise from /// a point oriented to top of the screen towards North celestial pole point /// </summary> /// <param name="eq">Equatorial coordinates of a central point of a body.</param> /// <returns></returns> public static float GetRotationTowardsNorth(this IMapContext map, CrdsEquatorial eq) { // Coordinates of center of a body (image) to be rotated PointF p = map.Project(eq.ToHorizontal(map.GeoLocation, map.SiderealTime)); // Point directed to North celestial pole PointF pNorth = map.Project((eq + new CrdsEquatorial(0, 1)).ToHorizontal(map.GeoLocation, map.SiderealTime)); // Clockwise rotation return(LineInclinationY(p, pNorth)); }
// Ctor : provides Map and mode (combat or not). Beware, use a Fight context un fight, and a Map out of fights public PathFinder(IMapContext map, bool fight) { Debug.Assert(fight && map is Fight || !fight && map is IMap); _isInFight = fight; _map = map; _cells = new CellInfo[map.Cells.Count]; for (int i = 0; i < map.Cells.Count; i++) { _cells[i] = new CellInfo(map.Cells[i]); } PathPacker = new MapMovement(_cells); }
private Color GetColor(IMapContext map, char spClass) { if (map.Schema == ColorSchema.White) { return(Color.Black); } if (settings.Get("StarsColors")) { switch (spClass) { case 'O': case 'W': starColor = Color.LightBlue; break; case 'B': starColor = Color.LightCyan; break; case 'A': starColor = Color.White; break; case 'F': starColor = Color.LightYellow; break; case 'G': starColor = Color.Yellow; break; case 'K': starColor = Color.Orange; break; case 'M': starColor = Color.OrangeRed; break; default: starColor = Color.White; break; } } else { starColor = Color.White; } return(map.GetColor(starColor, Color.Transparent)); }
public static void Rotate(this IMapContext map, PointF p, double angle) { map.Graphics.TranslateTransform(p.X, p.Y); if (map.IsInverted) { angle = -angle; } if (map.IsMirrored) { angle = -angle; } map.Graphics.RotateTransform((float)angle); }
private bool MagFilter(IMapContext map, float mag) { if (mag > map.MagLimit) { return(false); } if ((int)map.GetPointSize(mag) == 0) { return(false); } return(true); }
public static void Flip(this IMapContext map) { var transformMatrix = map.Graphics.Transform; if (map.IsMirrored) { transformMatrix.Multiply(new Matrix(-1, 0, 0, 1, 0, 0)); } if (map.IsInverted) { transformMatrix.Multiply(new Matrix(1, 0, 0, -1, 0, 0)); } map.Graphics.Transform = transformMatrix; }
public override void Render(IMapContext map) { Graphics g = map.Graphics; bool isGround = settings.Get <bool>("Ground"); bool isLabels = settings.Get <bool>("StarsLabels"); Brush brushNames = new SolidBrush(map.GetColor("ColorStarsLabels")); if (map.MagLimit > 8 && settings.Get <bool>("Stars") && settings.Get <bool>("Tycho2")) { Brush brushStar = GetColor(map); PrecessionalElements pe = Precession.ElementsFK5(map.JulianDay, Date.EPOCH_J2000); var eq0 = map.Center.ToEquatorial(map.GeoLocation, map.SiderealTime); CrdsEquatorial eq = Precession.GetEquatorialCoordinates(eq0, pe); SkyContext context = new SkyContext(map.JulianDay, map.GeoLocation); tycho2.LockedStar = map.LockedObject as Tycho2Star; tycho2.SelectedStar = map.SelectedObject as Tycho2Star; var stars = tycho2.GetStars(context, eq, map.ViewAngle, m => MagFilter(map, m)); foreach (var star in stars) { if (!isGround || star.Horizontal.Altitude > 0) { PointF p = map.Project(star.Horizontal); if (!map.IsOutOfScreen(p)) { float size = map.GetPointSize(star.Magnitude); if (map.Schema == ColorSchema.White) { g.FillEllipse(Brushes.White, p.X - size / 2 - 1, p.Y - size / 2 - 1, size + 2, size + 2); } g.FillEllipse(brushStar, p.X - size / 2, p.Y - size / 2, size, size); if (isLabels && map.ViewAngle < 1 && size > 3) { map.DrawObjectCaption(fontNames, brushNames, star.ToString(), p, size); } map.AddDrawnObject(star); } } } } }
/// <summary> /// Draws star name /// </summary> private void DrawStarName(IMapContext map, PointF point, Star s, float diam) { var fontStarNames = settings.Get <Font>("StarsLabelsFont"); // Star has proper name if (map.ViewAngle < limitProperNames && settings.Get <bool>("StarsProperNames") && s.ProperName != null) { map.DrawObjectCaption(fontStarNames, brushStarNames, s.ProperName, point, diam); return; } // Star has Bayer name (greek letter) if (map.ViewAngle < limitBayerNames) { string bayerName = s.BayerName; if (bayerName != null) { map.DrawObjectCaption(fontStarNames, brushStarNames, bayerName, point, diam); return; } } // Star has Flamsteed number if (map.ViewAngle < limitFlamsteedNames) { string flamsteedNumber = s.FlamsteedNumber; if (flamsteedNumber != null) { map.DrawObjectCaption(fontStarNames, brushStarNames, flamsteedNumber, point, diam); return; } } // Star has variable id if (map.ViewAngle < limitVarNames && s.VariableName != null) { string varName = s.VariableName.Split(' ')[0]; if (!varName.All(char.IsDigit)) { map.DrawObjectCaption(fontStarNames, brushStarNames, varName, point, diam); return; } } // Star doesn't have any names if (map.ViewAngle < 2) { map.DrawObjectCaption(fontStarNames, brushStarNames, $"HR {s.Number}", point, diam); } }
/// <summary> /// Constructs the Path instance from the complete path as a list of cell /// </summary> /// <param name="map">Current map</param> /// <param name="path">Complete path</param> public Path(IMapContext map, IEnumerable<Cell> path) { Map = map; m_cellsPath = path.ToArray(); }
/// <summary> /// Get an empty path with the current cell /// </summary> /// <param name="map"></param> /// <param name="startCell"></param> /// <returns></returns> public static Path GetEmptyPath(IMapContext map, Cell startCell) { return new Path(map, new[] { startCell }); }
public ContextActor TryGetSender(IMapContext context) { return context.Actors.FirstOrDefault(entry => ( entry is INamed && ( entry as INamed ).Name == SenderName ) || entry.Id == SenderId); }
/// <summary> /// Constructs the Path instance from the compressed path as a list of PathElement /// </summary> /// <param name="map">Current map</param> /// <param name="compressedPath">Compressed Path</param> private Path(IMapContext map, IEnumerable<PathElement> compressedPath) { Map = map; m_compressedPath = compressedPath.ToArray(); m_cellsPath = BuildCompletePath(); }
/// <summary> /// Build a Path instance from the keys sent by the client /// </summary> /// <param name="map"></param> /// <param name="keys"></param> /// <returns></returns> public static Path BuildFromClientCompressedPath(IMapContext map, IEnumerable<short> keys) { IEnumerable<PathElement> path = (from key in keys let cellId = key & 4095 let direction = (DirectionsEnum)((key >> 12) & 7) select new PathElement(map.Cells[cellId], direction)); return new Path(map, path); }