protected override void Update100_Options_TargetingThread(TargetingOptions current)
{
if (CurrentControl == Control.Engager)
{
return;
}
//Log.DebugLog("Turret flag: " + current.FlagSet(TargetingFlags.Turret) + ", No motor turret: " + (MyMotorTurret == null) + ", CanControl = " + CanControl, "Update_Options()");
if (current.FlagSet(TargetingFlags.Turret))
{
if (MyMotorTurret == null && CanControl)
{
//Log.DebugLog("MotorTurret is now enabled", "Update_Options()", Logger.severity.INFO);
MyMotorTurret = new MotorTurret(CubeBlock, MyMotorTurret_OnStatorChange, 1, WeaponDefinition.RequiredAccuracyRadians);
}
}
else
{
if (MyMotorTurret != null)
{
//Log.DebugLog("MotorTurret is now disabled", "Update_Options()", Logger.severity.INFO);
MyMotorTurret.Dispose();
MyMotorTurret = null; // MyMotorTurret will not be updated, so it will be recreated later incase something weird happens to motors
}
}
}
/// <summary>
/// Fill CanTarget from turret
/// </summary>
protected override void Update_Options(TargetingOptions Options)
{
//Options. CanTarget = TargetType.None;
MyObjectBuilder_TurretBase builder = CubeBlock.GetObjectBuilder_Safe() as MyObjectBuilder_TurretBase;
if (builder.TargetMissiles)
Options.CanTarget |= TargetType.Missile;
if (builder.TargetMeteors)
Options.CanTarget |= TargetType.Meteor;
if (builder.TargetCharacters)
Options.CanTarget |= TargetType.Character;
if (builder.TargetMoving)
Options.CanTarget |= TargetType.Moving;
if (builder.TargetLargeGrids)
Options.CanTarget |= TargetType.LargeGrid;
if (builder.TargetSmallGrids)
Options.CanTarget |= TargetType.SmallGrid;
if (builder.TargetStations)
Options.CanTarget |= TargetType.Station;
if (myTurret is Ingame.IMyLargeInteriorTurret && myTurret.BlockDefinition.SubtypeName == "LargeInteriorTurret")
Options.Flags |= TargetingFlags.Interior;
Options.TargetingRange = myTurret.Range;
//myLogger.debugLog("CanTarget = " + Options.CanTarget, "TargetOptionsFromTurret()");
}
protected override void Update_Options(TargetingOptions current)
{
if (ControllingEngager)
return;
//myLogger.debugLog("Turret flag: " + current.FlagSet(TargetingFlags.Turret) + ", No motor turret: " + (MyMotorTurret == null) + ", CanControl = " + CanControl, "Update_Options()");
if (current.FlagSet(TargetingFlags.Turret))
{
if (MyMotorTurret == null && CanControl)
{
myLogger.debugLog("Turret is now enabled", "Update_Options()", Logger.severity.INFO);
MyMotorTurret = new MotorTurret(CubeBlock, MyMotorTurret_OnStatorChange);
AllowedState = State.Targeting;
}
}
else
{
if (MyMotorTurret != null)
{
myLogger.debugLog("Turret is now disabled", "Update_Options()", Logger.severity.INFO);
MyMotorTurret = null; // MyMotorTurret will not be updated, so it will be recreated later incase something weird happens to motors
AllowedState = State.GetOptions;
}
}
}
/// <summary>
/// Updates instructions if necessary.
/// </summary>
public void UpdateInstruction()
{
base.UpdateInstructions(null);
if (!HasInstructions)
{
Options = new TargetingOptions();
}
}
public LastSeenTarget(LastSeen seen, IMyCubeBlock block = null)
{
m_lastSeen = seen;
m_block = block;
m_lastPostion = m_lastSeen.LastKnownPosition;
m_lastPositionUpdate = m_lastSeen.LastSeenAt;
m_targetType = TargetingOptions.GetTargetType(seen.Entity);
}
public void Assimilate(TargetingOptions fallback, TargetType typeFlags, TargetingFlags optFlags, float range, Vector3D targetGolis, long targetEntityId, string[] blocksToTarget)
{
this.CanTarget = typeFlags | fallback.CanTarget;
this.Flags = optFlags | fallback.Flags;
this.TargetingRange = Math.Max(range, fallback.TargetingRange);
this.TargetGolis = targetGolis.IsValid() ? targetGolis : fallback.TargetGolis;
this.TargetEntityId = targetEntityId > 0L ? targetEntityId : fallback.TargetEntityId;
this.blocksToTarget = blocksToTarget ?? fallback.blocksToTarget;
}
protected override bool ParseAll(string instructions)
{
CurrentIndex = -1;
InstructFound = false;
Options = new TargetingOptions();
Errors.Clear();
Parse(instructions);
myLogger.debugLog("leaving, instruct found: " + InstructFound + ", error count: " + Errors.Count);
return InstructFound || Errors.Count == 0;
}
private bool OnInstruction(string instructions)
{
CurrentIndex = -1;
InstructFound = false;
Options = new TargetingOptions();
Errors.Clear();
m_monitor.Clear();
Parse(instructions);
return InstructFound;
}
protected override bool ParseAll(string instructions)
{
CurrentIndex = -1;
InstructFound = false;
Options = new TargetingOptions();
Errors.Clear();
Parse(instructions);
Log.TraceLog("leaving, instruct found: " + InstructFound + ", error count: " + Errors.Count);
return(InstructFound || Errors.Count == 0);
}
/// <summary>
/// Updates instructions if necessary.
/// </summary>
public void UpdateInstruction()
{
if (Block.OwnedNPC())
{
if (FallBackInstruct == null)
{
FallBackInstruct = ServerSettings.GetSettingString(ServerSettings.SettingName.sDefaultWeaponCommandsNPC);
if (string.IsNullOrWhiteSpace(FallBackInstruct))
FallBackInstruct = null;
}
}
else
FallBackInstruct = null;
base.UpdateInstructions();
if (!HasInstructions)
Options = new TargetingOptions();
}
public TargetingBase(IMyEntity entity, IMyCubeBlock controllingBlock)
{
if (entity == null)
{
throw new ArgumentNullException("entity");
}
if (controllingBlock == null)
{
throw new ArgumentNullException("controllingBlock");
}
MyEntity = entity;
CubeBlock = (IMyUserControllableGun)controllingBlock;
myTarget = NoTarget.Instance;
CurrentTarget = myTarget;
Options = new TargetingOptions();
entity.OnClose += Entity_OnClose;
//Log.DebugLog("entity: " + MyEntity.getBestName() + ", block: " + CubeBlock.getBestName(), "TargetingBase()");
}
public TargetingBase(IMyEntity entity, IMyCubeBlock controllingBlock)
{
if (entity == null)
throw new ArgumentNullException("entity");
if (controllingBlock == null)
throw new ArgumentNullException("controllingBlock");
myLogger = new Logger("TargetingBase", entity);
MyEntity = entity;
CubeBlock = controllingBlock;
FuncBlock = controllingBlock as IMyFunctionalBlock;
myTarget = NoTarget.Instance;
CurrentTarget = myTarget;
Options = new TargetingOptions();
entity.OnClose += obj => {
if (WeaponsTargetingProjectile != null)
CurrentTarget = null;
};
//myLogger.debugLog("entity: " + MyEntity.getBestName() + ", block: " + CubeBlock.getBestName(), "TargetingBase()");
}
/// <summary>
/// Fill CanTarget from turret
/// </summary>
protected override void Update100_Options_TargetingThread(TargetingOptions Options)
{
MyLargeTurretBase turret = (MyLargeTurretBase)CubeBlock;
SetFlag(turret.TargetMissiles, TargetType.Missile);
SetFlag(turret.TargetMeteors, TargetType.Meteor);
SetFlag(turret.TargetCharacters, TargetType.Character);
SetFlag(turret.TargetLargeGrids, TargetType.LargeGrid);
SetFlag(turret.TargetSmallGrids, TargetType.SmallGrid);
SetFlag(turret.TargetStations, TargetType.Station);
if (turret.TargetNeutrals)
{
Options.Flags &= ~TargetingFlags.IgnoreOwnerless;
}
else
{
Options.Flags |= TargetingFlags.IgnoreOwnerless;
}
Options.TargetingRange = myTurret.Range;
//Log.DebugLog("CanTarget = " + Options.CanTarget, "TargetOptionsFromTurret()");
}
/// <summary>
/// Fill CanTarget from turret
/// </summary>
protected override void Update100_Options_TargetingThread(TargetingOptions Options)
{
if (TP_TargetMissiles.GetValue(CubeBlock))
Options.CanTarget |= TargetType.Missile;
if (TP_TargetMeteors.GetValue(CubeBlock))
Options.CanTarget |= TargetType.Meteor;
if (TP_TargetCharacters.GetValue(CubeBlock))
Options.CanTarget |= TargetType.Character;
if (TP_TargetMoving.GetValue(CubeBlock))
Options.CanTarget |= TargetType.Moving;
if (TP_TargetLargeGrids.GetValue(CubeBlock))
Options.CanTarget |= TargetType.LargeGrid;
if (TP_TargetSmallGrids.GetValue(CubeBlock))
Options.CanTarget |= TargetType.SmallGrid;
if (TP_TargetStations.GetValue(CubeBlock))
Options.CanTarget |= TargetType.Station;
if (myTurret.Range > Options.TargetingRange)
Options.TargetingRange = myTurret.Range;
if (myTurret is Ingame.IMyLargeInteriorTurret && myTurret.BlockDefinition.SubtypeName == "LargeInteriorTurret")
Options.Flags |= TargetingFlags.Interior;
//myLogger.debugLog("CanTarget = " + Options.CanTarget, "TargetOptionsFromTurret()");
}
public void Assimilate(TargetingOptions fallback, TargetType typeFlags, TargetingFlags optFlags, float range, Vector3D? targetGolis, long? targetEntityId, string[] blocksToTarget)
{
this.CanTarget = typeFlags | fallback.CanTarget;
this.Flags = optFlags | fallback.Flags;
this.TargetingRange = Math.Max(range, fallback.TargetingRange);
this.TargetGolis = targetGolis ?? fallback.TargetGolis;
this.TargetEntityId = targetEntityId ?? fallback.TargetEntityId;
this.blocksToTarget = blocksToTarget ?? fallback.blocksToTarget;
}
/// <summary>Invoked on targeting thread, every 100 updates.</summary> protected abstract void Update_Options(TargetingOptions current);
/// <summary>
/// Targets a LastSeen chosen from the given storage, will overrride current target.
/// </summary>
/// <param name="storage">NetworkStorage to get LastSeen from.</param>
public void GetLastSeenTarget(RelayStorage storage, double range)
{
if (Globals.UpdateCount < m_nextLastSeenSearch)
{
return;
}
m_nextLastSeenSearch = Globals.UpdateCount + 100ul;
if (storage == null)
{
//Log.DebugLog("no storage", "GetLastSeenTarget()", Logger.severity.INFO);
return;
}
if (storage.LastSeenCount == 0)
{
//Log.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)
{
Log.TraceLog("Updating current last seen target");
lst.Update(processing);
CurrentTarget = myTarget;
return;
}
if (ChooseBlock(processing, out targetBlock))
{
Log.TraceLog("Updating current last seen, chose a new block");
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
return;
}
}
if (Options.TargetEntityId > 0L)
{
if (storage.TryGetLastSeen(Options.TargetEntityId, out processing))
{
Log.TraceLog("Got last seen for entity id");
ChooseBlock(processing, out targetBlock);
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
}
//else
// Log.DebugLog("failed to get last seen from entity id", "GetLastSeenTarget()");
return;
}
processing = null;
targetBlock = null;
if (SEAD)
{
throw new NotImplementedException();
//float highestPowerLevel = 0f;
//storage.ForEachLastSeen((LastSeen seen) => {
// if (seen.isRecent() && Options.CanTargetType(seen.Entity) && CanConsiderHostile(seen.Entity))
// {
// IMyCubeBlock block;
// float powerLevel;
// if (RadarEquipment_old.GetRadarEquipment(seen, out block, out powerLevel) && powerLevel > highestPowerLevel)
// {
// highestPowerLevel = powerLevel;
// processing = seen;
// targetBlock = block;
// }
// }
//});
}
else
{
Vector3D myPos = ProjectilePosition();
TargetType bestType = TargetType.LowestPriority;
double maxRange = range * range;
double closestDist = maxRange;
storage.ForEachLastSeen(seen => {
TargetType typeOfSeen = TargetingOptions.GetTargetType(seen.Entity);
if (typeOfSeen <= bestType && Options.CanTargetType(typeOfSeen) && seen.isRecent() && CanConsiderHostile(seen.Entity))
{
IMyCubeBlock block;
if (!ChooseBlock(seen, out block) || !CheckWeaponsTargeting(typeOfSeen, seen.Entity))
{
return;
}
if (typeOfSeen == bestType && targetBlock != null && block == null)
{
return;
}
double dist = Vector3D.DistanceSquared(myPos, seen.LastKnownPosition);
if ((typeOfSeen < bestType && dist < maxRange) || dist < closestDist)
{
closestDist = dist;
bestType = typeOfSeen;
processing = seen;
targetBlock = block;
}
}
});
Log.DebugLog(() => "chose last seen with entity: " + processing.Entity.nameWithId() + ", block: " + targetBlock.getBestName() + ", type: " + bestType + ", distance squared: " + closestDist + ", position: " + processing.Entity.GetPosition(), condition: processing != null);
Log.DebugLog("no last seen target found", condition: processing == null);
}
if (processing == null)
{
if (this is Guided.GuidedMissile)
{
Log.TraceLog("GuidedMissile failed to get LastSeen target, keeping previous");
return;
}
//Log.DebugLog("failed to get a target from last seen", "GetLastSeenTarget()");
myTarget = NoTarget.Instance;
CurrentTarget = myTarget;
}
else
{
myTarget = new LastSeenTarget(processing, targetBlock);
CurrentTarget = myTarget;
}
}
/// <summary>
/// Fill CanTarget from turret
/// </summary>
protected override void Update100_Options_TargetingThread(TargetingOptions Options)
{
SetFlag(TP_TargetMissiles, TargetType.Missile);
SetFlag(TP_TargetMeteors, TargetType.Meteor);
SetFlag(TP_TargetCharacters, TargetType.Character);
SetFlag(TP_TargetMoving, TargetType.Moving);
SetFlag(TP_TargetLargeGrids, TargetType.LargeGrid);
SetFlag(TP_TargetSmallGrids, TargetType.SmallGrid);
SetFlag(TP_TargetStations, TargetType.Station);
Options.TargetingRange = myTurret.Range;
//myLogger.debugLog("CanTarget = " + Options.CanTarget, "TargetOptionsFromTurret()");
}
private void Update100()
{
CheckCustomInfo();
if (!CanControl)
{
myLogger.debugLog("cannot control", "Update100()");
DefaultTargeting = true;
Options.Flags = TargetingFlags.None;
return;
}
IsFiringWeapon = TPro_Shoot.GetValue(CubeBlock);
ClearBlacklist();
//if (RunTargeting || GuidedLauncher)
if ((CubeBlock.DisplayNameText.Contains("[") && CubeBlock.DisplayNameText.Contains("]")) || CubeBlock.OwnedNPC())
{
Interpreter.UpdateInstruction();
if (Interpreter.Errors.Count <= InterpreterErrorCount)
{
if (Interpreter.Options == null)
Options = new TargetingOptions();
else
Options = Interpreter.Options.Clone();
InterpreterErrorCount = Interpreter.Errors.Count;
//ArmsGuiWeapons.UpdateTerm(FuncBlock, Options);
Update100_Options_TargetingThread(Options);
myLogger.debugLog("updating Options, Error Count = " + Interpreter.Errors.Count + ", Options: " + Options, "Update100()");
}
else
myLogger.debugLog("not updating Options, Error Count = " + Interpreter.Errors.Count, "Update100()");
DefaultTargeting = false;
WriteErrors(Interpreter.Errors);
}
else
{
myLogger.debugLog("Not running targeting", "Update100()");
DefaultTargeting = true;
//ArmsGuiWeapons.UpdateArmsEnabled(FuncBlock, Options);
}
}
/// <summary>Invoked on targeting thread, every 100 updates, if targeting is permitted.</summary> protected abstract void Update100_Options_TargetingThread(TargetingOptions current);
