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-");