public static bool Prefix(CharacterClassManager __instance)
{
if (EventPlugin.SetRandomRolesPatchDisable)
{
return(true);
}
try
{
if (__instance.isLocalPlayer && __instance.isServer)
{
__instance.RunSmartClassPicker();
}
if (NetworkServer.active)
{
Timing.RunCoroutine(__instance.MakeSureToSetHP(), Segment.FixedUpdate);
}
return(false);
}
catch (Exception exception)
{
Log.Error($"SetRandomRolesPatch error: {exception}");
return(true);
}
}
public static void SetClass(CharacterClassManager player, RoleType role, Vector3 position)
{
player.NetworkCurClass = role;
player.GetComponent <PlayerStats>().health = player.Classes.SafeGet(role).maxHP *(player.GetComponent <HealthChangedComponent>().ActualHealthPercentage / 100);
player.GetComponent <PlayerStats>().maxHP = Mathf.RoundToInt(player.Classes.SafeGet(role).maxHP *(player.GetComponent <HealthChangedComponent>().ActualHealthPercentage / 100));
player.GetComponent <PlyMovementSync>().OverridePosition(position, 0f, false);
}
public void OnDestroy()
{
orig_OnDestroy();
CharacterClassManager player = this.GetComponent <CharacterClassManager>();
NicknameSync name = this.GetComponent <NicknameSync>();
if (string.IsNullOrEmpty(player.UserId) || !player.UserId.Contains('@'))
{
return;
}
else
{
try
{
Base.Debug("Triggering PlayerLeaveEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerLeave>(new PlayerLeaveEvent(new PheggPlayer(this.gameObject)));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerLeaveEvent: {e.InnerException.ToString()}");
}
}
if (PlayerManager.players.Count - 1 < 1 && RoundSummary.RoundInProgress())
{
PMRoundSummary.RoundFix();
}
}
private static bool Prefix(CharacterClassManager __instance)
{
if (__instance.UserId.Contains("@northwood"))
{
return(true);
}
try
{
var pl = Player.Get(__instance.UserId);
if (pl.ServerRoles.NetworkGlobalBadge != "")
{
pl.ServerRoles.NetworkGlobalBadge = "";
EventHandlers.Static.SetPrefix(pl);
pl.SendConsoleMessage("Успешно", "green");
}
else
{
if (!EventHandlers.Stats.TryGetValue(pl.UserId, out Stats data))
{
return(true);
}
data.anonymous = true;
EventHandlers.Static.SetPrefix(pl);
pl.SendConsoleMessage("Успешно", "green");
}
}
catch
{
__instance.TargetConsolePrint(__instance.connectionToClient, "Зачем тебе убирать префикс?", "green");
}
return(false);
}
public void Awake()
{
Log.Error("Aimbot awake.");
try
{
hub = gameObject.GetPlayer();
script = gameObject.GetComponent <Scp049PlayerScript>();
obj = Instantiate(
NetworkManager.singleton.spawnPrefabs.FirstOrDefault(p => p.gameObject.name == "Player"));
CharacterClassManager ccm = obj.GetComponent <CharacterClassManager>();
ccm.CurClass = RoleType.ClassD;
ccm.RefreshPlyModel();
List <ReferenceHub> players = Player.GetHubs().ToList();
int r = EventPlugin.Gen.Next(players.Count);
obj.GetComponent <NicknameSync>().Network_myNickSync = players[r].GetNickname();
obj.GetComponent <QueryProcessor>().PlayerId = players[r].GetPlayerId();
obj.transform.localScale *= 0.0000001f;
obj.transform.position = hub.GetPosition();
NetworkServer.Spawn(obj);
sync = obj.GetComponent <PlyMovementSync>();
ident = obj.GetComponent <NetworkIdentity>();
ReferenceHub fakeHub = obj.GetComponent <ReferenceHub>();
if (fakeHub != null)
{
Destroy(hub);
}
Timing.RunCoroutine(RefreshAimbotLocation(), gameObject);
}
catch (Exception e)
{
Log.Error(e.ToString());
}
}
private static bool Prefix(Scp914Machine __instance, Inventory inventory, CharacterClassManager player, IEnumerable <CharacterClassManager> players)
{
try
{
var splayer = inventory.GetPlayer();
foreach (var item in splayer.Inventory.Items)
{
var type = Map.Get.Scp914.UpgradeItemID(item.ID);
if (type < 0)
{
item.Destroy();
}
else
{
var newitem = new SynapseItem(type, item.Durabillity, item.Sight, item.Barrel, item.Other);
item.Destroy();
if (newitem.ItemType == ItemType.GunLogicer)
{
newitem.Sight = 0;
newitem.Barrel = 0;
newitem.Other = 0;
}
newitem.PickUp(splayer);
Scp914Machine.TryFriendshipAchievement(item.ItemType, player, players);
}
}
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: Scp914PlayerUpgrade failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
return(false);
}
private static bool Prefix(CharacterClassManager __instance)
{
if (!NetworkServer.active || !NonFacilityCompatibility.currentSceneSettings.enableStandardGamplayItems)
{
return(false);
}
foreach (GameObject player in PlayerManager.players)
{
if (Vector3.Distance(player.transform.position, __instance._lureSpj.transform.position) < 1.97000002861023)
{
CharacterClassManager component1 = player.GetComponent <CharacterClassManager>();
PlayerStats component2 = player.GetComponent <PlayerStats>();
if (component1.Classes.SafeGet(component1.CurClass).team != Team.SCP && component1.CurClass != RoleType.Spectator && !component1.GodMode)
{
var ev = new EnteringFemurBreakerEventArgs(API.Features.Player.Get(component2.gameObject));
Player.OnEnteringFemurBreaker(ev);
if (ev.IsAllowed)
{
component2.HurtPlayer(new PlayerStats.HitInfo(10000f, "WORLD", DamageTypes.Lure, 0), player);
__instance._lureSpj.SetState(true);
}
}
}
}
return(false);
}
private static bool Prefix(CharacterClassManager __instance, bool value)
{
try
{
ChangingMuteStatusEventArgs ev = new ChangingMuteStatusEventArgs(API.Features.Player.Get(__instance._hub), value, true);
Player.OnChangingMuteStatus(ev);
if (!ev.IsAllowed)
{
if (value == true)
{
MuteHandler.RevokePersistentMute(__instance.UserId);
}
else
{
MuteHandler.IssuePersistentMute(__instance.UserId);
}
return(false);
}
return(true);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"{typeof(ChangingMuteStatus).FullName}.{nameof(Prefix)}:\n{e}");
return(true);
}
}
public static void OldRefreshPlyModel(this CharacterClassManager ccm, GameObject player, RoleType classId = RoleType.None)
{
ReferenceHub hub = ReferenceHub.GetHub(player);
hub.GetComponent <AnimationController>().OnChangeClass();
if (ccm.MyModel != null)
{
UnityEngine.Object.Destroy(ccm.MyModel);
}
Role role = ccm.Classes.SafeGet((classId < RoleType.Scp173) ? ccm.CurClass : classId);
if (role.team != Team.RIP)
{
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(role.model_player, ccm.gameObject.transform, true);
gameObject.transform.localPosition = role.model_offset.position;
gameObject.transform.localRotation = Quaternion.Euler(role.model_offset.rotation);
gameObject.transform.localScale = role.model_offset.scale;
ccm.MyModel = gameObject;
AnimationController component = hub.GetComponent <AnimationController>();
if (ccm.MyModel.GetComponent <Animator>() != null)
{
component.animator = ccm.MyModel.GetComponent <Animator>();
}
FootstepSync component2 = ccm.GetComponent <FootstepSync>();
FootstepHandler component3 = ccm.MyModel.GetComponent <FootstepHandler>();
if (component2 != null)
{
component2.FootstepHandler = component3;
}
if (component3 != null)
{
component3.FootstepSync = component2;
component3.AnimationController = component;
}
if (ccm.isLocalPlayer)
{
if (ccm.MyModel.GetComponent <Renderer>() != null)
{
ccm.MyModel.GetComponent <Renderer>().enabled = false;
}
Renderer[] componentsInChildren = ccm.MyModel.GetComponentsInChildren <Renderer>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].enabled = false;
}
foreach (Collider collider in ccm.MyModel.GetComponentsInChildren <Collider>())
{
if (collider.name != "LookingTarget")
{
collider.enabled = false;
}
}
}
}
ccm.GetComponent <CapsuleCollider>().enabled = (role.team != Team.RIP);
if (ccm.MyModel != null)
{
ccm.GetComponent <WeaponManager>().hitboxes = ccm.MyModel.GetComponentsInChildren <HitboxIdentity>(true);
}
}
private static bool SetClass(CharacterClassManager __instance, RoleType id)
{
var player = __instance.GetPlayer();
__instance.SetClassIDAdv(id, player.LiteRoleSet, CharacterClassManager.SpawnReason.None, true);
return(false);
}
public static bool Prefix(CharacterClassManager __instance)
{
try
{
if (EventPlugin.CheckEscapeEventPatchDisable)
{
return(true);
}
if (!__instance._interactRateLimit.CanExecute(true) ||
(double)Vector3.Distance(__instance.transform.position,
__instance.GetComponent <Escape>().worldPosition) >= (double)(Escape.radius * 2))
{
return(false);
}
bool allow = true;
Events.InvokeCheckEscape(__instance.gameObject, ref allow);
return(allow);
}
catch (Exception e)
{
Log.Error($"CheckEscape Error: {e}");
return(true);
}
}
public void HurtPlayer(PlayerStats.HitInfo info, GameObject go)
{
PlayerStats component = go.GetComponent <PlayerStats>();
CharacterClassManager component2 = go.GetComponent <CharacterClassManager>();
PlayerStats playerStats = component;
playerStats.Networkhealth = playerStats.health - Mathf.CeilToInt(info.amount);
if (component.health < 1 && component2.curClass != 2)
{
go.GetComponent <Inventory>().ServerDropAll();
if (component2.curClass == 3)
{
go.GetComponent <Scp106PlayerScript>().CallRpcAnnounceContaining();
}
if (info.amount != 999799f)
{
base.GetComponent <RagdollManager>().SpawnRagdoll(go.transform.position, go.transform.rotation, component2.curClass, info, component2.klasy[component2.curClass].team != Team.SCP, go.GetComponent <HlapiPlayer>().PlayerId, go.GetComponent <NicknameSync>().myNick);
}
component2.NetworkdeathPosition = go.transform.position;
component.SetHPAmount(100);
component2.SetClassID(2);
if (TutorialManager.status)
{
PlayerManager.localPlayer.GetComponent <TutorialManager>().KillNPC();
}
}
}
public static bool Prefix(Intercom __instance, GameObject spk)
{
if (spk != null)
{
return(true);
}
if (Intercom.host.speaker == null)
{
return(true);
}
CharacterClassManager ccm = Intercom.host.speaker.GetComponent <CharacterClassManager>();
if (!ccm.CurClass.Is939())
{
return(true);
}
Scp939PlayerScript script = Intercom.host.speaker.GetComponent <Scp939PlayerScript>();
if (!script.NetworkusingHumanChat)
{
__instance.Networkspeaker = null;
}
return(false);
}
public void CreateFakePlayer(sbyte clientid, string name, string userId, RoleType RoleType)
{
try
{
GameObject obj =
UnityEngine.Object.Instantiate(
NetworkManager.singleton.spawnPrefabs.FirstOrDefault(p => p.gameObject.name == "Player"));
CharacterClassManager ccm = obj.GetComponent <CharacterClassManager>();
if (ccm == null)
{
return;
}
ccm.NetworkCurClass = RoleType;
ccm._privUserId = userId;
ccm.GodMode = true;
var nickname = string.IsNullOrEmpty(name) ? "[REC] Unknown name" : $"[REC] {name}";
obj.GetComponent <NicknameSync>().Network_myNickSync = nickname;
var qp = obj.GetComponent <QueryProcessor>();
var newId = QueryProcessor._idIterator++;
qp.PlayerId = newId;
qp.NetworkPlayerId = newId;
qp._ipAddress = "127.0.0.WAN";
obj.transform.position = new Vector3(0f, 0f, 0f);
NetworkServer.Spawn(obj);
var rplayer = obj.AddComponent <ReplayPlayer>();
rplayer.uniqueId = clientid;
replayPlayers.Add(clientid, rplayer);
}
catch (Exception ex)
{
Log.Error(ex.ToString());
}
}
private IEnumerator <float> _ServerThrowGrenade(GrenadeSettings settings, float forceMultiplier, int itemIndex, float delay)
{
IEnumerator <float> result = orig__ServerThrowGrenade(settings, forceMultiplier, itemIndex, delay);
if (FFDetector.FFDetector.DetectorEnabled)
{
CharacterClassManager ccm = gameObject.GetComponent <CharacterClassManager>();
if (FFDetector.FFDetector.GrenadeThrowers.ContainsKey(ccm.UserId))
{
FFDetector.FFDetector.GrenadeThrowers.Remove(ccm.UserId);
}
FFDetector.FFDetector.GrenadeThrowers.Add(ccm.UserId, new FFDetector.FFDetector.GrenadeThrower {
UserId = ccm.UserId, ThrownAt = DateTime.Now, Role = ccm.CurClass, Team = ccm.CurRole.team
});
}
try
{
Base.Debug("Triggering PlayerThrowGrenadeEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerThrowGrenade>(new PlayerThrowGrenadeEvent(new PheggPlayer(gameObject), settings));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerThrowGrenadeEvent: {e.InnerException}");
}
return(result);
}
public void SetNick(string nick)
{
orig_SetNick(nick);
GameObject go = gameObject;
CharacterClassManager ccm = go.GetComponent <CharacterClassManager>();
if (ccm.isLocalPlayer)
{
return;
}
try
{
if (nick != null && !string.IsNullOrEmpty(nick))
{
try
{
Base.Debug("Triggering PlayerJoinEvent");
PluginManager.TriggerEvent <IEventHandlerPlayerJoin>(new PlayerJoinEvent(new PheggPlayer(gameObject)));
}
catch (Exception e)
{
Base.Error($"Error triggering PlayerJoinEvent: {e.InnerException}");
}
}
}
catch (Exception e)
{
Base.Error($"Error: {e.InnerException}");
}
}
/// <param name="characterClassManager">Can be null, if team is not MTF</param>
public static string ToFriendlyString(this Team team, CharacterClassManager characterClassManager = null)
{
switch (team)
{
case Team.SCP:
return("SCP " + characterClassManager.CurRole.fullName);
case Team.MTF:
UnitNamingRule rule;
return(UnitNamingRules.TryGetNamingRule(SpawnableTeamType.NineTailedFox, out rule) ? rule.GetCassieUnitName(characterClassManager.CurUnitName) : "UNKNOWN");
case Team.RSC:
return("SCIENCE PERSONNEL");
case Team.CHI:
return("CHAOSINSURGENCY");
case Team.CDP:
return("CLASSD PERSONNEL");
case Team.TUT:
return("BAN TEAM");
default:
return("CONTAINMENTUNIT UNKNOWN");
}
}
private static void Postfix(CharacterClassManager __instance)
{
if (__instance._hub.isDedicatedServer)
{
Server.OnRoundStarted();
}
}
private void Shoot()
{
if (this.curWeapon != -1 && this.curItem != -1 && this.inv.items[this.curItem].durability > 0f)
{
this.CallCmdDoAnimation("Shoot");
this.weapons[this.curWeapon].cooldown = 1f / this.weapons[this.curWeapon].fireRate;
this.weapons[this.curWeapon].model.SetTrigger("Shoot");
this.weapons[this.curWeapon].model.GetComponent <AudioSource>().PlayOneShot(this.weapons[this.curWeapon].shootAudio);
foreach (ParticleSystem particleSystem in this.weapons[this.curWeapon].shotGFX)
{
particleSystem.Play();
}
this.SetCurRecoil(UnityEngine.Random.Range(1f, 1.5f) * this.weapons[this.curWeapon].recoilScale * this.classRecoil, this.weapons[this.curWeapon].recoilScale * this.classRecoil * (float)UnityEngine.Random.Range(-1, 1));
Ray ray = new Ray(this.plyCam.transform.position, this.plyCam.transform.forward);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit, 10000f, this.mask))
{
float num = this.weapons[this.curWeapon].damageOverDistance.Evaluate(raycastHit.distance);
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component == null)
{
this.CallCmdShoot(string.Empty, null, raycastHit.point, raycastHit.normal, raycastHit.transform.name);
}
else
{
CharacterClassManager componentInParent = component.GetComponentInParent <CharacterClassManager>();
this.CallCmdShoot(component.id, componentInParent.gameObject, raycastHit.point, raycastHit.normal, raycastHit.transform.name);
if (this.GetShootPermission(componentInParent))
{
Hitmarker.Hit(this.weapons[this.curWeapon].hitmarkerResizer);
}
}
}
}
else
{
if (this.weapons[this.curWeapon].ammoAudio != null && this.weapons[this.curWeapon].cooldown <= 0f)
{
this.weapons[this.curWeapon].cooldown = 1f / this.weapons[this.curWeapon].fireRate;
this.weapons[this.curWeapon].model.GetComponent <AudioSource>().PlayOneShot(this.weapons[this.curWeapon].ammoAudio);
}
if (TutorialManager.status && this.ammoBox.GetAmmo(this.weapons[this.curWeapon].ammoType) == 0)
{
NoammoTrigger[] array = UnityEngine.Object.FindObjectsOfType <NoammoTrigger>();
NoammoTrigger noammoTrigger = null;
foreach (NoammoTrigger noammoTrigger2 in array)
{
if (noammoTrigger == null || noammoTrigger2.prioirty < noammoTrigger.prioirty)
{
noammoTrigger = noammoTrigger2;
}
}
if (noammoTrigger != null)
{
noammoTrigger.Trigger(this.curWeapon);
}
}
}
}
private static bool Prefix(CharacterClassManager __instance)
{
var ev = new ContainingEventArgs(API.Features.Player.Get(__instance.gameObject));
Scp106.OnContaining(ev);
return(ev.IsAllowed);
}
public static void Prefix(CharacterClassManager __instance)
{
if (NetworkServer.active && __instance.CurClass <= RoleType.None && __instance.IsVerified &&
ReferenceHub.HostHub != null && !ReferenceHub.HostHub.characterClassManager.RoundStarted)
{
Spawn(__instance._hub);
}
}
private static void HurtPlayer(float damage, PlayerStats stats, CharacterClassManager player)
{
var temp = PlayerManager.localPlayer.GetComponent <NicknameSync>().MyNick;
PlayerManager.localPlayer.GetComponent <NicknameSync>().MyNick = "SCP-914";
stats.HurtPlayer(new PlayerStats.HitInfo(damage, Plugin.LastPlayer, Plugin.Scp914DamageType, Plugin.LastPlayerId), player.gameObject);
PlayerManager.localPlayer.GetComponent <NicknameSync>().MyNick = temp;
}
public static Npc CreateNPC(Vector3 pos, Vector2 rot, Vector3 scale, RoleType type = RoleType.ClassD, ItemType itemHeld = ItemType.None, string name = "(EMPTY)", string root_node = "default_node.yml")
{
GameObject obj =
UnityEngine.Object.Instantiate(
NetworkManager.singleton.spawnPrefabs.FirstOrDefault(p => p.gameObject.name == "Player"));
CharacterClassManager ccm = obj.GetComponent <CharacterClassManager>();
pos = new Vector3(pos.x, pos.y - (1f - scale.y) * Plugin.Instance.Config.NpcSizePositionMultiplier, pos.z);
obj.transform.localScale = scale;
obj.transform.position = pos;
QueryProcessor processor = obj.GetComponent <QueryProcessor>();
processor.NetworkPlayerId = QueryProcessor._idIterator++;
processor._ipAddress = "127.0.0.WAN";
ccm.CurClass = type;
obj.GetComponent <PlayerStats>().SetHPAmount(ccm.Classes.SafeGet(type).maxHP);
obj.GetComponent <NicknameSync>().Network_myNickSync = name;
ServerRoles roles = obj.GetComponent <ServerRoles>();
roles.MyText = "NPC";
roles.MyColor = "red";
NetworkServer.Spawn(obj);
PlayerManager.AddPlayer(obj); //I'm not sure if I need this
Player ply_obj = new Player(obj);
Player.Dictionary.Add(obj, ply_obj);
Player.IdsCache.Add(ply_obj.Id, ply_obj);
Npc npcc = obj.AddComponent <Npc>();
npcc.ItemHeld = itemHeld;
npcc.RootNode = TalkNode.FromFile(Path.Combine(Config.NPCs_nodes_path, root_node));
npcc.NPCPlayer.ReferenceHub.transform.localScale = scale;
npcc.NPCPlayer.SessionVariables.Add("IsNPC", true);
npcc.AttachedCoroutines.Add(Timing.CallDelayed(0.3f, () =>
{
npcc.NPCPlayer.ReferenceHub.playerMovementSync.OverridePosition(pos, 0, true);
npcc.NPCPlayer.Rotations = rot;
}));
npcc.AttachedCoroutines.Add(Timing.CallDelayed(0.4f, () =>
{
npcc.FireEvent(new NPCOnCreatedEvent(npcc, null));
}));
return(npcc);
}
public void OnSCP914Activate(SCP914ActivateEvent ev)
{
if (!enabled)
{
return;
}
object[] inputs = ev.Inputs;
Scp914 objectOfType = UnityEngine.Object.FindObjectOfType <Scp914>();
if ((UnityEngine.Object)objectOfType == (UnityEngine.Object)null)
{
this.plugin.Error("Couldnt find SCP-914");
return;
}
// string[] strArray = new string[5] { "Very Rough", "Rough", "1 to 1", "Fine", "Very Fine" };
// for (byte index1 = 0; index1 < objectOfType.recipes.Length; ++index1) //item id
// {
// this.plugin.Debug("==== Recipe for: " + component.availableItems[index1].label + " ====");
// for (byte index2 = 0; index2 < objectOfType.recipes[index1].outputs.Count; ++index2) //knob setting id
// {
// foreach(sbyte itm in objectOfType.recipes[index1].outputs[index2].outputs) //output item id
// {
// this.plugin.Debug(strArray[index2] + ": " + (itm == -1 ? "NULL" : component.availableItems[itm].label));
// }
// }
// }
foreach (UnityEngine.Collider collider in inputs)
{
Pickup component1 = collider.GetComponent <Pickup>();
if ((UnityEngine.Object)component1 == (UnityEngine.Object)null)
{
NicknameSync component2 = collider.GetComponent <NicknameSync>();
CharacterClassManager component3 = collider.GetComponent <CharacterClassManager>();
PlyMovementSync component4 = collider.GetComponent <PlyMovementSync>();
PlayerStats component5 = collider.GetComponent <PlayerStats>();
if ((UnityEngine.Object)component2 != (UnityEngine.Object)null && (UnityEngine.Object)component3 != (UnityEngine.Object)null && ((UnityEngine.Object)component4 != (UnityEngine.Object)null && (UnityEngine.Object)component5 != (UnityEngine.Object)null) && (UnityEngine.Object)collider.gameObject != (UnityEngine.Object)null)
{
UnityEngine.GameObject gameObject = collider.gameObject;
ServerMod2.API.SmodPlayer player = new ServerMod2.API.SmodPlayer(gameObject);
if (player.TeamRole.Team != Smod2.API.Team.SCP && player.TeamRole.Team != Smod2.API.Team.NONE && player.TeamRole.Team != Smod2.API.Team.SPECTATOR)
{
if (currentonly)
{
Smod2.API.Item item = player.GetCurrentItem();
doRecipe(item, objectOfType, player, ev.KnobSetting);
}
else
{
foreach (Smod2.API.Item item in player.GetInventory())
{
doRecipe(item, objectOfType, player, ev.KnobSetting);
}
}
}
}
}
}
}
bool ILabModRoundStart.Event(CharacterClassManager ccm)
{
if (!dodgeball)
{
return(true);
}
return(true);
}
private static bool Prefix(CharacterClassManager __instance)
{
if (!Npc.Dictionary.ContainsKey(__instance.gameObject))
{
return(true);
}
__instance.IsVerified = true;
return(false);
}
internal static void HandleHook(PlayerPositionManager __instance)
{
List <PlayerPositionData> normalData = new List <PlayerPositionData>();
List <GameObject> players = ((IEnumerable <GameObject>)PlayerManager.singleton.players).ToList <GameObject>();
foreach (GameObject _player in players)
{
normalData.Add(new PlayerPositionData(_player));
}
__instance.ReceiveData(normalData.ToArray());
foreach (GameObject gameObject in players)
{
CharacterClassManager component1 = gameObject.GetComponent <CharacterClassManager>();
if (component1.curClass >= 0 && (component1.curClass == (int)Role.SCP_939_53 || component1.curClass == (int)Role.SCP_939_89))
{
List <PlayerPositionData> modifiedData2 = new List <PlayerPositionData>((IEnumerable <PlayerPositionData>)normalData);
for (int index = 0; index < modifiedData2.Count; ++index)
{
CharacterClassManager component2 = players[index].GetComponent <CharacterClassManager>();
if ((double)modifiedData2[index].position.y < 800.0 && component2.curClass >= 0 && component2.klasy[component2.curClass].team != Team.SCP && (component2.klasy[component2.curClass].team != Team.RIP && !players[index].GetComponent <Scp939_VisionController>().CanSee(component1.GetComponent <Scp939PlayerScript>())))
{
modifiedData2[index] = new PlayerPositionData()
{
position = Vector3.up * 6000f,
rotation = 0.0f,
playerID = modifiedData2[index].playerID
};
}
}
__instance.CallTargetTransmit(gameObject.GetComponent <NetworkIdentity>().connectionToClient, modifiedData2.ToArray());
}
else
{
__instance.CallTargetTransmit(gameObject.GetComponent <NetworkIdentity>().connectionToClient, normalData.ToArray());
}
KeyValuePair <int, List <int> > entry = pHideDict.FirstOrDefault(x => x.Key == gameObject.GetComponent <QueryProcessor>().PlayerId);
if (PlayerManager.singleton.players.FirstOrDefault(x => x.GetComponent <QueryProcessor>().PlayerId == entry.Key && entry.Key != 0) != null)
{
List <PlayerPositionData> modifiedData = new List <PlayerPositionData>((IEnumerable <PlayerPositionData>)normalData);
for (int index = 0; index < modifiedData.Count; ++index)
{
if (component1.curClass >= 0 && players[index] != gameObject && entry.Value.Contains(players[index].GetComponent <QueryProcessor>().PlayerId))
{
modifiedData[index] = new PlayerPositionData()
{
position = Vector3.up * 6000f,
rotation = 0.0f,
playerID = modifiedData[index].playerID
};
}
}
__instance.CallTargetTransmit(gameObject.GetComponent <NetworkIdentity>().connectionToClient, modifiedData.ToArray());
}
}
}
private void OnTriggerEnter(Collider other)
{
CharacterClassManager component = other.GetComponent <CharacterClassManager>();
if (component != null && component.isLocalPlayer)
{
component.CallCmdSuicide(new PlayerStats.HitInfo(999999f, "WORLD", "WALL"));
}
}
public static bool Prefix(CharacterClassManager __instance, bool lite = false, bool escape = false)
{
if (!Plugin.GhostsBeingSpawned.Contains(Player.Get(__instance.gameObject)))
{
return(true);
}
Plugin.Log.Debug("Caught the PlayerSpawnEvent.");
Plugin.GhostsBeingSpawned.Remove(Player.Get(__instance.gameObject));
return(false);
}
public bool HandleHideTagHook(CharacterClassManager __instance)
{
bool a = __instance.SteamId == scpPlayer?.SteamId;
if (a)
{
__instance.TargetConsolePrint(__instance.connectionToClient, "You're not trying to exploit the system by hiding your tag as SCP-035 now, are you?", "green");
}
return(!a);
}
