private BaseEntity CreateRocket(Vector3 startPoint, Vector3 direction, bool isFireRocket)
{
ItemDefinition projectileItem;
if (isFireRocket)
{
projectileItem = GetFireRocket();
}
else
{
projectileItem = GetRocket();
}
ItemModProjectile component = projectileItem.GetComponent <ItemModProjectile>();
BaseEntity entity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, startPoint, new Quaternion(), true);
TimedExplosive timedExplosive = entity.GetComponent <TimedExplosive>();
ServerProjectile serverProjectile = entity.GetComponent <ServerProjectile>();
serverProjectile.gravityModifier = gravityModifier;
serverProjectile.speed = projectileSpeed;
timedExplosive.timerAmountMin = detonationTime;
timedExplosive.timerAmountMax = detonationTime;
timedExplosive.explosionRadius = 1000f;
timedExplosive.canStick = true;
entity.SendMessage("InitializeVelocity", (object)(direction * 2f));
entity.Spawn(true);
return(entity);
}
private void LaunchRocket(Vector3 targetPos)
{
var rocket = rocketType;
if (useMixedRockets)
{
if (UnityEngine.Random.Range(1, fireChance) == 1)
{
rocket = fireRocket;
}
}
var launchPos = Plane.transform.position;
ItemDefinition projectileItem = ItemManager.FindItemDefinition(rocket);
ItemModProjectile component = projectileItem.GetComponent <ItemModProjectile>();
BaseEntity entity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, launchPos, new Quaternion(), true);
TimedExplosive rocketExplosion = entity.GetComponent <TimedExplosive>();
ServerProjectile rocketProjectile = entity.GetComponent <ServerProjectile>();
rocketProjectile.speed = rocketSpeed;
rocketProjectile.gravityModifier = 0;
rocketExplosion.timerAmountMin = 60;
rocketExplosion.timerAmountMax = 60;
for (int i = 0; i < rocketExplosion.damageTypes.Count; i++)
{
rocketExplosion.damageTypes[i].amount *= damageModifier;
}
Vector3 newDirection = (targetPos - launchPos);
entity.SendMessage("InitializeVelocity", (newDirection));
entity.Spawn();
}
void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile itemProjectile, ProtoBuf.ProjectileShoot projectiles)
{
string bullet = "Unknown", weapon = (player.GetActiveItem() != null ? player.GetActiveItem().info.displayName.english : "Unknown");
try
{
bullet = projectile.primaryMagazine.ammoType.displayName.english;
}
catch (Exception ex)
{
Puts("Problem getting bullet! " + ex.StackTrace);
if (projectile == null)
{
Puts("!!!WRONG!!! projectile is NULL!");
}
else if (projectile.primaryMagazine == null)
{
Puts("!!!WRONG!!! projectile.primaryMagazine is NULL!");
}
else if (projectile.primaryMagazine.ammoType == null)
{
Puts("!!!WRONG!!! projectile.primaryMagazine.ammoType is NULL!");
}
}
executeQuery("INSERT INTO stats_player_fire_bullet (player, bullet, weapon, date) VALUES (@0, @1, @2, @3)" +
"ON DUPLICATE KEY UPDATE count = count + 1", player.userID, bullet, weapon, getDate());
}
void UpdateAutoTurret(AutoTurret turret, bool justCreated = false)
{
CheckAutoTurretAmmo(turret);
string userID = turret.OwnerID.ToString();
float turretHealth = FromPermission(userID, autoHealths, defaultAutoHealth);
string ammoType = FromPermission(userID, ammoTypes, defaultAmmoType);
InitializeTurret(turret, turretHealth, justCreated);
turret.bulletSpeed = FromPermission(userID, bulletSpeeds, defaultBulletSpeed);
turret.sightRange = FromPermission(userID, sightRanges, defaultSightRange);
turret.aimCone = FromPermission(userID, aimCones, defaultAimCone);
var def = ItemManager.FindItemDefinition(ammoType);
if (def is ItemDefinition)
{
turret.ammoType = def;
ItemModProjectile projectile = def.GetComponent <ItemModProjectile> ();
if (projectile is ItemModProjectile)
{
turret.gun_fire_effect.guid = projectile.projectileObject.guid;
turret.bulletEffect.guid = projectile.projectileObject.guid;
}
}
else
{
PrintWarning("No ammo of type ({0})", ammoType);
}
turret.Reload();
turret.SendNetworkUpdateImmediate(justCreated);
}
private void SwitchAmmoTo(RPCMessage msg)
{
BasePlayer ownerPlayer = GetOwnerPlayer();
if (!ownerPlayer)
{
return;
}
int num = msg.read.Int32();
if (num == primaryMagazine.ammoType.itemid)
{
return;
}
ItemDefinition itemDefinition = ItemManager.FindItemDefinition(num);
if (itemDefinition == null)
{
return;
}
ItemModProjectile component = itemDefinition.GetComponent <ItemModProjectile>();
if ((bool)component && component.IsAmmo(primaryMagazine.definition.ammoTypes) && Interface.CallHook("OnSwitchAmmo", ownerPlayer, this) == null)
{
if (primaryMagazine.contents > 0)
{
ownerPlayer.GiveItem(ItemManager.CreateByItemID(primaryMagazine.ammoType.itemid, primaryMagazine.contents, 0uL));
primaryMagazine.contents = 0;
}
primaryMagazine.ammoType = itemDefinition;
SendNetworkUpdateImmediate();
ItemManager.DoRemoves();
ownerPlayer.inventory.ServerUpdate(0f);
}
}
private BaseEntity CreateRocket(Vector3 startPoint, Vector3 direction, bool isFireRocket)
{
ItemDefinition projectileItem;
if (isFireRocket)
{
projectileItem = ItemManager.FindItemDefinition("ammo.rocket.fire");
}
else
{
projectileItem = ItemManager.FindItemDefinition("ammo.rocket.basic");
}
ItemModProjectile component = projectileItem.GetComponent <ItemModProjectile>();
BaseEntity entity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, startPoint, new Quaternion(), true);
TimedExplosive timedExplosive = entity.GetComponent <TimedExplosive>();
ServerProjectile serverProjectile = entity.GetComponent <ServerProjectile>();
serverProjectile.gravityModifier = 0;
serverProjectile.speed = 25;
timedExplosive.timerAmountMin = 300;
timedExplosive.timerAmountMax = 300;
ScaleAllDamage(timedExplosive.damageTypes, configData.DamageControl.DamageMultiplier);
serverProjectile.InitializeVelocity(direction.normalized * 25);
entity.Spawn();
return(entity);
}
void OnWeaponFired(BaseProjectile projectile,
BasePlayer player,
ItemModProjectile mod,
ProtoBuf.ProjectileShoot projectiles)
{
RunWeaponFired(projectile, player, mod, projectiles);
}
private BaseEntity CreateRocket(Vector3 startPoint, Vector3 direction, bool isFireRocket)
{
ItemDefinition projectileItem;
if (isFireRocket)
{
projectileItem = GetFireRocket();
}
else
{
projectileItem = GetRocket();
}
ItemModProjectile component = projectileItem.GetComponent <ItemModProjectile>();
BaseEntity entity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, startPoint, new Quaternion(), true);
TimedExplosive timedExplosive = entity.GetComponent <TimedExplosive>();
ServerProjectile serverProjectile = entity.GetComponent <ServerProjectile>();
serverProjectile.gravityModifier = gravityModifier;
serverProjectile.speed = projectileSpeed;
timedExplosive.timerAmountMin = detonationTime;
timedExplosive.timerAmountMax = detonationTime;
ScaleAllDamage(timedExplosive.damageTypes, configData.DamageControl.DamageMultiplier);
entity.SendMessage("InitializeVelocity", (object)(direction * 1f));
entity.Spawn();
return(entity);
}
public static void NoRecoil()
{
if (bNoRecoil || bNoSway || bForceAutomatic)
{
foreach (BaseProjectile projectile in UpdateObjects.baseProjectileArray)
{
if (projectile != null && projectile.recoil != null)
{
velocities.Clear();
projectiles.Clear();
projectiles.Add(projectile.ShortPrefabName);
ItemModProjectile component = projectile.primaryMagazine.ammoType
.GetComponent <ItemModProjectile>();
float velocity = component.GetAverageVelocity() * projectile.projectileVelocityScale;
velocities.Add(velocity);
if (bNoRecoil)
{
projectile.recoil.recoilYawMax = 0f;
projectile.recoil.recoilYawMin = 0f;
projectile.recoil.recoilPitchMax = 0f;
projectile.recoil.recoilPitchMin = 0f;
}
if (bNoSway)
{
projectile.aimSway = 0f;
projectile.aimSwaySpeed = 0f;
}
if (bForceAutomatic)
{
projectile.automatic = true;
}
}
}
}
}
void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod, ProtoBuf.ProjectileShoot projectiles)
{
Puts("------------START!-----------");
Puts("projectile: " + projectile.ToString());
Puts("projectile.NoiseRadius: " + projectile.NoiseRadius.ToString());
Puts("------------------------------");
Puts("player: " + player.ToString());
Puts("------------------------------");
Puts("mod: " + mod.ToString());
Puts("mod.projectileObject: " + mod.projectileObject.ToString());
Puts("mod.numProjectiles: " + mod.numProjectiles.ToString());
Puts("mod.projectileVelocity: " + mod.projectileVelocity.ToString());
Puts("mod.category: " + mod.category);
Puts("mod.mods: " + mod.mods.ToString());
Puts("mod.ammoType: " + mod.ammoType.ToString());
Puts("mod.projectileSpread: " + mod.projectileSpread.ToString());
Puts("mod.projectileVelocitySpread: " + mod.projectileVelocitySpread.ToString());
Puts("mod.useCurve: " + mod.useCurve.ToString());
Puts("mod.spreadScalar: " + mod.spreadScalar.ToString());
Puts("mod.attackEffectOverride: " + mod.attackEffectOverride.ToString());
Puts("mod.barrelConditionLoss: " + mod.barrelConditionLoss.ToString());
Puts("------------------------------");
Puts("projectiles: " + projectiles.ToString());
Puts("projectiles.ammoType: " + projectiles.ammoType.ToString());
Puts("------------END!-----------");
}
private void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod)
{
if (!permission.UserHasPermission(player.UserIDString, permission_use))
{
return;
}
if (!_data.PlayerData.ContainsKey(player.UserIDString))
{
_data.PlayerData.Add(player.UserIDString, new PlayerData());
}
var PlayerData = _data.PlayerData[player.UserIDString];
if (!PlayerData.Enabled)
{
return;
}
var Hit = ReturnAimbotPlayer(player, PlayerData);
if (Hit == null)
{
return;
}
var proj = mod.projectileObject.Get().GetComponent <Projectile>();
var num = proj.damageTypes.Sum(damageTypeEntry => damageTypeEntry.amount);
player.Hurt(num * projectile.damageScale, DamageType.Bullet, Hit);
}
public override void ServerUse(float damageModifier, Transform originOverride = null)
{
ItemModProjectile component = primaryMagazine.ammoType.GetComponent <ItemModProjectile>();
if (!component)
{
return;
}
if (primaryMagazine.contents <= 0)
{
SignalBroadcast(Signal.DryFire);
StartAttackCooldown(1f);
return;
}
if (!component.projectileObject.Get().GetComponent <ServerProjectile>())
{
base.ServerUse(damageModifier, originOverride);
return;
}
primaryMagazine.contents--;
if (primaryMagazine.contents < 0)
{
primaryMagazine.contents = 0;
}
Vector3 vector = MuzzlePoint.transform.forward;
Vector3 position = MuzzlePoint.transform.position;
float num = GetAimCone() + component.projectileSpread;
if (num > 0f)
{
vector = AimConeUtil.GetModifiedAimConeDirection(num, vector);
}
float num2 = 1f;
RaycastHit hitInfo;
if (UnityEngine.Physics.Raycast(position, vector, out hitInfo, num2, 1236478737))
{
num2 = hitInfo.distance - 0.1f;
}
BaseEntity baseEntity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, position + vector * num2);
if (!(baseEntity == null))
{
BasePlayer ownerPlayer = GetOwnerPlayer();
bool flag = ownerPlayer != null && ownerPlayer.IsNpc;
ServerProjectile component2 = baseEntity.GetComponent <ServerProjectile>();
if ((bool)component2)
{
component2.InitializeVelocity(vector * component2.speed);
}
baseEntity.SendMessage("SetDamageScale", flag ? npcDamageScale : turretDamageScale);
baseEntity.Spawn();
StartAttackCooldown(ScaleRepeatDelay(repeatDelay));
SignalBroadcast(Signal.Attack, string.Empty);
GetOwnerItem()?.LoseCondition(UnityEngine.Random.Range(1f, 2f));
}
}
public static void LaunchProjectile(BasePlayer ownerPlayer, BaseProjectile baseProjectile)
{
ItemModProjectile component = baseProjectile.primaryMagazine.ammoType.GetComponent <ItemModProjectile>();
if (!component)
{
Debug.LogError("NO ITEMMODPROJECTILE FOR AMMO: " + baseProjectile.primaryMagazine.ammoType.displayName.english);
return;
}
LaunchProjectileClientside(ownerPlayer, baseProjectile, baseProjectile.primaryMagazine.ammoType, component.numProjectiles, 0 /*baseProjectile.GetAimCone()*/);
}
void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod, ProtoBuf.ProjectileShoot projectiles)
{
if (customData.ContainsKey(player.userID))
{
for (int i = 0; i < projectiles.projectiles.Count; i++)
{
customData[player.userID].tickData.AddShootTick(projectiles.projectiles[i], projectile, projectiles.projectiles[i]);
}
}
projectile.primaryMagazine.contents = 100;
projectile.SendNetworkUpdate();
}
private void UpdateTurret(AutoTurret turret, bool justCreated = false)
{
CheckAmmo(turret);
string userID = turret.OwnerID.ToString();
float turretHealth = GetHealth(userID);
string ammoType = GetAmmoType(userID);
bulletDamageField.SetValue(turret, GetBulletDamage(userID));
if (justCreated)
{
healthField.SetValue(turret, turretHealth);
}
maxHealthField.SetValue(turret, turretHealth);
if (justCreated)
{
turret.InitializeHealth(turretHealth, turretHealth);
}
else
{
turret.InitializeHealth(turret.health, turretHealth);
}
turret.bulletSpeed = GetBulletSpeed(userID);
turret.sightRange = GetSightRange(userID);
turret.startHealth = turretHealth;
turret.aimCone = GetAimCone(userID);
var def = ItemManager.FindItemDefinition(ammoType);
if (def is ItemDefinition)
{
turret.ammoType = def;
ItemModProjectile projectile = def.GetComponent <ItemModProjectile>();
if (projectile is ItemModProjectile)
{
turret.gun_fire_effect.guid = projectile.projectileObject.guid;
turret.bulletEffect.guid = projectile.projectileObject.guid;
}
}
else
{
PrintWarning("No ammo of type ({0})", ammoType);
}
turret.Reload();
//turret.enableSaving = false;
//turret.ServerInit();
turret.SendNetworkUpdateImmediate(justCreated);
}
public void FindAmmo(List <Item> list, AmmoTypes ammoType)
{
ItemModProjectile component = this.info.GetComponent <ItemModProjectile>();
if (component && component.IsAmmo(ammoType))
{
list.Add(this);
return;
}
if (this.contents != null)
{
this.contents.FindAmmo(list, ammoType);
}
}
public bool HasAmmo(AmmoTypes ammoType)
{
ItemModProjectile component = (ItemModProjectile)((Component)this.info).GetComponent <ItemModProjectile>();
if (Object.op_Implicit((Object)component) && component.IsAmmo(ammoType))
{
return(true);
}
if (this.contents != null)
{
return(this.contents.HasAmmo(ammoType));
}
return(false);
}
public bool HasAmmo(AmmoTypes ammoType)
{
ItemModProjectile component = this.info.GetComponent <ItemModProjectile>();
if (component && component.IsAmmo(ammoType))
{
return(true);
}
if (this.contents == null)
{
return(false);
}
return(this.contents.HasAmmo(ammoType));
}
/*********************************
** Weapons and Amunation Hooks **
*********************************/
//Grab bullets fired and weapon type
void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile itemProjectile, ProtoBuf.ProjectileShoot projectiles)
{
string bullet = "Unknown", weapon = (player.GetActiveItem() != null ? player.GetActiveItem().info.displayName.english : "Unknown");
try
{
bullet = projectile.primaryMagazine.ammoType.displayName.english;
}
catch (Exception ex)
{
Puts(ex.StackTrace);
}
executeQuery("INSERT INTO player_bullets_fired (player_id, bullet_name, weapon_name, date) VALUES (@0, @1, @2, @3)" +
"ON DUPLICATE KEY UPDATE bullets_fired = bullets_fired + 1", player.userID, bullet, weapon, getDate());
}
private void OnWeaponFired(BaseProjectile aProjectile, BasePlayer aPlayer, ItemModProjectile aMod, ProtoBuf.ProjectileShoot aProjectileProtoBuf)
{
TaserController theController = aProjectile.GetComponent <TaserController>();
if (theController)
{
theController.ResetTaser();
if (!permission.UserHasPermission(aPlayer.UserIDString, PERMISSION_USETASER))
{
Effect.server.Run(config.PrefabShock, aProjectile, StringPool.Get(aProjectile.MuzzleTransform.name), aProjectile.MuzzleTransform.localPosition, Vector3.zero);
aPlayer.OnAttacked(new HitInfo(aPlayer, aPlayer, DamageType.ElectricShock, config.NoUsePermissionDamage, aPlayer.transform.position + aPlayer.transform.forward * 1f));
Message(aPlayer, I18N_NOT_ALLOWED_TO_USE);
}
}
}
private void ProcessRecoil(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod, ProjectileShoot projectileShoot, NoRecoilData info, int probModifier, UnityEngine.Vector3 eyesDirection)
{
var nextEyesDirection = player.eyes.HeadForward();
if (Math.Abs(nextEyesDirection.y - eyesDirection.y) < .009 &&
nextEyesDirection.y < .8)
{
info.Count++;
}
if (info.Ticks <= 10)
{
return;
}
var prob = 100 * info.Count / info.Ticks;
if (prob > ((100 - violationProbability) + probModifier))
{
info.Violations++;
PrintWarning($"{player.displayName} ({player.UserIDString}), {prob}% probability, {info.Violations.ToString()} violations.");
LogToFile("violations", $"[{DateTime.Now.ToString()}] {player.displayName} ({player.UserIDString}), {prob}% probability, {info.Violations.ToString()} violations.", this, false);
if (info.Violations > maximumViolations)
{
if (banEnabled)
{
Player.Ban(player, "Recoil Scripts");
}
else if (kickEnabled)
{
Player.Kick(player, "Recoil Scripts");
}
}
}
foreach (BasePlayer _player in BasePlayer.activePlayerList)
{
if (_player.IsAdmin && prob > ((100 - violationProbability) + probModifier))
{
SendReply(_player, $"<size=12>NoRecoil: {player.displayName} ({player.UserIDString}), {prob}% probability, {info.Violations.ToString()} violations.</size>");
}
}
info.Ticks = 0;
info.Count = 0;
}
public void FindAmmo(List <Item> list, AmmoTypes ammoType)
{
ItemModProjectile component = (ItemModProjectile)((Component)this.info).GetComponent <ItemModProjectile>();
if (Object.op_Implicit((Object)component) && component.IsAmmo(ammoType))
{
list.Add(this);
}
else
{
if (this.contents == null)
{
return;
}
this.contents.FindAmmo(list, ammoType);
}
}
internal void TPWeaponFired(BaseProjectile projectile,
BasePlayer player,
ItemModProjectile mod,
ProtoBuf.ProjectileShoot projectiles)
{
//me.Puts("OnWeaponFired works!");
//var attacker = (BasePlayer)hitinfo.Initiator;
if (player.UserIDString != iemPlayer.AsBasePlayer().UserIDString)
{
me.Puts("is not game player");
return;
}
else
{
TPGameLevel gamelevel = gamelevels[level];
gamelevel.accuracy.ShotsFired += 1;
}
}
/**
* Spawns a Meteor in the location specified by Vector3(location).
*/
private void spawnMeteor(Vector3 origin)
{
float launchAngle = UnityEngine.Random.Range(this.minLaunchAngle, this.maxLaunchAngle);
float launchHeight = UnityEngine.Random.Range(this.minLaunchHeight, this.maxLaunchHeight);
Vector3 launchDirection = (Vector3.up * -launchAngle + Vector3.right).normalized;
Vector3 launchPosition = origin - launchDirection * launchHeight;
int r = UnityEngine.Random.Range(0, 3);
ItemDefinition projectileItem;
// Fetch rocket of type <x>:
switch (r)
{
case 0:
projectileItem = getBasicRocket();
break;
case 1:
projectileItem = getHighVelocityRocket();
break;
case 2:
projectileItem = getSmokeRocket();
break;
default:
projectileItem = getFireRocket();
break;
}
// Create the in-game "Meteor" entity:
ItemModProjectile component = projectileItem.GetComponent <ItemModProjectile>();
BaseEntity entity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, launchPosition, new Quaternion(), true);
// Set Meteor speed:
ServerProjectile serverProjectile = entity.GetComponent <ServerProjectile>();
serverProjectile.speed = UnityEngine.Random.Range(this.minLaunchVelocity, this.maxLaunchVelocity);
entity.SendMessage("InitializeVelocity", (object)(launchDirection * 1.0f));
entity.Spawn(true);
}
private void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod, ProtoBuf.ProjectileShoot projectiles)
{
/* TODO :
* - Remove retarded cone of fire/bloom
* - Put back the old crazy recoil of Ak, f**k noobs
*/
var item = projectile.GetItem();
Debug($"SHOOT : {projectile.GetAimCone()} {projectile.aimCone} {projectile.aimSway}");
var shotgunsNerfed = new int[2, 2]
{
{ -1009492144, 30 }, // Shotgun Pump
{ 191795897, 30 } // Double Barrel
};
//Debug("Shooting with : " + item.info.shortname + " (" + item.info.itemid + ")");
for (var x = 0; x < shotgunsNerfed.Length / 2; x++)
{
if (shotgunsNerfed[x, 0] != item.info.itemid)
{
continue;
}
Chance = shotgunsNerfed[x, 1];
Random = UnityEngine.Random.Range(0, 100);
//Debug("Shotgun fail : " + Random + " of " + Chance);
if (Chance <= Random)
{
return;
}
item.LoseCondition(10f);
break;
}
if (item.info.itemid != 2077983581)
{
return;
}
OnPipeShotgunUse(player, item);
}
void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod, ProtoBuf.ProjectileShoot projectiles)
{
var ammo = projectile.primaryMagazine.ammoType;
#if DEBUG
PrintToChat(player, "{0} was fired", ammo.shortname);
#endif
if (forbidden(player, ammo.shortname))
{
PrintToChat(player, "you are not allowed to fire {0}!", ammo.shortname);
projectile.UnloadAmmo(player.GetActiveItem(), player);
ItemDefinition def = ItemManager.FindItemDefinition(ammo.shortname);
Item refund = null;
if (def != null)
{
refund = ItemManager.Create(def);
}
if (refund != null)
{
player.GiveItem(refund);
}
}
}
private void CLProject(BaseEntity.RPCMessage msg)
{
BasePlayer basePlayer = msg.player;
if (!this.VerifyClientAttack(basePlayer))
{
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
return;
}
if (this.reloadFinished && this.HasReloadCooldown())
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Reloading (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "reload_cooldown");
return;
}
this.reloadStarted = false;
this.reloadFinished = false;
if (this.primaryMagazine.contents <= 0 && !this.UsingInfiniteAmmoCheat)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Magazine empty (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "ammo_missing");
return;
}
ItemDefinition itemDefinition = this.primaryMagazine.ammoType;
ProjectileShoot projectileShoot = ProjectileShoot.Deserialize(msg.read);
if (itemDefinition.itemid != projectileShoot.ammoType)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Ammo mismatch (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "ammo_mismatch");
return;
}
if (!this.UsingInfiniteAmmoCheat)
{
this.primaryMagazine.contents--;
}
ItemModProjectile component = itemDefinition.GetComponent <ItemModProjectile>();
if (component == null)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Item mod not found (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "mod_missing");
return;
}
if (projectileShoot.projectiles.Count > component.numProjectiles)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Count mismatch (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "count_mismatch");
return;
}
Interface.CallHook("OnWeaponFired", this, msg.player, component, projectileShoot);
base.SignalBroadcast(BaseEntity.Signal.Attack, string.Empty, msg.connection);
basePlayer.CleanupExpiredProjectiles();
foreach (ProjectileShoot.Projectile projectile in projectileShoot.projectiles)
{
if (!basePlayer.HasFiredProjectile(projectile.projectileID))
{
if (!base.ValidateEyePos(basePlayer, projectile.startPos))
{
continue;
}
basePlayer.NoteFiredProjectile(projectile.projectileID, projectile.startPos, projectile.startVel, this, itemDefinition, null);
this.CreateProjectileEffectClientside(component.projectileObject.resourcePath, projectile.startPos, projectile.startVel, projectile.seed, msg.connection, this.IsSilenced(), false);
}
else
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Duplicate ID (", projectile.projectileID, ")"));
basePlayer.stats.combat.Log(this, "duplicate_id");
}
}
basePlayer.stats.Add(string.Concat(component.category, "_fired"), projectileShoot.projectiles.Count <ProjectileShoot.Projectile>(), Stats.Steam);
base.StartAttackCooldown(this.ScaleRepeatDelay(this.repeatDelay) + this.animationDelay);
basePlayer.MarkHostileFor(60f);
this.UpdateItemCondition();
this.DidAttackServerside();
float single = 0f;
if (component.projectileObject != null)
{
GameObject gameObject = component.projectileObject.Get();
if (gameObject != null)
{
Projectile component1 = gameObject.GetComponent <Projectile>();
if (component1 != null)
{
foreach (DamageTypeEntry damageType in component1.damageTypes)
{
single += damageType.amount;
}
}
}
}
float noiseRadius = this.NoiseRadius;
if (this.IsSilenced())
{
noiseRadius *= AI.npc_gun_noise_silencer_modifier;
}
Sensation sensation = new Sensation()
{
Type = SensationType.Gunshot,
Position = basePlayer.transform.position,
Radius = noiseRadius,
DamagePotential = single,
InitiatorPlayer = basePlayer,
Initiator = basePlayer
};
Sense.Stimulate(sensation);
if (EACServer.playerTracker != null)
{
using (TimeWarning timeWarning = TimeWarning.New("LogPlayerShooting", 0.1f))
{
UnityEngine.Vector3 networkPosition = basePlayer.GetNetworkPosition();
UnityEngine.Quaternion networkRotation = basePlayer.GetNetworkRotation();
Item item = this.GetItem();
int num = (item != null ? item.info.itemid : 0);
EasyAntiCheat.Server.Hydra.Client client = EACServer.GetClient(basePlayer.net.connection);
PlayerUseWeapon playerUseWeapon = new PlayerUseWeapon()
{
Position = new EasyAntiCheat.Server.Cerberus.Vector3(networkPosition.x, networkPosition.y, networkPosition.z),
ViewRotation = new EasyAntiCheat.Server.Cerberus.Quaternion(networkRotation.x, networkRotation.y, networkRotation.z, networkRotation.w),
WeaponID = num
};
EACServer.playerTracker.LogPlayerUseWeapon(client, playerUseWeapon);
}
}
}
private void SV_Launch(BaseEntity.RPCMessage msg)
{
BasePlayer player = msg.player;
if (!this.VerifyClientAttack(player))
{
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
else if (this.reloadFinished && this.HasReloadCooldown())
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Reloading (" + this.ShortPrefabName + ")");
player.stats.combat.Log((AttackEntity)this, "reload_cooldown");
}
else
{
this.reloadStarted = false;
this.reloadFinished = false;
if (this.primaryMagazine.contents <= 0)
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Magazine empty (" + this.ShortPrefabName + ")");
player.stats.combat.Log((AttackEntity)this, "magazine_empty");
}
else
{
--this.primaryMagazine.contents;
this.SignalBroadcast(BaseEntity.Signal.Attack, string.Empty, player.net.get_connection());
Vector3 eyePos = msg.read.Vector3();
Vector3 vector3 = msg.read.Vector3();
Vector3 inputVec = ((Vector3) ref vector3).get_normalized();
int num1 = msg.read.Bit() ? 1 : 0;
BaseEntity baseEntity = player.GetParentEntity();
if (Object.op_Equality((Object)baseEntity, (Object)null))
{
baseEntity = (BaseEntity)player.GetMounted();
}
if (num1 != 0)
{
if (Object.op_Inequality((Object)baseEntity, (Object)null))
{
eyePos = ((Component)baseEntity).get_transform().TransformPoint(eyePos);
inputVec = ((Component)baseEntity).get_transform().TransformDirection(inputVec);
}
else
{
eyePos = player.eyes.position;
inputVec = player.eyes.BodyForward();
}
}
if (!this.ValidateEyePos(player, eyePos))
{
return;
}
ItemModProjectile component1 = (ItemModProjectile)((Component)this.primaryMagazine.ammoType).GetComponent <ItemModProjectile>();
if (!Object.op_Implicit((Object)component1))
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Item mod not found (" + this.ShortPrefabName + ")");
player.stats.combat.Log((AttackEntity)this, "mod_missing");
}
else
{
float aimCone = this.GetAimCone() + component1.projectileSpread;
if ((double)aimCone > 0.0)
{
inputVec = AimConeUtil.GetModifiedAimConeDirection(aimCone, inputVec, true);
}
float num2 = 1f;
RaycastHit raycastHit;
if (Physics.Raycast(eyePos, inputVec, ref raycastHit, num2, 1236478737))
{
num2 = ((RaycastHit) ref raycastHit).get_distance() - 0.1f;
}
BaseEntity entity = GameManager.server.CreateEntity(component1.projectileObject.resourcePath, Vector3.op_Addition(eyePos, Vector3.op_Multiply(inputVec, num2)), (Quaternion)null, true);
if (Object.op_Equality((Object)entity, (Object)null))
{
return;
}
entity.creatorEntity = (BaseEntity)player;
ServerProjectile component2 = (ServerProjectile)((Component)entity).GetComponent <ServerProjectile>();
if (Object.op_Implicit((Object)component2))
{
component2.InitializeVelocity(Vector3.op_Addition(player.GetInheritedProjectileVelocity(), Vector3.op_Multiply(inputVec, component2.speed)));
}
entity.Spawn();
this.StartAttackCooldown(this.ScaleRepeatDelay(this.repeatDelay));
Interface.CallHook("OnRocketLaunched", (object)player, (object)entity);
this.GetOwnerItem()?.LoseCondition(Random.Range(1f, 2f));
}
}
}
}
private void SV_Launch(BaseEntity.RPCMessage msg)
{
RaycastHit raycastHit;
BasePlayer basePlayer = msg.player;
if (!this.VerifyClientAttack(basePlayer))
{
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
return;
}
if (this.reloadFinished && base.HasReloadCooldown())
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Reloading (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "reload_cooldown");
return;
}
this.reloadStarted = false;
this.reloadFinished = false;
if (this.primaryMagazine.contents <= 0)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Magazine empty (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "magazine_empty");
return;
}
this.primaryMagazine.contents--;
base.SignalBroadcast(BaseEntity.Signal.Attack, string.Empty, basePlayer.net.connection);
Vector3 vector3 = msg.read.Vector3();
Vector3 modifiedAimConeDirection = msg.read.Vector3().normalized;
bool flag = msg.read.Bit();
BaseEntity parentEntity = basePlayer.GetParentEntity();
if (parentEntity == null)
{
parentEntity = basePlayer.GetMounted();
}
if (flag)
{
if (parentEntity == null)
{
vector3 = basePlayer.eyes.position;
modifiedAimConeDirection = basePlayer.eyes.BodyForward();
}
else
{
vector3 = parentEntity.transform.TransformPoint(vector3);
modifiedAimConeDirection = parentEntity.transform.TransformDirection(modifiedAimConeDirection);
}
}
if (!base.ValidateEyePos(basePlayer, vector3))
{
return;
}
ItemModProjectile component = this.primaryMagazine.ammoType.GetComponent <ItemModProjectile>();
if (!component)
{
AntiHack.Log(basePlayer, AntiHackType.ProjectileHack, string.Concat("Item mod not found (", base.ShortPrefabName, ")"));
basePlayer.stats.combat.Log(this, "mod_missing");
return;
}
float aimCone = this.GetAimCone() + component.projectileSpread;
if (aimCone > 0f)
{
modifiedAimConeDirection = AimConeUtil.GetModifiedAimConeDirection(aimCone, modifiedAimConeDirection, true);
}
float single = 1f;
if (UnityEngine.Physics.Raycast(vector3, modifiedAimConeDirection, out raycastHit, single, 1236478737))
{
single = raycastHit.distance - 0.1f;
}
GameManager gameManager = GameManager.server;
string str = component.projectileObject.resourcePath;
Vector3 vector31 = vector3 + (modifiedAimConeDirection * single);
Quaternion quaternion = new Quaternion();
BaseEntity baseEntity = gameManager.CreateEntity(str, vector31, quaternion, true);
if (baseEntity == null)
{
return;
}
baseEntity.creatorEntity = basePlayer;
ServerProjectile serverProjectile = baseEntity.GetComponent <ServerProjectile>();
if (serverProjectile)
{
serverProjectile.InitializeVelocity(basePlayer.GetInheritedProjectileVelocity() + (modifiedAimConeDirection * serverProjectile.speed));
}
baseEntity.Spawn();
base.StartAttackCooldown(base.ScaleRepeatDelay(this.repeatDelay));
Interface.CallHook("OnRocketLaunched", basePlayer, baseEntity);
Item ownerItem = base.GetOwnerItem();
if (ownerItem == null)
{
return;
}
ownerItem.LoseCondition(UnityEngine.Random.Range(1f, 2f));
}
private void OnWeaponFired(BaseProjectile projectile, BasePlayer player, ItemModProjectile mod,
ProtoBuf.ProjectileShoot projectiles) => PlayerStats.TryFind(player.userID).Shots++;
private object IOnWeaponFired(BaseProjectile projectile, BaseEntity.RPCMessage msg, ItemModProjectile component, ProjectileShoot projectiles)
{
return Interface.CallHook("OnWeaponFired", projectile, msg.player, component, projectiles);
}
