eager/lab1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
eager
2025-09-12 15:20:28 +08:00
commit 3257a14c32
449 changed files with 388780 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

388
processors/timeline_agents/weapon_defs.txt Normal file
View File

@@ -0,0 +1,388 @@
# ****************************************************************************
# 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.
# ****************************************************************************
script_struct WeaponData
script_variables
string type = "";
double rangeMin = 0; #meters
double rangeMax = 0; #meters
bool onlyUseInRange = true;
double averageSpeed = 0; #meters/second
double maxTimeFlight = 0; #seconds, note: should == rangeMax / averageSpeed
int numActiveMax = 0;
bool domainAir = false;
bool domainLand = false;
double maxFiringAngle = 0;
end_script_variables
end_script_struct
script_variables
Map<string, struct> gWeaponDefs = Map<string, struct>();
gWeaponDefs["MEDIUM_RANGE_MISSILE"] = struct.New("WeaponData");
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->type = "MEDIUM_RANGE_MISSILE";
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->rangeMin = 50; # (meters)
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->rangeMax = 111120; # ~60 nm (meters)
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->averageSpeed = 1657.283; #mach 5 (m/s)
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->maxTimeFlight = 67.05; #for 60 nm range (seconds)
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->numActiveMax = 2;
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->domainAir = true;
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->domainLand = false;
gWeaponDefs["MEDIUM_RANGE_MISSILE"]->maxFiringAngle = 45.0;
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"] = struct.New("WeaponData");
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->type = "MEDIUM_RANGE_RADAR_MISSILE";
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->rangeMin = 50; # (meters)
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->rangeMax = 111120; # ~60 nm (meters)
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->averageSpeed = 1657.283; #mach 5 (m/s)
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->maxTimeFlight = 67.05; #for 60 nm range (seconds)
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->numActiveMax = 2;
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->domainAir = true;
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->domainLand = false;
gWeaponDefs["MEDIUM_RANGE_RADAR_MISSILE"]->maxFiringAngle = 45.0;
end_script_variables
#returns a 'WeaponData' struct
script struct GetWeaponData(string aType)
if (gWeaponDefs.Exists(aType))
{
return gWeaponDefs.Get(aType);
}
else
{
return struct.New("WeaponData");
}
end_script
include_once processors/quantum_agents/common/common_platform_script.txt
script_debug_writes off
script bool WeaponCapableAvailableAgainstThreat(WsfWeapon weapon, WsfTrack track)
writeln_d(" checking weapon ", weapon.Name(), " valid=", weapon.IsValid());
if (weapon.IsNull() || !weapon.IsValid() || track.IsNull() || !track.IsValid())
{
writeln_d("weapon or track is not valid!");
return false;
}
if ((weapon.QuantityRemaining()-weapon.WeaponsPendingFor(WsfTrackId())) <= 0)
{
writeln_d("no unassigned weapons left to fire!");
return false;
}
#check manually input user data first
struct weaponData = GetWeaponData(weapon.Type());
if (weaponData->type == weapon.Type())
{
if ((track.AirDomain() && !weaponData->domainAir) ||
(track.LandDomain() && !weaponData->domainLand) )
{
writeln_d("weapon not capable against target domain!");
return false;
}
}
else
{
writeln_d("could not find weapon type ", weapon.Type() ," in weapon database; query returned type ", weaponData->type);
#check if it has a launch computer of the necessary type
WsfLaunchComputer lcPtr = weapon.LaunchComputer();
if (lcPtr.IsValid())
{
if (track.AirDomain() && lcPtr.IsA_TypeOf("WSF_AIR_TO_AIR_LAUNCH_COMPUTER"))
{
return true;
}
else if (track.LandDomain() && lcPtr.IsA_TypeOf("WSF_ATG_LAUNCH_COMPUTER"))
{
return true;
}
}
writeln_d("nor could an applicable launch computer be found!");
return false; #dont have weapon data
}
return true;
end_script
#could return -1 for an invalid max range
#(from a launch computer or weapon struct not found)
script double MaxRange(WsfPlatform shooter, WsfWeapon weapon, WsfTrack track)
WsfLaunchComputer lcPtr = weapon.LaunchComputer();
if (lcPtr.IsValid() &&
lcPtr.IsA_TypeOf("WSF_AIR_TO_AIR_LAUNCH_COMPUTER"))
{
double rmax = lcPtr.LookupResult(track)[0];
return rmax;
}
else
{
struct weaponData = GetWeaponData(weapon.Type());
if (weaponData->type == weapon.Type())
{
return weaponData->rangeMax;
}
else
{
return -1.0;
}
}
end_script
#if beyond max range: returns time to hit if launched at max range
#if before min range: returns time to hit if launched at min range
#could return -1 for an invalid max range
#(from a launch computer or weapon struct not found)
script double TimeToHit(WsfPlatform shooter, WsfWeapon weapon, WsfTrack track)
double range = shooter.SlantRangeTo(track);
WsfLaunchComputer lcPtr = weapon.LaunchComputer();
if (lcPtr.IsValid() &&
lcPtr.IsA_TypeOf("WSF_AIR_TO_AIR_LAUNCH_COMPUTER"))
{
Array<double> arr = lcPtr.LookupResult(track);
double rmax = arr[0];
double rmaxTOF = arr[1];
double rmin = arr[4];
double rminTOF = arr[5];
if (range >= rmax)
{
return rmaxTOF;
}
else if (range<=rmin)
{
return rminTOF;
}
else
{
# in between, interpolate
double scale = (range-rmin)/(rmax-rmin);
double tof = scale*(rmaxTOF-rminTOF) + rminTOF;
return tof;
}
}
else
{
struct weaponData = GetWeaponData(weapon.Type());
if (weaponData->type == weapon.Type())
{
if (range > weaponData->rangeMax)
{
range = weaponData->rangeMax;
}
else if (range < weaponData->rangeMin)
{
range = weaponData->rangeMin;
}
double tof = range / weaponData->averageSpeed;
return tof;
}
else
{
return -1.0;
}
}
end_script
# Calculate time for the weapon to fly a given range
#if beyond max range: returns time to hit if launched at max range
#if before min range: returns time to hit if launched at min range
#could return -1 for an invalid max range
#(from a launch computer or weapon struct not found)
script double TimeToRange(double range, WsfWeapon weapon, WsfTrack track)
WsfLaunchComputer lcPtr = weapon.LaunchComputer();
if (lcPtr.IsValid() &&
lcPtr.IsA_TypeOf("WSF_AIR_TO_AIR_LAUNCH_COMPUTER"))
{
Array<double> arr = lcPtr.LookupResult(track);
double rmax = arr[0];
double rmaxTOF = arr[1];
double rmin = arr[4];
double rminTOF = arr[5];
if (range >= rmax)
{
return rmaxTOF;
}
else if (range<=rmin)
{
return rminTOF;
}
else
{
# in between, interpolate
double scale = (range-rmin)/(rmax-rmin);
double tof = scale*(rmaxTOF-rminTOF) + rminTOF;
return tof;
}
}
else
{
struct weaponData = GetWeaponData(weapon.Type());
if (weaponData->type == weapon.Type())
{
if (range > weaponData->rangeMax)
{
range = weaponData->rangeMax;
}
else if (range < weaponData->rangeMin)
{
range = weaponData->rangeMin;
}
double tof = range / weaponData->averageSpeed;
return tof;
}
else
{
return -1.0;
}
}
end_script
script bool InRangeToFire(WsfPlatform shooter, WsfWeapon weapon, WsfTrack track, double percentRangeMax, double percentRangeMin)
##do not check this again
#if ( ! WeaponCapableAvailableAgainstThreat(weapon, track) )
#{
# return false;
#}
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 = shooter.GroundRangeTo(track.CurrentLocation());
# 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.");
return false;
}
double RminConstraint = theRmin * percentRangeMin;
if (range < RminConstraint)
{
writeln_d(" Engagement did not shoot since inside the k * Rmin constraint distance.");
writeln_d(" Range versus Rmin constraint = ", range, ", ", RminConstraint);
return false;
}
}
# 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);
return 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.");
return false;
}
#double RmaxConstraint = theRmax * DefaultPercentRangeMax;
if (range > (theRmax * percentRangeMax))
{
writeln_d(" Engagement did not shoot since outside the k * Rmax constraint distance.");
writeln_d(" Range versus Rmax constraint = ", range, ", ", (theRmax * percentRangeMax));
return false;
}
}
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
{
return false;
}
}
else
{
struct weaponData = GetWeaponData(weapon.Type());
writeln_d(" using input WeaponData struct values");
#check our own ranges & angles --> hacky!!!
#extern double EffectiveRange (WsfPlatform, WsfTrack);
double effectiveRange = EffectiveRange(shooter, track);
double absRelativeBearing = MATH.Fabs(shooter.RelativeBearingTo( track ));
if ((weaponData->rangeMin * percentRangeMin) > effectiveRange)
{
writeln_d(" target too close");
return false;
}
if (absRelativeBearing > weaponData->maxFiringAngle)
{
writeln_d(" target firing angle too large");
return false;
}
if (weaponData->rangeMax * percentRangeMax < effectiveRange)
{
writeln_d(" target too far away");
return false;
}
double range = shooter.SlantRangeTo(track);
#double closingSpeed = PLATFORM.ClosingSpeedOf(track);
double relBearing = track.RelativeBearingTo(shooter);
if (relBearing > 90.0)
{
if (track.Speed() > weaponData->averageSpeed)
{
return false;
}
double speedDiff = weaponData->averageSpeed - track.Speed();
if ((range/speedDiff) > weaponData->maxTimeFlight)
{
return false;
}
}
}
return true;
end_script