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);
}
public static bool Prefix(Scp914Machine __instance)
{
try
{
Better914Config Config = Better914Plugin.instance.Config;
if (!Config.IsEnabled && !Config.UseNewRecipeSystem)
{
return(false);
}
if (!NetworkServer.active)
{
return(true);
}
__instance.players.Clear();
__instance.items.Clear();
foreach (var collider in Physics.OverlapBox(__instance.intake.position, __instance.inputSize / 2f))
{
if (collider.GetComponent <CharacterClassManager>() is CharacterClassManager ccm)
{
__instance.players.Add(ccm);
}
if (collider.GetComponent <Pickup>() is Pickup pickup)
{
__instance.items.Add(pickup);
}
}
return(Upgrade(__instance));
}
catch (System.Exception ex)
{
Log.Error(ex.ToString());
return(true);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UpgradingItemsEventArgs"/> class.
/// </summary>
/// <param name="scp914"><inheritdoc cref="Scp914"/></param>
/// <param name="players"><inheritdoc cref="Players"/></param>
/// <param name="items"><inheritdoc cref="Items"/></param>
/// <param name="knobSetting"><inheritdoc cref="KnobSetting"/></param>
/// <param name="isAllowed"><inheritdoc cref="IsAllowed"/></param>
public UpgradingItemsEventArgs(Scp914Machine scp914, List <Player> players, List <Pickup> items, Scp914Knob knobSetting, bool isAllowed = true)
{
Scp914 = scp914;
Players = players;
Items = items;
KnobSetting = knobSetting;
IsAllowed = isAllowed;
}
public static bool Upgrade(Scp914Machine instance)
{
if (!NetworkServer.active)
{
return(true);
}
UpgradeItems(instance.items);
return(false);
}
public static void UpgradeItem(Scp914Machine instance, Pickup pickup, bool dropped)
{
var selectedItem = GetItem(instance.knobState, pickup.ItemId);
if (selectedItem < 0)
{
pickup.Delete();
return;
}
pickup.SetIDFull(selectedItem);
if (dropped)
{
Vector3 b = instance.output.position - instance.intake.position;
pickup.transform.position += b;
}
}
public static bool Prefix(Scp914Machine __instance)
{
try
{
if (!PluginConfig.Cfg.Enabled)
{
return(true);
}
if (!PluginConfig.Cfg.UseNewRecipeSystem)
{
return(true);
}
if (!NetworkServer.active)
{
return(false);
}
Collider[] array = Physics.OverlapBox(__instance.intake.position, __instance.inputSize / 2f);
__instance.players.Clear();
__instance.items.Clear();
foreach (var collider in array)
{
var ccm = collider.GetComponent <CharacterClassManager>();
if (ccm != null)
{
__instance.players.Add(ccm);
}
else
{
var pickup = collider.GetComponent <Pickup>();
if (pickup != null)
{
__instance.items.Add(pickup);
}
}
}
return(Upgrade(__instance, __instance.items, __instance.players));
}
catch (Exception ex)
{
Log.Error(ex.ToString());
return(true);
}
}
public static void TrySwitchPlayers(Scp914Machine instance, List <CharacterClassManager> players)
{
if (instance.knobState == Scp914Knob.OneToOne)
{
if (players.Count < 2)
{
return;
}
if (CheckPercent(PluginConfig.Cfg.SwapRoleChance))
{
var player = players[Random.Range(0, players.Count - 1)];
var player2 = SelectDifferentRole(player, players.Except(new CharacterClassManager[] { player }));
var posTemp = player.transform.position;
var roleTemp = player.CurClass;
SetClass(player, player2.CurClass, player2.transform.position);
SetClass(player2, roleTemp, posTemp);
}
}
}
private static bool Prefix(Scp914Machine __instance)
{
if (!NetworkServer.active)
{
return(true);
}
Collider[] colliderArray = Physics.OverlapBox(__instance.intake.position, __instance.inputSize / 2f);
__instance.players.Clear();
__instance.items.Clear();
foreach (Collider collider in colliderArray)
{
CharacterClassManager component1 = collider.GetComponent <CharacterClassManager>();
if (component1 != null)
{
__instance.players.Add(component1);
}
else
{
Pickup component2 = collider.GetComponent <Pickup>();
if (component2 != null)
{
__instance.items.Add(component2);
}
}
}
var ev = new UpgradingItemsEventArgs(__instance, __instance.players.Select(player => API.Features.Player.Get(player.gameObject)).ToList(), __instance.items, __instance.knobState);
Scp914.OnUpgradingItems(ev);
var players = ev.Players.Select(player => player.ReferenceHub.characterClassManager).ToList();
__instance.MoveObjects(ev.Items, players);
if (ev.IsAllowed)
{
__instance.UpgradeObjects(ev.Items, players);
}
return(false);
}
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 static bool Upgrade(Scp914Machine instance, IEnumerable <Pickup> items, IEnumerable <CharacterClassManager> players)
{
if (!NetworkServer.active)
{
return(true);
}
foreach (var pickup in items)
{
UpgradeItem(instance, pickup, true);
Scp914Machine.TryFriendshipAchievement(pickup.ItemId, pickup.info.ownerPlayer.GetComponent <CharacterClassManager>(), players);
}
TrySwitchPlayers(instance, players.ToList());
foreach (var ccm in players)
{
UpgradePlayer(instance, ccm, players);
}
return(false);
}
public static bool Prefix(Scp914Machine __instance)
{
if (!PluginConfig.Cfg.Enabled)
{
return(true);
}
if (!PluginConfig.Cfg.CanChangeKnobWhileWorking && __instance.working || Math.Abs(__instance.curKnobCooldown) > 0.001f)
{
return(false);
}
//if (Plugin.KnobBlockade) return false;
__instance.curKnobCooldown = __instance.knobCooldown;
Scp914Knob knob = __instance.knobState + 1;
if (knob > Scp914Machine.knobStateMax)
{
knob = Scp914Machine.knobStateMin;
}
__instance.NetworkknobState = knob;
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 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);
}
/// <summary>
/// Initializes a new instance of the <see cref="UpgradingEventArgs"/> class.
/// </summary>
/// <param name="item"><inheritdoc cref="Item"/></param>
/// <param name="scp914"><inheritdoc cref="UpgradingItemsEventArgs.Scp914"/></param>
/// <param name="players"><inheritdoc cref="UpgradingItemsEventArgs.Players"/></param>
/// <param name="items"><inheritdoc cref="UpgradingItemsEventArgs.Items"/></param>
/// <param name="knobSetting"><inheritdoc cref="UpgradingItemsEventArgs.KnobSetting"/></param>
/// <param name="isAllowed"><inheritdoc cref="UpgradingItemsEventArgs.IsAllowed"/></param>
public UpgradingEventArgs(Inventory.SyncItemInfo item, Scp914Machine scp914, List <Player> players, List <Pickup> items, Scp914Knob knobSetting, bool isAllowed = true)
: base(scp914, players, items, knobSetting, isAllowed)
{
Item = item;
}
