TeslaRel410/restoration/source410/BT/POWERSUB.CPP

//===========================================================================//
// File:	powersub.cpp                                                        //
// Project: BattleTech           Brick: Mech subsystems                       //
// Contents: PoweredSubsystem -- a HeatSink drawing electrical power          //
//---------------------------------------------------------------------------//
// Copyright (C) 1995, Virtual World Entertainment, Inc.                     //
// All Rights reserved worldwide                                             //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL               //
//===========================================================================//

#include <bt.hpp>
#pragma hdrstop

#if !defined(POWERSUB_HPP)
#	include <powersub.hpp>
#endif

#if !defined(MECH_HPP)
#	include <mech.hpp>
#endif

//
//#############################################################################
// Shared data support
//#############################################################################
//
Derivation
	PoweredSubsystem::ClassDerivations(
		HeatSink::ClassDerivations,
		"PoweredSubsystem"
	);

//
//#############################################################################
// The cockpit generator buttons (binary handler table @0x50F4EC, ids 4-8),
// chained onto the HeatSink set (id 3 ToggleCooling) so every powered
// subsystem's dispatch reaches the Eng-page Coolant button too.  Static-init
// order is safe under the authentic .MAK lib order (heat precedes powersub).
//#############################################################################
//
const PoweredSubsystem::HandlerEntry
	PoweredSubsystem::MessageHandlerEntries[] =
{
	MESSAGE_ENTRY(PoweredSubsystem, SelectGeneratorA),		// id 4  @004b099c
	MESSAGE_ENTRY(PoweredSubsystem, SelectGeneratorB),		// id 5  @004b09e4
	MESSAGE_ENTRY(PoweredSubsystem, SelectGeneratorC),		// id 6  @004b0a2c
	MESSAGE_ENTRY(PoweredSubsystem, SelectGeneratorD),		// id 7  @004b0a74
	MESSAGE_ENTRY(PoweredSubsystem, ToggleGeneratorMode)	// id 8  @004b0abc
};

PoweredSubsystem::MessageHandlerSet
	PoweredSubsystem::MessageHandlers(
		ELEMENTS(PoweredSubsystem::MessageHandlerEntries),
		PoweredSubsystem::MessageHandlerEntries,
		HeatSink::MessageHandlers
	);

//
//#############################################################################
// Attribute tables (cockpit binding by name).
//#############################################################################
//
const PoweredSubsystem::IndexEntry
	PoweredSubsystem::AttributePointers[]=
{
	ATTRIBUTE_ENTRY(PoweredSubsystem, InputVoltage,		inputVoltage),
	ATTRIBUTE_ENTRY(PoweredSubsystem, OutputVoltage,	outputVoltage),
	ATTRIBUTE_ENTRY(PoweredSubsystem, RatedVoltage,		ratedVoltage),
	ATTRIBUTE_ENTRY(PoweredSubsystem, VoltageState,		electricalStateAlarm),
	ATTRIBUTE_ENTRY(PoweredSubsystem, ConnectMode,		modeAlarm)
};

PoweredSubsystem::AttributeIndexSet
	PoweredSubsystem::AttributeIndex(
		ELEMENTS(PoweredSubsystem::AttributePointers),
		PoweredSubsystem::AttributePointers,
		HeatSink::AttributeIndex
	);

PoweredSubsystem::SharedData
	PoweredSubsystem::DefaultData(
		PoweredSubsystem::ClassDerivations,
		PoweredSubsystem::MessageHandlers,
		PoweredSubsystem::AttributeIndex,
		Subsystem::StateCount
	);

