C#:
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using UnityEngine;
namespace Oxide.Plugins
{
[Info("SimpleEvents", "Ridamees", "0.0.2")]
[Description("Set Minimum required players and custom commands for rust events.")]
class SimpleEvents : RustPlugin
{
private ConfigFile config;
private Dictionary<string, Timer> timedCommandTimers = new Dictionary<string, Timer>();
class ConfigFile
{
[JsonProperty(PropertyName = "Custom Commands Execution Mode | 1 = Sequentially, 2 = Simultaneously, 3 = Disabled")]
public int ExecuteTimedCommandsMode = 1;
[JsonProperty(PropertyName = "Custom Commands")]
public List<TimedCommandConfig> timedCommands = new List<TimedCommandConfig>{};
[JsonProperty(PropertyName = "Patrol Helicopter")]
public EventConfig patrolHeli = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/npc/patrol helicopter/patrolhelicopter.prefab" };
[JsonProperty(PropertyName = "CH47 Helicopter")]
public EventConfig chinook = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/npc/ch47/ch47scientists.entity.prefab" };
[JsonProperty(PropertyName = "Cargo Ship")]
public CargoShipConfig cargoShip = new CargoShipConfig { MinPop = 0, LootRoundsMinPop = new List<int>(), Commands = new List<string> { "", }, Prefab = "assets/content/vehicles/boats/cargoship/cargoshiptest.prefab" };
[JsonProperty(PropertyName = "Cargo Plane")]
public EventConfig cargoPlane = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/npc/cargo plane/cargo_plane.prefab" };
[JsonProperty(PropertyName = "Easter Egg Hunt")]
public EventConfig easterEggHunt = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/misc/easter/egghunt.prefab" };
[JsonProperty(PropertyName = "Santa's Sleigh")]
public EventConfig santasSleigh = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/misc/xmas/sleigh/santasleigh.prefab" };
[JsonProperty(PropertyName = "Halloween Hunt")]
public EventConfig halloweenHunt = new EventConfig { MinPop = 0, Commands = new List<string> { "", }, Prefab = "assets/prefabs/misc/halloween/halloweenhunt.prefab" };
[JsonProperty(PropertyName = "Bradley APC")]
public EventConfig bradley = new EventConfig { MinPop = 0 };
public class EventConfig
{
[JsonProperty(PropertyName = "Commands")]
public List<string> Commands { get; set; }
[JsonProperty(PropertyName = "Min Players")]
public int MinPop { get; set; }
[JsonProperty(PropertyName = "Prefab")]
public string Prefab { get; set; }
}
public class CargoShipConfig : EventConfig
{
[JsonProperty(PropertyName = "Noninitial LootRound Min Players")]
public List<int> LootRoundsMinPop { get; set; }
public CargoShipConfig() : base()
{
}
}
public class TimedCommandConfig
{
[JsonProperty(PropertyName = "Commands")]
public List<string> Commands { get; set; }
[JsonProperty(PropertyName = "Min Interval (s)")]
public int MinInterval { get; set; }
[JsonProperty(PropertyName = "Max Interval (s)")]
public int MaxInterval { get; set; }
[JsonProperty(PropertyName = "Min Players")]
public int MinPlayers { get; set; }
}
public static List<TimedCommandConfig> GetDefaultTimedCommands()
{
return new List<TimedCommandConfig>
{
new TimedCommandConfig { Commands = new List<string> { "", "" }, MinInterval = 60, MaxInterval = 120, MinPlayers = 0 },
new TimedCommandConfig { Commands = new List<string> { "", "" }, MinInterval = 180, MaxInterval = 300, MinPlayers = 0 }
};
}
public static ConfigFile getDefaultConfigFile()
{
return new ConfigFile();
}
}
protected override void LoadConfig()
{
base.LoadConfig();
config = Config.ReadObject<ConfigFile>();
}
protected override void LoadDefaultConfig() => config = ConfigFile.getDefaultConfigFile();
protected override void SaveConfig() => Config.WriteObject(config);
private bool isConfiguredEvent(string prefabPath, ConfigFile.EventConfig config)
{
return prefabPath.Equals(config?.Prefab);
}
void Init()
{
LoadConfig();
initializedTimedCommands.Clear();
foreach (var timer in timedCommandTimers.Values)
{
timer.Destroy();
}
timedCommandTimers.Clear();
if (config.timedCommands.Count == 0)
{
config.timedCommands = ConfigFile.GetDefaultTimedCommands();
SaveConfig();
}
switch (config.ExecuteTimedCommandsMode)
{
case 1:
StartTimedCommandsSequentially();
break;
case 2:
StartTimedCommandsSimultaneously();
break;
case 3:
// Custom Timed Commands Disabled
break;
default:
PrintWarning("Invalid TimedCommands execution mode. Mode should be 1 (Sequentially), 2 (Simultaneously), or 3 (Disabled).");
break;
}
}
void OnEntitySpawned(BaseNetworkable networkable)
{
int numberOfActivePlayers = BasePlayer.activePlayerList.Count;
if (networkable is BradleyAPC)
{
if (numberOfActivePlayers < config.bradley.MinPop)
{
Puts("Killing Bradley because pop ({0}) is less than configured minimum of {1}", numberOfActivePlayers, config.bradley.MinPop);
networkable.Kill(BaseNetworkable.DestroyMode.None);
}
}
}
object OnEventTrigger(TriggeredEventPrefab prefab)
{
string prefabPath = prefab?.targetPrefab?.resourcePath;
if (prefabPath == null)
{
return null;
}
int numberOfActivePlayers = BasePlayer.activePlayerList.Count;
List<string> executedCommands = new List<string>();
if (prefabPath == config.cargoPlane.Prefab)
{
executedCommands = config.cargoPlane.Commands;
}
else if (prefabPath == config.santasSleigh.Prefab)
{
executedCommands = config.santasSleigh.Commands;
}
else if (prefabPath == config.patrolHeli.Prefab)
{
executedCommands = config.patrolHeli.Commands;
}
else if (prefabPath == config.chinook.Prefab)
{
executedCommands = config.chinook.Commands;
}
else if (prefabPath == config.cargoShip.Prefab)
{
executedCommands = config.cargoShip.Commands;
}
else if (prefabPath == config.easterEggHunt.Prefab)
{
executedCommands = config.easterEggHunt.Commands;
}
else if (prefabPath == config.halloweenHunt.Prefab)
{
executedCommands = config.halloweenHunt.Commands;
}
foreach (string command in executedCommands)
{
if (isConfiguredEvent(prefabPath, config.cargoPlane) && numberOfActivePlayers >= config.cargoPlane.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.santasSleigh) && numberOfActivePlayers >= config.santasSleigh.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.patrolHeli) && numberOfActivePlayers >= config.patrolHeli.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.chinook) && numberOfActivePlayers >= config.chinook.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.cargoShip) && numberOfActivePlayers >= config.cargoShip.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.easterEggHunt) && numberOfActivePlayers >= config.easterEggHunt.MinPop)
{
ExecuteConsoleCommand(command);
}
else if (isConfiguredEvent(prefabPath, config.halloweenHunt) && numberOfActivePlayers >= config.halloweenHunt.MinPop)
{
ExecuteConsoleCommand(command);
}
}
if (eventConfigCancelsEvent(prefabPath, config.cargoPlane, "cargo plane", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.santasSleigh, "santa's sleigh", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.patrolHeli, "patrol helicopter", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.chinook, "CH47 helicopter", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.cargoShip, "cargo ship", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.easterEggHunt, "easter egg hunt", numberOfActivePlayers) ||
eventConfigCancelsEvent(prefabPath, config.halloweenHunt, "halloween hunt", numberOfActivePlayers))
{
return false;
}
return null;
}
private bool eventConfigCancelsEvent(string prefabPath, ConfigFile.EventConfig config, string configName, int numberOfActivePlayers)
{
if (!isConfiguredEvent(prefabPath, config))
{
return false;
}
if (numberOfActivePlayers < config.MinPop)
{
Puts("Cancelling " + configName + " event because active population ({0}) is less than configured minimum of {1}", numberOfActivePlayers, config.MinPop);
return true;
}
return false;
}
private HashSet<string> initializedTimedCommands = new HashSet<string>();
private void ExecuteConsoleCommand(string command)
{
if (!string.IsNullOrEmpty(command))
{
string[] commands = command.Split('|');
foreach (string cmd in commands)
{
ConsoleSystem.Run(ConsoleSystem.Option.Server, cmd.Trim());
}
}
}
void StartTimedCommandsSequentially()
{
RunNextTimedCommandSequentially(0);
}
void RunNextTimedCommandSequentially(int index)
{
if (config.timedCommands.Count == 0)
{
return;
}
index = index % config.timedCommands.Count;
var timedCommand = config.timedCommands[index];
int numberOfActivePlayers = BasePlayer.activePlayerList.Count;
if (numberOfActivePlayers >= timedCommand.MinPlayers)
{
float interval = UnityEngine.Random.Range(timedCommand.MinInterval, timedCommand.MaxInterval);
List<string> commands = timedCommand.Commands;
string key = commands[0];
if (!initializedTimedCommands.Contains(key))
{
timedCommandTimers[key] = timer.Once(interval, () =>
{
foreach (string command in commands)
{
ExecuteConsoleCommand(command);
}
initializedTimedCommands.Remove(key);
RunNextTimedCommandSequentially(index + 1);
});
initializedTimedCommands.Add(key);
}
}
else
{
timedCommandTimers[timedCommand.Commands[0]] = timer.Once(timedCommand.MinInterval, () => RunNextTimedCommandSequentially(index + 1));
}
}
void StartTimedCommandsSimultaneously()
{
foreach (var timedCommand in config.timedCommands)
{
RunTimedCommandSimultaneously(timedCommand);
}
}
void RunTimedCommandSimultaneously(ConfigFile.TimedCommandConfig timedCommand)
{
int numberOfActivePlayers = BasePlayer.activePlayerList.Count;
if (numberOfActivePlayers >= timedCommand.MinPlayers)
{
float interval = UnityEngine.Random.Range(timedCommand.MinInterval, timedCommand.MaxInterval);
List<string> commands = timedCommand.Commands;
string key = commands[0];
if (!initializedTimedCommands.Contains(key))
{
timedCommandTimers[key] = timer.Once(interval, () =>
{
foreach (string command in commands)
{
ExecuteConsoleCommand(command);
}
initializedTimedCommands.Remove(key);
RunTimedCommandSimultaneously(timedCommand);
});
initializedTimedCommands.Add(key);
}
}
else
{
timedCommandTimers[timedCommand.Commands[0]] = timer.Once(timedCommand.MinInterval, () => RunTimedCommandSimultaneously(timedCommand));
}
}
void Unload()
{
foreach (var timer in timedCommandTimers.Values)
{
timer.Destroy();
}
}
}
}