private static bool SetClass(CharacterClassManager __instance, RoleType id)
{
var player = __instance.GetPlayer();
__instance.SetClassIDAdv(id, player.LiteRoleSet, CharacterClassManager.SpawnReason.None, true);
return(false);
}
private static bool Prefix(WeaponManager __instance, out bool __result, CharacterClassManager c, bool forceFriendlyFire = false)
{
try
{
var shooter = __instance.GetPlayer();
var target = c.GetPlayer();
__result = true;
if (shooter.CustomRole == null && target.CustomRole == null)
{
if (shooter.Team == Team.SCP && target.Team == Team.SCP)
{
__result = false;
}
var ff = Server.Get.FF;
if (forceFriendlyFire)
{
ff = true;
}
else if (!ff)
{
__result = Misc.GetFraction(shooter.Team) != Misc.GetFraction(target.Team);
}
}
else
{
if (shooter.CustomRole != null)
{
if (shooter.CustomRole.GetFriends().Any(x => x == target.RealTeam))
{
__result = false;
shooter.GiveTextHint(Server.Get.Configs.SynapseTranslation.GetTranslation("sameteam"));
}
}
if (target.CustomRole != null)
{
if (target.CustomRole.GetFriends().Any(x => x == shooter.RealTeam))
{
__result = false;
shooter.GiveTextHint(Server.Get.Configs.SynapseTranslation.GetTranslation("sameteam"));
}
}
}
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-API: GetShootPermission failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
__result = true;
return(true);
}
}
public static bool Prefix(CharacterClassManager __instance)
{
try
{
if (!NetworkServer.active)
{
return(false);
}
if (!NonFacilityCompatibility.currentSceneSettings.enableStandardGamplayItems)
{
return(false);
}
foreach (var gameObject in PlayerManager.players)
{
if (!(Vector3.Distance(gameObject.transform.position, __instance._lureSpj.transform.position) <
1.97f))
{
continue;
}
var component = gameObject.GetComponent <CharacterClassManager>();
var component2 = gameObject.GetComponent <PlayerStats>();
if (component.CurClass == RoleType.Spectator || component.GodMode)
{
continue;
}
var allow = component.CurRole.team != Team.SCP;
var closeFemur = FemurBrokePeople + 1 >= SynapseConfigs.RequiredForFemur;
var player = __instance.GetPlayer();
Events.InvokeFemurEnterEvent(player, ref allow, ref closeFemur);
if (!allow)
{
return(false);
}
component2.HurtPlayer(new PlayerStats.HitInfo(10000f, "WORLD", DamageTypes.Lure, 0), gameObject);
FemurBrokePeople++;
if (closeFemur)
{
__instance._lureSpj.SetState(true);
}
}
return(false);
}
catch (Exception e)
{
Log.Error($"FemurEnterEvent Error: {e}");
return(true);
}
}
public static bool Prefix(CharacterClassManager __instance)
{
try
{
Events.InvokePlayerTagEvent(__instance.GetPlayer(), true, out var allow);
return(allow);
}
catch (Exception e)
{
Log.Error($"PlayerTagEvent Error: {e}");
return(true);
}
}
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);
}
}
private static bool Prefix(CharacterClassManager __instance, bool lite, bool escape)
{
try
{
var player = __instance.GetPlayer();
var curRole = __instance.CurRole;
if (!__instance._wasAnytimeAlive && player.RoleType != RoleType.Spectator && player.RoleType != RoleType.None)
{
__instance._wasAnytimeAlive = true;
}
__instance.InitSCPs();
__instance.AliveTime = 0f;
if (player.Team - Team.RSC <= 1)
{
__instance.EscapeStartTime = (int)Time.realtimeSinceStartup;
}
try
{
__instance._hub.footstepSync.SetLoudness(curRole.team, curRole.roleId.Is939());
}
catch
{
}
if (NetworkServer.active)
{
player.Handcuffs.ClearTarget();
player.Handcuffs.NetworkCufferId = -1;
player.Handcuffs.NetworkForceCuff = false;
if (curRole.roleId != RoleType.Spectator &&
Respawning.RespawnManager.CurrentSequence() != Respawning.RespawnManager.RespawnSequencePhase.SpawningSelectedTeam &&
Respawning.NamingRules.UnitNamingManager.RolesWithEnforcedDefaultName.TryGetValue(curRole.roleId, out var spawnableTeamType) &&
Respawning.RespawnManager.Singleton.NamingManager.TryGetAllNamesFromGroup((byte)spawnableTeamType, out var array) &&
array.Length != 0)
{
__instance.NetworkCurSpawnableTeamType = (byte)spawnableTeamType;
__instance.NetworkCurUnitName = array[0];
}
else if (__instance.CurSpawnableTeamType != 0)
{
__instance.NetworkCurSpawnableTeamType = 0;
__instance.NetworkCurUnitName = string.Empty;
}
}
if (player.Team != Team.RIP)
{
if (NetworkServer.active && !lite)
{
player.PlayerMovementSync.OnPlayerClassChange(player.spawnPosition, player.spawnRotation);
player.PlayerMovementSync.IsAFK = true;
if (escape && CharacterClassManager.KeepItemsAfterEscaping)
{
for (var num = 0; num < 3; num++)
{
if (player.AmmoBox[num] >= 15)
{
var item = new SynapseItem(player.AmmoBox.types[num].inventoryID, player.AmmoBox[num], 0, 0, 0);
item.Drop(player.spawnPosition);
}
}
}
player.AmmoBox.ResetAmmo();
if (!__instance.SpawnProtected && CharacterClassManager.EnableSP && CharacterClassManager.SProtectedTeam.Contains((int)curRole.team))
{
__instance.GodMode = true;
__instance.SpawnProtected = true;
__instance.ProtectedTime = Time.time;
}
}
if (!__instance.isLocalPlayer)
{
player.MaxHealth = curRole.maxHP;
}
}
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass(position) failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
return(true);
}
}
private static void RemoveArgs(CharacterClassManager __instance) => __instance.GetPlayer().setClassEventArgs = null;
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);
}
}