//
//#############################################################################
// A HeatSink that draws electrical power from a generator (binary ctor
// @004b0f74).  Resolves the "VoltageSource" roster index to the powering
// generator, attaches the tap, and primes the electrical state machine.  The
// voltageSourceIndex indexes the owner mech's SUBSYSTEM ROSTER (the same
// index space the AmmoBin link uses) -- the roster slots ahead of this
// subsystem are already constructed by the segment walk, and the shipped
// stream orders the generators first.
//#############################################################################
//
PoweredSubsystem::PoweredSubsystem(
	Mech				*owner,
	int					subsystem_ID,
	SubsystemResource	*subsystem_resource,
	SharedData			&shared_data
):
	HeatSink(owner, subsystem_ID, subsystem_resource, shared_data),
	voltageSource(),
	electricalStateAlarm(5),
	modeAlarm(3)
{
	Check(owner);
	Check_Pointer(subsystem_resource);

	inputVoltage	= 0.0f;
	outputVoltage	= 0.0f;
	ratedVoltage	= 0.0f;

	thermalResistivityCoefficient	= subsystem_resource->thermalResistivityCoefficient;
	startTime						= subsystem_resource->startTime;

	//
	// Cache the authored aux-screen block NOW -- the resource memory dies
	// with the Mech ctor's stream buffer.
	//
	auxScreenNumber		= subsystem_resource->auxScreenNumber;
	auxScreenPlacement	= subsystem_resource->auxScreenPlacement;
	Str_Copy(auxScreenLabel, subsystem_resource->auxScreenLabel,
		sizeof(auxScreenLabel));
	Str_Copy(engScreenLabel, subsystem_resource->engScreenLabel,
		sizeof(engScreenLabel));
	startTimer						= startTime;
	voltageScale					= 1.0f;

	//
	// Resolve the voltage source from the roster and attach the tap.
	//
	Subsystem *source = NULL;
	if (subsystem_resource->voltageSourceIndex >= 0
		&& subsystem_resource->voltageSourceIndex < owner->GetSubsystemCount())
	{
		source = owner->GetSubsystem(subsystem_resource->voltageSourceIndex);
	}
	if (source != NULL)
	{
		AttachToVoltageSource(source);
	}

	if (getenv("BT_POWER_LOG"))
	{
		DEBUG_STREAM << "[power] '" << GetName()
			<< "' srcIdx=" << subsystem_resource->voltageSourceIndex << " -> ";
		if (source != NULL)
		{
			DEBUG_STREAM << source->GetName();
		}
		else
		{
			DEBUG_STREAM << "<none>";
		}
		DEBUG_STREAM << " startTime=" << startTime << endl << flush;
	}

	electricalStateAlarm.SetLevel(Ready);
	modeAlarm.SetLevel(Connected);

	//
	// A master (non-replicant) instance runs the per-frame electrical
	// simulation.  Derived subsystems (the weapons, Sensor, ...) override with
	// their own Performance in their ctors, each of which chains this step.
	//
	if (owner->GetInstance() != Entity::ReplicantInstance)
	{
		SetPerformance(&PoweredSubsystem::PoweredSubsystemSimulation);
	}

	Check_Fpu();
}

//
//#############################################################################
//#############################################################################
//
PoweredSubsystem::~PoweredSubsystem()
{
}

//
//#############################################################################
//#############################################################################
//
void
	PoweredSubsystem::ResetToInitialState(Logical powered)
{
	Check(this);
	HeatSink::ResetToInitialState(powered);
	inputVoltage	= 0.0f;
	outputVoltage	= 0.0f;
	electricalStateAlarm.SetLevel(0);
	modeAlarm.SetLevel(0);
}

//
//#############################################################################
//#############################################################################
//
Logical
	PoweredSubsystem::TestClass(Mech &)
{
	return True;
}

Logical
	PoweredSubsystem::TestInstance() const
{
	return IsDerivedFrom(ClassDerivations);
}

