public static void Prefix(MicroHID __instance)
{
if (!timers.ContainsKey(__instance))
{
timers.Add(__instance, 0f);
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && __instance.NetworkCurrentHidState == MicroHID.MicroHidState.Idle)
{
timers[__instance] += Time.deltaTime;
if (timers[__instance] >= MicroHIDPlugin.instance.Config.mhid_charge_interval)
{
timers[__instance] = 0f;
__instance.ChangeEnergy(__instance.GetEnergy() + MicroHIDPlugin.instance.Config.mhid_charge_rate);
__instance.Energy = __instance.GetEnergy();
__instance.NetworkEnergy = __instance.GetEnergy();
}
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && (__instance.NetworkCurrentHidState == MicroHID.MicroHidState.Discharge || __instance.NetworkCurrentHidState == MicroHID.MicroHidState.Spinning))
{
timers[__instance] += Time.deltaTime;
if (timers[__instance] >= MicroHIDPlugin.instance.Config.mhid_charge_use_interval)
{
timers[__instance] = 0f;
__instance.ChangeEnergy(__instance.GetEnergy() + MicroHIDPlugin.instance.Config.mhid_charge_use_rate);
__instance.Energy = __instance.GetEnergy();
__instance.NetworkEnergy = __instance.GetEnergy();
}
}
}
public static IEnumerator <float> BigHitmark(MicroHID microHID)
{
yield return(Timing.WaitForSeconds(0.1f));
microHID.TargetSendHitmarker(false);
yield break;
}
public static void Prefix(MicroHID __instance)
{
if (MicroHIDPlugin.instance.Config.mhid_damage_per_second == -1)
{
return;
}
__instance.damagePerSecond = MicroHIDPlugin.instance.Config.mhid_damage_per_second;
}
/// <summary>
/// Initializes a new instance of the <see cref="ChangingMicroHIDStateEventArgs"/> class.
/// </summary>
/// <param name="player"><inheritdoc cref="Player"/></param>
/// <param name="microHID"><inheritdoc cref="MicroHID"/></param>
/// <param name="oldState"><inheritdoc cref="OldState"/></param>
/// <param name="newState"><inheritdoc cref="NewState"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public ChangingMicroHIDStateEventArgs(Player player, MicroHID microHID, MicroHID.MicroHidState oldState, MicroHID.MicroHidState newState, bool isAllowed = true)
{
Player = player;
MicroHID = microHID;
OldState = oldState;
NewState = newState;
IsAllowed = isAllowed;
}
/// <summary>
/// Initializes a new instance of the <see cref="UsingMicroHIDEnergyEventArgs"/> class.
/// </summary>
/// <param name="player"><inheritdoc cref="Player"/></param>
/// <param name="microHID"><inheritdoc cref="MicroHID"/></param>
/// <param name="currentState"><inheritdoc cref="CurrentState"/></param>
/// <param name="oldValue"><inheritdoc cref="OldValue"/></param>
/// <param name="newValue"><inheritdoc cref="NewValue"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public UsingMicroHIDEnergyEventArgs(Player player, MicroHID microHID, MicroHID.MicroHidState currentState, float oldValue, float newValue, bool isAllowed = true)
{
Player = player;
MicroHID = microHID;
CurrentState = currentState;
OldValue = oldValue;
NewValue = newValue;
IsAllowed = isAllowed;
}
public static bool Prefix(MicroHID __instance)
{
if (__instance.refHub.TryGetComponent(out InfiniteAmmoComponent infAmmo) && __instance.refHub.inventory.curItem == ItemType.MicroHID)
{
__instance.ChangeEnergy(1);
__instance.NetworkEnergy = 1;
}
return(true);
}
private static void Prefix(MicroHID __instance)
{
var ply = Player.Get(__instance.gameObject);
if (SameThings.Instance.Config.InfiniteMicroAmmo && ply.CurrentItem.id == ItemType.MicroHID)
{
__instance.ChangeEnergy(1);
__instance.NetworkEnergy = 1;
}
}
private static bool Prefix(MicroHID __instance)
{
if (!__instance.refHub.TryGetComponent(out InfiniteAmmoComponent infAmmo) ||
__instance.refHub.inventory.curItem != ItemType.MicroHID)
{
return(true);
}
__instance.ChangeEnergy(1);
__instance.NetworkEnergy = 1;
return(true);
}
public static void Prefix(MicroHID __instance)
{
__instance.chargeupTime = MicroHIDPlugin.instance.Config.chargeupTime;
__instance.chargedownTime = MicroHIDPlugin.instance.Config.chargedownTime;
if (MicroHIDPlugin.instance.Config.disablePreDischarge)
{
__instance.soundEffectPause = 1.5f;
}
if (!timers.ContainsKey(__instance))
{
timers.Add(__instance, 0f);
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && __instance.NetworkCurrentHidState == MicroHID.MicroHidState.Idle)
{
timers[__instance] += Time.deltaTime;
if (timers[__instance] >= MicroHIDPlugin.instance.Config.mhid_charge_interval)
{
timers[__instance] = 0f;
__instance.ChangeEnergy(__instance.GetEnergy() + MicroHIDPlugin.instance.Config.mhid_charge_rate);
__instance.NetworkEnergy = __instance.GetEnergy();
}
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && __instance.NetworkCurrentHidState == MicroHID.MicroHidState.Discharge)
{
timers[__instance] += Time.deltaTime;
if (timers[__instance] >= MicroHIDPlugin.instance.Config.mhid_charge_use_interval)
{
timers[__instance] = 0f;
__instance.ChangeEnergy(__instance.GetEnergy() + MicroHIDPlugin.instance.Config.mhid_charge_use_rate);
__instance.NetworkEnergy = __instance.GetEnergy();
}
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && __instance.NetworkCurrentHidState == MicroHID.MicroHidState.Spinning)
{
timers[__instance] += Time.deltaTime;
if (timers[__instance] >= MicroHIDPlugin.instance.Config.mhid_charge_use_idle_interval)
{
timers[__instance] = 0f;
__instance.ChangeEnergy(__instance.GetEnergy() + MicroHIDPlugin.instance.Config.mhid_charge_use_idle_rate);
__instance.NetworkEnergy = __instance.GetEnergy();
}
}
}
private static bool Prefix(MicroHID __instance, ref float value)
{
// NetworkEnergy is set each frame, so this is to prevent calling the method each frame.
if (__instance.NetworkEnergy == value)
{
return(true);
}
var ev = new UsingMicroHIDEnergyEventArgs(Player.Get(__instance.gameObject), __instance, __instance.CurrentHidState, __instance.Energy, value);
Handlers.Player.OnUsingMicroHIDEnergy(ev);
if (!ev.IsAllowed)
{
return(false);
}
value = ev.NewValue;
return(true);
}
private static bool Prefix(MicroHID __instance, ref MicroHID.MicroHidState value)
{
// NetworkCurrentHid state is set each frame, so this is to prevent calling the method each frame.
if (__instance.CurrentHidState == value)
{
return(true);
}
var ev = new ChangingMicroHIDStateEventArgs(Player.Get(__instance.gameObject), __instance, __instance.CurrentHidState, value);
Handlers.Player.OnChangingMicroHIDState(ev);
if (!ev.IsAllowed)
{
return(false);
}
value = ev.NewState;
return(true);
}
private static bool Prefix(MicroHID __instance)
{
try
{
if (!NetworkServer.active)
{
return(false);
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID && __instance.GetEnergy() != __instance.Energy)
{
__instance.ChangeEnergy(__instance.Energy);
}
else
{
foreach (var item in __instance.refHub.inventory.items)
{
if (item.id == ItemType.MicroHID)
{
__instance.NetworkEnergy = item.durability;
}
}
}
if (__instance.keyAntiSpamCooldown > 0f)
{
__instance.keyAntiSpamCooldown -= Time.deltaTime;
}
if (__instance.refHub.inventory.curItem == ItemType.MicroHID || __instance.chargeup > 0f)
{
if (__instance.CurrentHidState != MicroHID.MicroHidState.Idle)
{
__instance.refHub.weaponManager.scp268.ServerDisable();
__instance._visionController.MakeNoise(__instance.CurrentHidState == MicroHID.MicroHidState.Discharge ? 20 : 75);
}
MicroHID.MicroHidState state = MicroHID.MicroHidState.Idle;
if (__instance.refHub.inventory.curItem == ItemType.MicroHID)
{
if (__instance.Energy > 0f && __instance.chargeup >= 1f && __instance.SyncKeyCode == 2)
{
state = MicroHID.MicroHidState.Discharge;
}
else if (__instance.Energy > 0f && __instance.chargeup < 1f && __instance.SyncKeyCode != 0 && __instance.CurrentHidState != MicroHID.MicroHidState.RampDown)
{
state = MicroHID.MicroHidState.RampUp;
}
else if (__instance.chargeup > 0f && (__instance.SyncKeyCode == 0 || __instance.Energy <= 0f || __instance.CurrentHidState == MicroHID.MicroHidState.RampDown))
{
state = MicroHID.MicroHidState.RampDown;
}
else if (__instance.chargeup <= 0f && (__instance.SyncKeyCode == 0 || __instance.Energy <= 0f || __instance.CurrentHidState == MicroHID.MicroHidState.RampDown))
{
state = MicroHID.MicroHidState.Idle;
}
else if (__instance.chargeup >= 1f)
{
state = MicroHID.MicroHidState.Spinning;
}
}
else
{
state = MicroHID.MicroHidState.RampDown;
}
var player = __instance.refHub.GetPlayer();
var item = player.ItemInHand;
SynapseController.Server.Events.Player.InvokeMicroUse(player, item, ref state);
//ItemUseEvent Invoke
if (state != MicroHID.MicroHidState.Idle)
{
var itemstate = ItemState.Initiating;
switch (state)
{
case MicroHID.MicroHidState.Spinning:
case MicroHID.MicroHidState.Discharge:
itemstate = ItemState.Finalizing;
break;
case MicroHID.MicroHidState.RampUp:
itemstate = ItemState.Initiating;
break;
case MicroHID.MicroHidState.RampDown:
itemstate = ItemState.Stopping;
break;
}
var allow = true;
SynapseController.Server.Events.Player.InvokePlayerItemUseEvent(player, item, itemstate, ref allow);
if (!allow)
{
state = MicroHID.MicroHidState.Idle;
}
}
switch (state)
{
case MicroHID.MicroHidState.Discharge:
if (__instance.soundEffectPause >= 1f)
{
__instance.NetworkEnergy = Mathf.Clamp01(__instance.Energy - Time.deltaTime * __instance.dischargeEnergyLoss);
__instance.DealDamage();
}
else
{
__instance.NetworkEnergy = Mathf.Clamp01(__instance.Energy - Time.deltaTime * __instance.speedBasedEnergyLoss.Evaluate(1f));
}
break;
case MicroHID.MicroHidState.RampUp:
__instance.chargeup = Mathf.Clamp01(__instance.chargeup + Time.deltaTime / __instance.chargeupTime);
__instance.NetworkEnergy = Mathf.Clamp01(__instance.Energy - Time.deltaTime * __instance.speedBasedEnergyLoss.Evaluate(__instance.chargeup));
break;
case MicroHID.MicroHidState.RampDown:
__instance.chargeup = Mathf.Clamp01(__instance.chargeup - Time.deltaTime / __instance.chargedownTime);
break;
case MicroHID.MicroHidState.Spinning:
__instance.NetworkEnergy = Mathf.Clamp01(__instance.Energy - Time.deltaTime * __instance.speedBasedEnergyLoss.Evaluate(__instance.chargeup));
break;
//Idle does nothing
}
__instance.NetworkCurrentHidState = state;
}
if (__instance.Energy <= 0.05f)
{
__instance.NetworkEnergy = 0f;
}
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerUseMicro failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
public static bool Prefix(MicroHID __instance)
{
if (!NetworkServer.active)
{
return(false);
}
var baseObj = (NetworkBehaviour)__instance;
__instance.damagePause += Time.deltaTime;
if (__instance.damagePause < 0.2f)
{
return(false);
}
__instance.damagePause -= 0.2f;
global::ReferenceHub referenceHub = __instance.refHub;
__instance.beamStart.localRotation = Quaternion.Euler(referenceHub.playerMovementSync.Rotations.x, 0f, 0f);
foreach (GameObject gameObject in global::PlayerManager.players)
{
if (gameObject != null && gameObject != baseObj.gameObject && Vector3.Distance(baseObj.transform.position, gameObject.transform.position) <= __instance.beamLength)
{
Vector3 normalized = (__instance.beamStart.position - gameObject.transform.position).normalized;
RaycastHit raycastHit;
if (Vector3.Dot(__instance.beamStart.forward, normalized) < -0.95f && Physics.Raycast(new Ray(__instance.beamStart.position, -normalized), out raycastHit, __instance.beamLength, __instance.beamMask))
{
if (raycastHit.collider != __instance.lastVictim)
{
__instance.lastVictim = raycastHit.collider;
__instance.lastVictimRefs = raycastHit.collider.GetComponentInParent <global::ReferenceHub>();
}
global::ReferenceHub referenceHub2 = __instance.lastVictimRefs;
if (referenceHub2 != null && referenceHub2.gameObject != baseObj.gameObject && referenceHub.weaponManager.GetShootPermission(referenceHub2.characterClassManager, false))
{
int damage = 0;
if (MicroHIDPlugin.instance.Config.mhid_damage_per_hit == -1)
{
float num = UnityEngine.Random.Range(-__instance.maxDamageVariationPercent, __instance.maxDamageVariationPercent) / 100f * __instance.damagePerSecond;
damage = Mathf.RoundToInt((__instance.damagePerSecond + num) * 0.2f);
}
else
{
damage = MicroHIDPlugin.instance.Config.mhid_damage_per_hit;
}
bool isAchievement = referenceHub2.characterClassManager.CurRole.team == global::Team.SCP;
if (!referenceHub.playerStats.HurtPlayer(new global::PlayerStats.HitInfo((float)damage, referenceHub.LoggedNameFromRefHub(), global::DamageTypes.MicroHid, referenceHub.queryProcessor.PlayerId), gameObject, false))
{
isAchievement = false;
}
__instance.TargetSendHitmarker(isAchievement);
}
}
}
}
RaycastHit raycastHit2;
if (Physics.Raycast(new Ray(__instance.beamStart.position, __instance.beamStart.forward), out raycastHit2, __instance.beamLength, __instance.beamMask))
{
global::BreakableWindow componentInParent = raycastHit2.collider.GetComponentInParent <global::BreakableWindow>();
if (componentInParent != null && !componentInParent.isBroken)
{
float num3 = UnityEngine.Random.Range(-__instance.maxDamageVariationPercent, __instance.maxDamageVariationPercent) / 100f * __instance.damagePerSecond;
int num4 = Mathf.RoundToInt((__instance.damagePerSecond + num3) * 0.2f);
componentInParent.ServerDamageWindow((float)num4);
}
}
return(false);
}
