public static void Prefix(Assets._Scripts.Dissonance.DissonanceUserSetup __instance, bool value)
{
if (!Configs.scp_can_talk_to_humans)
{
return;
}
CharacterClassManager ccm = __instance.gameObject.GetComponent <CharacterClassManager>();
if (ccm.IsAnyScp() && ccm.CurClass != RoleType.Scp079)
{
__instance.MimicAs939 = value;
}
return;
}
public static bool Prefix(Scp096 __instance)
{
if (__instance._flash.IsEnabled)
{
return(false);
}
Vector3 vector = __instance.Hub.transform.TransformPoint(Scp096._headOffset);
foreach (KeyValuePair <GameObject, ReferenceHub> keyValuePair in ReferenceHub.GetAllHubs())
{
ReferenceHub value = keyValuePair.Value;
CharacterClassManager characterClassManager = value.characterClassManager;
if (characterClassManager.CurClass != RoleType.Spectator &&
!value.isDedicatedServer &&
!(value == __instance.Hub) &&
!characterClassManager.IsAnyScp() &&
Vector3.Dot((value.PlayerCameraReference.position - vector).normalized, __instance.Hub.PlayerCameraReference.forward) >= 0.1f)
{
VisionInformation visionInformation = VisionInformation.GetVisionInformation(value, vector, -0.1f, 60f, true, true, __instance.Hub.localCurrentRoomEffects, 0);
bool toEnrage = visionInformation.IsLooking;
//Add touch check
if (!toEnrage && SanyaPlugin.Instance.Config.Scp096TouchEnrageDistance > visionInformation.Distance)
{
toEnrage = !Physics.Linecast(value.PlayerCameraReference.position, vector, VisionInformation.VisionLayerMask);
}
if (toEnrage)
{
float delay = visionInformation.LookingAmount / 0.25f * (visionInformation.Distance * 0.1f);
if (!__instance.Calming)
{
__instance.AddTarget(value.gameObject);
}
if (__instance.CanEnrage && value.gameObject != null)
{
__instance.PreWindup(delay);
}
}
}
}
return(false);
}
public static bool Prefix(PlayableScps.Scp096 __instance)
{
if (((PlayableScp)__instance).isLocalPlayer)
{
__instance._abilityManager.RunInputs();
CursorManager.ChangeMouseVisibility(LockReason.Scp096, (__instance.Charging || (__instance.TryingNotToCry || __instance.PryingGate)) ? MouseVisibilityType.InvisibleButCantMove : MouseVisibilityType.Invisible, false);
if (!__instance.PlayerState.IsOffensive() && !__instance._visionTargets.IsEmpty <TargetComponent>())
{
foreach (TargetComponent component in __instance._visionTargets)
{
if (component != null)
{
component.IsTarget = false;
}
}
__instance._visionTargets.Clear();
}
if (__instance.TryingNotToCry && (__instance.Hub.fpc.PlySpeed != Vector2.zero))
{
Scp096InputMessage message = new Scp096InputMessage
{
InputState = Scp096InputState.None
};
NetworkClient.Send <Scp096InputMessage>(message, 0);
}
}
if (NetworkServer.active)
{
__instance.UpdateShield();
__instance.UpdateEnrage();
__instance.UpdateCharging();
__instance.UpdatePry();
foreach (GameObject obj2 in PlayerManager.players)
{
CharacterClassManager manager = obj2.GetComponent <CharacterClassManager>();
if (manager == null || ((manager.CurClass != RoleType.Spectator) && !manager.IsAnyScp()))
{
Player player = Player.Get(obj2);
if (player != null && Tracking.PlayersWithSubclasses.ContainsKey(player) &&
Tracking.PlayersWithSubclasses[player].Abilities.Contains(AbilityType.Disable096Trigger))
{
continue;
}
VisionInformation visionInformation = __instance.GetVisionInformation(obj2);
if (visionInformation.Looking)
{
__instance.ParseVisionInformation(visionInformation);
}
}
}
foreach (KeyValuePair <GameObject, Door> pair in PlayableScps.Scp096.takenDoors)
{
if (pair.Value.isOpen)
{
PlayableScps.Scp096 scp = PlayableScps.Scp096.Get096FromPlayerObject(pair.Key);
if (scp != null)
{
if (pair.Key == null)
{
PlayableScps.Scp096.takenDoors.Remove(pair.Key);
}
else
{
scp.ResetState();
}
break;
}
}
}
}
return(false);
}
public static bool Prefix(SinkholeEnvironmentalHazard __instance, GameObject player)
{
// Check if player has a connection to the server.
if (!NetworkServer.active)
{
return(false);
}
PlayerEffectsController componentInParent = player.GetComponentInParent <PlayerEffectsController>();
if (componentInParent == null)
{
return(false);
}
componentInParent.GetEffect <CustomPlayerEffects.SinkHole>();
// Check if the player walking into a sinkhole is an SCP or not.
if (__instance.SCPImmune)
{
CharacterClassManager component = player.GetComponent <CharacterClassManager>();
if (component == null || component.IsAnyScp())
{
return(false);
}
}
// Check if player is in god mode.
Player ply = Player.Get(player);
if (ply.IsGodModeEnabled)
{
return(false);
}
// If a player is out of a sinkhole's range.
if (Vector3.Distance(player.transform.position, __instance.transform.position) > (double)__instance.DistanceToBeAffected * BetterSinkholes.config.SlowDistance)
{
// If player doesn't have a sinkhole effect don't remove it.
if (player.TryGetComponent(out PlayerEffectsController pec))
{
CustomPlayerEffects.SinkHole SinkholeEffect = pec.GetEffect <CustomPlayerEffects.SinkHole>();
// // If the player has the sinkhole effect, remove it.
if (SinkholeEffect != null && SinkholeEffect.Enabled)
{
componentInParent.DisableEffect <CustomPlayerEffects.SinkHole>();
}
return(false);
}
return(false);
}
// Check distance from the sinkhole's center.
if (Vector3.Distance(player.transform.position, __instance.transform.position) < (double)__instance.DistanceToBeAffected * BetterSinkholes.config.TeleportDistance)
{
// Remove Sinkhole effect once falling into a sinkhole.
componentInParent.DisableEffect <CustomPlayerEffects.SinkHole>();
// Teleport player once walking too close to the center of a sinkhole.
ReferenceHub referenceHub = ReferenceHub.GetHub(player);
referenceHub.playerMovementSync.OverridePosition(Vector3.down * 1998.5f, 0f, true);
// Apply corrosion effect.
PlayerEffectsController playerEffectsController = referenceHub.playerEffectsController;
playerEffectsController.GetEffect <CustomPlayerEffects.Corroding>().IsInPd = true;
playerEffectsController.EnableEffect <CustomPlayerEffects.Corroding>(0f, false);
// Send player a broadcast specified in the configs. Default: "" for 0U duration.
QueryProcessor.Localplayer.GetComponent <Broadcast>().TargetAddElement(player.gameObject.GetComponent <NetworkIdentity>().connectionToClient, BetterSinkholes.config.TeleportMessage, BetterSinkholes.config.TeleportMessageDuration, Broadcast.BroadcastFlags.Normal);
return(false);
}
componentInParent.EnableEffect <CustomPlayerEffects.SinkHole>(0f, false);
return(false);
}
public static void UpgradePlayer(Scp914Machine instance, CharacterClassManager player, IEnumerable <CharacterClassManager> players)
{
var c = PluginConfig.Cfg;
if (!c.RoughCoarseDamageSCP && player.IsScpButNotZombie())
{
TeleportPlayer(instance, player);
return;
}
if (CheckPercent(c.InvUpgradeChance) && !player.IsAnyScp())
{
Inventory inv = player.GetComponent <Inventory>();
if (inv.items.Count > 0)
{
var index = inv.items.Count > 1 ? Random.Range(0, inv.items.Count - 1) : 0;
var itemInfo = inv.items[index];
var item = GetItem(instance.knobState, itemInfo.id);
if (item < 0)
{
inv.items.RemoveAt(index);
}
else
{
itemInfo.id = item;
inv.items[index] = itemInfo;
Scp914Machine.TryFriendshipAchievement(item, player, players);
}
}
}
if (c.ChangePlayerHealth)
{
if (!player.GodMode && player.CurClass != RoleType.Spectator)
{
HealthChangedComponent component = player.GetComponent <HealthChangedComponent>();
var stats = player.GetComponent <PlayerStats>();
if (component == null)
{
component = player.gameObject.AddComponent <HealthChangedComponent>();
component.OriginalHealthAmmount = stats.maxHP;
component.ActualHealthPercentage = 100;
}
var newPercent = component.ActualHealthPercentage;
if (instance.knobState == Scp914Knob.Rough)
{
if (CheckPercent(c.RoughDamageChance) || (CheckPercent(c.RoughDamageChance * c.SCPDamageChanceMultiplier) && player.IsScpButNotZombie()))
{
if (player.IsScpButNotZombie())
{
HurtPlayer(stats.maxHP * ((c.RoughDamageAmmout / 2) / 100), stats, player);
}
else
{
newPercent -= c.RoughDamageAmmout;
}
}
}
else if (instance.knobState == Scp914Knob.Coarse)
{
if (CheckPercent(c.CoarseDamageChance) || (CheckPercent(c.CoarseDamageChance * c.SCPDamageChanceMultiplier) && player.IsScpButNotZombie()))
{
if (player.IsScpButNotZombie())
{
HurtPlayer(stats.maxHP * ((c.CoarseDamageAmmout / 2) / 100), stats, player);
}
else
{
newPercent -= c.CoarseDamageAmmout;
}
}
}
else if (instance.knobState == Scp914Knob.Fine && !player.IsScpButNotZombie())
{
if (CheckPercent(c.FineHealChance))
{
newPercent += c.FineHealAmmout;
}
}
else if (instance.knobState == Scp914Knob.VeryFine && !player.IsScpButNotZombie())
{
if (CheckPercent(c.VeryFineHealChance))
{
newPercent += c.VeryFineHealAmmout;
}
}
newPercent = Constrain(newPercent, 100 - c.RoughDamageAmmout, 100 + c.VeryFineHealAmmout);
Log.Info("newPercent: " + newPercent + "%");
if (newPercent <= 0)
{
HurtPlayer(stats.maxHP + 1f, stats, player);
if (stats.health > 0)
{
newPercent = 5f;
}
else
{
Object.Destroy(component);
}
}
if (newPercent >= 100)
{
var prev = stats.maxHP;
stats.maxHP = Mathf.RoundToInt(component.OriginalHealthAmmount * (newPercent / 100));
if (prev > stats.maxHP)
{
stats.health = stats.maxHP < stats.health ? stats.maxHP : stats.health;
}
else if (!player.IsScpButNotZombie())
{
stats.HealHPAmount(999999f);
}
}
component.ActualHealthPercentage = newPercent;
Log.Info(component.ActualHealthPercentage + "% " + stats.maxHP + "HP " + stats.health + "health");
}
}
TeleportPlayer(instance, player);
}
