コード例 #1
0
        private void DrawMouseMoveCross(Graphics graphics)
        {
            if (MouseMoveCelestialObject == null)
            {
                return;
            }

            DrawTacticalMap.DrawPreTarget(MouseMoveCelestialObject, graphics, _screenParameters);
        }
コード例 #2
0
ファイル: DrawMapTools.cs プロジェクト: dunvit/Outland-Area
        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);
        }
コード例 #3
0
        private void DrawPointInSpaceCross(Graphics graphics)
        {
            if (_gameSession.SelectedObject == null)
            {
                return;
            }

            var playerShip = _gameSession.GetPlayerSpaceShip();

            DrawTacticalMap.DrawPointInSpace(_gameSession.SelectedObject, playerShip, graphics, _screenParameters);
        }
コード例 #4
0
ファイル: DrawMapTools.cs プロジェクト: dunvit/Outland-Area
        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);
                    }
                }
            }
        }
コード例 #5
0
ファイル: DrawMapTools.cs プロジェクト: dunvit/Outland-Area
        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();
            }
        }
コード例 #6
0
        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);
                }
            }
        }
コード例 #7
0
        public void CalculateLineByAngleTest()
        {
            var result = DrawTacticalMap.CalculateLineByAngle(new PointF(100, 100), 90, 50);

            Assert.AreEqual(result.From, new PointF(150, 100));

            Assert.AreEqual(result.To, new PointF(50, 100));

            result = DrawTacticalMap.CalculateLineByAngle(new PointF(100, 100), 180, 50);

            Assert.AreEqual(result.From, new PointF(100, 150));

            Assert.AreEqual(result.To, new PointF(100, 50));
        }
コード例 #8
0
ファイル: TacticalMap.cs プロジェクト: dunvit/Outland-Area
        private void DrawTacticalMapScreen(IScreenInfo screenParameters, TacticalEnvironment environment)
        {
            DrawTacticalMap.DrawBackGround(screenParameters);

            DrawTacticalMap.DrawExplosions(screenParameters, environment);

            DrawTacticalMap.DrawWeaponAffectedArea(screenParameters, environment);

            DrawTacticalMap.DrawGrid(screenParameters);

            DrawTacticalMap.DrawRadar(screenParameters, environment);

            DrawTacticalMap.DrawAction(screenParameters, environment);

            DrawTacticalMap.DrawCelestialObjects(screenParameters, environment);

            DrawTacticalMap.DrawActiveCelestialObjects(screenParameters, environment);

            DrawTacticalMap.DrawDirections(screenParameters, environment);

            DrawTacticalMap.DrawHistoryTrajectory(screenParameters, environment, _history);
        }
