C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using System;
using System.Collections.Generic;
using System.Linq;
using System.Globalization;
using System.Collections;
//using Newtonsoft.Json;
using UnityEngine;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using Oxide.Core.Plugins;
namespace Oxide.Plugins {
[Info("GUIAnnouncements", "JoeSheep", "1.23.83", ResourceId = 1222)]
[Description("Creates announcements with custom messages by command across the top of every player's screen in a banner.")]
class GUIAnnouncements : RustPlugin {
#region Configuration
#region Permissions
const string PermAnnounce = "GUIAnnouncements.announce";
const string PermAnnounceToggle = "GUIAnnouncements.toggle";
const string PermAnnounceJoinLeave = "GUIAnnouncements.announcejoinleave";
#endregion
#region Global Declerations
private Dictionary<ulong, string> Exclusions = new Dictionary<ulong, string>();
private HashSet<ulong> JustJoined = new HashSet<ulong>();
private HashSet<ulong> GlobalTimerPlayerList = new HashSet<ulong>();
private Dictionary<BasePlayer, Timer> PrivateTimers = new Dictionary<BasePlayer, Timer>();
private Dictionary<BasePlayer, Timer> NewPlayerPrivateTimers = new Dictionary<BasePlayer, Timer>();
private Dictionary<BasePlayer, Timer> PlayerRespawnedTimers = new Dictionary<BasePlayer, Timer>();
private Timer PlayerTimer;
private Timer GlobalTimer;
private Timer NewPlayerTimer;
private Timer PlayerRespawnedTimer;
private Timer RealTimeTimer;
private bool RealTimeTimerStarted = false;
private Timer SixtySecondsTimer;
private Timer AutomaticAnnouncementsTimer;
//private static Core.Libraries.Timer.TimerInstance instance;
private Timer GetNextRestartTimer;
private string LastHitPlayer = String.Empty;
private HashSet<uint> HeliNetIDs = new HashSet<uint>();
private bool ConfigUpdated;
private List<DateTime> RestartTimes = new List<DateTime>();
private Dictionary<DateTime, TimeSpan> CalcNextRestartDict = new Dictionary<DateTime, TimeSpan>();
private DateTime NextRestart;
List<TimeSpan> RestartAnnouncementsWhen = new List<TimeSpan>();
private int LastHour;
private int LastMinute;
private bool RestartCountdown;
private bool RestartJustScheduled = false;
private bool RestartScheduled = false;
private string RestartReason = String.Empty;
private List<string> RestartAnnouncementsWhenStrings;
private DateTime ScheduledRestart;
private TimeSpan AutomaticTimedAnnouncementsRepeat;
private bool RestartSuspended = false;
private bool DontCheckNextRestart = false;
private bool MuteBans = false;
private bool ConvertedBannerColor = true;
private bool ConvertedTextColor = true;
private bool Announcing = false;
private List<string> GameTimes = new List<string>();
private IEnumerator<List<string>> ATALEnum;
private List<List<string>> AutomaticTimedAnnouncementsList = new List<List<string>>();
string BannerTintGrey = "0.1 0.1 0.1 0.7";
string BannerTintRed = "0.5 0.1 0.1 0.7";
string BannerTintOrange = "0.95294 0.37255 0.06275 0.7";
string BannerTintYellow = "1 0.92 0.016 0.7";
string BannerTintGreen = "0.1 0.4 0.1 0.5";
string BannerTintCyan = "0 1 1 0.7";
string BannerTintBlue = "0.09020 0.07843 0.71765 0.7";
string BannerTintPurple = "0.53333 0.07843 0.77647 0.7";
string TextRed = "0.5 0.2 0.2";
string TextOrange = "0.8 0.5 0.1";
string TextYellow = "1 0.92 0.016";
string TextGreen = "0 1 0";
string TextCyan = "0 1 1";
string TextBlue = "0.09020 0.07843 0.71765";
string TextPurple = "0.53333 0.07843 0.77647";
string TextWhite = "1 1 1";
string BannerAnchorMaxX = "1.026 ";
string BannerAnchorMaxY = "0.9743";
string TABannerAnchorMaxY = "0.9743";
string BannerAnchorMinX = "-0.027 ";
string BannerAnchorMinY = "0.915";
string TABannerAnchorMinY = "0.915";
string TextAnchorMaxX = "0.868 ";
string TextAnchorMaxY = "0.9743";
string TATextAnchorMaxY = "0.9743";
string TextAnchorMinX = "0.131 ";
string TextAnchorMinY = "0.915";
string TATextAnchorMinY = "0.915";
#endregion
//============================================================================================================
#region Config Option Declerations
//Color List
public string bannerColorList {
get;
private set;
}
= "Grey, Red, Orange, Yellow, Green, Cyan, Blue, Purple";
public string textColorList {
get;
private set;
}
= "White, Red, Orange, Yellow, Green, Cyan, Blue, Purple";
//Airdrop Announcements
public bool airdropAnnouncement {
get;
private set;
}
= true;
public bool airdropAnnouncementLocation {
get;
private set;
}
= true;
public string airdropAnnouncementText {
get;
private set;
}
= "Airdrop en route!";
public string airdropAnnouncementTextWithCoords {
get;
private set;
}
= "Airdrop en route to x{x}, z{z}";
public string airdropAnnouncementBannerColor {
get;
private set;
}
= "Green";
public string airdropAnnouncementTextColor {
get;
private set;
}
= "Yellow";
//Automatic Game Time Announcements
public bool automaticGameTimeAnnouncements {
get;
private set;
}
= false;
public Dictionary<string, List<object>> automaticGameTimeAnnouncementsList {
get;
private set;
}
= new Dictionary<string, List<object>> {
{
"18:15", new List<object> {
"The in game time is 18:15 announcement 1.", "The in game time is 18:15 announcement 2.", "The in game time is 18:15 announcement 3."
}
}
, {
"00:00", new List<object> {
"The in game time is 00:00 announcement 1.", "The in game time is 00:00 announcement 2.", "The in game time is 00:00 announcement 3."
}
}
, {
"12:00", new List<object> {
"The in game time is 12:00 announcement 1.", "The in game time is 12:00 announcement 2.", "The in game time is 12:00 announcement 3."
}
}
,
}
;
public string automaticGameTimeAnnouncementsBannerColor {
get;
private set;
}
= "Grey";
public string automaticGameTimeAnnouncementsTextColor {
get;
private set;
}
= "White";
//Automatic Timed Announcements
public bool automaticTimedAnnouncements {
get;
private set;
}
= false;
public static List<object> automaticTimedAnnouncementsList {
get;
private set;
}
= new List<object> {
new List<object> {
"1st Automatic Timed Announcement 1", "1st Automatic Timed Announcement 2"
}
, new List<object> {
"2nd Automatic Timed Announcement 1", "2nd Automatic Timed Announcement 2"
}
, new List<object> {
"3rd Automatic Timed Announcement 1", "3rd Automatic Timed Announcement 2"
}
,
}
;
public string automaticTimedAnnouncementsRepeat {
get;
private set;
}
= "00:30:00";
public string automaticTimedAnnouncementsBannerColor {
get;
private set;
}
= "Grey";
public string automaticTimedAnnouncementsTextColor {
get;
private set;
}
= "White";
//Christmas Stocking Refill Announcement
public bool stockingRefillAnnouncement {
get;
private set;
}
= false;
public string stockingRefillAnnouncementText {
get;
private set;
}
= "Santa has refilled your stockings.Go check what you've got!";
public string stockingRefillAnnouncementBannerColor {
get;
private set;
}
= "Green";
public string stockingRefillAnnouncementTextColor {
get;
private set;
}
= "Red";
//General Settings
public float announcementDuration {
get;
private set;
}
= 10f;
public int fontSize {
get;
private set;
}
= 18;
public float fadeOutTime {
get;
private set;
}
= 0.5f;
public float fadeInTime {
get;
private set;
}
= 0.5f;
public static float adjustVPosition {
get;
private set;
}
= 0.0f;
//Global Join/Leave Announcements
public bool globalLeaveAnnouncements {
get;
private set;
}
= false;
public bool globalJoinAnnouncements {
get;
private set;
}
= false;
public bool globalJoinLeavePermissionOnly {
get;
private set;
}
= true;
public string globalLeaveText {
get;
private set;
}
= "{rank} {playername} has left.";
public string globalJoinText {
get;
private set;
}
= "{rank} {playername} has joined.";
public string globalLeaveAnnouncementBannerColor {
get;
private set;
}
= "Grey";
public string globalLeaveAnnouncementTextColor {
get;
private set;
}
= "White";
public string globalJoinAnnouncementBannerColor {
get;
private set;
}
= "Grey";
public string globalJoinAnnouncementTextColor {
get;
private set;
}
= "White";
//Helicopter Announcements
public bool helicopterSpawnAnnouncement {
get;
private set;
}
= true;
public bool helicopterDespawnAnnouncement {
get;
private set;
}
= false;
public bool helicopterDestroyedAnnouncement {
get;
private set;
}
= true;
public bool helicopterDestroyedAnnouncementWithDestroyer {
get;
private set;
}
= true;
public string helicopterSpawnAnnouncementText {
get;
private set;
}
= "Patrol Helicopter Inbound!";
public string helicopterDespawnAnnouncementText {
get;
private set;
}
= "The patrol helicopter has left.";
public string helicopterDestroyedAnnouncementText {
get;
private set;
}
= "The patrol helicopter has been taken down!";
public string helicopterDestroyedAnnouncementWithDestroyerText {
get;
private set;
}
= "{playername} got the last shot on the helicopter taking it down!";
public string helicopterSpawnAnnouncementBannerColor {
get;
private set;
}
= "Red";
public string helicopterSpawnAnnouncementTextColor {
get;
private set;
}
= "Orange";
public string helicopterDestroyedAnnouncementBannerColor {
get;
private set;
}
= "Red";
public string helicopterDestroyedAnnouncementTextColor {
get;
private set;
}
= "White";
public string helicopterDespawnAnnouncementBannerColor {
get;
private set;
}
= "Red";
public string helicopterDespawnAnnouncementTextColor {
get;
private set;
}
= "White";
//New Player Announcements
public bool newPlayerAnnouncements {
get;
private set;
}
= true;
public string newPlayerAnnouncementsBannerColor {
get;
private set;
}
= "Grey";
public string newPlayerAnnouncementsTextColor {
get;
private set;
}
= "White";
public Dictionary<int, List<object>> newPlayerAnnouncementsList {
get;
private set;
}
= new Dictionary<int, List<object>> {
{
1, new List<object> {
"1st Join {rank} {playername} New player announcement 1.", "1st Join {rank} {playername} New player announcement 2.", "1st Join {rank} {playername} New player announcement 3."
}
}
, {
2, new List<object> {
"2nd Join {rank} {playername} New player announcement 1.", "2nd Join {rank} {playername} New player announcement 2.", "2nd Join {rank} {playername} New player announcement 3."
}
}
, {
3, new List<object> {
"3rd Join {rank} {playername} New player announcement 1.", "3rd Join {rank} {playername} New player announcement 2.", "3rd Join {rank} {playername} New player announcement 3."
}
}
,
}
;
//Player Banned Announcement
public bool playerBannedAnnouncement {
get;
private set;
}
= false;
public string playerBannedAnnouncmentText {
get;
private set;
}
= "{playername} has been banned.{reason}.";
public string playerBannedAnnouncementBannerColor {
get;
private set;
}
= "Grey";
public string playerBannedAnnouncementTextColor {
get;
private set;
}
= "Red";
//Respawn Announcements
public bool respawnAnnouncements {
get;
private set;
}
= false;
public string respawnAnnouncementsBannerColor {
get;
private set;
}
= "Grey";
public string respawnAnnouncementsTextColor {
get;
private set;
}
= "White";
public List<object> respawnAnnouncementsList {
get;
private set;
}
= new List<object> {
"{playername} Respawn announcement 1.", "{playername} Respawn announcement 2.", "{playername} Respawn announcement 3."
}
;
//Restart Announcements
public bool restartAnnouncements {
get;
private set;
}
= false;
public string restartAnnouncementsFormat {
get;
private set;
}
= "Restarting in {time}";
public string restartAnnouncementsBannerColor {
get;
private set;
}
= "Grey";
public string restartAnnouncementsTextColor {
get;
private set;
}
= "White";
public List<object> restartTimes {
get;
private set;
}
= new List<object> {
"08:00:00", "20:00:00"
}
;
public List<object> restartAnnouncementsWhen {
get;
private set;
}
= new List<object> {
"12:00:00", "11:00:00", "10:00:00", "09:00:00", "08:00:00", "07:00:00", "06:00:00", "05:00:00", "04:00:00", "03:00:00", "02:00:00", "01:00:00", "00:45:00", "00:30:00", "00:15:00", "00:05:00"
}
;
public bool restartServer {
get;
private set;
}
= false;
public string restartSuspendedAnnouncement {
get;
private set;
}
= "The restart in {time} has been suspended.";
public string restartCancelledAnnouncement {
get;
private set;
}
= "The restart in {time} has been cancelled.";
//Test Announcement
public float testAnnouncementDuration {
get;
private set;
}
= 10f;
public int testAnnouncementFontSize {
get;
private set;
}
= 18;
public float testAnnouncementFadeOutTime {
get;
private set;
}
= 0.5f;
public float testAnnouncementFadeInTime {
get;
private set;
}
= 0.5f;
public static float testAnnouncementAdjustVPosition {
get;
private set;
}
= 0.0f;
public string testAnnouncementBannerColor {
get;
private set;
}
= "Grey";
public string testAnnouncementsTextColor {
get;
private set;
}
= "White";
//Third Party Plugin Support
public bool doNotOverlayLustyMap {
get;
private set;
}
= false;
public string lustyMapPosition {
get;
private set;
}
= "Left";
//Welcome Announcement
public string welcomeAnnouncementText {
get;
private set;
}
= "Welcome {playername}! There are {playercount} player(s) online.";
public string welcomeBackAnnouncementText {
get;
private set;
}
= "Welcome back {playername}! There are {playercount} player(s) online.";
public string welcomeAnnouncementBannerColor {
get;
private set;
}
= "Grey";
public string welcomeAnnouncementTextColor {
get;
private set;
}
= "White";
public float welcomeAnnouncementDuration {
get;
private set;
}
= 20f;
public bool welcomeAnnouncement {
get;
private set;
}
= true;
public bool welcomeBackAnnouncement {
get;
private set;
}
= true;
#endregion
//============================================================================================================
#region LoadConfig
private void LoadGUIAnnouncementsConfig() {
//Color List
bannerColorList = GetConfig("A List Of Available Colors To Use (DO NOT CHANGE)", "Banner Colors", bannerColorList);
if (bannerColorList != "Grey, Red, Orange, Yellow, Green, Cyan, Blue, Purple") {
PrintWarning("Banner color list changed.Reverting changes.");
Config["A List Of Available Colors To Use(DO NOT CHANGE)", "Banner Colors"] = "Grey, Red, Orange, Yellow, Green, Cyan, Blue, Purple";
ConfigUpdated = true;
}
textColorList = GetConfig("A List Of Available Colors To Use (DO NOT CHANGE)", "Text Colors", textColorList);
if (textColorList != "White, Red, Orange, Yellow, Green, Cyan, Blue, Purple") {
PrintWarning("Text color list changed.Reverting changes.");
Config["A List Of Available Colors To Use(DO NOT CHANGE)", "Text Colors"] = "White, Red, Orange, Yellow, Green, Cyan, Blue, Purple";
ConfigUpdated = true;
}
//Airdrop Announcements
airdropAnnouncementText = GetConfig("Public Airdrop Announcements", "Text", airdropAnnouncementText);
airdropAnnouncementTextWithCoords = GetConfig("Public Airdrop Announcements", "Text With Coords", airdropAnnouncementTextWithCoords);
airdropAnnouncementBannerColor = GetConfig("Public Airdrop Announcements", "Banner Color", airdropAnnouncementBannerColor);
ConvertBannerColor(airdropAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Airdrop Announcements - Banner Color: " + airdropAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Airdrop Announcements", "Banner Color"] = "Green";
ConfigUpdated = true;
}
airdropAnnouncementTextColor = GetConfig("Public Airdrop Announcements", "Text Color", airdropAnnouncementTextColor);
ConvertTextColor(airdropAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Airdrop Announcements - Text Color: " + airdropAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Airdrop Announcements", "Text Color"] = "Yellow";
ConfigUpdated = true;
}
airdropAnnouncement = GetConfig("Public Airdrop Announcements", "Enabled", true);
airdropAnnouncementLocation = GetConfig("Public Airdrop Announcements", "Show Location", false);
//Automatic Game Time Announcements
automaticGameTimeAnnouncements = GetConfig("Public Automatic Game Time Announcements", "Enabled", false);
automaticGameTimeAnnouncementsList = GetConfig("Public Automatic Game Time Announcements", "Announcement List (Show at this in game time : Announcements to show)", automaticGameTimeAnnouncementsList);
automaticGameTimeAnnouncementsBannerColor = GetConfig("Public Automatic Game Time Announcements", "Banner Color", automaticGameTimeAnnouncementsBannerColor);
ConvertBannerColor(automaticGameTimeAnnouncementsBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Automatic Game Time Announcements - Banner Color: " + automaticGameTimeAnnouncementsBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Automatic Game Time Announcements", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
automaticGameTimeAnnouncementsTextColor = GetConfig("Public Automatic Game Time Announcements", "Text Color", automaticGameTimeAnnouncementsTextColor);
ConvertTextColor(automaticGameTimeAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Automatic Game Time Announcements - Text Color: " + automaticGameTimeAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Public Automatic Game Time Announcements", "Text Color"] = "White";
ConfigUpdated = true;
}
//Automatic Timed Announcements
automaticTimedAnnouncements = GetConfig("Public Automatic Timed Announcements", "Enabled", false);
automaticTimedAnnouncementsList = GetConfig("Public Automatic Timed Announcements", "Announcement List", automaticTimedAnnouncementsList);
automaticTimedAnnouncementsBannerColor = GetConfig("Public Automatic Timed Announcements", "Banner Color", automaticTimedAnnouncementsBannerColor);
ConvertBannerColor(automaticTimedAnnouncementsBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Automatic Timed Announcements - Banner Color: " + automaticTimedAnnouncementsBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Automatic Timed Announcements", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
automaticTimedAnnouncementsTextColor = GetConfig("Public Automatic Timed Announcements", "Text Color", automaticTimedAnnouncementsTextColor);
ConvertTextColor(automaticTimedAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Automatic Timed Announcements - Text Color: " + automaticTimedAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Public Automatic Timed Announcements", "Text Color"] = "White";
ConfigUpdated = true;
}
automaticTimedAnnouncementsRepeat = GetConfig("Public Automatic Timed Announcements", "Show Every (HH:MM:SS)", automaticTimedAnnouncementsRepeat);
if (!TimeSpan.TryParse(automaticTimedAnnouncementsRepeat, out AutomaticTimedAnnouncementsRepeat)) {
PrintWarning("Config: \"Automatic Timed Announcements - Show Every (HH:MM:SS)\" is not of the correct format HH:MM:SS, or has numbers out of range and should not be higher than 23:59:59.Resetting to default.");
Config["Public Automatic Timed Announcements", "Show Every (HH:MM:SS)"] = "00:30:00";
ConfigUpdated = true;
}
//Christmas Stocking Refill Announcement
stockingRefillAnnouncement = GetConfig("Public Christmas Stocking Refill Announcement", "Enabled", false);
stockingRefillAnnouncementText = GetConfig("Public Christmas Stocking Refill Announcement", "Text", stockingRefillAnnouncementText);
stockingRefillAnnouncementBannerColor = GetConfig("Public Christmas Stocking Refill Announcement", "Banner Color", stockingRefillAnnouncementBannerColor);
ConvertBannerColor(stockingRefillAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Christmas Stocking Refill Announcement - Banner Color: " + stockingRefillAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Christmas Stocking Refill Announcement", "Banner Color"] = "Green";
ConfigUpdated = true;
}
stockingRefillAnnouncementTextColor = GetConfig("Public Christmas Stocking Refill Announcement", "Text Color", stockingRefillAnnouncementTextColor);
ConvertTextColor(stockingRefillAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Christmas Stocking Refill Announcement - Text Color: " + stockingRefillAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Christmas Stocking Refill Announcement", "Text Color"] = "Red";
ConfigUpdated = true;
}
//General Settings:
announcementDuration = GetConfig("General Settings", "Announcement Duration", 10f);
if (announcementDuration == 0) {
PrintWarning("Config: \"General Settings - Announcement Duration\" set to 0, resetting to 10f.");
Config["General Settings", "Announcement Duration"] = 10f;
ConfigUpdated = true;
}
fontSize = GetConfig("General Settings", "Font Size", 18);
if (fontSize > 33 | fontSize == 0) {
PrintWarning("Config: \"General Settings - Font Size\" greater than 28 or 0, resetting to 18.");
Config["General Settings", "Font Size"] = 18;
ConfigUpdated = true;
}
fadeInTime = GetConfig("General Settings", "Fade In Time", 0.5f);
if (fadeInTime > announcementDuration / 2) {
PrintWarning("Config: \"General Settings - Fade In Time\" is greater than half of AnnouncementShowDuration, resetting to half of AnnouncementShowDuration.");
Config["General Settings", "Fade In Time"] = announcementDuration / 2;
ConfigUpdated = true;
}
fadeOutTime = GetConfig("General Settings", "Fade Out Time", 0.5f);
if (fadeOutTime > announcementDuration / 2) {
PrintWarning("Config: \"General Settings - Fade Out Time\" is greater than half of AnnouncementShowDuration, resetting to half of AnnouncementShowDuration.");
Config["General Settings", "Fade Out Time"] = announcementDuration / 2;
ConfigUpdated = true;
}
adjustVPosition = GetConfig("General Settings", "Adjust Vertical Position", 0.0f);
if (adjustVPosition != 0f) {
BannerAnchorMaxY = (float.Parse("0.9743") + adjustVPosition).ToString();
BannerAnchorMinY = (float.Parse("0.915") + adjustVPosition).ToString();
TextAnchorMaxY = (float.Parse("0.9743") + adjustVPosition).ToString();
TextAnchorMinY = (float.Parse("0.915") + adjustVPosition).ToString();
}
//Global Join/Leave Announcements
globalLeaveAnnouncements = GetConfig("Public Join/Leave Announcements", "Leave Enabled", false);
globalLeaveText = GetConfig("Public Join/Leave Announcements", "Leave Text", globalLeaveText);
globalLeaveAnnouncementBannerColor = GetConfig("Public Join/Leave Announcements", "Leave Banner Color", globalLeaveAnnouncementBannerColor);
ConvertBannerColor(globalLeaveAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Join/Leave Announcements - Leave Banner Color: " + globalLeaveAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Join/Leave Announcements", "Leave Banner Color"] = "Grey";
ConfigUpdated = true;
}
globalLeaveAnnouncementTextColor = GetConfig("Public Join/Leave Announcements", "Leave Text Color", globalLeaveAnnouncementTextColor);
ConvertTextColor(globalLeaveAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Join/Leave Announcements - Leave Text Color: " + globalLeaveAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Join/Leave Announcements", "Leave Text Color"] = "White";
ConfigUpdated = true;
}
globalJoinAnnouncements = GetConfig("Public Join/Leave Announcements", "Join Enabled", false);
globalJoinText = GetConfig("Public Join/Leave Announcements", "Join Text", globalJoinText);
globalJoinAnnouncementBannerColor = GetConfig("Public Join/Leave Announcements", "Join Banner Color", globalJoinAnnouncementBannerColor);
ConvertBannerColor(globalJoinAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Join/Leave Announcements - Join Banner Color: " + globalJoinAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Join/Leave Announcements", "Join Banner Color"] = "Grey";
ConfigUpdated = true;
}
globalJoinAnnouncementTextColor = GetConfig("Public Join/Leave Announcements", "Join Text Color", globalJoinAnnouncementTextColor);
ConvertTextColor(globalJoinAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Join/Leave Announcements - Join Text Color: " + globalJoinAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Join/Leave Announcements", "Join Text Color"] = "White";
ConfigUpdated = true;
}
globalJoinLeavePermissionOnly = GetConfig("Public Join/Leave Announcements", "Announce Only Players With Permission", globalJoinLeavePermissionOnly);
//Helicopter Announcements
helicopterSpawnAnnouncement = GetConfig("Public Helicopter Announcements", "Spawn", true);
helicopterSpawnAnnouncementText = GetConfig("Public Helicopter Announcements", "Spawn Text", helicopterSpawnAnnouncementText);
helicopterSpawnAnnouncementBannerColor = GetConfig("Public Helicopter Announcements", "Spawn Banner Color", helicopterSpawnAnnouncementBannerColor);
ConvertBannerColor(helicopterSpawnAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Helicopter Announcements - Spawn Banner Color: " + helicopterSpawnAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Spawn Banner Color"] = "Red";
ConfigUpdated = true;
}
helicopterSpawnAnnouncementTextColor = GetConfig("Public Helicopter Announcements", "Spawn Text Color", helicopterSpawnAnnouncementTextColor);
ConvertTextColor(helicopterSpawnAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Helicopter Announcements - Spawn Text Color: " + helicopterSpawnAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Spawn Text Color"] = "Orange";
ConfigUpdated = true;
}
helicopterDespawnAnnouncement = GetConfig("Public Helicopter Announcements", "Despawn", helicopterDespawnAnnouncement);
helicopterDespawnAnnouncementText = GetConfig("Public Helicopter Announcements", "Despawn Text", helicopterDespawnAnnouncementText);
helicopterDespawnAnnouncementBannerColor = GetConfig("Public Helicopter Announcements", "Despawn Banner Color", helicopterDespawnAnnouncementBannerColor);
ConvertBannerColor(helicopterDespawnAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Helicopter Announcements - Despawn Banner Color: " + helicopterDespawnAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Despawn Banner Color"] = "Red";
ConfigUpdated = true;
}
helicopterDespawnAnnouncementTextColor = GetConfig("Public Helicopter Announcements", "Despawn Text Color", helicopterDespawnAnnouncementTextColor);
ConvertTextColor(helicopterDespawnAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Helicopter Announcements - Despawn Text Color: " + helicopterDespawnAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Despawn Text Color"] = "White";
ConfigUpdated = true;
}
helicopterDestroyedAnnouncement = GetConfig("Public Helicopter Announcements", "Destroyed", true);
helicopterDestroyedAnnouncementWithDestroyer = GetConfig("Public Helicopter Announcements", "Show Destroyer", true);
helicopterDestroyedAnnouncementText = GetConfig("Public Helicopter Announcements", "Destroyed Text", helicopterDestroyedAnnouncementText);
helicopterDestroyedAnnouncementWithDestroyerText = GetConfig("Public Helicopter Announcements", "Destroyed Text With Destroyer", helicopterDestroyedAnnouncementWithDestroyerText);
helicopterDestroyedAnnouncementBannerColor = GetConfig("Public Helicopter Announcements", "Destroyed Banner Color", helicopterDestroyedAnnouncementBannerColor);
ConvertBannerColor(helicopterDestroyedAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Helicopter Announcements - Destroyed Banner Color: " + helicopterDestroyedAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Destroyed Banner Color"] = "Red";
ConfigUpdated = true;
}
helicopterDestroyedAnnouncementTextColor = GetConfig("Public Helicopter Announcements", "Destroyed Text Color", helicopterDestroyedAnnouncementTextColor);
ConvertTextColor(helicopterDestroyedAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Helicopter Announcements - Destroyed Text Color: " + helicopterDestroyedAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Helicopter Announcements", "Destroyed Text Color"] = "White";
ConfigUpdated = true;
}
//New Player Announcements
newPlayerAnnouncements = GetConfig("Private New Player Announcements", "Enabled", false);
newPlayerAnnouncementsBannerColor = GetConfig("Private New Player Announcements", "Banner Color", newPlayerAnnouncementsBannerColor);
ConvertBannerColor(newPlayerAnnouncementsBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Private New Player Announcements - Banner Color: " + newPlayerAnnouncementsBannerColor + "\" is not a valid color, resetting to default.");
Config["Private New Player Announcements", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
newPlayerAnnouncementsTextColor = GetConfig("Private New Player Announcements", "Text Color", newPlayerAnnouncementsTextColor);
ConvertTextColor(newPlayerAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Private New Player Announcements - Text Color: " + newPlayerAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Private New Player Announcements", "Text Color"] = "White";
ConfigUpdated = true;
}
newPlayerAnnouncementsList = GetConfig("Private New Player Announcements", "Announcements List (Show On This Many Joins : List To Show)", newPlayerAnnouncementsList);
//Player Banned Announcement
playerBannedAnnouncement = GetConfig("Public Player Banned Announcement", "Enabled", false);
playerBannedAnnouncmentText = GetConfig("Public Player Banned Announcement", "Text", playerBannedAnnouncmentText);
playerBannedAnnouncementBannerColor = GetConfig("Public Player Banned Announcement", "Banner Color", playerBannedAnnouncementBannerColor);
ConvertBannerColor(playerBannedAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Player Banned Announcement - Banner Color: " + playerBannedAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Player Banned Announcement", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
playerBannedAnnouncementTextColor = GetConfig("Public Player Banned Announcement", "Text Color", playerBannedAnnouncementTextColor);
ConvertTextColor(playerBannedAnnouncementTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Player Banned Announcement - Text Color: " + playerBannedAnnouncementTextColor + "\" is not a valid color, resetting to default.");
Config["Public Player Banned Announcement", "Text Color"] = "Red";
ConfigUpdated = true;
}
//Respawn Announcements
respawnAnnouncements = GetConfig("Private Respawn Announcements", "Enabled", false);
respawnAnnouncementsBannerColor = GetConfig("Private Respawn Announcements", "Banner Color", respawnAnnouncementsBannerColor);
ConvertBannerColor(respawnAnnouncementsBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Private Respawn Announcements - Banner Color: " + respawnAnnouncementsBannerColor + "\" is not a valid color, resetting to default.");
Config["Private Respawn Announcements", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
respawnAnnouncementsTextColor = GetConfig("Private Respawn Announcements", "Text Color", respawnAnnouncementsTextColor);
ConvertTextColor(respawnAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Private Respawn Announcements - Text Color: " + respawnAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Private Respawn Announcements", "Text Color"] = "White";
ConfigUpdated = true;
}
respawnAnnouncementsList = GetConfig("Private Respawn Announcements", "Announcements List", respawnAnnouncementsList);
//Restart Announcements
restartAnnouncements = GetConfig("Public Restart Announcements", "Enabled", restartAnnouncements);
restartTimes = GetConfig("Public Restart Announcements", "Restart At (HH:MM:SS)", restartTimes);
restartAnnouncementsBannerColor = GetConfig("Public Restart Announcements", "Banner Color", restartAnnouncementsBannerColor);
ConvertBannerColor(restartAnnouncementsBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Public Restart Announcements - Banner Color: " + restartAnnouncementsBannerColor + "\" is not a valid color, resetting to default.");
Config["Public Restart Announcements", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
restartAnnouncementsTextColor = GetConfig("Public Restart Announcements", "Text Color", restartAnnouncementsTextColor);
ConvertTextColor(restartAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Public Restart Announcements - Text Color: " + restartAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Public Restart Announcements", "Text Color"] = "White";
ConfigUpdated = true;
}
restartAnnouncementsWhen = GetConfig("Public Restart Announcements", "Announce With Time Left (HH:MM:SS)", restartAnnouncementsWhen);
restartServer = GetConfig("Public Restart Announcements", "Restart My Server", false);
restartAnnouncementsFormat = GetConfig("Public Restart Announcements", "Restart Announcement Text", restartAnnouncementsFormat);
restartSuspendedAnnouncement = GetConfig("Public Restart Announcements", "Suspended Restart Text", restartSuspendedAnnouncement);
restartCancelledAnnouncement = GetConfig("Public Restart Announcements", "Cancelled Scheduled Restart Text", restartCancelledAnnouncement);
//Test Announcement
testAnnouncementFontSize = GetConfig("Private Test Announcement", "Font Size", testAnnouncementFontSize);
testAnnouncementDuration = GetConfig("Private Test Announcement", "Duration", testAnnouncementDuration);
testAnnouncementFadeInTime = GetConfig("Private Test Announcement", "Fade In Time", testAnnouncementFadeInTime);
testAnnouncementFadeOutTime = GetConfig("Private Test Announcement", "Fade Out Time", testAnnouncementFadeOutTime);
testAnnouncementAdjustVPosition = GetConfig("Private Test Announcement", "Adjust Vertical Position", testAnnouncementAdjustVPosition);
if (adjustVPosition != 0f) {
TABannerAnchorMaxY = (float.Parse("0.9743") + adjustVPosition).ToString();
TABannerAnchorMinY = (float.Parse("0.915") + adjustVPosition).ToString();
TATextAnchorMaxY = (float.Parse("0.9743") + adjustVPosition).ToString();
TATextAnchorMinY = (float.Parse("0.915") + adjustVPosition).ToString();
}
testAnnouncementBannerColor = GetConfig("Private Test Announcement", "Banner Color", testAnnouncementBannerColor);
ConvertBannerColor(testAnnouncementBannerColor, true);
if (!ConvertedBannerColor) {
ConvertedBannerColor = true;
PrintWarning("\"Private Test Announcement - Banner Color: " + testAnnouncementBannerColor + "\" is not a valid color, resetting to default.");
Config["Private Test Announcement", "Banner Color"] = "Grey";
ConfigUpdated = true;
}
testAnnouncementsTextColor = GetConfig("Private Test Announcement", "Text Color", testAnnouncementsTextColor);
ConvertTextColor(testAnnouncementsTextColor, true);
if (!ConvertedTextColor) {
ConvertedTextColor = true;
PrintWarning("\"Private Test Announcement - Text Color: " + testAnnouncementsTextColor + "\" is not a valid color, resetting to default.");
Config["Private Test Announcement", "Text Color"] = "White";
ConfigUpdated = true;
}
//Third Party Plugin Support
doNotOverlayLustyMap = GetConfig("Third Party Plugin Support", "Do Not Overlay LustyMap", false);
lustyMapPosition = GetConfig("Third Party Plugin Support", "LustyMap Position (Left/Right)", "Left");
if (lustyMapPosition.ToLower() != "left" && lustyMapPosition.ToLower() != "right" || lustyMapPosition == string.Empty || lustyMapPosition == null) {
PrintWarning("Config: \"Third Party Plugin Sup
// ... [Code preview truncated due to length. Full source in attached file] ...