//
//#############################################################################
// AttachToVoltageSource  Link this subsystem to its powering generator
// (binary @004b0dd8): take a tap on the generator (-1 when every tap is
// taken) and hold the live connection.
//#############################################################################
//
int
	PoweredSubsystem::AttachToVoltageSource(Subsystem *source)
{
	Check(this);
	Check(source);

	Generator *generator = (Generator *)source;
	if (generator->TapVoltageSource() != 0)
	{
		return -1;
	}
	voltageSource.Add(source);
	inputVoltage = generator->MeasuredVoltage();
	return 0;
}

//
//#############################################################################
// DetachFromVoltageSource (binary @004b0e30): release the tap on the current
// source and clear the connection.
//#############################################################################
//
void
	PoweredSubsystem::DetachFromVoltageSource()
{
	Check(this);

	Generator *source = (Generator *)voltageSource.Resolve();
	if (source != NULL)
	{
		source->UntapVoltageSource();
		voltageSource.Clear();
	}
}

//
//#############################################################################
// FindGeneratorByNumber (binary @004b0b18): walk the owner's roster for the
// Generator whose authored generatorNumber matches (1=A .. 4=D).
//#############################################################################
//
Subsystem*
	PoweredSubsystem::FindGeneratorByNumber(int generator_number)
{
	Check(this);

	for (int slot = 2; slot < owner->GetSubsystemCount(); ++slot)
	{
		Subsystem *sub = owner->GetSubsystem(slot);
		if (sub != NULL
			&& sub->IsDerivedFrom(Generator::ClassDerivations)
			&& ((Generator *)sub)->GetGeneratorNumber() == generator_number)
		{
			return sub;
		}
	}
	return NULL;
}

//
//#############################################################################
// SelectGenerator -- the manual re-tap: release the current source, tap
// generator N, drop the connect mode back to Connected (a manual selection
// ends any auto-hunt).  The binary dereferences the find unguarded (authored
// mechs always carry A-D); we skip loud instead.
//#############################################################################
//
void
	PoweredSubsystem::SelectGenerator(int generator_number)
{
	Check(this);

	Subsystem *generator = FindGeneratorByNumber(generator_number);
	if (generator == NULL)
	{
		if (getenv("BT_MECH_LOG") || getenv("BT_POWER_LOG"))
		{
			DEBUG_STREAM << "[gensel] '" << GetName()
				<< "' -> generator " << generator_number
				<< " NOT FOUND" << endl << flush;
		}
		return;
	}

	DetachFromVoltageSource();
	int tap = AttachToVoltageSource(generator);
	modeAlarm.SetLevel(Connected);

	if (getenv("BT_MECH_LOG") || getenv("BT_POWER_LOG"))
	{
		DEBUG_STREAM << "[gensel] '" << GetName()
			<< "' -> '" << generator->GetName() << "'"
			<< ((tap >= 0) ? " (tapped)" : " (REFUSED: no spare tap)")
			<< endl << flush;
	}
}

//
//#############################################################################
// The cockpit button handlers (ids 4-8).  Press-only (dataContents > 0),
// novice-locked -- a novice cockpit's generator panel is inert.
//#############################################################################
//
void
	PoweredSubsystem::SelectGeneratorAMessageHandler(
		ReceiverDataMessageOf<int> *message)
{
	Check(this);
	if (!NoviceLockout() && message->dataContents > 0)
	{
		SelectGenerator(1);
	}
}

void
	PoweredSubsystem::SelectGeneratorBMessageHandler(
		ReceiverDataMessageOf<int> *message)
{
	Check(this);
	if (!NoviceLockout() && message->dataContents > 0)
	{
		SelectGenerator(2);
	}
}

void
	PoweredSubsystem::SelectGeneratorCMessageHandler(
		ReceiverDataMessageOf<int> *message)
{
	Check(this);
	if (!NoviceLockout() && message->dataContents > 0)
	{
		SelectGenerator(3);
	}
}

void
	PoweredSubsystem::SelectGeneratorDMessageHandler(
		ReceiverDataMessageOf<int> *message)
{
	Check(this);
	if (!NoviceLockout() && message->dataContents > 0)
	{
		SelectGenerator(4);
	}
}

