Hey Alex,
I have a problem with lead. The lead calculation of the vanilla autofire AI uses the projectile speeds from
weapon_data.csv rather than those of the relevant
ProjectileSpecAPIs. I know that the AI is using the .csv values because both the vanilla AutofireAIPlugin and
Leading Pip by DarkRevenant estimate the same excessive lead at the thousands of SU of range and projectile speed and hundreds of SU per second of ship speed in Realistic Combat: debugging DarkRevenant's code, I found that it uses the method
WeaponAPI.getProjectileSpeed(), which returns the value from
weapon_data.csv although Realistic Combat has modified the projectile speed
ProjectileSpecAPI of the
WeaponSpecAPI of the relevant
WeaponAPI. Replacing that method call with with the following statement corrected the lead:
((ProjectileSpecAPI) weapon.getSpec().getProjectileSpec()).getMoveSpeed(weapon.getShip().getMutableStats(), weapon)
I need the AI to use the value that this statement returns. I suspect I would have to inject some AutofireAIPlugin, but then I would be at best duplicating your years of effort to write a good one.
If you want to see more code, here it is:
Deriving the relevant stats of the
WeaponGroupAPI for which lead is to be calculated
Spoiler
private static class WeaponGroupDerivedStats {
private final float averageWeaponSpeed;
private final Vector2f center;
private static boolean isActiveNonBeamWeapon(WeaponAPI weapon) {
return (!weapon.isDisabled()
&& !weapon.isBeam()
&& !weapon.isBurstBeam()
&& weapon.getProjectileSpeed() >= 50f);
}
private static boolean firesMissiles(WeaponAPI weapon) {
return weapon.getSpec().getProjectileSpec() instanceof MissileSpecAPI;
}
private static float getMissileSpeed(WeaponAPI weapon) {
return ((MissileSpecAPI) weapon.getSpec().getProjectileSpec()
).getHullSpec().getEngineSpec().getMaxSpeed();
}
/**
* {@code WeaponAPI.getProjectileSpeed()} returns the speed
* in weapon_data.csv rather than after RealisticCombat has
* modified the weapon and projectile specs.
*
* @param weapon {@link WeaponAPI}
*
* @return {@code float} true speed of the projectile of
* a {@link WeaponAPI}
*/
private static float getProjectileSpeed(WeaponAPI weapon) {
return ((ProjectileSpecAPI) weapon.getSpec().getProjectileSpec()).getMoveSpeed(
weapon.getShip().getMutableStats(), weapon);
}
private static float getWeaponSpeed(WeaponAPI weapon) {
return firesMissiles(weapon) ? getMissileSpeed(weapon) : getProjectileSpeed(weapon);
}
private WeaponGroupDerivedStats(WeaponGroupAPI weaponGroup) {
float totalWeaponSpeed = 0.01f, activeNonBeamWeapons = 0;
Vector2f center = new Vector2f(0, 0);
for (WeaponAPI weapon : weaponGroup.getWeaponsCopy())
if (isActiveNonBeamWeapon(weapon)) {
totalWeaponSpeed += getWeaponSpeed(weapon);
Vector2f.add(center, weapon.getLocation(), center);
activeNonBeamWeapons += 1f;
}
averageWeaponSpeed = totalWeaponSpeed / activeNonBeamWeapons;
center.x /= activeNonBeamWeapons; center.y /= activeNonBeamWeapons;
this.center = center;
}
private float getAverageWeaponSpeed() { return averageWeaponSpeed; }
private Vector2f getWeaponsCenter() { return center; }
}
Math and driver code that update the center of the leading indicator. Note that
intercept may return
null to indicate that no lead is available.
Spoiler
/**
* @param a {@code float} coefficient of x^2
* @param b {@code float} coefficient of x
* @param c {@code float} constant
*
* @return {@link Vector2f} solutions of a quadratic equation
* ax^2 + bx + c = 0
*/
private static float[] quad(float a, float b, float c) {
if (Float.compare(Math.abs(a), 0) == 0) {
if (Float.compare(Math.abs(b), 0) == 0)
return (Float.compare(Math.abs(c), 0) == 0) ? new float[] {0, 0} : null;
return new float[] {-c / b, -c / b};
} else {
float d = b * b - 4 * a * c;
if (d >= 0) {
d = (float) Math.sqrt(d);
float e = 2 * a;
return new float[]{(-b - d) / e, (-b + d) / e};
}
} return null;
}
/**
* @param point {@link Vector2f} average {@link WeaponAPI} location of a
* {@link WeaponGroupAPI}
* @param speed {@code float} average {@link DamagingProjectileAPI} speed
* of the {@link WeaponAPI}s of a
* {@link WeaponGroupAPI}
* @param targetLoc {@link Vector2f} target location
* @param targetVel {@link Vector2f} target velocity
*
* @return {@link Vector2f} at which a {@link DamagingProjectileAPI}
* fired from the average {@link Vector2f} location of the
* {@link WeaponAPI}s of the selected {@link WeaponGroupAPI} with
* the {@code float} average {@link DamagingProjectileAPI} speed of
* the same would intercept a target of known {@link Vector2f}
* location and anticipated constant {@link Vector2f} velocity
*/
private static Vector2f intercept(Vector2f point,
float speed,
Vector2f targetLoc,
Vector2f targetVel)
{
Vector2f difference = new Vector2f(targetLoc.x - point.x, targetLoc.y - point.y);
float a = targetVel.x * targetVel.x + targetVel.y * targetVel.y - speed * speed;
float b = 2 * (targetVel.x * difference.x + targetVel.y * difference.y);
float c = difference.x * difference.x + difference.y * difference.y;
float[] solutions = quad(a, b, c);
if (solutions == null) return null;
float bestFit = Math.min(solutions[0], solutions[1]);
if (bestFit < 0) bestFit = Math.max(solutions[0], solutions[1]);
if (bestFit > 0) return new Vector2f(targetLoc.x + targetVel.x * bestFit,
targetLoc.y + targetVel.y * bestFit);
return null;
}
/**
* Set the {@link Vector2f} center of the indicator for its targeted
* {@link ShipAPI}.
*/
private void updateCenter() {
ShipAPI playerShip = Global.getCombatEngine().getPlayerShip();
WeaponGroupAPI weaponGroup = playerShip.getSelectedGroupAPI();
WeaponGroupDerivedStats stats = new WeaponGroupDerivedStats(weaponGroup);
Vector2f relativeVelocity = Vector2f.sub(target.getVelocity(), playerShip.getVelocity(),
null);
center = intercept(stats.getWeaponsCenter(), stats.getAverageWeaponSpeed(),
target.getLocation(), relativeVelocity);
}
Author
Topic: Misc modding questions that are too minor to warrant their own thread (Read 1717557 times)