public PowerRelay UpdateRelay(PowerRelay gdPowerRelay)
{
var result = this.Relays.Update(gdPowerRelay);
this.SaveChanges();
return(result.Entity);
}
public static void Postfix(PowerRelay __instance, ref bool __result, ref float amount, ref float modified)
{
if (!__result)
{
IPowerInterface powerInterface = __instance.inboundPowerSources.Find((x) => x is BaseInboundRelay || x is OtherConnectionRelay);
if (powerInterface != null)
{
PowerControl powerControl = null;
switch (powerInterface)
{
case BaseInboundRelay baseConnectionRelay:
powerControl = baseConnectionRelay.gameObject.GetComponent <PowerControl>();
break;
case OtherConnectionRelay otherConnectionRelay:
powerControl = otherConnectionRelay.gameObject.GetComponent <PowerControl>();
break;
}
PowerRelay endRelay = powerControl.powerRelay.GetEndpoint();
if (endRelay.GetMaxPower() > powerInterface.GetMaxPower())
{
__result = endRelay.ModifyPowerFromInbound(amount, out float newModified);
modified += newModified;
}
}
}
}
public PowerRelay AddRelay(PowerRelay gdRelay)
{
var result = this.Relays.Add(gdRelay);
this.SaveChanges();
return(result.Entity);
}
internal void FastUpdate(CyclopsHelmHUDManager cyclopsHelmHUD)
{
if (!powerIconsInitialized)
{
AddStatusIcons(cyclopsHelmHUD);
}
else
{
UpdateStatusIcons();
}
PowerRelay powerRelay = Cyclops.powerRelay;
switch (settings.EnergyDisplay)
{
case HelmEnergyDisplay.PowerCellAmount:
cyclopsHelmHUD.powerText.text = NumberFormatter.FormatValue(powerRelay.GetPower());
break;
case HelmEnergyDisplay.PercentageOverPowerCells:
float percentOver = (powerRelay.GetPower() + this.ChargeManager.GetTotalReservePower()) / powerRelay.GetMaxPower();
cyclopsHelmHUD.powerText.text = $"{NumberFormatter.FormatValue(percentOver * 100f)}%";
break;
case HelmEnergyDisplay.CombinedAmount:
cyclopsHelmHUD.powerText.text = NumberFormatter.FormatValue(powerRelay.GetPower() + this.ChargeManager.GetTotalReservePower());
break;
default: // HelmEnergyDisplay.PowerCellPercentage:
float percent = powerRelay.GetPower() / powerRelay.GetMaxPower();
cyclopsHelmHUD.powerText.text = $"{NumberFormatter.FormatValue(percent * 100f)}%";
break;
}
}
public static bool Prefix(TechLight __instance, ref PowerRelay __result, GameObject fromObject)
{
PowerRelay result = null;
float num = float.MaxValue;
for (int i = 0; i < PowerRelay.relayList.Count; i++)
{
PowerRelay powerRelay = PowerRelay.relayList[i];
if (powerRelay is OtherConnectionRelay && powerRelay.gameObject.activeInHierarchy && powerRelay.enabled && !powerRelay.dontConnectToRelays && !(Builder.GetGhostModel() == powerRelay.gameObject))
{
float magnitude = (powerRelay.GetConnectPoint(fromObject.transform.position) - fromObject.transform.position).magnitude;
if (magnitude <= TechLight.connectionDistance && magnitude < num)
{
num = magnitude;
result = powerRelay;
}
}
}
if (result != null)
{
__result = result;
return(false);
}
return(true);
}
public void Activate()
{
spin = gameObject.FindChild("Blade Parent").EnsureComponent <TurbineSpin>();
powerSource = gameObject.EnsureComponent <PowerSource>();
powerSource.maxPower = QPatch.config.MaxPower;
relay = gameObject.EnsureComponent <PowerRelay>();
relay.internalPowerSource = powerSource;
relay.dontConnectToRelays = false;
relay.maxOutboundDistance = 50;
//relay.powerSystemPreviewPrefab = Resources.Load<GameObject>("Base/Ghosts/PowerSystemPreview.prefab");
if (relayPrefab != null)
{
PowerFX yourPowerFX = gameObject.AddComponent <PowerFX>();
yourPowerFX.vfxPrefab = relayPrefab.powerFX.vfxPrefab;
yourPowerFX.attachPoint = gameObject.transform;
relay.powerFX = yourPowerFX;
}
#if SUBNAUTICA
Resources.UnloadAsset(powerRelay);
#endif
relay.UpdateConnection();
if (QPatch.config.TurbineMakesNoise)
{
SetupAudio();
}
Logger.Log(Logger.Level.Debug, $"WindTurbine.Activate: end");
}
public void OnHandHover(GUIHand hand)
{
if (!hand.IsTool())
{
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendLine($"Max Power {(int)powerRelay.GetEndpoint().GetMaxPower()}, Current Power: {(int)powerRelay.GetEndpoint().GetPower()}");
stringBuilder.Append($"MainConnections: {!powerRelay.dontConnectToRelays}, ");
stringBuilder.Append($"Other Connections: {!otherConnectionsDisabled}");
StringBuilder stringBuilder2 = new StringBuilder();
stringBuilder2.AppendLine("LeftHand: Full Enable/Disable");
stringBuilder2.AppendLine("Deconstruct Key (Q): Other Connections (Green)");
#if SN1
HandReticle.main.SetInteractText(stringBuilder.ToString(), stringBuilder2.ToString(), false, false, HandReticle.Hand.None);
#elif BZ
HandReticle.main.SetText(HandReticle.TextType.Hand, stringBuilder.ToString(), false);
HandReticle.main.SetText(HandReticle.TextType.HandSubscript, stringBuilder2.ToString(), false);
#endif
if (GameInput.GetButtonDown(GameInput.Button.Deconstruct) && !powerRelay.dontConnectToRelays)
{
otherConnectionsDisabled = !otherConnectionsDisabled;
otherConnectionRelays.ForEach((x) => {
x.dontConnectToRelays = otherConnectionsDisabled;
x.DisconnectFromRelay();
});
PowerRelay.MarkRelaySystemDirty();
}
}
}
public void Start()
{
powerRelay = gameObject.GetComponent <PowerRelay>();
powerRelay.maxOutboundDistance = Main.config.BlueBeamRange;
constructable = gameObject.GetComponent <Constructable>();
vehicle = gameObject.GetComponentInParent <Vehicle>();
subRoot = gameObject.GetComponentInParent <SubRoot>();
if (subRoot != null)
{
if (!subRoot.name.Contains("Cyclops"))
{
baseConnectionsDisabled = false;
}
}
#if BZ
truckSegment = gameObject.GetComponentInParent <SeaTruckSegment>();
#endif
if ((vehicle != null || subRoot != null
#if BZ
|| truckSegment != null
#endif
) && gameObject.TryGetComponent(out Rigidbody rigidbody))
{
GameObject.Destroy(rigidbody);
}
}
public void OnHandClick(GUIHand hand)
{
if (!hand.IsTool())
{
powerRelay.dontConnectToRelays = !powerRelay.dontConnectToRelays;
if (powerRelay.dontConnectToRelays)
{
baseInboundRelay.dontConnectToRelays = powerRelay.dontConnectToRelays;
baseInboundRelay.DisconnectFromRelay();
otherConnectionRelays.ForEach((x) => {
x.dontConnectToRelays = powerRelay.dontConnectToRelays;
x.DisconnectFromRelay();
});
}
else
{
baseInboundRelay.dontConnectToRelays = baseConnectionsDisabled;
baseInboundRelay.DisconnectFromRelay();
otherConnectionRelays.ForEach((x) => {
x.dontConnectToRelays = otherConnectionsDisabled;
x.DisconnectFromRelay();
});
}
powerRelay.DisconnectFromRelay();
PowerRelay.MarkRelaySystemDirty();
}
}
public static bool Prefix(ref PowerRelay __result, GameObject fromObject)
{
PowerRelay result = null;
var num = float.MaxValue;
foreach (var powerRelay in PowerRelay.relayList)
{
if (powerRelay is not OtherConnectionRelay || !powerRelay.gameObject.activeInHierarchy ||
!powerRelay.enabled || powerRelay.dontConnectToRelays ||
Builder.GetGhostModel() == powerRelay.gameObject)
{
continue;
}
var position = fromObject.transform.position;
var magnitude = (powerRelay.GetConnectPoint(position) - position).magnitude;
if (!(magnitude <= TechLight.connectionDistance) || !(magnitude < num))
{
continue;
}
num = magnitude;
result = powerRelay;
}
if (result == null)
{
return(true);
}
__result = result;
return(false);
}
private void UpdatePowerRelay()
{
try
{
var relay = PowerSource.FindRelay(transform);
if (relay != null && relay != _powerRelay)
{
if (_powerRelay != null)
{
_powerRelay.RemoveInboundPower(this);
}
_powerRelay = relay;
_powerRelay.AddInboundPower(this);
CancelInvoke("UpdatePowerRelay");
}
else
{
_powerRelay = null;
}
if (_powerRelay != null)
{
_powerRelay.RemoveInboundPower(this);
_powerRelay.AddInboundPower(this);
CancelInvoke("UpdatePowerRelay");
}
}
catch (Exception e)
{
Log.Error(e.Message);
}
}
private static void Postfix(PowerRelay __instance)
{
try
{
if (!Main.config.doSort)
{
return;
}
var info = __instance.inboundPowerSources;
var test = new List <IPowerInterface>(info);
test.Sort((i, i2) =>
{
var p = (UnityEngine.MonoBehaviour)i;
var p2 = (UnityEngine.MonoBehaviour)i2;
var pn = GetOrderNumber(p.gameObject.name);
var p2n = GetOrderNumber(p2.gameObject.name);
return(Math.Sign(pn - p2n));
});
__instance.inboundPowerSources = test;
Main.config.doSort = false;
}
catch (Exception e)
{
Logger.Log(Logger.Level.Error, ex: e);
}
}
public static void Postfix(PowerRelay __instance, ref float __result)
{
IPowerInterface powerInterface = __instance.inboundPowerSources.Find((x) => x is BaseInboundRelay || x is OtherConnectionRelay);
if (powerInterface != null)
{
PowerControl powerControl = null;
switch (powerInterface)
{
case BaseInboundRelay baseConnectionRelay:
powerControl = baseConnectionRelay.gameObject.GetComponent <PowerControl>();
break;
case OtherConnectionRelay otherConnectionRelay:
powerControl = otherConnectionRelay.gameObject.GetComponent <PowerControl>();
break;
}
PowerRelay endRelay = powerControl.powerRelay.GetEndpoint();
float endPower = endRelay.GetMaxPower();
float powerHere = powerInterface.GetMaxPower();
if (endPower > powerHere)
{
__result += endPower - powerHere;
}
}
}
public static void Postfix(PowerRelay __instance, ref bool __result, ref float amount, ref float modified)
{
if (__result)
{
return;
}
var powerInterface = __instance.inboundPowerSources.Find((x) => x is BaseInboundRelay or OtherConnectionRelay);
var powerControl = powerInterface switch
{
BaseInboundRelay baseConnectionRelay => baseConnectionRelay.gameObject.GetComponent <PowerControl>(),
OtherConnectionRelay otherConnectionRelay => otherConnectionRelay.gameObject.GetComponent <PowerControl>(),
_ => null
};
if (powerControl is null)
{
return;
}
var endRelay = powerControl.Relay.GetEndpoint();
if (!(endRelay.GetMaxPower() > powerInterface.GetMaxPower()))
{
return;
}
__result = endRelay.ModifyPowerFromInbound(amount, out var newModified);
modified += newModified;
}
}
public void OnEnable()
{
if (constructable?.constructed ?? false)
{
PowerRelay.MarkRelaySystemDirty();
}
}
private void AccumulatePowerSources(PowerRelay power)
{
List <IPowerInterface> inboundPowerSources = GetInboundPowerSources(power);
foreach (IPowerInterface iSource in inboundPowerSources)
{
if (iSource == null)
{
continue;
}
PowerSource source = TryGetPowerSource(iSource);
PowerRelay relay = TryGetPowerRelay(iSource);
BatterySource battery = TryGetBatterySource(iSource);
if (source != null)
{
AddPowerSourceEntry(source);
continue;
}
else if (relay != null)
{
AccumulatePowerSources(relay);
continue;
}
else if (battery != null)
{
AddGenericPowerEntry(battery);
continue;
}
}
}
public static void Postfix(PowerRelay __instance, ref bool __result)
{
if (__instance.gameObject.TryGetComponent <PowerControl>(out PowerControl powerControl))
{
__result = powerControl.constructable != null && !powerControl.constructable.constructed;
}
}
private IEnumerator UpdatePowerRelay()
{
QuickLogger.Debug("In UpdatePowerRelay found at last!");
var i = 1;
while (_connectedRelay == null)
{
QuickLogger.Debug($"Checking For Relay... Attempt {i}");
PowerRelay relay = PowerSource.FindRelay(this.transform);
if (relay != null && relay != _connectedRelay)
{
_connectedRelay = relay;
QuickLogger.Debug("PowerRelay found at last!");
}
else
{
_connectedRelay = null;
}
i++;
yield return(new WaitForSeconds(0.5f));
}
}
private string GetPowerStatusText(PowerRelay power)
{
string statusColor = GetPowerStatusColor(power.GetPowerStatus());
string statusText = GetPowerStatusText(power.GetPowerStatus());
return(string.Format(" <color={0}>{1}</color>", statusColor, statusText));
}
public static void Postfix(PowerRelay __instance, ref float __result)
{
var powerInterface = __instance.inboundPowerSources.Find((x) => x is BaseInboundRelay or OtherConnectionRelay);
var powerControl = powerInterface switch
{
BaseInboundRelay baseConnectionRelay => baseConnectionRelay.gameObject.GetComponent <PowerControl>(),
OtherConnectionRelay otherConnectionRelay => otherConnectionRelay.gameObject.GetComponent <PowerControl>(),
_ => null
};
if (powerControl is null)
{
return;
}
var endRelay = powerControl.Relay.GetEndpoint();
var endPower = endRelay.GetMaxPower();
var powerHere = powerInterface.GetMaxPower();
if (endPower > powerHere)
{
__result += endPower - powerHere;
}
}
}
// Token: 0x06002BB7 RID: 11191 RVA: 0x00104FDC File Offset: 0x001031DC
private static void CreatePowerPreview(TechType constructableTechType, GameObject ghostModel)
{
GameObject gameObject = null;
string poweredPrefabName = CraftData.GetPoweredPrefabName(constructableTechType);
if (poweredPrefabName != string.Empty)
{
gameObject = PrefabDatabase.GetPrefabForFilename(poweredPrefabName);
}
if (gameObject != null)
{
PowerRelay component = gameObject.GetComponent <PowerRelay>();
if (component.powerFX != null && component.powerFX.attachPoint != null)
{
PowerFX powerFX = ghostModel.AddComponent <PowerFX>();
powerFX.attachPoint = new GameObject
{
transform =
{
parent = ghostModel.transform,
localPosition = component.powerFX.attachPoint.localPosition
}
}.transform;
}
PowerRelay powerRelay = ghostModel.AddComponent <PowerRelay>();
powerRelay.maxOutboundDistance = component.maxOutboundDistance;
powerRelay.dontConnectToRelays = component.dontConnectToRelays;
if (component.internalPowerSource != null)
{
powerRelay.internalPowerSource = ghostModel.AddComponent <PowerSource>();
}
}
}
public void Activate()
{
spin = gameObject.FindChild("Blade Parent").AddComponent <TurbineSpin>();
powerSource = gameObject.AddComponent <PowerSource>();
powerSource.maxPower = QPatch.config.MaxPower;
relay = gameObject.AddComponent <PowerRelay>();
relay.internalPowerSource = powerSource;
relay.dontConnectToRelays = false;
relay.maxOutboundDistance = 50;
PowerFX yourPowerFX = gameObject.AddComponent <PowerFX>();
PowerRelay powerRelay = CraftData.GetPrefabForTechType(TechType.SolarPanel).GetComponent <PowerRelay>();
yourPowerFX.vfxPrefab = powerRelay.powerFX.vfxPrefab;
yourPowerFX.attachPoint = gameObject.transform;
relay.powerFX = yourPowerFX;
Resources.UnloadAsset(powerRelay);
relay.UpdateConnection();
if (QPatch.config.TurbineMakesNoise)
{
SetupAudio();
}
}
public override GameObject GetGameObject()
{
// Instantiate CyclopsFabricator object
GameObject prefab = GameObject.Instantiate(Resources.Load <GameObject>("Submarine/Build/Fabricator"));
// Update prefab name
prefab.name = NameID;
// Add prefab ID
var prefabId = prefab.AddComponent <PrefabIdentifier>();
prefabId.ClassId = NameID;
prefabId.name = FriendlyName;
// Add tech tag
var techTag = prefab.AddComponent <TechTag>();
techTag.type = this.TechType;
// Update sky applier
var skyApplier = prefab.GetComponent <SkyApplier>();
skyApplier.renderers = prefab.GetComponentsInChildren <Renderer>();
skyApplier.anchorSky = Skies.Auto;
// Associate custom craft tree to the fabricator
var fabricator = prefab.GetComponent <Fabricator>();
fabricator.craftTree = TreeTypeID;
fabricator.handOverText = HandOverText;
// Associate power relay
var ghost = fabricator.GetComponent <GhostCrafter>();
var powerRelay = new PowerRelay();
fabricator.SetPrivateField("powerRelay", powerRelay, BindingFlags.FlattenHierarchy);
// Add constructable
var constructible = prefab.AddComponent <Constructable>();
constructible.allowedInBase = true;
constructible.allowedInSub = true;
constructible.allowedOutside = false;
constructible.allowedOnCeiling = false;
constructible.allowedOnGround = false;
constructible.allowedOnWall = true;
constructible.allowedOnConstructables = false;
constructible.controlModelState = true;
constructible.rotationEnabled = false;
constructible.techType = this.TechType; // This was necessary to correctly associate the recipe at building time
// Set the custom texture
var customTexture = ImageUtils.LoadTextureFromFile(@"./QMods/MoreCyclopsUpgrades/Assets/NuclearFabricatorT.png");
var skinnedMeshRenderer = prefab.GetComponentInChildren <SkinnedMeshRenderer>();
skinnedMeshRenderer.material.mainTexture = customTexture;
return(prefab);
}
public async Task <PowerRelay> AddRelayAsync(PowerRelay gdRelay)
{
var result = await this.Relays.AddAsync(gdRelay);
await this.SaveChangesAsync();
return(result.Entity);
}
public async Task <PowerRelay> UpdateRelayAsync(PowerRelay gdPowerRelay)
{
var result = this.Relays.Update(gdPowerRelay);
await this.SaveChangesAsync();
return(result.Entity);
}
protected override float GetPowerConsumedPerMinute()
{
PowerRelay relay = filter.gameObject.GetComponentInParent <PowerRelay>();
bool powered = relay.GetPower() >= 0.85f;
bool working = filter.timeRemainingWater > 0f || filter.timeRemainingSalt > 0f;
float powerPerSecond = DayNightCycle.main.dayNightSpeed * 0.85f;
return((working && powered) ? powerPerSecond * 60 : 0);
}
private List <IPowerInterface> GetInboundPowerSources(PowerRelay power)
{
if (PowerSource_inboundPowerSources == null)
{
PowerSource_inboundPowerSources = typeof(PowerRelay).GetField("inboundPowerSources", BindingFlags.Instance | BindingFlags.NonPublic);
}
return((List <IPowerInterface>)PowerSource_inboundPowerSources.GetValue(power));
}
public void Awake()
{
Instance = this;
thisVehicle = Instance.GetComponent <SeaTruckUpgrades>();
energyMixin = thisVehicle.relay;
playerMain = Player.main;
var builderPrefab = Resources.Load <GameObject>("WorldEntities/Tools/Builder").GetComponent <BuilderTool>();
completeSound = Instantiate(builderPrefab.completeSound, gameObject.transform);
}
private string GetCurrentAndMaxPowerTextVerbose(PowerRelay power)
{
float totalProduction = Mathf.RoundToInt(GetTotalProductionPerMinute());
string name = Mod.FormatName(power.name.Replace("Base", "Habitat").Replace("Module", "").Replace("-MainPrefab", ""));
string firstLine = string.Format("{0} <color={2}><b>+{1}</b></color>", name, totalProduction, totalProduction > 0 ? "lime" : "silver");
return(string.Format("{0}\n<b><color=lightblue>Power Sources</color></b>",
firstLine
));
}
public static void Postfix(ref PowerRelay __result)
{
if (__result is null)
{
return;
}
var isCyclops = __result.gameObject.name.Contains("Cyclops");
if (__result is not BasePowerRelay && !isCyclops)
{
return;
}
var powerInterface = __result.inboundPowerSources.Where((x) => x is BaseInboundRelay).FirstOrFallback(null);
PowerControl powerControl;
if (powerInterface is null)
{
var entityRoot = UWE.Utils.GetEntityRoot(__result.gameObject) ?? __result.gameObject;
powerControl = entityRoot.GetComponentInChildren <PowerControl>();
if (powerControl?.Relay is null || powerControl.Relay.dontConnectToRelays)
{
return;
}
if (isCyclops)
{
__result.AddInboundPower(powerControl.Relay);
}
__result = powerControl.Relay;
return;
}
if (powerInterface is not BaseInboundRelay baseInboundRelay || !baseInboundRelay.gameObject.TryGetComponent(out powerControl))
{
return;
}
if (powerControl.Relay == null || powerControl.Relay.dontConnectToRelays)
{
return;
}
if (isCyclops)
{
__result.AddInboundPower(powerControl.Relay);
}
__result = powerControl.Relay;
}