//
//#############################################################################
// ToggleGeneratorMode (id 8, binary @004b0abc): cycle Manual -> AutoConnect
// -> (detach +) Manual.  The auto-hunt itself (a shorted/dead source makes
// the subsystem walk for a live generator) lives in
// PoweredSubsystemSimulation -- a later brick.
//#############################################################################
//
void
	PoweredSubsystem::ToggleGeneratorModeMessageHandler(
		ReceiverDataMessageOf<int> *message)
{
	Check(this);

	if (NoviceLockout() || message->dataContents <= 0)
	{
		return;
	}
	if ((unsigned)modeAlarm.GetLevel() < (unsigned)AutoConnect)
	{
		modeAlarm.SetLevel(AutoConnect);
	}
	else if (modeAlarm.GetLevel() == AutoConnect)
	{
		DetachFromVoltageSource();
		modeAlarm.SetLevel(ManualConnect);
	}
	if (getenv("BT_MECH_LOG") || getenv("BT_POWER_LOG"))
	{
		DEBUG_STREAM << "[gensel] '" << GetName()
			<< "' mode -> " << modeAlarm.GetLevel() << endl << flush;
	}
}

//
//#############################################################################
// ChargeTimeScale -- the heat/firepower feedback (binary @004b0d50):
//     rise  = max(0, sourceTemperature - sourceStartingTemperature)
//     scale = max(voltageScale,
//                 (thermalResistivityCoefficient * rise + 1) * voltageScale)
// A hot generator stretches the exponential charge constant, so recharging
// slows exactly when the electrical plant is cooking.
//#############################################################################
//
Scalar
	PoweredSubsystem::ChargeTimeScale()
{
	Check(this);

	Generator *source = (Generator *)voltageSource.Resolve();
	if (source == NULL)
	{
		return voltageScale;
	}

	Scalar rise = source->CurrentTemperatureOf()
		- source->StartingTemperatureOf();
	if (rise < 0.0f)
	{
		rise = 0.0f;
	}

	Scalar stretched =
		(thermalResistivityCoefficient * rise + 1.0f) * voltageScale;
	return (stretched > voltageScale) ? stretched : voltageScale;
}

//
//#############################################################################
// DeathReset -- respawn restore for the powered chain and the generators.
//#############################################################################
//
void
	PoweredSubsystem::DeathReset(Logical full_reset)
{
	Check(this);
	MechSubsystem::DeathReset(full_reset);
	ResetToInitialState(True);
	//
	// ResetToInitialState drops the connect-mode indicator to Manual; the
	// respawned subsystem keeps its live tap, so the mode is Connected
	// (the ctor's spawn state).
	//
	modeAlarm.SetLevel(Connected);
}

void
	Generator::DeathReset(Logical full_reset)
{
	Check(this);
	MechSubsystem::DeathReset(full_reset);
	//
	// PRESERVE the tap accounting across the reset: consumers keep their
	// voltageSource links through respawn (nothing detaches), so zeroing
	// currentTapCount here would desync the maxTapCount invariant and let
	// post-respawn SelectGenerator presses oversubscribe the generator
	// (caught by the 5.3.24 adversarial review).
	//
	int live_taps = currentTapCount;
	ResetToInitialState();
	currentTapCount = live_taps;
}

//
//#############################################################################
// ForceShortRecovery (binary @004b11bc): on a short event, drive the powering
// generator to Shorted and clear its output; GeneratorSimulation then runs
// the short-recovery timer back to Ready.  Both @4ac9c8 calls in the binary
// are the not-novice experience predicate (this part and its source share
// the same mech, hence the same player) -- novice cockpits never see
// electrical shorts.
//#############################################################################
//
void
	PoweredSubsystem::ForceShortRecovery()
{
	Check(this);

	if (NoviceLockout())
	{
		return;
	}

	Generator *source = (Generator *)voltageSource.Resolve();
	if (source != NULL)
	{
		source->ForceShort();
		if (getenv("BT_POWER_LOG") || getenv("BT_MECH_LOG"))
		{
			DEBUG_STREAM << "[short] '" << source->GetName()
				<< "' SHORTED by special damage" << endl << flush;
		}
	}
}

