internal void OnShotWeapon(ShootingEventArgs ev)
{
if (!config.Weapon.canShotWeaponGlobal && !config.Weapon.canShotWeapon[ev.Shooter.Role])
{
ev.IsAllowed = false;
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
try
{
foreach (Item item in ev.Shooter.Items.ToList())
{
if (Check(item))
{
Log.Debug($"SCP-2818: Found a 2818 in inventory of shooter, removing.");
ev.Shooter.RemoveItem(item);
}
}
Player target = Player.Get(ev.TargetNetId);
if (ev.ShotPosition == Vector3.zero || (ev.Shooter.Position - ev.ShotPosition).sqrMagnitude > 1000f)
{
ev.Shooter.Hurt(new UniversalDamageHandler(-1f, DeathTranslations.Warhead));
ev.IsAllowed = false;
return;
}
Timing.RunCoroutine(ShooterProjectile(ev.Shooter, ev.ShotPosition, target));
}
catch (Exception e)
{
Log.Error(e);
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
if (ev.Shooter.CurrentItem is Firearm firearm)
{
int ammoUsed = 0;
foreach (Player player in Player.List)
{
if (firearm.Ammo == ammoUsed &&
(!PerHitAmmo || firearm.Ammo == 0 || player.Role == RoleType.Spectator ||
(player.Role.Side == ev.Shooter.Role.Side && (player.Role.Side != ev.Shooter.Role.Side || !TeamKill)) ||
player == ev.Shooter ||
!(Vector3.Distance(ev.Shooter.Position, player.Position) < MaxDistance) ||
Physics.Linecast(ev.Shooter.Position, player.Position, player.ReferenceHub.playerMovementSync.CollidableSurfaces)))
{
continue;
}
ammoUsed++;
player.Hurt(new FirearmDamageHandler(firearm.Base, Damage, player.Role.Side != Side.Scp));
if (player.IsDead)
{
player.ShowHint("<color=#FF0000>YOU HAVE BEEN KILLED BY AUTO AIM GUN</color>");
}
ev.Shooter.ShowHitMarker(1f);
}
if (PerHitAmmo)
{
ammoUsed = 1;
}
firearm.Ammo -= (byte)ammoUsed;
ev.IsAllowed = false;
}
}
private static void HandleWeaponShoot(ShootingEventArgs ev)
{
if (Plugin.Config.InfiniteAmmo)
{
ev.Shooter.SetWeaponAmmo(ev.Shooter.CurrentItem, (int)ev.Shooter.CurrentItem.durability + 1);
}
}
public void OnShooting(ShootingEventArgs ev)
{
if (Tracking.PlayersInvisibleByCommand.Contains(ev.Shooter))
{
Tracking.PlayersInvisibleByCommand.Remove(ev.Shooter);
}
EPlayer target = EPlayer.Get(ev.Target);
if (target != null)
{
if (Tracking.PlayerHasFFToPlayer(ev.Shooter, target))
{
Log.Debug($"Attacker: {ev.Shooter.Nickname} has been granted friendly fire", Subclass.Instance.Config.Debug);
ev.Shooter.IsFriendlyFireEnabled = true;
Timing.CallDelayed(0.1f, () =>
{
ev.Shooter.IsFriendlyFireEnabled = false;
});
}
else
{
Log.Debug($"Attacker: {ev.Shooter.Nickname} has not been granted friendly fire", Subclass.Instance.Config.Debug);
}
}
}
private void OnShooting(ShootingEventArgs ev)
{
if (CheckItem(ev.Shooter.CurrentItem))
{
if (Player.Get(ev.Target) is Player player)
{
float num3 = Vector3.Distance(ev.Shooter.CameraTransform.transform.position, ev.Target.transform.position);
float num4 = ev.Shooter.ReferenceHub.weaponManager.weapons[ev.Shooter.ReferenceHub.weaponManager.curWeapon].damageOverDistance.Evaluate(num3);
float damage = num4 * ev.Shooter.ReferenceHub.weaponManager.weapons[ev.Shooter.ReferenceHub.weaponManager.curWeapon].allEffects.damageMultiplier * ev.Shooter.ReferenceHub.weaponManager.overallDamagerFactor;
if (player.Team.GetSide() == ev.Shooter.Team.GetSide())
{
player.Health += (damage * Plugin.Singleton.Config.ItemConfigs.MediCfg.HealingModifier);
}
else if (player.Role == RoleType.Scp0492 && Plugin.Singleton.Config.ItemConfigs.MediCfg.HealZombies)
{
player.MaxAdrenalineHealth = Plugin.Singleton.Config.ItemConfigs.MediCfg.ZombieHealingRequired;
player.AdrenalineHealth += damage;
if (player.AdrenalineHealth >= player.MaxAdrenalineHealth)
{
DoReviveZombie(player);
}
}
}
}
}
private void OnShoot(ShootingEventArgs ev)
{
if (player.CurrentItem.id.IsWeapon())
{
SetAmmo(player, player.CurrentItem, 100);
}
}
internal static void OnShooting(ShootingEventArgs ev)
{
if (Methods.FriendlyFireUsers.Contains(ev.Shooter.UserId))
{
Methods.RemoveFf(ev.Shooter);
}
if (ev.Target == null)
{
return;
}
Player target = Player.Get(ev.Target);
if (target == null)
{
return;
}
if (!API.IsScp035(target) && !API.IsScp035(ev.Shooter))
{
return;
}
if (target.Side == ev.Shooter.Side)
{
Methods.GrantFf(ev.Shooter);
}
}
public void OnShoot(ShootingEventArgs ev)
{
if (ev.Target == null)
{
return;
}
Player target = Player.Get(ev.Target);
if (target == null)
{
return;
}
if (spies.ContainsKey(ev.Shooter) && !spies.ContainsKey(target) && target.Team == Team.RSC)
{
if (!spies[ev.Shooter])
{
spies[ev.Shooter] = true;
ev.Shooter.Broadcast(10, $"Has atacado a un {(target.Team == Team.MTF ? "<color=#00b0fc>MTF" : "<color=#fcff8d>Cientifico")}</color>, ten cuidado de que no te haya visto los <color=#00b0fc>MTF</color> y <color=#fcff8d>cientificos</color> o podrian matarte");
}
GrantFF(ev.Shooter);
}
else if (spies.ContainsKey(target) && !spies.ContainsKey(ev.Shooter) && (ev.Shooter.Team == Team.MTF || ev.Shooter.Team == Team.RSC))
{
if (spies[target])
{
GrantFF(ev.Shooter);
}
}
}
public void RunWhenPlayerShoots(ShootingEventArgs s)
{
if (s.Shooter.ReferenceHub != Hub.ReferenceHub)
{
return;
}
ModifyAmmo(s.Shooter.ReferenceHub, 999);
}
public void OnShoot(ShootingEventArgs ev)
{
Player target = Player.Get(ev.Target);
if (target != null && target.Role == RoleType.Scp096 && shPlayers.Contains(ev.Shooter.Id))
{
ev.IsAllowed = false;
}
}
private void OnPlayerShooting(ShootingEventArgs ev)
{
if (Scp999Manager.IsScp999(ev.Shooter))
{
var weapon = ev.Shooter.Inventory.items[ev.Shooter.CurrentItemIndex];
weapon.durability = 1000f;
ev.Shooter.Inventory.items[ev.Shooter.CurrentItemIndex] = weapon;
}
}
public void RunWhenPlayerShoots(ShootingEventArgs ev)
{
if (ev.Shooter != _ply)
{
return;
}
ModifyAmmo(ev.Shooter, 999);
}
public void OnShooting(ShootingEventArgs ev)
{
Player target = Player.Get(ev.TargetNetId);
if (target != null && target.Role == RoleType.Scp096 && API.IsSerpent(ev.Shooter))
{
ev.IsAllowed = false;
}
}
public void OnPlayerShoot(PlayerShootEvent e)
{
var @event = new ShootingEventArgs(Player.Get(e.Player.gameObject), e.Target, e.TargetPos);
Handlers.Player.OnShooting(@event);
if ([email protected])
{
e.Cancelled = true;
}
}
public void OnPlayerShoot(ShootingEventArgs ev)
{
try
{
ResetAFKTime(ev.Shooter);
}
catch (Exception e)
{
Log.Error($"ERROR In ResetAFKTime(): {e}");
}
}
public void OnShooting(ShootingEventArgs ev)
{
if (scp372.Contains(ev.Shooter.UserId))
{
ev.Shooter.IsInvisible = false;
Timing.CallDelayed(0.5f, () =>
{
ev.Shooter.IsInvisible = true;
});
}
}
private void OnShooting(ShootingEventArgs ev)
{
if (Server.FriendlyFire || ev.Target == null)
{
return;
}
Player target = Player.Get(ev.Target);
ev.Shooter.IsFriendlyFireEnabled = !(target == null || target != _player);
}
/**
* <summary>When the player passed the shooting, saves number of attempts and starts running if the game has not been finished yet</summary>
**/
public void OnShootingPassed(object source, ShootingEventArgs args)
{
if (!shootingRangeResults.ContainsKey(shootingRoundsCounter - 1))
{
shootingRangeResults.Add(shootingRoundsCounter - 1, args.NumberOfTries);
}
StartRunning();
CheckForGameEnd();
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
base.OnShooting(ev);
ev.Shooter.SetWeaponAmmo(ev.Shooter.CurrentItem, (int)ClipSize - 1);
Player Target = Player.Get(ev.Target);
if (Target != null)
{
if (!sizedPlayers.ContainsKey(Target))
{
sizedPlayers.Add(Target, Target.Scale);
}
Vector3 NewSize = Target.Scale;
switch (playerMode[ev.Shooter])
{
case 1:
NewSize -= new Vector3(SizeChange, SizeChange, SizeChange);
if (NewSize.x < .4)
{
NewSize = new Vector3(.4f, .4f, .4f);
}
break;
case 2:
NewSize += new Vector3(SizeChange, SizeChange, SizeChange);
if (NewSize.x > 1.5)
{
NewSize = new Vector3(1.5f, 1.5f, 1.5f);
}
break;
case 3:
if (sizedPlayers.ContainsKey(Target))
{
NewSize = sizedPlayers[Target];
}
break;
}
if (Target.Scale != NewSize)
{
Target.Scale = NewSize;
}
ev.Shooter.ReferenceHub.weaponManager.RpcConfirmShot(true, ev.Shooter.ReferenceHub.weaponManager.curWeapon);
}
ev.IsAllowed = false;
}
private void OnShooting(ShootingEventArgs ev)
{
if (CheckItem(ev.Shooter.CurrentItem))
{
ev.IsAllowed = false;
ev.Shooter.SetWeaponAmmo(ev.Shooter.CurrentItem, (int)ev.Shooter.CurrentItem.durability - 1);
Vector3 velocity = (ev.Position - ev.Shooter.Position) * Plugin.Singleton.Config.ItemConfigs.GlCfg.GrenadeSpeed;
Grenade grenadeComponent = ev.Shooter.GrenadeManager.availableGrenades[0].grenadeInstance.GetComponent <Grenade>();
Vector3 pos = ev.Shooter.CameraTransform.TransformPoint(grenadeComponent.throwStartPositionOffset);
var grenade = SpawnGrenade(pos, velocity, Plugin.Singleton.Config.ItemConfigs.GlCfg.FuseTime, GrenadeType.FragGrenade, ev.Shooter);
CollisionHandler collisionHandler = grenade.gameObject.AddComponent <CollisionHandler>();
collisionHandler.owner = ev.Shooter.GameObject;
collisionHandler.grenade = grenadeComponent;
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
ev.IsAllowed = false;
if (ev.Shooter.CurrentItem is Firearm firearm)
{
firearm.Ammo -= 1;
}
Vector3 pos = ev.Shooter.CameraTransform.TransformPoint(new Vector3(0.0715f, 0.0225f, 0.45f));
ThrownProjectile projectile;
if (loadedCustomGrenade != null)
{
projectile = (ThrownProjectile)loadedCustomGrenade.Throw(pos, GrenadeSpeed, FuseTime, loadedCustomGrenade.Type, ev.Shooter).Base;
loadedCustomGrenade = null;
}
else
{
switch (loadedGrenade)
{
case GrenadeType.Scp018:
projectile = ev.Shooter.ThrowGrenade(GrenadeType.Scp018).Base.Projectile;
break;
case GrenadeType.Flashbang:
projectile = ev.Shooter.ThrowGrenade(GrenadeType.Flashbang).Base.Projectile;
break;
default:
projectile = ev.Shooter.ThrowGrenade(GrenadeType.FragGrenade).Base.Projectile;
break;
}
}
var comp = projectile.gameObject.AddComponent <CollisionHandler>();
comp.Init(ev.Shooter.GameObject, projectile);
if (comp.Owner == null || comp.Grenade == null)
{
Log.Debug($"{nameof(Name)}.{nameof(OnShooting)}: Grenade or owner is null, destroying collision component!", CustomItems.Instance.Config.IsDebugEnabled);
}
}
public void ShootEvent(ShootingEventArgs ev)
{
// I know this is a lazy fix, don't ree at me about it, I'm trying to fix my sleeping schedule and other projects so haven't got much time to find the cause of the Exception this week, prob will actually fix it soon
if (testFix)
{
return;
}
try {
if ((ev.Shooter.CurrentItem.id == ItemType.GunCOM15 && plugin.Config.comIsTranquilizer) ||
(ev.Shooter.CurrentItem.id == ItemType.GunUSP && plugin.Config.uspIsTranquilizer))
{
if (plugin.Config.silencerRequired && !ev.Shooter.HasSilencer())
{
return;
}
if (ev.Shooter.CurrentItem.durability < plugin.Config.ammoUsedPerShot - 1)
{
if (plugin.Config.notEnoughAmmoBroadcastDuration > 0)
{
if (plugin.Config.UseHintsSystem)
{
ev.Shooter.ShowHint(plugin.Config.notEnoughAmmoBroadcastDuration, plugin.Config.notEnoughAmmoBroadcast.Replace("%ammo", $"{plugin.Config.ammoUsedPerShot}"));
}
else
{
if (plugin.Config.clearBroadcasts)
{
ev.Shooter.ClearBroadcasts();
}
ev.Shooter.Broadcast(plugin.Config.notEnoughAmmoBroadcastDuration, plugin.Config.notEnoughAmmoBroadcast.Replace("%ammo", $"{plugin.Config.ammoUsedPerShot}"));
}
}
ev.IsAllowed = false;
return;
}
ev.Shooter.RemoveWeaponAmmo(plugin.Config.ammoUsedPerShot - 1);
}
} catch (Exception e) {
e.Print("ShootEvent");
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
ev.IsAllowed = false;
ev.Shooter.SetWeaponAmmo(ev.Shooter.CurrentItem, (int)ev.Shooter.CurrentItem.durability - 1);
Vector3 velocity = (ev.Position - ev.Shooter.Position) * GrenadeSpeed;
Vector3 pos = ev.Shooter.CameraTransform.TransformPoint(new Vector3(0.0715f, 0.0225f, 0.45f));
Grenade grenade;
if (loadedCustomGrenade != null)
{
grenade = loadedCustomGrenade.Spawn(pos, velocity, FuseTime, loadedCustomGrenade.Type, ev.Shooter);
loadedCustomGrenade = null;
}
else
{
grenade = SpawnGrenade(pos, velocity, FuseTime, GrenadeType.FragGrenade, ev.Shooter);
}
grenade.gameObject.AddComponent <CollisionHandler>().Init(ev.Shooter.GameObject, grenade);
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
if (!Check(ev.Shooter.CurrentItem))
{
return;
}
if (!(Player.Get(ev.Target) is Player player))
{
return;
}
float num3 = Vector3.Distance(ev.Shooter.CameraTransform.transform.position, ev.Target.transform.position);
float num4 = ev.Shooter.ReferenceHub.weaponManager.weapons[ev.Shooter.ReferenceHub.weaponManager.curWeapon].damageOverDistance.Evaluate(num3);
float damage = num4 * ev.Shooter.ReferenceHub.weaponManager.weapons[ev.Shooter.ReferenceHub.weaponManager.curWeapon].allEffects.damageMultiplier * ev.Shooter.ReferenceHub.weaponManager.overallDamagerFactor;
if (player.Team.GetSide() == ev.Shooter.Team.GetSide())
{
float amount = damage * HealingModifier;
if (player.Health + amount > player.MaxHealth)
{
player.Health = player.MaxHealth;
}
else
{
player.Health += amount;
}
}
else if (player.Role == RoleType.Scp0492 && HealZombies)
{
player.MaxArtificialHealth = ZombieHealingRequired;
player.ArtificialHealth += damage;
if (player.ArtificialHealth >= player.MaxArtificialHealth)
{
DoReviveZombie(player);
}
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
try
{
Player target = null;
if (ev.Target != null)
{
target = Player.Get(ev.Target);
}
if (ev.Position == Vector3.zero || Vector3.Distance(ev.Shooter.Position, ev.Position) > 100f)
{
ev.Shooter.Kill(DamageTypes.Nuke);
ev.IsAllowed = false;
return;
}
Timing.RunCoroutine(ShooterProjectile(ev.Shooter, ev.Position, target));
}
catch (Exception e)
{
Log.Error(e);
}
}
private void OnShooting(ShootingEventArgs ev)
{
if (!AllowShoot)
{
return;
}
Vector3 forward = ev.Shooter.CameraTransform.forward;
if (Physics.Raycast(ev.Shooter.CameraTransform.position + forward, forward, out var hit, 500))
{
Grenade grenade = hit.collider.gameObject.GetComponentInParent <Grenade>();
if (grenade == null)
{
return;
}
if (PlacedCharges.ContainsKey(grenade))
{
C4Handler(grenade, ShotMethod);
}
}
}
public void ShootEvent(ShootingEventArgs ev)
{
try {
if ((ev.Shooter.CurrentItem.id == ItemType.GunCOM15 && plugin.Config.comIsTranquilizer) ||
(ev.Shooter.CurrentItem.id == ItemType.GunUSP && plugin.Config.uspIsTranquilizer))
{
if (plugin.Config.silencerRequired && !ev.Shooter.HasSilencer())
{
return;
}
if (ev.Shooter.CurrentItem.durability < plugin.Config.ammoUsedPerShot - 1)
{
if (plugin.Config.notEnoughAmmoBroadcastDuration > 0)
{
if (plugin.Config.UseHintsSystem)
{
ev.Shooter.ShowHint(plugin.Config.notEnoughAmmoBroadcastDuration, plugin.Config.notEnoughAmmoBroadcast.Replace("%ammo", $"{plugin.Config.ammoUsedPerShot}"));
}
else
{
if (plugin.Config.clearBroadcasts)
{
ev.Shooter.ClearBroadcasts();
}
ev.Shooter.Broadcast(plugin.Config.notEnoughAmmoBroadcastDuration, plugin.Config.notEnoughAmmoBroadcast.Replace("%ammo", $"{plugin.Config.ammoUsedPerShot}"));
}
}
ev.IsAllowed = false;
return;
}
ev.Shooter.RemoveWeaponAmmo(plugin.Config.ammoUsedPerShot - 1);
}
} catch (Exception e) {
e.Print("ShootEvent");
}
}
/// <inheritdoc/>
protected override void OnShooting(ShootingEventArgs ev)
{
if (!(Player.Get(ev.TargetNetId) is Player player))
{
return;
}
if (!(ev.Shooter.CurrentItem is Firearm firearm))
{
return;
}
float num3 = Vector3.Distance(ev.Shooter.CameraTransform.transform.position, ev.ShotPosition);
float damage = firearm.Base.BaseStats.DamageAtDistance(firearm.Base, num3);
if (player.Role.Side == ev.Shooter.Role.Side)
{
float amount = damage * HealingModifier;
if (player.Health + amount > player.MaxHealth)
{
player.Health = player.MaxHealth;
}
else
{
player.Health += amount;
}
}
else if (player.Role == RoleType.Scp0492 && HealZombies)
{
player.MaxArtificialHealth = ZombieHealingRequired;
player.ArtificialHealth += damage;
if (player.ArtificialHealth >= player.MaxArtificialHealth)
{
DoReviveZombie(player, ev.Shooter);
}
}
}
/// <summary> /// Invoked before shooting. /// </summary> /// <param name="ev">The <see cref="ShootingEventArgs"/> instance.</param> public static void OnShooting(ShootingEventArgs ev) => Shooting.InvokeSafely(ev);
