389 lines
12 KiB
C#
389 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using Content.Server.Administration.Logs;
|
|
using Content.Server.GameTicking;
|
|
using Content.Server.StationEvents.Events;
|
|
using Content.Shared;
|
|
using Content.Shared.Administration.Logs;
|
|
using Content.Shared.CCVar;
|
|
using Content.Shared.Database;
|
|
using Content.Shared.GameTicking;
|
|
using Content.Shared.StationEvents;
|
|
using JetBrains.Annotations;
|
|
using Robust.Server.Console;
|
|
using Robust.Server.Player;
|
|
using Robust.Shared.Configuration;
|
|
using Robust.Shared.GameObjects;
|
|
using Robust.Shared.IoC;
|
|
using Robust.Shared.Localization;
|
|
using Robust.Shared.Network;
|
|
using Robust.Shared.Random;
|
|
using Robust.Shared.Reflection;
|
|
using Robust.Shared.Timing;
|
|
|
|
namespace Content.Server.StationEvents
|
|
{
|
|
[UsedImplicitly]
|
|
// Somewhat based off of TG's implementation of events
|
|
public sealed class StationEventSystem : EntitySystem
|
|
{
|
|
[Dependency] private readonly IConfigurationManager _configurationManager = default!;
|
|
[Dependency] private readonly IServerNetManager _netManager = default!;
|
|
[Dependency] private readonly IPlayerManager _playerManager = default!;
|
|
[Dependency] private readonly IConGroupController _conGroupController = default!;
|
|
[Dependency] private readonly GameTicker _gameTicker = default!;
|
|
[Dependency] private readonly IRobustRandom _random = default!;
|
|
|
|
[Dependency] private readonly AdminLogSystem _adminLog = default!;
|
|
|
|
public StationEvent? CurrentEvent { get; private set; }
|
|
public IReadOnlyCollection<StationEvent> StationEvents => _stationEvents;
|
|
|
|
private readonly List<StationEvent> _stationEvents = new();
|
|
|
|
private const float MinimumTimeUntilFirstEvent = 300;
|
|
|
|
/// <summary>
|
|
/// How long until the next check for an event runs
|
|
/// </summary>
|
|
/// Default value is how long until first event is allowed
|
|
private float _timeUntilNextEvent = MinimumTimeUntilFirstEvent;
|
|
|
|
/// <summary>
|
|
/// Whether random events can run
|
|
/// </summary>
|
|
/// If disabled while an event is running (even if admin run) it will disable it
|
|
public bool Enabled
|
|
{
|
|
get => _enabled;
|
|
set
|
|
{
|
|
if (_enabled == value)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_enabled = value;
|
|
CurrentEvent?.Shutdown();
|
|
CurrentEvent = null;
|
|
}
|
|
}
|
|
|
|
private bool _enabled = true;
|
|
|
|
/// <summary>
|
|
/// Admins can get a list of all events available to run, regardless of whether their requirements have been met
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string GetEventNames()
|
|
{
|
|
StringBuilder result = new StringBuilder();
|
|
|
|
foreach (var stationEvent in _stationEvents)
|
|
{
|
|
result.Append(stationEvent.Name + "\n");
|
|
}
|
|
|
|
return result.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Admins can forcibly run events by passing in the Name
|
|
/// </summary>
|
|
/// <param name="name">The exact string for Name, without localization</param>
|
|
/// <returns></returns>
|
|
public string RunEvent(string name)
|
|
{
|
|
_adminLog.Add(LogType.EventRan, LogImpact.High, $"Event run: {name}");
|
|
|
|
// Could use a dictionary but it's such a minor thing, eh.
|
|
// Wasn't sure on whether to localize this given it's a command
|
|
var upperName = name.ToUpperInvariant();
|
|
|
|
foreach (var stationEvent in _stationEvents)
|
|
{
|
|
if (stationEvent.Name.ToUpperInvariant() != upperName)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
CurrentEvent?.Shutdown();
|
|
CurrentEvent = stationEvent;
|
|
stationEvent.Announce();
|
|
return Loc.GetString("station-event-system-run-event", ("eventName", stationEvent.Name));
|
|
}
|
|
|
|
// I had string interpolation but lord it made it hard to read
|
|
return Loc.GetString("station-event-system-run-event-no-event-name", ("eventName", name));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Randomly run a valid event <b>immediately</b>, ignoring earlieststart
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string RunRandomEvent()
|
|
{
|
|
var randomEvent = PickRandomEvent();
|
|
|
|
if (randomEvent == null)
|
|
{
|
|
return Loc.GetString("station-event-system-run-random-event-no-valid-events");
|
|
}
|
|
|
|
CurrentEvent?.Shutdown();
|
|
CurrentEvent = randomEvent;
|
|
CurrentEvent.Startup();
|
|
|
|
return Loc.GetString("station-event-system-run-event",("eventName", randomEvent.Name));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Randomly picks a valid event.
|
|
/// </summary>
|
|
public StationEvent? PickRandomEvent()
|
|
{
|
|
var availableEvents = AvailableEvents(true);
|
|
return FindEvent(availableEvents);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Admins can stop the currently running event (if applicable) and reset the timer
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string StopEvent()
|
|
{
|
|
string resultText;
|
|
|
|
if (CurrentEvent == null)
|
|
{
|
|
resultText = Loc.GetString("station-event-system-stop-event-no-running-event");
|
|
}
|
|
else
|
|
{
|
|
resultText = Loc.GetString("station-event-system-stop-event", ("eventName", CurrentEvent.Name));
|
|
CurrentEvent.Shutdown();
|
|
CurrentEvent = null;
|
|
}
|
|
|
|
ResetTimer();
|
|
return resultText;
|
|
}
|
|
|
|
public override void Initialize()
|
|
{
|
|
base.Initialize();
|
|
var reflectionManager = IoCManager.Resolve<IReflectionManager>();
|
|
var typeFactory = IoCManager.Resolve<IDynamicTypeFactory>();
|
|
|
|
foreach (var type in reflectionManager.GetAllChildren(typeof(StationEvent)))
|
|
{
|
|
if (type.IsAbstract) continue;
|
|
|
|
var stationEvent = (StationEvent) typeFactory.CreateInstance(type);
|
|
IoCManager.InjectDependencies(stationEvent);
|
|
_stationEvents.Add(stationEvent);
|
|
}
|
|
|
|
// Can't just check debug / release for a default given mappers need to use release mode
|
|
// As such we'll always pause it by default.
|
|
_configurationManager.OnValueChanged(CCVars.EventsEnabled, value => Enabled = value, true);
|
|
|
|
_netManager.RegisterNetMessage<MsgRequestStationEvents>(RxRequest);
|
|
_netManager.RegisterNetMessage<MsgStationEvents>();
|
|
|
|
SubscribeLocalEvent<RoundRestartCleanupEvent>(Reset);
|
|
}
|
|
|
|
private void RxRequest(MsgRequestStationEvents msg)
|
|
{
|
|
if (_playerManager.TryGetSessionByChannel(msg.MsgChannel, out var player))
|
|
SendEvents(player);
|
|
}
|
|
|
|
private void SendEvents(IPlayerSession player)
|
|
{
|
|
if (!_conGroupController.CanCommand(player, "events"))
|
|
return;
|
|
|
|
var newMsg = _netManager.CreateNetMessage<MsgStationEvents>();
|
|
newMsg.Events = StationEvents.Select(e => e.Name).ToArray();
|
|
_netManager.ServerSendMessage(newMsg, player.ConnectedClient);
|
|
}
|
|
|
|
public override void Update(float frameTime)
|
|
{
|
|
base.Update(frameTime);
|
|
|
|
if (!Enabled && CurrentEvent == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Stop events from happening in lobby and force active event to end if the round ends
|
|
if (Get<GameTicker>().RunLevel != GameRunLevel.InRound)
|
|
{
|
|
if (CurrentEvent != null)
|
|
{
|
|
Enabled = false;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Keep running the current event
|
|
if (CurrentEvent != null)
|
|
{
|
|
CurrentEvent.Update(frameTime);
|
|
|
|
// Shutdown the event and set the timer for the next event
|
|
if (!CurrentEvent.Running)
|
|
{
|
|
CurrentEvent.Shutdown();
|
|
CurrentEvent = null;
|
|
ResetTimer();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Make sure we only count down when no event is running.
|
|
if (_timeUntilNextEvent > 0 && CurrentEvent == null)
|
|
{
|
|
_timeUntilNextEvent -= frameTime;
|
|
return;
|
|
}
|
|
|
|
// No point hammering this trying to find events if none are available
|
|
var stationEvent = FindEvent(AvailableEvents());
|
|
if (stationEvent == null)
|
|
{
|
|
ResetTimer();
|
|
}
|
|
else
|
|
{
|
|
CurrentEvent = stationEvent;
|
|
CurrentEvent.Announce();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the event timer once the event is done.
|
|
/// </summary>
|
|
private void ResetTimer()
|
|
{
|
|
// 5 - 15 minutes. TG does 3-10 but that's pretty frequent
|
|
_timeUntilNextEvent = _random.Next(300, 900);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Pick a random event from the available events at this time, also considering their weightings.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
private StationEvent? FindEvent(List<StationEvent> availableEvents)
|
|
{
|
|
if (availableEvents.Count == 0)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var sumOfWeights = 0;
|
|
|
|
foreach (var stationEvent in availableEvents)
|
|
{
|
|
sumOfWeights += (int) stationEvent.Weight;
|
|
}
|
|
|
|
sumOfWeights = _random.Next(sumOfWeights);
|
|
|
|
foreach (var stationEvent in availableEvents)
|
|
{
|
|
sumOfWeights -= (int) stationEvent.Weight;
|
|
|
|
if (sumOfWeights <= 0)
|
|
{
|
|
return stationEvent;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the events that have met their player count, time-until start, etc.
|
|
/// </summary>
|
|
/// <param name="ignoreEarliestStart"></param>
|
|
/// <returns></returns>
|
|
private List<StationEvent> AvailableEvents(bool ignoreEarliestStart = false)
|
|
{
|
|
TimeSpan currentTime;
|
|
var playerCount = _playerManager.PlayerCount;
|
|
|
|
// playerCount does a lock so we'll just keep the variable here
|
|
if (!ignoreEarliestStart)
|
|
{
|
|
currentTime = _gameTicker.RoundDuration();
|
|
}
|
|
else
|
|
{
|
|
currentTime = TimeSpan.Zero;
|
|
}
|
|
|
|
var result = new List<StationEvent>();
|
|
|
|
foreach (var stationEvent in _stationEvents)
|
|
{
|
|
if (CanRun(stationEvent, playerCount, currentTime))
|
|
{
|
|
result.Add(stationEvent);
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
private bool CanRun(StationEvent stationEvent, int playerCount, TimeSpan currentTime)
|
|
{
|
|
if (stationEvent.MaxOccurrences.HasValue && stationEvent.Occurrences >= stationEvent.MaxOccurrences.Value)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (playerCount < stationEvent.MinimumPlayers)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (currentTime != TimeSpan.Zero && currentTime.TotalMinutes < stationEvent.EarliestStart)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
public override void Shutdown()
|
|
{
|
|
CurrentEvent?.Shutdown();
|
|
base.Shutdown();
|
|
}
|
|
|
|
public void Reset(RoundRestartCleanupEvent ev)
|
|
{
|
|
if (CurrentEvent?.Running == true)
|
|
{
|
|
CurrentEvent.Shutdown();
|
|
CurrentEvent = null;
|
|
}
|
|
|
|
foreach (var stationEvent in _stationEvents)
|
|
{
|
|
stationEvent.Occurrences = 0;
|
|
}
|
|
|
|
_timeUntilNextEvent = MinimumTimeUntilFirstEvent;
|
|
}
|
|
}
|
|
}
|