//
//#############################################################################
// PoweredSubsystemSimulation -- the per-frame electrical step (binary
// @004b0bd0).  Runs the HeatSink thermal step, then advances the electrical
// state machine from the state of the powering generator.
//
// PARTIAL: the AutoConnect replacement-generator hunt (modeAlarm AutoConnect +
// the status-flag gate) joins with the damage wave.
//#############################################################################
//
void
	PoweredSubsystem::PoweredSubsystemSimulation(Scalar time_slice)
{
	Check(this);

	HeatSink::HeatSinkSimulation(time_slice);

	Generator *source = (Generator *)voltageSource.Resolve();
	if (source == NULL)
	{
		electricalStateAlarm.SetLevel(NoVoltage);
	}
	else
	{
		if (source->GeneratorStateOf() == Generator::GeneratorShorted)
		{
			electricalStateAlarm.SetLevel(Shorted);
		}
		if (source->GeneratorStateOf() == Generator::GeneratorStarting
			|| source->GeneratorStateOf() == Generator::GeneratorFailed)
		{
			electricalStateAlarm.SetLevel(GeneratorOff);
		}
	}

	switch (electricalStateAlarm.GetLevel())
	{
	case Starting:
		startTimer += time_slice;
		if (startTime <= startTimer)
		{
			electricalStateAlarm.SetLevel(Ready);
		}
		break;

	case NoVoltage:
		if (source != NULL)
		{
			electricalStateAlarm.SetLevel(Starting);
			startTimer = 0.0f;
		}
		break;

	case Shorted:
	case GeneratorOff:
		if (source != NULL
			&& source->GeneratorStateOf() == Generator::GeneratorReady)
		{
			electricalStateAlarm.SetLevel(Starting);
			startTimer = 0.0f;
		}
		break;
	}

	if (source != NULL)
	{
		inputVoltage = source->MeasuredVoltage();
	}

	Check_Fpu();
}

//###########################################################################
//##############################   Generator   #############################
//###########################################################################

//
//#############################################################################
// Shared data support
//#############################################################################
//
Derivation
	Generator::ClassDerivations(
		HeatSink::ClassDerivations,
		"Generator"
	);

const Generator::IndexEntry
	Generator::AttributePointers[]=
{
	ATTRIBUTE_ENTRY(Generator, OutputVoltage,		outputVoltage),
	ATTRIBUTE_ENTRY(Generator, RatedVoltage,		ratedVoltage),
	ATTRIBUTE_ENTRY(Generator, GeneratorNumber,		generatorNumber),
	ATTRIBUTE_ENTRY(Generator, GeneratorState,		stateAlarm),
	{ (int)Generator::GeneratorOnAttributeID2, "GeneratorOn",
		(Simulation::AttributePointer)&Generator::generatorOn }
};

Generator::AttributeIndexSet
	Generator::AttributeIndex(
		ELEMENTS(Generator::AttributePointers),
		Generator::AttributePointers,
		HeatSink::AttributeIndex
	);

//
// A Generator IS a HeatSink, and HeatSink is one of only two classes in the
// subsystem tree that defines a message handler of its own -- ToggleCooling.
// Chaining to Subsystem::MessageHandlers here skipped it, so a generator
// silently ignored every cooling toggle it was sent.  Found by sweeping every
// DefaultData against its real C++ base: fifteen classes chain past their
// immediate parent, but the other fourteen skip only classes that add no
// handlers and no attributes, which makes them equivalent (and probably
// authentic).  This one loses a handler, so it is a real defect.
//
Generator::SharedData
	Generator::DefaultData(
		Generator::ClassDerivations,
		HeatSink::MessageHandlers,
		Generator::AttributeIndex,
		Subsystem::StateCount
	);