コード例 #9
0
        private void DrawScreen()
        {
            var drawTurn = turn;

            var currentTurnCelestialMapData = DrawTurns[turn] as DrawMapData;

            if (currentTurnCelestialMapData == null)
            {
                return;
            }

            var stopwatch1 = Stopwatch.StartNew();

            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;

            if (_gameSession.SpaceMap.IsEnabled)
            {
                turnCurrentStep++;
                if (turnCurrentStep > turnAllSteps)
                {
                    turnCurrentStep = turnAllSteps;
                }
            }

            DrawCenterScreenCross(graphics);

            DrawMouseMoveCross(graphics);

            DrawPointInSpaceCross(graphics);

            DrawTrajectory(_gameSession, graphics, _screenParameters);

            foreach (DrawMapDataObject dataObject in currentTurnCelestialMapData.GetData().Values)
            {
                if (drawTurn != turn)
                {
                    return;
                }

                var currentObject = dataObject.GetCelestialObject(turn, turnCurrentStep);

                /* classification
                 *  1 - Asteroid
                 *  200 - Spacecraft
                 *  3 - Drone
                 *  4 - Missile
                 */

                switch ((CelestialObjectTypes)currentObject.Classification)
                {
                case CelestialObjectTypes.Asteroid:
                    // Regular asteroid
                    DrawTacticalMap.DrawAsteroid(currentObject, currentObject.GetLocation(), graphics, _screenParameters);
                    break;

                case CelestialObjectTypes.SpaceshipPlayer:
                    if (mapSettings.IsDrawSpaceshipInformation)
                    {
                        DrawTacticalMap.DrawSpaceshipInformation(currentObject, graphics, _screenParameters);
                    }

                    DrawTacticalMap.DrawSpaceship(currentObject, new PointF(currentObject.PositionX, currentObject.PositionY), graphics, _screenParameters);

                    break;

                case CelestialObjectTypes.Missile:
                    DrawTacticalMap.DrawMissile(currentObject, PointF.Empty, graphics, _screenParameters);
                    break;
                }

                if (mapSettings.IsDrawCelestialObjectDirections)
                {
                    try
                    {
                        DrawTacticalMap.DrawCelestialObjectDirection(currentObject, currentObject.GetLocation(), graphics, _screenParameters);
                    }
                    catch (Exception e)
                    {
                        Logger.Error(e.Message);
                    }
                }

                if (mapSettings.IsDrawCelestialObjectCoordinates)
                {
                    if (currentObject.Classification > 0)
                    {
                        DrawTacticalMap.DrawCelestialObjectCoordinates(currentObject, graphics, _screenParameters);
                    }
                }
            }

            stopwatch1.Stop();

            var workTime = stopwatch1.Elapsed.TotalMilliseconds;

            var logInformation = $"[WeyPoints] Turn = {_gameSession.Turn}.{turnCurrentStep} workTime = {workTime} ms";

            Logger.Debug(logInformation);

            using (var font = new Font("Times New Roman", 10, FontStyle.Bold, GraphicsUnit.Pixel))
            {
                graphics.DrawString(logInformation, font, new SolidBrush(Color.WhiteSmoke), new PointF(0, 0));
            }

            BackgroundImage = image;
        }
コード例 #10
0
        private void RefreshControl()
        {
            txtMouseX.Text = MouseCoordinates.X + "";
            txtMouseY.Text = MouseCoordinates.Y + "";

            if (SpacecraftLocation != PointF.Empty)
            {
                txtSpacecraftX.Text = SpacecraftLocation.X + "";
                txtSpacecraftY.Text = SpacecraftLocation.Y + "";
            }

            if (TargetLocation != PointF.Empty)
            {
                txtTargetX.Text = TargetLocation.X + "";
                txtTargetY.Text = TargetLocation.Y + "";
            }

            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;

            var screenParameters =
                new ScreenParameters(Width, Height, Width / 2, Height / 2)
            {
                GraphicSurface = graphics
            };

            DrawTacticalMap.DrawBackGround(screenParameters);

            if (isStarted)
            {
                DrawCalculationSteps(screenParameters);

                DrawSpacecraft(screenParameters);

                DrawTargetPoint(screenParameters);
            }



            if (CurrentMode == Mode.SetSpaceShipLocation)
            {
                var color = Color.DarkOliveGreen;

                screenParameters.GraphicSurface.FillEllipse(new SolidBrush(color), MouseCoordinates.X - 2, MouseCoordinates.Y - 2, 4, 4);
                screenParameters.GraphicSurface.DrawEllipse(new Pen(color), MouseCoordinates.X - 4, MouseCoordinates.Y - 4, 8, 8);
            }

            if (CurrentMode == Mode.SetTargetLocation)
            {
                var color = Color.Maroon;

                screenParameters.GraphicSurface.FillEllipse(new SolidBrush(color), MouseCoordinates.X - 2, MouseCoordinates.Y - 2, 4, 4);
                screenParameters.GraphicSurface.DrawEllipse(new Pen(color), MouseCoordinates.X - 4, MouseCoordinates.Y - 4, 8, 8);
            }

            BackgroundImage = image;
        }