private static bool Prefix(Scp914Machine __instance, ref bool __result, Pickup item)
{
try
{
var synapseitem = item.GetSynapseItem();
var type = Map.Get.Scp914.UpgradeItemID(synapseitem.ID);
if (type < 0)
{
synapseitem.Destroy();
__result = false;
return(false);
}
synapseitem.pickup = null;
synapseitem.Destroy();
var newitem = new SynapseItem(type, item.durability, item.weaponMods[0], item.weaponMods[1], item.weaponMods[2]);
newitem.pickup = item;
newitem.Position = newitem.pickup.transform.position;
newitem.pickup.RefreshDurability();
if (newitem.ItemType == ItemType.GunLogicer)
{
newitem.Sight = 0;
newitem.Barrel = 0;
newitem.Other = 0;
}
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Item: Scp914ItemUpgrade failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
return(false);
}
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 void ReCreateItem(Player player, SynapseItem item)
{
var newitem = new SynapseItem(item.ID);
newitem.Durabillity = item.Durabillity;
newitem.ItemData = item.ItemData;
item.Destroy();
newitem.PickUp(player);
}
private void RoundStart()
{
foreach (var point in PluginClass.Config.TranquilizerSpawns)
{
var item = new SynapseItem(PluginClass.TranquilizerID, 18, 0, 0, 0);
item.Position = point.Parse().Position;
item.Drop();
}
}
private static bool ServerAddItem(ref ItemBase __result, Inventory inv, ItemType type, ushort itemSerial, ItemPickupBase pickup)
{
try
{
__result = null;
if (inv.UserInventory.Items.Count >= 8)
{
return(false);
}
var itemBase = inv.CreateItemInstance(type, inv.isLocalPlayer);
if (itemBase == null)
{
return(false);
}
SynapseItem item;
if (itemSerial == 0)
{
itemSerial = ItemSerialGenerator.GenerateNext();
itemBase.ItemSerial = itemSerial;
item = new SynapseItem(itemBase);
}
else if (SynapseItem.AllItems.TryGetValue(itemSerial, out item))
{
item.ItemBase = itemBase;
}
else
{
Logger.Get.Warn($"Found unregistered ItemSerial: {itemSerial}");
return(false);
}
inv.UserInventory.Items[itemSerial] = itemBase;
itemBase.ItemSerial = itemSerial;
itemBase.OnAdded(pickup);
if (inv.isLocalPlayer && itemBase is IAcquisitionConfirmationTrigger trigger)
{
trigger.ServerConfirmAcqusition();
}
inv.SendItemsNextFrame = true;
__result = itemBase;
return(false);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Items: AddItem failed!!\n{e}");
return(false);
}
}
internal void InvokeMicroUse(Player player, SynapseItem micro, ref HidState state)
{
var ev = new PlayerUseMicroEventArgs
{
Player = player,
Micro = micro,
State = state,
};
PlayerUseMicroEvent?.Invoke(ev);
state = ev.State;
}
internal void InvokeChangeItem(Player player, SynapseItem old, SynapseItem newitem, out bool allow)
{
var ev = new PlayerChangeItemEventArgs
{
Player = player,
OldItem = old,
NewItem = newitem
};
PlayerChangeItemEvent?.Invoke(ev);
allow = ev.Allow;
}
internal void InvokePlayerConnectWorkstation(Player player, SynapseItem item, WorkStation station, out bool allow)
{
var ev = new PlayerConnectWorkstationEventArgs
{
Player = player,
Item = item,
WorkStation = station
};
PlayerConnectWorkstationEvent?.Invoke(ev);
allow = ev.Allow;
}
internal void InvokeThrowGrenade(Player player, SynapseItem grenade, out bool allow)
{
var ev = new PlayerThrowGrenadeEventArgs
{
Allow = true,
Item = grenade,
Player = player
};
PlayerThrowGrenadeEvent?.Invoke(ev);
allow = ev.Allow;
}
internal void InvokePlayerCuffTargetEvent(Player target, Player cuffer, SynapseItem disarmer, ref bool allow)
{
var ev = new PlayerCuffTargetEventArgs
{
Cuffer = cuffer,
Disarmer = disarmer,
Target = target,
Allow = allow
};
PlayerCuffTargetEvent?.Invoke(ev);
allow = ev.Allow;
}
internal void InvokePlayerDropAmmoEvent(Player player, SynapseItem item, ref uint amount, ref int type, out bool allow)
{
var ev = new PlayerDropAmmoEventArgs
{
Tablet = item,
AmmoType = (Enum.AmmoType)type,
Amount = amount,
Player = player
};
PlayerDropAmmoEvent?.Invoke(ev);
amount = ev.Amount;
type = (int)ev.AmmoType;
allow = ev.Allow;
}
internal void InvokeRadio(Player player, SynapseItem item, ref RadioMessages.RadioCommand interaction, RadioMessages.RadioRangeLevel current, ref RadioMessages.RadioRangeLevel next, out bool allow)
{
var ev = new PlayerRadioInteractEventArgs
{
CurrentRange = current,
Interaction = interaction,
NextRange = next,
Player = player,
Radio = item
};
PlayerRadioInteractEvent?.Invoke(ev);
allow = ev.Allow;
interaction = ev.Interaction;
next = ev.NextRange;
}
internal void InvokePlayerThrowGrenadeEvent(Player player, SynapseItem item, ref GrenadeSettings settings, ref float force, ref float delay, ref bool allow)
{
var ev = new PlayerThrowGrenadeEventArgs
{
Player = player,
Item = item,
ForceMultiplier = force,
Delay = delay,
Allow = allow,
Settings = settings,
};
PlayerThrowGrenadeEvent?.Invoke(ev);
force = ev.ForceMultiplier;
delay = ev.Delay;
allow = ev.Allow;
}
private static bool ServerCreatePickupPatch(ref ItemPickupBase __result, Inventory inv, ItemBase item, PickupSyncInfo psi, bool spawn = true)
{
try
{
__result = null;
if (item == null)
{
return(false);
}
var pickup = UnityEngine.Object.Instantiate(item.PickupDropModel, inv.transform.position,
ReferenceHub.GetHub(inv.gameObject).PlayerCameraReference.rotation *
item.PickupDropModel.transform.rotation);
//The Value to the Serial can also be null but every Serial should be as key inside AllItems
if (!SynapseItem.AllItems.TryGetValue(psi.Serial, out var sitem))
{
Logger.Get.Warn($"Found unregistered ItemSerial in PickupSyncInfo (CreatePickupPatch): {psi.Serial}");
psi.Serial = ItemSerialGenerator.GenerateNext();
}
pickup.NetworkInfo = psi;
pickup.Info = psi;
if (sitem == null)
{
sitem = new SynapseItem(pickup);
}
else
{
sitem.PickupBase = pickup;
}
pickup.transform.localScale = sitem.Scale;
if (spawn)
{
NetworkServer.Spawn(pickup.gameObject);
}
sitem.CheckForSchematic();
pickup.InfoReceived(default, psi);
public static SynapseItem GetSynapseItem(this ItemPickupBase pickupbase)
{
//If the List doesn't even contain the Serial then it is destroyed or a item with this ID was never spawned
if (!SynapseItem.AllItems.ContainsKey(pickupbase.Info.Serial))
{
return(null);
}
var item = SynapseItem.GetSynapseItem(pickupbase.Info.Serial);
//This is a simple fallback if the item is not registered
if (item == null)
{
Synapse.Api.Logger.Get.Warn($"Found unregistered ItemPickup with Serial: {pickupbase.Info.Serial}");
return(new SynapseItem(pickupbase));
}
return(item);
}
private static bool Prefix(Scp914Machine __instance, Inventory inventory, CharacterClassManager player, IEnumerable <CharacterClassManager> players)
{
try
{
if (inventory.curItem == ItemType.None)
{
return(false);
}
var splayer = inventory.GetPlayer();
var type = Map.Get.Scp914.UpgradeItemID(splayer.ItemInHand.ID);
var index = inventory.GetItemIndex();
if (index < 0 || index >= inventory.items.Count)
{
return(false);
}
if (type < 0)
{
splayer.ItemInHand.Destroy();
return(false);
}
var item = splayer.ItemInHand;
var newitem = new SynapseItem(type, item.Durabillity, item.Sight, item.Barrel, item.Other);
if (newitem.ItemType == ItemType.GunLogicer)
{
newitem.Barrel = 0;
newitem.Sight = 0;
newitem.Other = 0;
}
item.Destroy();
newitem.PickUp(splayer);
Scp914Machine.TryFriendshipAchievement(newitem.ItemType, player, players);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: Scp914HeldItemUpgrade failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
return(false);
}
public void Spawn035Item()
{
RemoveScp035Items();
if (Server.Get.GetPlayers(x => x.RoleID == (int)RoleType.Spectator && !x.OverWatch).Count < 1)
{
return;
}
for (int i = PluginClass.Config.Scp035ItemsAmount - Map.Get.Items.Where(x => IsScp035Item(x)).Count(); i > 0; i--)
{
if (PluginClass.Config.Possible035Items.Count < 1)
{
return;
}
var type = PluginClass.Config.Possible035Items.ElementAt(UnityEngine.Random.Range(0, PluginClass.Config.Possible035Items.Count));
var items = Map.Get.Items.Where(x => x.State == Synapse.Api.Enum.ItemState.Map);
var pos = items.ElementAt(UnityEngine.Random.Range(0, items.Count())).Position;
var item = new SynapseItem(type + 100);
item.Drop(pos);
}
}
private static bool OnSetClass(ref RoleType classid, GameObject ply, CharacterClassManager.SpawnReason spawnReason, out Player __state)
{
__state = null;
try
{
var player = ply.GetPlayer();
__state = player;
if (player.Hub.isDedicatedServer || !player.Hub.Ready)
{
return(false);
}
//Initialise eventargs
var eventargs = new PlayerSetClassEventArgs
{
Allow = true,
Player = player,
Role = classid,
SpawnReason = spawnReason,
EscapeItems = new List <SynapseItem>(),
Position = Vector3.zero,
Rotation = 0f,
Items = new List <SynapseItem>(),
Ammo = new Dictionary <AmmoType, ushort>(),
};
//Set EscapeItems if the Player is escaping
if (eventargs.IsEscaping)
{
eventargs.EscapeItems = player.Inventory.Items;
}
//Find the Position and Rotation if the player becomes a living Role
if (classid != RoleType.Spectator && classid != RoleType.None)
{
var randomPosition = SpawnpointManager.GetRandomPosition(classid);
if (Map.Get.RespawnPoint != Vector3.zero)
{
eventargs.Position = Map.Get.RespawnPoint;
}
else if (randomPosition != null)
{
eventargs.Position = randomPosition.transform.position;
eventargs.Rotation = randomPosition.transform.rotation.eulerAngles.y;
}
else
{
eventargs.Position = player.ClassManager.DeathPosition;
}
}
//Find and create the Items that the Player should spawn with
if (InventorySystem.Configs.StartingInventories.DefinedInventories.TryGetValue(classid, out var roleitems))
{
foreach (var ammo in roleitems.Ammo)
{
eventargs.Ammo[(AmmoType)ammo.Key] = ammo.Value;
}
foreach (var itemtype in roleitems.Items)
{
var item = new SynapseItem(itemtype);
item.ItemData["setup"] = true;
eventargs.Items.Add(item);
}
}
Server.Get.Events.Player.InvokeSetClassEvent(eventargs);
classid = eventargs.Role;
if (eventargs.Allow)
{
player.setClassEventArgs = eventargs;
}
return(eventargs.Allow);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass(SetPlayersClass) failed!!\n{e}");
return(true);
}
}
internal void InvokePlayerShootEvent(Player player, Player target, Vector3 targetpos, SynapseItem weapon, out bool allow)
{
var ev = new PlayerShootEventArgs
{
Player = player,
Allow = true,
Target = target,
TargetPosition = targetpos,
Weapon = weapon,
};
PlayerShootEvent?.Invoke(ev);
allow = ev.Allow;
}
private static bool Prefix(CharacterClassManager __instance, ref PlayerSetClassEventArgs __state, ref RoleType classid, GameObject ply, ref bool escape, bool lite)
{
try
{
if (!NetworkServer.active || ply == null)
{
return(false);
}
var player = ply.GetPlayer();
if (player.Hub.isDedicatedServer || !player.Hub.Ready)
{
return(false);
}
__state = new PlayerSetClassEventArgs
{
EscapeItems = new List <SynapseItem>(),
IsEscaping = escape,
Allow = true,
Player = player,
Role = classid,
Items = new List <SynapseItem>(),
Position = Vector3.zero,
Rotation = 0f
};
if (escape && CharacterClassManager.KeepItemsAfterEscaping && !lite)
{
__state.EscapeItems = player.Inventory.Items;
}
if (!lite)
{
foreach (var id in __instance.Classes.SafeGet(classid).startItems)
{
var synapseitem = new SynapseItem(id, 0, 0, 0, 0);
var item = new Item(player.VanillaInventory.GetItemByID(id));
synapseitem.Durabillity = item.durability;
for (int i = 0; i < player.VanillaInventory._weaponManager.weapons.Length; i++)
{
if (player.VanillaInventory._weaponManager.weapons[i].inventoryID == id)
{
synapseitem.Sight = player.VanillaInventory._weaponManager.modPreferences[i, 0];
synapseitem.Barrel = player.VanillaInventory._weaponManager.modPreferences[i, 1];
synapseitem.Other = player.VanillaInventory._weaponManager.modPreferences[i, 2];
}
}
__state.Items.Add(synapseitem);
}
}
if (__instance.Classes.SafeGet(classid).team != Team.RIP)
{
if (lite)
{
__state.Position = player.Position;
}
else
{
if (Synapse.Api.Map.Get.RespawnPoint != Vector3.zero)
{
__state.Position = Synapse.Api.Map.Get.RespawnPoint;
}
else
{
var randomPosition = CharacterClassManager._spawnpointManager.GetRandomPosition(classid);
if (randomPosition != null)
{
__state.Position = randomPosition.transform.position;
__state.Rotation = randomPosition.transform.rotation.eulerAngles.y;
}
else
{
__state.Position = player.DeathPosition;
}
}
}
}
try
{
Server.Get.Events.Player.InvokeSetClassEvent(__state);
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass failed!!\n{e}\nStackTrace:\n{e.StackTrace}");
}
if (!__state.Allow)
{
return(false);
}
classid = __state.Role;
foreach (var item in __state.EscapeItems)
{
item.Despawn();
}
//WHY THE F**K DOES SCP NOT USE THEIR OWN METHODS TO CLEAR THE INVENTORY THAT I ALREADY PATCHED?
player.Inventory.Clear();
player.spawnPosition = __state.Position;
player.spawnRotation = __state.Rotation;
}
catch (Exception e)
{
Logger.Get.Error($"Synapse-Event: PlayerSetClass Prefix 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);
}
}
public SerializedPlayerItem(SynapseItem item, short chance, bool preference)
: this(item.ID, item.Durabillity, item.WeaponAttachments, item.Scale, chance, preference)
{
}
public SerializedItem(SynapseItem item)
: this(item.ID, item.Durabillity, item.WeaponAttachments, item.Scale)
{
}
private bool IsScp035Item(SynapseItem item) => item != null && item.Name.Contains("Scp035-Item-");