//
//#############################################################################
// The generator -- the voltage source loads tap.
//#############################################################################
//
Generator::Generator(
	Mech				*owner,
	int					subsystem_ID,
	SubsystemResource	*subsystem_resource,
	SharedData			&shared_data
):
	HeatSink(owner, subsystem_ID, subsystem_resource, shared_data),
	stateAlarm(5)
{
	Check(owner);
	Check_Pointer(subsystem_resource);

	ratedVoltage			= subsystem_resource->ratedVoltage;
	outputVoltage			= ratedVoltage;
	maxTapCount				= subsystem_resource->maxTapCount;
	currentTapCount			= 0;
	percentVoltageAvailable	= 1.0f;
	startTime				= subsystem_resource->startTime;
	startTimer				= startTime;
	stateAlarm.SetLevel(GeneratorReady);
	generatorOn				= 1;
	shortRecoveryTime		= subsystem_resource->shortRecoveryTime;
	shortTimer				= shortRecoveryTime;

	//
	// Generator number from the last character of the segment name
	// ('A' -> 1, 'B' -> 2, ...).
	//
	const char *name = GetName();
	generatorNumber = name[strlen(name) - 1] - 0x40;

	//
	// Install the generator's per-frame electrical Performance.
	//
	if (owner->GetInstance() != Entity::ReplicantInstance)
	{
		SetPerformance(&Generator::GeneratorSimulation);
	}

	Check_Fpu();
}

//
//#############################################################################
//#############################################################################
//
Generator::~Generator()
{
}

//
//#############################################################################
//#############################################################################
//
Logical
	Generator::TestClass(Mech &)
{
	return True;
}

Logical
	Generator::TestInstance() const
{
	return IsDerivedFrom(ClassDerivations);
}

//
//#############################################################################
//#############################################################################
//
void
	Generator::ResetToInitialState()
{
	Check(this);
	HeatSink::ResetToInitialState(True);
	outputVoltage			= ratedVoltage;
	currentTapCount			= 0;
	percentVoltageAvailable	= 1.0f;
	startTimer				= startTime;
	shortTimer				= shortRecoveryTime;
	generatorOn				= 1;
	stateAlarm.SetLevel(GeneratorReady);
}

//
//#############################################################################
// GeneratorSimulation -- the generator's per-frame step (PARTIAL).  Runs the
// HeatSink thermal step and the start/short-recovery timers.  The authentic
// load model (output voltage sag under tap load / I^2R self-heat feeding the
// charge integration) joins with the electrical-charge wave
// (TrackSeekVoltage).  A healthy generator holds GeneratorReady at its rated
// voltage.
//#############################################################################
//
void
	Generator::GeneratorSimulation(Scalar time_slice)
{
	Check(this);

	HeatSink::HeatSinkSimulation(time_slice);

	switch (stateAlarm.GetLevel())
	{
	case GeneratorStarting:
		startTimer += time_slice;
		if (startTime <= startTimer)
		{
			stateAlarm.SetLevel(GeneratorReady);
			outputVoltage = ratedVoltage;
		}
		break;

	case GeneratorShorted:
		shortTimer -= time_slice;
		if (shortTimer <= 0.0f)
		{
			shortTimer = shortRecoveryTime;
			stateAlarm.SetLevel(GeneratorStarting);
			startTimer = 0.0f;
		}
		break;

	default:
		break;
	}

	Check_Fpu();
}

//###########################################################################
//############################   PowerWatcher   ############################
//###########################################################################

Derivation
	PowerWatcher::ClassDerivations(
		HeatWatcher::ClassDerivations,
		"PowerWatcher"
	);

