BT412/game/reconstructed/mislanch.cpp

//============================================================================//
// File:	mislanch.cpp                                                          //
// Project: BattleTech																			//
// Contents: Weapon Which Launches a missile  (MissileLauncher : ProjectileWeapon)//
//----------------------------------------------------------------------------//
// Copyright (C) 1995, Virtual World Entertainment, Inc. All Rights reserved  //
//                   	PROPRIETARY AND CONFIDENTIAL                          //
//============================================================================//
//
// RECONSTRUCTED from the shipped binary.  Behaviour follows the Ghidra
// pseudo-C in part_013.c; member / method names follow the surviving
// MISLANCH.HPP, the resource-parser tag strings, and the reconstructed
// mechweap.hpp / heat.hpp siblings.  Each non-trivial method cites the
// originating @ADDR.
//
// Class map for the projectile-weapon branch (resolved from vtable + ctor
// chaining + CreateStreamedSubsystem resource strings):
//      ProjectileWeapon  ctor @004bc3fc  dtor @004bc688  vtable @0051242c
//                        CSS  @004bc7cc  (TracerInterval, AmmoBin,
//                                         MinTimeOfFlight, MinJamChance,
//                                         MinVoltagePercentToFire)
//      MissileLauncher   ctor @004bcff0  dtor @004bd060  vtable @00512570
//                        CSS  @004bd08c  (MissileCount, MuzzleVelocity)
//
// ProjectileWeapon (base) member offsets used below:
//      @0x3ac this[0xeb]  damageAmount   (divided by missileCount in ctor)
//      @0x3d4 this[0xf5]  per-salvo count copy
//      @0x3f0 this[0xfc]  MinTimeOfFlight timer base
//      @0x3fc this[0xff]  MinJamChance
//      @0x404 this[0x101] MinVoltagePercentToFire
//      @0x40c this[0x103] MinTimeOfFlight
//      @0x410 this[0x104] (MissileLauncher) muzzleVelocity (Vector3D)
//      @0x418 this[0x106] jam-chance-derived scalar
//      @0x438 this[0x10e] TracerInterval
//      @0x43c this[0x10f] AmmoBin SharedData connection (FUN_004bcbb0)
//      @0x448 this[0x112] (MissileLauncher) missileCount
//
// Helper-function name mapping:
//      FUN_004bc3fc  ProjectileWeapon base constructor
//      FUN_004bc7cc  ProjectileWeapon::CreateStreamedSubsystem
//      FUN_004bcbb0  AmmoBin-connection ctor (SharedData, vtable @00512424)
//      FUN_004b964c  MechWeapon::TakeDamage      FUN_004b9690  WriteUpdateRecord
//      FUN_004bcabc  ProjectileWeapon::HandleMessage (msg 2 -> jam alarm)
//      FUN_004bc6c8  ProjectileWeapon::PrintState (Jammed/NoAmmo/Trigger...)
//      FUN_004bcc60  spawn-a-Missile (FireWeapon path)   FUN_004bf8bc Missile::New
//      FUN_00408440  Point3D/Vector3D copy   FUN_00404088/004040d8 resource get str/int
//      FUN_00404088  ResourceFile::GetString FUN_00408944  parse Vector3D from text
//      FUN_004084fc  Vector3D approx-equal    FUN_004dbb24  error-string append
//

#include <bt.hpp>
#pragma hdrstop

#if !defined(MISLANCH_HPP)
#	include <mislanch.hpp>
#endif
#if !defined(MISSILE_HPP)
#	include <missile.hpp>
#endif
#if !defined(AMMOBIN_HPP)
#	include <ammobin.hpp>
#endif
#if !defined(TESTBT_HPP)
#	include <testbt.hpp>
#endif
#include <math.h>

// WAVE 7 Phase B -- the port-side flying-projectile service (defined in mech4.cpp, a
// complete-Mech TU with the render + damage path).  A fired missile becomes a tracked
// projectile that flies to the target + delivers this weapon's damage on impact.
extern void BTPushProjectile(const Point3D &muzzle, void *shooter, void *target,
							 const Point3D &targetPos, Scalar speed, Scalar damage);

//###########################################################################
//###########################################################################
//					MissileLauncher
//###########################################################################
//###########################################################################

//#############################################################################
// Shared Data Support
//
Derivation
	MissileLauncher::ClassDerivations(
		&ProjectileWeapon::ClassDerivations,
		"MissileLauncher"
	);

// task #6: inherit ProjectileWeapon's handler set (see emitter.cpp note).
Receiver::MessageHandlerSet&
	MissileLauncher::GetMessageHandlers()
{
	static Receiver::MessageHandlerSet messageHandlers(
		ProjectileWeapon::GetMessageHandlers());		// copy-inherit
	return messageHandlers;
}
Simulation::AttributeIndexSet	MissileLauncher::AttributeIndex;

