public void Update()
{
if (prev_multiplier != Main.Instance.seatruckSpeedMultiplier || currentCyclopsMotorMode != subcontrol.cyclopsMotorMode.cyclopsMotorMode)
{
switch (subcontrol.cyclopsMotorMode.cyclopsMotorMode)
{
case CyclopsMotorMode.CyclopsMotorModes.Slow:
subcontrol.BaseForwardAccel = def_Slow_BaseForwardAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseVerticalAccel = def_Slow_BaseVerticalAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseTurningTorque = def_Slow_BaseTurningTorque * Main.Instance.seatruckSpeedMultiplier;;
break;
case CyclopsMotorMode.CyclopsMotorModes.Standard:
subcontrol.BaseForwardAccel = def_Standard_BaseForwardAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseVerticalAccel = def_Standard_BaseVerticalAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseTurningTorque = def_Standard_BaseTurningTorque * Main.Instance.seatruckSpeedMultiplier;;
break;
case CyclopsMotorMode.CyclopsMotorModes.Flank:
subcontrol.BaseForwardAccel = def_Flank_BaseForwardAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseVerticalAccel = def_Flank_BaseVerticalAccel * Main.Instance.seatruckSpeedMultiplier;;
subcontrol.BaseTurningTorque = def_Flank_BaseTurningTorque * Main.Instance.seatruckSpeedMultiplier;;
break;
}
currentCyclopsMotorMode = subcontrol.cyclopsMotorMode.cyclopsMotorMode;
prev_multiplier = Main.Instance.seatruckSpeedMultiplier;
#if DEBUG_CYCLOPS_OVERDRIVE
Logger.Log($"[CheatManager]\nCyclopsOverDrive().Update()\nMotorMode: {subcontrol.cyclopsMotorMode.cyclopsMotorMode}:\nBaseForwardAccel: {subcontrol.BaseForwardAccel}\nBaseVerticalAccel: {subcontrol.BaseVerticalAccel}\nBaseTurningTorque: {subcontrol.BaseTurningTorque}");
#endif
}
}
public void BroadcastChangeEngineMode(NitroxId id, CyclopsMotorMode.CyclopsMotorModes mode)
{
vehicles.GetVehicles <CyclopsModel>(id).EngineMode = mode;
CyclopsChangeEngineMode packet = new CyclopsChangeEngineMode(id, mode);
packetSender.Send(packet);
}
public CyclopsModel(NitroxModel.DataStructures.TechType techType, NitroxId id, Vector3 position, Quaternion rotation, List <InteractiveChildObjectIdentifier> interactiveChildIdentifiers, Optional <NitroxId> dockingBayId, string name, Vector3[] hsb, Vector3[] colours) : base(techType, id, position, rotation, interactiveChildIdentifiers, dockingBayId, name, hsb, colours)
{
FloodLightsOn = true;
InternalLightsOn = true;
SilentRunningOn = false;
ShieldOn = false;
SonarOn = false;
EngineState = false;
EngineMode = CyclopsMotorMode.CyclopsMotorModes.Standard;
}
public void ChangeEngineMode(NitroxId id, CyclopsMotorMode.CyclopsMotorModes mode)
{
GameObject cyclops = NitroxIdentifier.RequireObjectFrom(id);
CyclopsMotorMode motorMode = cyclops.RequireComponentInChildren <CyclopsMotorMode>();
if (motorMode.cyclopsMotorMode != mode)
{
motorMode.BroadcastMessage("SetCyclopsMotorMode", mode, SendMessageOptions.RequireReceiver);
}
}
public SpeedHandler(CyclopsSpeedModule cyclopsSpeedModule, SubRoot cyclops) : base(cyclopsSpeedModule.TechType, cyclops)
{
speedModule = cyclopsSpeedModule;
this.MaxCount = MaxSpeedBoosters;
// Store the original values before we start to change them
originalSpeeds[0] = this.MotorMode.motorModeSpeeds[0];
originalSpeeds[1] = this.MotorMode.motorModeSpeeds[1];
originalSpeeds[2] = this.MotorMode.motorModeSpeeds[2];
originalNoise[0] = this.MotorMode.motorModeNoiseValues[0];
originalNoise[1] = this.MotorMode.motorModeNoiseValues[1];
originalNoise[2] = this.MotorMode.motorModeNoiseValues[2];
OnFirstTimeMaxCountReached = () =>
{
ErrorMessage.AddMessage(CyclopsSpeedModule.MaxRatingAchived);
};
OnFinishedUpgrades = () =>
{
this.EfficiencyPenalty = Mathf.Pow(EnginePowerPenalty, this.Count);
this.RatingManager.ApplyPowerRatingModifier(TechType, this.EfficiencyPenalty);
int speedIndex = this.Count;
if (lastKnownSpeedIndex == speedIndex)
{
return;
}
lastKnownSpeedIndex = speedIndex;
float speedMultiplier = this.SpeedMultiplier = SpeedModifiers[speedIndex];
float noiseMultiplier = this.NoisePenalty = 1f + 0.05f * speedIndex;
// These will apply when changing speed modes
this.MotorMode.motorModeSpeeds[0] = originalSpeeds[0] * speedMultiplier;
this.MotorMode.motorModeSpeeds[1] = originalSpeeds[1] * speedMultiplier;
this.MotorMode.motorModeSpeeds[2] = originalSpeeds[2] * speedMultiplier;
this.MotorMode.motorModeNoiseValues[0] = originalNoise[0] * noiseMultiplier;
this.MotorMode.motorModeNoiseValues[1] = originalNoise[1] * noiseMultiplier;
this.MotorMode.motorModeNoiseValues[2] = originalNoise[2] * noiseMultiplier;
// These will apply immediately
CyclopsMotorMode.CyclopsMotorModes currentMode = this.MotorMode.cyclopsMotorMode;
this.SubControl.BaseForwardAccel = this.MotorMode.motorModeSpeeds[(int)currentMode];
ErrorMessage.AddMessage(CyclopsSpeedModule.SpeedRatingText(lastKnownSpeedIndex, speedMultiplier));
};
}
public CyclopsChangeEngineMode(string guid, CyclopsMotorMode.CyclopsMotorModes mode)
{
Guid = guid;
Mode = mode;
}
/// <summary>
/// Updates the Cyclops power and speed rating.
/// Power Rating manages engine efficiency as well as the power cost of using Silent Running, Sonar, and Defense Shield.
/// Speed rating manages bonus speed across all motor modes.
/// </summary>
internal void UpdatePowerSpeedRating()
{
int powerIndex = EngineEfficientyUpgrades.HighestValue;
int speedBoosters = SpeedBoosters.Count;
if (lastKnownPowerIndex != powerIndex)
{
lastKnownPowerIndex = powerIndex;
Cyclops.silentRunningPowerCost = SilentRunningPowerCosts[powerIndex];
Cyclops.sonarPowerCost = SonarPowerCosts[powerIndex];
Cyclops.shieldPowerCost = ShieldPowerCosts[powerIndex];
}
// Speed modules can affect power rating too
float efficiencyBonus = EnginePowerRatings[powerIndex];
for (int i = 0; i < speedBoosters; i++)
{
efficiencyBonus *= EnginePowerPenalty;
}
int cleanRating = Mathf.CeilToInt(100f * efficiencyBonus);
while (cleanRating % 5 != 0)
{
cleanRating--;
}
float powerRating = cleanRating / 100f;
if (lastKnownPowerRating != powerRating)
{
lastKnownPowerRating = powerRating;
Cyclops.currPowerRating = powerRating;
// Inform the new power rating just like the original method would.
ErrorMessage.AddMessage(Language.main.GetFormat("PowerRatingNowFormat", powerRating));
}
if (speedBoosters > MaxSpeedModules)
{
return; // Exit here
}
if (lastKnownSpeedBoosters != speedBoosters)
{
lastKnownSpeedBoosters = speedBoosters;
float SlowMultiplier = 1f;
float StandardMultiplier = 1f;
float FlankMultiplier = 1f;
// Calculate the speed multiplier with diminishing returns
while (--speedBoosters > -1)
{
SlowMultiplier += SlowSpeedBonuses[speedBoosters];
StandardMultiplier += StandardSpeedBonuses[speedBoosters];
FlankMultiplier += FlankSpeedBonuses[speedBoosters];
}
// These will apply when changing speed modes
this.MotorMode.motorModeSpeeds[0] = this.OriginalSpeeds[0] * SlowMultiplier;
this.MotorMode.motorModeSpeeds[1] = this.OriginalSpeeds[1] * StandardMultiplier;
this.MotorMode.motorModeSpeeds[2] = this.OriginalSpeeds[2] * FlankMultiplier;
// These will apply immediately
CyclopsMotorMode.CyclopsMotorModes currentMode = this.MotorMode.cyclopsMotorMode;
this.SubControl.BaseForwardAccel = this.MotorMode.motorModeSpeeds[(int)currentMode];
ErrorMessage.AddMessage(CyclopsSpeedBooster.SpeedRatingText(lastKnownSpeedBoosters, Mathf.RoundToInt(StandardMultiplier * 100)));
}
}
public void ChangeEngineMode(string guid, CyclopsMotorMode.CyclopsMotorModes mode)
{
CyclopsChangeEngineMode packet = new CyclopsChangeEngineMode(guid, mode);
packetSender.Send(packet);
}
public CyclopsChangeEngineMode(NitroxId id, CyclopsMotorMode.CyclopsMotorModes mode)
{
Id = id;
Mode = mode;
}
/// <summary>
/// Updates the Cyclops power index. This manages engine efficiency as well as the power cost of using Silent Running, Sonar, and Defense Shield.
/// </summary>
/// <param name="cyclops">The cyclops.</param>
/// <param name="auxUpgradeConsoles">The aux upgrade consoles.</param>
internal static void UpdatePowerSpeedRating(ref SubRoot cyclops, IList <AuxUpgradeConsole> auxUpgradeConsoles)
{
Equipment modules = cyclops.upgradeConsole.modules;
int powerIndex = GetPowerIndex(modules, auxUpgradeConsoles);
int speedIndex = GetSpeedIndex(modules, auxUpgradeConsoles);
// Speed modules can affect power rating too
float nextPowerRating = Mathf.Max(0.01f, EnginePowerRatings[powerIndex] - speedIndex * EnginePowerPenalty);
if (LastKnownPowerRating != nextPowerRating)
{
cyclops.silentRunningPowerCost = SilentRunningPowerCosts[powerIndex];
cyclops.sonarPowerCost = SonarPowerCosts[powerIndex];
cyclops.shieldPowerCost = ShieldPowerCosts[powerIndex];
LastKnownPowerRating = nextPowerRating;
cyclops.SetPrivateField("currPowerRating", nextPowerRating);
// Inform the new power rating just like the original method would.
ErrorMessage.AddMessage(Language.main.GetFormat("PowerRatingNowFormat", nextPowerRating));
}
if (LastKnownSpeedIndex == -1)
{
// Store the original values before we start to change them
// This will only run once
var motorMode = cyclops.GetComponentInChildren <CyclopsMotorMode>();
OriginalSpeeds[0] = motorMode.motorModeSpeeds[0];
OriginalSpeeds[1] = motorMode.motorModeSpeeds[1];
OriginalSpeeds[2] = motorMode.motorModeSpeeds[2];
}
if (speedIndex > SpeedIndexCount)
{
speedIndex = SpeedIndexCount; // Limit to Max
ErrorMessage.AddMessage($"Speed rating already at maximum");
}
if (LastKnownSpeedIndex != speedIndex)
{
float SlowMultiplier = 1f;
float StandardMultiplier = 1f;
float FlankMultiplier = 1f;
// Calculate the speed multiplier with diminishing returns
for (int s = 0; s < speedIndex; s++)
{
SlowMultiplier += SlowSpeedBonuses[s];
StandardMultiplier += StandardSpeedBonuses[s];
FlankMultiplier += FlankSpeedBonuses[s];
}
// These will apply when changing speed modes
var motorMode = cyclops.GetComponentInChildren <CyclopsMotorMode>();
motorMode.motorModeSpeeds[0] = OriginalSpeeds[0] * SlowMultiplier;
motorMode.motorModeSpeeds[1] = OriginalSpeeds[1] * StandardMultiplier;
motorMode.motorModeSpeeds[2] = OriginalSpeeds[2] * FlankMultiplier;
// These will apply immediately
var subControl = cyclops.GetComponentInChildren <SubControl>();
CyclopsMotorMode.CyclopsMotorModes currentMode = subControl.cyclopsMotorMode.cyclopsMotorMode;
subControl.BaseForwardAccel = motorMode.motorModeSpeeds[(int)currentMode];
LastKnownSpeedIndex = speedIndex;
ErrorMessage.AddMessage($"Speed rating is now at {(StandardMultiplier * 100):00}%");
if (speedIndex == SpeedIndexCount)
{
ErrorMessage.AddMessage($"Maximum speed rating reached");
}
}
}
internal static void Postfix(CyclopsMotorMode __instance, CyclopsMotorMode.CyclopsMotorModes newMode)
{
__instance.gameObject.GetComponent <CyclopsOverDrive>().onCyclopsMotorModeChanged.Trigger(newMode);
}
private void OnCyclopsMotorModeChanged(CyclopsMotorMode.CyclopsMotorModes newMotorMode)
{
SetCyclopsOverDrive(Main.Instance.cyclopsSpeedMultiplier);
}
/// <summary>
/// Updates the Cyclops power and speed rating.
/// Power Rating manages engine efficiency as well as the power cost of using Silent Running, Sonar, and Defense Shield.
/// Speed rating manages bonus speed across all motor modes.
/// </summary>
internal void UpdatePowerSpeedRating()
{
int powerIndex = this.UpgradeManager.PowerIndex;
int speedBoosters = this.UpgradeManager.SpeedBoosters;
if (this.LastKnownPowerIndex != powerIndex)
{
this.LastKnownPowerIndex = powerIndex;
this.Cyclops.silentRunningPowerCost = SilentRunningPowerCosts[powerIndex];
this.Cyclops.sonarPowerCost = SonarPowerCosts[powerIndex];
this.Cyclops.shieldPowerCost = ShieldPowerCosts[powerIndex];
}
// Speed modules can affect power rating too
float efficiencyBonus = EnginePowerRatings[powerIndex];
for (int i = 0; i < speedBoosters; i++)
{
efficiencyBonus *= EnginePowerPenalty;
}
int cleanRating = Mathf.CeilToInt(100f * efficiencyBonus);
while (cleanRating % 5 != 0)
{
cleanRating--;
}
float powerRating = cleanRating / 100f;
if (this.LastKnownPowerRating != powerRating)
{
this.LastKnownPowerRating = powerRating;
this.Cyclops.SetPrivateField("currPowerRating", powerRating);
// Inform the new power rating just like the original method would.
ErrorMessage.AddMessage(Language.main.GetFormat("PowerRatingNowFormat", powerRating));
}
if (speedBoosters > MaxSpeedBoosters)
{
ErrorMessage.AddMessage($"Speed rating already at maximum. You have {speedBoosters - MaxSpeedBoosters} too many.");
return; // Exit here
}
if (this.LastKnownSpeedBoosters != speedBoosters)
{
this.LastKnownSpeedBoosters = speedBoosters;
float SlowMultiplier = 1f;
float StandardMultiplier = 1f;
float FlankMultiplier = 1f;
// Calculate the speed multiplier with diminishing returns
while (--speedBoosters > -1)
{
SlowMultiplier += SlowSpeedBonuses[speedBoosters];
StandardMultiplier += StandardSpeedBonuses[speedBoosters];
FlankMultiplier += FlankSpeedBonuses[speedBoosters];
}
// These will apply when changing speed modes
this.MotorMode.motorModeSpeeds[0] = this.OriginalSpeeds[0] * SlowMultiplier;
this.MotorMode.motorModeSpeeds[1] = this.OriginalSpeeds[1] * StandardMultiplier;
this.MotorMode.motorModeSpeeds[2] = this.OriginalSpeeds[2] * FlankMultiplier;
// These will apply immediately
CyclopsMotorMode.CyclopsMotorModes currentMode = this.MotorMode.cyclopsMotorMode;
this.SubControl.BaseForwardAccel = this.MotorMode.motorModeSpeeds[(int)currentMode];
ErrorMessage.AddMessage($"Speed rating is now at +{this.LastKnownSpeedBoosters} : {StandardMultiplier * 100:00}%");
if (this.LastKnownSpeedBoosters == MaxSpeedBoosters)
{
ErrorMessage.AddMessage($"Maximum speed rating reached");
}
}
}
public CyclopsChangeEngineMode(String playerId, String guid, CyclopsMotorMode.CyclopsMotorModes mode) : base(playerId)
{
this.Guid = guid;
this.Mode = mode;
}