PowerWatcher::SharedData
	PowerWatcher::DefaultData(
		PowerWatcher::ClassDerivations,
		Subsystem::MessageHandlers,
		Subsystem::AttributeIndex,
		Subsystem::StateCount
	);

PowerWatcher::PowerWatcher(
	Mech				*owner,
	int					subsystem_ID,
	SubsystemResource	*subsystem_resource,
	SharedData			&shared_data
):
	HeatWatcher(owner, subsystem_ID, subsystem_resource, shared_data),
	watchdogAlarm(5)
{
	Check(owner);
	Check_Pointer(subsystem_resource);
	//
	// minVoltage is a scaled fraction of the watched supply; the exact scale
	// constant is a tuning value (stored 1:1 here until located).
	//
	minVoltage = subsystem_resource->minVoltagePercent;
		//
	// Install the per-frame watchdog on the master instance.
	//
	if (owner->GetInstance() != Entity::ReplicantInstance)
	{
		SetPerformance(&PowerWatcher::Simulation);
	}

Check_Fpu();
}

PowerWatcher::~PowerWatcher()
{
}

Logical
	PowerWatcher::TestClass(Mech &)
{
	return True;
}

Logical
	PowerWatcher::TestInstance() const
{
	return IsDerivedFrom(ClassDerivations);
}

void
	PowerWatcher::ResetToInitialState(Logical powered)
{
	Check(this);
	HeatWatcher::ResetToInitialState(powered);
	watchdogAlarm.SetLevel(0);
}

void
	PowerWatcher::DeathReset(Logical full_reset)
{
	Check(this);
	MechSubsystem::DeathReset(full_reset);
	ResetToInitialState(True);
}

//
// @004b181c -- the registered Performance wrapper; the body is UpdateWatch.
//
// The watchdog MIRRORS the watched subsystem's electrical state -- this is
// what drives ElectricalStateLevel()==Ready on the Torso (the twist-rate
// power gate) and the searchlight/thermal-sight voltage reads -- with one
// override: a subsystem reading Ready off a SAGGING source (measured
// voltage at or under minVoltage of the source's rating) shows level 1,
// the brownout.
//
void
	PowerWatcher::UpdateWatch()
{
	Check(this);

	WatchSimulation(0.0f);						// the heat-alarm mirror first

	PoweredSubsystem
		*watched = (PoweredSubsystem *)watchedLink.Resolve();
	if (watched == NULL)
	{
		watchdogAlarm.SetLevel(0);
		return;
	}

	unsigned
		level = watched->GetVoltageState();
	watchdogAlarm.SetLevel(level);

	Generator
		*source = (Generator *)watched->ResolveVoltageSource();
	if (
		level == PoweredSubsystem::Ready &&
		source != NULL &&
		source->MeasuredVoltage() <= minVoltage * source->RatedVoltageOf()
	)
	{
		watchdogAlarm.SetLevel(1);				// the brownout
	}
}

void
	PowerWatcher::Simulation(Scalar /* time_slice */)
{
	UpdateWatch();
}

