// Token: 0x06000291 RID: 657 RVA: 0x00017940 File Offset: 0x00015B40
public void OnGUI()
{
if (!DrawUtilities.ShouldRun())
{
return;
}
if (WeaponComponent.MainCamera == null)
{
WeaponComponent.MainCamera = Camera.main;
}
if (WeaponOptions.NoSway && Player.player.animator != null)
{
Player.player.animator.viewSway = Vector3.zero;
}
if (Event.current.type == EventType.Repaint)
{
if (WeaponOptions.ShowWeaponInfo)
{
ItemAsset asset = Player.player.equipment.asset;
if (asset == null)
{
return;
}
string content = asset.itemName;
GUI.depth = 0;
if (asset is ItemWeaponAsset)
{
ItemWeaponAsset itemWeaponAsset = (ItemWeaponAsset)asset;
content = string.Format("{0}\nДальность: {1}\nУрон: {2}", itemWeaponAsset.itemName, itemWeaponAsset.range, itemWeaponAsset.playerDamageMultiplier.damage);
}
DrawUtilities.DrawLabel(ESPComponent.ESPFont, LabelLocation.MiddleLeft, new Vector2((float)(Screen.width - 20), (float)(Screen.height / 2)), content, ColorUtilities.getColor("_WeaponInfoColor"), 1, 15);
}
return;
}
}
// Token: 0x06000238 RID: 568 RVA: 0x00015488 File Offset: 0x00013688
public static bool GenerateRaycast(out RaycastInfo info)
{
ItemWeaponAsset itemWeaponAsset = Player.player.equipment.asset as ItemWeaponAsset;
float range = (itemWeaponAsset != null) ? Mathf.Max(itemWeaponAsset.range, 20f) : 20f;
GameObject @object;
Vector3 point;
if (!RaycastUtilities.GetTargetObject(out @object, out point, range))
{
info = RaycastUtilities.GenerateOriginalRaycast(new Ray(Player.player.look.aim.position, Player.player.look.aim.forward), range, RayMasks.DAMAGE_CLIENT, null);
return(false);
}
info = RaycastUtilities.GenerateRaycast(@object, point);
return(true);
}
public void onWindow(int ID)
{
norecoil = GUILayout.Toggle(norecoil, "NoRecoil");
nospread = GUILayout.Toggle(nospread, "NoSpread");
rapidfire = GUILayout.Toggle(rapidfire, "RapidFire");
if (tool_ToolZ.getLocalPlayer().equipment.asset != null && tool_ToolZ.getLocalPlayer().equipment.asset is ItemWeaponAsset && tool_ToolZ.getLocalPlayer().equipment.asset is ItemMeleeAsset)
{
ItemWeaponAsset ima = (ItemWeaponAsset)tool_ToolZ.getLocalPlayer().equipment.asset;
new_range = ima.range;
GUILayout.Label("Reach: " + ima.range);
new_range = (float)Math.Round(GUILayout.HorizontalSlider(new_range, 1f, 26f), 0);
updateFarReach();
}
if (GUILayout.Button("Close Menu"))
{
isOn = false;
}
GUI.DragWindow();
}
public WAssetSave(ItemGunAsset asset)
{
this.asset = asset;
recoilMax_x = asset.recoilMax_x;
recoilMax_y = asset.recoilMax_y;
recoilMin_x = asset.recoilMin_x;
recoilMin_y = asset.recoilMin_y;
spreadAim = asset.spreadAim;
spreadHip = asset.spreadHip;
shakeMax_x = asset.shakeMax_x;
shakeMax_y = asset.shakeMax_y;
shakeMax_z = asset.shakeMax_z;
shakeMin_x = asset.shakeMin_x;
shakeMin_y = asset.shakeMin_y;
shakeMin_z = asset.shakeMin_z;
range = asset.range;
}
public static bool SetVehicleDamage(ItemWeaponAsset asset, float damage)
{
asset.vehicleDamage = damage;
return(true);
}
public static bool SetStructureDamage(ItemWeaponAsset asset, float damage)
{
asset.structureDamage = damage;
return(true);
}
public static bool SetBarricadeDamage(ItemWeaponAsset asset, float damage)
{
asset.barricadeDamage = damage;
return(true);
}
public static bool SetAnimalSkullMultiplier(ItemWeaponAsset asset, float multiplier)
{
asset.animalDamageMultiplier.skull = multiplier;
return(true);
}
public static bool SetIsInvulnerable(ItemWeaponAsset asset, bool isInvulnerable)
{
asset.isInvulnerable = isInvulnerable;
return(true);
}
public static bool SetPlayerSkullMultiplier(ItemWeaponAsset asset, float multiplier)
{
asset.playerDamageMultiplier.skull = multiplier;
return(true);
}
public static bool SetPlayerDamage(ItemWeaponAsset asset, float damage)
{
asset.playerDamageMultiplier.damage = damage;
return(true);
}
public static RaycastInfo OV_raycast(Ray ray, float range, int mask)
{
ItemWeaponAsset weapon = (ItemWeaponAsset)Player.player.equipment.asset;
/*if (MenuGUI.instance.LongRangeMelee && weapon == null)
* {
* range = MenuGUI.instance.MeleeRange;
* }*/
range = Mathf.Infinity;
RaycastHit hit;
PhysicsUtility.raycast(ray, out hit, range, mask, 0);
RaycastInfo raycastInfo = new RaycastInfo(hit);
if (MenuGUI.instance.silentAim)
{
if (hit.transform == null && Functions.GetDistance(Functions.GetNearestPlayer().transform.position) >= Functions.GetGunDistance())
{
return(raycastInfo);
}
}
if (hit.transform.CompareTag("Zombie"))
{
raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
}
if (hit.transform.CompareTag("Animal"))
{
raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
}
raycastInfo.direction = new Vector3(0, MenuGUI.instance.launchAmount, 0);
if (MenuGUI.instance.silentAim && !hit.transform.CompareTag("Zombie"))
{
if (Functions.GetDistFrom(Functions.GetNearestPlayer().transform.position, Player.player.look.aim.position) <= 15.5)
{
raycastInfo.point = Player.player.transform.position;
}
else
{
raycastInfo.point = Functions.GetLimbPosition(Functions.GetNearestPlayer().transform, "Skull");
}
if (MenuGUI.instance.randomLimb)
{
ELimb[] array = (ELimb[])Enum.GetValues(typeof(ELimb));
raycastInfo.limb = array[Random.Next(0, array.Length)];
}
else
{
raycastInfo.limb = ELimb.SKULL;
}
raycastInfo.player = Functions.GetNearestPlayer();
}
else
{
raycastInfo.limb = DamageTool.getLimb(hit.transform);
if (hit.transform.CompareTag("Enemy"))
{
raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
}
}
if (hit.transform.CompareTag("Vehicle"))
{
raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
}
if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
{
raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
}
else
{
raycastInfo.material = EPhysicsMaterial.NONE;
}
return(raycastInfo);
}
private void OnPrePreLevelLoaded(int level)
{
Asset[] AssetList = Assets.find(EAssetType.ITEM);
ushort gunsModified = 0;
ushort meleesModified = 0;
ushort throwablesModified = 0;
ushort trapsModified = 0;
ushort chargesModified = 0;
ushort vehiclesModified = 0;
ushort magsModified = 0;
ushort elementsModified = 0;
Logger.LogWarning("Starting anti grief modification run.");
BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.NonPublic;
bool shouldUpdateCount;
for (int i = 0; i < AssetList.Length; i++)
{
shouldUpdateCount = false;
Asset asset = AssetList[i];
bool shouldSkip = false;
// Look for and skip id's in the skil lists.
for (int si = 0; si < Configuration.Instance.SkipItemIDs.Count; si++)
{
if (asset.id == Configuration.Instance.SkipItemIDs[si])
{
shouldSkip = true;
break;
}
}
for (int se = 0; se < Configuration.Instance.SkipElementIDs.Count; se++)
{
if (asset.id == Configuration.Instance.SkipElementIDs[se])
{
shouldSkip = true;
break;
}
}
if (shouldSkip)
{
continue;
}
// Run though updating the items/elements/vehicles on the server.
if (asset is ItemWeaponAsset)
{
ItemWeaponAsset weaponAsset = asset as ItemWeaponAsset;
// Start modifying weapon type bundles, but skip the blowtorch(76) as that heals structures.
if (weaponAsset.barricadeDamage > 0 && Configuration.Instance.NegateBarricadeDamage && weaponAsset.id != 76)
{
weaponAsset.barricadeDamage = 0;
shouldUpdateCount = true;
}
if (weaponAsset.structureDamage > 0 && Configuration.Instance.NegateStructureDamage && weaponAsset.id != 76)
{
weaponAsset.structureDamage = 0;
shouldUpdateCount = true;
}
if (weaponAsset.vehicleDamage > 0 && Configuration.Instance.NegateVehicleDamage && weaponAsset.id != 76)
{
weaponAsset.vehicleDamage = 0;
shouldUpdateCount = true;
}
if (weaponAsset.objectDamage > 0 && Configuration.Instance.NegateObjectDamage)
{
weaponAsset.objectDamage = 0;
shouldUpdateCount = true;
}
// Don't change resource damage for resource gathering weapons: Camp Axe(16), Fire Axe(104), Chain Saw(490), Pickaxe(1198), Jackhammer(1475).
if (weaponAsset.resourceDamage > 0 && Configuration.Instance.NegateResourceDamage && weaponAsset.id != 16 && weaponAsset.id != 104 && weaponAsset.id != 490 && weaponAsset.id != 1198 && weaponAsset.id != 1475)
{
weaponAsset.resourceDamage = 0;
shouldUpdateCount = true;
}
if (shouldUpdateCount)
{
if (weaponAsset is ItemGunAsset)
{
gunsModified++;
}
if (weaponAsset is ItemMeleeAsset)
{
meleesModified++;
}
if (weaponAsset is ItemThrowableAsset)
{
throwablesModified++;
}
}
}
else if (asset is ItemTrapAsset)
{
ItemTrapAsset trapAsset = asset as ItemTrapAsset;
if (trapAsset.barricadeDamage > 0 && Configuration.Instance.NegateBarricadeDamage)
{
trapAsset.barricadeDamage = 0;
shouldUpdateCount = true;
}
if (trapAsset.structureDamage > 0 && Configuration.Instance.NegateStructureDamage)
{
trapAsset.structureDamage = 0;
shouldUpdateCount = true;
}
if (trapAsset.vehicleDamage > 0 && Configuration.Instance.NegateVehicleDamage)
{
trapAsset.vehicleDamage = 0;
shouldUpdateCount = true;
}
if (trapAsset.objectDamage > 0 && Configuration.Instance.NegateObjectDamage)
{
trapAsset.objectDamage = 0;
shouldUpdateCount = true;
}
if (trapAsset.resourceDamage > 0 && Configuration.Instance.NegateResourceDamage)
{
trapAsset.resourceDamage = 0;
shouldUpdateCount = true;
}
if (shouldUpdateCount)
{
trapsModified++;
}
}
else if (asset is ItemChargeAsset)
{
ItemChargeAsset chargeAsset = asset as ItemChargeAsset;
if (chargeAsset.barricadeDamage > 0 && Configuration.Instance.NegateBarricadeDamage)
{
chargeAsset.barricadeDamage = 0;
shouldUpdateCount = true;
}
if (chargeAsset.structureDamage > 0 && Configuration.Instance.NegateStructureDamage)
{
chargeAsset.structureDamage = 0;
shouldUpdateCount = true;
}
if (chargeAsset.vehicleDamage > 0 && Configuration.Instance.NegateVehicleDamage)
{
chargeAsset.vehicleDamage = 0;
shouldUpdateCount = true;
}
if (chargeAsset.objectDamage > 0 && Configuration.Instance.NegateObjectDamage)
{
chargeAsset.objectDamage = 0;
shouldUpdateCount = true;
}
if (chargeAsset.resourceDamage > 0 && Configuration.Instance.NegateResourceDamage)
{
chargeAsset.resourceDamage = 0;
shouldUpdateCount = true;
}
if (shouldUpdateCount)
{
chargesModified++;
}
}
else if (asset is ItemMagazineAsset)
{
ItemMagazineAsset magAsset = asset as ItemMagazineAsset;
if (magAsset.barricadeDamage > 0 && Configuration.Instance.NegateBarricadeDamage)
{
magAsset.barricadeDamage = 0;
shouldUpdateCount = true;
}
if (magAsset.structureDamage > 0 && Configuration.Instance.NegateStructureDamage)
{
magAsset.structureDamage = 0;
shouldUpdateCount = true;
}
if (magAsset.vehicleDamage > 0 && Configuration.Instance.NegateVehicleDamage)
{
magAsset.vehicleDamage = 0;
shouldUpdateCount = true;
}
if (magAsset.objectDamage > 0 && Configuration.Instance.NegateObjectDamage)
{
magAsset.objectDamage = 0;
shouldUpdateCount = true;
}
if (magAsset.resourceDamage > 0 && Configuration.Instance.NegateResourceDamage)
{
magAsset.resourceDamage = 0;
shouldUpdateCount = true;
}
if (shouldUpdateCount)
{
magsModified++;
}
}
shouldUpdateCount = false;
if (asset is ItemBarricadeAsset)
{
ItemBarricadeAsset basset = asset as ItemBarricadeAsset;
if (basset.health < Configuration.Instance.MinElementSpawnHealth && Configuration.Instance.ModifyMinElementSpawnHealth)
{
basset.GetType().GetField("_health", bindingFlags).SetValue(basset, Configuration.Instance.MinElementSpawnHealth);
shouldUpdateCount = true;
}
if (!basset.proofExplosion && Configuration.Instance.MakeElementsExplosionProof && (Configuration.Instance.MakeElementsExplosionProofIncludeTraps ? true : !(asset is ItemTrapAsset)))
{
basset.GetType().GetField("_proofExplosion", bindingFlags).SetValue(basset, true);
shouldUpdateCount = true;
}
if (basset.isVulnerable && Configuration.Instance.MakeElementsInvulnerable)
{
basset.GetType().GetField("_isVulnerable", bindingFlags).SetValue(basset, false);
shouldUpdateCount = true;
}
if ((basset.build == EBuild.SIGN || basset.build == EBuild.SIGN_WALL || basset.build == EBuild.NOTE) && !basset.isLocked && Configuration.Instance.MakeSignsLocked)
{
basset.GetType().GetField("_isLocked", bindingFlags).SetValue(basset, true);
shouldUpdateCount = true;
}
}
if (asset is ItemStructureAsset)
{
ItemStructureAsset sasset = asset as ItemStructureAsset;
if (sasset.health < Configuration.Instance.MinElementSpawnHealth && Configuration.Instance.ModifyMinElementSpawnHealth)
{
sasset.GetType().GetField("_health", bindingFlags).SetValue(sasset, Configuration.Instance.MinElementSpawnHealth);
shouldUpdateCount = true;
}
if (!sasset.proofExplosion && Configuration.Instance.MakeElementsExplosionProof)
{
sasset.GetType().GetField("_proofExplosion", bindingFlags).SetValue(sasset, true);
shouldUpdateCount = true;
}
if (sasset.isVulnerable && Configuration.Instance.MakeElementsInvulnerable)
{
sasset.GetType().GetField("_isVulnerable", bindingFlags).SetValue(sasset, false);
shouldUpdateCount = true;
}
}
if (asset is ItemStorageAsset)
{
ItemStorageAsset stasset = asset as ItemStorageAsset;
// make displays locked, or normal unlocked containers locked(excluding the airdrop container.).
if ((stasset.isDisplay && !stasset.isLocked && Configuration.Instance.MakeDisplaysLocked) || (!stasset.isLocked && Configuration.Instance.MakeContainersLocked && stasset.id != 1374))
{
stasset.GetType().GetField("_isLocked", bindingFlags).SetValue(stasset, true);
shouldUpdateCount = true;
}
if (stasset.isDisplay && Configuration.Instance.ModDisplayGrid)
{
if (stasset.storage_y < Configuration.Instance.DisplayGridY)
{
stasset.GetType().GetField("_storage_y", bindingFlags).SetValue(stasset, Configuration.Instance.DisplayGridY);
shouldUpdateCount = true;
}
if (stasset.storage_x < Configuration.Instance.DisplayGridX)
{
stasset.GetType().GetField("_storage_x", bindingFlags).SetValue(stasset, Configuration.Instance.DisplayGridX);
shouldUpdateCount = true;
}
}
}
if (shouldUpdateCount)
{
elementsModified++;
}
}
Asset[] vehicleList = Assets.find(EAssetType.VEHICLE);
for (int v = 0; v < vehicleList.Length; v++)
{
shouldUpdateCount = false;
Asset asset = vehicleList[v];
bool shouldSkip = false;
for (int i = 0; i < Configuration.Instance.SkipVehicleIDs.Count; i++)
{
if (asset.id == Configuration.Instance.SkipVehicleIDs[i])
{
shouldSkip = true;
break;
}
}
if (shouldSkip == true)
{
continue;
}
VehicleAsset vAsset = asset as VehicleAsset;
if ((vAsset.isVulnerable || vAsset.isVulnerableToBumper || vAsset.isVulnerableToEnvironment || vAsset.isVulnerableToExplosions) && Configuration.Instance.MakeVehiclesInvulnerable)
{
vAsset.isVulnerable = false;
vAsset.isVulnerableToBumper = false;
vAsset.isVulnerableToEnvironment = false;
vAsset.isVulnerableToExplosions = false;
shouldUpdateCount = true;
}
if (vAsset.isVulnerableToExplosions && Configuration.Instance.MakeVehiclesInvulnerableExplosions)
{
vAsset.isVulnerableToExplosions = false;
shouldUpdateCount = true;
}
if (vAsset.canTiresBeDamaged && Configuration.Instance.MakeTiresInvulnerable)
{
vAsset.canTiresBeDamaged = false;
shouldUpdateCount = true;
}
if (vAsset.healthMax < Configuration.Instance.MinVehicleSpawnHealth && Configuration.Instance.ModifyMinVehicleSpawnHealth)
{
vAsset.GetType().GetField("_healthMax", bindingFlags).SetValue(vAsset, Configuration.Instance.MinVehicleSpawnHealth);
shouldUpdateCount = true;
}
if (!vAsset.supportsMobileBuildables && Configuration.Instance.VehicleSetMobileBuildables)
{
vAsset.GetType().GetProperty("supportsMobileBuildables", bindingFlags | BindingFlags.Public).SetValue(vAsset, true, null);
// Bundle hash needs to be disabled for these, as this flag for this needs to be set client side as well.
vAsset.GetType().GetField("_shouldVerifyHash", bindingFlags).SetValue(vAsset, false);
shouldUpdateCount = true;
}
if (shouldUpdateCount)
{
vehiclesModified++;
}
}
Logger.LogWarning(string.Format("Finished modification run, counts of bundles modified: Guns: {0}, Mags: {6}, Melee: {1}, Throwables: {2}, Traps: {3}, Charges: {4}, Vehicles: {5}, Elements: {7}.", gunsModified, meleesModified, throwablesModified, trapsModified, chargesModified, vehiclesModified, magsModified, elementsModified));
}
public static bool Prefix(InteractableSentry __instance)
{
RocketPlayer ownerPlayer = new RocketPlayer(__instance.owner.ToString());
bool hasWeapon = (bool)hasWeaponField.GetValue(__instance);
bool isFiring = (bool)isFiringField.GetValue(__instance);
bool isAiming = (bool)isAimingField.GetValue(__instance);
float lastScan = (float)lastScanField.GetValue(__instance);
float lastFire = (float)lastFireField.GetValue(__instance);
float fireTime = (float)fireTimeField.GetValue(__instance);
float lastAim = (float)lastAimField.GetValue(__instance);
ItemWeaponAsset displayAsset = displayAssetField.GetValue(__instance) as ItemWeaponAsset;
Attachments attachments = attachmentsField.GetValue(__instance) as Attachments;
bool interact = (bool)interactField.GetValue(__instance);
var playersInRadius = (List <Player>)playersInRadiusField.GetValue(null);
var zombiesInRadius = (List <Zombie>)zombiesInRadiusField.GetValue(null);
var animalsInRadius = (List <Animal>)animalsInRadiusField.GetValue(null);
var targetPlayer = targetPlayerField.GetValue(__instance) as Player;
var targetZombie = targetZombieField.GetValue(__instance) as Zombie;
var targetAnimal = targetAnimalField.GetValue(__instance) as Animal;
var aimTransform = aimTransformField.GetValue(__instance) as Transform;
if (__instance.isPowered)
{
Vector3 vector3_1 = __instance.transform.position + new Vector3(0.0f, 0.65f, 0.0f);
Vector3 vector3_2;
if ((double)Time.realtimeSinceStartup - (double)lastScan > 0.100000001490116)
{
lastScanField.SetValue(__instance, Time.realtimeSinceStartup);
float a = 48f;
if (hasWeapon)
{
a = Mathf.Min(a, ((ItemWeaponAsset)displayAsset).range);
}
float sqrRadius = a * a;
float num = sqrRadius;
Player player = (Player)null;
Zombie zombie = (Zombie)null;
Animal animal = (Animal)null;
if (Provider.isPvP)
{
playersInRadius.Clear();
PlayerTool.getPlayersInRadius(vector3_1, sqrRadius, playersInRadius);
for (int index = 0; index < playersInRadius.Count; ++index)
{
Player playersInRadiu = playersInRadius[index];
var currentRocketPlayer = new RocketPlayer(playersInRadiu.channel.owner.playerID.steamID.ToString());
if (currentRocketPlayer.HasPermission(GodPermission))
{
continue;
}
if (!(playersInRadiu.channel.owner.playerID.steamID == __instance.owner) && !playersInRadiu.quests.isMemberOfGroup(__instance.group) && (!playersInRadiu.life.isDead && playersInRadiu.animator.gesture != EPlayerGesture.ARREST_START) && ((!playersInRadiu.movement.isSafe || !playersInRadiu.movement.isSafeInfo.noWeapons) && playersInRadiu.movement.canAddSimulationResultsToUpdates) && (!((UnityEngine.Object)player != (UnityEngine.Object)null) || playersInRadiu.animator.gesture != EPlayerGesture.SURRENDER_START) && (__instance.sentryMode != ESentryMode.FRIENDLY || (double)Time.realtimeSinceStartup - (double)playersInRadiu.equipment.lastPunching < 2.0 || playersInRadiu.equipment.isSelected && playersInRadiu.equipment.asset != null && playersInRadiu.equipment.asset.shouldFriendlySentryTargetUser))
{
vector3_2 = playersInRadiu.look.aim.position - vector3_1;
float sqrMagnitude = vector3_2.sqrMagnitude;
if ((double)sqrMagnitude <= (double)num)
{
Vector3 vector3_3 = playersInRadiu.look.aim.position - vector3_1;
float magnitude = vector3_3.magnitude;
Vector3 vector3_4 = vector3_3 / magnitude;
if (!((UnityEngine.Object)playersInRadiu != (UnityEngine.Object)targetPlayer) || (double)Vector3.Dot(vector3_4, aimTransform.forward) >= 0.5)
{
if ((double)magnitude > 0.025000000372529)
{
RaycastHit hit;
PhysicsUtility.raycast(new Ray(vector3_1, vector3_4), out hit, magnitude - 0.025f, RayMasks.BLOCK_SENTRY, QueryTriggerInteraction.UseGlobal);
if (!((UnityEngine.Object)hit.transform != (UnityEngine.Object)null) || !((UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform))
{
PhysicsUtility.raycast(new Ray(vector3_1 + vector3_4 * (magnitude - 0.025f), -vector3_4), out hit, magnitude - 0.025f, RayMasks.DAMAGE_SERVER, QueryTriggerInteraction.UseGlobal);
if ((UnityEngine.Object)hit.transform != (UnityEngine.Object)null && (UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform)
{
continue;
}
}
else
{
continue;
}
}
num = sqrMagnitude;
player = playersInRadiu;
}
}
}
}
}
zombiesInRadius.Clear();
ZombieManager.getZombiesInRadius(vector3_1, sqrRadius, zombiesInRadius);
for (int index = 0; index < zombiesInRadius.Count; ++index)
{
Zombie zombiesInRadiu = zombiesInRadius[index];
if (!zombiesInRadiu.isDead && zombiesInRadiu.isHunting)
{
Vector3 position = zombiesInRadiu.transform.position;
switch (zombiesInRadiu.speciality)
{
case EZombieSpeciality.NORMAL:
position += new Vector3(0.0f, 1.75f, 0.0f);
break;
case EZombieSpeciality.MEGA:
position += new Vector3(0.0f, 2.625f, 0.0f);
break;
case EZombieSpeciality.CRAWLER:
position += new Vector3(0.0f, 0.25f, 0.0f);
break;
case EZombieSpeciality.SPRINTER:
position += new Vector3(0.0f, 1f, 0.0f);
break;
}
vector3_2 = position - vector3_1;
float sqrMagnitude = vector3_2.sqrMagnitude;
if ((double)sqrMagnitude <= (double)num)
{
Vector3 vector3_3 = position - vector3_1;
float magnitude = vector3_3.magnitude;
Vector3 vector3_4 = vector3_3 / magnitude;
if (!((UnityEngine.Object)zombiesInRadiu != (UnityEngine.Object)targetZombie) || (double)Vector3.Dot(vector3_4, aimTransform.forward) >= 0.5)
{
if ((double)magnitude > 0.025000000372529)
{
RaycastHit hit;
PhysicsUtility.raycast(new Ray(vector3_1, vector3_4), out hit, magnitude - 0.025f, RayMasks.BLOCK_SENTRY, QueryTriggerInteraction.UseGlobal);
if (!((UnityEngine.Object)hit.transform != (UnityEngine.Object)null) || !((UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform))
{
PhysicsUtility.raycast(new Ray(vector3_1 + vector3_4 * (magnitude - 0.025f), -vector3_4), out hit, magnitude - 0.025f, RayMasks.DAMAGE_SERVER, QueryTriggerInteraction.UseGlobal);
if ((UnityEngine.Object)hit.transform != (UnityEngine.Object)null && (UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform)
{
continue;
}
}
else
{
continue;
}
}
num = sqrMagnitude;
player = (Player)null;
zombie = zombiesInRadiu;
}
}
}
}
animalsInRadius.Clear();
AnimalManager.getAnimalsInRadius(vector3_1, sqrRadius, animalsInRadius);
for (int index = 0; index < animalsInRadius.Count; ++index)
{
Animal animalsInRadiu = animalsInRadius[index];
if (!animalsInRadiu.isDead)
{
Vector3 position = animalsInRadiu.transform.position;
vector3_2 = position - vector3_1;
float sqrMagnitude = vector3_2.sqrMagnitude;
if ((double)sqrMagnitude <= (double)num)
{
Vector3 vector3_3 = position - vector3_1;
float magnitude = vector3_3.magnitude;
Vector3 vector3_4 = vector3_3 / magnitude;
if (!((UnityEngine.Object)animalsInRadiu != (UnityEngine.Object)targetAnimal) || (double)Vector3.Dot(vector3_4, aimTransform.forward) >= 0.5)
{
if ((double)magnitude > 0.025000000372529)
{
RaycastHit hit;
PhysicsUtility.raycast(new Ray(vector3_1, vector3_4), out hit, magnitude - 0.025f, RayMasks.BLOCK_SENTRY, QueryTriggerInteraction.UseGlobal);
if (!((UnityEngine.Object)hit.transform != (UnityEngine.Object)null) || !((UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform))
{
PhysicsUtility.raycast(new Ray(vector3_1 + vector3_4 * (magnitude - 0.025f), -vector3_4), out hit, magnitude - 0.025f, RayMasks.DAMAGE_SERVER, QueryTriggerInteraction.UseGlobal);
if ((UnityEngine.Object)hit.transform != (UnityEngine.Object)null && (UnityEngine.Object)hit.transform != (UnityEngine.Object)__instance.transform)
{
continue;
}
}
else
{
continue;
}
}
num = sqrMagnitude;
player = (Player)null;
zombie = (Zombie)null;
animal = animalsInRadiu;
}
}
}
}
if ((UnityEngine.Object)player != (UnityEngine.Object)targetPlayer || (UnityEngine.Object)zombie != (UnityEngine.Object)targetZombie || (UnityEngine.Object)animal != (UnityEngine.Object)targetAnimal)
{
targetPlayerField.SetValue(__instance, player);
targetZombieField.SetValue(__instance, zombie);
targetAnimalField.SetValue(__instance, animal);
lastFireField.SetValue(__instance, Time.realtimeSinceStartup + 0.1f);
}
}
if ((UnityEngine.Object)targetPlayer != (UnityEngine.Object)null)
{
switch (__instance.sentryMode)
{
case ESentryMode.NEUTRAL:
case ESentryMode.FRIENDLY:
isFiringField.SetValue(__instance, targetPlayer.animator.gesture != EPlayerGesture.SURRENDER_START);
break;
case ESentryMode.HOSTILE:
isFiringField.SetValue(__instance, true);
break;
}
isAimingField.SetValue(__instance, true);
}
else if ((UnityEngine.Object)targetZombie != (UnityEngine.Object)null)
{
isFiringField.SetValue(__instance, true);
isAimingField.SetValue(__instance, true);
}
else if ((UnityEngine.Object)targetAnimal != (UnityEngine.Object)null)
{
switch (__instance.sentryMode)
{
case ESentryMode.NEUTRAL:
case ESentryMode.FRIENDLY:
isFiringField.SetValue(__instance, targetAnimal.isHunting);
break;
case ESentryMode.HOSTILE:
isFiringField.SetValue(__instance, true);
break;
}
isAimingField.SetValue(__instance, true);
}
else
{
isFiringField.SetValue(__instance, false);
isAimingField.SetValue(__instance, false);
}
if (isAiming && (double)Time.realtimeSinceStartup - (double)lastAim > (double)Provider.UPDATE_TIME)
{
lastAimField.SetValue(__instance, Time.realtimeSinceStartup);
Transform transform = (Transform)null;
Vector3 vector3_3 = Vector3.zero;
if ((UnityEngine.Object)targetPlayer != (UnityEngine.Object)null)
{
transform = targetPlayer.transform;
vector3_3 = targetPlayer.look.aim.position;
}
else if ((UnityEngine.Object)targetZombie != (UnityEngine.Object)null)
{
transform = targetZombie.transform;
vector3_3 = targetZombie.transform.position;
switch (targetZombie.speciality)
{
case EZombieSpeciality.NORMAL:
vector3_3 += new Vector3(0.0f, 1.75f, 0.0f);
break;
case EZombieSpeciality.MEGA:
vector3_3 += new Vector3(0.0f, 2.625f, 0.0f);
break;
case EZombieSpeciality.CRAWLER:
vector3_3 += new Vector3(0.0f, 0.25f, 0.0f);
break;
case EZombieSpeciality.SPRINTER:
vector3_3 += new Vector3(0.0f, 1f, 0.0f);
break;
}
}
else if ((UnityEngine.Object)targetAnimal != (UnityEngine.Object)null)
{
transform = targetAnimal.transform;
vector3_3 = targetAnimal.transform.position + Vector3.up;
}
if ((UnityEngine.Object)transform != (UnityEngine.Object)null)
{
float yaw = Mathf.Atan2(vector3_3.x - vector3_1.x, vector3_3.z - vector3_1.z) * 57.29578f;
double num = (double)vector3_3.y - (double)vector3_1.y;
vector3_2 = vector3_3 - vector3_1;
double magnitude = (double)vector3_2.magnitude;
float pitch = Mathf.Sin((float)(num / magnitude)) * 57.29578f;
BarricadeManager.sendAlertSentry(__instance.transform, yaw, pitch);
}
}
if (isFiring && hasWeapon && (__instance.displayItem.state[10] > (byte)0 && !__instance.isOpen) && (double)Time.realtimeSinceStartup - (double)lastFire > (double)fireTime)
{
lastFireField.SetValue(__instance, lastFire + fireTime);
if ((double)Time.realtimeSinceStartup - (double)lastFire > (double)fireTime)
{
lastFire = Time.realtimeSinceStartup;
}
float num1 = (float)__instance.displayItem.quality / 100f;
if (attachments.magazineAsset == null)
{
return(false);
}
if (!ownerPlayer.HasPermission(IgnoreAmmoPermission))
{
Console.WriteLine("Ammo reduction");
if ((__instance.sentryAsset.infiniteAmmo ? 1 : (((ItemGunAsset)displayAsset).infiniteAmmo ? 1 : 0)) == 0)
{
--__instance.displayItem.state[10];
}
if (!__instance.sentryAsset.infiniteQuality && Provider.modeConfigData.Items.Has_Durability && (__instance.displayItem.quality > (byte)0 && (double)UnityEngine.Random.value < (double)((ItemWeaponAsset)displayAsset).durability))
{
if ((int)__instance.displayItem.quality > (int)((ItemWeaponAsset)displayAsset).wear)
{
__instance.displayItem.quality -= ((ItemWeaponAsset)displayAsset).wear;
}
else
{
__instance.displayItem.quality = (byte)0;
}
}
}
if (attachments.barrelAsset == null || !attachments.barrelAsset.isSilenced || __instance.displayItem.state[16] == (byte)0)
{
AlertTool.alert(__instance.transform.position, 48f);
}
float num2 = ((ItemGunAsset)displayAsset).spreadAim * ((double)num1 < 0.5 ? (float)(1.0 + (1.0 - (double)num1 * 2.0)) : 1f);
if (attachments.tacticalAsset != null && interact)
{
num2 *= attachments.tacticalAsset.spread;
}
if (attachments.gripAsset != null)
{
num2 *= attachments.gripAsset.spread;
}
if (attachments.barrelAsset != null)
{
num2 *= attachments.barrelAsset.spread;
}
if (attachments.magazineAsset != null)
{
num2 *= attachments.magazineAsset.spread;
}
if ((UnityEngine.Object)((ItemGunAsset)displayAsset).projectile == (UnityEngine.Object)null)
{
BarricadeManager.sendShootSentry(__instance.transform);
byte pellets = attachments.magazineAsset.pellets;
for (byte index1 = 0; (int)index1 < (int)pellets; ++index1)
{
EPlayerKill kill = EPlayerKill.NONE;
uint xp = 0;
float times = (float)(1.0 * ((double)num1 < 0.5 ? 0.5 + (double)num1 : 1.0));
Transform transform = (Transform)null;
float num3 = 0.0f;
if ((UnityEngine.Object)targetPlayer != (UnityEngine.Object)null)
{
transform = targetPlayer.transform;
}
else if ((UnityEngine.Object)targetZombie != (UnityEngine.Object)null)
{
transform = __instance.transform;
}
else if ((UnityEngine.Object)targetAnimal != (UnityEngine.Object)null)
{
transform = targetAnimal.transform;
}
if ((UnityEngine.Object)transform != (UnityEngine.Object)null)
{
vector3_2 = transform.position - __instance.transform.position;
num3 = vector3_2.magnitude;
}
float num4 = (1f - num3 / ((ItemWeaponAsset)displayAsset).range) * (1f - ((ItemGunAsset)displayAsset).spreadHip) * 0.75f;
if ((UnityEngine.Object)transform == (UnityEngine.Object)null || (double)UnityEngine.Random.value > (double)num4)
{
Vector3 forward = aimTransform.forward;
forward += aimTransform.right * UnityEngine.Random.Range(-((ItemGunAsset)displayAsset).spreadHip, ((ItemGunAsset)displayAsset).spreadHip) * num2;
forward += aimTransform.up * UnityEngine.Random.Range(-((ItemGunAsset)displayAsset).spreadHip, ((ItemGunAsset)displayAsset).spreadHip) * num2;
forward.Normalize();
RaycastInfo raycastInfo = DamageTool.raycast(new Ray(aimTransform.position, forward), ((ItemWeaponAsset)displayAsset).range, RayMasks.DAMAGE_SERVER);
if (!((UnityEngine.Object)raycastInfo.transform == (UnityEngine.Object)null))
{
DamageTool.impact(raycastInfo.point, raycastInfo.normal, raycastInfo.material, (UnityEngine.Object)raycastInfo.vehicle != (UnityEngine.Object)null || raycastInfo.transform.CompareTag("Barricade") || raycastInfo.transform.CompareTag("Structure") || raycastInfo.transform.CompareTag("Resource"));
if ((UnityEngine.Object)raycastInfo.vehicle != (UnityEngine.Object)null)
{
DamageTool.damage(raycastInfo.vehicle, false, Vector3.zero, false, ((ItemWeaponAsset)displayAsset).vehicleDamage, times, true, out kill, new CSteamID(), EDamageOrigin.Sentry);
}
else if ((UnityEngine.Object)raycastInfo.transform != (UnityEngine.Object)null)
{
if (raycastInfo.transform.CompareTag("Barricade"))
{
ushort result;
if (ushort.TryParse(raycastInfo.transform.name, NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture, out result))
{
ItemBarricadeAsset itemBarricadeAsset = (ItemBarricadeAsset)Assets.find(EAssetType.ITEM, result);
if (itemBarricadeAsset != null && (itemBarricadeAsset.isVulnerable || ((ItemWeaponAsset)displayAsset).isInvulnerable))
{
DamageTool.damage(raycastInfo.transform, false, ((ItemWeaponAsset)displayAsset).barricadeDamage, times, out kill, new CSteamID(), EDamageOrigin.Sentry);
}
}
}
else if (raycastInfo.transform.CompareTag("Structure"))
{
ushort result;
if (ushort.TryParse(raycastInfo.transform.name, NumberStyles.Any, (IFormatProvider)CultureInfo.InvariantCulture, out result))
{
ItemStructureAsset itemStructureAsset = (ItemStructureAsset)Assets.find(EAssetType.ITEM, result);
if (itemStructureAsset != null && (itemStructureAsset.isVulnerable || ((ItemWeaponAsset)displayAsset).isInvulnerable))
{
DamageTool.damage(raycastInfo.transform, false, raycastInfo.direction * Mathf.Ceil((float)attachments.magazineAsset.pellets / 2f), ((ItemWeaponAsset)displayAsset).structureDamage, times, out kill, new CSteamID(), EDamageOrigin.Sentry);
}
}
}
else if (raycastInfo.transform.CompareTag("Resource"))
{
byte x;
byte y;
ushort index2;
if (ResourceManager.tryGetRegion(raycastInfo.transform, out x, out y, out index2))
{
ResourceSpawnpoint resourceSpawnpoint = ResourceManager.getResourceSpawnpoint(x, y, index2);
if (resourceSpawnpoint != null && !resourceSpawnpoint.isDead && (int)resourceSpawnpoint.asset.bladeID == (int)((ItemWeaponAsset)displayAsset).bladeID)
{
DamageTool.damage(raycastInfo.transform, raycastInfo.direction * Mathf.Ceil((float)attachments.magazineAsset.pellets / 2f), ((ItemWeaponAsset)displayAsset).resourceDamage, times, 1f, out kill, out xp, new CSteamID(), EDamageOrigin.Sentry);
}
}
}
else if (raycastInfo.section < byte.MaxValue)
{
InteractableObjectRubble componentInParent = raycastInfo.transform.GetComponentInParent <InteractableObjectRubble>();
if ((UnityEngine.Object)componentInParent != (UnityEngine.Object)null && !componentInParent.isSectionDead(raycastInfo.section) && (componentInParent.asset.rubbleIsVulnerable || ((ItemWeaponAsset)displayAsset).isInvulnerable))
{
DamageTool.damage(componentInParent.transform, raycastInfo.direction, raycastInfo.section, ((ItemWeaponAsset)displayAsset).objectDamage, times, out kill, out xp, new CSteamID(), EDamageOrigin.Sentry);
}
}
}
}
}
else
{
Vector3 point = Vector3.zero;
if ((UnityEngine.Object)targetPlayer != (UnityEngine.Object)null)
{
point = targetPlayer.look.aim.position;
}
else if ((UnityEngine.Object)targetZombie != (UnityEngine.Object)null)
{
point = targetZombie.transform.position;
switch (targetZombie.speciality)
{
case EZombieSpeciality.NORMAL:
point += new Vector3(0.0f, 1.75f, 0.0f);
break;
case EZombieSpeciality.MEGA:
point += new Vector3(0.0f, 2.625f, 0.0f);
break;
case EZombieSpeciality.CRAWLER:
point += new Vector3(0.0f, 0.25f, 0.0f);
break;
case EZombieSpeciality.SPRINTER:
point += new Vector3(0.0f, 1f, 0.0f);
break;
}
}
else if ((UnityEngine.Object)targetAnimal != (UnityEngine.Object)null)
{
point = targetAnimal.transform.position + Vector3.up;
}
DamageTool.impact(point, -aimTransform.forward, EPhysicsMaterial.FLESH_DYNAMIC, true);
Vector3 direction = aimTransform.forward * Mathf.Ceil((float)attachments.magazineAsset.pellets / 2f);
if ((UnityEngine.Object)targetPlayer != (UnityEngine.Object)null)
{
DamageTool.damage(targetPlayer, EDeathCause.SENTRY, ELimb.SPINE, __instance.owner, direction, (IDamageMultiplier)((ItemWeaponAsset)displayAsset).playerDamageMultiplier, times, true, out kill, true, ERagdollEffect.NONE);
}
else if ((UnityEngine.Object)targetZombie != (UnityEngine.Object)null)
{
IDamageMultiplier damageMultiplier = ((ItemWeaponAsset)displayAsset).zombieOrPlayerDamageMultiplier;
DamageZombieParameters parameters = DamageZombieParameters.make(targetZombie, direction, damageMultiplier, ELimb.SPINE);
parameters.times = times;
parameters.legacyArmor = true;
parameters.instigator = (object)__instance;
DamageTool.damageZombie(parameters, out kill, out xp);
}
else if ((UnityEngine.Object)targetAnimal != (UnityEngine.Object)null)
{
IDamageMultiplier damageMultiplier = ((ItemWeaponAsset)displayAsset).animalOrPlayerDamageMultiplier;
DamageAnimalParameters parameters = DamageAnimalParameters.make(targetAnimal, direction, damageMultiplier, ELimb.SPINE);
parameters.times = times;
parameters.instigator = (object)__instance;
DamageTool.damageAnimal(parameters, out kill, out xp);
}
}
}
}
__instance.rebuildState();
}
}
return(false);
}
public static bool SetResourceDamage(ItemWeaponAsset asset, float damage)
{
asset.resourceDamage = damage;
return(true);
}
public static bool SetObjectDamage(ItemWeaponAsset asset, float damage)
{
asset.objectDamage = damage;
return(true);
}
public static bool SetZombieDamage(ItemWeaponAsset asset, float damage)
{
asset.zombieDamageMultiplier.damage = damage;
return(true);
}
internal static void Modify(ItemModification modification)
{
ItemAsset asset = (ItemAsset)Assets.find(EAssetType.ITEM, modification.ID);
if (asset == null)
{
LogError("Item ID {0} is invalid.", modification.ID);
return;
}
if (asset.isPro)
{
LogError("Item ID {0} is a cosmetic.", modification.ID);
return;
}
if (modification.Height.HasValue || modification.Width.HasValue)
{
if (asset is ItemBagAsset)
{
ItemBagAsset bagAsset = asset as ItemBagAsset;
if (modification.Width.HasValue)
{
SetWidth(bagAsset, modification.Width.Value);
}
if (modification.Height.HasValue)
{
SetHeight(bagAsset, modification.Height.Value);
}
}
else
{
LogError("Item ID {0} isn't a clothing item with storage.", modification.ID);
}
}
if (modification.Health.HasValue)
{
if (asset is ItemBarricadeAsset)
{
SetHealth(asset as ItemBarricadeAsset, modification.Health.Value);
}
else if (asset is ItemStructureAsset)
{
SetHealth(asset as ItemStructureAsset, modification.Health.Value);
}
else
{
LogError("Item ID {0} isn't a structure or barricade.", modification.ID);
}
}
if (modification.PlayerDamage.HasValue ||
modification.PlayerLegMultiplier.HasValue ||
modification.PlayerArmMultiplier.HasValue ||
modification.PlayerSpineMultiplier.HasValue ||
modification.PlayerSkullMultiplier.HasValue ||
modification.ZombieDamage.HasValue ||
modification.ZombieLegMultiplier.HasValue ||
modification.ZombieArmMultiplier.HasValue ||
modification.ZombieSpineMultiplier.HasValue ||
modification.ZombieSkullMultiplier.HasValue ||
modification.AnimalDamage.HasValue ||
modification.AnimalLegMultiplier.HasValue ||
modification.AnimalSpineMultiplier.HasValue ||
modification.AnimalSkullMultiplier.HasValue ||
modification.BarricadeDamage.HasValue ||
modification.StructureDamage.HasValue ||
modification.VehicleDamage.HasValue ||
modification.ResourceDamage.HasValue ||
modification.ObjectDamage.HasValue ||
modification.Invulnerable.HasValue) // Isn't this pretty?
{
if (asset is ItemWeaponAsset)
{
ItemWeaponAsset weaponAsset = asset as ItemWeaponAsset;
if (modification.PlayerDamage.HasValue)
{
SetPlayerDamage(weaponAsset, modification.PlayerDamage.Value);
}
if (modification.PlayerLegMultiplier.HasValue)
{
SetPlayerLegMultiplier(weaponAsset, modification.PlayerLegMultiplier.Value);
}
if (modification.PlayerArmMultiplier.HasValue)
{
SetPlayerArmMultiplier(weaponAsset, modification.PlayerArmMultiplier.Value);
}
if (modification.PlayerSpineMultiplier.HasValue)
{
SetPlayerSpineMultiplier(weaponAsset, modification.PlayerSpineMultiplier.Value);
}
if (modification.PlayerSkullMultiplier.HasValue)
{
SetPlayerSkullMultiplier(weaponAsset, modification.PlayerSkullMultiplier.Value);
}
if (modification.ZombieDamage.HasValue)
{
SetZombieDamage(weaponAsset, modification.ZombieDamage.Value);
}
if (modification.ZombieLegMultiplier.HasValue)
{
SetZombieLegMultiplier(weaponAsset, modification.ZombieLegMultiplier.Value);
}
if (modification.ZombieArmMultiplier.HasValue)
{
SetZombieArmMultiplier(weaponAsset, modification.ZombieArmMultiplier.Value);
}
if (modification.ZombieSpineMultiplier.HasValue)
{
SetZombieSpineMultiplier(weaponAsset, modification.ZombieSpineMultiplier.Value);
}
if (modification.ZombieSkullMultiplier.HasValue)
{
SetZombieSkullMultiplier(weaponAsset, modification.ZombieSkullMultiplier.Value);
}
if (modification.AnimalDamage.HasValue)
{
SetAnimalDamage(weaponAsset, modification.AnimalDamage.Value);
}
if (modification.AnimalLegMultiplier.HasValue)
{
SetAnimalLegMultiplier(weaponAsset, modification.AnimalLegMultiplier.Value);
}
if (modification.AnimalSpineMultiplier.HasValue)
{
SetAnimalSpineMultiplier(weaponAsset, modification.AnimalSpineMultiplier.Value);
}
if (modification.AnimalSkullMultiplier.HasValue)
{
SetAnimalSkullMultiplier(weaponAsset, modification.AnimalSkullMultiplier.Value);
}
if (modification.BarricadeDamage.HasValue)
{
SetBarricadeDamage(weaponAsset, modification.BarricadeDamage.Value);
}
if (modification.StructureDamage.HasValue)
{
SetStructureDamage(weaponAsset, modification.StructureDamage.Value);
}
if (modification.VehicleDamage.HasValue)
{
SetVehicleDamage(weaponAsset, modification.VehicleDamage.Value);
}
if (modification.ResourceDamage.HasValue)
{
SetResourceDamage(weaponAsset, modification.ResourceDamage.Value);
}
if (modification.ObjectDamage.HasValue)
{
SetObjectDamage(weaponAsset, modification.ObjectDamage.Value);
}
if (modification.Invulnerable.HasValue)
{
SetIsInvulnerable(weaponAsset, modification.Invulnerable.Value);
}
}
else
{
LogError("Item ID {0} isn't a weapon.", modification.ID);
}
}
if (modification.Caliber.HasValue ||
modification.Range.HasValue ||
modification.SpreadAim.HasValue ||
modification.SpreadHip.HasValue ||
modification.Muzzle.HasValue)
{
if (asset is ItemWeaponAsset)
{
ItemGunAsset gunAsset = asset as ItemGunAsset;
if (modification.Caliber.HasValue)
{
SetCaliber(gunAsset, modification.Caliber.Value);
}
if (modification.Range.HasValue)
{
SetRange(gunAsset, modification.Range.Value);
}
if (modification.SpreadAim.HasValue)
{
SetSpreadAim(gunAsset, modification.SpreadAim.Value);
}
if (modification.SpreadHip.HasValue)
{
SetSpreadHip(gunAsset, modification.SpreadHip.Value);
}
if (modification.Muzzle.HasValue)
{
SetMuzzle(gunAsset, modification.Muzzle.Value);
}
}
else
{
LogError("Item ID {0} isn't a gun.", modification.ID);
}
}
if (modification.Explosion.HasValue)
{
if (asset is ItemStructureAsset)
{
SetExplosion(asset as ItemStructureAsset, modification.Explosion.Value);
}
else if (asset is ItemBarricadeAsset)
{
SetExplosion(asset as ItemBarricadeAsset, modification.Explosion.Value);
}
else if (asset is ItemGunAsset)
{
SetExplosion(asset as ItemGunAsset, modification.Explosion.Value);
}
else
{
LogError("Item ID {0} doesn't have an explosion tag.");
}
}
if (modification.BallisticDrop.HasValue ||
modification.Braked.HasValue ||
modification.Silenced.HasValue ||
modification.Volume.HasValue)
{
if (asset is ItemBarrelAsset)
{
ItemBarrelAsset barrelAsset = asset as ItemBarrelAsset;
if (modification.BallisticDrop.HasValue)
{
SetBallisticDrop(barrelAsset, modification.BallisticDrop.Value);
}
if (modification.Braked.HasValue)
{
SetIsBraked(barrelAsset, modification.Braked.Value);
}
if (modification.Silenced.HasValue)
{
SetIsSilenced(barrelAsset, modification.Silenced.Value);
}
if (modification.Volume.HasValue)
{
SetVolume(barrelAsset, modification.Volume.Value);
}
}
else
{
LogError("Item ID {0} isn't a barrel.");
}
}
}
public static bool SetZombieSkullMultiplier(ItemWeaponAsset asset, float multiplier)
{
asset.zombieDamageMultiplier.skull = multiplier;
return(true);
}
private void setRange(ItemWeaponAsset asset, float range)
{
asset.range = range;
}
public static bool SetAnimalDamage(ItemWeaponAsset asset, float damage)
{
asset.animalDamageMultiplier.damage = damage;
return(true);
}
