public static void Update(bool withEnts = true)
{
if (entityAddress == 0)
entityAddress = SignatureManager.GetEntityList();
currentList = new EntityList();
var players = new List<BasePlayer>();
var entities = new List<BaseEntity>();
var entityList = Memory.ReadMemory(entityAddress, 4096 * 0x10); //lol
for (int i = 0; i < 64/*BaseClient.GlobalVars.maxClients*/; i++)
{
var entity = BitConverter.ToInt32(entityList, i * 0x10);
if (entity == 0) continue;
var player = new BasePlayer(entity);
players.Add(player);
}
currentList.Players = players;
if (withEnts)
{
for (int i = 64/*BaseClient.GlobalVars.maxClients*/; i < 4096; i++)
{
var entity = BitConverter.ToInt32(entityList, i * 0x10);
if (entity == 0) continue;
var ent = new BaseEntity(entity);
entities.Add(ent);
}
currentList.Entities = entities;
}
}
void cmdSpawnOpen(BasePlayer player, string command, string[] args)
{
if (!hasAccess(player)) return;
if (SpawnsData.ContainsKey(player))
{
SendReply(player, "You must save/close your current spawns first. /spawns_help for more informations");
return;
}
if (args == null || args.Length == 0)
{
SendReply(player, "/spawns_remove SPAWN_NUMBER");
return;
}
var NewSpawnFile = Interface.GetMod().DataFileSystem.GetDatafile(args[0].ToString());
if (NewSpawnFile["1"] == null)
{
SendReply(player, "This spawnfile is empty or not valid");
return;
}
SpawnsData.Add(player, new List<Vector3>());
foreach (KeyValuePair<string, object> pair in NewSpawnFile)
{
var currentvalue = pair.Value as Dictionary<string, object>;
((List<Vector3>)SpawnsData[player]).Add(new Vector3(Convert.ToInt32(currentvalue["x"]), Convert.ToInt32(currentvalue["y"]), Convert.ToInt32(currentvalue["z"])));
}
SendReply(player, string.Format("Opened spawnfile with {0} spawns", ((List<Vector3>)SpawnsData[player]).Count.ToString()));
}
/// <summary>
/// Gets the dialog currently being shown to the specified <paramref name="player" />.
/// </summary>
/// <param name="player">The player whose dialog to get.</param>
/// <returns>The dialog currently being shown to the specified <paramref name="player" />.</returns>
public static Dialog GetOpenDialog(BasePlayer player)
{
if (player == null)
throw new ArgumentNullException(nameof(player));
return OpenDialogs.ContainsKey(player.Id) ? OpenDialogs[player.Id] : null;
}
public void AddPlayerLobbyTest()
{
var lobby = new Lobby(new LobbyConfig());
var player = new BasePlayer();
lobby.AddPlayers(new BasePlayerGroup(player));
Assert.IsTrue(lobby.PlayerList.Contains(player));
}
/// <summary>
/// Initializes a new instance of the DamageEventArgs class.
/// </summary>
/// <param name="otherPlayer">The other player.</param>
/// <param name="amount">Amount of damage done.</param>
/// <param name="weapon">Weapon used to damage another.</param>
/// <param name="bodypart">BodyPart shot at.</param>
public DamageEventArgs(BasePlayer otherPlayer, float amount, Weapon weapon, BodyPart bodypart)
{
OtherPlayer = otherPlayer;
Amount = amount;
Weapon = weapon;
BodyPart = bodypart;
}
/// <summary>
/// Initializes a new instance of the <see cref="SelectPlayerObjectEventArgs" /> class.
/// </summary>
/// <param name="player">The player.</param>
/// <param name="object">The player object.</param>
/// <param name="modelid">The modelid.</param>
/// <param name="position">The position.</param>
public SelectPlayerObjectEventArgs(BasePlayer player, PlayerObject @object, int modelid, Vector3 position)
: base(position)
{
Player = player;
Object = @object;
ModelId = modelid;
}
public BasePlayer Load_Player(string user)
{
//Debug.Log(Get_Random_User());
user = user.ToLower().Replace(" ", string.Empty);
//GameManager.instance.player = new BasePlayer();
//GameManager.instance.player.Player_Spell_Book = new SpellBook();
//GameManager.instance.player.Player_Spell_Inventory = new SpellInventory();
//GameManager.instance.player.Player_Name = user;
BasePlayer player = new BasePlayer();
player.Player_Spell_Book = new SpellBook();
player.Player_Spell_Inventory = new SpellInventory();
player.Player_Name = user;
player.Players_Summon = Load_Player_Summon(user);
Load_Player_Spell_Inventory(user, ref player);
spell_book_db.Load("Assets/Scripts/Grimoire/Database/SpellBookDatabase.xml");
spell_book_root = spell_book_db.DocumentElement;
string path = "descendant::Book[@id='" + user + "']";
XmlNode book = spell_book_root.SelectSingleNode(path);
if (book == null)
{
return null;
}
//Debug.Log("Spell Book Elements: " + book.ChildNodes.Count);
foreach (XmlNode spell in book.ChildNodes)
{
Add_Spell(spell.InnerText, "spell_book", ref player);
}
return player;
}
public void ApplyEffect(BasePlayer p)
{
switch (Type)
{
// More power
case PowerUpType.Power:
p.IncreasePower(1);
break;
// More bombs
case PowerUpType.Bomb:
p.IncreaseTotalBombNumber(1);
break;
// More speed
case PowerUpType.Speed:
p.IncreaseSpeed(GameConfiguration.BasePlayerSpeed * (GameConfiguration.PlayerSpeedIncrementeurPercentage/100));
break;
// Skeleton ! => Bad items
case PowerUpType.BadEffect:
int randomBadEffect = GameConfiguration.Random.Next(GameConfiguration.BadEffectList.Count);
p.ApplyBadItem(GameConfiguration.BadEffectList[randomBadEffect]);
break;
// More points
case PowerUpType.Score:
p.Stats.Score++;
break;
}
}
void cmdWaypointsClose(BasePlayer player, string command, string[] args)
{
if (!hasAccess(player)) return;
if (!isEditingWP(player, 1)) return;
SendReply(player, "Waypoints: Closed without saving");
GameObject.Destroy(player.GetComponent<WaypointEditor>());
}
public void Create_User()
{
BasePlayer player = new BasePlayer();
GrimoireDatabase db = new GrimoireDatabase();
string user = character_name_field.GetComponentsInChildren<Text>()[1].text;
player.Player_Name = user;
user = user.Trim().ToLower().Replace(" ", string.Empty);
if(user == "")
{
warning_text.GetComponent<Text>().text = "Name Cannot Be Empty";
warning_text.SetActive(true);
return;
}
Debug.Log(user + " , word size: " + user.Length);
Debug.Log("User Exisist: " + db.User_Exists(user));
if(db.User_Exists(user))
{
warning_text.GetComponent<Text>().text = "User already exists";
warning_text.SetActive(true);
return;
}
player.Player_Spell_Book = starter_book;
Setup_Summon();
player.Players_Summon = starter_summon;
player.Player_Spell_Inventory = starter_inventory;
db.Save_Player(user, player);
GameManager.instance.player = player;
GameManager.instance.current_state = GameManager.GameStates.MAIN;
GameManager.instance.scene_loaded = false;
}
public virtual void UpdateBehavior(BasePlayer player)
{
if((mStopWhileFlickering && mEnemy.IsFlickering) || mEnemy.Hp <= 0)
{
return;
}
if(mResponseDelayTimer > 0)
{
mResponseDelayTimer -= Time.deltaTime;
return;
}
mAttackDelayTimer -= Time.deltaTime;
switch (mCurrentState)
{
case EnemyState.Idle:
HandleIdleState(player);
break;
case EnemyState.Chase:
HandleChaseState(player);
break;
case EnemyState.Attack:
HandleAttackState(player);
break;
case EnemyState.Flee:
HandleFleeState(player);
break;
case EnemyState.Boss:
HandleBossBehaviour(player);
break;
}
}
public object GiveItem(BasePlayer player, string itemname, int amount, ItemContainer pref)
{
itemname = itemname.ToLower();
bool isBP = false;
if (itemname.EndsWith(" bp"))
{
isBP = true;
itemname = itemname.Substring(0, itemname.Length - 3);
}
if (displaynameToShortname.ContainsKey(itemname))
itemname = displaynameToShortname[itemname];
var definition = ItemManager.FindItemDefinition(itemname);
if (definition == null)
return string.Format("{0} {1}", "Item not found: ", itemname);
int giveamount = 0;
int stack = (int)definition.stackable;
if (isBP)
stack = 1;
if (stack < 1) stack = 1;
for (var i = amount; i > 0; i = i - stack)
{
if (i >= stack)
giveamount = stack;
else
giveamount = i;
if (giveamount < 1) return true;
player.inventory.GiveItem(ItemManager.CreateByItemID((int)definition.itemid, giveamount, isBP), pref);
}
return true;
}
void Start()
{
animator = GameObject.Find("Player").GetComponent<Animator>();
if (!animator)
{
Debug.LogError("Missing animator!");
}
basePlayer = GameObject.Find("Player").GetComponent<BasePlayer>();
if (!basePlayer)
{
Debug.LogError("Missing BasePlayer script!");
}
audioSource = GameObject.Find("Player").GetComponent<AudioSource>();
if (!audioSource)
{
Debug.LogError("Missing audio source!");
}
if (!cooldownIndicator)
{
Debug.LogError("Missing cooldown button!");
}
if (clip.Length == 0)
{
Debug.LogError("0 sounds for attacking!");
}
timer = 0f;
targets = new List<BaseNPC>();
attacking = false;
}
static void EjectPlayer(Zone zone, BasePlayer player)
{
cachedDirection = player.transform.position - zone.transform.position;
player.transform.position = zone.transform.position + (cachedDirection / cachedDirection.magnitude * (zone.GetComponent<UnityEngine.SphereCollider>().radius + 1f));
player.ClientRPCPlayer(null, player, "ForcePositionTo", new object[] { player.transform.position });
player.TransformChanged();
}
void cmdChatProd(BasePlayer player, string command, string[] args)
{
if(!(hasAccess(player)))
{
SendReply(player, noAccess);
return;
}
var input = serverinput.GetValue(player) as InputState;
var currentRot = Quaternion.Euler(input.current.aimAngles) * Vector3.forward;
var target = DoRay(player.transform.position + eyesAdjust, currentRot);
if (target is bool)
{
SendReply(player, noTargetfound);
return;
}
if (target as BuildingBlock)
{
GetBuildingblockOwner(player,(BuildingBlock)target);
}
else if (target as BuildingPrivlidge)
{
GetToolCupboardUsers(player, (BuildingPrivlidge)target);
}
else if (target as DeployedItem)
{
GetDeployedItemOwner(player, (DeployedItem)target);
}
else
{
GetStorageBoxCode(player, (StorageContainer)target);
}
}
void Start () {
m_player = m_user.GetComponent<BasePlayer> ();
Transform hero = m_player.m_transform.Find (m_modeName);
m_hero = (Transform)Instantiate (hero, transform.position, hero.rotation);
m_hero.gameObject.SetActive (true);
m_hero.GetComponent<Animation>().Play (m_aniName);
}
//Oxide Hook
void OnPlayerInput(BasePlayer player, InputState input)
{
if (this.allowAdminRotate && player.IsAdmin() && player.GetActiveItem() != null && player.GetActiveItem().info.shortname.Equals("hammer"))
{
if (input.WasJustPressed(BUTTON.FIRE_PRIMARY))
{
RaycastHit hit;
if (Physics.Raycast(player.eyes.position, (player.eyes.rotation * Vector3.forward), out hit, 2f, Layers.Server.Buildings))
{
BaseEntity baseEntity = hit.collider.gameObject.ToBaseEntity();
if (baseEntity != null)
{
BuildingBlock block = baseEntity.GetComponent<BuildingBlock>();
if (block != null && block.blockDefinition.canRotate && !this.instanceIDs.Contains(block.GetInstanceID()))
{
block.SetFlag(BaseEntity.Flags.Reserved1, true);
addBlockToLists(block.GetInstanceID(), DateTime.Now.AddMinutes(-this.amountOfMinutesAfterUpgrade).ToString());
int remainingSeconds = timerInterval - DateTime.Now.Subtract(lastTimerTick).Seconds;
SendReply(player, "<color=green>You can now rotate this " + block.blockDefinition.info.name.english + " for " + remainingSeconds + " seconds.</color>");
}
}
}
}
}
}
public BasePlayer(string elementName)
: base(elementName)
{
Instance = this;
Futile.instance.SignalUpdate += HandleUpdate;
Futile.touchManager.AddMultiTouchTarget(this);
}
void ActivateFly(BasePlayer player, float speed)
{
fly.Add(player, speed);
oldPos.Add(player, player.transform.position);
player.ChangePlayerState(PlayerState.Type.Spectating, false);
SendReply(player, "FlyMode: Activated, press any key to start flying");
}
public HammerEvent(HitInfo info, BasePlayer player)
{
_info = info;
basePlayer = player;
string bonename = StringPool.Get(info.HitBone);
HitBone = bonename == "" ? "unknown" : bonename;
}
void Awake()
{
cameraMove = false;
secondTarget = false;
if (!player)
{
Debug.LogError("Missing player!");
}
else
{
basePlayer = player.GetComponent<BasePlayer>();
if(!basePlayer)
{
Debug.LogError("Missing base player script!");
}
}
if (!goblin)
{
Debug.LogError("Missing goblin!");
}
if (!goblin1)
{
Debug.LogError("Missing goblin1!");
}
if (!mainCamera)
{
Debug.LogError("Missing camera!");
}
}
internal RustLivePlayer(BasePlayer player)
{
this.player = player;
steamId = player.userID;
Character = this;
Object = player;
}
private void spawnWall(BasePlayer player, string cmd, string[] args)
{
var pos = player.transform.position;
pos.z += 2;
var angles = new Quaternion();
var prefab = GameManager.server.CreatePrefab("assets/prefabs/building/wall.external.high.stone/wall.external.high.stone.prefab", pos, angles, true);
if (prefab == null)
{
this.SendReply(player, "Prefab is null");
return;
}
var block = prefab.GetComponent<BuildingBlock>();
if (block == null)
{
this.SendReply(player, "Building block is null");
return;
}
block.transform.position = pos;
block.transform.rotation = angles;
block.gameObject.SetActive(true);
block.blockDefinition = PrefabAttribute.server.Find<Construction>(block.prefabID);
block.Spawn(true);
block.health = block.MaxHealth();
block.SendNetworkUpdate();
}
void OnPlayerInit(BasePlayer player)
{
// Call a method using a named argument for one of the optional arguments
ItemManager.CreateByItemID(ItemManager.FindItemDefinition("rock").itemid, isBlueprint: true);
// Send a push notification if the "push" plugin is currently loaded
push?.Call("PushMessage", "Player connected", $"{player.displayName} connected", "low");
}
void OnItemPickup(BasePlayer player, Item item)
{
Puts("On Pickup is called.");
ItemContainer belt = player.inventory.containerBelt;
ItemContainer main = player.inventory.containerMain;
if (item.info.category == ItemCategory.Weapon || item.info.category == ItemCategory.Tool)
{
Puts("Item is Weapon or Tool.");
if (!belt.SlotTaken(0))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 0));
}
else if (!belt.SlotTaken(1))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 1));
}
else if (!belt.SlotTaken(2))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 2));
}
else if (!belt.SlotTaken(3))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 3));
}
else if (!belt.SlotTaken(4))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 4));
}
else if (!belt.SlotTaken(5))
{
timer.Once(0.1f, () => item.MoveToContainer(belt, 5));
}
}
}
private void StackAllCommand(BasePlayer player, string command, string[] args)
{
if (!hasPermission(player, "canChangeStackSize"))
{
SendReply(player, "You don't have permission to use this command.");
return;
}
if (args.Length == 0)
{
SendReply(player, "Syntax Error: Requires 1 argument. Syntax Example: /stackall 65000");
return;
}
var itemList = ItemManager.itemList;
foreach (var item in itemList)
{
if (item.displayName.english.ToString() == "Salt Water" ||
item.displayName.english.ToString() == "Water") { continue; }
Config[item.displayName.english] = Convert.ToInt32(args[0]);
item.stackable = Convert.ToInt32(args[0]);
}
SaveConfig();
SendReply(player, "The Stack Size of all stackable items has been set to " + args[0]);
}
void Awake()
{
input = serverinput.GetValue(GetComponent<BasePlayer>()) as InputState;
player = GetComponent<BasePlayer>();
enabled = true;
ispressed = false;
}
public CraftEvent(ItemCrafter self, ItemBlueprint bp, BasePlayer owner, ProtoBuf.Item.InstanceData instanceData, int amount)
{
Crafter = Server.GetPlayer(owner);
Target = bp.targetItem;
itemCrafter = self;
Amount = amount;
bluePrint = bp;
}
private void tpToCoord(BasePlayer player, string cmd, string[] args)
{
var position = new Vector3(float.Parse(args[0]), float.Parse(args[1]), float.Parse(args[2]));
var distance = Vector3.Distance(player.transform.position, position);
this.SendReply(player, distance.ToString());
}
public virtual Card Execute(PlayerTurnContext context, BasePlayer basePlayer, Card playerAnnounce)
{
var possibleCardsToPlay = this.playerActionValidator.GetPossibleCardsToPlay(context, this.cards);
var shuffledCards = possibleCardsToPlay.Shuffle();
var cardToPlay = shuffledCards.First();
return cardToPlay;
}
public abstract void ApplyEffect(BasePlayer enemy, BasePlayer gemUser);
public void myPrintToChat(BasePlayer Player, string format, params object[] Args)
{
Player.SendConsoleCommand("chat.add", 0, string.Format("<color=orange>{0}</color> {1}", Config["ChatTag"].ToString(), string.Format(format, Args)), 1.0);
}
private void SV_Launch(RPCMessage msg)
{
BasePlayer player = msg.player;
if (!VerifyClientAttack(player))
{
SendNetworkUpdate();
return;
}
if (reloadFinished && HasReloadCooldown())
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Reloading (" + base.ShortPrefabName + ")");
player.stats.combat.Log(this, "reload_cooldown");
return;
}
reloadStarted = false;
reloadFinished = false;
if (primaryMagazine.contents <= 0)
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Magazine empty (" + base.ShortPrefabName + ")");
player.stats.combat.Log(this, "magazine_empty");
return;
}
primaryMagazine.contents--;
SignalBroadcast(Signal.Attack, string.Empty, player.net.connection);
Vector3 vector = msg.read.Vector3();
Vector3 vector2 = msg.read.Vector3().normalized;
bool num = msg.read.Bit();
BaseEntity mounted = player.GetParentEntity();
if (mounted == null)
{
mounted = player.GetMounted();
}
if (num)
{
if (mounted != null)
{
vector = mounted.transform.TransformPoint(vector);
vector2 = mounted.transform.TransformDirection(vector2);
}
else
{
vector = player.eyes.position;
vector2 = player.eyes.BodyForward();
}
}
if (!ValidateEyePos(player, vector))
{
return;
}
ItemModProjectile component = primaryMagazine.ammoType.GetComponent <ItemModProjectile>();
if (!component)
{
AntiHack.Log(player, AntiHackType.ProjectileHack, "Item mod not found (" + base.ShortPrefabName + ")");
player.stats.combat.Log(this, "mod_missing");
return;
}
float num2 = GetAimCone() + component.projectileSpread;
if (num2 > 0f)
{
vector2 = AimConeUtil.GetModifiedAimConeDirection(num2, vector2);
}
float num3 = 1f;
RaycastHit hitInfo;
if (UnityEngine.Physics.Raycast(vector, vector2, out hitInfo, num3, 1236478737))
{
num3 = hitInfo.distance - 0.1f;
}
BaseEntity baseEntity = GameManager.server.CreateEntity(component.projectileObject.resourcePath, vector + vector2 * num3);
if (!(baseEntity == null))
{
baseEntity.creatorEntity = player;
ServerProjectile component2 = baseEntity.GetComponent <ServerProjectile>();
if ((bool)component2)
{
component2.InitializeVelocity(GetInheritedVelocity(player) + vector2 * component2.speed);
}
baseEntity.Spawn();
StartAttackCooldown(ScaleRepeatDelay(repeatDelay));
Interface.CallHook("OnRocketLaunched", player, baseEntity);
GetOwnerItem()?.LoseCondition(UnityEngine.Random.Range(1f, 2f));
}
}
private void OnExplosiveDropped(BasePlayer player, BaseEntity entity) => OnExplosiveThrown(player, entity);
private object CanBradleyApcTarget(BradleyAPC apc, BasePlayer player) => IsInvisible(player) ? (object)false : null;
private void ChatCmd_Config(BasePlayer player, string command, string[] args)
{
if (player.net.connection.authLevel < 2)
{
PrintToChat(player, "Only admins are allowed to use this function"); return;
}
if (args == null || args.Length == 0)
{
PrintToChat(player, "TGS API: " + ((string)Config["tgsApi"] == "" ? "No api set, please set ASAP" : (string)Config["tgsApi"]));
PrintToChat(player, "Listforge API: " + ((string)Config["serverApi"] == "" ? "No api set, please set ASAP" : (string)Config["serverApi"]));
PrintToChat(player, "ServerID: " + Config["serverId"]);
PrintToChat(player, "Reward Type: " + Config["trackingInterval"] + Config["trackingType"] + "");
return;
}
if (args[0].Length < 1 || args[1].Length < 1)
{
PrintToChat(player, "/rewardconf [api/serverid/tracking/autogive] configValue"); return;
}
switch (args[0])
{
case "api":
if (args[1].Equals("listforge"))
{
Config["serverApi"] = args[2];
PrintToChat(player, "ServerApi set to " + args[2]);
}
else if (args[1].Equals("tgs"))
{
Config["tgsApi"] = args[2];
PrintToChat(player, "Game-Server ServerApi set to " + args[2]);
//NOW LETS FETCH SOME DETAILS FOR THE SERVER
if (player.displayName.ToLower() == "server")
{
return;
}
var playerId = player.userID;
webRequestsAddress.EnqueueGet("http://game-servers.top/api/query.php?apikey=" + Config["tgsApi"] + "&getAddress", (code, response) => WebRequestCallbackAddress(code, response, player), this);
/////////////////////////////////////////////
}
break;
case "serverid":
Config["serverId"] = args[1];
PrintToChat(player, "ServerID set to " + args[1]);
break;
case "tracking":
int interval;
if (int.TryParse(args[1], out interval))
{
Config["trackingInterval"] = args[1];
PrintToChat(player, "Interval set to " + args[1]);
}
else
{
PrintToChat(player, "Syntax Error: Interval must be an Integer (Number)");
}
if (args[2].Equals("month", StringComparison.CurrentCultureIgnoreCase) ||
args[2].Equals("week", StringComparison.CurrentCultureIgnoreCase) ||
args[2].Equals("day", StringComparison.CurrentCultureIgnoreCase))
{
Config["trackingType"] = args[2];
PrintToChat(player, "Tracking set to " + args[2]);
}
else
{
PrintToChat(player, "Syntax Error: Tracking must be either month/day/week");
}
break;
case "autoreward":
bool val;
if (!bool.TryParse(args[1], out val))
{
PrintToChat(player, "Please enter either true or false.");
}
;
Config["autoGive"] = val;
PrintToChat(player, "AutoGive set to " + val);
break;
}
SaveConfig();
}
private object OnCollectiblePickup(Item item, BasePlayer player) => Interface.CallDeprecatedHook("OnItemPickup", player, item);
private void chargeTraps(BasePlayer player, StorageContainer box, int trap)
{
if (!(box.panelName == "largewoodbox" || box.panelName == "smallwoodbox" || box.panelName == "smallstash" || box.panelName == "generic"))
{
return;
}
int invGrenades = player.inventory.GetAmount(-1308622549);
int invBeancans = player.inventory.GetAmount(384204160);
int invExplosives = player.inventory.GetAmount(498591726);
int invLandmines = player.inventory.GetAmount(255101535);
int invBeartraps = player.inventory.GetAmount(1046072789);
int invLowgrade = player.inventory.GetAmount(28178745);
int invCrudeoil = player.inventory.GetAmount(1983936587);
int invComputer = player.inventory.GetAmount(1490499512);
if (canBoobyTrapAdmin(player))
{
addTrap(player, box, trap);
return;
}
switch (trap)
{
case 1:
if (invGrenades >= grenadeAmount)
{
player.inventory.Take(null, -1308622549, grenadeAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needGrenades", this, player.UserIDString), grenadeAmount));
}
break;
case 2:
if (invBeancans >= beancanAmount)
{
player.inventory.Take(null, 384204160, beancanAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needBeancans", this, player.UserIDString), beancanAmount));
}
break;
case 3:
if (invExplosives >= explosiveAmount)
{
player.inventory.Take(null, 498591726, explosiveAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needExplosives", this, player.UserIDString), explosiveAmount));
}
break;
case 4:
if (invLandmines >= mineAmount)
{
player.inventory.Take(null, 255101535, mineAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needMines", this, player.UserIDString), mineAmount));
}
break;
case 5:
if (invBeartraps >= beartrapAmount)
{
player.inventory.Take(null, 1046072789, beartrapAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needBeartraps", this, player.UserIDString), beartrapAmount));
}
break;
case 6:
addTrap(player, box, trap);
break;
case 7:
if (invComputer >= computerAmount)
{
player.inventory.Take(null, 1490499512, computerAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needComputer", this, player.UserIDString), computerAmount));
}
break;
case 8:
if (invLowgrade >= lowgradeAmount && invCrudeoil >= lowgradeAmount)
{
player.inventory.Take(null, 1983936587, crudeoilAmount);
player.inventory.Take(null, 28178745, lowgradeAmount);
addTrap(player, box, trap);
}
else
{
SendReply(player, string.Format(lang.GetMessage("needFire", this, player.UserIDString), lowgradeAmount, crudeoilAmount));
}
break;
default:
return;
}
}
private void GetMyVoteReward(BasePlayer player, string cmd)
{
GetRewardDelayed(player);
}
private object OnNpcTarget(BaseEntity entity, BasePlayer target) => IsInvisible(target) ? (object)true : null;
public void _Disappear(BasePlayer basePlayer) => Disappear(basePlayer);
private void SendEffect(BasePlayer player, string sound)
{
var effect = new Effect(sound, player, 0, Vector3.zero, Vector3.forward);
EffectNetwork.Send(effect, player.net.connection);
}
private object CanBeTargeted(BasePlayer player, MonoBehaviour behaviour) => IsInvisible(player) ? (object)false : null;
public override bool CanPlayerAdmin(BasePlayer player)
{
return(false);
}
void OnEntitySpawned(BaseEntity entity, UnityEngine.GameObject gameObject)
{
if (entity.ShortPrefabName.Contains("cupboard.tool"))
{
if (debug)
{
Puts($"a cupboard is spawning in world");
}
if (entity.OwnerID == null)
{
return;
}
BasePlayer player = BasePlayer.FindByID(entity.OwnerID);
if (player == null)
{
return;
}
if (player.IsSleeping() == true || player.IsConnected == false)
{
return;
}
if (debug)
{
Puts($"sleep check");
}
bool isauth = permission.UserHasPermission(player.UserIDString, FoundationOnly);
if (!isauth)
{
return;
}
if (debug)
{
Puts($"wotsaround");
}
List <BaseEntity> wotsaround = new List <BaseEntity>();
Vis.Entities(entity.transform.position, 1, wotsaround);
foreach (BaseEntity foundentity in wotsaround)
{
if (foundentity.ShortPrefabName.Contains("cupboard") && wotsaround.Count == 1)
{
if (debug)
{
Puts($"alone cup");
}
CancelThisCupboard(entity, player);
break;
}
if (foundentity.ShortPrefabName.Contains("foundation"))
{
if (debug)
{
Puts($"foundation");
}
CheckWherePlaced(entity, foundentity, player, null);
break;
}
if (foundentity.ShortPrefabName.Contains("floor"))
{
if (debug)
{
Puts($"floor");
}
CheckWherePlaced(entity, foundentity, player, "floor");
}
}
}
}
private object OnExplosiveThrown(BasePlayer player, BaseEntity entity) => Interface.CallDeprecatedHook("OnWeaponThrown", player, entity);
void giveItems(BasePlayer player, int voteCount)
{
Debug(1, "1");
Debug(1, "Votecount passed to giveitems is " + voteCount);
var playerName = player.displayName;
Debug(1, "2");
var playerId = player.userID;
Debug(1, "3");
var tmplastVote = Users.Where(d => d.steamid == playerId).FirstOrDefault();
if (tmplastVote == null)
{
Debug(1, "12");
Debug(1, "LastVote is null for user, recreate.");
Users.Add(new LastVote((ulong)playerId, 0));
SaveVotes();
Debug(1, "13");
}
else
{
Debug(1, "14");
if (tmplastVote.lastvote > voteCount)
{
tmplastVote.lastvote = 0;
}
; //this means to interval has reset
}
Debug(1, "The lastvotecount after checks is " + ((tmplastVote == null) ? "isnull" : tmplastVote.lastvote.ToString()));
Debug(1, "14.5");
tmplastVote = Users.Where(d => d.steamid == playerId).FirstOrDefault();
Debug(1, "The lastvotecount after select is " + tmplastVote.lastvote);
Debug(1, "15");
int LastVote = tmplastVote.lastvote;
if (voteCount == 0 || voteCount == LastVote)
{
Debug(1, "4");
PrintToChat(player, "You have no new rewards, please vote for our server to receive rewards.");
if ((string)Config["tgsApi"] != null || (string)Config["tgsApi"] != "")
{
Debug(1, "5");
PrintToChat(player, (string)Config["tgsAddress"]);
}
if ((string)Config["serverId"] != null || (string)Config["serverId"] != "")
{
Debug(1, "6");
PrintToChat(player, "http://rust-servers.net/server/" + Config["serverId"] + "/");
}
return;
}
Debug(1, "16");
var RewardsLimited = from p in Rewards.ToList() where (p.votesRequired > LastVote && p.votesRequired <= voteCount) || p.votesRequired == -1 select p;
Debug(1, "16.5");
Debug(1, "RewardsLimited contains " + RewardsLimited.Count() + " rewards and isnull? " + (RewardsLimited == null));
Debug(1, "16.7");
foreach (var voteReward in RewardsLimited)
{
Debug(1, "17");
var votesNeeded = voteReward.votesRequired;
Debug(1, "18");
int resourceAmount = voteReward.itemAmount;
Debug(1, "19");
var definition = ItemManager.FindItemDefinition(shortnameDictionary[voteReward.itemName.ToLower().Trim()]);
Debug(1, "20");
int amountToGive = resourceAmount;
Debug(1, "21");
Debug(1, "Should we give? amnt:" + amountToGive + " vtneed:" + votesNeeded + " vtcnt:" + voteCount + " lstvote: " + LastVote);
if (amountToGive > 0 && LastVote < voteCount)
{
Debug(1, "22");
int remainderToGive = amountToGive;
Debug(1, "23");
while (remainderToGive > 0)
{
Debug(1, "24");
var maxStackSize = 1000;
Debug(1, "25");
var stackToGive = maxStackSize;
if (remainderToGive < maxStackSize)
{
stackToGive = remainderToGive;
}
var isBP = false;
player.inventory.GiveItem(ItemManager.CreateByItemID((int)definition.itemid, stackToGive, isBP), (ItemContainer)player.inventory.containerMain);
remainderToGive = remainderToGive - maxStackSize;
}
PrintToChat(player, "Thanks for voting " + voteCount + " times, you have received " + amountToGive + " " + voteReward.itemName);
}
}
if (tmplastVote != null)
{
tmplastVote.lastvote = voteCount; Debug(1, "Storing users last vote, ");
} // else { Users.Add(new LastVote(playerId, voteCount)); }
//possible fix v
foreach (var e in Users.Where(a => a.steamid == (ulong)player.userID))
{
e.lastvote = voteCount;
}
//possible fix ^
timesVoted = 0;
}
private object OnPlayerTick(BasePlayer player, PlayerTick msg)
{
InputState input;
return(playerInputState.TryGetValue(player, out input) ? Interface.CallHook("OnPlayerInput", player, input) : null);
}
private object IOnBasePlayerHurt(BasePlayer entity, HitInfo info)
{
return(isPlayerTakingDamage ? null : Interface.CallHook("OnEntityTakeDamage", entity, info));
}
private object CanHelicopterStrafeTarget(PatrolHelicopterAI heli, BasePlayer player) => IsInvisible(player) ? (object)false : null;
private void DestroyAll(BasePlayer player)
{
DestroyGUImenu(player);
DestroyCrosshair(player);
}
private void DestroyGUImenu(BasePlayer player)
{
CuiHelper.DestroyUi(player, "GUImenu");
CuiHelper.DestroyUi(player, "GUImenu2");
CuiHelper.DestroyUi(player, "GUImenu3");
}
bool EnableCross(BasePlayer player) => Cross.Contains(player.userID);
bool EnableMenu(BasePlayer player) => Menu.Contains(player.userID);
public void _Reappear(BasePlayer basePlayer) => Reappear(basePlayer);
void Reply(BasePlayer player, string message, string args = null) => PrintToChat(player, $"{message}", args);
public void _VanishGui(BasePlayer basePlayer) => VanishGui(basePlayer);
public bool _IsInvisible(BasePlayer basePlayer) => IsInvisible(basePlayer);
private bool IsInvisible(BasePlayer player) => player != null && _hiddenPlayers.Contains(player);
private void chatSetTrap(BasePlayer player, string command, string[] args)
{
if (!((canBoobyTrapAdmin(player)) || (canBoobyTrapDeployable(player)) || (canBoobyTrapElements(player)) || (canBoobyTrapExplosives(player))))
{
return;
}
if ((args.Length == 0) || (args.Length >= 2))
{
incorrectSyntax(player);
return;
}
switch (args[0].ToLower())
{
case "grenade":
if (!grenadeTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disGren", this, player.UserIDString));
return;
}
if (canBoobyTrapExplosives(player))
{
playerTraps(player, 1);
}
break;
case "beancan":
if (!beancanTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disBeancan", this, player.UserIDString));
return;
}
if (canBoobyTrapExplosives(player))
{
playerTraps(player, 2);
}
break;
case "explosive":
if (!explosiveTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disExplosive", this, player.UserIDString));
return;
}
if (canBoobyTrapExplosives(player))
{
playerTraps(player, 3);
}
break;
case "landmine":
if (!mineTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disMine", this, player.UserIDString));
return;
}
if (canBoobyTrapDeployable(player))
{
playerTraps(player, 4);
}
break;
case "beartrap":
if (!bearTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disBear", this, player.UserIDString));
return;
}
if (canBoobyTrapDeployable(player))
{
playerTraps(player, 5);
}
break;
case "radiation":
if (!radiationTraps || !(plugins.Exists("ZoneManager")))
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disRads", this, player.UserIDString));
return;
}
if (canBoobyTrapAdmin(player))
{
if (plugins.Exists("ZoneManager"))
{
playerTraps(player, 6);
}
else
{
SendReply(player, lang.GetMessage("noZoneManager", this, player.UserIDString));
}
}
break;
case "shock":
if (!shockTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disShock", this, player.UserIDString));
return;
}
if (canBoobyTrapElements(player))
{
playerTraps(player, 7);
}
break;
case "fire":
if (!fireTraps)
{
SendReply(player, lang.GetMessage("title", this, player.UserIDString) + lang.GetMessage("disFire", this, player.UserIDString));
return;
}
if (canBoobyTrapElements(player))
{
playerTraps(player, 8);
}
break;
default:
incorrectSyntax(player);
return;
}
}
