/// <summary>Stores the shot data to the repository and invokes module extension points.</summary>
private void ShootingRangeOnShot(object sender, ShotEventArgs e)
{
if (_sessionsAwaitingProgramNumber.ContainsKey(e.LaneNumber))
{
Session session = _sessionsAwaitingProgramNumber[e.LaneNumber];
_sessionsAwaitingProgramNumber.Remove(e.LaneNumber);
_sessionsOngoing.Add(e.LaneNumber, session);
session.ProgramNumber = e.ProgramNumber;
_sessionDataStore.Create(session);
SubSession subSession = session.CreateSubSession();
_sessionSubtotalDataStore.Create(subSession);
AddShotToSubsession(e, subSession);
}
else if (_sessionsOngoing.ContainsKey(e.LaneNumber))
{
Session session = _sessionsOngoing[e.LaneNumber];
SubSession subSession = session.CurrentSubsession();
if (subSession.SessionSubtotalId == 0)
{
_sessionSubtotalDataStore.Create(subSession);
}
AddShotToSubsession(e, subSession);
}
else
{
throw new InvalidOperationException("Session is not available.");
}
}
private static void OnShot(ShotEventArgs ev)
{
if (Scp457.Get(ev.Target) != null && ev.Hitbox._dmgMultiplier == HitboxIdentity.DamagePercent.Headshot)
{
ev.Damage /= 4;
}
}
/// <summary>
/// Выстрел по мне.
/// </summary>
private async void MyGameField_ShotMyField(object sender, ShotEventArgs e)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Rectangle rectangle = new Rectangle();
Player1Grid.Children.Add(rectangle);
Grid.SetColumn(rectangle, e.Hits[0].X);
Grid.SetRow(rectangle, e.Hits[0].Y);
if (e.ShotResult == Game.ShotResult.Miss) //промах
{
rectangle.Fill = new SolidColorBrush(killColor);
Model.CanShot = true;
}
else if (e.ShotResult == Game.ShotResult.Damage) //ранил
{
SetImage("ms-appx:///Assets/Ships/Hurt.png", 1, 1, e.Hits[0].X, e.Hits[0].Y, Player1Grid);
Model.CanShot = false;
}
else if (e.ShotResult == Game.ShotResult.Kill) //убил
{
Ship s = (Ship)e.Ship.Clone();
ClientShip ship = new ClientShip(s.Id, s.ShipClass, s.Orientation, s.Location); // сюда передается кораблик
KillShip(ship, Player1Grid);
SetImage("ms-appx:///Assets/Ships/Hurt.png", ship.ShipWidth, ship.ShipHeight, ship.Location.X, ship.Location.Y, Player1Grid);
Model.CanShot = false;
}
});
if (MyGameField.IsGameOver)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Canvas.SetZIndex(panel, 7);
panel.Background = new SolidColorBrush(Colors.White);
tbGameResult.Text = "Вы проиграли";
btnStartNewGame.Visibility = Visibility.Visible;
});
}
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
if (Model.CanShot == true)
{
tbWait.Visibility = Visibility.Collapsed;
tbGo.Visibility = Visibility.Visible;
progressRing.IsActive = false;
}
else
{
StateObject state = new StateObject();
state.workSocket = Model.PlayerSocket;
state.obj = MyGameField;
Model.PlayerSocket.BeginReceive(state.buffer, 0, StateObject.BufferSize, SocketFlags.None, new AsyncCallback(ReceiveCallbackEnemyShot), state);
}
});
}
private void _battleTheatre_ShotLanded(object sender, ShotEventArgs e)
{
if (e.Team != Team)
{
//trigger a battle status update to check the state of the ship
BattleStatusUpdate(e.Location, e.Id);
}
}
protected virtual void OnShot(ShotEventArgs e)
{
EventHandler <ShotEventArgs> handler = Shot;
if (handler != null)
{
handler(this, e);
}
}
private void OnShot(ShotEventArgs ev)
{
Player target = Player.Get(ev.Target);
if (target != null && target == _player && target.Role != _player.Role)
{
UnDisguise();
}
}
public void OnPlayerShotByPlayer(PlayerShotByPlayerEvent e)
{
var @event = new ShotEventArgs(Player.Get(e.Shooter.gameObject), e.Player.gameObject, e.HitBoxType, e.Distance, e.HitInfo.Amount);
Handlers.Player.OnShot(@event);
if ([email protected])
{
e.Cancelled = true;
}
}
private void ShootingRangeOnBestShot(object sender, ShotEventArgs e)
{
if (_sessionsOngoing.ContainsKey(e.LaneNumber))
{
SubSession currentSubSession = _sessionsOngoing[e.LaneNumber].CurrentSubsession();
Shot shot =
_shotDataStore.FindBySubSessionId(currentSubSession.SessionSubtotalId)
.Single(_ => _.Ordinal == e.Ordinal);
currentSubSession.BestShotId = shot.ShotId;
_sessionSubtotalDataStore.Update(currentSubSession);
}
}
private void AddShotToSubsession(ShotEventArgs e, SubSession subSession)
{
Shot shot = new Shot
{
PrimaryScore = e.PrimaryScore,
SecondaryScore = e.SecondaryScore,
LaneNumber = e.LaneNumber,
SubtotalId = subSession.SessionSubtotalId,
Ordinal = e.Ordinal,
};
_shotDataStore.Create(shot);
}
public void ProcessShotMessage(ShotMessage shotMessage)
{
ShotEventArgs e = new ShotEventArgs
{
PrimaryScore = shotMessage.PrimaryScore,
SecondaryScore = shotMessage.SecondaryScore,
ProgramNumber = shotMessage.ProgramNumber,
LaneNumber = shotMessage.LaneNumber,
LaneId = shotMessage.LaneId,
Ordinal = shotMessage.ShotNbr,
};
OnShot(e);
}
public void ProcessBestShotMessage(BestShotMessage bestShotMessage)
{
ShotEventArgs e = new ShotEventArgs
{
PrimaryScore = bestShotMessage.PrimaryScore,
SecondaryScore = bestShotMessage.SecondaryScore,
ProgramNumber = bestShotMessage.ProgramNumber,
LaneNumber = bestShotMessage.LaneNumber,
LaneId = bestShotMessage.LaneId,
Ordinal = bestShotMessage.ShotNbr,
};
OnBestShot(e);
}
internal void Shot(ShotEventArgs ev)
{
if (Plugin.Instance.Config.Shot == "")
{
return;
}
string message = Plugin.Instance.Config.Shot.Replace("%player%", ev.Shooter.ToString());
if (Plugin.Instance.Config.debug_to_console)
{
Log.Debug(message: "[ " + Plugin.Instance.Config.player_name + "] " + message);
}
Plugin.sendWebHook(Plugin.Instance.Config.player_url, message, Plugin.Instance.Config.player_name);
}
private void OnPlayerShot(ShotEventArgs ev)
{
if (Scp999Manager.IsScp999(ev.Shooter))
{
ev.Damage = 0;
var referenceHub = ev.Target.GetComponent <ReferenceHub>();
if (referenceHub != null)
{
var player = Player.Get(referenceHub);
if (player.Health + Config.HealPerShot <= player.MaxHealth * Config.MaxHealPercent / 100)
{
player.Health += Config.HealPerShot;
}
}
}
}
/// <summary>
/// выстрел по противнику
/// </summary>
private async void EnemyGameField_EnemyShot(object sender, ShotEventArgs e)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Rectangle rectangle = new Rectangle();
Player2Grid.Children.Add(rectangle);
Grid.SetColumn(rectangle, e.Hits[0].X);
Grid.SetRow(rectangle, e.Hits[0].Y);
if (e.ShotResult == Game.ShotResult.Miss) //промах
{
rectangle.Fill = new SolidColorBrush(killColor);
Model.CanShot = false;
}
else if (e.ShotResult == Game.ShotResult.Damage) //ранил
{
SetImage("ms-appx:///Assets/Ships/Hurt.png", 1, 1, e.Hits[0].X, e.Hits[0].Y, Player2Grid);
Model.CanShot = true;
}
else if (e.ShotResult == Game.ShotResult.Kill) //убил
{
Ship s = (Ship)e.Ship.Clone();
ClientShip ship = new ClientShip(s.Id, s.ShipClass, s.Orientation, s.Location);
KillShip(ship, Player2Grid);
SetImage(ship.Source, ship.ShipWidth, ship.ShipHeight, ship.Location.X, ship.Location.Y, Player2Grid);
Model.CanShot = true;
}
});
if (EnemyGameField.IsGameOver)
{
await Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
Canvas.SetZIndex(panel, 7);
panel.Background = new SolidColorBrush(Colors.White);
tbGameResult.Text = "Вы победили";
btnStartNewGame.Visibility = Visibility.Visible;
});
}
await AwaitEnemyView();
}
/// <summary> /// Invoked after a player's shot. /// </summary> /// <param name="ev">The <see cref="ShotEventArgs"/> instance.</param> public static void OnShot(ShotEventArgs ev) => Shot.InvokeSafely(ev);
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 void cshot_Shot(object o, ShotEventArgs e)
{
try
{
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (JsonWriter writer = new JsonTextWriter(sw))
{
writer.Formatting = Formatting.None;
writer.WriteStartArray();
writer.WriteValue((int)ServerOpcode.play); //8
writer.WriteStartArray();
if (e.User.Position == 0)
{
writer.WriteValue(1); //2 - next_turn_number
}
else
{
writer.WriteValue(0); //2 - next_turn_number
}
writer.WriteValue(e.User.Position); //0 - player_number
writer.WriteValue(e.xb); //1022 - x
writer.WriteValue(e.yb); //121 - y
writer.WriteValue(e.look); //1 - look
writer.WriteValue(1); //845 - delay
//writer.WriteValue(0); //1 - next_turn_of_player
if (e.User.Position == 0)
{
writer.WriteValue(1); //2 - next_turn_of_player
}
else
{
writer.WriteValue(0); //2 - next_turn_of_player
}
writer.WriteStartArray();
writer.WriteEndArray();
writer.WriteValue(799); //799 - thor_x
writer.WriteValue(-420); //-420 - thor_y
writer.WriteValue(0); //24 - thor_angle
writer.WriteValue(40); //0 - thor_damage
writer.WriteValue(1); //33
writer.WriteValue(0); //0
writer.WriteValue(234); //326
writer.WriteStartArray();
writer.WriteStartObject();
writer.WritePropertyName("start");
writer.WriteStartObject();
writer.WritePropertyName("x");
writer.WriteValue(e.xf); //1042
writer.WritePropertyName("y");
writer.WriteValue(e.yf); //95
writer.WritePropertyName("ang");
writer.WriteValue(e.angle); //24
writer.WritePropertyName("power");
writer.WriteValue(e.power); //101
writer.WritePropertyName("ax");
writer.WriteValue(e.ax); //0
writer.WritePropertyName("ay");
writer.WriteValue(e.ay); //398
writer.WriteEndObject();
writer.WritePropertyName("exp");
writer.WriteValue(0); //0
writer.WritePropertyName("img");
writer.WriteValue(0); //0
writer.WritePropertyName("time");
writer.WriteValue(e.time); //1340
//"hole":[887,95,60,40],"damages":[]}],150]
if (e.col == true)
{
writer.WritePropertyName("hole");
writer.WriteStartArray();
writer.WriteValue(e.cx); //x hole
writer.WriteValue(e.cy); //y hole
writer.WriteValue(36); //w
writer.WriteValue(40); //h
writer.WriteEndArray();
writer.WritePropertyName("damages");
writer.WriteStartArray();
writer.WriteEndArray();
}
writer.WriteEndObject();
writer.WriteEndArray();
writer.WriteValue(150);
writer.WriteEndArray();
writer.WriteEndArray();
}
SendAll(sb.ToString());
}
catch (Exception ex)
{
LogConsole.Show(LogType.ERROR, ex.ToString());
}
}
private static bool Prefix(WeaponManager __instance, GameObject target, string hitboxType, Vector3 dir, Vector3 sourcePos, Vector3 targetPos)
{
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", Loader.ShouldDebugBeShown);
var shootingEventArgs = new ShootingEventArgs(Player.Get(__instance.gameObject), target, targetPos);
Handlers.Player.OnShooting(shootingEventArgs);
if (!shootingEventArgs.IsAllowed)
{
return(false);
}
targetPos = shootingEventArgs.Position;
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;
}
Log.Debug("Invoking late shoot.", Loader.ShouldDebugBeShown);
var shotEventArgs = new ShotEventArgs(Player.Get(__instance.gameObject), target, hitboxType, num1, num2);
Handlers.Player.OnShot(shotEventArgs);
if (!shotEventArgs.CanHurt)
{
return(false);
}
__instance._hub.playerStats.HurtPlayer(
new PlayerStats.HitInfo(
shotEventArgs.Damage * __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, shotEventArgs.Damage);
}
}
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 e)
{
Exiled.API.Features.Log.Error($"Exiled.Events.Patches.Events.Player.Shoot: {e}\n{e.StackTrace}");
return(true);
}
}
