private void UseOther(BaseEntity.RPCMessage msg)
{
BasePlayer basePlayer = msg.player;
if (!this.VerifyClientAttack(basePlayer))
{
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
return;
}
if (!basePlayer.CanInteract())
{
return;
}
if (!base.HasItemAmount() || !this.canUseOnOther)
{
return;
}
BasePlayer basePlayer1 = BaseNetworkable.serverEntities.Find(msg.read.UInt32()) as BasePlayer;
if (basePlayer1 != null && Vector3.Distance(basePlayer1.transform.position, basePlayer.transform.position) < 4f)
{
base.ClientRPCPlayer(null, basePlayer, "Reset");
this.GiveEffectsTo(basePlayer1);
base.UseItemAmount(1);
base.StartAttackCooldown(this.repeatDelay);
}
}
private void RPC_OpenLoot(BaseEntity.RPCMessage rpc)
{
if (this.inventory == null)
{
return;
}
BasePlayer basePlayer = rpc.player;
if (!basePlayer || !basePlayer.CanInteract())
{
return;
}
if (Interface.CallHook("CanLootEntity", basePlayer, this) != null)
{
return;
}
if (basePlayer.inventory.loot.StartLootingEntity(this, true))
{
base.SetFlag(BaseEntity.Flags.Open, true, false, true);
basePlayer.inventory.loot.AddContainer(this.inventory);
basePlayer.inventory.loot.SendImmediate();
basePlayer.ClientRPCPlayer <string>(null, basePlayer, "RPC_OpenLootPanel", this.lootPanelName);
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
}
private bool CanFire(BasePlayer player)
{
if (RequiresPumping && pressure < PressureLossPerTick)
{
return(false);
}
if (player == null)
{
return(false);
}
if (HasFlag(Flags.Open))
{
return(false);
}
if (AmountHeld() <= 0)
{
return(false);
}
if (!player.CanInteract())
{
return(false);
}
if (!player.CanAttack() || player.IsRunning())
{
return(false);
}
Item item = GetItem();
if (item == null || item.contents == null)
{
return(false);
}
return(true);
}
private void UseOther(BaseEntity.RPCMessage msg)
{
BasePlayer player1 = msg.player;
if (!this.VerifyClientAttack(player1))
{
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
else
{
if (!player1.CanInteract() || !this.HasItemAmount() || !this.canUseOnOther)
{
return;
}
BasePlayer player2 = BaseNetworkable.serverEntities.Find(msg.read.UInt32()) as BasePlayer;
if (!Object.op_Inequality((Object)player2, (Object)null) || (double)Vector3.Distance(((Component)player2).get_transform().get_position(), ((Component)player1).get_transform().get_position()) >= 4.0)
{
return;
}
this.ClientRPCPlayer((Connection)null, player1, "Reset");
this.GiveEffectsTo(player2);
this.UseItemAmount(1);
this.StartAttackCooldown(this.repeatDelay);
}
}
public override void ServerUse()
{
if (base.isClient)
{
return;
}
BasePlayer ownerPlayer = base.GetOwnerPlayer();
if (ownerPlayer == null)
{
return;
}
if (!ownerPlayer.CanInteract())
{
return;
}
if (!base.HasItemAmount())
{
return;
}
this.GiveEffectsTo(ownerPlayer);
base.UseItemAmount(1);
base.StartAttackCooldown(this.repeatDelay);
base.SignalBroadcast(BaseEntity.Signal.Attack, string.Empty, null);
}
private void RPC_LootCorpse(BaseEntity.RPCMessage rpc)
{
BasePlayer basePlayer = rpc.player;
if (!basePlayer || !basePlayer.CanInteract())
{
return;
}
if (!this.CanLoot())
{
return;
}
if (this.containers == null)
{
return;
}
if (Interface.CallHook("CanLootEntity", basePlayer, this) != null)
{
return;
}
if (basePlayer.inventory.loot.StartLootingEntity(this, true))
{
base.SetFlag(BaseEntity.Flags.Open, true, false, true);
ItemContainer[] itemContainerArray = this.containers;
for (int i = 0; i < (int)itemContainerArray.Length; i++)
{
ItemContainer itemContainer = itemContainerArray[i];
basePlayer.inventory.loot.AddContainer(itemContainer);
}
basePlayer.inventory.loot.SendImmediate();
base.ClientRPCPlayer(null, basePlayer, "RPC_ClientLootCorpse");
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
}
private void Lock(BasePlayer player)
{
if (!(player == null) && player.CanInteract() && !IsLocked() && Interface.CallHook("CanLock", player, this) == null && HasLockPermission(player))
{
LockLock(player);
SendNetworkUpdate();
}
}
private void StartLootingContainer(BaseEntity.RPCMessage msg)
{
BasePlayer player = msg.player;
if (!Object.op_Implicit((Object)player) || !player.CanInteract() || (!this.lootable || Interface.CallHook("CanLootEntity", (object)player, (object)this) != null) || !player.inventory.loot.StartLootingEntity(this.baseEntity, true))
{
return;
}
this.lastAccessTime = Time.get_realtimeSinceStartup();
player.inventory.loot.AddContainer(this.container);
}
private void RPC_OpenLoot(RPCMessage rpc)
{
if (inventory != null)
{
BasePlayer player = rpc.player;
if ((bool)player && player.CanInteract())
{
PlayerOpenLoot(player, lootPanelName);
}
}
}
public override void ServerUse()
{
if (!base.isClient)
{
BasePlayer ownerPlayer = GetOwnerPlayer();
if (!(ownerPlayer == null) && ownerPlayer.CanInteract() && HasItemAmount())
{
GiveEffectsTo(ownerPlayer);
UseItemAmount(1);
StartAttackCooldown(repeatDelay);
SignalBroadcast(Signal.Attack, string.Empty);
}
}
}
private void RPC_OpenLoot(RPCMessage rpc)
{
if (inventory != null)
{
BasePlayer player = rpc.player;
if ((bool)player && player.CanInteract() && CanOpenStorage(player) && (!needsBuildingPrivilegeToUse || player.CanBuild()) && Interface.CallHook("CanLootEntity", player, this) == null && player.inventory.loot.StartLootingEntity(this))
{
player.inventory.loot.AddContainer(inventory);
player.inventory.loot.SendImmediate();
player.ClientRPCPlayer(null, player, "RPC_OpenLootPanel", lootPanelName);
SendNetworkUpdate();
}
}
}
private void RPC_OpenLoot(RPCMessage rpc)
{
if (inventory != null)
{
BasePlayer player = rpc.player;
if ((bool)player && player.CanInteract() && Interface.CallHook("CanLootEntity", player, this) == null && player.inventory.loot.StartLootingEntity(this))
{
SetFlag(Flags.Open, true);
player.inventory.loot.AddContainer(inventory);
player.inventory.loot.SendImmediate();
player.ClientRPCPlayer(null, player, "RPC_OpenLootPanel", lootPanelName);
SendNetworkUpdate();
}
}
}
private void UseSelf(RPCMessage msg)
{
BasePlayer player = msg.player;
if (!VerifyClientAttack(player))
{
SendNetworkUpdate();
}
else if (player.CanInteract() && HasItemAmount())
{
ClientRPCPlayer(null, player, "Reset");
GiveEffectsTo(player);
UseItemAmount(1);
StartAttackCooldown(repeatDelay);
}
}
private bool CanDowngrade(BuildingBlock buildingBlock, BasePlayer player, BuildingGrade.Enum targetGrade, bool refund, bool isAdmin)
{
if (player == null || !player.CanInteract())
{
return(false);
}
var constructionGrade = buildingBlock.GetGrade(targetGrade);
if (constructionGrade == null)
{
return(false);
}
if (!isAdmin)
{
if (buildingBlock.SecondsSinceAttacked < 30f)
{
return(false);
}
var obj = Interface.CallHook("CanChangeGrade", player, buildingBlock, targetGrade);
if (obj is bool)
{
return((bool)obj);
}
if (player.IsBuildingBlocked(buildingBlock.transform.position, buildingBlock.transform.rotation, buildingBlock.bounds))
{
return(false);
}
var isUpgradeBlocked = isUpgradeBlockedMethod?.Invoke(buildingBlock, null);
if (isUpgradeBlocked is bool && (bool)isUpgradeBlocked)
{
return(false);
}
if (!HasAccess(player, buildingBlock))
{
return(false);
}
if (Interface.CallHook("OnStructureUpgrade", buildingBlock, player, targetGrade) != null)
{
return(false);
}
}
return(true);
}
private bool CanUpgrade(BuildingBlock buildingBlock, BasePlayer player, BuildingGrade.Enum targetGrade, bool pay, bool isAdmin)
{
if (player == null || !player.CanInteract())
{
return(false);
}
var constructionGrade = buildingBlock.GetGrade(targetGrade);
if (constructionGrade == null)
{
return(false);
}
if (!isAdmin)
{
if (buildingBlock.SecondsSinceAttacked < 30f)
{
return(false);
}
if (!buildingBlock.CanChangeToGrade(targetGrade, player))
{
return(false);
}
if (!HasAccess(player, buildingBlock))
{
return(false);
}
if (Interface.Oxide.CallHook("OnStructureUpgrade", buildingBlock, player, targetGrade) != null)
{
return(false);
}
}
if (pay)
{
//if (!buildingBlock.CanAffordUpgrade(targetGrade, player)) {
// return false;
//}
//buildingBlock.PayForUpgrade(constructionGrade, player);
if (!CanAffordUpgrade(buildingBlock, constructionGrade, player, targetGrade))
{
return(false);
}
PayForUpgrade(buildingBlock, constructionGrade, player);
}
return(true);
}
public override void ServerUse()
{
if (this.isClient)
{
return;
}
BasePlayer ownerPlayer = this.GetOwnerPlayer();
if (Object.op_Equality((Object)ownerPlayer, (Object)null) || !ownerPlayer.CanInteract() || !this.HasItemAmount())
{
return;
}
this.GiveEffectsTo(ownerPlayer);
this.UseItemAmount(1);
this.StartAttackCooldown(this.repeatDelay);
this.SignalBroadcast(BaseEntity.Signal.Attack, string.Empty, (Connection)null);
}
private void RPC_LootCorpse(BaseEntity.RPCMessage rpc)
{
BasePlayer player = rpc.player;
if (!Object.op_Implicit((Object)player) || !player.CanInteract() || (!this.CanLoot() || this.containers == null) || (Interface.CallHook("CanLootEntity", (object)player, (object)this) != null || !player.inventory.loot.StartLootingEntity((BaseEntity)this, true)))
{
return;
}
this.SetFlag(BaseEntity.Flags.Open, true, false, true);
foreach (ItemContainer container in this.containers)
{
player.inventory.loot.AddContainer(container);
}
player.inventory.loot.SendImmediate();
this.ClientRPCPlayer((Connection)null, player, "RPC_ClientLootCorpse");
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
private void RPC_LootCorpse(RPCMessage rpc)
{
BasePlayer player = rpc.player;
if ((bool)player && player.CanInteract() && CanLoot() && containers != null && Interface.CallHook("CanLootEntity", player, this) == null && player.inventory.loot.StartLootingEntity(this))
{
SetFlag(Flags.Open, true);
ItemContainer[] array = containers;
foreach (ItemContainer container in array)
{
player.inventory.loot.AddContainer(container);
}
player.inventory.loot.SendImmediate();
ClientRPCPlayer(null, player, "RPC_ClientLootCorpse");
SendNetworkUpdate();
}
}
private void RPC_OpenLoot(BaseEntity.RPCMessage rpc)
{
if (this.inventory == null)
{
return;
}
BasePlayer player = rpc.player;
if (!Object.op_Implicit((Object)player) || !player.CanInteract() || (Interface.CallHook("CanLootEntity", (object)player, (object)this) != null || !player.inventory.loot.StartLootingEntity((BaseEntity)this, true)))
{
return;
}
this.SetFlag(BaseEntity.Flags.Open, true, false, true);
player.inventory.loot.AddContainer(this.inventory);
player.inventory.loot.SendImmediate();
player.ClientRPCPlayer <string>((Connection)null, player, "RPC_OpenLootPanel", this.lootPanelName);
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
private void UseSelf(BaseEntity.RPCMessage msg)
{
BasePlayer player = msg.player;
if (!this.VerifyClientAttack(player))
{
this.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
}
else
{
if (!player.CanInteract() || !this.HasItemAmount())
{
return;
}
this.ClientRPCPlayer((Connection)null, player, "Reset");
this.GiveEffectsTo(player);
this.UseItemAmount(1);
this.StartAttackCooldown(this.repeatDelay);
}
}
private void UseOther(RPCMessage msg)
{
BasePlayer player = msg.player;
if (!VerifyClientAttack(player))
{
SendNetworkUpdate();
}
else if (player.CanInteract() && HasItemAmount() && canUseOnOther)
{
BasePlayer basePlayer = BaseNetworkable.serverEntities.Find(msg.read.UInt32()) as BasePlayer;
if (basePlayer != null && Vector3.Distance(basePlayer.transform.position, player.transform.position) < 4f)
{
ClientRPCPlayer(null, player, "Reset");
GiveEffectsTo(basePlayer);
UseItemAmount(1);
StartAttackCooldown(repeatDelay);
}
}
}
private void UseSelf(BaseEntity.RPCMessage msg)
{
BasePlayer basePlayer = msg.player;
if (!this.VerifyClientAttack(basePlayer))
{
base.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
return;
}
if (!basePlayer.CanInteract())
{
return;
}
if (!base.HasItemAmount())
{
return;
}
base.ClientRPCPlayer(null, basePlayer, "Reset");
this.GiveEffectsTo(basePlayer);
base.UseItemAmount(1);
base.StartAttackCooldown(this.repeatDelay);
}
private void StartLootingContainer(BaseEntity.RPCMessage msg)
{
BasePlayer basePlayer = msg.player;
if (!basePlayer || !basePlayer.CanInteract())
{
return;
}
if (!this.lootable)
{
return;
}
if (Interface.CallHook("CanLootEntity", basePlayer, this) != null)
{
return;
}
if (basePlayer.inventory.loot.StartLootingEntity(base.baseEntity, true))
{
this.lastAccessTime = UnityEngine.Time.realtimeSinceStartup;
basePlayer.inventory.loot.AddContainer(this.container);
}
}
