public void Poll()
{
foreach (var sensor in sensors)
{
if (sensor.Enabled)
{
if ((refExpSettings & EntityTracking_Module.refExpSettings.Lidar) != 0 || (Me?.IsSameConstructAs(sensor) ?? true))
{
templist.Clear();
sensor.DetectedEntities(templist);
foreach (var entity in templist)
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = entity,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
OnEntityDetected?.Invoke(detectedEntity);
}
}
}
}
}
public HaE_Entity RaycastPosition(Vector3D position)
{
IMyCameraBlock camera = GetUsableCamera(position);
if (camera == null)
{
return(null);
}
MyDetectedEntityInfo detected = camera.Raycast(position);
if (!detected.IsEmpty())
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = detected,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
return(detectedEntity);
}
return(null);
}
/// <summary>
/// PRONAV
/// </summary>
/// <param name="target"></param>
/// <returns>Heading we need to aim at</returns>
public Vector3D Navigate(HaE_Entity target)
{
Vector3D targetpos = target.entityInfo.Position;
if (target.entityInfo.HitPosition.HasValue)
{
targetpos = target.entityInfo.HitPosition.Value;
}
Vector3D myVel = controller.control.GetShipVelocities().LinearVelocity;
Vector3D rangeVec = targetpos - controller.control.GetPosition();
Vector3D closingVel = target.entityInfo.Velocity - myVel;
Vector3D accel = CalculateAccel(rangeVec, closingVel);
accel += -controller.control.GetNaturalGravity(); //Gravity term
double maxForwardAccel = ThrustUtils.GetForwardThrust(controller.thrusters, controller.control);
maxForwardAccel /= controller.control.CalculateShipMass().PhysicalMass;
double forwardAccel = maxForwardAccel;
double accelMag = accel.Normalize();
forwardAccel -= accelMag;
forwardAccel = MathHelperD.Clamp(forwardAccel, 0, maxForwardAccel);
accel *= accelMag;
accel += Vector3D.Normalize(rangeVec) * forwardAccel;
return(accel);
}
private bool CheckIfEntityRelevant(HaE_Entity entity, Vector3D currentHeading)
{
if (entity.entityInfo.EntityId == rc.CubeGrid.EntityId)
{
return(false);
}
if (entity.BoundingSphere.Radius <= 0)
{
return(false);
}
Vector3D movementDir = rc.GetShipVelocities().LinearVelocity;
movementDir.Normalize();
RayD movementRay = new RayD(rc.CubeGrid.WorldVolume.Center, movementDir);
RayD headingRay = new RayD(rc.CubeGrid.WorldVolume.Center, currentHeading);
BoundingSphereD sphere = entity.BoundingSphere;
sphere.Radius += rc.CubeGrid.WorldVolume.Radius;
double?intersectVel = sphere.Intersects(movementRay);
double?intersectHeading = sphere.Intersects(headingRay);
return(intersectVel.HasValue || intersectHeading.HasValue);
}
public void Poll()
{
foreach (var turret in turrets)
{
if (turret.HasTarget)
{
if ((refExpSettings & EntityTracking_Module.refExpSettings.Turret) != 0 || (Me?.IsSameConstructAs(turret) ?? true))
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = turret.GetTargetedEntity(),
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
OnEntityDetected?.Invoke(detectedEntity);
if (earlyReturn)
{
return;
}
}
}
}
}
public bool UpdateEntity(HaE_Entity entity)
{
if (!detectedEntitiesDict.ContainsKey(entity.entityInfo.EntityId))
{
return(false);
}
detectedEntitiesDict[entity.entityInfo.EntityId] = entity;
detectedEntitiesSet.Remove(entity);
detectedEntitiesSet.Add(entity);
switch (entity.trackingType)
{
case HaE_Entity.TrackingType.Lidar:
_lidarEntities.Remove(entity);
_lidarEntities.Add(entity);
break;
case HaE_Entity.TrackingType.Sensor:
_sensorEntities.Remove(entity);
_sensorEntities.Add(entity);
break;
case HaE_Entity.TrackingType.Turret:
_turretEntities.Remove(entity);
_turretEntities.Add(entity);
break;
}
return(true);
}
public void OnEntityDetected(HaE_Entity entity)
{
if (CheckIfEntityRelevant(entity, lastHeadingDir))
{
relevantEntities[entity.entityInfo.EntityId] = entity;
}
}
public static Vector3D GetPredictedEntityLocation(HaE_Entity entity)
{
Vector3D oldPosition = entity.entityInfo.Position;
Vector3D velocity = entity.entityInfo.Velocity;
double timeSinceLastDetectionSeconds = entity.GetTimeSinceAdded().TotalSeconds;
return(oldPosition + velocity * timeSinceLastDetectionSeconds);
}
public void OnEntityDetected(HaE_Entity entity)
{
statusWriter.LogEvent($"LIDAR: Entity detected! | {entity.entityInfo.Name}");
if (waitForNextLock != null)
{
waitForNextLock.Invoke(entity);
waitForNextLock = null;
}
}
public bool GetEntityById(long entityId, ref HaE_Entity entity)
{
if (!detectedEntitiesDict.ContainsKey(entityId))
{
return(false);
}
entity = detectedEntitiesDict[entityId];
return(true);
}
public bool Remove(HaE_Entity entity)
{
if (detectedEntitiesDict.Remove(entity.entityInfo.EntityId))
{
_lidarEntities.Remove(entity);
_sensorEntities.Remove(entity);
_turretEntities.Remove(entity);
detectedEntitiesSet.Remove(entity);
return(true);
}
return(false);
}
public void OnEntityDetected(HaE_Entity entity)
{
if (CheckIfEntityRelevant(entity, lastHeadingDir))
{
if (relevantEntities.Contains(entity))
{
relevantEntities.Remove(entity);
relevantEntities.Add(entity);
}
else
{
relevantEntities.Add(entity);
}
}
}
private void RaycastEntity(HaE_Entity entity)
{
Vector3D extrapolatedPosition = TrackingUtils.GetPredictedEntityLocation(entity);
HaE_Entity detectedEntity = RaycastPosition(extrapolatedPosition);
if (detectedEntity == null)
{
if (!AttemptReScan(entity))
{
return;
}
}
OnEntityDetected?.Invoke(detectedEntity);
}
public void OnTargetFound(HaE_Entity target)
{
Vector3D targetPos = target.entityInfo.Position;
if (mode == CurrentMode.Idle || mode == CurrentMode.Launching)
{
return;
}
else if (mode == CurrentMode.TurretGuided)
{
if (target.trackingType != HaE_Entity.TrackingType.Turret)
{
return;
}
}
else if (mode == CurrentMode.LidarGuided)
{
if (target.trackingType != HaE_Entity.TrackingType.Lidar)
{
return;
}
if (target.entityInfo.HitPosition.HasValue)
{
targetPos = target.entityInfo.HitPosition.Value;
}
}
if ((target.entityInfo.Relationship != MyRelationsBetweenPlayerAndBlock.Enemies) &&
(target.entityInfo.Relationship != MyRelationsBetweenPlayerAndBlock.Neutral) &&
(target.entityInfo.Relationship != MyRelationsBetweenPlayerAndBlock.NoOwnership))
{
return;
}
double distSq = Vector3D.DistanceSquared(Me.GetPosition(), targetPos);
payload.UpdateDist(distSq);
Vector3D reqDir = proNav.Navigate(target);
double reqMag = reqDir.Normalize();
controlModule.AimMissile(reqDir);
controlModule.ApplyThrust(reqDir);
}
public void Poll()
{
foreach (var turret in turrets)
{
if (turret.HasTarget)
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = turret.GetTargetedEntity(),
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
OnEntityDetected?.Invoke(detectedEntity);
}
}
}
private void OnEntityDetected(HaE_Entity entity)
{
if (entity == null)
{
return;
}
if (known_Objects.Contains(entity))
{
known_Objects.UpdateEntity(entity);
}
else
{
known_Objects.AddEntity(entity);
}
onEntityDetected?.Invoke(entity);
}
public bool Scan(double distance)
{
bool detected = false;
foreach (var direction in localScanMap)
{
Vector3D worldDirection = VectorUtils.TransformDirLocalToWorld(rc.WorldMatrix, direction);
Vector3D worldPos = rc.GetPosition() + worldDirection * distance;
HaE_Entity entity = trackingModule.PaintTarget(worldPos);
if (entity != null)
{
detected = true;
}
}
return(detected);
}
private bool AttemptReScan(HaE_Entity entity)
{
Vector3D Direction = entity.entityInfo.Position - reference.GetPosition();
double distance = Direction.Normalize();
for (int i = 0; i < MaxReScanAmount; i++)
{
Vector3D scanDir = TrackingUtils.GenerateShotgunVector(random, Direction, ReScanConeAngle);
HaE_Entity detected = RaycastDirection(Direction, distance * ReScanMultiplier);
if (detected != null)
{
OnEntityDetected?.Invoke(detected);
return(true);
}
}
return(false);
}
public HaE_Entity PaintTarget(Vector3D position)
{
foreach (var camera in cameras)
{
if (camera.CanScan(position))
{
MyDetectedEntityInfo detected = camera.Raycast(position);
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = detected,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
return(detectedEntity);
}
}
return(null);
}
public void Poll()
{
foreach (var sensor in sensors)
{
if (sensor.Enabled)
{
templist.Clear();
sensor.DetectedEntities(templist);
foreach (var entity in templist)
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = entity,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
OnEntityDetected?.Invoke(detectedEntity);
}
}
}
}
public HaE_Entity PaintTarget(Vector3D position)
{
foreach (var camera in cameras)
{
if ((refExpSettings & EntityTracking_Module.refExpSettings.Lidar) != 0 || (Me?.IsSameConstructAs(camera) ?? true))
{
if (camera.CanScan(position))
{
MyDetectedEntityInfo detected = camera.Raycast(position);
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = detected,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
return(detectedEntity);
}
}
}
return(null);
}
public HaE_Entity PaintTarget(double distance)
{
if (targetingCamera == null)
{
return(null);
}
MyDetectedEntityInfo detected = targetingCamera.Raycast(distance);
if (!detected.IsEmpty())
{
HaE_Entity detectedEntity = new HaE_Entity
{
entityInfo = detected,
LastDetectionTime = DateTime.Now,
trackingType = TRACKINGTYPE
};
return(detectedEntity);
}
return(null);
}
public void OnEntityDetected(HaE_Entity entity)
{
if (Vector3D.DistanceSquared(entity.entityInfo.Position, control.GetPosition()) > 1000 * 1000)
{
return;
}
if (IgnoreEventAfterOnce)
{
return;
}
if (control.GetShipSpeed() < maxActiveRotorGunVel)
{
gridCannonTargeting.NewTarget(entity.entityInfo);
}
else
{
foreach (var cannon in rotorTurretGroups)
{
cannon.TargetDirection(ref Vector3D.Zero);
}
}
statusWriter.UpdateStatus(StatusWriter.TargetingStatus.Targeting);
missileCannonTargeting.NewTarget(entity.entityInfo);
basicTargeting.UpdateValues(control.GetVelocityVector(), control.GetPosition(), maxGatlingBulletVel);
var result = basicTargeting.CalculateTrajectory(entity.entityInfo);
if (result.HasValue)
{
TargetSolvedGatling(result.Value);
}
IgnoreEventAfterOnce = true;
}
public bool Contains(HaE_Entity entity)
{
return(detectedEntitiesSet.Contains(entity));
}
private void WaitForNextLock(HaE_Entity entity)
{
var missile = P.missiles.GetLaunchedMissile(entity.entityInfo.Position);
missile?.RetargetRayCast(entity.entityInfo.Position);
}
