C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
// Requires: ImageLibrary
using System.Collections.Generic;
using System;
using System.Linq;
using UnityEngine;
using Oxide.Core;
using Oxide.Core.Configuration;
using Oxide.Core.Plugins;
using Oxide.Core.Libraries.Covalence;
using Oxide.Game.Rust.Cui;
using Oxide.Plugins;
using Rust;
using Newtonsoft.Json;
namespace Oxide.Plugins
{
[Info("Raid Limit", "noname", "2.2.3")]
[Description("Limits the number of raids per day on buildings")]
class RaidLimit : CovalencePlugin
{
[PluginReference]
Plugin ImageLibrary, PlaytimeTracker;
private static RaidLimit Instance;
private int MaskInt = LayerMask.GetMask("Construction", "Prevent Building", "Deployed");
private const string raidlimit_admin_Perm = "raidlimit.admin";
private const string raidlimit_bypass_Perm = "raidlimit.bypass";
private List<ulong> PlayerSpamMessageBlockFlags;
#region Hooks
private new void LoadDefaultConfig()
{
PrintWarning("Creating a new configuration file");
Config.WriteObject(GetDefaultConfig(), true);
}
private void Init()
{
Instance = this;
RegisterPermissions();
LoadConfig();
LoadPlayersData();
ChargeDataCheck();
}
private void OnServerSave()
{
SavePlayersData();
}
private void Unload()
{
PlayersDestroyRaidLimitUI();
SavePlayersData();
Instance = null;
}
private void Loaded()
{
RegisterUICommand();
}
private void OnServerInitialized()
{
PlayerSpamMessageBlockFlags = new List<ulong>();
playersDateTimeData = new PlayersDateTimeData();
PlayersAddToData();
PlayersUpdateNameData();
LoadImage();
PlayersUpdateRaidLimitUI(true);
StartTimer();
}
private void OnPlayerConnected(BasePlayer player)
{
if (player.IsNpc) return;
PlayerAddToData(player);
PlayerUpdateNameData(player);
timer.Once(4f, () =>
{
PlayerAddToData(player);
PlayerUpdateNameData(player);
PlayerUpdateRaidLimitUI(player, true);
});
}
private void OnUserGroupAdded(string id, string groupName)
{
if (!permission.GroupHasPermission(groupName, raidlimit_bypass_Perm))
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (player.UserIDString == id)
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnUserGroupRemoved(string id, string groupName)
{
if (!permission.GroupHasPermission(groupName, raidlimit_bypass_Perm))
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (player.UserIDString == id)
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnUserPermissionGranted(string id, string permName)
{
if (permName != raidlimit_bypass_Perm)
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (player.UserIDString == id)
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnUserPermissionRevoked(string id, string permName)
{
if (permName != raidlimit_bypass_Perm)
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (player.UserIDString == id)
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnGroupPermissionGranted(string name, string perm)
{
if (perm != raidlimit_bypass_Perm)
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (permission.UserHasGroup(player.UserIDString, name))
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnGroupPermissionRevoked(string name, string perm)
{
if (perm != raidlimit_bypass_Perm)
return;
foreach (BasePlayer player in BasePlayer.activePlayerList)
{
if (permission.UserHasGroup(player.UserIDString, name))
PlayerUpdateRaidLimitUI(player, false);
}
}
private void OnGroupDeleted(string name)
{
PlayersUpdateRaidLimitUI(false);
}
#endregion
#region PluginIO
#region ConfigManage
private PluginConfig config;
private void LoadConfig()
{
config = Config.ReadObject<PluginConfig>();
if (config == null)
config = GetDefaultConfig();
else
CheckMissingVariable();
}
private class PluginConfig
{
[JsonProperty("1.RaidLimitOperationType")]
public RaidLimitOperationType RaidLimitOperationType;
[JsonProperty("2.RaidLimitSettings")]
public RaidLimitSettings RaidLimitSettings;
[JsonProperty("3.UISettings")]
public UISettings UISettings;
[JsonProperty("4.TeamSyncSettings")]
public TeamSyncSettings TeamSyncSettings;
}
private class RaidLimitOperationType
{
[JsonProperty("1.1.OperationType")]
public int OperationType;
[JsonProperty("1.2.ObjectOwnerIdentification")]
public ObjectOwnerIdentification ObjectOwnerIdentification;
[JsonProperty("1.3.ToolCupboardIdentification")]
public ToolCupboardIdentification ToolCupboardIdentification;
}
private class ObjectOwnerIdentification
{
[JsonProperty("1.2.1.ObjectSearchDepth")]
public int ObjectSearchDepth;
[JsonProperty("1.2.2.ObjectSearchRange")]
public int ObjectSearchRange;
}
private class ToolCupboardIdentification
{
[JsonProperty("1.3.1.ObjectSearchDepth")]
public int ObjectSearchDepth;
[JsonProperty("1.3.2.ObjectSearchRange")]
public int ObjectSearchRange;
[JsonProperty("1.3.3.CheckToolCupboardInstanceID")]
public bool CheckToolCupboardInstanceID;
[JsonProperty("1.3.4.CheckAuthorizedPeoples")]
public bool CheckAuthorizedPeoples;
}
private class RaidLimitSettings
{
[JsonProperty("2.1.OneTimeMaximumRaidableHomeCount")]
public int? OneTimeMaximumRaidableHomeCount;
[JsonProperty("2.2.NoobCantRaidSecond")]
public int? NoobCantRaidSecond;
[JsonProperty("2.3.InitializeCounterOnMidnightTime")]
public bool? InitializeCounterOnMidnightTime;
[JsonProperty("2.4.MidnightTimeDetectionTimerInterval")]
public int? MidnightTimeDetectionTimerInterval;
[JsonProperty("2.5.CounterChargeDelay")]
public int? CounterChargeDelay;
[JsonProperty("2.6.CounterChargeDelayType")]
public int? CounterChargeDelayType;
[JsonProperty("2.7.CounterChargeType")]
public int? CounterChargeType;
}
private class UISettings
{
[JsonProperty("3.1.UIEnable")]
public bool UIEnable;
[JsonProperty("3.2.UIUpdateInterval")]
public int UIUpdateInterval;
[JsonProperty("3.3.UIPosition")]
public UIPosition UIPosition;
}
private class UIPosition
{
[JsonProperty("3.3.1.AnchorMin")]
public string AnchorMin;
[JsonProperty("3.3.2.AnchorMax")]
public string AnchorMax;
}
private class TeamSyncSettings
{
[JsonProperty("4.1.TeamCounterSync")]
public bool TeamCounterSync;
[JsonProperty("4.2.PreventTempDisband")]
public bool PreventTempDisband;
[JsonProperty("4.3.OldTeamSaveInterval")]
public int OldTeamSaveInterval;
}
private PluginConfig GetDefaultConfig()
{
return new PluginConfig
{
RaidLimitOperationType = new RaidLimitOperationType()
{
OperationType = 0,
ObjectOwnerIdentification = new ObjectOwnerIdentification()
{
ObjectSearchDepth = -1,
ObjectSearchRange = 5
},
ToolCupboardIdentification = new ToolCupboardIdentification()
{
ObjectSearchDepth = -1,
ObjectSearchRange = 5,
CheckToolCupboardInstanceID = true,
CheckAuthorizedPeoples = true
}
},
RaidLimitSettings = new RaidLimitSettings()
{
OneTimeMaximumRaidableHomeCount = 2,
NoobCantRaidSecond = 10800,//3h
InitializeCounterOnMidnightTime = true,
CounterChargeDelay = 43200,//12h -1 == disable
CounterChargeDelayType = 0,//0 == realtime, 1 == playtime
CounterChargeType = 0//0 == Charge when used up, 1 == Charge if there is not enough
},
UISettings = new UISettings()
{
UIEnable = true,
UIUpdateInterval = 3,
UIPosition = new UIPosition()
{
AnchorMin = "0.28 0.025",
AnchorMax = "0.3392 0.06"
}
},
TeamSyncSettings = new TeamSyncSettings()
{
TeamCounterSync = true,
PreventTempDisband = true,
OldTeamSaveInterval = 600
}
};
}
private void CheckMissingVariable()
{
bool Missed = false;
if (config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount == null)
{
config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount = 2;
Missed = true;
}
if (config.RaidLimitSettings.NoobCantRaidSecond == null)
{
config.RaidLimitSettings.NoobCantRaidSecond = 10800;
Missed = true;
}
if (config.RaidLimitSettings.InitializeCounterOnMidnightTime == null)
{
config.RaidLimitSettings.InitializeCounterOnMidnightTime = true;
Missed = true;
}
if (config.RaidLimitSettings.MidnightTimeDetectionTimerInterval == null)
{
config.RaidLimitSettings.MidnightTimeDetectionTimerInterval = 10;
Missed = true;
}
if (config.RaidLimitSettings.CounterChargeDelay == null)
{
config.RaidLimitSettings.CounterChargeDelay = 43200;
Missed = true;
}
if (config.RaidLimitSettings.CounterChargeDelayType == null)
{
config.RaidLimitSettings.CounterChargeDelayType = 0;
Missed = true;
}
if (config.RaidLimitSettings.CounterChargeType == null)
{
config.RaidLimitSettings.CounterChargeType = 0;
Missed = true;
}
if (Missed)
Config.WriteObject(config, true);
}
#endregion
#region DataManage
DynamicConfigFile playersdataFile;
PlayersData playersData;
DynamicConfigFile playersuidataFile;
PlayersUIData playersUIData;
DynamicConfigFile playersteamdataFile;
PlayersTeamData playersTeamData;
private void LoadPlayersData()
{
playersdataFile = Interface.Oxide.DataFileSystem.GetDatafile("RaidLimitPlayerData");
playersData = playersdataFile.ReadObject<PlayersData>();
if (playersData == null)
playersData = new PlayersData();
playersuidataFile = Interface.Oxide.DataFileSystem.GetDatafile("RaidLimitPlayerUIData");
playersUIData = playersuidataFile.ReadObject<PlayersUIData>();
if (playersUIData == null)
playersUIData = new PlayersUIData();
playersteamdataFile = Interface.Oxide.DataFileSystem.GetDatafile("RaidLimitPlayerTeamData");
playersTeamData = playersuidataFile.ReadObject<PlayersTeamData>();
if (playersTeamData == null)
playersTeamData = new PlayersTeamData();
}
private void ChargeDataCheck()
{
foreach (var item in playersData.Players)
{
PlayerInfo playerinfo = item.Value;
if (config.RaidLimitSettings.CounterChargeDelay != -1)
{
switch (config.RaidLimitSettings.CounterChargeType)
{
case 0:
if (playerinfo.RaidLeftCount == 0 && playerinfo.Charging == false)
playerinfo.AddChargeSchedule();
break;
case 1:
if (playerinfo.RaidLeftCount < config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount && playerinfo.Charging == false)
playerinfo.AddChargeSchedule();
break;
default:
goto case 0;
}
}
}
}
private void SavePlayersData()
{
Puts("Saving RaidLimit PlayersDataFile...");
playersdataFile.WriteObject<PlayersData>(playersData);
playersuidataFile.WriteObject<PlayersUIData>(playersUIData);
playersteamdataFile.WriteObject<PlayersTeamData>(playersTeamData);
}
private class PlayersTeamData
{
public Dictionary<ulong, PlayerTeam> TeamsData1;
public Dictionary<ulong, PlayerTeam> TeamsData2;
public int OldDataIndicator;
public PlayersTeamData()
{
TeamsData1 = new Dictionary<ulong, PlayerTeam>();
TeamsData2 = new Dictionary<ulong, PlayerTeam>();
OldDataIndicator = 2;
}
public void UpdateData()
{
Dictionary<ulong, PlayerTeam> OldTeamsData;
if (OldDataIndicator == 1)
OldTeamsData = TeamsData2;
else
OldTeamsData = TeamsData1;
OldTeamsData.Clear();
foreach (var item in RelationshipManager.ServerInstance.teams)
{
OldTeamsData.Add(item.Key, new PlayerTeam(item.Value.members));
}
if (OldDataIndicator == 1)
OldDataIndicator = 2;
else
OldDataIndicator = 1;
}
}
private class PlayerTeam
{
public List<ulong> Members { get; set; }
public PlayerTeam()
{
Members = new List<ulong>();
}
public PlayerTeam(List<ulong> members)
{
Members = new List<ulong>(members);
}
}
private class PlayersUIData
{
public Dictionary<string, bool> PlayersUIToggle;
public PlayersUIData()
{
PlayersUIToggle = new Dictionary<string, bool>();
}
public void AddPlayer(BasePlayer player)
{
if (!PlayersUIToggle.ContainsKey(player.UserIDString) && player != null)
{
PlayersUIToggle.Add(player.UserIDString, true);
}
}
}
private class PlayersData
{
public DateTime excutteddate;
public Dictionary<string, PlayerInfo> Players;
public PlayersData()
{
excutteddate = DateTime.MinValue;
Players = new Dictionary<string, PlayerInfo>();
}
public void AddPlayer(string playerId)
{
if (!Players.ContainsKey(playerId) && playerId != null)
{
Players.Add(playerId, new PlayerInfo(playerId));
}
}
public void AddPlayer(BasePlayer player)
{
if (!Players.ContainsKey(player.UserIDString) && player != null)
{
Players.Add(player.UserIDString, new PlayerInfo(player.IPlayer));
}
}
public void PlayerAddTime(string PlayerID, TimeSpan time)
{
if (Players.ContainsKey(PlayerID))
{
Players[PlayerID].Playtime = Players[PlayerID].Playtime.Add(time);
}
}
}
private class PlayerInfo
{
public string Id;
public string Name;
public int RaidLeftCount;
public List<RaidCountItem> RaidCountItems;
public bool Charging;
public TimeSpan NextChargePlaytime;
public DateTime NextChargeRealtime;
public TimeSpan Playtime;
public bool NoobCanRaidPlaytimeTracker;
public bool NoobCanRaid;
public PlayerInfo()
{
//for json deserialize
}
public PlayerInfo(string playerId)
{
Id = playerId;
Name = null;
RaidLeftCount = 0;
RaidCountItems = new List<RaidCountItem>();
Charging = false;
NextChargePlaytime = new TimeSpan(0, 0, 0);
NextChargeRealtime = DateTime.MinValue;
Playtime = new TimeSpan(0, 0, 0);
NoobCanRaidPlaytimeTracker = false;
NoobCanRaid = false;
}
public PlayerInfo(IPlayer player)
{
Id = player.Id;
Name = player.Name;
RaidLeftCount = 0;
RaidCountItems = new List<RaidCountItem>();
Charging = false;
NextChargePlaytime = new TimeSpan(0, 0, 0);
NextChargeRealtime = DateTime.MinValue;
Playtime = new TimeSpan(0, 0, 0);
NoobCanRaidPlaytimeTracker = false;
NoobCanRaid = false;
}
public bool AddRaidTarget(RaidCountItem raidCountItem)
{
if (RaidLeftCount <= 0)
return false;
RaidLeftCount--;
RaidCountItems.Add(raidCountItem);
return true;
}
public void AddChargeSchedule()
{
TimeSpan CounterChargeDelay = TimeSpan.FromSeconds(Instance.config.RaidLimitSettings.CounterChargeDelay.Value);
NextChargePlaytime = Instance.GetPlayerPlaytime(Id) + CounterChargeDelay;
NextChargeRealtime = DateTime.Now + CounterChargeDelay;
Charging = true;
}
public void StopCharging()
{
Charging = false;
}
public void ChargeRaidCount(bool chargeAll)
{
if (Instance.config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount <= RaidLeftCount)
return;
if (chargeAll)
RaidLeftCount = Instance.config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount.Value;
else
RaidLeftCount++;
if (Instance.config.RaidLimitSettings.InitializeCounterOnMidnightTime == false)
{
if (chargeAll)
RaidCountItems.Clear();
else
RaidCountItems.RemoveAt(RaidCountItems.Count - 1);
}
}
public int AddRaidCount(int amount)
{
int CountSave = RaidLeftCount;
RaidLeftCount += amount;
if (RaidLeftCount < 0)
RaidLeftCount = 0;
else if (Instance.config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount < RaidLeftCount)
RaidLeftCount = Instance.config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount.Value;
for (int i = 0; i < amount; i++)
{
if (RaidCountItems.Count <= 0)
break;
RaidCountItems.RemoveAt(RaidCountItems.Count - 1);
}
return RaidLeftCount - CountSave;
}
public void ResetRaidDataNCount()
{
RaidLeftCount = Instance.config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount.Value;
RaidCountItems.Clear();
}
}
private class RaidCountItem
{
public List<ulong> RaidTargets;
public List<int> TCInstanceIDs;
public RaidCountItem()
{
//for json deserialize
}
public RaidCountItem(List<ulong> raidTargets, List<int> tcInstanceIDs)
{
RaidTargets = raidTargets;
TCInstanceIDs = tcInstanceIDs;
}
public void AddRaidTargetsRange(List<ulong> raidTargets)
{
foreach (var item in raidTargets)
{
if (RaidTargets.Contains(item) == false)
RaidTargets.Add(item);
}
}
public void AddTCInstanceIDsRange(List<int> tcInstanceIDs)
{
foreach (var item in tcInstanceIDs)
{
if (TCInstanceIDs.Contains(item) == false)
TCInstanceIDs.Add(item);
}
}
}
#endregion
#region PermissionManage
private void RegisterPermissions()
{
permission.RegisterPermission(raidlimit_admin_Perm, this);
permission.RegisterPermission(raidlimit_bypass_Perm, this);
}
#endregion
#region LangManage
protected override void LoadDefaultMessages()
{
lang.RegisterMessages(new Dictionary<string, string>
{
["No Permission"] = "You do not have permission to use the '{0}' command.",
["Date Changed"] = "The day has changed.The raid limit has been initialized.",
["You Can Raid"] = "You have enough play time to raid.",
["Add RaidList"] = "The owner of this building has been added to the raid list.you can raid {0} more time.",
["Add RaidList TC"] = "The building has been added to the raid list.you can raid {0} more time.",
["Team Member Raiding"] = "Team member \"{0}\" is raiding.Raid limit counter reduced.The owner of the house where the team is raiding has been added to the raid list.",
["Left Raid Count"] = "You can raid {0} more time.",
["Raid Blocked"] = "You can't raid any more today.",
["Raid Blocked NoRefill"] = "You can't raid any more.",
["Raid Blocked RNextTime"] = "You can't raid right now.After {0} seconds in realtime, Raid count will be recharged.",
["Raid Blocked PNextTime"] = "You can't raid right now.After {0} seconds in playtime, Raid count will be recharged.",
["Raid Blocked Time"] = "You have to play the game for more than {0}seconds before you can raid it.Your play time is {1}seconds.",
["Raid Reset Specific Slayer"] = "Your raid limit has been refilled.",
["Raid List Reset"] = "The raid limit has been initialized.",
["bypass GUI Msg"] = "<color=#FFE400>bypass</color>",
["SteamID Not Found"] = "Could not find this SteamID: {0}.",
["Player Not Found"] = "Could not find this player: {0}.",
["Multiple Players Found"] = "Found multiple players!\n\n{0}",
["NotEnoughArgument"] = "to run this command you need {0} arguments.",
["Invalid Parameter"] = "'{0}' is an invalid parameter.",
["Count IncreasedC"] = "{0}'s raidlimit has increased by '{1}'.",
["Count DecreasedC"] = "{0}'s raidlimit has decreased by '{1}'.",
["Count IncreasedP"] = "raidlimit has increased by '{0}'.",
["Count DecreasedP"] = "raidlimit has decreased by '{0}'."
}, this);
lang.RegisterMessages(new Dictionary<string, string>
{
["No Permission"] = "'{0}' 명령어를 사용하실 권한이 없습니다.",
["Date Changed"] = "날이 바뀌었습니다.레이드 제한이 초기화 되었습니다.",
["You Can Raid"] = "플레이타임이 충분하므로 이제 레이드가 가능합니다.",
["Add RaidList"] = "이 건축물의 주인이 레이드 가능 목록에 추가되었습니다.앞으로 {0}번 더 레이드 할 수 있습니다.",
["Add RaidList TC"] = "이 건묵물이 레이드 가능 목록에 추가되었습니다.앞으로 {0}번 더 레이드 할 수 있습니다.",
["Team Member Raiding"] = "팀원 \"{0}\" 님이 레이드 중입니다.레이드 제한이 감소하였습니다.레이드 당하고 있는 건축물의 주인이 레이드 가능 목록에 추가되었습니다.",
["Left Raid Count"] = "{0}번 더 레이드 하실 수 있습니다.",
["Raid Blocked"] = "오늘은 더이상 레이드를 할 수 없습니다.",
["Raid Blocked NoRefill"] = "더이상 레이드를 할 수 없습니다.",
["Raid Blocked RNextTime"] = "더이상 레이드를 할 수 없습니다.리얼타임을 기준으로 {0}초후에 레이드 제한 횟수가 다시 충전됩니다.",
["Raid Blocked PNextTime"] = "더이상 레이드를 할 수 없습니다.플레이타임을 기준으로 {0}초후에 레이드 제한 횟수가 다시 충전됩니다.",
["Raid Blocked Time"] = "레이드를 하기위해선 플레이타임이 {0}초 이상이여야합니다.현재 누적 플레이타임은 {1}초입니다.",
["Raid Reset Specific Slayer"] = "레이드 제한횟수가 재충전 되었습니다.",
["Raid List Reset"] = "레이드 제한횟수가 재충전 되었습니다.",
["bypass GUI Msg"] = "<color=#FFE400>무한</color>",
["SteamID Not Found"] = "{0} 와 일치하는 스팀 아이디를 가진 플레이어가 없습니다.",
["Player Not Found"] = "{0} 와 일치하는 이름을 가진 플레이어가 없습니다.",
["Multiple Players Found"] = "여러명의 플레이어를 검색했습니다!\n\n{0}",
["NotEnoughArgument"] = "이명령어를 실행하기 위해서는 {0} 개의 값이 필요합니다.",
["Invalid Parameter"] = "'{0}'는 유효하지 않은 파라미터 입니다.",
["Count IncreasedC"] = "{0}님의 레이드제한이 '{1}'만큼 증가하였습니다.",
["Count DecreasedC"] = "{0}님의 레이드제한이 '{1}'만큼 감소하였습니다.",
["Count IncreasedP"] = "레이드제한이 '{0}'만큼 증가하였습니다.",
["Count DecreasedP"] = "레이드제한이 '{0}'만큼 감소하였습니다."
}, this, "ko");
}
private string Lang(string key, string id = null, params object[] args)
{
return string.Format(lang.GetMessage(key, this, id), args);
}
#endregion
#endregion
#region TimerManager
private void StartTimer()
{
if (config.TeamSyncSettings.PreventTempDisband == true)
timer.Every(config.TeamSyncSettings.OldTeamSaveInterval, PreventTempDisband_Timer_Tick);
if (config.RaidLimitSettings.InitializeCounterOnMidnightTime == true)
timer.Every(config.RaidLimitSettings.MidnightTimeDetectionTimerInterval.Value, CheckDayChanged_Timer_Tick);
timer.Every(config.UISettings.UIUpdateInterval, UIUpdate_Timer_Tick);
}
private void PreventTempDisband_Timer_Tick()
{
playersTeamData.UpdateData();
}
private void CheckDayChanged_Timer_Tick()
{
if (playersData.excutteddate.DayOfYear < DateTime.Now.DayOfYear || playersData.excutteddate.Year < DateTime.Now.Year)
{
Puts(Lang("Date Changed", null));
foreach (IPlayer current in players.Connected)
current.Message(Lang("Date Changed", current.Id));
foreach (var item in playersData.Players)
{
item.Value.ResetRaidDataNCount();
item.Value.StopCharging();
}
SavePlayersData();
PlayersUpdateRaidLimitUI(false);
playersData.excutteddate = DateTime.Now;
}
}
private void UIUpdate_Timer_Tick()//done
{
foreach (BasePlayer basePlayer in BasePlayer.activePlayerList)
{
PlayerInfo playerInfo = playersData.Players[basePlayer.UserIDString];
TimeSpan playtime = GetPlayerPlaytime(basePlayer);
if (GetCanRaid(playerInfo) == false)
{
if (playtime.TotalSeconds > config.RaidLimitSettings.NoobCantRaidSecond)
{
if (PlaytimeTracker != null)
playerInfo.NoobCanRaidPlaytimeTracker = true;
else
playerInfo.NoobCanRaid = true;
playerInfo.ChargeRaidCount(true);
if (!permission.UserHasPermission(basePlayer.UserIDString, raidlimit_bypass_Perm))
basePlayer.ChatMessage(Lang("You Can Raid", basePlayer.UserIDString));
UpdatePlayerCountUI(basePlayer, false);
}
}
if (GetCanRaid(playerInfo) == false)
{
UpdatePlayerNoobTimeUI(basePlayer, playtime, false);
}
else
{
if (playerInfo.Charging && config.RaidLimitSettings.CounterChargeDelay != -1)
{
switch (config.RaidLimitSettings.CounterChargeDelayType)
{
case 0://realtume
switch (config.RaidLimitSettings.CounterChargeType)
{
case 0://Charge when used up
if (playerInfo.RaidLeftCount != 0)
break;
if (DateTime.Now >= playerInfo.NextChargeRealtime)
{
playerInfo.ChargeRaidCount(true);
basePlayer.ChatMessage(Lang("Raid Reset Specific Slayer", basePlayer.UserIDString));
playerInfo.StopCharging();
PlayerUpdateRaidLimitUI(basePlayer, false);
}
break;
case 1://Charge if there is not enough
if (DateTime.Now >= playerInfo.NextChargeRealtime)
{
playerInfo.ChargeRaidCount(false);
basePlayer.ChatMessage(Lang("Raid Reset Specific Slayer", basePlayer.UserIDString));
if (config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount <= playerInfo.RaidLeftCount)
playerInfo.StopCharging();
else
playerInfo.AddChargeSchedule();
PlayerUpdateRaidLimitUI(basePlayer, false);
}
break;
default:
goto case 0;
}
break;
case 1://playtime
switch (config.RaidLimitSettings.CounterChargeType)
{
case 0://Charge when used up
if (playerInfo.RaidLeftCount != 0)
break;
if (playtime >= playerInfo.NextChargePlaytime)
{
playerInfo.ChargeRaidCount(true);
basePlayer.ChatMessage(Lang("Raid Reset Specific Slayer", basePlayer.UserIDString));
playerInfo.StopCharging();
PlayerUpdateRaidLimitUI(basePlayer, false);
}
break;
case 1://Charge if there is not enough
if (playtime >= playerInfo.NextChargePlaytime)
{
playerInfo.ChargeRaidCount(false);
basePlayer.ChatMessage(Lang("Raid Reset Specific Slayer", basePlayer.UserIDString));
if (config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount <= playerInfo.RaidLeftCount)
playerInfo.StopCharging();
else
playerInfo.AddChargeSchedule();
PlayerUpdateRaidLimitUI(basePlayer, false);
}
break;
default:
goto case 0;
}
break;
default:
goto case 0;
}
if (playerInfo.RaidLeftCount == 0)
{
switch (config.RaidLimitSettings.CounterChargeDelayType)
{
case 0:
UpdatePlayerTimeUI(basePlayer, playerInfo.NextChargeRealtime - DateTime.Now, false);
break;
case 1:
UpdatePlayerTimeUI(basePlayer, playerInfo.NextChargePlaytime - playtime, false);
break;
default:
goto case 0;
}
}
}
}
}
if (PlaytimeTracker == null)
{
TimeSpan timerticktimeSpan = DateTime.Now - playersDateTimeData.SaveTickTime;
foreach (BasePlayer basePlayer in BasePlayer.activePlayerList)
{
if (playersDateTimeData.BasePlayerList.Contains(basePlayer))
{
PlayerInfo playerInfo = playersData.Players[basePlayer.UserIDString];
if (playerInfo.Playtime.TotalSeconds < config.RaidLimitSettings.NoobCantRaidSecond)
playersData.PlayerAddTime(basePlayer.UserIDString, timerticktimeSpan);
else
{
if (playerInfo.NoobCanRaid == false)
{
playerInfo.NoobCanRaid = true;
}
}
}
}
playersDateTimeData.SaveTickTime = DateTime.Now;
playersDateTimeData.BasePlayerList = BasePlayer.activePlayerList;
}
else
{
playersDateTimeData.SaveTickTime = DateTime.Now;
}
}
#endregion
#region InterCommand
private void OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
{
if (entity == null || entity.gameObject == null || info == null)
return;
if (((1 << entity.gameObject.layer) & MaskInt) != 0)
{
BasePlayer player = info.Initiator as BasePlayer;// ?? entity.lastAttacker;
if (player == null ||
player.IsNpc ||
!entity.OwnerID.IsSteamId()||
player.UserIDString == entity.OwnerID.ToString() ||
info.damageTypes.Get(DamageType.Explosion) == 0 ||
permission.UserHasPermission(player.UserIDString, raidlimit_bypass_Perm))
return;
PlayerInfo playerinfo = playersData.Players[player.UserIDString];
if (GetCanRaid(playerinfo) == false)
{
TimeSpan playtime = GetPlayerPlaytime(player);
TryChatMessage(player, Lang("Raid Blocked Time", player.UserIDString, config.RaidLimitSettings.NoobCantRaidSecond, playtime.TotalSeconds));
info.damageTypes.Scale(DamageType.Explosion, 0);
return;
}
/////////////////////////////////////////////////////////////////////
if (config.RaidLimitOperationType.OperationType != 1)
{
if (CheckRaidCountItemContainsNAdd(playerinfo.RaidCountItems, new RaidCountItem(new List<ulong>() { entity.OwnerID }, new List<int>())) == true)
return;
if (permission.UserHasPermission(entity.OwnerID.ToString(), "antinoobraid.noob"))
{
info.damageTypes.Scale(DamageType.Explosion, 0);
return;
}
}
string addraidlistmsg = (config.RaidLimitOperationType.OperationType == 1 &&
config.RaidLimitOperationType.ToolCupboardIdentification.CheckToolCupboardInstanceID == true &&
config.RaidLimitOperationType.ToolCupboardIdentification.CheckAuthorizedPeoples == false) ? "Add RaidList TC" : "Add RaidList";
if (0 < playerinfo.RaidLeftCount)
{
RaidCountItem RaidCountItem = FindLinkedStructuresRaidCountItem(entity);
if (RaidCountItem == null)
{
info.damageTypes.Scale(DamageType.Explosion, 0);
return;
}
if (RaidCountItem.RaidTargets.Count == 0 && RaidCountItem.TCInstanceIDs.Count == 0)
return;
if (config.RaidLimitOperationType.OperationType == 1)
{
if (RaidCountItem.RaidTargets.Contains(player.userID))
return;
}
if (CheckRaidCountItemContainsNAdd(playerinfo.RaidCountItems, RaidCountItem) == true)
return;
playerinfo.AddRaidTarget(RaidCountItem);
if (config.RaidLimitSettings.CounterChargeDelay != -1)
{
switch (config.RaidLimitSettings.CounterChargeType)
{
case 0:
if (playerinfo.RaidLeftCount == 0)
playerinfo.AddChargeSchedule();
break;
case 1:
if (playerinfo.RaidLeftCount < config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount)
playerinfo.AddChargeSchedule();
break;
default:
goto case 0;
}
}
if (playerinfo.Charging && playerinfo.RaidLeftCount == 0)
{
switch (config.RaidLimitSettings.CounterChargeDelayType)
{
case 0:
UpdatePlayerTimeUI(player, playerinfo.NextChargeRealtime - DateTime.Now, false);
break;
case 1:
TimeSpan playerplaytime = GetPlayerPlaytime(player);
UpdatePlayerTimeUI(player, playerinfo.NextChargePlaytime - playerplaytime, false);
break;
default:
goto case 0;
}
}
else
UpdatePlayerCountUI(player, false);
player.ChatMessage(Lang(addraidlistmsg, player.UserIDString, playerinfo.RaidLeftCount));
if (config.TeamSyncSettings.TeamCounterSync == true && player.currentTeam != 0)
{
List<ulong> Team;
if (config.TeamSyncSettings.PreventTempDisband == true)
{
Team = new List<ulong>(RelationshipManager.ServerInstance.FindTeam(player.currentTeam).members);
Dictionary<ulong, PlayerTeam> oldTeamData;
if (playersTeamData.OldDataIndicator == 1)
oldTeamData = playersTeamData.TeamsData1;
else
oldTeamData = playersTeamData.TeamsData2;
if (oldTeamData.ContainsKey(player.currentTeam))
{
Team.AddRange(oldTeamData[player.currentTeam].Members);
Team = Team.Distinct().ToList();
}
}
else
Team = RelationshipManager.ServerInstance.FindTeam(player.currentTeam).members;
foreach (var member in Team)
{
if (member != player.userID)
{
if (playersData.Players.ContainsKey(member.ToString()) == false)
playersData.AddPlayer(member.ToString());
PlayerInfo playerInfo = playersData.Players[member.ToString()];
if (0 < playerInfo.RaidLeftCount && CheckRaidCountItemContainsNAdd(playerInfo.RaidCountItems, RaidCountItem) == false)
{
BasePlayer memberBplayer = TryGetPlayer(member);
playerInfo.AddRaidTarget(RaidCountItem);
if (config.RaidLimitSettings.CounterChargeDelay != -1)
{
switch (config.RaidLimitSettings.CounterChargeType)
{
case 0:
if (playerInfo.RaidLeftCount == 0)
playerInfo.AddChargeSchedule();
break;
case 1:
if (playerInfo.RaidLeftCount < config.RaidLimitSettings.OneTimeMaximumRaidableHomeCount)
playerInfo.AddChargeSchedule();
break;
default:
goto case 0;
}
}
if (playerInfo.Charging && playerInfo.RaidLeftCount == 0)
{
switch (config.RaidLimitSettings.CounterChargeDelayType)
{
case 0:
UpdatePlayerTimeUI(memberBplayer, playerInfo.NextChargeRealtime - DateTime.Now, false);
break;
case 1:
if (memberBplayer == null)
break;
TimeSpan playerplaytime = GetPlayerPlaytime(memberBplayer);
UpdatePlayerTimeUI(memberBplayer, playerInfo.NextChargePlaytime - playerplaytime, false);
break;
default:
goto case 0;
}
}
else
UpdatePlayerCountUI(player, false);
UpdatePlayerCountUI(memberBplayer, false);
memberBplayer?.ChatMessage(Lang("Team Member Raiding", member.ToString(), player.displayName));
}
}
}
}
}
else
{
if (playerinfo.Charging)
{
int leftseconds;
switch (config.RaidLimitSettings.CounterChargeDelayType)
{
case 0:
leftseconds = (int)(playerinfo.NextChargeRealtime - DateTime.Now).TotalSeconds;
TryChatMessage(player, Lang("Raid Blocked RNextTime", player.UserIDString, leftseconds));
break;
case 1:
TimeSpan playerplaytime = GetPlayerPlaytime(player);
leftseconds = (int)(playerinfo.NextChargePlaytime - playerplaytime).TotalSeconds;
TryChatMessage(player, Lang("Raid Blocked PNextTime", player.UserIDString, leftseconds));
break;
default:
goto case 0;
}
}
else
{
if (config.RaidLimitSettings
// ... [Code preview truncated due to length. Full source in attached file] ...