public List <string> getFriendList(string player)
{
object friends_obj = null;
DateTime lastFriendCheckPlayer;
if (lastFriendCheck.TryGetValue(player, out lastFriendCheckPlayer))
{
if ((DateTime.Now - lastFriendCheckPlayer).TotalMinutes <= cacheTimer)
{
return(friendCache[player]);
}
else
{
friends_obj = Friends?.CallHook("IsFriendOfS", player);
lastFriendCheck[player] = DateTime.Now;
}
}
else
{
friends_obj = Friends?.CallHook("IsFriendOfS", player);
if (lastFriendCheck.ContainsKey(player))
{
lastFriendCheck.Remove(player);
}
if (friendCache.ContainsKey(player))
{
friendCache.Remove(player);
}
lastFriendCheck.Add(player, DateTime.Now);
}
var players = new List <string>();
if (friends_obj == null)
{
return(players);
}
string[] friends = friends_obj as string[];
foreach (string fid in friends)
{
players.Add(fid);
}
if (friendCache.ContainsKey(player))
{
friendCache[player] = players;
}
else
{
friendCache.Add(player, players);
}
return(players);
}
void Unload()
{
if (useZoneManager)
{
foreach (var zone in zones)
{
ZoneManager.CallHook("EraseZone", zone.Value.zoneid);
}
}
}
void cmdPm(BasePlayer player, string command, string[] args)
{
if (args.Length > 1)
{
var name = args[0];
var p = FindPlayer(name);
if (p == player)
{
PrintMessage(player, "SelfPM");
return;
}
if (p != null)
{
if (!(bool)(Interface.Oxide.CallHook("CanChat", player) ?? true))
{
SendReply(player, "You are not allowed to chat here");
return;
}
var hasIgnore = Ignore?.CallHook("HasIgnored", p.userID, player.userID);
if (hasIgnore != null && (bool)hasIgnore)
{
PrintMessage(player, "IgnoreYou", p.displayName);
return;
}
hasIgnore = BetterChat?.CallHook("API_PlayerIgnores", p.UserIDString, player.UserIDString);
if (hasIgnore != null && (bool)hasIgnore)
{
PrintMessage(player, "IgnoreYou", p.displayName);
return;
}
var msg = string.Empty;
for (var i = 1; i < args.Length; i++)
{
msg = $"{msg} {args[i]}";
}
pmHistory[player.userID] = p.userID;
pmHistory[p.userID] = player.userID;
PrintMessage(player, "PMTo", p.displayName, msg);
PrintMessage(p, "PMFrom", player.displayName, msg);
Effect.server.Run("assets/prefabs/locks/keypad/effects/lock.code.updated.prefab", p, 0, Vector3.zero, Vector3.zero);
Puts("[PM]{0}->{1}:{2}", player.displayName, p.displayName, msg);
}
else
{
PrintMessage(player, "PlayerNotOnline", name);
}
}
else
{
PrintMessage(player, "SyntaxPM");
}
}
private void PlayerCommand(BasePlayer player, string command, string[] args)
{
if (ConnectionDB)
{
if (Convert.ToBoolean(ConnectionDB.CallHook("ConnectionDataExists", player)))
{
DateTime init_date = Convert.ToDateTime(ConnectionDB.CallHook("FirstSeen", player));
int seconds = Convert.ToInt32(ConnectionDB.CallHook("SecondsPlayed", player));
TimeSpan ts = TimeSpan.FromSeconds(seconds);
PrintToChat(player, "<color=#66ff66>" + player.displayName + "</color> (<color=#ffccff>" + Convert.ToString(ConnectionDB.CallHook("FirstName", player)) + "</color>):\nYou have played <color=yellow>" + Math.Round(ts.TotalMinutes).ToString() + "</color> minutes since <color=yellow>" + init_date.ToShortDateString() + "</color>!\nTotal Seconds: <color=yellow>" + seconds.ToString() + "</color> | Connections: <color=yellow>" + Convert.ToString(ConnectionDB.CallHook("Connections", player)) + "</color>.");
}
}
}
void cmdPm(BasePlayer player, string command, string[] args)
{
if (args.Length > 1)
{
var name = args[0];
var p = FindPlayer(name);
if (p == player)
{
PrintMessage(player, "SelfPM");
return;
}
if (p != null)
{
if (!(bool)(Interface.Oxide.CallHook("CanChat", player) ?? true))
{
SendReply(player, "You are not allowed to chat here");
return;
}
var hasIgnore = Ignore?.CallHook("HasIgnored", p.userID, player.userID);
if (hasIgnore != null && (bool)hasIgnore)
{
PrintMessage(player, "IgnoreYou", p.displayName);
return;
}
if (RustyChat != null && ((double)RustyChat.Call("IsMutePlayer", player.userID)) > 0)
{
SendReply(player, "Ваш чат заблокирован!");
return;
}
var msg = string.Empty;
for (var i = 1; i < args.Length; i++)
{
msg = $"{msg} {args[i]}";
}
pmHistory[player.userID] = p.userID;
pmHistory[p.userID] = player.userID;
PrintMessage(player, "PMTo", p.displayName, msg);
PrintMessage(p, "PMFrom", player.displayName, msg);
Puts("[PM]{0}->{1}:{2}", player.displayName, p.displayName, msg);
}
else
{
PrintMessage(player, "PlayerNotOnline", name);
}
}
else
{
PrintMessage(player, "SyntaxPM");
}
}
private bool CheckPlayerMoney(BasePlayer player, int amount)
{
if (useEconomics)
{
double money = (double)Economics?.CallHook("GetPlayerMoney", player.userID);
if (money >= amount)
{
money = money - amount;
Economics?.CallHook("Set", player.userID, money);
return(true);
}
return(false);
}
return(false);
}
void TransferMoney(BasePlayer victim, BasePlayer attacker)
{
// Check if player is in event/zone with no looting
var inEvent = EventManager?.Call("isPlaying", victim);
if (inEvent != null && (bool)inEvent)
{
return;
}
if (ZoneManager != null)
{
var noLooting = Enum.Parse(ZoneManager.GetType().GetNestedType("ZoneFlags"), "noplayerloot", true);
if ((bool)ZoneManager.CallHook("HasPlayerFlag", victim, noLooting))
{
return;
}
}
// Calculate and transfer money
var wallet = (double)Economics.Call("GetPlayerMoney", victim.userID);
var amount = victim.IsSleeping() ? Math.Floor(wallet * (PercentSleeping / 100)) : Math.Floor(wallet * (PercentAwake / 100));
if (amount > 0)
{
Economics.Call("Transfer", victim.userID, attacker.userID, amount);
PrintToChat(attacker, MoneyStolen.Replace("{amount}", amount.ToString()).Replace("{player}", victim.displayName));
return;
}
PrintToChat(attacker, NothingStolen.Replace("{player}", victim.displayName));
}
bool IsFriend(ulong friendid, ulong playerid)
{
if (UseFriendsAPI && Friends != null)
{
var fr = Friends.CallHook("AreFriends", friendid, playerid);
if (fr != null && (bool)fr)
{
return(true);
}
}
if (UseTeams)
{
BasePlayer player = BasePlayer.FindByID(playerid);
if (player.currentTeam != (long)0)
{
RelationshipManager.PlayerTeam playerTeam = RelationshipManager.Instance.FindTeam(player.currentTeam);
if (playerTeam == null)
{
return(false);
}
if (playerTeam.members.Contains(friendid))
{
return(true);
}
}
}
return(false);
}
private void NotifyDiscord(Configuration.Limit limit, BaseNetworkable entity, BasePlayer player)
{
var discord = limit.Webhook;
if (string.IsNullOrEmpty(discord.Webhook) || DiscordMessages == null || !DiscordMessages.IsLoaded)
{
return;
}
object fields = new[]
{
new
{
name = discord.PlayerTitle,
value = discord.Player.Replace("{name}", player?.displayName ?? "Unknown")
.Replace("{id}", player?.UserIDString ?? "0"),
inline = discord.Inline
},
new
{
name = discord.EntityTitle,
value = discord.Entity.Replace("{shortname}", entity.ShortPrefabName)
.Replace("{id}", entity.net.ID.ToString()).Replace("{type}", limit.Name),
inline = discord.Inline
},
new
{
name = discord.PositionTitle,
value = discord.Position.Replace("{position}", FormattedCoordinates(entity.transform.position)),
inline = discord.Inline
}
};
DiscordMessages.CallHook("API_SendFancyMessage", discord.Webhook, discord.Title, discord.Color, JsonConvert.SerializeObject(fields));
}
private object OnAttackInternal(BasePlayer attacker, BasePlayer victim, HitInfo hit)
{
if (configData.FriendlyFire || attacker == victim || FriendlyFireEnabled(attacker.userID))
{
return(null);
}
var victimId = victim.userID;
var attackerId = attacker.userID;
var hasFriend = (bool)(Friends?.CallHook("HasFriend", attackerId, victimId) ?? false);
if (!hasFriend)
{
hasFriend = (bool)(Clans?.CallHook("HasFriend", attacker.UserIDString, victim.UserIDString) ?? false);
if (!hasFriend)
{
return(null);
}
}
var now = Facepunch.Math.Epoch.Current;
int time;
var key = $"{attackerId}-{victimId}";
if (!times.TryGetValue(key, out time) || time < now)
{
PrintToChat(attacker, _("CannotHurt", attacker, victim.displayName));
times[key] = now + 10;
}
hit.damageTypes = new DamageTypeList();
hit.DidHit = false;
hit.HitEntity = null;
hit.Initiator = null;
hit.DoHitEffects = false;
hit.HitMaterial = 0;
return(false);
}
private string getDeathMessage(string deathType, string listKey, object tags)
{
List <string> messageList;
string message = null;
if (messages.ContainsKey(deathType))
{
if (messages[deathType].ContainsKey(listKey))
{
if (disabledMessages.Contains($"{deathType}.{listKey}"))
{
return(null);
}
messageList = messages[deathType][listKey];
}
else
{
if (disabledMessages.Contains($"{deathType}.Default"))
{
return(null);
}
messageList = messages[deathType]["Default"];
}
message = messageList[random.Next(messageList.Count)].ToString();
}
if (message == null)
{
return(message);
}
return(Death.CallHook("GetDeathString", message, tags).ToString());;
}
private void GiveCredit(BasePlayer player, string type, float amount, string gathered)
{
if (amount > 0)
{
if (config.Settings.UseEconomics && Economics)
{
Economics.CallHook("Deposit", player.UserIDString, amount);
}
if (config.Settings.UseServerRewards && ServerRewards)
{
ServerRewards?.Call("AddPoints", new object[] { player.userID, amount });
}
if (type == "gather" && config.Settings.ShowMessagesOnGather)
{
PrintToChat(player, config.Settings.PluginPrefix + " " + string.Format(Lang("ReceivedForGather", player), amount, gathered.ToLower()));
}
else if (type == "kill" && config.Settings.ShowMessagesOnKill)
{
PrintToChat(player, config.Settings.PluginPrefix + " " + string.Format(Lang("ReceivedForKill", player), amount, gathered.ToLower()));
}
}
else
{
amountstring = amount.ToString().Replace("-", "");
amount = float.Parse(amountstring);
if (config.Settings.UseEconomics && Economics)
{
Economics.CallHook("Withdraw", player.UserIDString, amount);
}
if (config.Settings.UseServerRewards && ServerRewards)
{
ServerRewards?.Call("TakePoints", new object[] { player.userID, amount });
}
if (type == "gather" && config.Settings.ShowMessagesOnGather)
{
PrintToChat(player, config.Settings.PluginPrefix + " " + string.Format(Lang("LostForGather", player), amount, gathered.ToLower()));
}
else if (type == "kill" && config.Settings.ShowMessagesOnKill)
{
PrintToChat(player, config.Settings.PluginPrefix + " " + string.Format(Lang("LostForKill", player), amount, gathered.ToLower()));
}
}
}
private bool AreFriends(string playerId, string friendId)
{
try {
bool result = (bool)Friends?.CallHook("AreFriends", playerId, friendId);
return(result);
} catch {
return(false);
}
}
private void ProcessConfiguration(BasePlayer player, string type)
{
var entityName = type.Contains("cupboard") ? "Tool Cupboard" : (type.Contains("lock") ? "Code Lock" : "Turret");
if (Configuration.SendToDiscord && DiscordMessages)
{
object fields = new[]
{
new
{
name = "Player", value = $"{player.displayName} ({player.UserIDString})", inline = true
},
new
{
name = "Coordinates", value = $"teleportpos {FormattedCoordinates(player)}", inline = true
},
new
{
name = "Violation Type", value = $"{entityName}", inline = true
}
};
DiscordMessages?.Call("API_SendFancyMessage", Configuration.DiscordWebhook,
Configuration.DiscordEmbedTitle, Configuration.DiscordEmbedColor,
JsonConvert.SerializeObject(fields));
}
if (Configuration.SendToSlack && Slack)
{
Slack.CallHook("Message", Lang("slackMessage")
.Replace("{player}", player.displayName)
.Replace("{steamID}", player.UserIDString)
.Replace("{type}", entityName)
.Replace("{coordinates}", FormattedCoordinates(player)));
}
if (Configuration.SendToStaff)
{
foreach (var target in BasePlayer.activePlayerList.Where(x => x.IsAdmin || HasPermission(x, "grouplimits.notify")))
{
PrintToChat(target, Lang("staffMessage")
.Replace("{player}", player.displayName)
.Replace("{steamID}", player.UserIDString)
.Replace("{type}", entityName)
.Replace("{coordinates}", FormattedCoordinates(player)));
}
}
if (!Configuration.WarnPlayers)
{
return;
}
PrintToChat(player, Lang("playerMessage").Replace("{limit}", Configuration.MaxPlayers.ToString()));
}
void OnServerInitialized()
{
defaultClanCol = Config["defaultClanCol"];
before = Config["BeforeTag"];
after = Config["AfterTag"];
perClanColor = JsonConvert.DeserializeObject <Dictionary <string, string> >(JsonConvert.SerializeObject(Config["PerClanColor"]));
permission.RegisterPermission("clantags.admin", this);
permission.RegisterPermission("clantags.default", this);
BetterChat?.CallHook("API_RegisterThirdPartyTitle", this, new Func <IPlayer, string>(GetClanTagFormatted));
}
bool IsFriend(ulong playerid, ulong friend)
{
if (UseFriendsAPI && Friends != null)
{
var fr = Friends.CallHook("AreFriends", playerid, friend);
if (fr != null && (bool)fr)
{
return(true);
}
}
return(false);
}
private string RunPlaceholders(IPlayer player, string message)
{
if (PlaceholderAPI == null || !PlaceholderAPI.IsLoaded)
{
return(message);
}
var builder = new StringBuilder(message);
PlaceholderAPI.CallHook("ProcessPlaceholders", player, builder);
return(builder.ToString());
}
private bool CheckActiveFriends(ulong id)
{
foreach (var pair in playerConnections.PlayerInfo)
{
if ((bool)Friends?.CallHook("AreFriends", pair.Key, id))
{
if (UnixTimeStampUTC() - playerConnections.PlayerInfo[pair.Key].LastTime < inactiveAfter)
{
return(true);
}
}
}
return(false);
}
private object OnAttackInternal(BasePlayer attacker, BasePlayer victim, HitInfo hit)
{
if (attacker == victim)
{
return(null);
}
float amount = hit.damageTypes.Get(hit.damageTypes.GetMajorityDamageType());
float scale = attackerAmount / 100;
if (!adminPunish)
{
var victimId = victim.userID;
var attackerId = attacker.userID;
var hasFriend = (bool)(Friends?.CallHook("HasFriend", attackerId, victimId) ?? false);
if (hasFriend)
{
attacker.Hurt(amount * scale);
if (debug)
{
Puts(amount.ToString());
}
if (debug)
{
Puts(scale.ToString());
}
return(true);
}
}
else
{
if (!permission.UserHasPermission(victim.UserIDString, adminPerm))
{
return(null);
}
attacker.Hurt(amount * scale);
if (debug)
{
Puts(amount.ToString());
}
if (debug)
{
Puts(scale.ToString());
}
return(true);
}
return(null);
}
// playerid = active player, ownerid = owner of camera, who may be offline
bool IsFriend(ulong playerid, ulong ownerid)
{
if (configData.useFriends && Friends != null)
{
var fr = Friends?.CallHook("AreFriends", playerid, ownerid);
if (fr != null && (bool)fr)
{
return(true);
}
}
if (configData.useClans && Clans != null)
{
string playerclan = (string)Clans?.CallHook("GetClanOf", playerid);
string ownerclan = (string)Clans?.CallHook("GetClanOf", ownerid);
if (playerclan == ownerclan && playerclan != null && ownerclan != null)
{
return(true);
}
}
if (configData.useTeams)
{
BasePlayer player = BasePlayer.FindByID(playerid);
if (player.currentTeam != (long)0)
{
RelationshipManager.PlayerTeam playerTeam = RelationshipManager.ServerInstance.FindTeam(player.currentTeam);
if (playerTeam == null)
{
return(false);
}
if (playerTeam.members.Contains(ownerid))
{
return(true);
}
}
}
return(false);
}
private bool IsIgnored(IPlayer sender, IPlayer target)
{
if (configData.UseIgnore)
{
var hasIgnore = Ignore?.CallHook("HasIgnored", target.Id, sender.Id);
if (hasIgnore != null && (bool)hasIgnore)
{
sender.Reply(Lang("IgnoreYou", sender.Id, target.Name));
return(true);
}
}
return(false);
}
public void TeleportLand(BasePlayer player, int id)
{
if (GetLand(id) == null)
{
Send(player, GetMessage("WrongID")); return;
}
Vector3 landPosition = (Vector3)ZoneManager.CallHook("GetZoneLocation", GetLand(id).zoneID.ToString());
if (landPosition == null)
{
Send(player, GetMessage("ErrorTP")); return;
}
player.transform.position = landPosition;
Send(player, GetMessage("TP"), id);
}
/// <summary>
/// Display a game tip to the given player
/// </summary>
/// <param name="player"></param>
/// <param name="tip"></param>
private void ShowGameTip(BasePlayer player, string tip)
{
if (player == null)
{
return;
}
if (GameTipAPI)
{
GameTipAPI.CallHook("ShowGameTip", player, tip, 5f);
}
else
{
player.SendConsoleCommand("gametip.hidegametip");
player.SendConsoleCommand("gametip.showgametip", tip);
timer.Once(5f, () => player?.SendConsoleCommand("gametip.hidegametip"));
}
}
object OnTrapTrigger(BaseTrap trap, GameObject obj)
{
if (trap is Landmine)
{
BasePlayer target = obj.GetComponent <BasePlayer>();
if (target)
{
if (target.userID == trap.OwnerID)
{
return(false);
}
else if (Convert.ToBoolean(Friends?.CallHook("AreFriends", target.userID, trap.OwnerID)))
{
return(false);
}
}
}
return(null);
}
private void ProcessConfiguration(BasePlayer player, string type)
{
var entityName = type.Contains("cupboard") ? "Tool Cupboard" : (type.Contains("lock") ? "Code Lock" : "Turret");
if (Configuration.SendToDiscord && Discord)
{
Discord.CallHook("Send Message", Lang("discordMessage")
.Replace("{player}", player.displayName)
.Replace("{steamID}", player.UserIDString)
.Replace("{type}", entityName)
.Replace("{coordinates}", FormattedCoordinates(player)));
}
if (Configuration.SendToSlack && Slack)
{
Slack.CallHook("Message", Lang("slackMessage")
.Replace("{player}", player.displayName)
.Replace("{steamID}", player.UserIDString)
.Replace("{type}", entityName)
.Replace("{coordinates}", FormattedCoordinates(player)));
}
if (Configuration.SendToStaff)
{
foreach (var target in BasePlayer.activePlayerList.Where(x => x.IsAdmin || HasPermission(x, "grouplimits.notify")))
{
PrintToChat(target, Lang("staffMessage")
.Replace("{player}", player.displayName)
.Replace("{steamID}", player.UserIDString)
.Replace("{type}", entityName)
.Replace("{coordinates}", FormattedCoordinates(player)));
}
}
if (!Configuration.WarnPlayers)
{
return;
}
PrintToChat(player, Lang("playerMessage").Replace("{limit}", Configuration.MaxPlayers.ToString()));
}
// ------------------
private object OnPlayerRespawned(BasePlayer player)
{
int id = MAData.PlayerData[player.userID].iInArea; bool success = false;
if (PlayerExists(player) && id != -1 && MagicAreaExists(id))
{
if (MAData.Areas[id].Spawns.Count == 0)
{
success = Convert.ToBoolean(MagicTeleportation.CallHook("InitTeleport", player, MAData.Areas[id].fMinX, MAData.Areas[id].fMinY, MAData.Areas[id].fMinZ, false, true, MAData.Areas[id].tTitle, null, 1, 3));
}
if (success)
{
string parsed_config = GetMessage("TeleportedBack", player.UserIDString);
parsed_config = parsed_config.Replace("{area_title}", MAData.Areas[id].tTitle);
PrintToChat(player, parsed_config);
}
MAData.PlayerData[player.userID].iInArea = -1;
return(false);
}
return(null);
}
object GiveKit(BasePlayer player, string kitname)
{
if (string.IsNullOrEmpty(kitname))
{
return("Empty kit name");
}
kitname = kitname.ToLower();
Kit kit;
if (!storedData.Kits.TryGetValue(kitname, out kit))
{
return("This kit doesn't exist");
}
foreach (KitItem kitem in kit.items)
{
if (kitem.weapon)
{
player.inventory.GiveItem(BuildWeapon(kitem.itemid, kitem.skinid, kitem.mods), kitem.container == "belt" ? player.inventory.containerBelt : kitem.container == "wear" ? player.inventory.containerWear : player.inventory.containerMain);
}
else
{
player.inventory.GiveItem(BuildItem(kitem.itemid, kitem.amount, kitem.skinid), kitem.container == "belt" ? player.inventory.containerBelt : kitem.container == "wear" ? player.inventory.containerWear : player.inventory.containerMain);
}
}
if (kit.building != null && kit.building != string.Empty)
{
var success = CopyPaste?.CallHook("TryPasteFromPlayer", player, kit.building, CopyPasteParameters.ToArray());
if (success is string)
{
return(success);
}
if (!(success is List <BaseEntity>))
{
return("Something went wrong while pasting, is CopyPaste installed?");
}
}
return(true);
}
private void OnEntityBuilt(Planner planner, GameObject gObject)
{
BasePlayer player = planner.GetOwnerPlayer();
BaseEntity entity = gObject.ToBaseEntity();
if (ZoneManager?.CallHook("GetPlayerZoneIDs", player) == null)
{
if (permission.UserHasPermission(player.UserIDString, perm2))
{
Send(player, lang.GetMessage("OnlyLand", this));
entity.Kill(BaseNetworkable.DestroyMode.Gib);
}
}
else
{
String[] lands = (string[])ZoneManager?.CallHook("GetPlayerZoneIDs", player);
if (lands == null)
{
Send(player, GetMessage("ErrorLand")); return;
}
foreach (LandData data in landCache)
{
if (data.zoneID == Convert.ToInt32(lands[0]))
{
if (player.userID != data.OwnerID)
{
Send(player, GetMessage("NoLand"));
entity.Kill(BaseNetworkable.DestroyMode.Gib);
}
}
}
}
Send(player, "Positon: " + entity.transform.position);
}
void OnLootEntity(BasePlayer player, BaseEntity entity)
{
if (bProtectionEnabled == true)
{
ProtectionInfo p = null;
var hasProtection = storedData.Players.TryGetValue(player.userID, out p);
if (!hasProtection)
{
return;
}
var corpse = entity as LootableCorpse;
var sleeper = entity as BasePlayer;
string minutes = Convert.ToInt32(TimeSpan.FromSeconds(p.TimeLeft).TotalMinutes).ToString();
string parsed_config = GetMessage("cantDo", player.UserIDString);
parsed_config = parsed_config.Replace("{minutes_left}", minutes.ToString());
//can loot corpses own and bots
if (corpse != null && corpse.playerSteamID != player.userID && corpse.playerSteamID > 76560000000000000L)
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
//can loot friend sleeper
else if (sleeper != null && canLootFriends && !(bool)(Friends?.CallHook("AreFriends", sleeper.userID, player.userID) ?? false))
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
//can loot self or bot dropped rust_backpack
else if (entity.PrefabName.Contains("item_drop"))
{
if ((entity as DroppedItemContainer).playerSteamID == 0)
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
else if ((entity as DroppedItemContainer).playerSteamID != player.userID && (entity as DroppedItemContainer).playerSteamID > 76560000000000000L && !(canLootFriends && (bool)(Friends?.CallHook("AreFriends", entity.OwnerID, player.userID) ?? false)))
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
}
//no loot heli or supply
else if (!canLootHeli && entity.PrefabName.Contains("heli_crate"))
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
else if (!canLootDrop && entity.PrefabName.Contains("supply_drop"))
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
//can loot friends deployables or own
else if (entity.PrefabName.Contains("deployable") && entity.OwnerID != 0 && entity.OwnerID != player.userID)
{
if (!(canLootFriendDeployables && (bool)(Friends?.CallHook("AreFriends", entity.OwnerID, player.userID) ?? false)))
{
SPUi(player, parsed_config);
timer.Once(0.01f, player.EndLooting);
}
}
}
}
static void RunBenchmark(Plugin plugin)
{
object ret;
var iterations = 100000;
var t = DateTime.Now;
for (var i = 0; i < iterations; i++)
{
plugin.DirectCallHook("OnMy", out ret, new[] { "test" });
plugin.DirectCallHook("OnMy2", out ret, new[] { "test2" });
plugin.DirectCallHook("OnMy3", out ret, new[] { "test3" });
plugin.DirectCallHook("OnMy4", out ret, new[] { "test4" });
plugin.DirectCallHook("OnMy5", out ret, new[] { "test5" });
plugin.DirectCallHook("OnMy6", out ret, new[] { "test6" });
plugin.DirectCallHook("OnMy7", out ret, new[] { "test7" });
plugin.DirectCallHook("OnMy8", out ret, new[] { "test8" });
plugin.DirectCallHook("OnMy9", out ret, new[] { "test9" });
plugin.DirectCallHook("OnYour", out ret, new[] { "test0" });
}
Puts($"Calling {10 * iterations} hooks directly took {DateTime.Now - t}");
t = DateTime.Now;
for (var i = 0; i < iterations; i++)
{
plugin.CallHook("OnMy", out ret, new[] { "test" });
plugin.CallHook("OnMy2", out ret, new[] { "test2" });
plugin.CallHook("OnMy3", out ret, new[] { "test3" });
plugin.CallHook("OnMy4", out ret, new[] { "test4" });
plugin.CallHook("OnMy5", out ret, new[] { "test5" });
plugin.CallHook("OnMy6", out ret, new[] { "test6" });
plugin.CallHook("OnMy7", out ret, new[] { "test7" });
plugin.CallHook("OnMy8", out ret, new[] { "test8" });
plugin.CallHook("OnMy9", out ret, new[] { "test9" });
plugin.CallHook("OnYour", out ret, new[] { "test0" });
}
Puts($"Calling {10 * iterations} hooks with Invoke took {DateTime.Now - t}");
}
void cmdPlaceBet(ConsoleSystem.Arg arg)
{
Dictionary <ulong, playerinfo> playerinfos = new Dictionary <ulong, playerinfo>();
GUIDestroy(arg.Player());
if (arg.Player() == null)
{
return;
}
playerinfo playerbet = new playerinfo();
if (!Currentbet.ContainsKey(arg.Player().userID))
{
Currentbet.Add(arg.Player().userID, new playerinfo());
}
else
{
Currentbet.TryGetValue(arg.Player().userID, out playerbet);
}
if (playerbet.currentbet == 0)
{
SendReply(arg.Player(), lang.GetMessage("NoBet", this, arg.Player().UserIDString));
return;
}
int random = UnityEngine.Random.Range(DefaultMinRange, DefaultMaxRange);
if (UseSR && ServerRewards.IsLoaded)
{
if (SRMinBet <= playerbet.currentbet * playerbet.multiplicator)
{
double reward = FindReward(arg.Player(), (int)playerbet.currentbet, random, playerbet.multiplicator);
if (playerbet.currentbet * playerbet.multiplicator >= MinBetjackpot)
{
if (random == SRJackpotNumber)
{
foreach (var resetbet in Currentbet)
{
resetbet.Value.totalbet = 0;
resetbet.Value.multiplicator = 1;
playerinfos.Add(resetbet.Key, resetbet.Value);
}
Currentbet.Clear();
Currentbet = playerinfos;
ServerRewards?.Call("AddPoints", new object[] { arg.Player().userID, reward });
SendReply(arg.Player(), string.Format(lang.GetMessage("Jackpot", this, arg.Player().UserIDString), random, reward));
return;
}
}
if (reward != 0 && random != SRJackpotNumber)
{
Currentbet.Remove(arg.Player().userID);
Currentbet.Add(arg.Player().userID, playerbet);
ServerRewards?.Call("AddPoints", new object[] { arg.Player().userID, reward });
SendReply(arg.Player(), string.Format(lang.GetMessage("WinPoints", this, arg.Player().UserIDString), random, reward));
}
else if (reward == 0)
{
SendReply(arg.Player(), string.Format(lang.GetMessage("NoWin", this, arg.Player().UserIDString), random));
}
else
{
ServerRewards?.Call("AddPoints", new object[] { arg.Player().userID, reward });
SendReply(arg.Player(), string.Format(lang.GetMessage("WinPoints", this, arg.Player().UserIDString), random, reward));
}
playerbet.totalbet += playerbet.currentbet * (10 / 100.0);
Economy?.CallHook("Withdraw", arg.Player().userID, playerbet.currentbet * playerbet.multiplicator);
playerbet.currentbet = 0;
playerbet.multiplicator = 1;
}
else
{
SendReply(arg.Player(), string.Format(lang.GetMessage("MiniSRBet", this, arg.Player().UserIDString), SRMinBet));
}
}
else
{
double reward = FindReward(arg.Player(), (int)playerbet.currentbet, random, playerbet.multiplicator);
if (random == JackpotNumber)
{
foreach (var resetbet in Currentbet)
{
resetbet.Value.totalbet = 0;
resetbet.Value.multiplicator = 1;
playerinfos.Add(resetbet.Key, resetbet.Value);
}
Currentbet.Clear();
Currentbet = playerinfos;
Economy?.CallHook("Deposit", arg.Player().userID, reward);
SendReply(arg.Player(), string.Format(lang.GetMessage("Jackpot", this, arg.Player().UserIDString), random, reward));
}
else if (reward != 0 && random != JackpotNumber)
{
Currentbet.Remove(arg.Player().userID);
Currentbet.Add(arg.Player().userID, playerbet);
Economy?.CallHook("Deposit", arg.Player().userID, reward);
SendReply(arg.Player(), string.Format(lang.GetMessage("Win", this, arg.Player().UserIDString), random, reward));
}
else if (reward == 0)
{
SendReply(arg.Player(), string.Format(lang.GetMessage("NoWin", this, arg.Player().UserIDString), random));
}
else
{
Economy?.CallHook("Deposit", arg.Player().userID, reward);
SendReply(arg.Player(), string.Format(lang.GetMessage("Win", this, arg.Player().UserIDString), random, reward));
}
playerbet.totalbet += playerbet.currentbet * (10 / 100.0);
Economy?.CallHook("Withdraw", arg.Player().userID, playerbet.currentbet * playerbet.multiplicator);
playerbet.currentbet = 0;
playerbet.multiplicator = 1;
}
SaveData(Currentbet);
}
