private static bool ProcessDamage(AttackerDamageHandler __instance, ReferenceHub ply)
{
try
{
var curClass = ply.characterClassManager.CurClass;
if (__instance.CheckSpawnProtection(__instance.Attacker.Hub, ply))
{
__instance.Damage = 0f;
return(false);
}
if (ply.networkIdentity.netId == __instance.Attacker.NetId || __instance.ForceFullFriendlyFire)
{
if (!__instance.AllowSelfDamage && !__instance.ForceFullFriendlyFire)
{
__instance.Damage = 0f;
return(false);
}
__instance.IsSuicide = true;
}
else if (!HitboxIdentity.CheckFriendlyFire(__instance.Attacker.Hub, ply))
{
__instance.Damage *= AttackerDamageHandler._ffMultiplier;
__instance.IsFriendlyFire = true;
}
return(false);
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: ProcessDamage failed!!\n{ex}");
return(true);
}
}
static private void AimAt(UnityEngine.GameObject target, UnityEngine.GameObject lp)
{
var ccm = target.GetComponent <CharacterClassManager>();
if (ccm && ccm.curClass != 2)
{
var weapon = lp.GetComponent <WeaponManager>();
UnityEngine.Vector3 localEulerAngles2 = UnityEngine.Camera.main.transform.localEulerAngles;
UnityEngine.Vector3 localPosition = UnityEngine.Camera.main.transform.localPosition;
var at = target.transform.position;
UnityEngine.Camera.main.transform.LookAt(at);
UnityEngine.RaycastHit raycastHit;
UnityEngine.Physics.Raycast(new UnityEngine.Ray(UnityEngine.Camera.main.transform.position, UnityEngine.Camera.main.transform.forward), out raycastHit, 10000f, weapon.raycastMask);
if (raycastHit.collider != null)
{
HitboxIdentity hitboxIdentity = raycastHit.collider.GetComponent <HitboxIdentity>();
if (hitboxIdentity == null)
{
hitboxIdentity = raycastHit.collider.gameObject.AddComponent <HitboxIdentity>();
}
hitboxIdentity.id = "HEAD";
}
try
{
weapon.GetType().GetMethod("Shoot", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(weapon, new object[0]);
}
catch
{
}
UnityEngine.Camera.main.transform.localPosition = localPosition;
UnityEngine.Camera.main.transform.localEulerAngles = localEulerAngles2;
}
}
private void Shoot()
{
if (this.curWeapon != -1 && this.curItem != -1 && this.inv.items[this.curItem].durability > 0f)
{
this.CallCmdDoAnimation("Shoot");
this.weapons[this.curWeapon].cooldown = 1f / this.weapons[this.curWeapon].fireRate;
this.weapons[this.curWeapon].model.SetTrigger("Shoot");
this.weapons[this.curWeapon].model.GetComponent <AudioSource>().PlayOneShot(this.weapons[this.curWeapon].shootAudio);
foreach (ParticleSystem particleSystem in this.weapons[this.curWeapon].shotGFX)
{
particleSystem.Play();
}
this.SetCurRecoil(UnityEngine.Random.Range(1f, 1.5f) * this.weapons[this.curWeapon].recoilScale * this.classRecoil, this.weapons[this.curWeapon].recoilScale * this.classRecoil * (float)UnityEngine.Random.Range(-1, 1));
Ray ray = new Ray(this.plyCam.transform.position, this.plyCam.transform.forward);
RaycastHit raycastHit;
if (Physics.Raycast(ray, out raycastHit, 10000f, this.mask))
{
float num = this.weapons[this.curWeapon].damageOverDistance.Evaluate(raycastHit.distance);
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component == null)
{
this.CallCmdShoot(string.Empty, null, raycastHit.point, raycastHit.normal, raycastHit.transform.name);
}
else
{
CharacterClassManager componentInParent = component.GetComponentInParent <CharacterClassManager>();
this.CallCmdShoot(component.id, componentInParent.gameObject, raycastHit.point, raycastHit.normal, raycastHit.transform.name);
if (this.GetShootPermission(componentInParent))
{
Hitmarker.Hit(this.weapons[this.curWeapon].hitmarkerResizer);
}
}
}
}
else
{
if (this.weapons[this.curWeapon].ammoAudio != null && this.weapons[this.curWeapon].cooldown <= 0f)
{
this.weapons[this.curWeapon].cooldown = 1f / this.weapons[this.curWeapon].fireRate;
this.weapons[this.curWeapon].model.GetComponent <AudioSource>().PlayOneShot(this.weapons[this.curWeapon].ammoAudio);
}
if (TutorialManager.status && this.ammoBox.GetAmmo(this.weapons[this.curWeapon].ammoType) == 0)
{
NoammoTrigger[] array = UnityEngine.Object.FindObjectsOfType <NoammoTrigger>();
NoammoTrigger noammoTrigger = null;
foreach (NoammoTrigger noammoTrigger2 in array)
{
if (noammoTrigger == null || noammoTrigger2.prioirty < noammoTrigger.prioirty)
{
noammoTrigger = noammoTrigger2;
}
}
if (noammoTrigger != null)
{
noammoTrigger.Trigger(this.curWeapon);
}
}
}
}
private static void ProcessPlayers(FlashbangGrenade grenade, List <Player> players)
{
foreach (Player player in players)
{
if (HitboxIdentity.CheckFriendlyFire(grenade.PreviousOwner.Role, player.ReferenceHub.characterClassManager.CurClass))
{
grenade.ProcessPlayer(player.ReferenceHub);
}
}
}
private static bool ExplodeDestructible(ExplosionGrenade __instance, IDestructible dest, Footprinting.Footprint attacker, Vector3 pos, ExplosionGrenade setts, out bool __result)
{
__result = false;
try
{
if (Physics.Linecast(dest.CenterOfMass, pos, InventorySystem.Items.MicroHID.MicroHIDItem.WallMask))
{
return(false);
}
Vector3 a = dest.CenterOfMass - pos;
float magnitude = a.magnitude;
float num = setts._playerDamageOverDistance.Evaluate(magnitude);
ReferenceHub referenceHub;
bool flag = ReferenceHub.TryGetHubNetID(dest.NetworkId, out referenceHub);
if (flag && referenceHub.characterClassManager.CurRole.team == Team.SCP)
{
num *= setts._scpDamageMultiplier;
}
Vector3 force = (1f - magnitude / setts._maxRadius) * (a / magnitude) * setts._rigidbodyLiftForce + Vector3.up * setts._rigidbodyLiftForce;
if (num > 0f && dest.Damage(num, new PlayerStatsSystem.ExplosionDamageHandler(attacker, force, num, 50), dest.CenterOfMass) && flag)
{
float num2 = setts._effectDurationOverDistance.Evaluate(magnitude);
bool flag2 = attacker.Hub == referenceHub;
if (num2 > 0f && (flag2 || HitboxIdentity.CheckFriendlyFire(attacker.Hub, referenceHub, false)))
{
float minimalDuration = setts._minimalDuration;
ExplosionGrenade.TriggerEffect <CustomPlayerEffects.Burned>(referenceHub, num2 * setts._burnedDuration, minimalDuration);
ExplosionGrenade.TriggerEffect <CustomPlayerEffects.Deafened>(referenceHub, num2 * setts._deafenedDuration, minimalDuration);
ExplosionGrenade.TriggerEffect <CustomPlayerEffects.Concussed>(referenceHub, num2 * setts._concussedDuration, minimalDuration);
}
if (!flag2 && attacker.Hub != null)
{
Hitmarker.SendHitmarker(attacker.Hub, 1f);
}
referenceHub.inventory.connectionToClient.Send(new GunHitMessage(false, num, pos), 0);
}
__result = true;
return(false);
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: ExplodeDestructible failed!!\n{ex}");
return(true);
}
}
private static float HitHandler(HitboxIdentity box)
{
switch (box.id)
{
case HitBoxType.HEAD:
return(Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.BaseDamage * 1.25f);
case HitBoxType.LEG:
return(Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.BaseDamage * 0.65f);
case HitBoxType.ARM:
return(Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.BaseDamage * 0.55f);
default:
return(Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.BaseDamage);
}
}
private float HitHandler(HitboxIdentity hitbox)
{
switch (hitbox?.id.ToUpper())
{
case "HEAD":
return(HmdPlugin.HeadDamage);
case "LEG":
return(HmdPlugin.LegDamage);
// left here but probably unused / not the right string
case "SCP106":
return(HmdPlugin.Scp106Damage);
default:
return(HmdPlugin.BodyDamage);
}
}
private static bool OnDamage(HitboxIdentity __instance, DamageHandlerBase handler)
{
try
{
if (handler is AttackerDamageHandler ahandler)
{
var ply = __instance.TargetHub.GetPlayer();
var attacker = ahandler.Attacker.GetPlayer();
Logger.Get.Debug($"{ply == null} - {attacker == null}");
return(SynapseExtensions.GetHarmPermission(attacker, ply));
}
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: PlayerDamage failed!!\n{ex}");
}
return(true);
}
private static bool Prefix(WeaponManager __instance, GameObject target, HitBoxType hitboxType, Vector3 dir, Vector3 sourcePos, Vector3 targetPos)
{
try
{
bool npc = Npc.Dictionary.ContainsKey(__instance.gameObject);
if (!__instance._iawRateLimit.CanExecute(true))
{
return(false);
}
int itemIndex = __instance._hub.inventory.GetItemIndex();
if (!npc)
{
if (itemIndex < 0 ||
itemIndex >= __instance._hub.inventory.items.Count ||
__instance.curWeapon < 0 ||
__instance._hub.inventory.curItem != __instance.weapons[__instance.curWeapon].inventoryID ||
__instance._hub.inventory.items[itemIndex].durability <= 0.0)
{
return(false);
}
if (Vector3.Distance(__instance._hub.playerMovementSync.RealModelPosition, sourcePos) > 5.5f)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.6 (difference between real source position and provided source position is too big)", "gray");
return(false);
}
if (sourcePos.y - __instance._hub.playerMovementSync.LastSafePosition.y > 1.78f)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.7 (Y axis difference between last safe position and provided source position is too big)", "gray");
return(false);
}
if (Math.Abs(sourcePos.y - __instance._hub.playerMovementSync.RealModelPosition.y) > 2.7f)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.8 (|Y| axis difference between real position and provided source position is too big)", "gray");
return(false);
}
}
if ((__instance._reloadCooldown > 0f || __instance._fireCooldown > 0f) && !__instance.isLocalPlayer)
{
return(false);
}
Log.Debug("Invoking shooting event", Loader.ShouldDebugBeShown);
var shootingEventArgs = new ShootingEventArgs(Player.Get(__instance.gameObject), target, targetPos);
Exiled.Events.Handlers.Player.OnShooting(shootingEventArgs);
if (!shootingEventArgs.IsAllowed)
{
return(false);
}
targetPos = shootingEventArgs.Position;
// <Exiled
if (!npc)
{
__instance._hub.inventory.items.ModifyDuration(itemIndex, __instance._hub.inventory.items[itemIndex].durability - 1f);
}
__instance.scp268.ServerDisable();
__instance._fireCooldown = 1f / (__instance.weapons[__instance.curWeapon].shotsPerSecond * __instance.weapons[__instance.curWeapon].allEffects.firerateMultiplier) * 0.9f;
float sourceRangeScale = __instance.weapons[__instance.curWeapon].allEffects.audioSourceRangeScale;
sourceRangeScale = sourceRangeScale * sourceRangeScale * 70f;
__instance.GetComponent <Scp939_VisionController>().MakeNoise(Mathf.Clamp(sourceRangeScale, 5f, 100f));
bool flag = target != null;
if (targetPos == Vector3.zero)
{
if (Physics.Raycast(sourcePos, dir, out RaycastHit raycastHit, 500f, __instance.raycastMask))
{
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component != null)
{
WeaponManager componentInParent = component.GetComponentInParent <WeaponManager>();
if (componentInParent != null)
{
flag = false;
target = componentInParent.gameObject;
hitboxType = component.id;
targetPos = componentInParent.transform.position;
}
}
}
}
else if (Physics.Linecast(sourcePos, targetPos, out RaycastHit raycastHit, __instance.raycastMask))
{
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component != null)
{
WeaponManager componentInParent = component.GetComponentInParent <WeaponManager>();
if (componentInParent != null)
{
if (componentInParent.gameObject == target)
{
flag = false;
}
else if (componentInParent.scp268.Enabled)
{
flag = false;
target = componentInParent.gameObject;
hitboxType = component.id;
targetPos = componentInParent.transform.position;
}
}
}
}
ReferenceHub referenceHub = null;
if (target != null)
{
referenceHub = ReferenceHub.GetHub(target);
}
if (referenceHub != null && __instance.GetShootPermission(referenceHub.characterClassManager, false))
{
if (!npc)
{
if (Math.Abs(__instance._hub.playerMovementSync.RealModelPosition.y - referenceHub.playerMovementSync.RealModelPosition.y) > 35f)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.1 (too big Y-axis difference between source and target)", "gray");
return(false);
}
if (Vector3.Distance(referenceHub.playerMovementSync.RealModelPosition, targetPos) > 5f)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.2 (difference between real target position and provided target position is too big)", "gray");
return(false);
}
if (Physics.Linecast(__instance._hub.playerMovementSync.RealModelPosition, sourcePos, __instance.raycastServerMask))
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.3 (collision between source positions detected)", "gray");
return(false);
}
if (flag && Physics.Linecast(sourcePos, targetPos, __instance.raycastServerMask))
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.4 (collision on shot line detected)", "gray");
return(false);
}
if (referenceHub.gameObject == __instance.gameObject)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.5 (target is itself)", "gray");
return(false);
}
Vector3 positionOffset = referenceHub.playerMovementSync.RealModelPosition - __instance._hub.playerMovementSync.RealModelPosition;
float sqrMagnitude = positionOffset.sqrMagnitude;
if (Math.Abs(positionOffset.y) < 10f && sqrMagnitude > 7.84f && (referenceHub.characterClassManager.CurClass != global::RoleType.Scp0492 || sqrMagnitude > 9f) && ((referenceHub.characterClassManager.CurClass != global::RoleType.Scp93953 && referenceHub.characterClassManager.CurClass != global::RoleType.Scp93989) || sqrMagnitude > 18.49f))
{
float angl = Math.Abs(global::Misc.AngleIgnoreY(positionOffset, __instance.transform.forward));
if (angl > 45f)
{
__instance.GetComponent <global::CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.12 (too big angle)", "gray");
return(false);
}
if (__instance._lastAngleReset > 0f && angl > 25f && Math.Abs(global::Misc.AngleIgnoreY(positionOffset, __instance._lastAngle)) > 60f)
{
__instance._lastAngle = positionOffset;
__instance._lastAngleReset = 0.4f;
__instance.GetComponent <global::CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.13 (too big angle v2)", "gray");
return(false);
}
__instance._lastAngle = positionOffset;
__instance._lastAngleReset = 0.4f;
}
if (__instance._lastRotationReset > 0f && (__instance._hub.playerMovementSync.Rotations.x < 68f || __instance._hub.playerMovementSync.Rotations.x > 295f))
{
float num5 = __instance._hub.playerMovementSync.Rotations.x - __instance._lastRotation;
if (num5 >= 0f && num5 <= 0.0005f)
{
__instance._lastRotation = __instance._hub.playerMovementSync.Rotations.x;
__instance._lastRotationReset = 0.35f;
__instance.GetComponent <global::CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient, "Shot rejected - Code W.9 (no recoil)", "gray");
return(false);
}
}
__instance._lastRotation = __instance._hub.playerMovementSync.Rotations.x;
__instance._lastRotationReset = 0.35f;
}
float num2 = Vector3.Distance(__instance.camera.transform.position, target.transform.position);
float num3 = __instance.weapons[(int)__instance.curWeapon].damageOverDistance.Evaluate(num2);
switch (referenceHub.characterClassManager.CurClass)
{
case RoleType.Scp106:
num3 /= 10f;
goto IL_6D1;
case RoleType.Scp049:
case RoleType.Scp079:
case RoleType.Scp096:
case RoleType.Scp173:
case RoleType.Scp93953:
case RoleType.Scp93989:
goto IL_6D1;
default:
switch (hitboxType)
{
case HitBoxType.HEAD:
num3 *= 4;
float num4 = 1 / (__instance.weapons[(int)__instance.curWeapon].shotsPerSecond * __instance.weapons[(int)__instance.curWeapon].allEffects.firerateMultiplier);
__instance._headshotsL++;
__instance._headshotsS++;
__instance._headshotsResetS = num4 * 1.86f;
__instance._headshotsResetL = num4 * 2.9f;
if (__instance._headshotsS >= 3)
{
__instance._hub.playerMovementSync.AntiCheatKillPlayer("Headshots limit exceeded in time window A\n(debug code: W.10)", "W.10");
return(false);
}
if (__instance._headshotsL >= 4)
{
__instance._hub.playerMovementSync.AntiCheatKillPlayer("Headshots limit exceeded in time window B\n(debug code: W.11)", "W.11");
return(false);
}
break;
case HitBoxType.ARM:
case HitBoxType.LEG:
num3 /= 2;
break;
}
break;
}
IL_6D1:
num3 *= __instance.weapons[(int)__instance.curWeapon].allEffects.damageMultiplier;
num3 *= __instance.overallDamagerFactor;
// >Exiled
Log.Debug("Invoking late shoot.", Loader.ShouldDebugBeShown);
var shotEventArgs = new ShotEventArgs(Player.Get(__instance.gameObject), target, hitboxType, num2, num3);
Exiled.Events.Handlers.Player.OnShot(shotEventArgs);
if (!shotEventArgs.CanHurt)
{
return(false);
}
// <Exiled
__instance._hub.playerStats.HurtPlayer(
new PlayerStats.HitInfo(
shotEventArgs.Damage,
__instance._hub.LoggedNameFromRefHub(),
DamageTypes.FromWeaponId(__instance.curWeapon),
__instance._hub.queryProcessor.PlayerId),
referenceHub.gameObject);
__instance.RpcConfirmShot(hitmarker: true, __instance.curWeapon);
__instance.PlaceDecal(isBlood: true, new Ray(__instance.camera.position, dir), (int)referenceHub.characterClassManager.CurClass, num2);
}
else if (target != null && hitboxType == HitBoxType.WINDOW && target.GetComponent <BreakableWindow>() != null)
{
float time = Vector3.Distance(__instance.camera.transform.position, target.transform.position);
float damage = __instance.weapons[__instance.curWeapon].damageOverDistance.Evaluate(time);
target.GetComponent <BreakableWindow>().ServerDamageWindow(damage);
__instance.RpcConfirmShot(hitmarker: true, __instance.curWeapon);
}
else
{
__instance.PlaceDecal(isBlood: false, new Ray(__instance.camera.position, dir), __instance.curWeapon, 0f);
__instance.RpcConfirmShot(hitmarker: false, __instance.curWeapon);
}
return(false);
}
catch (Exception e)
{
Exiled.API.Features.Log.Error($"{typeof(ShootFixPatch).FullName}.{nameof(Prefix)}:\n{e}");
return(true);
}
}
public static bool Prefix(WeaponManager __instance, GameObject target, string hitboxType, Vector3 dir, Vector3 sourcePos, Vector3 targetPos)
{
if (EventPlugin.LateShootEventPatchDisable)
{
return(true);
}
try
{
if (!__instance._iawRateLimit.CanExecute(true))
{
return(false);
}
int itemIndex = __instance.hub.inventory.GetItemIndex();
if (itemIndex < 0 || itemIndex >= __instance.hub.inventory.items.Count || __instance.curWeapon < 0 ||
(__instance.reloadCooldown > 0.0 || __instance.fireCooldown > 0.0) && !__instance.isLocalPlayer ||
(__instance.hub.inventory.curItem != __instance.weapons[__instance.curWeapon].inventoryID ||
__instance.hub.inventory.items[itemIndex].durability <= 0.0))
{
return(false);
}
Log.Debug("Invoking shoot event");
bool allowShot = true;
Events.InvokeOnShoot(__instance.hub, target, ref allowShot, ref targetPos);
if (!allowShot)
{
return(false);
}
if (Vector3.Distance(__instance.camera.transform.position, sourcePos) > 6.5)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient,
"Shot rejected - Code 2.2 (difference between real source position and provided source position is too big)",
"gray");
}
else
{
__instance.hub.inventory.items.ModifyDuration(itemIndex,
__instance.hub.inventory.items[itemIndex].durability - 1f);
__instance.scp268.ServerDisable();
__instance.fireCooldown =
(float)(1.0 / (__instance.weapons[__instance.curWeapon].shotsPerSecond *
(double)__instance.weapons[__instance.curWeapon].allEffects.firerateMultiplier) *
0.800000011920929);
float sourceRangeScale = __instance.weapons[__instance.curWeapon].allEffects.audioSourceRangeScale;
__instance.GetComponent <Scp939_VisionController>()
.MakeNoise(Mathf.Clamp((float)(sourceRangeScale * (double)sourceRangeScale * 70.0), 5f, 100f));
bool flag = target != null;
if (targetPos == Vector3.zero)
{
if (Physics.Raycast(sourcePos, dir, out RaycastHit raycastHit, 500f, __instance.raycastMask))
{
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component != null)
{
WeaponManager componentInParent = component.GetComponentInParent <WeaponManager>();
if (componentInParent != null)
{
flag = false;
target = componentInParent.gameObject;
hitboxType = component.id;
targetPos = componentInParent.transform.position;
}
}
}
}
else
{
if (Physics.Linecast(sourcePos, targetPos, out RaycastHit raycastHit, __instance.raycastMask))
{
HitboxIdentity component = raycastHit.collider.GetComponent <HitboxIdentity>();
if (component != null)
{
WeaponManager componentInParent = component.GetComponentInParent <WeaponManager>();
if (componentInParent != null)
{
if (componentInParent.gameObject == target)
{
flag = false;
}
else if (componentInParent.scp268.Enabled)
{
flag = false;
target = componentInParent.gameObject;
hitboxType = component.id;
targetPos = componentInParent.transform.position;
}
}
}
}
}
CharacterClassManager c = null;
if (target != null)
{
c = target.GetComponent <CharacterClassManager>();
}
if (c != null && __instance.GetShootPermission(c, false))
{
if (Math.Abs(__instance.camera.transform.position.y - c.transform.position.y) > 40.0)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient,
"Shot rejected - Code 2.1 (too big Y-axis difference between source and target)", "gray");
}
else if (Vector3.Distance(c.transform.position, targetPos) > 6.5)
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient,
"Shot rejected - Code 2.3 (difference between real target position and provided target position is too big)",
"gray");
}
else if (Physics.Linecast(__instance.camera.transform.position, sourcePos, __instance.raycastServerMask))
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient,
"Shot rejected - Code 2.4 (collision between source positions detected)", "gray");
}
else if (flag && Physics.Linecast(sourcePos, targetPos, __instance.raycastServerMask))
{
__instance.GetComponent <CharacterClassManager>().TargetConsolePrint(__instance.connectionToClient,
"Shot rejected - Code 2.5 (collision on shot line detected)", "gray");
}
else
{
float num1 = Vector3.Distance(__instance.camera.transform.position, target.transform.position);
float num2 = __instance.weapons[__instance.curWeapon].damageOverDistance.Evaluate(num1);
string upper = hitboxType.ToUpper();
if (upper != "HEAD")
{
if (upper != "LEG")
{
if (upper == "SCP106")
{
num2 /= 10f;
}
}
else
{
num2 /= 2f;
}
}
else
{
num2 *= 4f;
}
bool allow = true;
Log.Debug("Invoking late shoot.");
Events.InvokeOnLateShoot(__instance.hub, target, ref num2, num1, upper, ref allow);
if (!allow)
{
return(false);
}
__instance.hub.playerStats.HurtPlayer(
new PlayerStats.HitInfo(
num2 * __instance.weapons[__instance.curWeapon].allEffects.damageMultiplier *
__instance.overallDamagerFactor,
__instance.hub.nicknameSync.MyNick + " (" + __instance.hub.characterClassManager.UserId + ")",
DamageTypes.FromWeaponId(__instance.curWeapon), __instance.hub.queryProcessor.PlayerId),
c.gameObject);
__instance.RpcConfirmShot(true, __instance.curWeapon);
__instance.PlaceDecal(true, new Ray(__instance.camera.position, dir), (int)c.CurClass, num1);
}
}
else if (target != null && hitboxType == "window" && target.GetComponent <BreakableWindow>() != null)
{
float damage = __instance.weapons[__instance.curWeapon].damageOverDistance
.Evaluate(Vector3.Distance(__instance.camera.transform.position, target.transform.position));
target.GetComponent <BreakableWindow>().ServerDamageWindow(damage);
__instance.RpcConfirmShot(true, __instance.curWeapon);
}
else
{
__instance.PlaceDecal(false, new Ray(__instance.camera.position, dir), __instance.curWeapon, 0.0f);
__instance.RpcConfirmShot(false, __instance.curWeapon);
}
}
return(false);
}
catch (Exception exception)
{
Log.Error($"LateShootEvent error: {exception}");
return(true);
}
}
private static bool PlayExplosionEffects(FlashbangGrenade __instance)
{
try
{
float time = __instance._blindingOverDistance.keys[__instance._blindingOverDistance.length - 1].time;
float num = time * time;
foreach (KeyValuePair <GameObject, ReferenceHub> keyValuePair in ReferenceHub.GetAllHubs())
{
if (!(keyValuePair.Value == null) && (__instance.transform.position - keyValuePair.Value.transform.position).sqrMagnitude <= num && !(keyValuePair.Value == __instance.PreviousOwner.Hub) && HitboxIdentity.CheckFriendlyFire(__instance.PreviousOwner.Hub, keyValuePair.Value, false))
{
__instance.ProcessPlayer(keyValuePair.Value);
}
}
return(false);
}
catch (Exception ex)
{
Logger.Get.Error($"Synapse-FF: PlayExplosionFlash failed!!\n{ex}");
return(true);
}
}
protected override void OnValidShoot(GameObject target, ref float damage)
{
WeaponManager weps = PlayerObject.GetComponent <WeaponManager>();
Transform cam = PlayerObject.GetComponent <Scp049PlayerScript>().plyCam.transform;
Ray ray = new Ray(cam.position, cam.forward);
Physics.Raycast(cam.position + cam.forward, cam.forward, out RaycastHit playerHit, PlayerMask);
HitboxIdentity hitbox = playerHit.collider?.GetComponent <HitboxIdentity>();
damage = 0;
if (overCharged)
{
damage = HmdPlugin.TagDamage;
if (hitbox != null)
{
Timing.In(x =>
{
OverchargeDetonate(weps, target.GetComponent <PlyMovementSync>().position);
if (weps.GetShootPermission(target.GetComponent <CharacterClassManager>()))
{
float glitchTime = x;
for (int i = 0; i < HmdPlugin.TagGlitches; i++)
{
Timing.In(y => TargetShake(target), glitchTime += GlitchLength);
}
}
}, HmdPlugin.TagTime);
}
else if (Physics.Raycast(ray, out RaycastHit hit, 500f, WorldMask))
{
Timing.In(x =>
{
OverchargeDetonate(weps, hit.point);
}, DetonateFlash(hit.point));
}
}
else
{
PlayerStats stats = target.GetComponent <PlayerStats>();
float damageTmp;
if (target.GetComponent <CharacterClassManager>().curClass == (int)Role.SCP_106)
{
damageTmp = HmdPlugin.Scp106Damage;
}
else
{
damageTmp = HitHandler(hitbox);
}
stats.HurtPlayer(
new PlayerStats.HitInfo(
damageTmp,
PlayerObject.GetComponent <NicknameSync>().myNick + " (" + PlayerObject.GetComponent <CharacterClassManager>().SteamId + ")",
DamageTypes.E11StandardRifle,
PlayerObject.GetComponent <QueryProcessor>().PlayerId
),
target);
}
int shots = Barrel == 1 ? HmdPlugin.SuppressedKrakatoa : HmdPlugin.Krakatoa;
for (int i = 0; i < shots; i++)
{
weps.CallRpcConfirmShot(false, weps.curWeapon);
}
}
private static bool ChargePlayer(PlayableScps.Scp096 __instance, ReferenceHub player)
{
try
{
var scp = __instance.GetPlayer();
var target = player.GetPlayer();
if (!HitboxIdentity.CheckFriendlyFire(scp.Hub, target.Hub))
{
return(false);
}
if (Physics.Linecast(scp.transform.position, player.transform.position, LayerMask.GetMask(new string[]
{
"Default",
"Door",
"Glass"
})))
{
return(false);
}
if (__instance._chargeHitTargets.Contains(player))
{
return(false);
}
try
{
ev.Get.Scp.InvokeScpAttack(scp, target, Api.Enum.ScpAttackType.Scp096_Tear, out var allow);
if (!allow)
{
return(false);
}
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp096-Charge) failed!!\n{e}");
}
var flag = __instance._targets.Contains(player);
var damage = flag ? 9696f : 40f;
var flag2 = player.playerStats.DealDamage(new Scp096DamageHandler(__instance, damage, Scp096DamageHandler.AttackType.Charge));
__instance._chargeHitTargets.Add(player);
if (flag2)
{
__instance._targets.Remove(player);
Hitmarker.SendHitmarker(__instance.Hub, 1.35f);
if (!__instance._chargeKilled)
{
__instance._chargeCooldownPenaltyAmount++;
__instance._chargeKilled = true;
}
}
if (flag)
{
__instance.EndChargeNextFrame();
}
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: Scp096AttackEvent(Charge) failed!!\n{e}");
return(true);
}
}
private static bool Pry(PlayableScps.Scp096 __instance)
{
try
{
if (!__instance.PryingGate)
{
return(false);
}
var num = Physics.OverlapSphereNonAlloc(__instance.Hub.playerMovementSync.RealModelPosition, 0.5f, PlayableScps.Scp096._sphereHits, LayerMask.GetMask(new string[]
{
"Hitbox"
}));
if (num <= 0)
{
return(false);
}
for (int i = 0; i < num; i++)
{
ReferenceHub componentInParent = PlayableScps.Scp096._sphereHits[i].gameObject.GetComponentInParent <ReferenceHub>();
if (componentInParent == null || componentInParent == __instance.Hub)
{
continue;
}
var scp = __instance.GetPlayer();
var target = componentInParent.GetPlayer();
if (!HitboxIdentity.CheckFriendlyFire(scp.Hub, target.Hub))
{
continue;
}
try
{
ev.Get.Scp.InvokeScpAttack(scp, target, Api.Enum.ScpAttackType.Scp096_Tear, out var allow);
if (!allow)
{
continue;
}
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: ScpAttackEvent(Scp096-Charge) failed!!\n{e}");
}
// if (__instance.Hub.playerStats.HurtPlayer(new PlayerStats.HitInfo(9696f, null, DamageTypes.Scp096, __instance.Hub.playerId, false), componentInParent.gameObject, false, true))
if (componentInParent.playerStats.DealDamage(new Scp096DamageHandler(__instance, 9696f, Scp096DamageHandler.AttackType.GateKill)))
{
if (__instance._targets.Contains(componentInParent))
{
__instance._targets.Remove(componentInParent);
}
NetworkServer.SendToAll(default(PlayableScps.Messages.Scp096OnKillMessage), 0);
}
}
if (Physics.Raycast(__instance.Hub.PlayerCameraReference.position, __instance.Hub.PlayerCameraReference.forward, 2f, LayerMask.GetMask(new string[]
{
"Default"
})))
{
__instance.EndChargeNextFrame();
}
return(false);
}
catch (Exception e)
{
Synapse.Api.Logger.Get.Error($"Synapse-Event: Scp096AttackEvent(Pry) failed!!\n{e}");
return(true);
}
}
private void OnShooting(ShootingEventArgs ev)
{
if (CheckItem(ev.Shooter.CurrentItem))
{
ev.IsAllowed = false;
try
{
int bullets = Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.SpreadCount;
if (ev.Shooter.CurrentItem.durability <= bullets)
{
bullets = (int)ev.Shooter.CurrentItem.durability;
}
Ray[] rays = new Ray[bullets];
for (int i = 0; i < rays.Length; i++)
{
Vector3 forward = ev.Shooter.CameraTransform.forward;
rays[i] = new Ray(ev.Shooter.CameraTransform.position + forward, RandomAimcone() * forward);
}
RaycastHit[] hits = new RaycastHit[bullets];
bool[] didHit = new bool[hits.Length];
for (int i = 0; i < hits.Length; i++)
{
didHit[i] = Physics.Raycast(rays[i], out hits[i], 500f, 1208246273);
}
WeaponManager component = ev.Shooter.ReferenceHub.weaponManager;
bool confirm = false;
for (int i = 0; i < hits.Length; i++)
{
try
{
if (!didHit[i])
{
continue;
}
HitboxIdentity hitbox = hits[i].collider.GetComponent <HitboxIdentity>();
if (hitbox != null)
{
Player target = Player.Get(hits[i].collider.GetComponentInParent <ReferenceHub>());
if (target == null)
{
continue;
}
if (component.GetShootPermission(target.ReferenceHub.characterClassManager, Server.FriendlyFire))
{
float damage = HitHandler(hitbox);
if (target.Role == RoleType.Scp106)
{
damage /= 10;
}
float distance = Vector3.Distance(ev.Shooter.Position, target.Position);
for (int f = 0; f < (int)distance; f++)
{
damage *= Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.DamageFalloffModifier;
}
target.Hurt(damage,
DamageTypes.FromWeaponId(ev.Shooter.ReferenceHub.weaponManager.curWeapon),
ev.Shooter.Nickname, ev.Shooter.Id);
component.RpcPlaceDecal(true, (sbyte)target.ReferenceHub.characterClassManager.Classes.SafeGet(target.Role).bloodType, hits[i].point + hits[i].normal * 0.01f, Quaternion.FromToRotation(Vector3.up, hits[i].normal));
confirm = true;
}
continue;
}
}
catch (Exception e)
{
Log.Error($"{e}\n{e.StackTrace}");
}
BreakableWindow window = hits[i].collider.GetComponent <BreakableWindow>();
if (window != null)
{
window.ServerDamageWindow(Plugin.Singleton.Config.ItemConfigs.ShotgunCfg.BaseDamage);
confirm = true;
continue;
}
component.RpcPlaceDecal(false, component.curWeapon, hits[i].point + hits[i].normal * 0.01f,
Quaternion.FromToRotation(Vector3.up, hits[i].normal));
}
for (int i = 0; i < bullets; i++)
{
component.RpcConfirmShot(confirm, component.curWeapon);
}
ev.Shooter.SetWeaponAmmo(ev.Shooter.CurrentItem, (int)ev.Shooter.CurrentItem.durability - bullets);
}
catch (Exception e)
{
Log.Error(e.ToString());
}
}
}