MissileLauncher::SharedData
	MissileLauncher::DefaultData(
		&MissileLauncher::ClassDerivations,
		MissileLauncher::GetMessageHandlers(),
		MechWeapon::GetAttributeIndex(),	// gauge wave: inherit temps/InputVoltage/OutputVoltage/PercentDone (was empty)
		MissileLauncher::StateCount
	);

//#############################################################################
// Construction
//
// @004bcff0  MissileLauncher::MissileLauncher(...)
//
//   Chains the ProjectileWeapon base ctor, stamps the MissileLauncher vtable,
//   then reads the two launcher resource fields and splits the damage budget
//   evenly across the salvo so each spawned Missile carries
//   damageAmount/missileCount.
//
MissileLauncher::MissileLauncher(
	Mech				*owner,
	int					subsystem_ID,
	SubsystemResource	*subsystem_resource,
	SharedData			&default_data)
:
	// ProjectileWeapon base ctor (ammo bin, jam, tracer, targeting).
	ProjectileWeapon(owner, subsystem_ID, subsystem_resource, default_data)	// @004bc3fc
{
	// vtable installed by the compiler (PTR_FUN_00512570)

	missileCount = subsystem_resource->missileCount;			// @0x448  resource +0x1d0
	launchVelocity = subsystem_resource->muzzleVelocity;		// @0x410 (inherited ProjectileWeapon slot; was aliased "muzzleVelocity")

	// per-salvo count copy + per-missile damage (write the inherited Damage fields)
	this->damageData.burstCount   = missileCount;				// @0x3d4  this[0xf5] (was shadow "salvoCount")
	this->damageData.damageAmount /= (Scalar)missileCount;		// @0x3ac  this[0xeb] /= missileCount
}

//#############################################################################
// Destruction
//
// @004bd060  ~MissileLauncher() -- restores the launcher vtable, chains the
// ProjectileWeapon destructor (which releases the AmmoBin connection @00512424).
//
MissileLauncher::~MissileLauncher()
{
	// vtable reset + base ~ProjectileWeapon chaining handled by the compiler.
}

//#############################################################################
// CreateStreamedSubsystem
//
// @004bd08c  Reads MissileCount (+0x1d0) and MuzzleVelocity (+0x1d4) after
// chaining ProjectileWeapon::CreateStreamedSubsystem (@004bc7cc).  Stamps the
// streamed-record class/size header bytes, then validates both fields,
// emitting "missing MissileCount!" / "missing MuzzleVelocity!" on failure.
//
Logical MissileLauncher::CreateStreamedSubsystem(
	ResourceFile				*resource_file,
	NotationFile				*model_file,
	const char					*model_name,
	const char					*subsystem_name,
	SubsystemResource			*subsystem_resource,
	NotationFile				*subsystem_file,
	const ResourceDirectories	*directories,
	int							passes)
{
	// chain the ProjectileWeapon record parser (ammo/jam/tracer fields)
	if (!ProjectileWeapon::CreateStreamedSubsystem(
			resource_file, model_file, model_name, subsystem_name,
			subsystem_resource, subsystem_file, directories, passes))	// @004bc7cc
		return False;

	// stamp streamed-record header (classID / size bytes @+0x20/+0x24)
	// ... (record housekeeping, see @004bd08c) ...

	if (passes == 1)
		subsystem_resource->missileCount = -1;			// sentinel

	// "MissileCount"  (+0x1d0)
	if (!model_file->GetEntry(subsystem_name, "MissileCount",
							  &subsystem_resource->missileCount)
		&& subsystem_resource->missileCount == -1)
	{
		DebugStream << subsystem_name << " missing MissileCount!" << endl;	// @004bd08c
		return False;
	}

	// "MuzzleVelocity"  (+0x1d4, Vector3D parsed from text)
	const char *text = "Unspecified";
	Vector3D &mv = subsystem_resource->muzzleVelocity;
	if (!model_file->GetEntry(subsystem_name, "MuzzleVelocity", &text)
		&& (mv.x == 0.0f && mv.y == 0.0f && mv.z == 0.0f))
	{
		DebugStream << subsystem_name << " missing MuzzleVelocity!" << endl;	// @004bd08c
		return False;
	}
	if (strcmp(text, "Unspecified") != 0)
	{
		// FUN_00408944 -- parse a "x y z" Vector3D from the resource text.
		float x = 0.0f, y = 0.0f, z = 0.0f;
		if (sscanf(text, "%f %f %f", &x, &y, &z) == 3)
		{
			mv.x = x;  mv.y = y;  mv.z = z;
		}
	}

	return True;
}

