private void AllLastSeen(RelayStorage store)
{
Vector3D myPos = m_block.GetPosition();
store.ForEachLastSeen((LastSeen seen) => {
IMyCubeGrid grid = seen.Entity as IMyCubeGrid;
if (grid != null && AttachedGrid.IsGridAttached(m_block.CubeGrid, grid, AttachedGrid.AttachmentKind.Physics))
{
return;
}
ExtensionsRelations.Relations relations = m_block.getRelationsTo(seen.Entity, ExtensionsRelations.Relations.Enemy).highestPriority();
m_sortableList.Add(new sortableLastSeen(myPos, seen, relations, m_options));
//Log.DebugLog("item: " + seen.Entity.getBestName() + ", relations: " + relations, "Display()");
});
}
/// <summary>
/// Looks for a missile threating the ship the player is controlling.
/// </summary>
private void UpdateMissileThreat()
{
if (!(m_controlled is IMyCubeBlock))
{
//Log.DebugLog("not controlling a ship");
return;
}
if (m_storage == null)
{
Log.TraceLog("no storage getter");
return;
}
RelayStorage store = m_storage.Invoke();
if (store == null)
{
Log.TraceLog("no storage");
return;
}
byte timeToImpact = byte.MaxValue;
m_threat = null;
store.ForEachLastSeen((LastSeen seen) => {
if (seen.Type == LastSeen.EntityType.Missile)
{
GuidedMissile guided;
if (Registrar.TryGetValue(seen.Entity, out guided) && IsThreat(guided))
{
Log.DebugLog("threat: " + guided.MyEntity, Logger.severity.TRACE);
byte tti;
if (GetTimeToImpact(guided, out tti) && tti < timeToImpact)
{
timeToImpact = tti;
m_threat = guided;
}
}
}
});
}
private void UpdateGPS()
{
byte newInterval = UserSettings.GetSetting(UserSettings.ByteSettingName.UpdateIntervalHUD);
if (newInterval != m_updateIntervalGPS)
{
Log.DebugLog("Update interval changed from " + m_updateIntervalGPS + " to " + newInterval, Logger.severity.DEBUG);
UpdateManager.Unregister(m_updateIntervalGPS, UpdateGPS);
UpdateManager.Register(newInterval, UpdateGPS);
m_updateIntervalGPS = newInterval;
}
if (m_storage == null)
{
Log.TraceLog("no storage getter");
return;
}
RelayStorage store = m_storage.Invoke();
if (store == null)
{
Log.TraceLog("no storage");
return;
}
if (store.LastSeenCount == 0)
{
Log.TraceLog("No LastSeen");
return;
}
Vector3D myPosition = m_controlled.GetPosition();
foreach (var pair in Data)
{
pair.Value.MaxOnHUD = UserSettings.GetSetting(pair.Key);
pair.Value.Prepare();
}
Log.TraceLog("primary node: " + store.PrimaryNode.DebugName);
m_haveTerminalAccess.Clear();
foreach (RelayNode node in Registrar.Scripts <RelayNode>())
{
MyCubeGrid grid = (node.Entity as MyCubeBlock)?.CubeGrid;
Log.TraceLog("grid: " + grid.nameWithId() + ", node storage: " + node.GetStorage()?.PrimaryNode.DebugName);
if (grid != null && node.GetStorage()?.PrimaryNode == store.PrimaryNode && m_haveTerminalAccess.Add(grid))
{
foreach (var aGrid in Attached.AttachedGrid.AttachedGrids(grid, Attached.AttachedGrid.AttachmentKind.Terminal, true))
{
m_haveTerminalAccess.Add(aGrid);
}
}
}
store.ForEachLastSeen((LastSeen seen) => {
Log.TraceLog("seen: " + seen.Entity.nameWithId());
if (!seen.isRecent())
{
Log.TraceLog("not recent: " + seen.Entity.nameWithId());
return;
}
if (seen.isRecent_Broadcast())
{
Log.TraceLog("already visible: " + seen.Entity.getBestName());
return;
}
if (seen.Entity is IMyCubeGrid && m_haveTerminalAccess.Contains((IMyCubeGrid)seen.Entity))
{
Log.TraceLog("terminal linked: " + seen.Entity.nameWithId());
return;
}
UserSettings.ByteSettingName setting;
if (!CanDisplay(seen, out setting))
{
Log.TraceLog("cannot display: " + seen.Entity.nameWithId());
return;
}
GpsData relateData;
if (!Data.TryGetValue(setting, out relateData))
{
Log.DebugLog("failed to get setting data, setting: " + setting, Logger.severity.WARNING);
return;
}
if (relateData.MaxOnHUD == 0)
{
Log.TraceLog("type not permitted: " + seen.Entity.nameWithId());
return;
}
Log.TraceLog("approved: " + seen.Entity.nameWithId());
float distance = Vector3.DistanceSquared(myPosition, seen.GetPosition());
relateData.distanceSeen.Add(new DistanceSeen(distance, seen));
});
m_haveTerminalAccess.Clear();
foreach (var pair in Data)
{
UpdateGPS(pair.Key, pair.Value);
}
}
/// <summary>
/// Check opts, load/unload
/// </summary>
public void Update100()
{
if (m_holoEntities.Count != 0 && DateTime.UtcNow >= m_clearAllAt)
{
Log.DebugLog("clearing all holo entities");
foreach (SeenHolo sh in m_holoEntities.Values)
{
Log.DebugLog("removing " + sh.Seen.Entity.EntityId + "from m_holoEntities (clear all)");
OnRemove(sh);
}
m_holoEntities.Clear();
}
if (!Enabled)
{
return;
}
Vector3D playerPos = MyAPIGateway.Session.Player.GetPosition(), holoCentre = m_offset.ToWorld(m_block);
double distSquared = Vector3D.DistanceSquared(playerPos, holoCentre);
m_playerCanSee = distSquared <= 1e4d;
if (m_playerCanSee && distSquared > 100d)
{
List <MyLineSegmentOverlapResult <MyEntity> > entitiesInRay = ResourcePool <List <MyLineSegmentOverlapResult <MyEntity> > > .Get();
m_playerCanSee = false;
MyEntity[] ignore = new MyEntity[] { (MyEntity)MyAPIGateway.Session.Player.Controller.ControlledEntity };
foreach (Vector3 vector in Static.Directions)
{
LineD ray = new LineD(playerPos, holoCentre + vector * m_radiusHolo);
MyGamePruningStructure.GetTopmostEntitiesOverlappingRay(ref ray, entitiesInRay);
if (!RayCast.Obstructed(ray, entitiesInRay.Select(overlap => overlap.Element), ignore))
{
m_playerCanSee = true;
entitiesInRay.Clear();
break;
}
entitiesInRay.Clear();
}
ResourcePool <List <MyLineSegmentOverlapResult <MyEntity> > > .Return(entitiesInRay);
}
if (!m_playerCanSee)
{
return;
}
RelayStorage storage = m_netClient.GetStorage();
if (storage == null)
{
((IMyTerminalBlock)m_block).AppendCustomInfo("No network connection");
return;
}
m_clearAllAt = DateTime.UtcNow + Static.keepInCache;
storage.ForEachLastSeen(CreateHolo);
foreach (SeenHolo sh in m_holoEntities.Values)
{
if (CanDisplay(sh.Seen))
{
if (!sh.Holo.Render.Visible)
{
Log.DebugLog("showing holo: " + sh.Seen.Entity.getBestName());
SetupProjection(sh.Holo);
SetVisible(sh.Holo, true);
}
if (sh.Seen.Entity is MyCubeGrid && sh.ColouredByIntegrity != ((m_options & Option.IntegrityColours) != 0))
{
if (sh.ColouredByIntegrity)
{
RestoreColour(sh);
}
else
{
ColourByIntegrity(sh);
}
}
}
else if (sh.Holo.Render.Visible)
{
Log.DebugLog("hiding holo: " + sh.Seen.Entity.getBestName());
SetVisible(sh.Holo, false);
}
}
if (m_holoEntitiesRemove.Count != 0)
{
foreach (long entityId in m_holoEntitiesRemove)
{
Log.DebugLog("removing " + entityId + "from m_holoEntities");
SeenHolo sh;
if (!m_holoEntities.TryGetValue(entityId, out sh))
{
// this may be normal
Log.DebugLog("not in m_holoEntities: " + entityId, Logger.severity.WARNING);
continue;
}
OnRemove(sh);
m_holoEntities.Remove(entityId);
}
m_holoEntitiesRemove.Clear();
}
}
/// <summary>
/// Creates the parameter for the block and runs the program.
/// </summary>
private void HandleDetected()
{
if (m_progBlock.IsRunning)
{
return;
}
StringBuilder parameter = new StringBuilder();
bool first = true;
RelayStorage store = m_networkClient.GetStorage();
if (store == null)
{
return;
}
store.ForEachLastSeen((LastSeen seen) => {
ExtensionsRelations.Relations relations = (m_progBlock as IMyCubeBlock).getRelationsTo(seen.Entity, ExtensionsRelations.Relations.Enemy).highestPriority();
bool friendly = ExtensionsRelations.toIsFriendly(relations);
string bestName = friendly ? seen.Entity.getBestName() : seen.HostileName();
TimeSpan sinceSeen;
Vector3D predictedPosition = seen.predictPosition(out sinceSeen);
if (first)
{
first = false;
}
else
{
parameter.Append(entitySeparator);
}
parameter.Append(seen.Entity.EntityId); parameter.Append(fieldSeparator);
parameter.Append((byte)relations); parameter.Append(fieldSeparator);
parameter.Append((byte)seen.Type); parameter.Append(fieldSeparator);
parameter.Append(bestName); parameter.Append(fieldSeparator);
parameter.Append(seen.isRecent_Radar()); parameter.Append(fieldSeparator);
parameter.Append(seen.isRecent_Jam()); parameter.Append(fieldSeparator);
parameter.Append((int)sinceSeen.TotalSeconds); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(predictedPosition.X, 1)); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(predictedPosition.Y, 1)); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(predictedPosition.Z, 1)); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(seen.LastKnownVelocity.X, 1)); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(seen.LastKnownVelocity.Y, 1)); parameter.Append(fieldSeparator);
parameter.Append(Math.Round(seen.LastKnownVelocity.Z, 1)); parameter.Append(fieldSeparator);
if (seen.RadarInfoIsRecent())
{
parameter.Append(seen.Info.Volume);
}
else
{
parameter.Append(0f);
}
if (!friendly && seen.Type == LastSeen.EntityType.Grid && m_blockCountList_sb.Length > 2 && seen.isRecent() && m_blockCountList_btl != null)
{
int[] blockCounts = m_blockCountList_btl.Count(CubeGridCache.GetFor((IMyCubeGrid)seen.Entity));
if (blockCounts.Length != 0)
{
parameter.Append(fieldSeparator);
parameter.Append(string.Join(fieldSeparator.ToString(), blockCounts));
}
}
});
if (parameter.Length == 0)
{
Log.DebugLog("no detected entities");
return;
}
//Log.DebugLog("parameters:\n" + parameter.ToString().Replace(string.Empty + entitySeparator, entitySeparator + "\n"));
if (!m_progBlock.TryRun(parameter.ToString()))
{
Log.AlwaysLog("Failed to run program", Logger.severity.INFO);
}
}
/// <summary>
/// Targets a LastSeen chosen from the given storage, will overrride current target.
/// </summary>
/// <param name="storage">NetworkStorage to get LastSeen from.</param>
protected void GetLastSeenTarget(RelayStorage storage, double range)
{
if (Globals.UpdateCount < m_nextLastSeenSearch)
return;
m_nextLastSeenSearch = Globals.UpdateCount + 100ul;
if (storage == null)
{
//myLogger.debugLog("no storage", "GetLastSeenTarget()", Logger.severity.INFO);
return;
}
if (storage.LastSeenCount == 0)
{
//myLogger.debugLog("no last seen in storage", "GetLastSeenTarget()", Logger.severity.DEBUG);
return;
}
LastSeen processing;
IMyCubeBlock targetBlock;
if (CurrentTarget.Entity != null && storage.TryGetLastSeen(CurrentTarget.Entity.EntityId, out processing) && processing.isRecent())
{
LastSeenTarget lst = myTarget as LastSeenTarget;
if (lst != null && lst.Block != null && !lst.Block.Closed)
{
lst.Update(processing);
CurrentTarget = myTarget;
return;
}
if (ChooseBlock(processing, out targetBlock))
{
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
return;
}
}
if (Options.TargetEntityId.HasValue)
{
if (storage.TryGetLastSeen(Options.TargetEntityId.Value, out processing))
{
ChooseBlock(processing, out targetBlock);
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
}
//else
// myLogger.debugLog("failed to get last seen from entity id", "GetLastSeenTarget()");
return;
}
processing = null;
targetBlock = null;
if (SEAD)
{
float highestPowerLevel = 0f;
storage.ForEachLastSeen((LastSeen seen) => {
if (seen.isRecent() && CubeBlock.canConsiderHostile(seen.Entity) && Options.CanTargetType(seen.Entity))
{
IMyCubeBlock block;
float powerLevel;
if (RadarEquipment.GetRadarEquipment(seen, out block, out powerLevel) && powerLevel > highestPowerLevel)
{
highestPowerLevel = powerLevel;
processing = seen;
targetBlock = block;
}
}
});
}
else
{
// choose closest grid
Vector3D myPos = ProjectilePosition();
double closestDist = range * range;
storage.ForEachLastSeen(seen => {
if (seen.isRecent() && CubeBlock.canConsiderHostile(seen.Entity) && Options.CanTargetType(seen.Entity))
{
IMyCubeBlock block;
if (!ChooseBlock(seen, out block))
return;
// always prefer a grid with a block
if (targetBlock != null && block == null)
return;
double dist = Vector3D.DistanceSquared(myPos, seen.LastKnownPosition);
if (dist < closestDist)
{
closestDist = dist;
processing = seen;
targetBlock = block;
}
}
});
}
if (processing == null)
{
//myLogger.debugLog("failed to get a target from last seen", "GetLastSeenTarget()");
myTarget = NoTarget.Instance;
CurrentTarget = myTarget;
}
else
{
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
}
}
