Add CombatFormulas::CalcWeaponDamage and the explosion damage path

CalcWeaponDamage works out the damage of one attack before armour, for combat
and for the figure an item card shows. ID 2209001.

For a launcher that is only half the story. A Fat Man's WEAP record is worth 18
damage, because the launcher is a tube and nearly all of the damage belongs to
the shell it fires. Reaching the shell takes two more functions, and they are
not interchangeable.

TESObjectWEAP::GetProjectile, which is static, returns what a weapon fires, or
null for one that fires nothing. The instance data's own override is preferred,
then the base form's, and the ammunition's projectile stands in when neither
names one, so a barrel that swaps the projectile and a change of ammunition are
both followed. ID 2198934.

Explosion::GetDamage returns what a blast already in the world is worth. It
multiplies the explosion record's damage by that explosion's own damageMult,
keeps the result in calculatedDamage and hands the same number back every time
afterwards, so everything the engine asks about one blast agrees with itself.
ID 2236658.

Which of the two applies depends on whether anything has been fired. An item
card describes a weapon that has fired nothing, so there is no Explosion to ask
and CombatFormulas::GetWeaponDisplayDamage calls GetProjectile and reads the
explosion record directly. A blast in the world calls Explosion::GetDamage
instead. The two routes reach the same figure through different code.

Explosion::GetActorOwner resolves an explosion's owner handle and returns it
only when it names an actor, which is the aggressor a blast's blows are credited
to. ID 2236659.

Author: hxef

include/RE/C/CombatFormulas.h

@@ -42,6 +42,20 @@ namespace RE
 			return func(a_target, a_bodyPart, a_physicalDamage, a_damageTypes);
 		}
 
+		// The damage one attack deals before the target's armour. Combat and the
+		// damage an item card shows both work it out through this.
+		//
+		// a_avOwner is the actor the damage belongs to, and a TESNPC record is
+		// taken as well, with the actor values read off that instead. a_condition
+		// is the weapon's item health, and a_rangeMult the falloff for a target
+		// past the weapon's range, 1.0 within it.
+		[[nodiscard]] inline float CalcWeaponDamage(const TESForm* a_avOwner, const TESObjectWEAP::InstanceData* a_data, const TESAmmo* a_ammo, float a_condition, float a_rangeMult)
+		{
+			using func_t = decltype(&CombatFormulas::CalcWeaponDamage);
+			static REL::Relocation<func_t> func{ ID::CombatFormulas::CalcWeaponDamage };
+			return func(a_avOwner, a_data, a_ammo, a_condition, a_rangeMult);
+		}
+
 		[[nodiscard]] inline std::int64_t GetNumCrippledAttackConditions(Actor* a_actor)
 		{
 			using func_t = decltype(&CombatFormulas::GetNumCrippledAttackConditions);

include/RE/E/Explosion.h

@@ -14,6 +14,7 @@
 
 namespace RE
 {
+	class Actor;
 	class ActorCause;
 	class NiLight;
 	class NonActorMagicCaster;
@@ -74,6 +75,33 @@ namespace RE
 		virtual void Update(float a_delta);  // C7
 		virtual void FindTargets();          // C8
 
+		// Whoever set the blast off, or null when the owner has gone away or is
+		// not an actor. This is the aggressor the engine credits an explosion's
+		// blows to.
+		[[nodiscard]] Actor* GetActorOwner()
+		{
+			using func_t = decltype(&Explosion::GetActorOwner);
+			static REL::Relocation<func_t> func{ ID::Explosion::GetActorOwner };
+			return func(this);
+		}
+
+		// What the blast is worth. Worked out from the explosion record's damage
+		// and this explosion's damageMult the first time anything asks, then kept
+		// in calculatedDamage and handed back unchanged after that.
+		//
+		// Every question the engine asks about a live blast is answered from
+		// here, from whether it is worth looking for targets at all to what each
+		// of them loses. The item card is the one thing that does not come
+		// through it, because a weapon being looked at has set nothing off, so
+		// CombatFormulas::GetWeaponDisplayDamage reads the explosion record
+		// instead and the two arrive at the same number by different routes.
+		[[nodiscard]] float GetDamage()
+		{
+			using func_t = decltype(&Explosion::GetDamage);
+			static REL::Relocation<func_t> func{ ID::Explosion::GetDamage };
+			return func(this);
+		}
+
 		// members
 		hknpClosestUniqueBodyIdHitCollector collector;           // 110
 		void*                               explosionDBHandle;   // 520 - TODO

include/RE/IDs.h

@@ -1036,6 +1036,12 @@ namespace RE::ID
 		inline constexpr REL::ID GetBuildConfirmQuestion{ 2223057 };
 	}
 
+	namespace Explosion
+	{
+		inline constexpr REL::ID GetActorOwner{ 2236659 };
+		inline constexpr REL::ID GetDamage{ 2236658 };
+	}
+
 	namespace ExteriorCellSingleton
 	{
 		inline constexpr REL::ID Singleton{ 4796370 };
@@ -2322,6 +2328,7 @@ namespace RE::ID
 
 	namespace TESObjectWEAP
 	{
+		inline constexpr REL::ID GetProjectile{ 2198934 };
 		inline constexpr REL::ID GetMeleeAttackSpeed{ 2198957 };
 		inline constexpr REL::ID GetMeleeAttackSpeedLabel{ 2198959 };
 		inline constexpr REL::ID Fire{ 2198960 };

include/RE/T/TESObjectWEAP.h

@@ -140,6 +140,22 @@ namespace RE
 		};
 		static_assert(sizeof(Data) == 0x138);
 
+		// What this weapon fires, or null for one that fires nothing.
+		//
+		// The instance data's own override is preferred, then the base form's,
+		// and the ammunition's projectile stands in when neither names one. A
+		// muzzle or a barrel that swaps the projectile is therefore followed,
+		// and so is a change of ammunition.
+		//
+		// a_instanceData may be null, in which case only the base form and the
+		// ammunition are consulted.
+		[[nodiscard]] static BGSProjectile* GetProjectile(const TESObjectWEAP* a_weapon, const TESAmmo* a_ammo, const InstanceData* a_instanceData)
+		{
+			using func_t = decltype(&TESObjectWEAP::GetProjectile);
+			static REL::Relocation<func_t> func{ ID::TESObjectWEAP::GetProjectile };
+			return func(a_weapon, a_ammo, a_instanceData);
+		}
+
 		[[nodiscard]] MELEE_ATTACK_SPEED GetMeleeAttackSpeed()
 		{
 			using func_t = decltype(&TESObjectWEAP::GetMeleeAttackSpeed);