TestFlight_Generic_Engines.cfg

// Pre-process: EngineConfigs/ put TESTFLIGHT nodes inside MEC/CONFIGs;
// this lets us copy some fields from one to the other, but then the
// FOR:zTestFlight processing steps need them directly in the PART node.
// Must use BEFORE to preserve TestLite compatibility.
@PART[*]:HAS[@MODULE[Module*EngineConfigs]]:BEFORE[zTestFlight]
{
	@MODULE[Module*EngineConfigs]
	{
		@CONFIG:HAS[@TESTFLIGHT:HAS[#ratedBurnTime]] { &ratedBurnTime = #$TESTFLIGHT/ratedBurnTime$ }
		@CONFIG:HAS[@TESTFLIGHT:HAS[#ratedContinuousBurnTime]] { &ratedContinuousBurnTime = #$TESTFLIGHT/ratedContinuousBurnTime$ }
		@CONFIG:HAS[@TESTFLIGHT:HAS[#testedBurnTime]] {
			// The game doesn't show testedBurnTime anywhere!
			// I like having it in the description for lack of something better
			@description = #$description$ testedBurnTime=$TESTFLIGHT/testedBurnTime$
		}

		@CONFIG:HAS[@TESTFLIGHT]
		{
			|_ = CONFIG_wip // for the MM_PATCH_LOOP below
			@TESTFLIGHT,* {
				%name = #$../name$
			}
		}
	}
}

// This is a loop: one CONFIG-with-TESTFLIGHT-inside at a time, move TESTFLIGHT
// node out of the MEC
@PART[*]:HAS[@MODULE[Module*EngineConfigs]:HAS[@CONFIG_wip]]:BEFORE[zTestFlight]
{
	#/MODULE[Module*EngineConfigs]/CONFIG_wip/TESTFLIGHT {}

	@MODULE[Module*EngineConfigs]
	{
		@CONFIG_wip
		{
			!TESTFLIGHT {}
			|_ = CONFIG
		}
	}
	MM_PATCH_LOOP {}
}

@PART[*]:HAS[@TESTFLIGHT,#clusterMultiplier]:BEFORE[zTestFlight]
{
	@TESTFLIGHT,* {
		// PARTs set a clusterMultplier, but it's the TESTFLIGHT
		// block that really wants it
		&clusterMultiplier = #$../clusterMultiplier$
	}
}

// Handle TF interop
@PART:HAS[@TESTFLIGHT,@MODULE[TestFlightInterop]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	!TESTFLIGHT,* {} // something else is configuring TF, so don't do it.
}
@PART:HAS[@TESTFLIGHT,!MODULE[TestFlightInterop]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	MODULE { name = TestFlightInterop }
}

// Force-set isSolid=true for cases where we have an engine type.
@PART:HAS[@MODULE[ModuleEnginesRF]:HAS[#EngineType[SolidBooster]]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	@TESTFLIGHT,* { %isSolid = True }
}

// Preprocess
@PART:HAS[@TESTFLIGHT]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	@TESTFLIGHT,*
	{
		&name = TFGenericMissingName

		// First, set the 'mainConfiguration' to be the name of the engine config we will bind to.
		&mainConfiguration = #engineConfig = $name$:$name$

		// Set default parameters for the curve.
		// TF configs generally have a "kink" in their du->reliability curve,
		// where reliability hits the midpoint. Usually you hit 50% reliability
		// gains well before you get 50% data.
		// This sets up the default parameters which we can override as desired.
		&reliabilityMidV = 0.75
		&reliabilityMidH = 0.4
		&reliabilityMidTangentWeight = 0.5

		// How many engines are in this cluster
		&clusterMultiplier = 1.0

		// Default multiplier to data produced
		&reliabilityDataRateMultiplier = 1.0

		// Start tech transfer out blank
		&techTransfer =

		// Default chance for triggering an additional failure on the same engine when an ignition failure occurs
		&additionalIgnitionFailureChance = 0.2

		//Create placeholder flat curve for restartWindowPenalty
		&restartWindowPenalty
		{
			key = 0 1
			key = 1 1
		}
		
		//Create placeholder flat curve for thrustModifier
		&thrustModifier
		{
			key = 0 1
			key = 1 1
		}

		// Default overburn penalty. This is the value of the `cycle` curve at `testedBurnTime`.
		&overburnPenalty = 2.0
	}

	// Now we create the actual curves for TestFlight.
	@TESTFLIGHT,*
	{
		// Perform a transformation to decrease reliability
		// of ignitions on clusters. We do this for both start and end of curve.
		// Note that since reliability starts <= 1.0,
		// multiplying by -1 and then adding 1 gives us
		// the failure chance rather than the ignition chance.
		// With that we multiply the failure chance by the
		// cluster mult, then transform back.
		@ignitionReliabilityStart *= -1
		@ignitionReliabilityStart += 1
		@ignitionReliabilityStart *= #$clusterMultiplier$
		@ignitionReliabilityStart -= 1
		@ignitionReliabilityStart *= -1

		@ignitionReliabilityEnd *= -1
		@ignitionReliabilityEnd += 1
		@ignitionReliabilityEnd *= #$clusterMultiplier$
		@ignitionReliabilityEnd -= 1
		@ignitionReliabilityEnd *= -1

		// Now we do the same thing for cycle reliability.

		@cycleReliabilityStart *= -1
		@cycleReliabilityStart += 1
		@cycleReliabilityStart *= #$clusterMultiplier$
		@cycleReliabilityStart -= 1
		@cycleReliabilityStart *= -1

		@cycleReliabilityEnd *= -1
		@cycleReliabilityEnd += 1
		@cycleReliabilityEnd *= #$clusterMultiplier$
		@cycleReliabilityEnd -= 1
		@cycleReliabilityEnd *= -1

		// Multiply data rate by cluster multiplier.
		@reliabilityDataRateMultiplier *= #$clusterMultiplier$

		// Start creating our fail chance curve.
		// Again, transform from reliability to failure chance
		// so we can apply cluster mult.
		failChanceStart = #$cycleReliabilityStart$
		@failChanceStart *= -1
		@failChanceStart += 1
		@failChanceStart /= #$ratedBurnTime$
		failChanceEnd = #$cycleReliabilityEnd$
		@failChanceEnd *= -1
		@failChanceEnd += 1
		@failChanceEnd /= #$ratedBurnTime$

		reliabilityCurve
		{
			// Create first key
			key10 = 0
			key11 = #$../failChanceStart$

			// Calculate kink time
			key20 = #$../reliabilityMidH$
			@key20 *= 5000
			@key20 += 1000

			// Calculate kink value
			key21 = #$../failChanceEnd$
			@key21 -= #$../failChanceStart$
			@key21 *= #$../reliabilityMidV$
			@key21 += #$../failChanceStart$

			// Calculate kink tangent
			key22 = #$../failChanceEnd$
			@key22 -= #$../failChanceStart$
			@key22 *= 0.0001
			@key22 *= #$../reliabilityMidTangentWeight$
			// now average it with the linear tangent to the endpoint
			key221 = #$../failChanceEnd$
			@key221 -= #$key21$
			key222 = 10000
			@key222 -= #$key20$
			@key221 /= #$key222$
			@key222 = #$../reliabilityMidTangentWeight$
			@key222 *= -1
			@key222 += 1
			@key221 *= #$key222$
			@key22 += #$key221$

			// Create end key
			key30 = 10000
			key31 = #$../failChanceEnd$
			key32 = 0 // flat tangent

			// Create the keys
			key = #$key10$ $key11$
			key = #$key20$ $key21$ $key22$ $key22$
			key = #$key30$ $key31$ $key32$ $key32$

			// Clean up
			!key10 = DEL
			!key11 = DEL
			!key20 = DEL
			!key21 = DEL
			!key22 = DEL
			!key30 = DEL
			!key31 = DEL
			!key32 = DEL
			!key221 = DEL
			!key222 = DEL
		}

		baseIgnitionChance
		{
			// Create first key
			key10 = 0
			key11 = #$../ignitionReliabilityStart$

			// Calculate kink time
			key20 = #$../reliabilityMidH$
			@key20 *= 5000
			@key20 += 1000

			// Calculate kink value
			key21 = #$../ignitionReliabilityEnd$
			@key21 -= #$../ignitionReliabilityStart$
			@key21 *= #$../reliabilityMidV$
			@key21 += #$../ignitionReliabilityStart$

			// Calculate kink tangent
			// tangent = Y/X
			key22 = #$../ignitionReliabilityEnd$
			@key22 -= #$../ignitionReliabilityStart$
			@key22 *= 0.0001
			@key22 *= #$../reliabilityMidTangentWeight$
			// now average it with the linear tangent to the endpoint
			key221 = #$../ignitionReliabilityEnd$
			@key221 -= #$key21$
			key222 = 10000
			@key222 -= #$key20$
			@key221 /= #$key222$
			@key222 = #$../reliabilityMidTangentWeight$
			@key222 *= -1
			@key222 += 1
			@key221 *= #$key222$
			@key22 += #$key221$

			// Create end key
			key30 = 10000
			key31 = #$../ignitionReliabilityEnd$
			key32 = 0 // flat intangent

			// Create the keys
			key = #$key10$ $key11$
			key = #$key20$ $key21$ $key22$ $key22$
			key = #$key30$ $key31$ $key32$ $key32$

			// Clean up
			!key10 = DEL
			!key11 = DEL
			!key20 = DEL
			!key21 = DEL
			!key22 = DEL
			!key221 = DEL
			!key222 = DEL
			!key30 = DEL
			!key31 = DEL
			!key32 = DEL
		}
	}

	// Generation of cycle curves. There are three cases:
	// (a) Only `ratedBurnTime` is specified. This is the pre-TF v2.1 behavior (only a `cycle`
	//     curve, 100 at 2.5x `ratedBurnTime`).
	// (b) `ratedBurnTime` and `ratedContinuousBurnTime` are specified. This is for 'space taxi'
	//     engines whose full burn time is split across multiple small burns. In this case,
	//     create a `cycle` curve as with (a) but also a `continuousCycle` curve with the
	//     same rules (100 at 2.5x `ratedContinuousBurnTime`).
	// (c) `ratedBurnTime` and `testedBurnTime` are specified. This is for engines that have
	//     been tested for a longer duration on the test stand than what they have been 'rated'
	//     for. In this case, Create only a `cycle` curve, but use more keys. After the
	//     (`ratedBurnTime` + 5, 1) point, the next point is (`testedBurnTime`, `overburnPenalty`).
	//     The in and out tangents (which are equal) on this point are set to provide a smooth
	//     transition in failure chance from `ratedBurnTime` to `testedBurnTime`, and then to
	//     complete failure at (2.5 x `testedBurnTime`, 100).
	@TESTFLIGHT,*
	{
		cycle
		{
			// Failure rate at start of burn.
			key = 0.00 10.00
			key = 5.00 1.00 -0.8 0

			// 5 seconds of overburn for free.
			rbtCushioned = #$../ratedBurnTime$
			@rbtCushioned += 5
			key = #$rbtCushioned$ 1 0 0

			// Complete failure at 2.5x burn time.
			failTime = #$../ratedBurnTime$
			@failTime *= 2.5
			rbtToFailInterval = #$failTime$
			@rbtToFailInterval -= #$rbtCushioned$
			failInSlope = 292.8 // Magic number.
			@failInSlope /= #$rbtToFailInterval$

			key = #$failTime$ 100 $failInSlope$ 0

			// Cleanup.
			!rbtCushioned = DEL
			!failTime = DEL
			!rbtToFailInterval = DEL
			!failInSlope = DEL
		}
	}
	@TESTFLIGHT:HAS[#ratedContinuousBurnTime]
	{
		continuousCycle
		{
			// Failure rate at start of burn.
			key = 0.00 10.00
			key = 5.00 1.00 -0.8 0

			// 5 seconds of overburn for free.
			rcbtCushioned = #$../ratedContinuousBurnTime$
			@rcbtCushioned += 5
			key = #$rcbtCushioned$ 1 0 0

			// Complete failure at 2.5x burn time.
			failTime = #$../ratedContinuousBurnTime$
			@failTime *= 2.5
			rcbtToFailInterval = #$failTime$
			@rcbtToFailInterval -= #$rcbtCushioned$
			failInSlope = 292.8 // Magic number.
			@failInSlope /= #$rcbtToFailInterval$

			key = #$failTime$ 100 $failInSlope$ 0

			// Cleanup.
			!rcbtCushioned = DEL
			!failTime = DEL
			!rcbtToFailInterval = DEL
			!failInSlope = DEL
		}
	}
	@TESTFLIGHT:HAS[#testedBurnTime]
	{
		@cycle
		{
			// Remove the original full failure point.
			!key,3 = DEL

			// Curve has value `overburnPenalty` at tested burn time, transition smoothly.
			// No 5s cushion here.
			ratedToTestedInterval = #$../testedBurnTime$
			@ratedToTestedInterval -= #$key,2[0, ]$  // This key contains the cushioned rated burn time.
			// Compute the slope at the tested burn time. The curve is made to be differentiable
			// at this point, but the exact slope depends on the overburn penalty.
			tbtTransitionSlope = 3.135 // Magic number, for an overburn penalty of 2.
			@tbtTransitionSlope /= #$ratedToTestedInterval$
			tbtTransitionSlopeMult = #$../overburnPenalty$
			@tbtTransitionSlopeMult -= 1.0 // When overburn penalty is 1 the slope should be 0.
			@tbtTransitionSlope *= #$tbtTransitionSlopeMult$
			key = #$../testedBurnTime$ $../overburnPenalty$ $tbtTransitionSlope$ $tbtTransitionSlope$

			// Fail at 2.5x tested burn time.
			failTime = #$../testedBurnTime$
			@failTime *= 2.5
			tbtToFailInterval = #$failTime$
			@tbtToFailInterval -= #$../testedBurnTime$
			// Compute the in-tangent slope.
			failInSlope = 1.989  // Magic number.
			@failInSlope /= #$tbtToFailInterval$
			// The end point of this segment of the curve is always 100, but the start point
			// depends on the overburn penalty. Adjust accordingly.
			failInSlopeMult = 100
			@failInSlopeMult -= #$../overburnPenalty$
			@failInSlope *= #$failInSlopeMult$
			key = #$failTime$ 100 $failInSlope$ 0

			// Cleanup.
			!ratedToTestedInterval = DEL
			!tbtTransitionSlope = DEL
			!tbtTransitionSlopeMult = DEL
			!failTime = DEL
			!tbtToFailInterval = DEL
			!failInSlope = DEL
			!failInSlopeMult = DEL
		}
	}

	// Create placeholder continuous curves for engines that don't have them. This would normally be
	// done by TF (see https://github.com/KSP-RO/TestFlight/blob/c2a4fc999e827a6a8b98d9b2746d1bc9256d18c7/TestFlightReliability_EngineCycle.cs#L153-L172)
	// but we need to do it ourselves here because we need to paste them in an `MM_PATCH_LOOP` later
	// and there's no easy way to do so conditionally.
	@TESTFLIGHT:HAS[~ratedContinuousBurnTime]
	{
		ratedContinuousBurnTime = #$ratedBurnTime$
		continuousCycle { key = 0 1 }
	}

	// If we are not setting an explicit data rate,
	// then we normalize it based on the burn time.
	@TESTFLIGHT:HAS[~explicitDataRate[?rue]]
	{
		@reliabilityDataRateMultiplier *= 640 // normalized to rate=4 at 160s burntime
		@reliabilityDataRateMultiplier /= #$ratedContinuousBurnTime$
	}
}

// Create uninitalized nodes
@PART:HAS[@TESTFLIGHT]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	MODULE
	{
		name = TestFlightCore
		configVersion = 2
	}
	MODULE
	{
		name = FlightDataRecorder_Engine
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightReliability
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightReliability_EngineCycle
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightFailure_EnginePerformanceLoss
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightFailure_IgnitionFail
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightFailure_Explode
		configVersion = 2
	}
}
@PART:HAS[@TESTFLIGHT:HAS[~isSolid[?rue]]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	MODULE
	{
		name = TestFlightFailure_ShutdownEngine
		configVersion = 2
	}
	MODULE
	{
		name = TestFlightFailure_ReducedMaxThrust
		configVersion = 2
	}
	
	// Only default this to 1.0 for non-solids
	@TESTFLIGHT:HAS[~isSolid[?rue]]
	{
		// Default multiplier to failure chance from dynamic pressure
		&ignitionDynPresFailMultiplier = 1.0
	}
}

@PART:HAS[@TESTFLIGHT:HAS[#isSolid[?rue]]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	@TESTFLIGHT:HAS[#isSolid[?rue]]
	{
		// Default multiplier to failure chance from dynamic pressure - solids default to 0
		&ignitionDynPresFailMultiplier = 0
	}
}


// Iterate over each TESTFLIGHT node, appending new config data into each module.
// Constant data gets patched in at the end.
@PART:HAS[@TESTFLIGHT]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	@MODULE[TestFlightCore]
	{
		CONFIG
		{
			title = #$/TESTFLIGHT/name$
			configuration = #$/TESTFLIGHT/mainConfiguration$
			techTransfer = #$/TESTFLIGHT/techTransfer$
		}
	}
	@MODULE[FlightDataRecorder_Engine]
	{
		CONFIG
		{
			configuration = #$/TESTFLIGHT/name$
			flightDataMultiplier = #$/TESTFLIGHT/reliabilityDataRateMultiplier$
		}
	}
	@MODULE[TestFlightReliability]
	{
		CONFIG
		{
			configuration = #$/TESTFLIGHT/name$
			#/TESTFLIGHT/reliabilityCurve {}
		}
	}
	@MODULE[TestFlightReliability_EngineCycle]
	{
		CONFIG
		{
			configuration = #$/TESTFLIGHT/name$
			ratedBurnTime = #$/TESTFLIGHT/ratedBurnTime$
			ratedContinuousBurnTime = #$/TESTFLIGHT/ratedContinuousBurnTime$
			engineConfig = #$/TESTFLIGHT/name$
			#/TESTFLIGHT/cycle {}
			#/TESTFLIGHT/continuousCycle {}
			#/TESTFLIGHT/thrustModifier {}
		}
	}
	@MODULE[TestFlightFailure_IgnitionFail]
	{
		CONFIG
		{
			configuration = #$/TESTFLIGHT/name$
			additionalFailureChance = #$/TESTFLIGHT/additionalIgnitionFailureChance$
			pressureCurve
			{
				ignitionDynPresFailMultiplier = #$/TESTFLIGHT/ignitionDynPresFailMultiplier$
			}
			#/TESTFLIGHT/baseIgnitionChance {}
			#/TESTFLIGHT/restartWindowPenalty {}
		}
	}
	@MODULE[TestFlightFailure_ShutdownEngine]
	{
		CONFIG { configuration = #$/TESTFLIGHT/name$ }
	}
	@MODULE[TestFlightFailure_ReducedMaxThrust]
	{
		CONFIG { configuration = #$/TESTFLIGHT/name$ }
	}
	@MODULE[TestFlightFailure_EnginePerformanceLoss]
	{
		CONFIG { configuration = #$/TESTFLIGHT/name$ }
	}
	@MODULE[TestFlightFailure_Explode]
	{
		CONFIG { configuration = #$/TESTFLIGHT/name$ }
	}

	!TESTFLIGHT {} // remove the node we processed

	MM_PATCH_LOOP {}
}

// Set all the constant configuration values here, instead of in the patch-duplicating process.
@PART:HAS[@MODULE[TestFlightCore]]:FOR[zTestFlight]:NEEDS[!TestLite,TestFlight]
{
	@MODULE[TestFlightCore]
	{
		@CONFIG,*
		{
			maxData = 10000
			techTransferMax = 2000
			perFlightMax = 1000
		}
	}
	@MODULE[FlightDataRecorder_Engine]
	{
		@CONFIG,*
		{
			flightDataEngineerModifier = 0.4
		}
	}
	@MODULE[TestFlightFailure_ShutdownEngine]
	{
		@CONFIG,*
		{
			REPAIR
			{
				canBeRepairedInFlight = True
				dataSize = 1
				dataScale = 1
				repairChance = 75
				canBeRepairedOnSplashed = True
				canBeRepairedByRemote = True
			}
			awardDuInPreLaunch = False
			duFail = 1100
			weight = 32
			failureType = software
			failureTitle = Engine Shutdown
			duRepair = 50
			severity = major
		}
	}
	@MODULE[TestFlightFailure_IgnitionFail]
	{
		@CONFIG,*
		{
			// Handle the pressure curve, checking if the fail chance is zero first.
			// Set the first key
			@pressureCurve
			{
				key = 0 1 0 0
			}
			
			// If fail mult is >0, set the other keys
			@pressureCurve:HAS[~ignitionDynPresFailMultiplier[0]]
			{
				key = 5000 1 0 0
				key = 15000 0.85
				key = 30000 0.4
				key = 50000 0.15 0 0
				@key,*[0, ] *= #$ignitionDynPresFailMultiplier$
			}
			
			// Finally clean up
			@pressureCurve
			{
				!ignitionDynPresFailMultiplier = DEL
			}
			
			restoreIgnitionCharge = False
			duFail = 1050
			oneShot = True
			awardDuInPreLaunch = True
			failureType = mechanical
			failureTitle = Failed to ignite
			ignorePressureOnPad = True // doesn't actually do anything...
			severity = major
		}
	}
	@MODULE[TestFlightFailure_ReducedMaxThrust]
	{
		@CONFIG,*
		{
			oneShot = True
			awardDuInPreLaunch = False
			REPAIR
			{
				canBeRepairedInFlight = False
				canBeRepairedOnSplashed = False
				canBeRepairedByRemote = False
				repairChance = 75
			}
			duFail = 700
			weight = 8
			failureType = mechanical
			failureTitle = Loss of Thrust
			duRepair = 250
			severity = minor
		}
	}
	@MODULE[TestFlightFailure_EnginePerformanceLoss]
	{
		@CONFIG,*
		{
			oneShot = True
			awardDuInPreLaunch = False
			REPAIR
			{
				canBeRepairedInFlight = False
				canBeRepairedOnSplashed = False
				canBeRepairedByRemote = False
				repairChance = 75
			}
			duFail = 800
			weight = 16
			failureType = mechanical
			failureTitle = Performance Loss
			duRepair = 250
			severity = minor
			ispMultiplier = 0.5
			ispMultiplierJitter = 0.1
		}
	}
	@MODULE[TestFlightFailure_Explode]
	{
		@CONFIG,*
		{
			awardDuInPreLaunch = False
			failureTitle = Explosion!
			duFail = 1300
			weight = 2
			failureType = mechanical
			severity = major
		}
	}
}