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 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);
}
}
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);
}
}
static bool Prefix(PlayerPositionManager __instance)
{
List <PlayerPositionData> posData = new List <PlayerPositionData>();
List <GameObject> players = PlayerManager.singleton.players.ToList();
bool smGhostMode = ConfigFile.GetBool("sm_enable_ghostmode", false);
foreach (GameObject player in players)
{
posData.Add(new PlayerPositionData(player));
}
__instance.ReceiveData(posData.ToArray());
foreach (GameObject gameObject in players)
{
CharacterClassManager component = gameObject.GetComponent <CharacterClassManager>();
int pid1 = gameObject.GetComponent <QueryProcessor>().PlayerId;
if (smGhostMode && gameObject != __instance.gameObject && component.curClass >= 0)
{
for (int i = 0; i < posData.Count; i++)
{
if (players[i] == gameObject)
{
continue;
}
CharacterClassManager component2 = players[i].GetComponent <CharacterClassManager>();
int pid2 = players[i].GetComponent <QueryProcessor>().PlayerId;
if (component2.smGhostMode && component2.curClass >= 0 && component2.curClass != 2 && (component.curClass != 2 || (!component2.smVisibleToSpec && component.curClass == 2)) && (!component2.smVisibleWhenTalking || (component2.smVisibleWhenTalking && !component2.GetComponent <Radio>().NetworkisTransmitting)))
{
posData[i] = new PlayerPositionData
{
position = Vector3.up * 6000f,
rotation = 0f,
playerID = posData[i].playerID
}
}
;
if (Methods.CheckHidden(pid1, pid2))
{
ServerConsole.AddLog("Returned true for " + pid1 + " " + pid2);
posData[i] = new PlayerPositionData
{
position = Vector3.up * 6000f, rotation = 0f, playerID = posData[i].playerID
};
}
}
}
switch (component.curClass)
{
case 16:
case 17:
{
List <PlayerPositionData> posData939 = new List <PlayerPositionData>(posData);
for (int i = 0; i < posData939.Count; i++)
{
CharacterClassManager component2 = players[i].GetComponent <CharacterClassManager>();
if (posData939[i].position.y < 800f && component2.klasy[component2.curClass].team != Team.SCP && component2.klasy[component2.curClass].team != Team.RIP && !players[i].GetComponent <Scp939_VisionController>().CanSee(component.GetComponent <Scp939PlayerScript>()))
{
posData939[i] = new PlayerPositionData
{
position = Vector3.up * 6000f,
rotation = 0f,
playerID = posData939[i].playerID
}
}
;
}
__instance.CallTargetTransmit(gameObject.GetComponent <NetworkIdentity>().connectionToClient, posData939.ToArray());
break;
}
default:
__instance.CallTargetTransmit(gameObject.GetComponent <NetworkIdentity>().connectionToClient, posData.ToArray());
break;
}
}
return(false);
}
private static bool Prefix(CharacterClassManager __instance)
{
try
{
//Ratelimit Check
if (!__instance._interactRateLimit.CanExecute())
{
return(false);
}
//Position Check
if (Vector3.Distance(__instance.transform.position, __instance.GetComponent <Escape>().worldPosition) >=
Escape.radius * 2)
{
return(false);
}
//Event vars
var player = __instance.GetPlayer();
var spawnRole = player.RoleType;
var cufferRole = RoleType.None;
var allow = true;
var isCuffed = false;
//Cuff Check
var flag = false;
if (player.Cuffer != null)
{
cufferRole = player.Cuffer.RoleType;
isCuffed = true;
if (ConfigFile.ServerConfig.GetBool("cuffed_escapee_change_team", true))
{
switch (player.RoleType)
{
case RoleType.Scientist when(cufferRole == RoleType.ChaosInsurgency || cufferRole == RoleType.ClassD):
case RoleType.ClassD when(player.Cuffer.Team == Team.MTF || cufferRole == RoleType.Scientist):
flag = true;
break;
}
}
}
//TeamCheck
var singleton = Respawning.RespawnTickets.Singleton;
switch (player.Team)
{
case Team.CDP when flag:
spawnRole = RoleType.NtfCadet;
break;
case Team.CDP:
case Team.RSC when flag:
spawnRole = RoleType.ChaosInsurgency;
break;
case Team.RSC:
spawnRole = RoleType.NtfScientist;
break;
}
//PlayerEscapeEvent
SynapseController.Server.Events.Player.InvokePlayerEscapeEvent(player, ref spawnRole, cufferRole, ref allow, isCuffed);
if (!allow)
{
return(false);
}
if (spawnRole == RoleType.None || spawnRole == player.RoleType)
{
return(false);
}
player.ClassManager.SetPlayersClass(spawnRole, player.gameObject, false, true);
switch (player.Team)
{
case Team.MTF:
RoundSummary.escaped_scientists++;
singleton.GrantTickets(Respawning.SpawnableTeamType.NineTailedFox, ConfigFile.ServerConfig.GetInt("respawn_tickets_mtf_classd_cuffed_count", 1));
break;
case Team.CHI:
RoundSummary.escaped_ds++;
singleton.GrantTickets(Respawning.SpawnableTeamType.ChaosInsurgency, ConfigFile.ServerConfig.GetInt("respawn_tickets_ci_classd_count", 1));
break;
}
return(false);
}
catch (Exception e)
{
SynapseController.Server.Logger.Error($"Synapse-Event: PlayerEscape failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
public static bool Prefix(PlayerPositionManager __instance)
{
try
{
List <GameObject> players = PlayerManager.players;
__instance.usedData = players.Count;
if (__instance.receivedData == null || __instance.receivedData.Length < __instance.usedData)
{
__instance.receivedData = new PlayerPositionData[__instance.usedData * 2];
}
for (int index = 0; index < __instance.usedData; ++index)
{
__instance.receivedData[index] = new PlayerPositionData(players[index]);
}
if (__instance.transmitBuffer == null || __instance.transmitBuffer.Length < __instance.usedData)
{
__instance.transmitBuffer = new PlayerPositionData[__instance.usedData * 2];
}
foreach (GameObject gameObject in players)
{
CharacterClassManager component1 = gameObject.GetComponent <CharacterClassManager>();
Array.Copy(__instance.receivedData, __instance.transmitBuffer, __instance.usedData);
if (component1.CurClass == RoleType.Scp096 || component1.CurClass == RoleType.Scp173)
{
for (int i = 0; i < __instance.usedData; i++)
{
ReferenceHub hub = Plugin.GetPlayer(__instance.transmitBuffer[i].playerID.ToString());
if (hub.characterClassManager.CurClass != RoleType.Tutorial)
{
continue;
}
Scp049PlayerScript script = hub.GetComponent <Scp049PlayerScript>();
Vector3 fwd = script.plyCam.transform.forward;
Vector3 pos = script.gameObject.transform.position;
Vector3 position = component1.gameObject.transform.position;
float angle = Vector3.Angle(fwd,
(pos - position).normalized);
Vector3 dir = (pos - position).normalized;
Quaternion rot = Quaternion.LookRotation(dir);
if (angle <= 80f)
{
__instance.transmitBuffer[i] = new PlayerPositionData(__instance.transmitBuffer[i].position, Quaternion.Inverse(rot).y, __instance.transmitBuffer[i].playerID, __instance.transmitBuffer[i].uses268);
}
}
}
if (component1.CurClass.Is939())
{
for (int index = 0; index < __instance.usedData; ++index)
{
if (__instance.transmitBuffer[index].position.y < 800.0)
{
CharacterClassManager component2 = players[index].GetComponent <CharacterClassManager>();
if (component2.Classes.SafeGet(component2.CurClass).team != Team.SCP &&
component2.Classes.SafeGet(component2.CurClass).team != Team.RIP && !players[index]
.GetComponent <Scp939_VisionController>()
.CanSee(component1.GetComponent <Scp939PlayerScript>()))
{
__instance.transmitBuffer[index] = new PlayerPositionData(Vector3.up * 6000f, 0.0f,
__instance.transmitBuffer[index].playerID);
}
}
}
}
else if (component1.CurClass == RoleType.Scp096)
{
Scp096PlayerScript script = component1.GetComponent <Scp096PlayerScript>();
if (script.Networkenraged == Scp096PlayerScript.RageState.Enraged || script.Networkenraged == Scp096PlayerScript.RageState.Panic)
{
for (int i = 0; i < __instance.usedData; i++)
{
if (!Plugin.Scp096Targets.Contains(__instance.transmitBuffer[i].playerID))
{
__instance.transmitBuffer[i] = new PlayerPositionData(Vector3.up * 6000f, 0f, __instance.transmitBuffer[i].playerID);
}
}
}
}
else if (component1.CurClass != RoleType.Scp079 && component1.CurClass != RoleType.Spectator)
{
for (int index = 0; index < __instance.usedData; ++index)
{
if (__instance.transmitBuffer[index].uses268 || EXILED.EventPlugin.GhostedIds.Contains(__instance.transmitBuffer[index].playerID))
{
__instance.transmitBuffer[index] = new PlayerPositionData(Vector3.up * 6000f, 0.0f,
__instance.transmitBuffer[index].playerID);
}
}
}
NetworkConnection networkConnection = component1.netIdentity.isLocalPlayer
? NetworkServer.localConnection
: component1.netIdentity.connectionToClient;
if (__instance.usedData <= 20)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer,
(byte)__instance.usedData, 0), 1);
}
else
{
byte part;
for (part = (byte)0; (int)part < __instance.usedData / 20; ++part)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer, 20, part),
1);
}
byte count = (byte)(__instance.usedData % (part * 20));
if (count > 0)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer, count, part), 1);
}
}
}
return(false);
}
catch (Exception e)
{
Plugin.Info($"TransmitData Error. {e}");
return(true);
}
}
public static bool Prefix(CharacterClassManager __instance, bool lite = false, bool escape = false)
{
if (EventPlugin.PlayerSpawnEventPatchDisable)
{
return(true);
}
try
{
Role role = __instance.Classes.SafeGet(__instance.CurClass);
if (!__instance._wasAnytimeAlive && __instance.CurClass != RoleType.Spectator && __instance.CurClass != RoleType.None)
{
__instance._wasAnytimeAlive = true;
}
__instance.InitSCPs();
__instance.AliveTime = 0f;
switch (role.team)
{
case Team.MTF:
AchievementManager.Achieve("arescue");
break;
case Team.CHI:
AchievementManager.Achieve("chaos");
break;
case Team.RSC:
case Team.CDP:
__instance.EscapeStartTime = (int)Time.realtimeSinceStartup;
break;
}
__instance.GetComponent <Inventory>();
try
{
__instance.GetComponent <FootstepSync>().SetLoudness(role.team, role.roleId.Is939());
}
catch
{
}
if (NetworkServer.active)
{
Handcuffs component = __instance.GetComponent <Handcuffs>();
component.ClearTarget();
component.NetworkCufferId = -1;
}
if (role.team != Team.RIP)
{
if (NetworkServer.active && !lite)
{
Vector3 constantRespawnPoint = NonFacilityCompatibility.currentSceneSettings.constantRespawnPoint;
if (constantRespawnPoint != Vector3.zero)
{
__instance._pms.OnPlayerClassChange(constantRespawnPoint, 0f);
}
else
{
GameObject randomPosition = CharacterClassManager.SpawnpointManager.GetRandomPosition(__instance.CurClass);
Vector3 spawnPoint = new Vector3(0f, 0f, 0f);
float rotY = 0f;
if (randomPosition != null)
{
spawnPoint = randomPosition.transform.position;
rotY = randomPosition.transform.rotation.eulerAngles.y;
AmmoBox component2 = __instance.GetComponent <AmmoBox>();
if (escape && __instance.KeepItemsAfterEscaping)
{
Inventory component3 = PlayerManager.localPlayer.GetComponent <Inventory>();
for (ushort num = 0; num < 3; num += 1)
{
if (component2.GetAmmo(num) >= 15)
{
component3.SetPickup(component2.types[num].inventoryID, component2.GetAmmo(num), randomPosition.transform.position, randomPosition.transform.rotation, 0, 0, 0);
}
}
}
component2.SetAmmoAmount();
}
else
{
spawnPoint = __instance.DeathPosition;
rotY = 0f;
}
Events.InvokePlayerSpawn(__instance, __instance.CurClass, ref spawnPoint, ref rotY);
__instance._pms.OnPlayerClassChange(spawnPoint, rotY);
}
if (!__instance.SpawnProtected && __instance.EnableSP && __instance.SProtectedTeam.Contains((int)role.team))
{
__instance.GodMode = true;
__instance.SpawnProtected = true;
__instance.ProtectedTime = Time.time;
}
}
if (!__instance.isLocalPlayer)
{
__instance.GetComponent <PlayerStats>().maxHP = role.maxHP;
}
}
__instance.Scp049.iAm049 = (__instance.CurClass == RoleType.Scp049);
__instance.Scp0492.iAm049_2 = (__instance.CurClass == RoleType.Scp0492);
__instance.Scp096.iAm096 = (__instance.CurClass == RoleType.Scp096);
__instance.Scp106.iAm106 = (__instance.CurClass == RoleType.Scp106);
__instance.Scp173.iAm173 = (__instance.CurClass == RoleType.Scp173);
__instance.Scp939.iAm939 = __instance.CurClass.Is939();
__instance.RefreshPlyModel();
return(false);
}
catch (Exception exception)
{
Log.Error($"PlayerSpawnEvent error: {exception}");
return(true);
}
}
public static bool Prefix(PlayerPositionManager __instance)
{
if (EventPlugin.GhostmodePatchDisable)
{
return(true);
}
try
{
List <GameObject> players = PlayerManager.players;
__instance.usedData = players.Count;
if (__instance.receivedData == null || __instance.receivedData.Length < __instance.usedData)
{
__instance.receivedData = new PlayerPositionData[__instance.usedData * 2];
}
for (int index = 0; index < __instance.usedData; ++index)
{
__instance.receivedData[index] = new PlayerPositionData(players[index]);
}
if (__instance.transmitBuffer == null || __instance.transmitBuffer.Length < __instance.usedData)
{
__instance.transmitBuffer = new PlayerPositionData[__instance.usedData * 2];
}
foreach (GameObject gameObject in players)
{
CharacterClassManager component1 = gameObject.GetComponent <CharacterClassManager>();
Array.Copy(__instance.receivedData, __instance.transmitBuffer, __instance.usedData);
if (component1.CurClass == RoleType.Scp096 || component1.CurClass == RoleType.Scp173)
{
for (int i = 0; i < __instance.usedData; i++)
{
ReferenceHub hub = Player.GetPlayer(__instance.transmitBuffer[i].playerID);
if (hub.characterClassManager.CurClass != RoleType.Tutorial)
{
continue;
}
Scp049PlayerScript script = hub.GetComponent <Scp049PlayerScript>();
Vector3 fwd = script.plyCam.transform.forward;
Vector3 pos = script.gameObject.transform.position;
Vector3 position = component1.gameObject.transform.position;
float angle = Vector3.Angle(fwd, (pos - position).normalized);
Vector3 dir = (pos - position).normalized;
Quaternion rot = Quaternion.LookRotation(dir);
if (angle >= 100f)
{
float newAngle = Vector3.Angle(new Vector3(fwd.x, fwd.y + 180f, fwd.z),
(pos - position).normalized);
if (component1.CurClass == RoleType.Scp096 && EventPlugin.Scp096Fix || component1.CurClass == RoleType.Scp173 && EventPlugin.Scp173Fix)
{
__instance.transmitBuffer[i] = new PlayerPositionData(__instance.transmitBuffer[i].position, newAngle, __instance.transmitBuffer[i].playerID);
}
}
}
}
if (component1.CurClass.Is939())
{
for (int index = 0; index < __instance.usedData; ++index)
{
if (__instance.transmitBuffer[index].position.y < 800.0)
{
CharacterClassManager component2 = players[index].GetComponent <CharacterClassManager>();
if (component2.Classes.SafeGet(component2.CurClass).team != Team.SCP &&
component2.Classes.SafeGet(component2.CurClass).team != Team.RIP && !players[index]
.GetComponent <Scp939_VisionController>()
.CanSee(component1.GetComponent <Scp939PlayerScript>()))
{
__instance.transmitBuffer[index] = new PlayerPositionData(Vector3.up * 6000f, 0.0f,
__instance.transmitBuffer[index].playerID);
}
}
}
}
else if (component1.CurClass != RoleType.Scp079 && component1.CurClass != RoleType.Spectator)
{
for (int index = 0; index < __instance.usedData; ++index)
{
if (__instance.transmitBuffer[index].uses268 || EventPlugin.GhostedIds.Contains(__instance.transmitBuffer[index].playerID))
{
__instance.transmitBuffer[index] = new PlayerPositionData(Vector3.up * 6000f, 0.0f,
__instance.transmitBuffer[index].playerID);
}
}
}
if (EventPlugin.TargetGhost.ContainsKey(gameObject.GetPlayer()))
{
for (int i = 0; i < __instance.usedData; i++)
{
if (EventPlugin.TargetGhost[gameObject.GetPlayer()]
.Contains(__instance.transmitBuffer[i].playerID))
{
__instance.transmitBuffer[i] = new PlayerPositionData(Vector3.up * 6000f, 0.0f, __instance.transmitBuffer[i].playerID);
}
}
}
NetworkConnection networkConnection = component1.netIdentity.isLocalPlayer
? NetworkServer.localConnection
: component1.netIdentity.connectionToClient;
if (__instance.usedData <= 20)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer,
(byte)__instance.usedData, 0), 1);
}
else
{
byte part;
for (part = 0; part < __instance.usedData / 20; ++part)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer, 20, part),
1);
}
byte count = (byte)(__instance.usedData % (part * 20));
if (count > 0)
{
networkConnection.Send(
new PlayerPositionManager.PositionMessage(__instance.transmitBuffer, count, part), 1);
}
}
}
return(false);
}
catch (Exception exception)
{
Log.Error($"GhostmodePatch error: {exception}");
return(true);
}
}
public static bool Prefix(CharacterClassManager __instance)
{
try
{
//RateLimit Check
if (!__instance._interactRateLimit.CanExecute())
{
return(false);
}
//Position Check
if (Vector3.Distance(__instance.transform.position, __instance.GetComponent <Escape>().worldPosition) >=
Escape.radius * 2)
{
return(false);
}
//Event vars
var player = __instance.GetPlayer();
var spawnRole = player.Role;
var cufferRole = RoleType.None;
var allow = true;
var isCuffed = false;
//Cuff Check
var flag = false;
var component = __instance.GetComponent <Handcuffs>();
if (component.CufferId >= 0)
{
var component2 = component.GetCuffer(component.CufferId).GetComponent <CharacterClassManager>();
cufferRole = component2.NetworkCurClass;
isCuffed = true;
if (ConfigFile.ServerConfig.GetBool("cuffed_escapee_change_team", true))
{
switch (__instance.CurClass)
{
case RoleType.Scientist when(component2.CurClass == RoleType.ChaosInsurgency || component2.CurClass == RoleType.ClassD):
case RoleType.ClassD when(component2.CurRole.team == Team.MTF || component2.CurClass == RoleType.Scientist):
flag = true;
break;
}
}
}
//TeamCheck
var singleton = Respawning.RespawnTickets.Singleton;
var team = __instance.CurRole.team;
switch (team)
{
case Team.CDP when flag:
spawnRole = RoleType.NtfCadet;
break;
case Team.CDP:
case Team.RSC when flag:
spawnRole = RoleType.ChaosInsurgency;
break;
case Team.RSC:
spawnRole = RoleType.NtfScientist;
break;
}
//PlayerEscapeEvent
Events.InvokePlayerEscapeEvent(player, ref allow, ref spawnRole, cufferRole, isCuffed);
if (!allow)
{
return(false);
}
if (spawnRole == RoleType.None || spawnRole == __instance.NetworkCurClass)
{
return(false);
}
__instance.SetPlayersClass(spawnRole, __instance.gameObject, false, true);
switch (__instance.CurRole.team)
{
case Team.MTF:
RoundSummary.escaped_scientists++;
singleton.GrantTickets(Respawning.SpawnableTeamType.NineTailedFox, ConfigFile.ServerConfig.GetInt("respawn_tickets_mtf_classd_cuffed_count", 1));
break;
case Team.CHI:
RoundSummary.escaped_ds++;
singleton.GrantTickets(Respawning.SpawnableTeamType.ChaosInsurgency, ConfigFile.ServerConfig.GetInt("respawn_tickets_ci_classd_count", 1));
break;
}
return(false);
}
catch (Exception e)
{
Log.Error($"PlayerEscapeEvent Error: {e}");
return(true);
}
}
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);
}
private static bool Prefix(CharacterClassManager __instance)
{
var ev = new ExtendedEscapingEventArgs(Player.Get(__instance._hub));
EventHandlers.OnEscaping(ev); // i can do that now, neato
Exiled.Events.Handlers.Player.OnEscaping(ev);
if (!ev.IsAllowed)
{
return(false);
}
var cuffed = false;
foreach (DisarmedPlayers.DisarmedEntry entry in DisarmedPlayers.Entries.Where(entry =>
entry.DisarmedPlayer == __instance._hub.networkIdentity.netId))
{
if (entry.Disarmer == 0U)
{
cuffed = CharacterClassManager.ForceCuffedChangeTeam;
break;
}
if (ReferenceHub.TryGetHubNetID(entry.Disarmer, out ReferenceHub hub))
{
CharacterClassManager characterClassManager = hub.characterClassManager;
if (__instance.Faction == Faction.FoundationStaff &&
characterClassManager.Faction == Faction.FoundationEnemy ||
__instance.Faction == Faction.FoundationEnemy &&
characterClassManager.Faction == Faction.FoundationStaff)
{
cuffed = true;
}
}
else
{
break;
}
}
RespawnTickets singleton = RespawnTickets.Singleton;
switch (__instance.CurRole.team)
{
case Team.RSC:
if (cuffed)
{
++RoundSummary.EscapedClassD;
singleton.GrantTickets(SpawnableTeamType.ChaosInsurgency,
ConfigFile.ServerConfig.GetInt("respawn_tickets_ci_scientist_cuffed_count", 2));
__instance.GetComponent <Escape>().TargetShowEscapeMessage(__instance.connectionToClient, isClassD: false, changeTeam: true);
break;
}
++RoundSummary.EscapedScientists;
singleton.GrantTickets(SpawnableTeamType.NineTailedFox,
ConfigFile.ServerConfig.GetInt("respawn_tickets_mtf_scientist_count", 1));
__instance.GetComponent <Escape>().TargetShowEscapeMessage(__instance.connectionToClient, isClassD: false, changeTeam: false);
break;
case Team.CDP:
if (cuffed)
{
++RoundSummary.EscapedScientists;
singleton.GrantTickets(SpawnableTeamType.NineTailedFox,
ConfigFile.ServerConfig.GetInt("respawn_tickets_mtf_classd_cuffed_count", 1));
__instance.GetComponent <Escape>().TargetShowEscapeMessage(__instance.connectionToClient, isClassD: true, changeTeam: true);
break;
}
++RoundSummary.EscapedClassD;
singleton.GrantTickets(SpawnableTeamType.ChaosInsurgency,
ConfigFile.ServerConfig.GetInt("respawn_tickets_ci_classd_count", 1));
__instance.GetComponent <Escape>().TargetShowEscapeMessage(__instance.connectionToClient, isClassD: true, changeTeam: false);
break;
}
if (ev.ClearInventory)
{
ev.Player.ClearInventory();
}
ev.Player.SetRole(ev.NewRole, SpawnReason.Escaped);
return(false);
}
private void CuffPlayer()
{
Ray ray = new Ray(this.plyCam.position, this.plyCam.forward);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit, this.maxDistance, this.mask))
{
CharacterClassManager componentInParent = raycastHit.collider.GetComponentInParent <CharacterClassManager>();
if (componentInParent != null)
{
Class @class = this.ccm.klasy[componentInParent.curClass];
if (@class.team != Team.SCP && (@class.team == Team.CDP || @class.team == Team.CHI) != (this.ccm.klasy[this.ccm.curClass].team == Team.CDP || this.ccm.klasy[this.ccm.curClass].team == Team.CHI) && componentInParent.GetComponent <AnimationController>().curAnim == 0 && componentInParent.GetComponent <AnimationController>().speed == Vector2.zero)
{
this.CallCmdTarget(componentInParent.gameObject);
}
}
}
}
void ILabModUpdate.Event()
{
if (!dodgeball)
{
return;
}
PlayerManager.localPlayer.GetComponent <CharacterClassManager>().LaterJoinEnabled = false;
if (!RoundSummary.RoundLock)
{
return;
}
timer -= Time.deltaTime;
timer2 += Time.deltaTime;
if (timer > 0f)
{
return;
}
if (timer2 >= 60f)
{
foreach (var plr in PlayerManager.players)
{
NineTailedFoxAnnouncer.singleton.ServerOnlyAddGlitchyPhrase(".g7 .g7", 0.5f, 0.5f);
plr.GetComponent <Broadcast>().RpcAddElement("You all failed! Pathetic...", 100, false);
}
RoundSummary.RoundLock = false;
}
if (timer2 >= 45f && !hasGun)
{
foreach (var plr in PlayerManager.players)
{
plr.GetComponent <Broadcast>().RpcAddElement("GUNS!!!", 3, false);
plr.GetComponent <Inventory>().AddNewItem(ItemType.GunUSP);
plr.GetComponent <Inventory>().AddNewItem(ItemType.Ammo9mm);
plr.GetComponent <Inventory>().AddNewItem(ItemType.Ammo9mm);
}
hasGun = true;
}
timer = 0.5f;
int dc_c = 0;
CharacterClassManager win = null;
foreach (var plr in PlayerManager.players)
{
if (plr.GetComponent <CharacterClassManager>().NetworkCurClass == RoleType.ClassD)
{
dc_c++;
win = plr.GetComponent <CharacterClassManager>();
}
}
if (dc_c == 0)
{
foreach (var plr in PlayerManager.players)
{
NineTailedFoxAnnouncer.singleton.ServerOnlyAddGlitchyPhrase(".g7 .g7", 0.5f, 0.5f);
plr.GetComponent <Broadcast>().RpcAddElement("You all died! Pathetic...", 100, false);
}
RoundSummary.RoundLock = false;
}
if (dc_c == 1 && win != null)
{
foreach (var plr in PlayerManager.players)
{
plr.GetComponent <Broadcast>().RpcAddElement(win.GetComponent <NicknameSync>().Network_myNickSync + " won!", 100, false);
}
RoundSummary.RoundLock = false;
}
}
private static bool Prefix(CharacterClassManager __instance, bool lite = false, bool escape = false)
{
Role role = __instance.Classes.SafeGet(__instance.CurClass);
if (!__instance._wasAnytimeAlive && __instance.CurClass != RoleType.Spectator && __instance.CurClass != RoleType.None)
{
__instance._wasAnytimeAlive = true;
}
__instance.InitSCPs();
__instance.AliveTime = 0f;
switch (role.team)
{
case Team.MTF:
AchievementManager.Achieve("arescue");
break;
case Team.CHI:
AchievementManager.Achieve("chaos");
break;
case Team.RSC:
case Team.CDP:
__instance.EscapeStartTime = (int)Time.realtimeSinceStartup;
break;
}
__instance.GetComponent <Inventory>();
try
{
__instance.GetComponent <FootstepSync>().SetLoudness(role.team, role.roleId.Is939());
}
catch
{
}
if (NetworkServer.active)
{
Handcuffs component = __instance.GetComponent <Handcuffs>();
component.ClearTarget();
component.NetworkCufferId = -1;
}
if (role.team != Team.RIP)
{
if (NetworkServer.active && !lite)
{
Vector3 constantRespawnPoint = NonFacilityCompatibility.currentSceneSettings.constantRespawnPoint;
if (constantRespawnPoint != Vector3.zero)
{
__instance._pms.OnPlayerClassChange(constantRespawnPoint, 0f);
}
else
{
GameObject randomPosition = CharacterClassManager._spawnpointManager.GetRandomPosition(__instance.CurClass);
Vector3 spawnPoint;
float rotY;
if (randomPosition != null)
{
spawnPoint = randomPosition.transform.position;
rotY = randomPosition.transform.rotation.eulerAngles.y;
AmmoBox component1 = __instance.GetComponent <AmmoBox>();
if (escape && __instance.KeepItemsAfterEscaping)
{
Inventory component2 = PlayerManager.localPlayer.GetComponent <Inventory>();
for (ushort index = 0; index < 3; ++index)
{
if (component1[index] >= 15U)
{
component2.SetPickup(component1.types[index].inventoryID, component1[index], randomPosition.transform.position, randomPosition.transform.rotation, 0, 0, 0);
}
}
}
component1.ResetAmmo();
}
else
{
spawnPoint = __instance.DeathPosition;
rotY = 0f;
}
var ev = new SpawningEventArgs(API.Features.Player.Get(__instance.gameObject), __instance.CurClass, spawnPoint, rotY);
Player.OnSpawning(ev);
__instance._pms.OnPlayerClassChange(ev.Position, ev.RotationY);
}
if (!__instance.SpawnProtected && __instance.EnableSP && __instance.SProtectedTeam.Contains((int)role.team))
{
__instance.GodMode = true;
__instance.SpawnProtected = true;
__instance.ProtectedTime = Time.time;
}
}
if (!__instance.isLocalPlayer)
{
__instance.GetComponent <PlayerStats>().maxHP = role.maxHP;
}
}
__instance.Scp0492.iAm049_2 = __instance.CurClass == RoleType.Scp0492;
__instance.Scp106.iAm106 = __instance.CurClass == RoleType.Scp106;
__instance.Scp173.iAm173 = __instance.CurClass == RoleType.Scp173;
__instance.Scp939.iAm939 = __instance.CurClass.Is939();
__instance.RefreshPlyModel();
return(false);
}
public static void TeleportPlayer(Scp914Machine instance, CharacterClassManager player)
{
Vector3 b = instance.output.position - instance.intake.position;
player.GetComponent <PlyMovementSync>().OverridePosition(player.transform.position + b, 0f, false);
}
public static bool Prefix(CharacterClassManager __instance)
{
if (!PluginConfig.Cfg.Enabled)
{
return(true);
}
if (!__instance._interactRateLimit.CanExecute(true))
{
return(false);
}
if (Vector3.Distance(__instance.transform.position, __instance.GetComponent <Escape>().worldPosition) >= (float)(Escape.radius * 2))
{
return(false);
}
bool flag = false;
Handcuffs component = __instance.GetComponent <Handcuffs>();
if (component.CufferId >= 0 && ConfigFile.ServerConfig.GetBool("cuffed_escapee_change_team", true))
{
CharacterClassManager component2 = component.GetCuffer(component.CufferId).GetComponent <CharacterClassManager>();
if (__instance.CurClass == RoleType.Scientist && (component2.CurClass == RoleType.ChaosInsurgency || component2.CurClass == RoleType.ClassD))
{
flag = true;
}
if (__instance.CurClass == RoleType.ClassD && (component2.Classes.SafeGet(component2.CurClass).team == Team.MTF || component2.CurClass == RoleType.Scientist))
{
flag = true;
}
}
Team team = __instance.Classes.SafeGet(__instance.CurClass).team;
if (team == Team.CDP)
{
if (flag)
{
__instance.SetPlayersClass(RoleType.NtfCadet, __instance.gameObject, false, true);
RoundSummary.escaped_scientists++;
__instance.GetComponent <PlayerStats>().health = __instance.Classes.SafeGet(RoleType.NtfCadet).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100);
__instance.GetComponent <PlayerStats>().maxHP = Mathf.RoundToInt(__instance.Classes.SafeGet(RoleType.NtfCadet).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100));
return(false);
}
__instance.SetPlayersClass(RoleType.ChaosInsurgency, __instance.gameObject, false, true);
RoundSummary.escaped_ds++;
__instance.GetComponent <PlayerStats>().health = __instance.Classes.SafeGet(RoleType.ChaosInsurgency).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100);
__instance.GetComponent <PlayerStats>().maxHP = Mathf.RoundToInt(__instance.Classes.SafeGet(RoleType.ChaosInsurgency).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100));
return(false);
}
else if (team == Team.RSC)
{
if (flag)
{
__instance.SetPlayersClass(RoleType.ChaosInsurgency, __instance.gameObject, false, true);
RoundSummary.escaped_ds++;
__instance.GetComponent <PlayerStats>().health = __instance.Classes.SafeGet(RoleType.ChaosInsurgency).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100);
__instance.GetComponent <PlayerStats>().maxHP = Mathf.RoundToInt(__instance.Classes.SafeGet(RoleType.ChaosInsurgency).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100));
return(false);
}
__instance.SetPlayersClass(RoleType.NtfScientist, __instance.gameObject, false, true);
RoundSummary.escaped_scientists++;
__instance.GetComponent <PlayerStats>().health = __instance.Classes.SafeGet(RoleType.NtfScientist).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100);
__instance.GetComponent <PlayerStats>().maxHP = Mathf.RoundToInt(__instance.Classes.SafeGet(RoleType.NtfScientist).maxHP *((__instance.GetComponent <HealthChangedComponent>()?.ActualHealthPercentage ?? 100) / 100));
return(false);
}
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());
}
}
}
