private static void UpdateOrbit(ProtoEntity entity, PositionDB parentPositionDB, DateTime toDate) { var entityOrbitDB = entity.GetDataBlob <OrbitDB>(OrbitTypeIndex); var entityPosition = entity.GetDataBlob <PositionDB>(PositionTypeIndex); // Get our Parent-Relative coordinates. try { Vector4 newPosition = GetPosition(entityOrbitDB, toDate); // Get our Absolute coordinates. entityPosition.AbsolutePosition = parentPositionDB.AbsolutePosition + newPosition; } catch (OrbitProcessorException e) { // TODO: Debug log this exception. Do NOT fail to the UI. There is NO data-corruption on this exception. // In this event, we did NOT update our position. throw new Exception("Position Exception thrown in OrbitProcessor"); } // Update our children. foreach (Entity child in entityOrbitDB.Children) { // RECURSION! UpdateOrbit(child, entityPosition, toDate); } }
// sets the speed of the ship to the maximum speed allowed in the direction of the target. // Returns true if the destination has been reached. public override bool processOrder() { PositionDB currentPosition = Owner.GetDataBlob <PositionDB>(); PositionDB targetPosition = null; if (Target != Entity.InvalidEntity) { targetPosition = Target.GetDataBlob <PositionDB>(); } else if (PositionTarget != null) { targetPosition = PositionTarget; } if (currentPosition == targetPosition) // We have reached the target { return(true); } // Set the speed of the ship // @todo - take into account Task Group speeds and limiting speed set by user Owner.GetDataBlob <PropulsionDB>().CurrentSpeed = getSpeed(currentPosition, targetPosition, Owner.GetDataBlob <PropulsionDB>().MaximumSpeed); return(false); }
internal override void ActionCommand(Game game) { OrderableProcessor.ProcessOrderList(game, NestedCommands); if (NestedCommands.Count == 0) { if (!IsRunning) { var entPos = _entityCommanding.GetDataBlob <PositionDB>().PositionInKm; var tarPos = _targetEntity.GetDataBlob <PositionDB>().PositionInKm; double distanceAU = PositionDB.GetDistanceBetween(_entityCommanding.GetDataBlob <PositionDB>(), _targetEntity.GetDataBlob <PositionDB>()); var rangeAU = ApihelionInKM / GameConstants.Units.KmPerAu; if (Math.Abs(rangeAU - distanceAU) <= 500 / GameConstants.Units.MetersPerAu) //distance within 500m { DateTime datenow = _entityCommanding.Manager.ManagerSubpulses.SystemLocalDateTime; var newOrbit = ShipMovementProcessor.CreateOrbitHereWithPerihelion(_entityCommanding, _targetEntity, PerhelionInKM, datenow); _entityCommanding.SetDataBlob(newOrbit); IsRunning = true; } else //insert new translate move { var cmd = new TranslateMoveCommand() { RequestingFactionGuid = this.RequestingFactionGuid, EntityCommandingGuid = this.EntityCommandingGuid, CreatedDate = this.CreatedDate, TargetEntityGuid = this.TargetEntityGuid, RangeInKM = this.ApihelionInKM }; NestedCommands.Insert(0, cmd); cmd.IsValidCommand(game); cmd.ActionCommand(game); } } } }
/// <summary> /// Refreshes the properties of this ViewModel. /// /// If partialRefresh is set to true, the ViewModel will try to update only data changes during a pulse. /// </summary> public void Refresh(bool partialRefresh = false) { // Get up-to-date datablobs for this entity. PositionDB positionDB = _entity.GetDataBlob <PositionDB>(); UpdateProperties(positionDB); SystemBodyInfoDB systemBodyDB = _entity.GetDataBlob <SystemBodyInfoDB>(); UpdateProperties(systemBodyDB, partialRefresh); NameDB nameDB = _entity.GetDataBlob <NameDB>(); UpdateProperties(nameDB); //AtmosphereDB atmosphereDB = _entity.GetDataBlob<AtmosphereDB>(); //UpdateProperties(atmosphereDB); // Check if we're doing a full refresh. if (!partialRefresh) { OrbitDB orbitDB = _entity.GetDataBlob <OrbitDB>(); UpdateProperties(orbitDB); MassVolumeDB massVolumeDB = _entity.GetDataBlob <MassVolumeDB>(); UpdateProperties(massVolumeDB); } }
private static void UpdateOrbit(ProtoEntity entity, PositionDB parentPositionDB, DateTime toDate) { var entityOrbitDB = entity.GetDataBlob <OrbitDB>(OrbitTypeIndex); var entityPosition = entity.GetDataBlob <PositionDB>(PositionTypeIndex); //if(toDate.Minute > entityOrbitDB.OrbitalPeriod.TotalMinutes) // Get our Parent-Relative coordinates. try { Vector3 newPosition = GetPosition_AU(entityOrbitDB, toDate); // Get our Absolute coordinates. entityPosition.AbsolutePosition_AU = parentPositionDB.AbsolutePosition_AU + newPosition; } catch (OrbitProcessorException e) { //Do NOT fail to the UI. There is NO data-corruption on this exception. // In this event, we did NOT update our position. Event evt = new Event(StaticRefLib.CurrentDateTime, "Non Critical Position Exception thrown in OrbitProcessor for EntityItem " + entity.Guid + " " + e.Message); evt.EventType = EventType.Opps; StaticRefLib.EventLog.AddEvent(evt); } // Update our children. foreach (Entity child in entityOrbitDB.Children) { // RECURSION! UpdateOrbit(child, entityPosition, toDate); } }
/// <summary> /// Creates a star entity in the system. /// Does not initialize an orbit. /// </summary> public Entity CreateStar(StarSystem system, double mass, double radius, double age, string starClass, double temperature, float luminosity, SpectralType spectralType, string starName = null) { double tempRange = temperature / _galaxyGen.Settings.StarTemperatureBySpectralType[spectralType].Max; // temp range from 0 to 1. ushort subDivision = (ushort)Math.Round((1 - tempRange) * 10); LuminosityClass luminosityClass = LuminosityClass.V; if (starName == null) { starName = system.NameDB.DefaultName; } int starIndex = system.GetAllEntitiesWithDataBlob <StarInfoDB>().Count; starName += " " + (char)('A' + starIndex) + " " + spectralType + subDivision + luminosityClass; MassVolumeDB starMassVolumeDB = MassVolumeDB.NewFromMassAndRadius(mass, radius); StarInfoDB starInfoDB = new StarInfoDB { Age = age, Class = starClass, Luminosity = luminosity, SpectralType = spectralType, Temperature = temperature, LuminosityClass = luminosityClass, SpectralSubDivision = subDivision }; PositionDB starPositionDB = new PositionDB(new Vector3(0, 0, 0), system.Guid); NameDB starNameDB = new NameDB(starName); OrbitDB starOrbitDB = new OrbitDB(); SensorProfileDB emmisionSignature = SensorProcessorTools.SetStarEmmisionSig(starInfoDB, starMassVolumeDB); return(new Entity(system, new List <BaseDataBlob> { starOrbitDB, starMassVolumeDB, starInfoDB, starNameDB, starPositionDB, emmisionSignature })); }
public TranslateMoveDB(TranslateMoveDB db) { TargetPositionDB = db.TargetPositionDB; CurrentVector = db.CurrentVector; MoveRangeInKM = db.MoveRangeInKM; IsAtTarget = db.IsAtTarget; }
public SensorPositionDB(PositionDB actualEntityPosition, DataFrom dataFrom = DataFrom.Parent) { ActualEntityPositionDB = actualEntityPosition; //if(actualEntityPosition.ParentDB != null) ParentPositionDB = (PositionDB)actualEntityPosition.ParentDB; GetDataFrom = DataFrom.Parent; }
private Vector4 getSpeed(PositionDB currentPosition, PositionDB targetPosition, double speedMagnitude) { Vector4 speed = new Vector4(0, 0, 0, 0); double length; Vector4 speedMagInKM; Vector4 direction = new Vector4(0, 0, 0, 0); direction.X = targetPosition.X - currentPosition.X; direction.Y = targetPosition.Y - currentPosition.Y; direction.Z = targetPosition.Z - currentPosition.Z; direction.W = 0; length = direction.Length(); // Distance between targets in AU direction.X = (direction.X / length); direction.Y = (direction.Y / length); direction.Z = (direction.Z / length); speedMagInKM.X = direction.X * speedMagnitude; speedMagInKM.Y = direction.Y * speedMagnitude; speedMagInKM.Z = direction.Z * speedMagnitude; speed.X = Distance.KmToAU(speedMagInKM.X); speed.Y = Distance.KmToAU(speedMagInKM.Y); speed.Z = Distance.KmToAU(speedMagInKM.Z); return(speed); }
/// <summary> /// Creates an test system with planets of varying longitude of periapsis. /// Adds to game.StarSystem. /// </summary> public StarSystem CreateLongitudeTest(Game game) { StarSystem system = new StarSystem(game, "Longitude test", -1); Entity sun = _starFactory.CreateStar(system, GameConstants.Units.SolarMassInKG, GameConstants.Units.SolarRadiusInAu, 4.6E9, "G", 5778, 1, SpectralType.G, "_lop"); MassVolumeDB sunMVDB = sun.GetDataBlob <MassVolumeDB>(); double planetSemiMajAxis = 0.387098; double planetEccentricity = 0.9;// 0.205630; double planetInclination = 0; double planetLoAN = 48.33167; double planetLoP = 77.45645; double planetMeanLongd = 252.25084; for (int i = 0; i < 13; i++) { NameDB planetNameDB = new NameDB("planet" + i); SystemBodyInfoDB planetBodyDB = new SystemBodyInfoDB { BodyType = BodyType.Terrestrial, SupportsPopulations = true }; MassVolumeDB planetMVDB = MassVolumeDB.NewFromMassAndRadius_AU(3.3022E23, Distance.KmToAU(2439.7)); PositionDB planetPositionDB = new PositionDB(system.Guid); planetLoP = i * 15; OrbitDB planetOrbitDB = OrbitDB.FromMajorPlanetFormat(sun, sunMVDB.MassDry, planetMVDB.MassDry, planetSemiMajAxis, planetEccentricity, planetInclination, planetLoAN, planetLoP, planetMeanLongd, GalaxyGen.Settings.J2000); planetPositionDB.AbsolutePosition_AU = OrbitProcessor.GetPosition_AU(planetOrbitDB, StaticRefLib.CurrentDateTime); Entity planet = new Entity(system, new List <BaseDataBlob> { planetPositionDB, planetBodyDB, planetMVDB, planetNameDB, planetOrbitDB }); } game.GameMasterFaction.GetDataBlob <FactionInfoDB>().KnownSystems.Add(system.Guid); return(system); }
public PositionDB(PositionDB positionDB) : base(positionDB.Parent) { _positionInMeters = positionDB._positionInMeters; this.SystemGuid = positionDB.SystemGuid; }
/* * public TimeSpan RunFrequency => TimeSpan.FromMinutes(60); * * public void ProcessEntity(Entity entity, int deltaSeconds) * { * SetEntityProfile(entity); * } * * public void ProcessManager(EntityManager manager, int deltaSeconds) * { * Stopwatch timer = new Stopwatch(); * timer.Start(); * var entites = manager.GetAllEntitiesWithDataBlob<SensorProfileDB>(); * foreach (var entity in entites) * { * ProcessEntity(entity, deltaSeconds); * } * var ms = timer.ElapsedMilliseconds; * var numEntites = entites.Count; * } */ internal static void SetEntityProfile(Entity entity, DateTime atDate) { var position = entity.GetDataBlob <PositionDB>(); var sensorSig = entity.GetDataBlob <SensorProfileDB>(); sensorSig.LastPositionOfReflectionSet = position.AbsolutePosition_AU; sensorSig.LastDatetimeOfReflectionSet = atDate; var emmiters = entity.Manager.GetAllEntitiesWithDataBlob <SensorProfileDB>(); int numberOfEmmitters = emmiters.Count; sensorSig.ReflectedEMSpectra.Clear(); PercentValue reflectionPercent = 0.1f; //TODO: this should be calculated from crossSection(size), distance, and a reflectivity value(stealth armor?/ other design factors?). foreach (var emittingEntity in emmiters) { if (emittingEntity != entity) // don't reflect our own emmision. { double distance = PositionDB.GetDistanceBetween(position, emittingEntity.GetDataBlob <PositionDB>()); var emmissionDB = emittingEntity.GetDataBlob <SensorProfileDB>(); foreach (var emitedItem in emmissionDB.EmittedEMSpectra) { var reflectedMagnatude = SensorProcessorTools.AttenuationCalc(emitedItem.Value, distance) * reflectionPercent; sensorSig.ReflectedEMSpectra.Add(emitedItem.Key, emitedItem.Value); } } } }
public PositionDB(PositionDB positionDB) : base(positionDB.Parent) { this.X = positionDB.X; this.Y = positionDB.Y; this.Z = positionDB.Z; this.SystemGuid = positionDB.SystemGuid; }
public static Entity GetSOIParentEntity(Entity entity, PositionDB positionDB = null) { if (positionDB == null) { positionDB = entity.GetDataBlob <PositionDB>(); } return(positionDB.Parent); }
private static PositionDB SetPositionClone(SensorInfoDB sensorInfo) { PositionDB position = sensorInfo.DetectedEntity.GetDataBlob <PositionDB>(); PositionDB sensorEntityPosition = GenericClone <PositionDB>(position, sensorInfo); //tweak add some random noise depending on quality; return(sensorEntityPosition); }
public TranslationMoveVM(Game game, CommandReferences cmdRef, Entity entity) { _tMoveDB = entity.GetDataBlob <TranslateMoveDB>(); _posDB = entity.GetDataBlob <PositionDB>(); _propDB = entity.GetDataBlob <PropulsionDB>(); _cmdRef = cmdRef; TargetList.SelectionChangedEvent += OnTargetSelectonChange; UpdateTargetList(entity.GetDataBlob <OwnedDB>().OwnedByFaction, entity.Manager); }
public MoveOrderDB(Entity ship, PositionDB target, long orbitRadius = 0) { DelayTime = 0; Owner = ship; Target = Entity.InvalidEntity; PositionTarget = new PositionDB(target); OrbitRadius = orbitRadius; MaximumSpeed = ship.GetDataBlob <PropulsionDB>().MaximumSpeed; }
private void setPositionToTarget(Entity ship, PositionDB target) { Owner.GetDataBlob <PropulsionDB>().CurrentSpeed = new Vector4(0.0, 0.0, 0.0, 0.0); Owner.GetDataBlob <PositionDB>().X = target.X; Owner.GetDataBlob <PositionDB>().Y = target.Y; Owner.GetDataBlob <PositionDB>().Z = target.Z; return; }
// Creates a new order for a ship to move to the given coordinates in a star system public bool MoveOrder(Entity ship, StarSystem system, double x, double y) { PositionDB position = new PositionDB(new Vector4(x, y, 0.0, 0.0), system.Guid); MoveOrder moveOrder = new MoveOrder(ship, position); _orderList.Add(moveOrder); return(true); }
/// <summary> /// creates an asteroid that will collide with the given entity on the given date. /// </summary> /// <param name="starSys"></param> /// <param name="target"></param> /// <param name="collisionDate"></param> /// <returns></returns> public static Entity CreateAsteroid(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0) { //todo rand these a bit. double radius = Distance.KmToAU(0.5); double mass; if (asteroidMass == -1.0) { mass = 1.5e+12; //about 1.5 billion tonne } else { mass = asteroidMass; } Vector3 velocity = new Vector3(8, 7, 0); var position = new PositionDB(0, 0, 0, Guid.Empty); var massVolume = MassVolumeDB.NewFromMassAndRadius(mass, radius); var planetInfo = new SystemBodyInfoDB(); var balisticTraj = new NewtonBalisticDB(target.Guid, collisionDate); var name = new NameDB("Ellie"); var AsteroidDmg = new AsteroidDamageDB(); var sensorPfil = new SensorProfileDB(); planetInfo.SupportsPopulations = false; planetInfo.BodyType = BodyType.Asteroid; Vector3 targetPos = OrbitProcessor.GetAbsolutePosition_AU(target.GetDataBlob <OrbitDB>(), collisionDate); TimeSpan timeToCollision = collisionDate - StaticRefLib.CurrentDateTime; Vector3 offset = velocity * timeToCollision.TotalSeconds; targetPos -= Distance.KmToAU(offset); position.AbsolutePosition_AU = targetPos; position.SystemGuid = starSys.Guid; balisticTraj.CurrentSpeed = velocity; var planetDBs = new List <BaseDataBlob> { position, massVolume, planetInfo, name, balisticTraj, AsteroidDmg, sensorPfil }; Entity newELE = new Entity(starSys, planetDBs); return(newELE); }
void SetOrbitHere(Entity entity, PositionDB positionDB, WarpMovingDB moveDB, DateTime atDateTime) { //propulsionDB.CurrentVectorMS = new Vector3(0, 0, 0); double targetSOI = OrbitProcessor.GetSOI_m(moveDB.TargetEntity); Entity targetEntity; if (moveDB.TargetEntity.GetDataBlob <PositionDB>().GetDistanceTo_m(positionDB) > targetSOI) { targetEntity = moveDB.TargetEntity.GetDataBlob <OrbitDB>().Parent; //TODO: it's concevable we could be in another SOI not the parent (ie we could be in a target's moon's SOI) } else { targetEntity = moveDB.TargetEntity; } OrbitDB targetOrbit = targetEntity.GetDataBlob <OrbitDB>(); Vector3 insertionVector_m = OrbitProcessor.GetOrbitalInsertionVector_m(moveDB.SavedNewtonionVector, targetOrbit, atDateTime); positionDB.SetParent(targetEntity); if (moveDB.ExpendDeltaV.Length() != 0) { NewtonThrustCommand.CreateCommand(entity.FactionOwner, entity, entity.StarSysDateTime, moveDB.ExpendDeltaV); entity.RemoveDataBlob <WarpMovingDB>(); moveDB.IsAtTarget = true; } else { OrbitDB newOrbit = OrbitDB.FromVelocity_m(targetEntity, entity, insertionVector_m, atDateTime); entity.RemoveDataBlob <WarpMovingDB>(); if (newOrbit.Apoapsis < targetSOI) //furtherst point within soi, normal orbit { entity.SetDataBlob(newOrbit); } else if (newOrbit.Periapsis > targetSOI) //closest point outside soi { //find who's SOI we are in, and create an orbit around that. targetEntity = OrbitProcessor.FindSOIForPosition((StarSystem)entity.Manager, positionDB.AbsolutePosition_m); newOrbit = OrbitDB.FromVelocity_m(targetEntity, entity, insertionVector_m, atDateTime); entity.SetDataBlob(newOrbit); } else //closest point inside soi, but furtherest point outside. make a newtonion trajectory. { var newtmove = new NewtonMoveDB(targetEntity, insertionVector_m); entity.SetDataBlob(newtmove); } positionDB.SetParent(targetEntity); moveDB.IsAtTarget = true; } }
private double distanceBetweenPositions(PositionDB origin, PositionDB target) { Vector4 delta = new Vector4(); delta.X = origin.X - target.X; delta.Y = origin.Y - target.Y; delta.Z = origin.Z - target.Z; return(delta.Length()); }
private void Deserialized(StreamingContext context) { if (TargetEntity != null) { var game = (Game)context.Context; game.PostLoad += (sender, args) => { TargetPositionDB = TargetEntity.GetDataBlob <PositionDB>(); }; } }
public TranslationMoveVM(Game game, CommandReferences cmdRef, Entity entity) { _tMoveDB = entity.GetDataBlob <TranslateMoveDB>(); _posDB = entity.GetDataBlob <PositionDB>(); _propDB = entity.GetDataBlob <PropulsionAbilityDB>(); _cmdRef = cmdRef; TargetList.SelectionChangedEvent += OnTargetSelectonChange; Entity faction; entity.Manager.FindEntityByGuid(entity.FactionOwner, out faction); UpdateTargetList(faction, entity.Manager); }
private static ProtoEntity CreateSurveyPoint(double x, double y, int nameNumber) { // TODO: Rebalance "pointsRequired" here. // TODO: Load "pointsRequired" from GalaxyGen settings const int pointsRequired = 400; var surveyDB = new JPSurveyableDB(pointsRequired, new Dictionary <Entity, int>()); var posDB = new PositionDB(x, y, 0, Guid.Empty); var nameDB = new NameDB($"Survey Point #{nameNumber}"); return(ProtoEntity.Create(Guid.Empty, new BaseDataBlob[] { surveyDB, posDB, nameDB })); }
public MoveOrder(Entity ship, PositionDB target, long orbitRadius = 0) : this() { DelayTime = 0; Owner = ship; // The owners positions is sometimes set to that of another entity for orbiting purposes. This resets that issue Owner.SetDataBlob <PositionDB>(new PositionDB(Owner.GetDataBlob <PositionDB>())); Target = Entity.InvalidEntity; PositionTarget = new PositionDB(target); OrbitRadius = orbitRadius; MaximumSpeed = ship.GetDataBlob <PropulsionDB>().MaximumSpeed; }
private void UpdateProperties([NotNull] PositionDB positionDB) { if (positionDB == null) { throw new ArgumentNullException("positionDB"); } Position = positionDB.AbsolutePosition_AU; if (Name == "Earth") { } }
/// <summary> /// This asteroid was destroyed, see if it is big enough for child asteroids to spawn, and if so spawn them. /// </summary> /// <param name="Asteroid"></param> internal static void SpawnSubAsteroids(Entity Asteroid) { Game game = Asteroid.Manager.Game; MassVolumeDB ADB = Asteroid.GetDataBlob <MassVolumeDB>(); //const double massDefault = 1.5e+12; //150 B tonnes? const double massThreshold = 1.5e+9; //150 M tonnes? if (ADB.Mass > massThreshold) { //spawn new asteroids. call the asteroid factory? double newMass = ADB.Mass * 0.4; //add a random factor into this? do we care? will mass be printed to the player? NewtonBalisticDB nDB = Asteroid.GetDataBlob <NewtonBalisticDB>(); PositionDB pDB = Asteroid.GetDataBlob <PositionDB>(); StarSystem mySystem; if (!game.Systems.TryGetValue(pDB.SystemGuid, out mySystem)) { throw new GuidNotFoundException(pDB.SystemGuid); } Entity myTarget; if (!mySystem.FindEntityByGuid(nDB.TargetGuid, out myTarget)) { throw new GuidNotFoundException(nDB.TargetGuid); } //public static Entity CreateAsteroid(StarSystem starSys, Entity target, DateTime collisionDate, double asteroidMass = -1.0) //I need the target entity, the collisionDate, and the starSystem. I may have starsystem from guid. //Ok so this should create the asteroid without having to add the new asteroids to a list. as that is done in the factory. Entity newAsteroid1 = AsteroidFactory.CreateAsteroid(mySystem, myTarget, nDB.CollisionDate, newMass); Entity newAsteroid2 = AsteroidFactory.CreateAsteroid(mySystem, myTarget, nDB.CollisionDate, newMass); mySystem.RemoveEntity(Asteroid); //Randomize the number of created asteroids? } else { //delete the existing asteroid. PositionDB pDB = Asteroid.GetDataBlob <PositionDB>(); StarSystem mySystem; if (!game.Systems.TryGetValue(pDB.SystemGuid, out mySystem)) { throw new GuidNotFoundException(pDB.SystemGuid); } mySystem.RemoveEntity(Asteroid); } }
public TranslateMoveDB(TranslateMoveDB db) { LastProcessDateTime = db.LastProcessDateTime; SavedNewtonionVector_AU = db.SavedNewtonionVector_AU; TranslateEntryPoint_AU = db.TranslateEntryPoint_AU; TranslateExitPoint_AU = db.TranslateExitPoint_AU; CurrentNonNewtonionVectorMS = db.CurrentNonNewtonionVectorMS; ExpendDeltaV_AU = db.ExpendDeltaV_AU; IsAtTarget = db.IsAtTarget; TargetEntity = db.TargetEntity; TargetPositionDB = db.TargetPositionDB; }
/// <summary> /// process balistic movement for a single system /// currently is not affected by gravity. /// </summary> /// <param name="manager">the system to process</param> internal static void Process(EntityManager manager) { TimeSpan orbitCycle = manager.Game.Settings.OrbitCycleTime; DateTime toDate = manager.ManagerSubpulses.SystemLocalDateTime + orbitCycle; manager.ManagerSubpulses.AddSystemInterupt(toDate + orbitCycle, PulseActionEnum.BalisticMoveProcessor); List <Entity> RemoveList = new List <Entity>(); List <StarSystem> RemoveSystem = new List <StarSystem>(); foreach (Entity objectEntity in manager.GetAllEntitiesWithDataBlob <NewtonBalisticDB>()) { NewtonBalisticDB balisticDB = objectEntity.GetDataBlob <NewtonBalisticDB>(); PositionDB position = objectEntity.GetDataBlob <PositionDB>(); position.RelativePosition += Distance.KmToAU(balisticDB.CurrentSpeed * orbitCycle.TotalSeconds); Entity myTarget = manager.GetLocalEntityByGuid(balisticDB.TargetGuid); PositionDB targetPos = myTarget.GetDataBlob <PositionDB>(); if (targetPos.AbsolutePosition == position.AbsolutePosition) { //do something in damage processor for asteroid hitting a planet? DamageProcessor.OnTakingDamage(myTarget, 1000000); ///one. million. damage points. StarSystem mySystem; if (!manager.Game.Systems.TryGetValue(position.SystemGuid, out mySystem)) { throw new GuidNotFoundException(position.SystemGuid); } RemoveList.Add(objectEntity); RemoveSystem.Add(mySystem); mySystem.SystemManager.RemoveEntity(objectEntity); //get rid of the asteroid } } /// <summary> /// Clean up the asteroids that have hit something and been put in the remove list. /// </summary> for (int removeIterator = 0; removeIterator < RemoveList.Count; removeIterator++) { RemoveSystem[removeIterator].SystemManager.RemoveEntity(RemoveList[removeIterator]); } /// <summary> /// This may not be necessary but clear these two lists. /// </summary> RemoveList.Clear(); RemoveSystem.Clear(); }