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 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);
}
private bool CanShowPanel(TimedExplosive explosive)
{
if (!(explosive?.IsValid() ?? false))
{
return(false);
}
ServerProjectile proj = explosive.GetComponent <ServerProjectile>();
if (proj == null)
{
return(false);
}
//Rain of Fire checks
if (proj.gravityModifier != 0f ||
proj.speed != 25f ||
explosive.timerAmountMin != 300 ||
explosive.timerAmountMax != 300)
{
return(false);
}
object result = Interface.Call("MagicPanelCanShow", Name, explosive);
if (result is bool)
{
return((bool)result);
}
return(true);
}
void OnEntitySpawned(BaseNetworkable entity)
{
if (entity is BaseOven)
{
if (entity.ShortPrefabName == "jackolantern.happy" || entity.ShortPrefabName == "jackolantern.angry")
{
var jack = entity.GetComponent <BaseOven>();
if (craftedBombs.Contains(jack.OwnerID))
{
jack.gameObject.AddComponent <BombLight>();
var expEnt = GameManager.server.CreateEntity("assets/prefabs/tools/c4/explosive.timed.deployed.prefab", jack.transform.position, new Quaternion(), true);
TimedExplosive explosive = expEnt.GetComponent <TimedExplosive>();
explosive.timerAmountMax = configData.ExplosiveSettings.DetonationTimer;
explosive.timerAmountMin = configData.ExplosiveSettings.DetonationTimer;
explosive.explosionRadius = configData.ExplosiveSettings.ExplosionRadius;
explosive.damageTypes = new List <Rust.DamageTypeEntry>
{
new Rust.DamageTypeEntry {
amount = configData.ExplosiveSettings.DamageAmount, type = Rust.DamageType.Explosion
}
};
explosive.Spawn();
craftedBombs.Remove(jack.OwnerID);
}
}
}
}
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);
}
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();
}
private void HandleSuicideExplosion(Item item) // الله أكبر
{
player.inventory.containerBelt.Take(new List <Item> {
item
}, item.info.itemid, 1);
BaseEntity grenade = null;
switch (item.info.shortname)
{
case "grenade.f1":
grenade = GameManager.server.CreateEntity("assets/prefabs/weapons/f1 grenade/grenade.f1.deployed.prefab", player.transform.position + new Vector3(0, 1, 0));
break;
case "grenade.beancan":
grenade = GameManager.server.CreateEntity("assets/prefabs/weapons/beancan grenade/grenade.beancan.deployed.prefab", player.transform.position + new Vector3(0, 1, 0));
break;
}
if (grenade == null)
{
return;
}
grenade.Spawn();
TimedExplosive expl = grenade.GetComponent <TimedExplosive>();
expl.Explode();
cookingGrenade = false;
if (!player.IsDead())
{
RemoveActiveItem(player);
}
DestroyThis();
}
void OnExplosiveThrown(BasePlayer player, BaseEntity entity)
{
if (entity == null)
{
return;
}
if (entity.ShortPrefabName.Contains("explosive.timed"))
{
if (!weaponData.Weapons.ContainsKey("explosive.timed"))
{
return;
}
if (weaponData.Weapons["explosive.timed"].GlobalModifier != 1.0f)
{
TimedExplosive c4 = entity?.GetComponent <TimedExplosive>() ?? null;
if (c4 != null)
{
for (int i = 0; i < c4.damageTypes.Count; i++)
{
c4.damageTypes[i].amount += weaponData.Weapons["explosive.timed"].GlobalModifier;
}
}
}
}
}
public virtual void SetFuse(float fuseLength)
{
if (base.isServer)
{
TimedExplosive timedExplosive = this;
base.Invoke(new Action(timedExplosive.Explode), fuseLength);
}
}
public void Refresh(IAIAgent self, BaseEntity[] entities, int entityCount)
{
this.Self = self;
this.Entities = entities;
this.EntityCount = entityCount;
this.AnimalTarget = null;
this.AnimalScore = 0f;
this.ExplosiveTarget = null;
this.ExplosiveScore = 0f;
}
private void AddToRocketLaunch(string playerId, TimedExplosive explosive)
{
if (!lastLanched.ContainsKey(playerId))
{
lastLanched.Add(playerId, explosive);
}
else
{
lastLanched[playerId] = explosive;
}
}
private TimedExplosive GetRocketLaunch(string playerId)
{
TimedExplosive result = null;
if (lastLanched.ContainsKey(playerId))
{
result = lastLanched[playerId];
}
return(result);
}
private void DoDrop(BaseEntity.RPCMessage msg)
{
if (!this.HasItemAmount() || this.HasAttackCooldown())
{
return;
}
Vector3 vector3_1 = msg.read.Vector3();
Vector3 vector3_2 = msg.read.Vector3();
Vector3 normalized = ((Vector3) ref vector3_2).get_normalized();
if (msg.player.isMounted || msg.player.HasParent())
{
vector3_1 = msg.player.eyes.position;
}
else if (!this.ValidateEyePos(msg.player, vector3_1))
{
return;
}
BaseEntity entity1 = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, vector3_1, Quaternion.LookRotation(Vector3.get_up()), true);
if (Object.op_Equality((Object)entity1, (Object)null))
{
return;
}
RaycastHit hit;
if (Physics.SphereCast(new Ray(vector3_1, normalized), 0.05f, ref hit, 1.5f, 1236478737))
{
Vector3 point = ((RaycastHit) ref hit).get_point();
Vector3 normal = ((RaycastHit) ref hit).get_normal();
BaseEntity entity2 = hit.GetEntity();
if (Object.op_Implicit((Object)entity2) && entity2 is StabilityEntity && entity1 is TimedExplosive)
{
BaseEntity server = entity2.ToServer <BaseEntity>();
TimedExplosive timedExplosive = entity1 as TimedExplosive;
timedExplosive.onlyDamageParent = true;
timedExplosive.DoStick(point, normal, server);
}
else
{
entity1.SetVelocity(normalized);
}
}
else
{
entity1.SetVelocity(normalized);
}
entity1.creatorEntity = (BaseEntity)msg.player;
entity1.Spawn();
this.StartAttackCooldown(this.repeatDelay);
Interface.CallHook("OnExplosiveDropped", (object)msg.player, (object)entity1);
this.UseItemAmount(1);
}
private void DoDrop(BaseEntity.RPCMessage msg)
{
RaycastHit raycastHit;
if (!base.HasItemAmount() || base.HasAttackCooldown())
{
return;
}
Vector3 vector3 = msg.read.Vector3();
Vector3 vector31 = msg.read.Vector3().normalized;
if (msg.player.isMounted || msg.player.HasParent())
{
vector3 = msg.player.eyes.position;
}
else if (!base.ValidateEyePos(msg.player, vector3))
{
return;
}
BaseEntity baseEntity = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, vector3, Quaternion.LookRotation(Vector3.up), true);
if (baseEntity == null)
{
return;
}
if (!UnityEngine.Physics.SphereCast(new Ray(vector3, vector31), 0.05f, out raycastHit, 1.5f, 1236478737))
{
baseEntity.SetVelocity(vector31);
}
else
{
Vector3 vector32 = raycastHit.point;
Vector3 vector33 = raycastHit.normal;
BaseEntity entity = raycastHit.GetEntity();
if (!entity || !(entity is StabilityEntity) || !(baseEntity is TimedExplosive))
{
baseEntity.SetVelocity(vector31);
}
else
{
entity = entity.ToServer <BaseEntity>();
TimedExplosive timedExplosive = baseEntity as TimedExplosive;
timedExplosive.onlyDamageParent = true;
timedExplosive.DoStick(vector32, vector33, entity);
}
}
baseEntity.creatorEntity = msg.player;
baseEntity.Spawn();
base.StartAttackCooldown(this.repeatDelay);
Interface.CallHook("OnExplosiveDropped", msg.player, baseEntity, this);
base.UseItemAmount(1);
}
public virtual float Score(IAIContext context, BaseEntity option)
{
TimedExplosive timedExplosive = option as TimedExplosive;
if (!Object.op_Implicit((Object)timedExplosive))
{
return(0.0f);
}
float num = 0.0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
num += damageType.amount;
}
return((double)num <= 0.0 ? 0.0f : 1f);
}
private void OnEntitySpawned(TimedExplosive explosive)
{
NextTick(() =>
{
if (!CanShowPanel(explosive))
{
return;
}
_isRainOfFireActive = true;
MagicPanel?.Call("UpdatePanel", Name, (int)UpdateEnum.Image);
_endTimer?.Destroy();
_endTimer = timer.In(_pluginConfig.EventEnd, () =>
{
_isRainOfFireActive = false;
MagicPanel?.Call("UpdatePanel", Name, (int)UpdateEnum.Image);
});
});
}
private void OnExplosiveDropped(BasePlayer player, BaseEntity entity)
{
if (!throwerList.ContainsKey(player.UserIDString))
{
return;
}
if (entity.ShortPrefabName != "grenade.f1.deployed" && entity.ShortPrefabName != "grenade.beancan.deployed")
{
return;
}
TimedExplosive expl = entity.GetComponent <TimedExplosive>();
if (!expl)
{
return;
}
expl.CancelInvoke("Explode");
expl.SetFuse(throwerList[player.UserIDString]);
}
void CreateExplosive(EType type, BasePlayer player)
{
var Details = Explosives[type];
var expEnt = GameManager.server.CreateEntity(Details.PrefabName, player.transform.position + new Vector3(0, 1.5f, 0), new Quaternion(), true);
expEnt.OwnerID = player.userID;
expEnt.creatorEntity = player;
TimedExplosive explosive = expEnt.GetComponent <TimedExplosive>();
explosive.timerAmountMax = Details.Fuse;
explosive.timerAmountMin = Details.Fuse;
explosive.explosionRadius = Details.Radius;
explosive.damageTypes = new List <Rust.DamageTypeEntry> {
new Rust.DamageTypeEntry {
amount = Details.Damage, type = Rust.DamageType.Explosion
}
};
explosive.Spawn();
}
public static bool TryGetBest(
EntityTargetContext context,
IList <IOptionScorer <BaseEntity> > scorers,
BaseEntity[] options,
int numOptions,
bool allScorersMustScoreAboveZero,
out TimedExplosive best,
out float bestScore)
{
bestScore = float.MinValue;
best = (TimedExplosive)null;
BaseEntity baseEntity = (BaseEntity)null;
for (int index1 = 0; index1 < numOptions; ++index1)
{
float num1 = 0.0f;
bool flag = true;
for (int index2 = 0; index2 < ((ICollection <IOptionScorer <BaseEntity> >)scorers).Count; ++index2)
{
if (!((ICanBeDisabled)scorers[index2]).get_isDisabled())
{
float num2 = scorers[index2].Score((IAIContext)context, options[index1]);
if (allScorersMustScoreAboveZero && (double)num2 <= 0.0)
{
flag = false;
break;
}
num1 += num2;
}
}
if (flag && (double)num1 > (double)bestScore)
{
bestScore = num1;
baseEntity = options[index1];
}
}
if (Object.op_Inequality((Object)baseEntity, (Object)null))
{
best = baseEntity as TimedExplosive;
}
return(Object.op_Inequality((Object)best, (Object)null));
}
private void CreateExplosive(ExplosiveType type, BasePlayer player)
{
ExplosiveInfo info = explosiveInfo[type];
BaseEntity entity = GameManager.server.CreateEntity(info.PrefabName, player.transform.position + new Vector3(0, 1.5f, 0), new Quaternion(), true);
entity.OwnerID = player.userID;
entity.creatorEntity = player;
TimedExplosive explosive = entity.GetComponent <TimedExplosive>();
explosive.timerAmountMax = info.Fuse;
explosive.timerAmountMin = info.Fuse;
explosive.explosionRadius = info.Radius;
explosive.damageTypes = new List <Rust.DamageTypeEntry> {
new Rust.DamageTypeEntry {
amount = info.Damage, type = Rust.DamageType.Explosion
}
};
explosive.Spawn();
}
public override float Score(IAIContext context, BaseEntity option)
{
TimedExplosive timedExplosive = option as TimedExplosive;
if (!timedExplosive)
{
return(0f);
}
float single = 0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
single += damageType.amount;
}
if (single <= 0f)
{
return(0f);
}
return(1f);
}
public void Awake()
{
entity = GetComponent <BaseOven>();
lastOn = false;
entity.SetFlag(BaseEntity.Flags.On, false);
var expEnt = GameManager.server.CreateEntity("assets/prefabs/tools/c4/explosive.timed.deployed.prefab", entity.transform.position, new Quaternion(), true);
TimedExplosive explosive = expEnt.GetComponent <TimedExplosive>();
explosive.timerAmountMax = ins.configData.Explosives.Timer;
explosive.timerAmountMin = ins.configData.Explosives.Timer;
explosive.explosionRadius = ins.configData.Explosives.Radius;
explosive.damageTypes = new List <Rust.DamageTypeEntry> {
new Rust.DamageTypeEntry {
amount = ins.configData.Explosives.Amount, type = Rust.DamageType.Explosion
}
};
explosive.Spawn();
entity.InvokeRepeating(this.ToggleLight, 0.5f, 0.5f);
}
void CheckExplosivePosition(TimedExplosive explosive)
{
if (explosive == null)
{
return;
}
var objects = GameObject.FindObjectsOfType(typeof(Zone));
if (objects != null)
{
foreach (Zone zone in objects)
{
if (zone.info.undestr != null)
{
if (Vector3.Distance(explosive.GetEstimatedWorldPosition(), zone.transform.position) <= (zone.info.Location.GetRadius()))
{
explosive.KillMessage();
}
}
}
}
}
private void LaunchRocket()
{
if (rocketsFired >= rocketOptions.Amount)
{
entity.CancelInvoke(LaunchRocket);
return;
}
var rocketType = rocketOptions.Type == "Normal" ? basicRocket : fireRocket;
if (rocketOptions.Mixed && UnityEngine.Random.Range(1, rocketOptions.FireChance) == 1)
{
rocketType = fireRocket;
}
Vector3 launchPos = entity.transform.position;
Vector3 newTarget = Quaternion.Euler(GetRandom(), GetRandom(), GetRandom()) * targetPos;
BaseEntity rocket = GameManager.server.CreateEntity(rocketType, launchPos, new Quaternion(), true);
TimedExplosive rocketExplosion = rocket.GetComponent <TimedExplosive>();
ServerProjectile rocketProjectile = rocket.GetComponent <ServerProjectile>();
rocketProjectile.speed = rocketOptions.Speed;
rocketProjectile.gravityModifier = 0;
rocketExplosion.timerAmountMin = 60;
rocketExplosion.timerAmountMax = 60;
for (int i = 0; i < rocketExplosion.damageTypes.Count; i++)
{
rocketExplosion.damageTypes[i].amount *= rocketOptions.Damage;
}
Vector3 newDirection = (newTarget - launchPos);
rocket.SendMessage("InitializeVelocity", (newDirection));
rocket.Spawn();
++rocketsFired;
}
private void CheckExplosivePosition(TimedExplosive explosive)
{
if (explosive == null) return;
var objects = UnityEngine.Object.FindObjectsOfType<Zone>();
if (objects == null) return;
foreach (var zone in objects)
{
if (!HasZoneFlag(zone, ZoneFlags.UnDestr)) continue;
if (Vector3.Distance(explosive.GetEstimatedWorldPosition(), zone.transform.position) > zone.Info.radius) continue;
explosive.KillMessage();
break;
}
}
public void ServerThrow(Vector3 targetPosition)
{
Sensation sensation;
if (base.isClient)
{
return;
}
if (!base.HasItemAmount() || base.HasAttackCooldown())
{
return;
}
BasePlayer ownerPlayer = base.GetOwnerPlayer();
if (ownerPlayer == null)
{
return;
}
Vector3 vector3 = ownerPlayer.eyes.position;
Vector3 vector31 = ownerPlayer.eyes.BodyForward();
float single = 1f;
base.SignalBroadcast(BaseEntity.Signal.Throw, string.Empty, null);
BaseEntity baseEntity = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, vector3, Quaternion.LookRotation((this.overrideAngle == Vector3.zero ? -vector31 : this.overrideAngle)), true);
if (baseEntity == null)
{
return;
}
baseEntity.creatorEntity = ownerPlayer;
Vector3 vector32 = vector31 + (Quaternion.AngleAxis(10f, Vector3.right) * Vector3.up);
float throwVelocity = this.GetThrowVelocity(vector3, targetPosition, vector32);
if (float.IsNaN(throwVelocity))
{
vector32 = vector31 + (Quaternion.AngleAxis(20f, Vector3.right) * Vector3.up);
throwVelocity = this.GetThrowVelocity(vector3, targetPosition, vector32);
if (float.IsNaN(throwVelocity))
{
throwVelocity = 5f;
}
}
baseEntity.SetVelocity((vector32 * throwVelocity) * single);
if (this.tumbleVelocity > 0f)
{
baseEntity.SetAngularVelocity(new Vector3(UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f)) * this.tumbleVelocity);
}
baseEntity.Spawn();
base.StartAttackCooldown(this.repeatDelay);
base.UseItemAmount(1);
TimedExplosive timedExplosive = baseEntity as TimedExplosive;
if (timedExplosive == null)
{
sensation = new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ownerPlayer.transform.position,
Radius = 50f,
DamagePotential = 0f,
InitiatorPlayer = ownerPlayer,
Initiator = ownerPlayer,
UsedEntity = this
};
Sense.Stimulate(sensation);
return;
}
float single1 = 0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
single1 += damageType.amount;
}
sensation = new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ownerPlayer.transform.position,
Radius = 50f,
DamagePotential = single1,
InitiatorPlayer = ownerPlayer,
Initiator = ownerPlayer,
UsedEntity = timedExplosive
};
Sense.Stimulate(sensation);
}
private void DoThrow(BaseEntity.RPCMessage msg)
{
Sensation sensation;
if (!base.HasItemAmount() || base.HasAttackCooldown())
{
return;
}
Vector3 vector3 = msg.read.Vector3();
Vector3 vector31 = msg.read.Vector3().normalized;
float single = Mathf.Clamp01(msg.read.Float());
if (msg.player.isMounted || msg.player.HasParent())
{
vector3 = msg.player.eyes.position;
}
else if (!base.ValidateEyePos(msg.player, vector3))
{
return;
}
BaseEntity baseEntity = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, vector3, Quaternion.LookRotation((this.overrideAngle == Vector3.zero ? -vector31 : this.overrideAngle)), true);
if (baseEntity == null)
{
return;
}
baseEntity.creatorEntity = msg.player;
baseEntity.SetVelocity((msg.player.GetInheritedThrowVelocity() + ((vector31 * this.maxThrowVelocity) * single)) + (msg.player.estimatedVelocity * 0.5f));
if (this.tumbleVelocity > 0f)
{
baseEntity.SetAngularVelocity(new Vector3(UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f), UnityEngine.Random.Range(-1f, 1f)) * this.tumbleVelocity);
}
baseEntity.Spawn();
base.StartAttackCooldown(this.repeatDelay);
Interface.CallHook("OnExplosiveThrown", msg.player, baseEntity, this);
base.UseItemAmount(1);
BasePlayer basePlayer = msg.player;
if (basePlayer != null)
{
TimedExplosive timedExplosive = baseEntity as TimedExplosive;
if (timedExplosive != null)
{
float single1 = 0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
single1 += damageType.amount;
}
sensation = new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = basePlayer.transform.position,
Radius = 50f,
DamagePotential = single1,
InitiatorPlayer = basePlayer,
Initiator = basePlayer,
UsedEntity = timedExplosive
};
Sense.Stimulate(sensation);
return;
}
sensation = new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = basePlayer.transform.position,
Radius = 50f,
DamagePotential = 0f,
InitiatorPlayer = basePlayer,
Initiator = basePlayer,
UsedEntity = this
};
Sense.Stimulate(sensation);
}
}
private void DoThrow(BaseEntity.RPCMessage msg)
{
if (!this.HasItemAmount() || this.HasAttackCooldown())
{
return;
}
Vector3 vector3_1 = msg.read.Vector3();
Vector3 vector3_2 = msg.read.Vector3();
Vector3 normalized = ((Vector3) ref vector3_2).get_normalized();
float num1 = Mathf.Clamp01(msg.read.Float());
if (msg.player.isMounted || msg.player.HasParent())
{
vector3_1 = msg.player.eyes.position;
}
else if (!this.ValidateEyePos(msg.player, vector3_1))
{
return;
}
BaseEntity entity = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, vector3_1, Quaternion.LookRotation(Vector3.op_Equality(this.overrideAngle, Vector3.get_zero()) ? Vector3.op_UnaryNegation(normalized) : this.overrideAngle), true);
if (Object.op_Equality((Object)entity, (Object)null))
{
return;
}
entity.creatorEntity = (BaseEntity)msg.player;
entity.SetVelocity(Vector3.op_Addition(Vector3.op_Addition(msg.player.GetInheritedThrowVelocity(), Vector3.op_Multiply(Vector3.op_Multiply(normalized, this.maxThrowVelocity), num1)), Vector3.op_Multiply(msg.player.estimatedVelocity, 0.5f)));
if ((double)this.tumbleVelocity > 0.0)
{
entity.SetAngularVelocity(Vector3.op_Multiply(new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)), this.tumbleVelocity));
}
entity.Spawn();
this.StartAttackCooldown(this.repeatDelay);
Interface.CallHook("OnExplosiveThrown", (object)msg.player, (object)entity);
this.UseItemAmount(1);
BasePlayer player = msg.player;
if (!Object.op_Inequality((Object)player, (Object)null))
{
return;
}
TimedExplosive timedExplosive = entity as TimedExplosive;
if (Object.op_Inequality((Object)timedExplosive, (Object)null))
{
float num2 = 0.0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
num2 += damageType.amount;
}
Sense.Stimulate(new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ((Component)player).get_transform().get_position(),
Radius = 50f,
DamagePotential = num2,
InitiatorPlayer = player,
Initiator = (BaseEntity)player,
UsedEntity = (BaseEntity)timedExplosive
});
}
else
{
Sense.Stimulate(new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ((Component)player).get_transform().get_position(),
Radius = 50f,
DamagePotential = 0.0f,
InitiatorPlayer = player,
Initiator = (BaseEntity)player,
UsedEntity = (BaseEntity)this
});
}
}
public void ServerThrow(Vector3 targetPosition)
{
if (this.isClient || !this.HasItemAmount() || this.HasAttackCooldown())
{
return;
}
BasePlayer ownerPlayer = this.GetOwnerPlayer();
if (Object.op_Equality((Object)ownerPlayer, (Object)null))
{
return;
}
Vector3 position = ownerPlayer.eyes.position;
Vector3 vector3 = ownerPlayer.eyes.BodyForward();
float num1 = 1f;
this.SignalBroadcast(BaseEntity.Signal.Throw, string.Empty, (Connection)null);
BaseEntity entity = GameManager.server.CreateEntity(this.prefabToThrow.resourcePath, position, Quaternion.LookRotation(Vector3.op_Equality(this.overrideAngle, Vector3.get_zero()) ? Vector3.op_UnaryNegation(vector3) : this.overrideAngle), true);
if (Object.op_Equality((Object)entity, (Object)null))
{
return;
}
entity.creatorEntity = (BaseEntity)ownerPlayer;
Vector3 aimDir = Vector3.op_Addition(vector3, Quaternion.op_Multiply(Quaternion.AngleAxis(10f, Vector3.get_right()), Vector3.get_up()));
float f = this.GetThrowVelocity(position, targetPosition, aimDir);
if (float.IsNaN(f))
{
aimDir = Vector3.op_Addition(vector3, Quaternion.op_Multiply(Quaternion.AngleAxis(20f, Vector3.get_right()), Vector3.get_up()));
f = this.GetThrowVelocity(position, targetPosition, aimDir);
if (float.IsNaN(f))
{
f = 5f;
}
}
entity.SetVelocity(Vector3.op_Multiply(Vector3.op_Multiply(aimDir, f), num1));
if ((double)this.tumbleVelocity > 0.0)
{
entity.SetAngularVelocity(Vector3.op_Multiply(new Vector3(Random.Range(-1f, 1f), Random.Range(-1f, 1f), Random.Range(-1f, 1f)), this.tumbleVelocity));
}
entity.Spawn();
this.StartAttackCooldown(this.repeatDelay);
this.UseItemAmount(1);
TimedExplosive timedExplosive = entity as TimedExplosive;
if (Object.op_Inequality((Object)timedExplosive, (Object)null))
{
float num2 = 0.0f;
foreach (DamageTypeEntry damageType in timedExplosive.damageTypes)
{
num2 += damageType.amount;
}
Sense.Stimulate(new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ((Component)ownerPlayer).get_transform().get_position(),
Radius = 50f,
DamagePotential = num2,
InitiatorPlayer = ownerPlayer,
Initiator = (BaseEntity)ownerPlayer,
UsedEntity = (BaseEntity)timedExplosive
});
}
else
{
Sense.Stimulate(new Sensation()
{
Type = SensationType.ThrownWeapon,
Position = ((Component)ownerPlayer).get_transform().get_position(),
Radius = 50f,
DamagePotential = 0.0f,
InitiatorPlayer = ownerPlayer,
Initiator = (BaseEntity)ownerPlayer,
UsedEntity = (BaseEntity)this
});
}
}
void CheckExplosivePosition(TimedExplosive explosive)
{
if (explosive == null) return;
var objects = GameObject.FindObjectsOfType(typeof(Zone));
if (objects != null)
foreach (Zone zone in objects)
{
if (zone.info.undestr != null)
{
if (Vector3.Distance(explosive.GetEstimatedWorldPosition(), zone.transform.position) <= (zone.info.Location.GetRadius()))
explosive.KillMessage();
}
}
}
//////////////////
// DIFFERENTS CASES
//////////////////
void BirthdayBoomBoom(Item item, string birthdaytype, BaseEntity entity)
{
if (debug)
{
Puts("BoomBoom sequence");
}
Vector3 daboom = new Vector3(entity.transform.position.x, entity.transform.position.y, entity.transform.position.z);
if (debug)
{
Puts($"Vector3 {daboom}");
}
TimedExplosive boom = new TimedExplosive();
//SmokeGrenade boomboom = new SmokeGrenade();
if (birthdaytype == "explose")
{
BaseEntity GrenadeF1 = GameManager.server.CreateEntity("assets/prefabs/weapons/f1 grenade/grenade.f1.deployed.prefab", daboom, new Quaternion(), true);
if (GrenadeF1 == null)
{
if (debug)
{
Puts("GrenadeF1 NULL BaseEntity ENTITY !!!!");
}
else if (debug)
{
Puts($"oright {GrenadeF1}");
}
}
boom = GrenadeF1.GetComponent <TimedExplosive>();
if (boom == null)
{
Puts("boom NULL TimedExplosive ENTITY !!!!");
}
if (debug)
{
Puts("F1 BIRTHDAY !!!!");
}
boom.Explode();
return;
}
/*if (birthdaytype == "smoke")
* {
* prefab = "assets/prefabs/tools/smoke grenade/grenade.smoke.deployed.prefab";
* Puts("SMOKE BIRTHDAY !!!!");
* BaseEntity GrenadeSmoke = GameManager.server.CreateEntity(prefab, daboom, new Quaternion(), true);
* if (GrenadeSmoke == null) Puts("GrenadeSmoke NULL BaseEntity ENTITY !!!!");
* else Puts($"oright {GrenadeSmoke}");
* boomboom = GrenadeSmoke.GetComponent<SmokeGrenade>();
* if (boomboom != null) Puts($"SmokeGrenade {boomboom}");
* boomboom.smokeDuration = 20f;
* GrenadeSmoke.Spawn();
* //boomboom.Explode();
* return;
* }*/
string prefab = string.Empty;
if (birthdaytype == "fire")
{
prefab = "assets/bundled/prefabs/fireball.prefab";
}
if (birthdaytype == "oil")
{
prefab = "assets/bundled/prefabs/oilfireballsmall.prefab";
}
if (birthdaytype == "napalm")
{
prefab = "assets/bundled/prefabs/napalm.prefab";
}
BaseEntity GrenadeFlames = GameManager.server.CreateEntity(prefab, daboom, new Quaternion(), true);
if (GrenadeFlames == null)
{
if (debug)
{
Puts("GrenadeFlames NULL BaseEntity ENTITY !!!!");
}
else if (debug)
{
Puts($"oright fireflames {GrenadeFlames}");
}
}
GrenadeFlames?.Spawn();
timer.Once(flamingtime, () =>
{
if (GrenadeFlames != null)
{
GrenadeFlames.Kill();
}
});
}
void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
{
if (hitInfo != null &&
hitInfo.Initiator != null &&
hitInfo.Initiator.ToPlayer() != null)
{
BasePlayer player = hitInfo.Initiator.ToPlayer();
if (ZoneManager != null)
{
object canBeWounded = ZoneManager.Call("CanBeWounded", player, hitInfo);
if (canBeWounded == null)
{
return;
}
}
TimedExplosive explosion = null;
if (hitInfo.WeaponPrefab != null &&
hitInfo.WeaponPrefab.ToString().Contains("explosive"))
{
explosion = (hitInfo.WeaponPrefab.GetEntity() as TimedExplosive);
}
if (entity.ShortPrefabName.ToString().Contains("player") &&
(
explosion == null ||
explosion.explosionRadius >= player.Distance(entity.GetEntity())
)
)
{
float totalDamage = (float)0.0;
foreach (Rust.DamageType damageType in Enum.GetValues(typeof(Rust.DamageType))) //calculate the damage the player would take
{
try
{
if (hitInfo.damageTypes.Get(damageType) > (float)0.0)
{
if (hitInfo.damageTypes.Get(damageType) > player.baseProtection.Get(damageType)) //damage of attack surpass player protection
{
totalDamage += hitInfo.damageTypes.Get(damageType) - player.baseProtection.Get(damageType);
}
}
}
catch
{ }
}
if (player.health <= totalDamage)
{
//if (!popupsEnabled)
SendReply(player, localization["AboutToDie"]);
}
//else
// PopupNotifications.Call("CreatePopupNotification", localization["AboutToDie"], player);
}
}
}
