public static ICelestialObject GenerateNpcShip(GameSession gameSession, int spaceShipClass, int spaceShipType, int standing)
{
Logger.Debug($"[CelestialObjectsFactory][GenerateNpcShip] Start generate.");
var spaceship = gameSession.GetPlayerSpaceShip().ToSpaceship();
Spaceship newCelestialObject = null;
switch (spaceShipType)
{
case 12:
newCelestialObject = Fury.Generate();
break;
default:
break;
}
if (newCelestialObject != null)
{
newCelestialObject.PositionX = spaceship.PositionX + Math.Abs(500 + RandomGenerator.GetInteger(-20, 20));
newCelestialObject.PositionY = spaceship.PositionY + Math.Abs(500 + RandomGenerator.GetInteger(-20, 20));
newCelestialObject.Speed = newCelestialObject.MaxSpeed;
newCelestialObject.Direction = SpaceMapTools.GetAngleBetweenPoints(newCelestialObject.GetLocation().ToVector2(), spaceship.GetLocation().ToVector2());
}
return(newCelestialObject);
}
public static void DrawCelestialObjectDirection(ICelestialObject celestialObject, PointF location, Graphics graphics, ScreenParameters screenParameters)
{
var screenCoordinates = UI.ToScreenCoordinates(screenParameters, new PointF(location.X, location.Y));
if ((CelestialObjectTypes)celestialObject.Classification == CelestialObjectTypes.Explosion)
{
return;
}
var move = SpaceMapTools.Move(screenCoordinates, 8, 6, celestialObject.Direction);
SpaceMapGraphics.DrawArrow(graphics, move, Color.DimGray);
}
public static void DrawArrow(Graphics graphics, SpaceMapVector line, Color color, int arrowSize = 4)
{
// Base arrow line
graphics.DrawLine(new Pen(color), line.PointFrom.X, line.PointFrom.Y, line.PointTo.X, line.PointTo.Y);
// Arrow left line
var leftArrowLine = SpaceMapTools.Move(line.PointTo.ToVector2(), arrowSize, line.Direction + 150);
graphics.DrawLine(new Pen(color), leftArrowLine.PointFrom.X, leftArrowLine.PointFrom.Y, leftArrowLine.PointTo.X, leftArrowLine.PointTo.Y);
// Arrow right line
var rightArrowLine = SpaceMapTools.Move(line.PointTo.ToVector2(), arrowSize, line.Direction - 150);
graphics.DrawLine(new Pen(color), rightArrowLine.PointFrom.X, rightArrowLine.PointFrom.Y, rightArrowLine.PointTo.X, rightArrowLine.PointTo.Y);
}
public static List <PointF> LinearMovement(PointF currentLocation, PointF targetLocation)
{
var result = new List <PointF>();
var distance = SpaceMapTools.GetDistance(currentLocation, targetLocation);
for (var i = 0; i < distance; i++)
{
var x = (float)(currentLocation.X * (1 - (i / distance)) + targetLocation.X * (i / distance));
var y = (float)(currentLocation.Y * (1 - (i / distance)) + targetLocation.Y * (i / distance));
result.Add(new PointF(x, y));
}
return(result);
}
private Hashtable EnqueueMovementHistory(ICelestialObject mapCelestialObject, Hashtable allObjectsHistory)
{
var previousIteration = new SpaceMapObjectLocation
{
Distance = SpaceMapTools.GetDistance(mapCelestialObject.GetLocation(), mapCelestialObject.GetLocation()),
Direction = mapCelestialObject.Direction,
Status = MovementType.Linear,
Coordinates = mapCelestialObject.GetLocation()
};
if (allObjectsHistory.ContainsKey(mapCelestialObject.Id) == false)
{
// New celestial object in history collection
var initialIteration = new SpaceMapObjectLocation
{
Distance = SpaceMapTools.GetDistance(mapCelestialObject.GetLocation(), mapCelestialObject.GetLocation()),
Direction = mapCelestialObject.Direction,
Status = MovementType.Linear,
Coordinates = Coordinates.MoveObject(mapCelestialObject.GetLocation(), 2000,
(mapCelestialObject.Direction - 180).To360Degrees())
};
var initialHistory = new FixedSizedQueue <SpaceMapObjectLocation>(_historyBufferSize);
initialHistory.Enqueue(initialIteration);
initialHistory.Enqueue(previousIteration);
allObjectsHistory.Add(mapCelestialObject.Id, initialHistory);
return(allObjectsHistory);
}
// Add new history point to exist celestial object movement history
if (!(allObjectsHistory[mapCelestialObject.Id] is FixedSizedQueue <SpaceMapObjectLocation> currentObjectMovementHistory))
{
return(allObjectsHistory);
}
currentObjectMovementHistory.Enqueue(previousIteration);
allObjectsHistory[mapCelestialObject.Id] = currentObjectMovementHistory;
return(allObjectsHistory);
}
public CommandExecuteResult Execute(GameSession gameSession, Command command)
{
gameSession.AddHistoryMessage($"started.", GetType().Name, true);
var explosion = gameSession.GetCelestialObject(command.CelestialObjectId).ToExplosion();
var destroyedSpaceships = new List <ICelestialObject>();
foreach (var celestialObject in gameSession.SpaceMap.CelestialObjects)
{
if (celestialObject.IsSpaceship() == false)
{
continue;
}
var spaceShip = celestialObject.ToSpaceship();
var distance = SpaceMapTools.GetDistance(celestialObject.GetLocation(), explosion.GetLocation());
if (distance < explosion.Radius * 2)
{
spaceShip.Damage(explosion.Damage);
gameSession.AddHistoryMessage($"Spaceship {spaceShip.Name} get damage '{explosion.Damage}' from '{explosion.Name}'", GetType().Name);
if (spaceShip.IsDestroyed)
{
destroyedSpaceships.Add(celestialObject);
}
}
foreach (var destroyedSpaceship in destroyedSpaceships)
{
gameSession.RemoveCelestialObject(destroyedSpaceship);
gameSession.AddHistoryMessage($"Spaceship {destroyedSpaceship.Name} was destroyed.", GetType().Name);
}
}
return(new CommandExecuteResult {
Command = command, IsResume = false
});
}
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
}
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 List <SpaceMapObjectLocation> Calculate(PointF location, PointF center, double direction, int maxIterations = 500)
{
const int radius = 30;
var result = new List <SpaceMapObjectLocation>();
var orbitInformation = SpaceMapTools.GetRadiusPoint(location, center, radius, direction);
var orbitPoint = orbitInformation.StartLocation;
var movementRotation = orbitInformation.Rotation;
var distance = Coordinates.GetDistance(center, location);
var previousIteration = new SpaceMapObjectLocation
{
Distance = Coordinates.GetDistance(center, location),
Direction = direction,
Status = MovementType.Orbit,
Coordinates = new PointF(location.X, location.Y)
};
result.Add(previousIteration);
// Here we on orbit of celestial object
for (var iteration = 0; iteration < 500; iteration++)
{
var currentIteration = result[result.Count - 1];
distance = Coordinates.GetDistance(center, currentIteration.Coordinates);
float speedOrbit = 1;
var directionDelta = 0;
switch (movementRotation)
{
case OrbitRotation.Right:
speedOrbit = 0.5f;
directionDelta = +90;
break;
case OrbitRotation.Left:
speedOrbit = -0.5f;
directionDelta = -90;
break;
}
var r = OrbitPrototype.Execute(center.ToVector2(), currentIteration.Coordinates.ToVector2(), speedOrbit, 1);
var attackAzimuth = Coordinates.GetRotation(center, r.ToPointF()) + directionDelta;
if (attackAzimuth < 0)
{
attackAzimuth = 360 + attackAzimuth;
}
if (attackAzimuth > 360)
{
attackAzimuth = attackAzimuth - 360;
}
result.Add(new SpaceMapObjectLocation
{
Distance = distance,
Direction = attackAzimuth,
Iteration = result.Count,
Coordinates = r.ToPointF()
});
}
return(result);
}
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 List <SpaceMapObjectLocation> CalculateIteration(PointF currentLocation, PointF targetLocation, double direction, double speed, int maxIterations = 2000)
{
const int agility = 5;
var result = new List <SpaceMapObjectLocation>();
// In this case first iteration - start position for calculation.
var previousIteration = new SpaceMapObjectLocation
{
Distance = SpaceMapTools.GetDistance(targetLocation, currentLocation),
Direction = direction,
Status = MovementType.Default,
Coordinates = new PointF(currentLocation.X, currentLocation.Y)
};
var currentStepInTurn = speed;
for (var iteration = 0; iteration < maxIterations; iteration++)
{
var location = SpaceMapTools.Move(previousIteration.Coordinates.ToVector2(), 1, previousIteration.Direction);
var iterationResult = new SpaceMapObjectLocation
{
Direction = previousIteration.Direction,
Iteration = iteration,
Coordinates = location.PointTo,
Distance = SpaceMapTools.GetDistance(targetLocation, location.PointTo)
};
// 0 - 360 degree
var attackAzimuth = SpaceMapTools.GetAngleBetweenPoints(location.PointTo.ToVector2(), targetLocation.ToVector2());
// Turn angle
var attackAngle = (int)SpaceMapTools.GetRotateDirection(iterationResult.Direction, attackAzimuth);
var currentAgility = 0;
if (speed == currentStepInTurn)
{
currentAgility = agility;
}
currentStepInTurn++;
if (currentStepInTurn > speed)
{
currentStepInTurn = 0;
}
switch (attackAngle)
{
case var _ when attackAngle > 0:
// > 0 left turn
iterationResult.Direction -= currentAgility;
iterationResult.Status = MovementType.Turn;
break;
case var _ when attackAngle < 0:
// < 0 right turn
iterationResult.Direction += currentAgility;
iterationResult.Status = MovementType.Turn;
break;
case var _ when attackAngle == 0:
// = 0 forward
iterationResult.Status = MovementType.Linear;
break;
}
if (iterationResult.Distance >= 2)
{
result.Add(iterationResult);
}
else
{
result.Add(iterationResult);
break;
}
result.Add(iterationResult);
previousIteration = iterationResult;
}
//result.Add(new SpaceMapObjectLocation { ScanRange = 0, Direction = direction, Iteration = result.Count, Coordinates = targetLocation });
return(result);
}
public static Result Calculate(PointF currentLocation, PointF targetLocation, double direction, double speed, int maxIterations = 2000)
{
const int agility = 5;
var result = new Result();
// In this case first iteration - start position for calculation.
var previousIteration = new SpaceMapObjectLocation
{
Distance = SpaceMapTools.GetDistance(targetLocation, currentLocation),
Direction = direction,
Status = MovementType.Default,
Coordinates = new PointF(currentLocation.X, currentLocation.Y)
};
var currentStepInTurn = speed;
for (var iteration = 0; iteration < maxIterations; iteration++)
{
var location = SpaceMapTools.Move(previousIteration.Coordinates.ToVector2(), 1, previousIteration.Direction);
var iterationResult = new SpaceMapObjectLocation
{
Direction = previousIteration.Direction,
Iteration = iteration,
Coordinates = location.PointTo,
Distance = SpaceMapTools.GetDistance(targetLocation, location.PointTo)
};
// 0 - 360 degree
var attackAzimuth = SpaceMapTools.GetAngleBetweenPoints(location.PointTo.ToVector2(), targetLocation.ToVector2());
// Turn angle
var attackAngle = SpaceMapTools.GetRotateDirection(iterationResult.Direction, attackAzimuth);
var currentAgility = 0;
if ((int)speed == (int)currentStepInTurn)
{
currentAgility = agility;
if (Math.Abs(attackAngle) < agility)
{
attackAngle = 0;
iterationResult.Direction = attackAzimuth;
}
}
currentStepInTurn++;
if (currentStepInTurn > speed)
{
currentStepInTurn = 0;
}
switch (attackAngle)
{
case var _ when attackAngle > 1:
// > 0 left turn
iterationResult.Direction -= currentAgility;
iterationResult.Status = MovementType.Turn;
break;
case var _ when attackAngle < -1:
// < 0 right turn
iterationResult.Direction += currentAgility;
iterationResult.Status = MovementType.Turn;
break;
case var _ when attackAngle == 0:
// = 0 forward
iterationResult.Status = MovementType.Linear;
break;
case var _ when attackAngle == 1:
// = 0 forward
iterationResult.Status = MovementType.Linear;
break;
}
if (iterationResult.Distance >= 2)
{
result.Trajectory.Add(iterationResult);
}
else
{
result.Trajectory.Add(iterationResult);
break;
}
iterationResult.Direction = iterationResult.Direction.To360Degrees();
result.Trajectory.Add(iterationResult);
previousIteration = iterationResult;
if (iterationResult.Status == MovementType.Linear)
{
var linearIteration = 0;
foreach (var points in LinearMovement(iterationResult.Coordinates, targetLocation))
{
linearIteration++;
result.Trajectory.Add(new SpaceMapObjectLocation
{
Coordinates = points,
Distance = SpaceMapTools.GetDistance(targetLocation, points),
Direction = iterationResult.Direction.To360Degrees(),
Status = MovementType.Linear,
Iteration = iterationResult.Iteration + linearIteration
});
}
break;
}
}
return(result);
}