//#############################################################################
// FireWeapon  (ProjectileWeapon spawn path, @004bcc60)
//
//   Builds a streamed-entity spawn descriptor for a Missile (entity ClassID
//   0xBD0), seeded from this weapon's muzzle transform, the explosion model
//   resource (this->explosionResourceID @0x3e4), the per-missile Damage block
//   (this->damageData @0x3a8) and the owning Mech's target.  The descriptor is
//   handed to Missile::New (FUN_004bf8bc), which allocates the 0x368-byte
//   entity and runs the Missile ctor (@004bf5b4).  Heat from firing is added
//   to the owner here (this->heatCostToFire -> owner heatLoad) when the weapon
//   is heat-bearing (FUN_004ad7d4).
//
//   NOTE: this body lives in the ProjectileWeapon address range and is shared
//   by MissileLauncher; it is documented here because MISLANCH.HPP declares
//   FireWeapon() as the launcher's protected entry point.
//
void MissileLauncher::FireWeapon()
{
	Check(this);

	// THE FIRING HEAT (task #9): heatCostToFire RAW into the launcher's own
	// pendingHeat (pre-scaled 1e7-unit resources: SRM6 = 5e7, LRM15 = 6.5e7)
	// -- the binary's add @part_013.c:8744-8747, gated on the heatable check.
	if (HeatModelActive())								// FUN_004ad7d4 (heat.hpp; [T3] permissive)
	{
		pendingHeat += heatCostToFire;					// HeatSink @0x1C8, raw
	}

	// A salvo draws one ammo unit from the linked bin; a dry / not-ready bin
	// latches NoAmmo (ConsumeRound) and aborts the launch.
	if (!ConsumeRound())								// FUN_004bd4f4 (AmmoBin::FeedAmmo)
		return;

	// Begin the per-shot recharge cooldown (recoil bleeds to 0 before ReadyToFire).
	recoil = rechargeRate;

	// Resolve the muzzle / lead geometry (seeds each flying missile).
	Point3D muzzle;
	GetMuzzlePoint(muzzle);								// @004b9948
	damageData.burstCount = missileCount;				// @0x3d4 (was shadow "salvoCount")

	// WAVE 7 Phase B: launch `missileCount` flying projectiles toward the owner's target.
	// (Port reconstruction -- the byte-exact world-entity Missile is blocked by the 2007
	// engine Entity base mismatch; see BTPushProjectile / mech4.cpp.)  Speed = |launchVelocity|
	// (resource MuzzleVelocity); per-missile damage = damageData.damageAmount (already
	// divided by missileCount in the ctor).
	char *o = (char *)owner;							// inherited MechSubsystem::owner (the Mech)
	void *target = (o != 0) ? *(void **)(o + 0x388) : 0;			// owner's locked target entity (null in bring-up)
	Point3D targetPos = (o != 0) ? *(Point3D *)(o + 0x37c) : muzzle;	// owner target point
	Scalar  speed = (Scalar)sqrtf(launchVelocity.x*launchVelocity.x
								+ launchVelocity.y*launchVelocity.y
								+ launchVelocity.z*launchVelocity.z);
	// Always launch -- BTPushProjectile falls back to gEnemyMech when the owner's target
	// slot isn't populated (bring-up); missileCount missiles per salvo.
	int nmiss = (missileCount > 0 && missileCount < 40) ? missileCount : 1;
	for (int i = 0; i < nmiss; ++i)
		BTPushProjectile(muzzle, o, target, targetPos, speed, damageData.damageAmount);

	simulationFlags |= 0x1;								// replication-dirty
	Check_Fpu();
}

//#############################################################################
// TakeDamage / DeathReset
//
// TakeDamage inherits MechWeapon::TakeDamage (vtable slot 6, @004b964c).
// DeathReset chains the ProjectileWeapon ammo/feed reset (@004bbaf8).
//
void MissileLauncher::TakeDamage(Damage &damage)
{
	MechWeapon::TakeDamage(damage);					// @004b964c
}

void MissileLauncher::DeathReset(Logical /*full_reset*/)
{
	ProjectileWeapon::ResetToInitialState();		// @004bbaf8 (best-effort)
}

//#############################################################################
// TestInstance -- inherits the ProjectileWeapon/MechWeapon base check.
//
Logical MissileLauncher::TestInstance() const
{
	return ProjectileWeapon::TestInstance();
}


//===========================================================================//
// WAVE 7 factory bridge -- MissileLauncher (factory case 0xBD0, "BallisticWeapon"
//   mislabel).  VDATA.h enum: 0xBD0 == MissileLauncherClassID.  The real class
//   (ctor @004bcff0) is MissileLauncher : ProjectileWeapon (sizeof 0x44C); the
//   factory built a BallisticWeapon RECON_SUBSYS stub.  alloc 0x44C.  Ticks its
//   real per-frame sim (charge/ammo/heat, damage split across missileCount);
//   FireWeapon consumes a round + recoils but DEFERS the missile spawn (Phase B).
//===========================================================================//
Subsystem *CreateMissileLauncherSubsystem(Mech *owner, int id, void *seg)
{
	Check(sizeof(MissileLauncher) <= 0x44C);
	return (Subsystem *) new (Memory::Allocate(0x44C))
		MissileLauncher(owner, id, (MissileLauncher::SubsystemResource *)seg, MissileLauncher::DefaultData);
}