private void RefreshControl()
{
if (_refreshInProgress)
{
return;
}
var timeDrawScreen = Stopwatch.StartNew();
_refreshInProgress = true;
Image image = new Bitmap(Width, Height);
var graphics = Graphics.FromImage(image);
graphics.CompositingQuality = CompositingQuality.HighQuality;
graphics.InterpolationMode = InterpolationMode.Bicubic;
graphics.SmoothingMode = SmoothingMode.AntiAlias;
graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
_screenParameters =
new ScreenParameters(Width, Height, (int)_centerScreenPosition.X, (int)_centerScreenPosition.Y)
{
GraphicSurface = graphics
};
DrawTacticalMapScreen(_screenParameters, _environment);
BackgroundImage = image;
_refreshInProgress = false;
Logger.Debug($"Refresh space map for turn '{_environment.Session.Turn}' was finished successful. Time {timeDrawScreen.Elapsed.TotalMilliseconds} ms.");
}
public void PointOnScreenTest()
{
var screen = new ScreenParameters(1920, 1080);
Assert.AreEqual(true, screen.PointInVisibleScreen(10400, 10400));
Assert.AreEqual(false, screen.PointInVisibleScreen(9400, 12400));
}
public static PointF ToMapCoordinates(ScreenParameters screenParameters, PointF celestialObjectPosition)
{
var relativeX = screenParameters.CenterScreenOnMap.X - screenParameters.Width / 2 + celestialObjectPosition.X;
var relativeY = screenParameters.CenterScreenOnMap.Y - screenParameters.Height / 2 + celestialObjectPosition.Y;
return(new PointF(relativeX, relativeY));
}
public void PositiveConstructorTest(double height, double width, double thikness)
{
ScreenParameters screenParameters = new ScreenParameters(height, width, thikness);
Assert.AreEqual(screenParameters.Height, height);
Assert.AreEqual(screenParameters.Width, width);
Assert.AreEqual(screenParameters.Thikness, thikness);
}
/// <summary> Creates a new instance of the Engine class with the given parameters. </summary>
public Engine(ScreenParameters screenParameters, ViewportParameters viewportParameters, RenderParameters renderParameters)
{
_screenParameters = screenParameters;
_viewportParameters = viewportParameters;
_renderParameters = renderParameters;
_cameraConverter = new CameraConverter(_screenParameters, _viewportParameters);
}
public void Initialize()
{
if (DebugTools.IsInDesignMode())
{
return;
}
_screenParameters = new ScreenParameters(Width, Height, _centerScreenPosition.X, _centerScreenPosition.Y);
Scheduler.Instance.ScheduleTask(100, 100, RefreshControl);
}
internal CameraConverter(ScreenParameters screenParameters, ViewportParameters viewportParameters)
{
_viewportParameters = viewportParameters;
_screenParameters = screenParameters;
_halfScreenWidth = _screenParameters.Width / 2d;
_halfScreenHeight = _screenParameters.Height / 2d;
_viewportToScreenRatioX = _viewportParameters.Width / _screenParameters.Width;
_viewportToScreenRatioY = _viewportParameters.Height / _screenParameters.Height;
}
public static void DrawSpaceShipMovement(Graphics graphics, GameSession gameSession,
SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep,
MovementLog history,
ScreenParameters screenParameters)
{
foreach (var celestialObject in gameSession.SpaceMap.CelestialObjects.Where(o => screenParameters.PointInVisibleScreen(o.PositionX, o.PositionY)))
{
var historyMovement = history.GetHistoryForCelestialObject(celestialObject.Id);
var granularTurnPositions = turnMapInformation.Values.Where(o => o.Id == celestialObject.Id);
DrawTrajectory(graphics, celestialObject, historyMovement, turnMapInformation, turnStep, Color.FromArgb(200, 200, 44), screenParameters);
}
}
private void DrawTrajectory(GameSession gameSession, Graphics graphics, ScreenParameters screenParameters)
{
var spaceShip = gameSession.GetPlayerSpaceShip();
foreach (var command in gameSession.Commands)
{
if (command.CelestialObjectId == spaceShip.Id)
{
var targetObject = gameSession.GetCelestialObject(command.TargetCelestialObjectId);
DrawTacticalMap.DrawTrajectory(gameSession, spaceShip, targetObject, graphics, screenParameters);
}
}
}
public static void CommonErrorDialog(
string title, string main, string message)
{
TaskDialog td = new TaskDialog();
td.Caption = title;
td.InstructionText = main;
td.Text = message;
td.Icon = TaskDialogStandardIcon.Error;
td.Cancelable = false;
td.OwnerWindowHandle = ScreenParameters.GetWindowHandle(Common.GetCurrentWindow());
td.StartupLocation = TaskDialogStartupLocation.CenterOwner;
td.Opened += Common.TaskDialog_Opened;
td.Show();
}
private void Initialization()
{
Logger.Info("Celestial map control - Initialization.");
_screenParameters = new ScreenParameters(Width, Height, _centerScreenPosition.X, _centerScreenPosition.Y);
if (DebugTools.IsInDesignMode())
{
return;
}
crlRefreshMap = new Timer();
crlRefreshMap.Elapsed += Event_Refresh;
crlRefreshMap.Interval = 100;
crlRefreshMap.Enabled = true;
}
public static TaskDialogResult CommonWarningDialog(string title,
string main, string message, TaskDialogStandardButtons buttons =
TaskDialogStandardButtons.Ok | TaskDialogStandardButtons.Cancel)
{
TaskDialog td = new TaskDialog();
td.Caption = title;
td.InstructionText = main;
td.Text = message;
td.Icon = TaskDialogStandardIcon.Warning;
td.Cancelable = false;
td.StandardButtons = buttons;
td.OwnerWindowHandle = ScreenParameters.GetWindowHandle(Common.GetCurrentWindow());
td.StartupLocation = TaskDialogStartupLocation.CenterOwner;
td.Opened += Common.TaskDialog_Opened;
return(td.Show());
}
private void Visualize_Click(object sender, RoutedEventArgs e)
{
if (!_visualizationOpen)
{
var screenMirrorAlgorithm = OptionsViewModel.ScreenMirrorAlgorithmMapping[OptionsViewModel.SelectedScreenMirrorAlgorithm];
var monitorIndex = Array.IndexOf(_monitorNames.ToArray(), OptionsViewModel.SelectedMonitor);
var device = UserSettings.Settings.Devices.FirstOrDefault(d => d.Name == OptionsViewModel.SelectedDevice);
var visualizeWindow = new ScreenMirrorVisualizationWindow(device, monitorIndex, screenMirrorAlgorithm);
visualizeWindow.Show();
var scale = ScreenParameters.GetScreenScaleFactorNonDpiAware(visualizeWindow);
visualizeWindow.Visualize(scale);
visualizeWindow.Closed += (sender2, eventArgs) => _visualizationOpen = false; //Set the bool to false when the window is closed
_visualizationOpen = true;
}
}
private void Initialization()
{
Logger.Info(TraceMessage.Execute(this, "Celestial map control - Initialization"));
_screenParameters = new ScreenParameters(Width, Height, _centerScreenPosition.X, _centerScreenPosition.Y);
if (DebugTools.IsInDesignMode())
{
return;
}
crlRefreshMap = new MicroTimer();
crlRefreshMap.MicroTimerElapsed += Event_Refresh;
var intervalMilliseconds = 50;
crlRefreshMap.Interval = 1000 * intervalMilliseconds; // 1000 = 1ms
crlRefreshMap.Enabled = true;
_screenParameters.DrawInterval = 1000 / intervalMilliseconds;
}
public static void DrawMissiles(Graphics graphics, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, ScreenParameters screenParameters)
{
foreach (GranularObjectInformation turnInformation in turnMapInformation.Values)
{
var currentObject = turnInformation.CelestialObject;
var location = GetCurrentLocation(turnMapInformation, currentObject, turnStep, screenParameters.DrawInterval);
if ((CelestialObjectTypes)currentObject.Classification != CelestialObjectTypes.Missile)
{
continue;
}
var a = "Missile";
var b = gameSession.GetSpaceShipCommands(currentObject.Id);
foreach (var command in b)
{
if (command.Type == CommandTypes.Fire)
{
var targetPoint = gameSession.GetCelestialObject(command.TargetCelestialObjectId);
}
}
}
}
public static void DrawSpaceShipMovement(Graphics graphics, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, FixedSizedQueue <SortedDictionary <int, GranularObjectInformation> > history, ScreenParameters screenParameters)
{
var playerSpaceship = gameSession.GetPlayerSpaceShip();
#region Direction forward
foreach (var turnInformation in turnMapInformation.Values)
{
if (playerSpaceship.Id == turnInformation.CelestialObject.Id)
{
continue;
}
if (gameSession.GetCelestialObject(turnInformation.CelestialObject.Id).IsSpaceship() == false)
{
return;
}
var currentObject = turnInformation.CelestialObject;
var location = GetCurrentLocation(turnMapInformation, currentObject, turnStep, screenParameters.DrawInterval).ToScreen(screenParameters);
var step = SpaceMapTools.Move(location, 4000, 0, currentObject.Direction);
graphics.DrawLine(new Pen(Color.FromArgb(24, 24, 24)), step.PointFrom, step.PointTo);
}
#endregion
#region Direction back
foreach (var turnInformation in turnMapInformation.Values)
{
if (turnInformation.CelestialObject.IsSpaceship() == false)
{
continue;
}
var currentObject = turnInformation.CelestialObject;
var points = new List <PointF>();
var data = history.GetData();
var turnId = 0;
foreach (var turnData in data)
{
var stepId = 0;
foreach (var wayPoint in turnData[currentObject.Id].WayPoints.Values)
{
if (turnId > 0 || stepId > turnStep)
{
points.Add(wayPoint.ToScreen(screenParameters));
}
stepId++;
}
turnId++;
}
if (points.Count > 2)
{
graphics.DrawCurve(new Pen(Color.FromArgb(200, 44, 44))
{
DashStyle = DashStyle.Dash
}, points.ToArray());
}
}
#endregion
}
public static void DrawExplosions(Graphics graphics, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, ScreenParameters screenParameters)
{
foreach (GranularObjectInformation turnInformation in turnMapInformation.Values)
{
var currentObject = turnInformation.CelestialObject;
if ((CelestialObjectTypes)currentObject.Classification != CelestialObjectTypes.Explosion)
{
continue;
}
var explosion = (Explosion)currentObject;
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, explosion.GetLocation());
graphics.FillEllipse(new SolidBrush(Color.IndianRed),
screenCoordinates.X - explosion.Radius,
screenCoordinates.Y - explosion.Radius,
explosion.Radius * 2,
explosion.Radius * 2
);
graphics.DrawEllipse(new Pen(Color.Red, 1),
screenCoordinates.X - explosion.Radius,
screenCoordinates.Y - explosion.Radius,
explosion.Radius * 2,
explosion.Radius * 2
);
// Explosive epicenter
graphics.FillEllipse(new SolidBrush(Color.Red),
screenCoordinates.X - 2,
screenCoordinates.Y - 2,
4,
4
);
}
}
public static void DrawChangeMovementDestination(Graphics graphics, GameSession gameSession, PointF pointInSpace, SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, ScreenParameters screenParameters)
{
if (pointInSpace != PointF.Empty)
{
var playerSpaceship = gameSession.GetPlayerSpaceShip();
var location = GetCurrentLocation(turnMapInformation, playerSpaceship, turnStep, screenParameters.DrawInterval);
var results = Approach.Calculate(location, pointInSpace, playerSpaceship.Direction, playerSpaceship.Speed);
if (results.IsCorrect)
{
DrawCurveTrajectory(graphics, results.Trajectory, Color.FromArgb(44, 44, 44), screenParameters, true);
}
}
}
public static void DrawScreen(Graphics graphics, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, ScreenParameters screenParameters)
{
foreach (GranularObjectInformation turnInformation in turnMapInformation.Values)
{
var currentObject = turnInformation.CelestialObject;
var location = GetCurrentLocation(turnMapInformation, currentObject, turnStep, screenParameters.DrawInterval);
var celestialObjectType = (CelestialObjectTypes)currentObject.Classification;
switch (celestialObjectType)
{
case CelestialObjectTypes.Asteroid:
// Regular asteroid
DrawTacticalMap.DrawAsteroid(currentObject, location, graphics, screenParameters);
break;
case CelestialObjectTypes.SpaceshipPlayer:
case CelestialObjectTypes.SpaceshipNpcEnemy:
case CelestialObjectTypes.SpaceshipNpcFriend:
case CelestialObjectTypes.SpaceshipNpcNeutral:
//if (mapSettings.IsDrawSpaceshipInformation)
// DrawTacticalMap.DrawSpaceshipInformation(currentObject, location, graphics, _screenParameters);
DrawTacticalMap.DrawSpaceship(currentObject, location, graphics, screenParameters);
break;
case CelestialObjectTypes.Missile:
DrawTacticalMap.DrawMissile(currentObject, location, graphics, screenParameters);
break;
}
if (screenParameters.Settings.IsDrawCelestialObjectDirections)
{
try
{
DrawTacticalMap.DrawCelestialObjectDirection(currentObject, location, graphics, screenParameters);
}
catch (Exception e)
{
Logger.Error(e.Message);
}
}
if (screenParameters.Settings.IsDrawCelestialObjectCoordinates)
{
if (currentObject.Classification > 0)
{
DrawTacticalMap.DrawCelestialObjectCoordinates(currentObject, graphics, screenParameters);
}
}
}
}
public static void DrawPointInSpace(ICelestialObject celestialObject, ICelestialObject spaceShip, Graphics graphics, ScreenParameters screenParameters)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(celestialObject.PositionX, celestialObject.PositionY));
var radarLinePen = new Pen(Color.FromArgb(60, 60, 60), 1);
graphics.DrawLine(radarLinePen, screenCoordinates.X - 15, screenCoordinates.Y, screenCoordinates.X + 15, screenCoordinates.Y);
graphics.DrawLine(radarLinePen, screenCoordinates.X, screenCoordinates.Y - 15, screenCoordinates.X, screenCoordinates.Y + 15);
graphics.FillEllipse(new SolidBrush(Color.Black), screenCoordinates.X - 5, screenCoordinates.Y - 5, 10, 10);
}
public static void DrawActiveModule(Graphics graphics, CelestialObjectTypes activeModule, PointF mousePosition, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> granularTurnInformation, int turnStep, ScreenParameters screenParameters)
{
var playerSpaceship = gameSession.GetPlayerSpaceShip();
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(playerSpaceship.PositionX, playerSpaceship.PositionY));
var mouseCoordinatesInternal = OutlandAreaCommon.Tools.ToRelativeCoordinates(mousePosition, screenParameters.Center);
var mouseMapCoordinates = OutlandAreaCommon.Tools.ToTacticalMapCoordinates(mouseCoordinatesInternal, screenParameters.CenterScreenOnMap);
switch (activeModule)
{
case CelestialObjectTypes.PointInMap:
break;
case CelestialObjectTypes.Missile:
var radarLinePen = new Pen(Color.FromArgb(60, 60, 60), 1);
graphics.DrawLine(radarLinePen, screenCoordinates.X, screenCoordinates.Y, mousePosition.X, mousePosition.Y);
var missile = new Missile
{
PositionY = mouseMapCoordinates.Y,
PositionX = mouseMapCoordinates.X
};
DrawTacticalMap.DrawPreTarget(missile, graphics, screenParameters);
break;
case CelestialObjectTypes.SpaceshipPlayer:
break;
case CelestialObjectTypes.SpaceshipNpcNeutral:
break;
case CelestialObjectTypes.SpaceshipNpcEnemy:
break;
case CelestialObjectTypes.SpaceshipNpcFriend:
break;
case CelestialObjectTypes.Asteroid:
break;
case CelestialObjectTypes.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
private static void DrawCurveTrajectory(Graphics graphics, List <SpaceMapObjectLocation> results, Color color, ScreenParameters screenParameters, bool isDrawArrow = false)
{
var points = new List <PointF>();
foreach (var position in results)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(position.Coordinates.X, position.Coordinates.Y));
points.Add(new PointF(screenCoordinates.X, screenCoordinates.Y));
}
var lastPoint = results[results.Count - 1];
var pointInSpaceCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(lastPoint.Coordinates.X, lastPoint.Coordinates.Y));
var step = SpaceMapTools.Move(pointInSpaceCoordinates, 4000, 0, lastPoint.Direction);
if (points.Count > 2)
{
graphics.DrawCurve(new Pen(color), points.ToArray());
}
graphics.DrawLine(new Pen(color), step.PointFrom, step.PointTo);
var move = SpaceMapTools.Move(pointInSpaceCoordinates, 0, 0, lastPoint.Direction);
SpaceMapGraphics.DrawArrow(graphics, move, color, 12);
#region Show linear movement
//foreach (var position in results)
//{
// var screenCoordinates = UI.ToScreenCoordinates(_screenParameters, new PointF(position.Coordinates.X, position.Coordinates.Y));
// if (position.Status == MovementType.Linear)
// {
// graphics.DrawEllipse(new Pen(Color.Brown, 1), screenCoordinates.X, screenCoordinates.Y, 2, 2 );
// }
//}
#endregion
}
//------------------------------------------------------------------------------------
private static void DrawTrajectory(Graphics graphics, ICelestialObject celestialObject, IEnumerable <SpaceMapObjectLocation> results,
SortedDictionary <int, GranularObjectInformation> turnMapInformation, int turnStep, Color color, ScreenParameters screenParameters)
{
var points = new List <PointF>();
var startDrawingPosition = new PointF(-10000, -10000);
var initialDrawingPosition = new PointF(-10000, -10000);
var iteration = -1;
if (celestialObject.Classification == CelestialObjectTypes.Missile.ToInt())
{
return;
}
foreach (var position in results)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(position.Coordinates.X, position.Coordinates.Y));
iteration++;
if (iteration == 0)
{
initialDrawingPosition = new PointF(screenCoordinates.X, screenCoordinates.Y);
continue;
}
if (iteration == 1)
{
startDrawingPosition = new PointF(screenCoordinates.X, screenCoordinates.Y);
}
points.Add(new PointF(screenCoordinates.X, screenCoordinates.Y));
}
var currentPosition = UI.ToScreenCoordinates(screenParameters, GetCurrentLocation(turnMapInformation, celestialObject, turnStep,
screenParameters.DrawInterval));
graphics.DrawLine(new Pen(color)
{
DashStyle = DashStyle.Dash
}, initialDrawingPosition, startDrawingPosition);
points.Add(currentPosition);
if (points.Count > 2)
{
graphics.DrawCurve(new Pen(color)
{
DashStyle = DashStyle.Dash
}, points.ToArray());
}
}
public static void DrawSpaceShipTrajectories(Graphics graphics, GameSession gameSession, SortedDictionary <int, GranularObjectInformation> turnMapInformation, ScreenParameters screenParameters)
{
var playerSpaceship = gameSession.GetPlayerSpaceShip();
var commands = gameSession.GetSpaceShipCommands(playerSpaceship.Id);
foreach (var command in commands)
{
switch (command.Type)
{
case CommandTypes.MoveForward:
break;
case CommandTypes.Fire:
break;
case CommandTypes.AlignTo:
var target = gameSession.GetCelestialObject(command.TargetCelestialObjectId).GetLocation();
var results = Approach.Calculate(playerSpaceship.GetLocation(), target, playerSpaceship.Direction, playerSpaceship.Speed);
DrawCurveTrajectory(graphics, results.Trajectory, Color.FromArgb(45, 100, 145), screenParameters);
break;
case CommandTypes.Orbit:
break;
}
}
}
public static void DrawDestinationPoint(Graphics graphics, GameSession gameSession, ICelestialObject point, ScreenParameters screenParameters)
{
if (point == null)
{
return;
}
var playerSpaceship = gameSession.GetPlayerSpaceShip();
DrawTacticalMap.DrawPointInSpace(point, playerSpaceship, graphics, screenParameters);
}
public static void DrawMouseMoveObject(Graphics graphics, GameSession gameSession, ICelestialObject celestialObject, SortedDictionary <int, GranularObjectInformation> granularTurnInformation, int turnStep, ScreenParameters screenParameters)
{
if (celestialObject == null)
{
return;
}
var location = GetCurrentLocation(granularTurnInformation, celestialObject, turnStep, screenParameters.DrawInterval);
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(location.X, location.Y));
var rectangle = new RectangleF(screenCoordinates.X + 30, screenCoordinates.Y + 30, 100, 40);
graphics.FillRectangle(new SolidBrush(Color.DimGray), rectangle);
graphics.DrawRectangle(new Pen(Color.Gray), rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
graphics.DrawRectangle(new Pen(Color.Black), rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
graphics.DrawLine(new Pen(Color.Gray), rectangle.X, rectangle.Y, screenCoordinates.X, screenCoordinates.Y);
}
public static void DrawPreTarget(ICelestialObject celestialObject, Graphics graphics, ScreenParameters screenParameters)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(celestialObject.PositionX, celestialObject.PositionY));
var radarLinePen = new Pen(Color.FromArgb(60, 60, 60), 1);
graphics.DrawEllipse(radarLinePen, screenCoordinates.X - 12, screenCoordinates.Y - 12, 24, 24);
graphics.DrawEllipse(radarLinePen, screenCoordinates.X - 22, screenCoordinates.Y - 22, 44, 44);
graphics.DrawEllipse(radarLinePen, screenCoordinates.X - 32, screenCoordinates.Y - 32, 64, 64);
graphics.DrawLine(radarLinePen, screenCoordinates.X - 45, screenCoordinates.Y, screenCoordinates.X + 45, screenCoordinates.Y);
graphics.DrawLine(radarLinePen, screenCoordinates.X, screenCoordinates.Y - 45, screenCoordinates.X, screenCoordinates.Y + 45);
graphics.FillEllipse(new SolidBrush(Color.Black), screenCoordinates.X - 10, screenCoordinates.Y - 10, 20, 20);
}
public static void DrawSelectedObject(Graphics graphics, TacticalMapMode mode, GameSession gameSession, ICelestialObject celestialObject, IEnumerable <ICelestialObject> connectorsSelect, SortedDictionary <int, GranularObjectInformation> granularTurnInformation, int turnStep, ScreenParameters screenParameters)
{
//var location = GetCurrentLocation(granularTurnInformation, celestialObject, turnStep, screenParameters.DrawInterval);
//var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(location.X, location.Y));
//var rectangle = new RectangleF(screenCoordinates.X + 30, screenCoordinates.Y + 30, 100, 40);
//graphics.FillRectangle(new SolidBrush(Color.DimGray), rectangle);
//graphics.DrawRectangle(new Pen(Color.Gray), rectangle.X, rectangle.Y, rectangle.Width, rectangle.Height);
//graphics.DrawRectangle(new Pen(Color.Black), rectangle.X + 1, rectangle.Y + 1, rectangle.Width - 2, rectangle.Height - 2);
//graphics.DrawLine(new Pen(Color.Gray), rectangle.X, rectangle.Y, screenCoordinates.X, screenCoordinates.Y);
}
public static void DrawConnectors(Graphics graphics, GameSession gameSession, IEnumerable <ICelestialObject> connectors, SortedDictionary <int, GranularObjectInformation> granularTurnInformation, int turnStep, ScreenParameters screenParameters)
{
if (connectors == null || !connectors.Any())
{
return;
}
var playerSpaceship = gameSession.GetPlayerSpaceShip();
var connectorPen = new Pen(Color.DimGray);
var objectsInScreenArea = connectors.Where(o => screenParameters.PointInVisibleScreen(o.PositionX, o.PositionY));
foreach (var celestialObject in objectsInScreenArea)
{
var objectLocation = GetCurrentLocation(granularTurnInformation, celestialObject, turnStep, screenParameters.DrawInterval);
var shipLocation = GetCurrentLocation(granularTurnInformation, playerSpaceship, turnStep, screenParameters.DrawInterval);
var directionFromShipToTarget = Coordinates.GetRotation(objectLocation, shipLocation);
var directionFromTargetToShip = Coordinates.GetRotation(shipLocation, objectLocation);
var shipLocationStep = SpaceMapTools.Move(shipLocation, 12, 0, directionFromShipToTarget);
var targetLocationStep = SpaceMapTools.Move(objectLocation, 20, 0, directionFromTargetToShip);
var shipScreenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(shipLocationStep.PointTo.X, shipLocationStep.PointTo.Y));
var objectScreenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(targetLocationStep.PointTo.X, targetLocationStep.PointTo.Y));
var targetScreenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(objectLocation.X, objectLocation.Y));
graphics.DrawLine(connectorPen, shipScreenCoordinates.X, shipScreenCoordinates.Y,
objectScreenCoordinates.X, objectScreenCoordinates.Y);
graphics.DrawEllipse(connectorPen, targetScreenCoordinates.X - 20, targetScreenCoordinates.Y - 20, 40, 40);
}
}
public static void DrawSpaceshipInformation(ICelestialObject celestialObject, Graphics graphics, ScreenParameters screenParameters)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(celestialObject.PositionX, celestialObject.PositionY));
var drawSpaceshipInformationAngle = 0;
var drawSpaceshipInformationShelf = 0;
var pen = new Pen(Color.DimGray, 2);
if (celestialObject.Direction >= 0 && celestialObject.Direction < 90)
{
drawSpaceshipInformationAngle = 135;
drawSpaceshipInformationShelf = 90;
}
if (celestialObject.Direction >= 90 && celestialObject.Direction < 180)
{
drawSpaceshipInformationAngle = 45;
drawSpaceshipInformationShelf = 90;
}
if (celestialObject.Direction >= 180 && celestialObject.Direction < 270)
{
drawSpaceshipInformationAngle = 135;
drawSpaceshipInformationShelf = 90;
}
if (celestialObject.Direction >= 270 && celestialObject.Direction < 360)
{
drawSpaceshipInformationAngle = 45;
drawSpaceshipInformationShelf = 90;
}
var footCoordinates = OutlandAreaCommon.Tools.MoveCelestialObjects(screenCoordinates, DrawSpaceshipInformationLenght, drawSpaceshipInformationAngle);
graphics.DrawLine(pen, screenCoordinates.X, screenCoordinates.Y, footCoordinates.X, footCoordinates.Y);
var shelfCoordinates = OutlandAreaCommon.Tools.MoveCelestialObjects(footCoordinates, DrawSpaceshipInformationShelfLenght, drawSpaceshipInformationShelf);
graphics.DrawLine(pen, footCoordinates.X, footCoordinates.Y, shelfCoordinates.X, shelfCoordinates.Y);
var pointInformationBase = new PointF(footCoordinates.X + 3, footCoordinates.Y);
#region Detail information
graphics.FillRectangle(new SolidBrush(Color.Chartreuse), new RectangleF(pointInformationBase.X, pointInformationBase.Y - 13, 10, 10));
using (var font = new Font("Times New Roman", 10, FontStyle.Bold, GraphicsUnit.Pixel))
{
graphics.DrawString($"{celestialObject.Name}", font, new SolidBrush(Color.WhiteSmoke), new PointF(pointInformationBase.X + 15, pointInformationBase.Y - 13));
}
// TODO: Check size string for draw line length
#endregion
}
