630 lines
25 KiB
Plaintext
630 lines
25 KiB
Plaintext
|
# ****************************************************************************
|
||
|
|
# CUI
|
||
|
|
#
|
||
|
|
# The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
|
||
|
|
#
|
||
|
|
# The use, dissemination or disclosure of data in this file is subject to
|
||
|
|
# limitation or restriction. See accompanying README and LICENSE for details.
|
||
|
|
# ****************************************************************************
|
||
|
|
|
||
|
|
|
||
|
|
##############################################################################
|
||
|
|
### assumes exists: #extern string GetWeaponForThreat(WsfPlatform, WsfTrack);
|
||
|
|
##############################################################################
|
||
|
|
|
||
|
|
behavior engage-target
|
||
|
|
|
||
|
|
script_debug_writes off
|
||
|
|
|
||
|
|
script_variables
|
||
|
|
|
||
|
|
//**********************************************************************//
|
||
|
|
//** platform / agent specific shooting parameters **//
|
||
|
|
//**********************************************************************//
|
||
|
|
bool mCoopEngageOne = false;
|
||
|
|
bool mCoopEngageOneFlightOnly = false;
|
||
|
|
|
||
|
|
//specify any targets here that you will always shoot at...
|
||
|
|
//even disregarding other targets to do so. (use types or names)
|
||
|
|
Array<string> mMustShootAtCategories = Array<string>();
|
||
|
|
mMustShootAtCategories[0] = "sam";
|
||
|
|
mMustShootAtCategories[1] = "FIRE_CONTROL";
|
||
|
|
|
||
|
|
double mDegradedFiringAngle = 55.0; //negative if not valid
|
||
|
|
double mDegradedPercentRange = 0.50; //range constraint if past degraded firing angle
|
||
|
|
|
||
|
|
//specify orientation limits for shooting
|
||
|
|
double mMaxFiringRollAngle = 10.0; //dont shoot if rolled more/less than this
|
||
|
|
double mMaxFiringPitchAngle = 15.0; //dont shoot if pitched more than this
|
||
|
|
double mMinFiringPitchAngle = -10.0; //dont shoot if pitched less than this
|
||
|
|
|
||
|
|
|
||
|
|
//**********************************************************************//
|
||
|
|
//** threat specific shooting parameters **//
|
||
|
|
//**********************************************************************//
|
||
|
|
|
||
|
|
//require different track qualities to fire on different kinds of threats
|
||
|
|
double DefaultRequiredTrackQuality = 0.49;
|
||
|
|
Map<string, double> ThreatTypeRequiredTrackQuality = Map<string, double>();
|
||
|
|
ThreatTypeRequiredTrackQuality["bomber"] = 0.49;
|
||
|
|
ThreatTypeRequiredTrackQuality["fighter"] = 0.49;
|
||
|
|
|
||
|
|
//fire off different salvos at different types of threats
|
||
|
|
int DefaultAirSalvo = 1;
|
||
|
|
int DefaultGndSalvo = 1;
|
||
|
|
Map<string, int> ThreatTypeSalvo = Map<string, int>();
|
||
|
|
ThreatTypeSalvo["sam"] = 2;
|
||
|
|
ThreatTypeSalvo["ship"] = 2;
|
||
|
|
ThreatTypeSalvo["bomber"] = 2;
|
||
|
|
ThreatTypeSalvo["fighter"] = 1;
|
||
|
|
ThreatTypeSalvo["FIRE_CONTROL"] = 1;
|
||
|
|
ThreatTypeSalvo["primary_target"] = 2;
|
||
|
|
ThreatTypeSalvo["secondary_target"] = 2;
|
||
|
|
|
||
|
|
//force a specific weapon for use against given threat type
|
||
|
|
Map<string, string> ThreatTypeWeapon = Map<string, string>();
|
||
|
|
//ThreatTypeWeapon["uav"] = "srm";
|
||
|
|
//ThreatTypeWeapon["fighter"] = "lrm";
|
||
|
|
|
||
|
|
|
||
|
|
//**********************************************************************//
|
||
|
|
//** weapon + threat specific shooting parameters **//
|
||
|
|
//**********************************************************************//
|
||
|
|
|
||
|
|
//specify an Rmax based on which weapon used and which threat engaged
|
||
|
|
double DefaultPercentRangeMax = 0.80; // don't launch unless within this percent of Rmax
|
||
|
|
double DefaultPercentRangeMin = 1.20; // don't launch unless beyond this percent of Rmin
|
||
|
|
Map<string, Map<string, double>> WeaponThreatRmaxMap = Map<string, Map<string, double>>();
|
||
|
|
WeaponThreatRmaxMap["base_weapon"] = Map<string, double>();
|
||
|
|
WeaponThreatRmaxMap["base_weapon"].Set("fighter", 0.80);
|
||
|
|
|
||
|
|
//specify max firing angles based on weapon used and threat engaged
|
||
|
|
double DefaultMaxFiringAngle = 45.0;
|
||
|
|
Map<string, Map<string, double>> WeaponThreatAngleMap = Map<string, Map<string, double>>();
|
||
|
|
WeaponThreatAngleMap["base_weapon"] = Map<string, double>();
|
||
|
|
WeaponThreatAngleMap["base_weapon"].Set("fighter", 45.0);
|
||
|
|
WeaponThreatAngleMap["base_weapon"].Set("missile", 30.0);
|
||
|
|
|
||
|
|
|
||
|
|
//**********************************************************************//
|
||
|
|
//********* VARIABLES BELOW THIS LINE ARE NOT FOR USER EDITING *********//
|
||
|
|
//**********************************************************************//
|
||
|
|
double mInactiveLaunchDelay = 1.0; // wait 1 seconds after your last missile detonated.
|
||
|
|
// hacky, useful for weapons that dont show active
|
||
|
|
Map<string,double> mTrackWeaponActiveMap = Map<string,double>();
|
||
|
|
Map<WsfTrack, double> mRoundsFiredAtMap = Map<WsfTrack, double>(); //useful when weapons don't show as active
|
||
|
|
|
||
|
|
end_script_variables
|
||
|
|
|
||
|
|
|
||
|
|
script bool MustShootAt(WsfTrack track)
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( track.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
foreach( string aCategory in mMustShootAtCategories )
|
||
|
|
{
|
||
|
|
if( plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
script int GetSalvoForThreat(WsfTrack track)
|
||
|
|
|
||
|
|
#writeln_d("checking salvo size for category: ", category);
|
||
|
|
|
||
|
|
#WsfPlatform plat = WsfSimulation.FindPlatform( track.TargetIndex() );
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( track.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
foreach( string aCategory : int salvo in ThreatTypeSalvo )
|
||
|
|
{
|
||
|
|
if( plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
writeln_d("salvo for type ", aCategory, " = ", salvo);
|
||
|
|
return salvo;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
#extern string GetTargetDomain(WsfTrack);
|
||
|
|
string sTargetDomain = GetTargetDomain(track);
|
||
|
|
if ( (sTargetDomain == "LAND") || (sTargetDomain == "SURFACE") )
|
||
|
|
{
|
||
|
|
return DefaultGndSalvo;
|
||
|
|
}
|
||
|
|
return DefaultAirSalvo;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
script double GetRequiredTrackQualityForThreat(WsfTrack threat)
|
||
|
|
writeln_d("checking required TQ for track: ", threat.TargetName());
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( threat.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
foreach( string aCategory : double quality in ThreatTypeRequiredTrackQuality )
|
||
|
|
{
|
||
|
|
if( plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
writeln_d("TQ for type ", aCategory, " = ", quality);
|
||
|
|
return quality;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return DefaultRequiredTrackQuality;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
script double GetLaunchPercentRangeMaxOnThreat(string weaponName, WsfTrack threat)
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( threat.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
if (WeaponThreatRmaxMap.Exists(weaponName))
|
||
|
|
{
|
||
|
|
Map<string, double> categoryRangeMap = WeaponThreatRmaxMap.Get(weaponName);
|
||
|
|
foreach (string aCategory : double percent in categoryRangeMap)
|
||
|
|
{
|
||
|
|
if( plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
return percent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return DefaultPercentRangeMax;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
script double GetMaxFiringAngleForWeapon(string weaponName, WsfTrack threat)
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( threat.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
if (WeaponThreatAngleMap.Exists(weaponName))
|
||
|
|
{
|
||
|
|
Map<string, double> threatAngleMap = WeaponThreatAngleMap.Get(weaponName);
|
||
|
|
foreach (string aCategory : double angle in threatAngleMap)
|
||
|
|
{
|
||
|
|
if( plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
return angle;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return DefaultMaxFiringAngle;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
script string GetWeaponForThreat(WsfPlatform platform, WsfTrack track)
|
||
|
|
bool checkName = false;
|
||
|
|
string name = "";
|
||
|
|
#extern bool IsWeaponDomainCapable(WsfTrack, Map<string, Object>);
|
||
|
|
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( track.TargetName() );
|
||
|
|
if (plat.IsValid())
|
||
|
|
{
|
||
|
|
foreach( string aCategory : string wpnStr in ThreatTypeWeapon )
|
||
|
|
{
|
||
|
|
writeln_d("checking if ", plat.Name(), " is category: ", aCategory);
|
||
|
|
if( wpnStr.Length()>0 && plat.CategoryMemberOf( aCategory ) )
|
||
|
|
{
|
||
|
|
checkName = true;
|
||
|
|
name = wpnStr;
|
||
|
|
writeln_d(" Time= ", TIME_NOW, " ", PLATFORM.Name(), " searching only for weapon category: ", name, " (for use against ", plat.Name(), ")");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
writeln_d("platform for target ", track.TargetName()," is not valid!");
|
||
|
|
}
|
||
|
|
|
||
|
|
extern Array<Map<string, Object>> mWeaponArray;
|
||
|
|
foreach (Map<string, Object> curWeapon in mWeaponArray)
|
||
|
|
{
|
||
|
|
string weaponName = (string)curWeapon["name"];
|
||
|
|
WsfWeapon weapon = (WsfWeapon)curWeapon["weapon"];
|
||
|
|
|
||
|
|
writeln_d(" checking weapon ", weaponName, " valid=", weapon.IsValid());
|
||
|
|
|
||
|
|
if (checkName && weaponName != name)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (weapon.QuantityRemaining() <= 0)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (!IsWeaponDomainCapable(track,curWeapon))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
WsfLaunchComputer lcPtr = weapon.LaunchComputer();
|
||
|
|
|
||
|
|
if (lcPtr.IsValid() &&
|
||
|
|
lcPtr.IsA_TypeOf("WSF_AIR_TO_AIR_LAUNCH_COMPUTER"))
|
||
|
|
{
|
||
|
|
writeln_d(" using air-to-air launch computer");
|
||
|
|
|
||
|
|
// The returned array contains: Rmax, RmaxTOF, Rne, RneTOF, Rmin, RminTOF
|
||
|
|
// in that order. -1.0 means "not valid".
|
||
|
|
|
||
|
|
Array<double> returnedValues = lcPtr.LookupResult(track);
|
||
|
|
|
||
|
|
// Now have to consider whether we have enough information to continue with a weapon shot:
|
||
|
|
double theRmax = returnedValues[0]; //"Rmax";
|
||
|
|
double theRmaxTOF = returnedValues[1]; //"RmaxTOF";
|
||
|
|
double theRne = returnedValues[2]; //"Rne";
|
||
|
|
double theRneTOF = returnedValues[3]; //"RneTOF";
|
||
|
|
double theRmin = returnedValues[4]; //"Rmin";
|
||
|
|
double theRminTOF = returnedValues[5]; //"RminTOF";
|
||
|
|
|
||
|
|
double range = 0.0;
|
||
|
|
if (track.RangeValid())
|
||
|
|
{
|
||
|
|
range = track.Range(); #is this the range from you to the track, or the range from the sensor to the track?
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
range = track.GroundRangeTo(PLATFORM);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for track range less than Rmin * scaleFactor, if not, return.
|
||
|
|
// But do not check for min range constraint at all unless we are likely to be needing it.
|
||
|
|
if (range < 5000)
|
||
|
|
{
|
||
|
|
if (theRmin == -1.0)
|
||
|
|
{
|
||
|
|
writeln_d(" Engagement did not shoot since Rmin was not valid.");
|
||
|
|
continue;
|
||
|
|
#return;
|
||
|
|
}
|
||
|
|
double RminConstraint = theRmin * DefaultPercentRangeMin;
|
||
|
|
if (range < RminConstraint)
|
||
|
|
{
|
||
|
|
writeln_d(" Engagement did not shoot since inside the k * Rmin constraint distance.");
|
||
|
|
writeln_d(" Range versus Rmin constraint = ", range, ", ", RminConstraint);
|
||
|
|
continue;
|
||
|
|
#return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Check for track range less than Rne, if so, FORCE a weapon fire.
|
||
|
|
bool forceWeaponFire = false;
|
||
|
|
if (range < theRne)
|
||
|
|
{
|
||
|
|
writeln_d(" Engagement is forcing a weapon fire due to inside Rne.");
|
||
|
|
writeln_d(" Range versus Rne constraint = ", range, ", ", theRne);
|
||
|
|
forceWeaponFire = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (forceWeaponFire == false)
|
||
|
|
{
|
||
|
|
######################################TRY THIS######################################
|
||
|
|
WsfPlatform plat = WsfSimulation.FindPlatform( track.TargetName() );
|
||
|
|
if (plat.IsValid() && plat.CategoryMemberOf("fighter"))
|
||
|
|
{
|
||
|
|
#theRmax = theRne;
|
||
|
|
theRmax = (theRmax + theRne)/2.0; //for highly maneuverable fighter targets
|
||
|
|
}
|
||
|
|
####################################END TRY THIS####################################
|
||
|
|
// Check for track range less than k * Rmax, if not, return.
|
||
|
|
if (theRmax == -1.0)
|
||
|
|
{
|
||
|
|
writeln_d(" Engagement did not shoot since Rmax was not valid.");
|
||
|
|
continue;
|
||
|
|
#return;
|
||
|
|
}
|
||
|
|
//double RmaxConstraint = theRmax * DefaultPercentRangeMax;
|
||
|
|
double percentRMax = GetLaunchPercentRangeMaxOnThreat(weaponName, track);
|
||
|
|
double RmaxConstraint = theRmax * percentRMax;
|
||
|
|
if (range > RmaxConstraint)
|
||
|
|
{
|
||
|
|
writeln_d(" Engagement did not shoot since outside the k * Rmax constraint distance.");
|
||
|
|
writeln_d(" Range versus Rne constraint = ", range, ", ", theRne);
|
||
|
|
continue;
|
||
|
|
#return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
writeln_d(" Engagement meets constraints for firing a weapon (continue).");
|
||
|
|
}
|
||
|
|
else if (lcPtr.IsValid() &&
|
||
|
|
lcPtr.IsA_TypeOf("WSF_ATG_LAUNCH_COMPUTER"))
|
||
|
|
{
|
||
|
|
writeln_d(" using air-to-ground launch computer");
|
||
|
|
if (lcPtr.CanIntercept(track))
|
||
|
|
{
|
||
|
|
//intercept works, this weapon is a candidate
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
writeln_d(" using script input mWeaponArray array range values");
|
||
|
|
|
||
|
|
//check our own ranges & angles --> hacky!!!
|
||
|
|
|
||
|
|
#extern double EffectiveRange(WsfPlatform, WsfTrack);
|
||
|
|
double effectiveRange = EffectiveRange(platform, track);
|
||
|
|
double absRelativeBearing = MATH.Fabs(PLATFORM.RelativeBearingTo( track ));
|
||
|
|
double rangeScale = GetLaunchPercentRangeMaxOnThreat(weaponName, track);
|
||
|
|
if (absRelativeBearing > mDegradedFiringAngle)
|
||
|
|
{
|
||
|
|
rangeScale = MATH.Min(mDegradedPercentRange, rangeScale);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((double)curWeapon["rangeMin"] > effectiveRange)
|
||
|
|
{
|
||
|
|
writeln_d(" target too close");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (absRelativeBearing > GetMaxFiringAngleForWeapon(weaponName, track))
|
||
|
|
{
|
||
|
|
writeln_d(" target firing angle too large");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if ((double)curWeapon["rangeMax"] * rangeScale < effectiveRange)
|
||
|
|
{
|
||
|
|
writeln_d(" target too far away");
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
double TOF = 180;
|
||
|
|
double missileAvgSpeed = 1000;
|
||
|
|
if (curWeapon.Exists("avgSpeed"))
|
||
|
|
{
|
||
|
|
missileAvgSpeed = (double)curWeapon["avgSpeed"];
|
||
|
|
}
|
||
|
|
if (curWeapon.Exists("TOF"))
|
||
|
|
{
|
||
|
|
TOF = (double)curWeapon["TOF"];
|
||
|
|
}
|
||
|
|
double range = PLATFORM.SlantRangeTo(track);
|
||
|
|
//double closingSpeed = PLATFORM.ClosingSpeedOf(track);
|
||
|
|
double relBearing = track.RelativeBearingTo(PLATFORM);
|
||
|
|
if (relBearing > 90.0)
|
||
|
|
{
|
||
|
|
if (track.Speed() > missileAvgSpeed)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
double speedDiff = missileAvgSpeed - track.Speed();
|
||
|
|
if ((range/speedDiff) > TOF)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return (string)curWeapon["name"];
|
||
|
|
}
|
||
|
|
return "";
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
#on_init
|
||
|
|
#end_on_init
|
||
|
|
|
||
|
|
|
||
|
|
precondition
|
||
|
|
writeln_d("precondition engage-target");
|
||
|
|
|
||
|
|
if (!PROCESSOR.IsA_TypeOf("WSF_RIPR_PROCESSOR"))
|
||
|
|
{
|
||
|
|
return Failure("behavior not attached to a RIPR processor!");
|
||
|
|
}
|
||
|
|
|
||
|
|
#extern WsfTrack GetTrackByName(WsfPlatform, string);
|
||
|
|
|
||
|
|
double pitch = PLATFORM.Pitch();
|
||
|
|
if (MATH.Fabs(PLATFORM.Roll()) > mMaxFiringRollAngle ||
|
||
|
|
pitch > mMaxFiringPitchAngle ||
|
||
|
|
pitch < mMinFiringPitchAngle)
|
||
|
|
{
|
||
|
|
string msgStr = write_str(" ", PLATFORM.Name(), " orientation too far off to fire! (roll or pitch)");
|
||
|
|
writeln_d(msgStr);
|
||
|
|
//PLATFORM.Comment(msgStr);
|
||
|
|
return Failure(msgStr);
|
||
|
|
}
|
||
|
|
|
||
|
|
WsfRIPRProcessor commander = ((WsfRIPRProcessor)PROCESSOR).GetRIPRCommanderProcessor();
|
||
|
|
if (commander.IsValid())
|
||
|
|
{
|
||
|
|
#check all job channels, not just the main target
|
||
|
|
for (int channel = 0; channel < ((WsfRIPRProcessor)PROCESSOR).GetNumJobChannels(); channel = channel + 1)
|
||
|
|
{
|
||
|
|
WsfRIPRJob aJob = commander.GetJobFor(((WsfRIPRProcessor)PROCESSOR), channel);
|
||
|
|
if (aJob.IsValid() &&
|
||
|
|
aJob.Name() == "pursue-target")
|
||
|
|
{
|
||
|
|
string targetName = (string)aJob.GetData("targetTrackName");
|
||
|
|
WsfTrack targetTrack = GetTrackByName(PLATFORM, targetName);
|
||
|
|
if (!targetTrack.IsNull() &&
|
||
|
|
targetTrack.IsValid())
|
||
|
|
{
|
||
|
|
#extern bool TestTrackCategory( WsfTrack, string );
|
||
|
|
if (!TestTrackCategory(targetTrack, "unknown") &&
|
||
|
|
targetTrack.BelievedAlive())
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return Failure("no acceptable target to shoot at!");
|
||
|
|
end_precondition
|
||
|
|
|
||
|
|
|
||
|
|
script bool FireWeapon(WsfTrack targetTrack)
|
||
|
|
bool launched = false;
|
||
|
|
|
||
|
|
writeln_d(" Time= ", TIME_NOW, " Attempting a shot against: ", targetTrack.TargetName(), " Index: ", targetTrack.TargetIndex(), " Type: ", targetTrack.TargetType());
|
||
|
|
|
||
|
|
#extern bool TestTrackCategory(WsfTrack, string);
|
||
|
|
if (!TestTrackCategory(targetTrack, "unknown") &&
|
||
|
|
targetTrack.BelievedAlive())
|
||
|
|
{
|
||
|
|
if ((((WsfRIPRProcessor)PROCESSOR).WeaponsActive(targetTrack) > 0) ||
|
||
|
|
(((WsfRIPRProcessor)PROCESSOR).PeersWeaponsActive(targetTrack) > 0))
|
||
|
|
{
|
||
|
|
mTrackWeaponActiveMap[targetTrack.TargetName()] = TIME_NOW;
|
||
|
|
writeln_d(" FAIL: Weapons already active against ", targetTrack.TargetName());
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
writeln_d("no weapons active against target ", targetTrack.TargetName());
|
||
|
|
}
|
||
|
|
|
||
|
|
if ((TIME_NOW - mTrackWeaponActiveMap[targetTrack.TargetName()]) < mInactiveLaunchDelay)
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: Waiting to see what last active weapon did, score a kill?");
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if this is a ttr, it should ignore the check for coop engage one
|
||
|
|
if (targetTrack.CheckAuxData("notlocal") == false)
|
||
|
|
{
|
||
|
|
if (mCoopEngageOne == false)
|
||
|
|
{
|
||
|
|
WsfLocalTrack targetLocalTrack = (WsfLocalTrack)targetTrack;
|
||
|
|
if (targetLocalTrack.IsValid())
|
||
|
|
{
|
||
|
|
if(!targetLocalTrack.ContributorOf(PLATFORM) &&
|
||
|
|
!targetLocalTrack.IsPredefined())
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: Not able to coop engage! ", PLATFORM.Name(), " targeting ",targetTrack.TargetName(), ". NumContributors: ", targetLocalTrack.NumContributors() );
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (mCoopEngageOneFlightOnly == true)
|
||
|
|
{
|
||
|
|
//check if this platform needs somebody in his flight to have track on the target
|
||
|
|
WsfLocalTrack targetLocalTrack = (WsfLocalTrack)targetTrack;
|
||
|
|
if (targetLocalTrack.IsValid())
|
||
|
|
{
|
||
|
|
if (targetLocalTrack.IsPredefined())
|
||
|
|
{
|
||
|
|
//its fine, go ahead & shoot
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bool OkToShoot = false;
|
||
|
|
Array<WsfPlatform> peers = ((WsfRIPRProcessor)PROCESSOR).GetRIPRCommanderProcessor().SubordinatePlatforms();
|
||
|
|
foreach (WsfPlatform peer in peers)
|
||
|
|
{
|
||
|
|
if(targetLocalTrack.ContributorOf(peer))
|
||
|
|
{
|
||
|
|
OkToShoot = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!OkToShoot)
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: Cant engage tracks not supported by flight group! ", PLATFORM.Name(), " targeting ", targetTrack.TargetName(), ".");
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// We can launch once we have a target-quality track.
|
||
|
|
//TODO probably need something to test for failure to lockon
|
||
|
|
writeln_d (" targetTrack.TrackQuality == ", targetTrack.TrackQuality());
|
||
|
|
|
||
|
|
if (targetTrack.TrackQuality() < GetRequiredTrackQualityForThreat(targetTrack))
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: track quality not good enough to fire on target");
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
|
||
|
|
string selectedWeapon = GetWeaponForThreat(PLATFORM, targetTrack); #checks domain & kinematic capability, & valid quantity remaining
|
||
|
|
|
||
|
|
if (selectedWeapon == "")
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: No domain capable weapon within range available!");
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
|
||
|
|
WsfWeapon weaponToLaunch = PLATFORM.Weapon(selectedWeapon);
|
||
|
|
|
||
|
|
//writeln_d(" using a conventional weapon!");
|
||
|
|
#extern Array<Map<string, Object>> mWeaponArray;
|
||
|
|
#extern int GetWeaponNumberActiveMax(string, Array<Map<string, Object>>);
|
||
|
|
int maxActiveOfType = GetWeaponNumberActiveMax(selectedWeapon,mWeaponArray);
|
||
|
|
int curActiveOfType = ((WsfRIPRProcessor)PROCESSOR).WeaponsActiveOfType(weaponToLaunch);
|
||
|
|
if (MustShootAt(targetTrack))
|
||
|
|
{
|
||
|
|
curActiveOfType = maxActiveOfType - 1;
|
||
|
|
}
|
||
|
|
if (curActiveOfType >= maxActiveOfType)
|
||
|
|
{
|
||
|
|
writeln_d(" FAIL: Max number(", maxActiveOfType,") of ", selectedWeapon, " weapon type are already active! (", curActiveOfType,")");
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
|
||
|
|
int salvoCount = GetSalvoForThreat(targetTrack);
|
||
|
|
writeln_d(" salvo count for ", targetTrack, " is: ", salvoCount);
|
||
|
|
|
||
|
|
#extern bool LaunchWeapon(WsfPlatform, WsfTrack, WsfWeapon, int);
|
||
|
|
launched = LaunchWeapon(PLATFORM, targetTrack, weaponToLaunch, salvoCount);
|
||
|
|
|
||
|
|
writeln_d(" launched == ", launched, ", weapon: ", selectedWeapon);
|
||
|
|
if (launched == true)
|
||
|
|
{
|
||
|
|
double dPreviousRoundsFiredAt = mRoundsFiredAtMap.Get(targetTrack);
|
||
|
|
mRoundsFiredAtMap.Set(targetTrack,dPreviousRoundsFiredAt + salvoCount);
|
||
|
|
string msg = "Shot at: " + targetTrack.TargetName();
|
||
|
|
PLATFORM.Comment(msg);
|
||
|
|
writeln_d(" SUCCESS: ", PLATFORM.Name(), " ", msg);
|
||
|
|
}
|
||
|
|
return launched;
|
||
|
|
}
|
||
|
|
|
||
|
|
return launched;
|
||
|
|
end_script
|
||
|
|
|
||
|
|
|
||
|
|
execute
|
||
|
|
writeln_d(PLATFORM.Name(), " executing engage-target, T=", TIME_NOW);
|
||
|
|
#extern WsfTrack GetTrackByName(WsfPlatform, string);
|
||
|
|
#check all possible targets on all channels
|
||
|
|
########################################################################
|
||
|
|
### fire on any pursue-target jobs we are assigned to
|
||
|
|
########################################################################
|
||
|
|
WsfRIPRProcessor commander = ((WsfRIPRProcessor)PROCESSOR).GetRIPRCommanderProcessor();
|
||
|
|
for (int channel = 0; channel < ((WsfRIPRProcessor)PROCESSOR).GetNumJobChannels(); channel = channel + 1)
|
||
|
|
{
|
||
|
|
WsfRIPRJob aJob = commander.GetJobFor(((WsfRIPRProcessor)PROCESSOR), channel);
|
||
|
|
if (aJob.IsValid() &&
|
||
|
|
aJob.Name() == "pursue-target")
|
||
|
|
{
|
||
|
|
string targetName = (string)aJob.GetData("targetTrackName");
|
||
|
|
WsfTrack targetTrack = GetTrackByName(PLATFORM, targetName);
|
||
|
|
if (!targetTrack.IsNull() &&
|
||
|
|
targetTrack.IsValid())
|
||
|
|
{
|
||
|
|
writeln_d(" ", PLATFORM.Name(), " trying to shoot at job track: ", targetName, " at time: ", TIME_NOW);
|
||
|
|
if(FireWeapon(targetTrack) == false)
|
||
|
|
{
|
||
|
|
writeln_d(" ", PLATFORM.Name(), " could NOT fire at track: ", targetTrack.TargetName(), " at time: ", TIME_NOW);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
end_execute
|
||
|
|
|
||
|
|
end_behavior
|