C#:
// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using System.Collections.Generic;
using Newtonsoft.Json;
using CompanionServer.Handlers;
using Oxide.Plugins.SputnikExtensionMethods;
using UnityEngine;
using System;
using Oxide.Core.Plugins;
using Network;
using Rust;
using System.Collections;
using Newtonsoft.Json.Linq;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
using System.Reflection;
using Time = UnityEngine.Time;
namespace Oxide.Plugins {
[Info("Sputnik", "https://discord.gg/96eJaVaWBv", "1.2.4")]
class Sputnik : RustPlugin {
#region Variables
[PluginReference]
Plugin NpcSpawn, PveMode, GUIAnnouncements, DiscordMessages, ZoneManager, RaidableBases;
const bool en = true;
static Sputnik ins;
EventClass eventClass;
static Dictionary<string, List<EntData>> saveData;
Coroutine findSpawnPointsCorountine;
Coroutine autoEventCorountine;
HashSet<string> subscribeMethods = new HashSet<string> {
"OnCardSwipe", "CanHackCrate", "OnLootEntity", "CanLootEntity", "OnEntityTakeDamage", "OnEntityDeath", "OnPlayerSleep", "OnCorpsePopulate", "OnTrapTrigger", "OnTurretTarget", "CanHelicopterTarget", "OnCustomNpcTarget", "CanPopulateLoot", "OnCustomLootContainer", "CanEntityTakeDamage", "CanEntityTrapTrigger", "CanEntityBeTargeted"
}
;
#endregion Variables
#region Hooks
void Init() => Unsubscribes();
void OnServerInitialized() {
ins = this;
PostLoadCheck();
UpdateConfig();
LoadDefaultMessages();
LoadData();
FindNewEventPoints();
if (_config.mainConfig.isAutoEvent) autoEventCorountine = ServerMgr.Instance.StartCoroutine(AutoEventCorountine());
}
void Unload() {
StopEvent();
if (findSpawnPointsCorountine != null) ServerMgr.Instance.StopCoroutine(findSpawnPointsCorountine);
if (autoEventCorountine != null) ServerMgr.Instance.StopCoroutine(autoEventCorountine);
}
object OnCardSwipe(CardReader cardReader, Keycard keycard, BasePlayer player) {
if (eventClass == null || player == null || cardReader == null || keycard == null) return null;
Item keyCardItem = keycard.GetItem();
if (keyCardItem == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCardReaderUid(cardReader.net.ID.Value);
if (sputnikClass == null) return null;
if (!sputnikClass.IsSputnikAgressive()) {
sputnikClass.MakeSputnikAgressive();
return true;
}
if (keyCardItem.info.shortname == ins._config.customCardConfig.shortName && keyCardItem.skin == ins._config.customCardConfig.skinID) {
if (sputnikClass != null && !sputnikClass.cardReaderOpen) {
keyCardItem.LoseCondition(_config.customCardConfig.helthLossScale);
sputnikClass.cardReaderOpen = true;
return true;
}
else if (keyCardItem.skin != 0) {
return true;
}
}
else if (sputnikClass != null) {
InformPlayer(player, "NeedUseCard", _config.prefix);
}
return true;
}
object CanHackCrate(BasePlayer player, HackableLockedCrate crate) {
if (eventClass == null || player == null || crate == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCrateUid(crate.net.ID.Value);
if (sputnikClass != null) {
if (!sputnikClass.IsSputnikAgressive()) {
sputnikClass.MakeSputnikAgressive();
return true;
}
if (!sputnikClass.CanOpenCrate(crate.net.ID.Value)) {
InformPlayer(player, "NeedUseCard", _config.prefix);
return true;
}
else ActionEconomy(player.userID, "LockedCrate");
}
return null;
}
void OnLootEntity(BasePlayer player, LootContainer container) {
if (eventClass == null || player == null || container == null) return;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCrateUid(container.net.ID.Value);
if (sputnikClass != null) {
sputnikClass.MakeSputnikAgressive();
sputnikClass.OnCratelooted(container.net.ID.Value);
ActionEconomy(player.userID, "Crates", container.PrefabName);
}
}
object CanLootEntity(BasePlayer player, LootContainer container) {
if (eventClass == null || player == null || container == null || container.net == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCrateUid(container.net.ID.Value);
if (sputnikClass != null) {
if (!sputnikClass.IsSputnikAgressive()) {
sputnikClass.MakeSputnikAgressive();
return true;
}
if (!sputnikClass.CanOpenCrate(container.net.ID.Value)) {
InformPlayer(player, "NeedUseCard", _config.prefix);
return true;
}
}
return null;
}
void OnLootSpawn(LootContainer container) {
if (!_config.customCardConfig.enableSpawnInDefaultCrates || container == null || container.inventory == null) return;
float chance = 0;
if (!_config.customCardConfig.spawnSetting.TryGetValue(container.PrefabName, out chance) || chance == 0) return;
if (UnityEngine.Random.Range(0f, 100f) <= chance) {
Item item = CreateCustomCardItem();
container.inventory.Remove(container.inventory.itemList.FirstOrDefault(x => true));
if (!item.MoveToContainer(container.inventory)) item.Remove();
}
}
object OnEntityTakeDamage(ScientistNPC scientistNPC, HitInfo info) {
if (eventClass == null || scientistNPC == null || info == null || info.Initiator == null) return null;
NpcConfig npcConfig = _config.npcConfigs.FirstOrDefault(x => x.name == scientistNPC.displayName);
if (npcConfig == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByNpcUid(scientistNPC.net.ID.Value);
if (sputnikClass != null && info.InitiatorPlayer.IsRealPlayer()) {
sputnikClass.MakeSputnikAgressive();
}
AutoTurret autoTurret = info.Initiator as AutoTurret;
if (autoTurret == null) return null;
if (eventClass.GetSputnikClassByTurretUid(autoTurret.net.ID.Value) != null) return true;
return null;
}
object OnEntityTakeDamage(AutoTurret autoTurret, HitInfo info) {
if (eventClass == null || autoTurret == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByTurretUid(autoTurret.net.ID.Value);
if (sputnikClass != null) {
if (info.InitiatorPlayer.IsRealPlayer()) sputnikClass.MakeSputnikAgressive();
}
return null;
}
void OnEntityTakeDamage(PatrolHelicopter patrolHelicopter, HitInfo info) {
if (eventClass == null || patrolHelicopter == null || patrolHelicopter.net == null) return;
SputnikClass sputnikClass = eventClass.GetSputnikClassByHeliUid(patrolHelicopter.net.ID.Value);
if (sputnikClass != null) {
if (info.InitiatorPlayer.IsRealPlayer()) sputnikClass.MakeSputnikAgressive();
}
}
void OnEntityDeath(ScientistNPC scientistNPC, HitInfo info) {
if (eventClass == null || scientistNPC == null || info == null) return;
if (info.InitiatorPlayer.IsRealPlayer() && _config.npcConfigs.Any(x => x != null && x.name == scientistNPC.displayName)) ActionEconomy(info.InitiatorPlayer.userID, "Npc");
}
void OnEntityDeath(BasePlayer player, HitInfo info) {
OnPlayerSleep(player);
}
void OnPlayerSleep(BasePlayer player) {
if (eventClass == null || !player.IsRealPlayer()) return;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromPLayerInZoneUid(player.userID);
if (sputnikClass != null) {
sputnikClass.RemovePlayerFromZone(player);
}
}
void OnCorpsePopulate(BasePlayer entity, NPCPlayerCorpse corpse) {
if (eventClass != null || entity == null || corpse == null) return;
if (entity is ScientistNPC) {
NpcConfig npcConfig = _config.npcConfigs.FirstOrDefault(x => x.name == entity.displayName);
if (npcConfig == null) return;
NextTick(() => {
if (corpse == null) return;
ItemContainer container = corpse.containers[0];
if (npcConfig.typeLootTable == 0) {
for (int i = container.itemList.Count - 1; i >= 0; i--) {
Item item = container.itemList[i];
if (npcConfig.wearItems.Any(x => x.shortName == item.info.shortname)) {
item.RemoveFromContainer();
item.Remove();
}
}
if (npcConfig.deleteCorpse && corpse != null && !corpse.IsDestroyed) corpse.Kill();
return;
}
if (npcConfig.typeLootTable == 2 || npcConfig.typeLootTable == 3) {
if (npcConfig.deleteCorpse && !corpse.IsDestroyed) corpse.Kill();
return;
}
container.ClearItemsContainer();
if (npcConfig.typeLootTable == 1 && npcConfig.lootTable.minAmount > 0) AddToContainerItem(container, npcConfig.lootTable, npcConfig.typeLootTable);
if (npcConfig.deleteCorpse && corpse != null && !corpse.IsDestroyed) corpse.Kill();
}
);
}
}
object OnTrapTrigger(BaseTrap baseTrap, GameObject gameObject) {
if (baseTrap == null) return null;
ScientistNPC scientistNPC = gameObject.ToBaseEntity() as ScientistNPC;
if (scientistNPC != null && _config.npcConfigs.Any(x => x.name == scientistNPC.displayName)) return true;
return null;
}
object OnTurretTarget(AutoTurret turret, BasePlayer player) {
if (eventClass == null || !turret.IsExists() || player == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByTurretUid(turret.net.ID.Value);
if (sputnikClass != null) {
if (!player.IsRealPlayer()) return true;
if (!sputnikClass.IsSputnikAgressive() && !_config.agressiveConfig.turretAgressiveMode) return true;
}
return null;
}
object CanHelicopterTarget(PatrolHelicopterAI heli, BasePlayer player) {
if (eventClass == null || heli == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByHeliUid(heli.helicopterBase.net.ID.Value);
if (sputnikClass != null) {
if (!player.IsRealPlayer()) return false;
if (!sputnikClass.IsSputnikAgressive() && !_config.agressiveConfig.heliAgressiveMode) return false;
return null;
}
return null;
}
#region OtherPlugins
object OnCustomNpcTarget(ScientistNPC npc, BasePlayer player) {
if (eventClass == null || npc == null || npc.net == null) return null;
if (!_config.npcConfigs.Any(x => x.name == npc.displayName)) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByNpcUid(npc.net.ID.Value);
if (sputnikClass != null) {
if (!sputnikClass.IsSputnikAgressive() && !_config.agressiveConfig.npcAgressiveMode) return false;
}
return null;
}
object CanPopulateLoot(ScientistNPC entity, NPCPlayerCorpse corpse) {
if (eventClass == null || entity == null || corpse == null) return null;
NpcConfig npcConfig = _config.npcConfigs.FirstOrDefault(x => x.name == entity.displayName);
if (npcConfig != null && npcConfig.typeLootTable != 2) return true;
return null;
}
object CanPopulateLoot(LootContainer container) {
if (eventClass == null || container == null) return null;
string cratePresetName = null;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCrateUid(container.net.ID.Value);
if (sputnikClass == null) return null;
if (container is HackableLockedCrate) {
if (sputnikClass.lockedCrates.Any(y => y.Key != null && y.Key.net.ID == container.net.ID)) cratePresetName = sputnikClass.lockedCrates[container];
}
else if (sputnikClass.crates.Any(y => y.Key != null && y.Key.net.ID == container.net.ID)) cratePresetName = sputnikClass.crates[container];
if (cratePresetName == null) return null;
CrateConfig crateConfig = _config.crateConfigs.FirstOrDefault(x => x.presetName == cratePresetName);
if (crateConfig != null && crateConfig.typeLootTable != 2) return true;
return null;
}
object OnCustomLootContainer(NetworkableId netID) {
if (eventClass == null || netID == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassFromCrateUid(netID.Value);
if (sputnikClass == null) return null;
string cratePresetName = null;
if (sputnikClass.lockedCrates.Any(y => y.Key != null && y.Key.net.ID.Value == netID.Value)) cratePresetName = sputnikClass.lockedCrates.FirstOrDefault(y => y.Key != null && y.Key.net.ID.Value == netID.Value).Value;
else if (sputnikClass.crates.Any(y => y.Key != null && y.Key.net.ID.Value == netID.Value)) cratePresetName = sputnikClass.crates.FirstOrDefault(y => y.Key != null && y.Key.net.ID.Value == netID.Value).Value;
if (cratePresetName == null) return null;
CrateConfig crateConfig = _config.crateConfigs.FirstOrDefault(x => x.presetName == cratePresetName);
if (crateConfig != null && crateConfig.typeLootTable != 3) return true;
return null;
}
object CanEntityTakeDamage(AutoTurret autoTurret, HitInfo hitinfo) {
if (eventClass == null || autoTurret == null || hitinfo == null) return null;
if (eventClass.GetSputnikClassByTurretUid(autoTurret.net.ID.Value) != null) {
if (hitinfo.InitiatorPlayer == null || !hitinfo.InitiatorPlayer.IsRealPlayer()) return false;
else return true;
}
return null;
}
object CanEntityTakeDamage(Landmine landmine, HitInfo hitinfo) {
if (eventClass == null || landmine == null || hitinfo == null) return null;
if (eventClass.GetSputnikClassByMineUid(landmine.net.ID.Value) != null) {
if (hitinfo.InitiatorPlayer == null || !hitinfo.InitiatorPlayer.IsRealPlayer()) return false;
else return true;
}
return null;
}
object CanEntityTakeDamage(ScientistNPC scientistNPC, HitInfo hitinfo) {
if (eventClass == null || scientistNPC == null || hitinfo == null || hitinfo.Initiator == null) return null;
NpcConfig npcConfig = _config.npcConfigs.FirstOrDefault(x => x.name == scientistNPC.displayName);
if (npcConfig == null) return null;
AutoTurret autoTurret = hitinfo.Initiator as AutoTurret;
if (autoTurret == null) return null;
if (eventClass.GetSputnikClassByTurretUid(autoTurret.net.ID.Value) != null) return false;
return null;
}
object CanEntityTakeDamage(BasePlayer victim, HitInfo hitinfo) {
if (eventClass == null || victim == null || hitinfo == null || !victim.userID.IsSteamId()) return null;
BasePlayer attacker = hitinfo.InitiatorPlayer;
if (attacker != null) {
SputnikClass sputnikClass = eventClass.GetSputnikClassFromPLayerInZoneUid(victim.userID);
if (sputnikClass != null && sputnikClass.sputnikDebrisConfig.zoneConfig.isCreateZonePVP && (attacker == null || (attacker != null && eventClass.GetSputnikClassFromPLayerInZoneUid(attacker.userID) != null))) return true;
}
else if (hitinfo.Initiator != null) {
AutoTurret autoTurret = hitinfo.Initiator as AutoTurret;
if (autoTurret != null) {
if (eventClass.GetSputnikClassByTurretUid(autoTurret.net.ID.Value) != null) return true;
return null;
}
BaseTrap baseTrap = hitinfo.Initiator as BaseTrap;
if (baseTrap != null) {
if (eventClass.GetSputnikClassByMineUid(baseTrap.net.ID.Value) != null) return true;
return null;
}
}
return null;
}
object CanEntityTrapTrigger(BaseTrap trap, BasePlayer player) {
if (eventClass == null || trap == null || !player.IsRealPlayer()) return null;
if (eventClass.GetSputnikClassByMineUid(trap.net.ID.Value) != null) return true;
return null;
}
object CanEntityBeTargeted(BasePlayer player, BaseEntity turret) {
if (eventClass == null || turret == null || turret.net == null) return null;
SputnikClass sputnikClass = eventClass.GetSputnikClassByTurretUid(turret.net.ID.Value);
if (sputnikClass != null) {
if (!player.IsRealPlayer()) return false;
if (!sputnikClass.IsSputnikAgressive() && !_config.agressiveConfig.turretAgressiveMode) return false;
else return true;
}
return null;
}
#endregion OtherPlugins
#endregion Hooks
#region Commands
[ChatCommand("sputnikstart")]
void ChatStartCommand(BasePlayer player, string command, string[] arg) {
if (!player.IsAdmin) return;
if (arg != null && arg.Length >= 1) StartEvent(arg[0], player);
else StartEvent(activator : player);
}
[ChatCommand("sputnikstop")]
void ChatStopCommand(BasePlayer player, string command, string[] arg) {
if (!player.IsAdmin) return;
StopEvent();
}
[ConsoleCommand("sputnikstart")]
void ConsoleStartCommand(ConsoleSystem.Arg arg) {
if (arg.Player() != null) return;
if (arg.Args != null && arg.Args.Length > 0) StartEvent(arg.Args[0]);
StartEvent();
Puts("Event activated");
}
[ConsoleCommand("sputnikstop")]
void ConsoleStopCommand(ConsoleSystem.Arg arg) {
if (arg.Player() == null) StopEvent();
}
[ChatCommand("givespacecard")]
void GiveCustomItemChatCommand(BasePlayer player, string command, string[] arg) {
if (player == null || !player.IsAdmin || arg == null) return;
MoveItem(player, CreateCustomCardItem());
PrintToChat(player, GetMessage("GetSpaceCard", player.UserIDString, _config.prefix));
}
[ConsoleCommand("givespacecard")]
void GiveCustomItemCommand(ConsoleSystem.Arg arg) {
BasePlayer player = arg.Player();
BasePlayer target = null;
if (arg.Args.Length >= 1) target = BasePlayer.FindByID(Convert.ToUInt64(arg.Args[0]));
if (target == null) {
PrintToConsole(player, "Player not found");
return;
}
MoveItem(target, CreateCustomCardItem());
PrintToChat(target, GetMessage("GetSpaceCard", target.UserIDString, _config.prefix));
Puts($"A space card was given to {target.displayName}");
}
[ChatCommand("sputnikspawnpoint")]
void SpawnPointCommand(BasePlayer player, string command, string[] arg) {
if (!player.IsAdmin) return;
if (arg.Length <= 0) {
PrintToChat(player, _config.prefix + " Use the command: /sputnikspawnpoint <DebrisPresetName>");
return;
}
SputnikDebrisConfig sputnikDebrisConfig = _config.sputnikDebrisConfigs.FirstOrDefault(x => x.presetName == arg[0]);
if (sputnikDebrisConfig == null) {
PrintToChat(player, _config.prefix + " <color=#ce3f27>Couldn't</color> find the preset");
return;
}
sputnikDebrisConfig.customSpawnPoints.Add(player.transform.position.ToString());
SaveConfig();
PrintToChat(player, _config.prefix + " New spawn point <color=#738d43>successfully</color> added");
}
#endregion Commands
#region Methods
void PostLoadCheck() {
if (!plugins.Exists("NpcSpawn")) {
PrintError("NpcSpawn plugin doesn`t exist! Please read the file ReadMe.txt");
NextTick(() => Server.Command($"o.unload {Name}"));
return;
}
}
void UpdateConfig() {
if (_config.version == Version) return;
if (_config.version.Minor == 0) {
if (_config.version.Patch <= 2) {
_config.supportedPluginsConfig.zoneManager = new ZoneManagerConfig {
enable = false, blockFlags = new HashSet<string> {
"eject", "pvegod"
}
}
;
}
if (_config.version.Patch <= 3) {
_config.supportedPluginsConfig.raidableBases = new RaidableBasesConfig();
_config.spawnConfig.minTCDistance = 25;
_config.mainConfig.destroyAfterLootingTime = 300;
}
if (_config.version.Patch <= 8) {
_config.supportedPluginsConfig.pveMode.scaleDamage.Add(new ScaleDamageConfig {
Type = "Helicopter", Scale = 1
}
);
}
_config.version = new VersionNumber(1, 1, 0);
}
if (_config.version.Minor == 1) {
if (_config.version.Patch <= 2) {
_config.agressiveConfig = new AgressiveConfig {
agressiveSecurityMode = true, agressiveTime = 120, npcAgressiveMode = true, turretAgressiveMode = true, heliAgressiveMode = false,
}
;
foreach (SputnikDebrisConfig sputnikDebrisConfig in _config.sputnikDebrisConfigs) {
sputnikDebrisConfig.useCustomSpawnPoints = false;
sputnikDebrisConfig.customSpawnPoints = new List<string>();
}
}
_config.version = new VersionNumber(1, 2, 0);
}
if (_config.version.Minor == 2) {
if (_config.version.Patch == 0) {
foreach (HeliConfig heliConfig in _config.heliConfigs) {
heliConfig.outsideTime = 60;
}
}
if (_config.version.Patch <= 1) {
foreach (SputnikDebrisConfig sputnikDebrisConfig in _config.sputnikDebrisConfigs) {
sputnikDebrisConfig.markerConfig.useRingMarker = true;
sputnikDebrisConfig.markerConfig.useShopMarker = true;
}
_config.supportedPluginsConfig.pveMode.showEventOwnerNameOnMap = true;
}
}
_config.version = Version;
SaveConfig();
}
void LoadData() {
saveData = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, List<EntData>>>(ins.Title);
if (saveData == null || saveData.Count == 0) {
PrintError("Data file not found");
NextTick(() => Server.Command($"o.unload {Name}"));
}
}
void Unsubscribes() {
foreach (string hook in subscribeMethods) Unsubscribe(hook);
if (!_config.customCardConfig.enableSpawnInDefaultCrates) Unsubscribe("OnLootSpawn");
}
void Subscribes() {
foreach (string hook in subscribeMethods) Subscribe(hook);
}
void StartEvent(string presetName = "", BasePlayer activator = null) {
if (eventClass != null) {
SendErrorMessage(GetMessage("EventActive", activator != null ? activator.UserIDString : null, _config.prefix), activator);
return;
}
StopEvent();
EventConfig eventConfig = DefineEventConfig(presetName);
if (eventConfig == null) {
SendErrorMessage("Event preset not found!", activator);
return;
}
if (autoEventCorountine != null) ServerMgr.Instance.StopCoroutine(autoEventCorountine);
LocationDefiner.CacheBuildingPrivilegeLocations();
eventClass = new EventClass();
eventClass.StartEvent(eventConfig);
Interface.CallHook("OnSputnikEventStart");
if (ins._config.mainConfig.enableStartStopLogs) PrintLogMessage("EventStart_Log", eventConfig.presetName);
}
void StopEvent() {
if (eventClass != null) {
if (autoEventCorountine != null) ServerMgr.Instance.StopCoroutine(autoEventCorountine);
if (_config.mainConfig.isAutoEvent) autoEventCorountine = ServerMgr.Instance.StartCoroutine(AutoEventCorountine());
eventClass.StopEvent();
eventClass = null;
FindNewEventPoints();
InformAllPlayers("EndEvent", _config.prefix);
Interface.CallHook("OnSputnikEventStop");
DefineEventWinner();
SendBalance();
Unsubscribes();
if (ins._config.mainConfig.enableStartStopLogs) PrintLogMessage("EventStop_Log");
}
}
EventConfig DefineEventConfig(string presetName) {
if (presetName != "") {
return ins._config.eventConfigs.FirstOrDefault(x => x.presetName.Contains(presetName));
}
else if (ins._config.eventConfigs.Any(x => x.chance > 0)) {
while (true) {
foreach (EventConfig checkEventConfig in ins._config.eventConfigs) {
float chance = UnityEngine.Random.Range(0, 100);
if (chance <= checkEventConfig.chance) {
return checkEventConfig;
}
}
}
}
return null;
}
void FindNewEventPoints() {
if (findSpawnPointsCorountine != null) ServerMgr.Instance.StopCoroutine(findSpawnPointsCorountine);
findSpawnPointsCorountine = ServerMgr.Instance.StartCoroutine(LocationDefiner.FindSpawnPosition());
}
IEnumerator AutoEventCorountine() {
yield return CoroutineEx.waitForSeconds(UnityEngine.Random.Range(_config.mainConfig.minTimeBetweenEvent, _config.mainConfig.maxTimeBetweenEvent));
StartEvent();
}
void AddToContainerItem(ItemContainer container, LootTableConfig lootTableConfig, int typeOfLootTable) {
if (typeOfLootTable == 1) container.ClearItemsContainer();
int CountLootInContainer = 0;
int countLoot = UnityEngine.Random.Range(lootTableConfig.minAmount, lootTableConfig.maxAmount);
if (typeOfLootTable == 4) container.capacity += countLoot;
else container.capacity = countLoot;
for (; CountLootInContainer < countLoot;) {
foreach (ItemConfig item in lootTableConfig.itemsConfig) {
if (UnityEngine.Random.Range(0.0f, 100.0f) <= item.chance) {
int amount = UnityEngine.Random.Range(item.minAmount, item.maxAmount);
Item newItem = item.isBluePrint ? ItemManager.CreateByName("blueprintbase") : ItemManager.CreateByName(item.shortName, amount, item.skinID);
if (item.isBluePrint) newItem.blueprintTarget = ItemManager.FindItemDefinition(item.shortName).itemid;
if (item.name != "") newItem.name = item.name;
if (!newItem.MoveToContainer(container)) newItem.Remove();
if (CountLootInContainer == countLoot) return;
CountLootInContainer++;
}
}
}
}
#region MoveItem
void MoveItem(BasePlayer player, Item item) {
int spaceCountItem = GetSpaceCountItem(player, item.info.shortname, item.MaxStackable(), item.skin);
int inventoryItemCount;
if (spaceCountItem > item.amount) inventoryItemCount = item.amount;
else inventoryItemCount = spaceCountItem;
if (inventoryItemCount > 0) {
Item itemInventory = ItemManager.CreateByName(item.info.shortname, inventoryItemCount, item.skin);
if (item.skin != 0) itemInventory.name = item.name;
item.amount -= inventoryItemCount;
MoveInventoryItem(player, itemInventory);
}
if (item.amount > 0) MoveOutItem(player, item);
}
int GetSpaceCountItem(BasePlayer player, string shortname, int stack, ulong skinID) {
int slots = player.inventory.containerMain.capacity + player.inventory.containerBelt.capacity;
int taken = player.inventory.containerMain.itemList.Count + player.inventory.containerBelt.itemList.Count;
int result = (slots - taken) * stack;
foreach (Item item in player.inventory.AllItems()) if (item.info.shortname == shortname && item.skin == skinID && item.amount < stack) result += stack - item.amount;
return result;
}
void MoveInventoryItem(BasePlayer player, Item item) {
if (item.amount <= item.MaxStackable()) {
foreach (Item itemInv in player.inventory.AllItems()) {
if (itemInv.info.shortname == item.info.shortname && itemInv.skin == item.skin && itemInv.amount < itemInv.MaxStackable()) {
if (itemInv.amount + item.amount <= itemInv.MaxStackable()) {
itemInv.amount += item.amount;
itemInv.MarkDirty();
return;
}
else {
item.amount -= itemInv.MaxStackable() - itemInv.amount;
itemInv.amount = itemInv.MaxStackable();
}
}
}
if (item.amount > 0) player.inventory.GiveItem(item);
}
else {
while (item.amount > item.MaxStackable()) {
Item thisItem = ItemManager.CreateByName(item.info.shortname, item.MaxStackable(), item.skin);
if (item.skin != 0) thisItem.name = item.name;
player.inventory.GiveItem(thisItem);
item.amount -= item.MaxStackable();
}
if (item.amount > 0) player.inventory.GiveItem(item);
}
}
void MoveOutItem(BasePlayer player, Item item) {
if (item.amount <= item.MaxStackable()) item.Drop(player.transform.position, Vector3.up);
else {
while (item.amount > item.MaxStackable()) {
Item thisItem = ItemManager.CreateByName(item.info.shortname, item.MaxStackable(), item.skin);
if (item.skin != 0) thisItem.name = item.name;
thisItem.Drop(player.transform.position, Vector3.up);
item.amount -= item.MaxStackable();
}
if (item.amount > 0) item.Drop(player.transform.position, Vector3.up);
}
}
Item CreateCustomCardItem() {
Item item = ItemManager.CreateByName(_config.customCardConfig.shortName, 1, _config.customCardConfig.skinID);
if (_config.customCardConfig.name != "") item.name = _config.customCardConfig.name;
return item;
}
#endregion MoveItem
#region Notify
void SendErrorMessage(string message, BasePlayer player = null) {
if (player != null) PrintToChat(player, message);
else PrintError(message);
}
void PrintLogMessage(string langKey, params object[] args) {
ins.Puts(ClearColorAndSize(GetMessage(langKey, null, args)));
}
void InformAllPlayers(string langKey, params object[] args) {
foreach (BasePlayer player in BasePlayer.activePlayerList) if (player != null) InformPlayer(player, langKey, args);
SendDiscordMessage(langKey, args);
}
void InformPlayer(BasePlayer player, string langKey, params object[] args) {
if (_config.notifyConfig.chat) PrintToChat(player, GetMessage(langKey, player.UserIDString, args));
if (_config.supportedPluginsConfig.GUIAnnouncements.isGUIAnnouncements) GUIAnnouncements?.Call("CreateAnnouncement", ClearColorAndSize(GetMessage(langKey, player.UserIDString, args)), _config.supportedPluginsConfig.GUIAnnouncements.bannerColor, _config.supportedPluginsConfig.GUIAnnouncements.textColor, player, _config.supportedPluginsConfig.GUIAnnouncements.apiAdjustVPosition);
if (_config.supportedPluginsConfig.notify.isNotify) player.SendConsoleCommand($"notify.show {_config.supportedPluginsConfig.notify.type} {ClearColorAndSize(GetMessage(langKey, player.UserIDString, args))}");
}
void SendDiscordMessage(string langKey, params object[] args) {
if (CanSendDiscordMessage() && _config.supportedPluginsConfig.discord.keys.Contains(langKey)) {
object fields = new[] {
new {
name = Title, value = ClearColorAndSize(GetMessage(langKey, null, args)), inline = false
}
}
;
DiscordMessages?.Call("API_SendFancyMessage", _config.supportedPluginsConfig.discord.webhookUrl, "", _config.supportedPluginsConfig.discord.embedColor, JsonConvert.SerializeObject(fields), null, this);
}
}
string ClearColorAndSize(string message) {
message = message.Replace("</color>", string.Empty);
message = message.Replace("</size>", string.Empty);
while (message.Contains("<color=")) {
int index = message.IndexOf("<color=");
message = message.Remove(index, message.IndexOf(">", index) - index + 1);
}
while (message.Contains("<size=")) {
int index = message.IndexOf("<size=");
message = message.Remove(index, message.IndexOf(">", index) - index + 1);
}
return message;
}
private bool CanSendDiscordMessage() => _config.supportedPluginsConfig.discord.isDiscord && !string.IsNullOrEmpty(_config.supportedPluginsConfig.discord.webhookUrl) && _config.supportedPluginsConfig.discord.webhookUrl != "https://support.discordapp.com/hc/en-us/articles/228383668-Intro-to-Webhooks";
string GetTimeMessage(string userIDString, int seconds) {
string message = "";
TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
if (timeSpan.Hours > 0) message += $" {timeSpan.Hours} {GetMessage("Hour", userIDString)}";
if (timeSpan.Minutes > 0) message += $" {timeSpan.Minutes} {GetMessage("Min", userIDString)}";
if (message == "") message += $" {timeSpan.Seconds} {GetMessage("Sec", userIDString)}";
return message;
}
#endregion Notify
#region Economy
[PluginReference]
readonly Plugin Economics, ServerRewards, IQEconomic;
readonly Dictionary<ulong, double> _playersBalance = new Dictionary<ulong, double>();
void ActionEconomy(ulong playerId, string type, string arg = "") {
switch (type) {
case "Crates" : double economyCrateData;
if (_config.supportedPluginsConfig.economy.crates.TryGetValue(arg, out economyCrateData)) AddBalance(playerId, economyCrateData);
break;
case "Npc" : AddBalance(playerId, _config.supportedPluginsConfig.economy.npcPoint);
break;
case "LockedCrate" : AddBalance(playerId, _config.supportedPluginsConfig.economy.lockedCratePoint);
break;
case "Turret" : AddBalance(playerId, _config.supportedPluginsConfig.economy.turretPoint);
break;
case "Heli" : AddBalance(playerId, _config.supportedPluginsConfig.economy.heliPoint);
break;
}
}
void AddBalance(ulong playerId, double balance) {
if (balance == 0) return;
if (_playersBalance.ContainsKey(playerId)) _playersBalance[playerId] += balance;
else _playersBalance.Add(playerId, balance);
}
void SendBalance() {
if (!_config.supportedPluginsConfig.economy.enable || _playersBalance.Count == 0) {
_playersBalance.Clear();
return;
}
foreach (KeyValuePair<ulong, double> dic in _playersBalance) {
if (dic.Value < _config.supportedPluginsConfig.economy.minEconomyPiont) continue;
int intCount = Convert.ToInt32(dic.Value);
if (_config.supportedPluginsConfig.economy.plugins.Contains("Economics") && plugins.Exists("Economics") && dic.Value > 0) Economics.Call("Deposit", dic.Key.ToString(), dic.Value);
if (_config.supportedPluginsConfig.economy.plugins.Contains("Server Rewards") && plugins.Exists("ServerRewards") && intCount > 0) ServerRewards.Call("AddPoints", dic.Key, intCount);
if (_config.supportedPluginsConfig.economy.plugins.Contains("IQEconomic") && plugins.Exists("IQEconomic") && intCount > 0) IQEconomic.Call("API_SET_BALANCE", dic.Key, intCount);
BasePlayer player = BasePlayer.FindByID(dic.Key);
if (player != null) InformPlayer(player, "SendEconomy", _config.prefix, dic.Value);
}
double max = 0;
ulong winnerId = 0;
foreach (var a in _playersBalance) {
if (a.Value > max) {
max = a.Value;
winnerId = a.Key;
}
}
if (max >= _config.supportedPluginsConfig.economy.minCommandPoint) foreach (string command in _config.supportedPluginsConfig.economy.commands) Server.Command(command.Replace("{steamid}", $"{winnerId}"));
_playersBalance.Clear();
}
void DefineEventWinner() {
var winnerPair = _playersBalance.Max(x => (float)x.Value);
if (winnerPair.Value > 0) Interface.CallHook("OnSputnikEventWin", winnerPair.Key);
}
#endregion Economy
#endregion Methods
#region Classes
class EventClass {
EventConfig eventConfig;
Coroutine startEventCorountine;
Coroutine eventCorountine;
HashSet<SputnikClass> sputnikClasses = new HashSet<SputnikClass>();
internal int eventTime;
internal SputnikClass GetSputnikClassFromPLayerInZoneUid(ulong userId) => sputnikClasses.FirstOrDefault(x => x != null && x.IsPlayerInZone(userId));
internal SputnikClass GetSputnikClassFromCrateUid(ulong crateUID) => sputnikClasses.FirstOrDefault(x => x != null && (x.IsEventCrate(crateUID) || x.IsEventLockedCrate(crateUID)));
internal SputnikClass GetSputnikClassFromCardReaderUid(ulong cardReaderUID) => sputnikClasses.FirstOrDefault(x => x != null && x.IsClassCardReader(cardReaderUID));
internal SputnikClass GetSputnikClassByTurretUid(ulong netID) => sputnikClasses.FirstOrDefault(x => x != null && x.IsDebrisTurret(netID));
internal SputnikClass GetSputnikClassByMineUid(ulong netID) => sputnikClasses.FirstOrDefault(x => x != null && x.IsDebrisMine(netID));
internal SputnikClass GetSputnikClassByNpcUid(ulong netID) => sputnikClasses.FirstOrDefault(x => x != null && x.IsNpcMine(netID));
internal SputnikClass GetSputnikClassByHeliUid(ulong netID) => sputnikClasses.FirstOrDefault(x => x != null && x.IsHeliMine(netID));
internal void StartEvent(EventConfig eventConfig) {
this.eventConfig = eventConfig;
eventTime = eventConfig.eventTime;
startEventCorountine = ServerMgr.Instance.StartCoroutine(StartEventCorountine());
}
internal void StopEvent() {
foreach (SputnikClass sputnikClass in sputnikClasses) {
if (sputnikClass != null && sputnikClass.gameObject != null) UnityEngine.Object.DestroyImmediate(sputnikClass.gameObject);
}
if (startEventCorountine != null) ServerMgr.Instance.StopCoroutine(startEventCorountine);
if (eventCorountine != null) ServerMgr.Instance.StopCoroutine(eventCorountine);
}
IEnumerator StartEventCorountine() {
if (ins._config.notifyConfig.preStartTime > 0) {
foreach (BasePlayer player in BasePlayer.activePlayerList) if (player != null) ins.InformPlayer(player, "PreStartEvent", ins._config.prefix, eventConfig.displayName, ins.GetTimeMessage(player.UserIDString, ins._config.notifyConfig.preStartTime));
ins.SendDiscordMessage("PreStartEvent", ins._config.prefix, eventConfig.displayName, ins.GetTimeMessage(null, ins._config.notifyConfig.preStartTime));
}
yield return CoroutineEx.waitForSeconds(ins._config.notifyConfig.preStartTime);
if (ins.autoEventCorountine != null) ServerMgr.Instance.StopCoroutine(ins.autoEventCorountine);
ins.InformAllPlayers("StartEvent", ins._config.prefix, eventConfig.displayName);
CreateNewSputnikClasses();
eventCorountine = ServerMgr.Instance.StartCoroutine(EventCorountine());
ins.Subscribes();
}
IEnumerator EventCorountine() {
while (eventTime > 0 && sputnikClasses.Any(x => x != null)) {
eventTime -= 1;
if (ins._config.notifyConfig.chat && ins._config.notifyConfig.timeNotifications.Contains(eventTime)) {
foreach (BasePlayer player in BasePlayer.activePlayerList) {
if (player != null) ins.PrintToChat(player, ins.GetMessage("RemainTime", player.UserIDString, ins._config.prefix, eventConfig.displayName, ins.GetTimeMessage(player.UserIDString, eventTime)));
}
}
foreach (SputnikClass sputnikClass in sputnikClasses) sputnikClass.UpdateZone();
yield return CoroutineEx.waitForSeconds(1);
}
ins.StopEvent();
}
void CreateNewSputnikClasses() {
if (eventConfig.fixedSputniksPresets != null && eventConfig.fixedSputniksPresets.Count > 0) {
foreach (string sputnikDebrisPresetName in eventConfig.fixedSputniksPresets) {
SputnikDebrisConfig sputnikDebrisConfig = ins._config.sputnikDebrisConfigs.FirstOrDefault(x => x.presetName == sputnikDebrisPresetName);
if (sputnikDebrisConfig == null) {
ins.PrintError("Sputnik debris preset not found!");
continue;
}
CreateNewSputnikClass(sputnikDebrisConfig);
}
}
if (sputnikClasses.Count == 0 || !sputnikClasses.Any(x => x != null)) ins.StopEvent();
}
void CreateNewSputnikClass(SputnikDebrisConfig sputnikDebrisConfig) {
GameObject gameObject = new GameObject();
gameObject.layer = (int)Layer.Reserved1;
SputnikClass sputnik = gameObject.AddComponent<SputnikClass>();
sputnik.Init(sputnikDebrisConfig);
sputnikClasses.Add(sputnik);
}
}
class SputnikClass : FacepunchBehaviour {
internal SputnikDebrisConfig sputnikDebrisConfig;
Coroutine crushEffectsCorountine;
Coroutine onSputnikFellCorountine;
Coroutine destroyCorountine;
Coroutine updateCorountine;
FallSputnikClass fallSputnik;
MapMarkerGenericRadius mapmarker;
VendingMachineMapMarker vendingMarker;
HashSet<BaseEntity> decorEntities = new HashSet<BaseEntity>();
HashSet<AutoTurret> turrets = new HashSet<AutoTurret>();
HashSet<BaseEntity> mines = new HashSet<BaseEntity>();
ZoneClass zoneClass;
CardReader cardReader;
internal SputnikHeli sputnikHeli;
internal bool cardReaderOpen = true;
internal HashSet<ScientistNPC> npcs = new HashSet<ScientistNPC>();
internal HashSet<ulong> openedCrates = new HashSet<ulong>();
internal Dictionary<LootContainer, string> crates = new Dictionary<LootContainer, string>();
internal Dictionary<LootContainer, string> lockedCrates = new Dictionary<LootContainer, string>();
internal HashSet<ulong> spaceCardCratesIDs = new HashSet<ulong>();
internal int destroyTime = 0;
internal int agressiveTime = 0;
float lastEventOvnerNameCheckTime = 0;
string eventOwnerName = "";
internal bool IsSputnikAgressive() {
return ins._config.agressiveConfig.agressiveSecurityMode || agressiveTime > 0;
}
internal void MakeSputnikAgressive() {
if (ins._config.agressiveConfig.agressiveSecurityMode) return;
agressiveTime = ins._config.agressiveConfig.agressiveTime;
}
internal bool IsClassCardReader(ulong netId) => cardReader != null && cardReader.net.ID.Value == netId;
internal bool CanOpenCrate(ulong netId)
// ... [Code preview truncated due to length. Full source in attached file] ...