//
//#############################################################################
// CreateStreamedSubsystem -- binary @004b13ac (declared in POWERSUB.HPP all
// along; the definition was the gap).  Chains the shared heat-record parser
// (@004ae150 -- HeatSink adds no keys, so the chain call is Heatable's),
// stamps classID 0x0BC2 / size 0x190, then the electrical block: the
// REQUIRED "VoltageSource" subsystem link (+2 segment-table bias), the
// thermal resistivity, the aux/eng screen plumbing the cockpit reads
// (AuxScreenPlacement optional; AuxScreenNumber/labels required), and
// "StartTime".
//#############################################################################
//
int
	PoweredSubsystem::CreateStreamedSubsystem(
		NotationFile				*model_file,
		const char					*model_name,
		const char					*subsystem_name,
		SubsystemResource			*subsystem_resource,
		NotationFile				*subsystem_file,
		const ResourceDirectories	*directories,
		int							passes
	)
{
	if (
		!HeatableSubsystem::CreateStreamedSubsystem(
			model_file, model_name, subsystem_name,
			subsystem_resource, subsystem_file, directories, passes
		)
	)
	{
		return False;
	}

	subsystem_resource->subsystemModelSize	= 0x190;
	subsystem_resource->classID				= RegisteredClass::PoweredSubsystemClassID;

	if (passes == 1)
	{
		subsystem_resource->voltageSourceIndex				= -1;
		subsystem_resource->thermalResistivityCoefficient	= -1.0f;
		subsystem_resource->auxScreenNumber					= -1;
		subsystem_resource->auxScreenPlacement				= -1;
		memset(subsystem_resource->auxScreenLabel, 0,
			sizeof(subsystem_resource->auxScreenLabel));
		memset(subsystem_resource->engScreenLabel, 0,
			sizeof(subsystem_resource->engScreenLabel));
		subsystem_resource->startTime						= -1.0f;
	}

	const char
		*voltage_source_name = "Unspecified";
	if (
		!subsystem_file->GetEntry(subsystem_name, "VoltageSource",
			&voltage_source_name)
		&& subsystem_resource->voltageSourceIndex == -1
	)
	{
		DEBUG_STREAM << subsystem_name << " missing VoltageSource!" << endl;
		return False;
	}
	if (strcmp(voltage_source_name, "Unspecified") != 0)
	{
		subsystem_resource->voltageSourceIndex =
			Find_Subsystem_Index(subsystem_file, voltage_source_name);
	}
	if (subsystem_resource->voltageSourceIndex < 0)
	{
		DEBUG_STREAM << subsystem_name << " has an invalid voltage source!" << endl;
		return False;
	}
	if (strcmp(voltage_source_name, "Unspecified") != 0)
	{
		subsystem_resource->voltageSourceIndex += 2;
	}

	if (
		!subsystem_file->GetEntry(subsystem_name, "ThermalResistivityCoefficient",
			&subsystem_resource->thermalResistivityCoefficient)
		&& subsystem_resource->thermalResistivityCoefficient == -1.0f
	)
	{
		DEBUG_STREAM << subsystem_name << " missing ThermalResistivityCoefficient!" << endl;
		return False;
	}

	subsystem_file->GetEntry(subsystem_name, "AuxScreenPlacement",
		&subsystem_resource->auxScreenPlacement);

	if (
		!subsystem_file->GetEntry(subsystem_name, "AuxScreenNumber",
			&subsystem_resource->auxScreenNumber)
		&& subsystem_resource->auxScreenNumber == -1
	)
	{
		DEBUG_STREAM << subsystem_name << " missing AuxScreenNumber!" << endl;
		return False;
	}

	const char
		*label;
	if (subsystem_file->GetEntry(subsystem_name, "AuxScreenLabel", &label))
	{
		strcpy(subsystem_resource->auxScreenLabel, label);
	}
	else if (subsystem_resource->auxScreenLabel[0] == '\0')
	{
		DEBUG_STREAM << subsystem_name << " missing AuxScreenLabel!" << endl;
		return False;
	}
	if (subsystem_file->GetEntry(subsystem_name, "EngScreenLabel", &label))
	{
		strcpy(subsystem_resource->engScreenLabel, label);
	}
	else if (subsystem_resource->engScreenLabel[0] == '\0')
	{
		DEBUG_STREAM << subsystem_name << " missing EngScreenLabel!" << endl;
		return False;
	}

	if (
		!subsystem_file->GetEntry(subsystem_name, "StartTime",
			&subsystem_resource->startTime)
		&& subsystem_resource->startTime == -1.0f
	)
	{
		DEBUG_STREAM << subsystem_name << " missing StartTime!" << endl;
		return False;
	}

	Check_Fpu();
	return True;
}