971 lines
38 KiB
C#
971 lines
38 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Threading;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Text.RegularExpressions;
|
|
|
|
using SharedLibraryCore;
|
|
using SharedLibraryCore.Interfaces;
|
|
using SharedLibraryCore.Objects;
|
|
using SharedLibraryCore.Services;
|
|
using SharedLibraryCore.Database.Models;
|
|
using SharedLibraryCore.Dtos;
|
|
using SharedLibraryCore.Configuration;
|
|
|
|
using IW4MAdmin.Application.Misc;
|
|
|
|
namespace IW4MAdmin
|
|
{
|
|
public class IW4MServer : Server
|
|
{
|
|
private CancellationToken cts;
|
|
|
|
public IW4MServer(IManager mgr, ServerConfiguration cfg) : base(mgr, cfg) { }
|
|
|
|
public override int GetHashCode()
|
|
{
|
|
return Math.Abs($"{IP}:{Port.ToString()}".GetHashCode());
|
|
}
|
|
|
|
override public async Task<bool> AddPlayer(Player polledPlayer)
|
|
{
|
|
if (polledPlayer.Ping == 999 || polledPlayer.Ping < 1 || polledPlayer.ClientNumber > (MaxClients) || polledPlayer.ClientNumber < 0)
|
|
{
|
|
//Logger.WriteDebug($"Skipping client not in connected state {P}");
|
|
return true;
|
|
}
|
|
|
|
if (Players[polledPlayer.ClientNumber] != null &&
|
|
Players[polledPlayer.ClientNumber].NetworkId == polledPlayer.NetworkId)
|
|
{
|
|
// update their ping & score
|
|
Players[polledPlayer.ClientNumber].Ping = polledPlayer.Ping;
|
|
Players[polledPlayer.ClientNumber].Score = polledPlayer.Score;
|
|
return true;
|
|
}
|
|
|
|
#if !DEBUG
|
|
if (polledPlayer.Name.Length < 3)
|
|
{
|
|
Logger.WriteDebug($"Kicking {polledPlayer} because their name is too short");
|
|
await this.ExecuteCommandAsync($"clientkick {polledPlayer.ClientNumber} \"Your name must contain atleast 3 characters.\"");
|
|
return false;
|
|
}
|
|
|
|
if (Players.FirstOrDefault(p => p != null && p.Name == polledPlayer.Name) != null)
|
|
{
|
|
Logger.WriteDebug($"Kicking {polledPlayer} because their name is already in use");
|
|
await this.ExecuteCommandAsync($"clientkick {polledPlayer.ClientNumber} \"Your name is being used by someone else.\"");
|
|
return false;
|
|
}
|
|
|
|
if (polledPlayer.Name == "Unknown Soldier" ||
|
|
polledPlayer.Name == "UnknownSoldier" ||
|
|
polledPlayer.Name == "CHEATER")
|
|
{
|
|
Logger.WriteDebug($"Kicking {polledPlayer} because their name is generic");
|
|
await this.ExecuteCommandAsync($"clientkick {polledPlayer.ClientNumber} \"Please change your name using /name.\"");
|
|
return false;
|
|
}
|
|
|
|
if (polledPlayer.Name.Where(c => Char.IsControl(c)).Count() > 0)
|
|
{
|
|
Logger.WriteDebug($"Kicking {polledPlayer} because their contains control characters");
|
|
await this.ExecuteCommandAsync($"clientkick {polledPlayer.ClientNumber} \"Your name cannot contain control characters.\"");
|
|
return false;
|
|
}
|
|
|
|
#endif
|
|
Logger.WriteDebug($"Client slot #{polledPlayer.ClientNumber} now reserved");
|
|
|
|
try
|
|
{
|
|
Player player = null;
|
|
var client = await Manager.GetClientService().GetUnique(polledPlayer.NetworkId);
|
|
|
|
// first time client is connecting to server
|
|
if (client == null)
|
|
{
|
|
Logger.WriteDebug($"Client {polledPlayer} first time connecting");
|
|
player = (await Manager.GetClientService().Create(polledPlayer)).AsPlayer();
|
|
}
|
|
|
|
// client has connected in the past
|
|
else
|
|
{
|
|
client.Connections += 1;
|
|
var existingAlias = client.AliasLink.Children
|
|
.FirstOrDefault(a => a.Name == polledPlayer.Name && a.IPAddress == polledPlayer.IPAddress);
|
|
|
|
if (existingAlias == null)
|
|
{
|
|
Logger.WriteDebug($"Client {polledPlayer} has connected previously under a different ip/name");
|
|
client.CurrentAlias = new EFAlias()
|
|
{
|
|
IPAddress = polledPlayer.IPAddress,
|
|
Name = polledPlayer.Name,
|
|
};
|
|
// we need to update their new ip and name to the virtual property
|
|
client.Name = polledPlayer.Name;
|
|
client.IPAddress = polledPlayer.IPAddress;
|
|
|
|
await Manager.GetClientService().Update(client);
|
|
}
|
|
|
|
else if (existingAlias.Name == polledPlayer.Name)
|
|
{
|
|
client.CurrentAlias = existingAlias;
|
|
client.CurrentAliasId = existingAlias.AliasId;
|
|
await Manager.GetClientService().Update(client);
|
|
}
|
|
player = client.AsPlayer();
|
|
}
|
|
|
|
// Do the player specific stuff
|
|
player.ClientNumber = polledPlayer.ClientNumber;
|
|
player.Score = polledPlayer.Score;
|
|
player.CurrentServer = this;
|
|
Players[player.ClientNumber] = player;
|
|
|
|
var activePenalties = await Manager.GetPenaltyService().GetActivePenaltiesAsync(player.AliasLinkId);
|
|
var currentBan = activePenalties.FirstOrDefault(b => b.Expires > DateTime.UtcNow);
|
|
|
|
if (currentBan != null)
|
|
{
|
|
Logger.WriteInfo($"Banned client {player} trying to connect...");
|
|
var autoKickClient = (await Manager.GetClientService().Get(1)).AsPlayer();
|
|
autoKickClient.CurrentServer = this;
|
|
|
|
if (currentBan.Type == Penalty.PenaltyType.TempBan)
|
|
await this.ExecuteCommandAsync($"clientkick {player.ClientNumber} \"You are temporarily banned. ({(currentBan.Expires - DateTime.UtcNow).TimeSpanText()} left)\"");
|
|
else
|
|
await player.Kick($"Previously banned for {currentBan.Offense}", autoKickClient);
|
|
|
|
if (player.Level != Player.Permission.Banned && currentBan.Type == Penalty.PenaltyType.Ban)
|
|
await player.Ban($"Previously banned for {currentBan.Offense}", autoKickClient);
|
|
return true;
|
|
}
|
|
|
|
Logger.WriteInfo($"Client {player} connecting...");
|
|
|
|
await ExecuteEvent(new Event(Event.GType.Connect, "", player, null, this));
|
|
|
|
|
|
if (!Manager.GetApplicationSettings().Configuration().EnableClientVPNs &&
|
|
await VPNCheck.UsingVPN(player.IPAddressString, Manager.GetApplicationSettings().Configuration().IPHubAPIKey))
|
|
{
|
|
await player.Kick("VPNs are not allowed on this server", new Player() { ClientId = 1 });
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
catch (Exception E)
|
|
{
|
|
Manager.GetLogger().WriteError($"Unable to add player {polledPlayer.Name}::{polledPlayer.NetworkId}");
|
|
Manager.GetLogger().WriteDebug(E.StackTrace);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
//Remove player by CLIENT NUMBER
|
|
override public async Task RemovePlayer(int cNum)
|
|
{
|
|
if (cNum >= 0 && Players[cNum] != null)
|
|
{
|
|
Player Leaving = Players[cNum];
|
|
Logger.WriteInfo($"Client {Leaving} disconnecting...");
|
|
|
|
await ExecuteEvent(new Event(Event.GType.Disconnect, "", Leaving, null, this));
|
|
|
|
Leaving.TotalConnectionTime += (int)(DateTime.UtcNow - Leaving.ConnectionTime).TotalSeconds;
|
|
Leaving.LastConnection = DateTime.UtcNow;
|
|
await Manager.GetClientService().Update(Leaving);
|
|
Players[cNum] = null;
|
|
}
|
|
}
|
|
|
|
//Another version of client from line, written for the line created by a kill or death event
|
|
override public Player ParseClientFromString(String[] L, int cIDPos)
|
|
{
|
|
if (L.Length < cIDPos)
|
|
{
|
|
Logger.WriteError("Line sent for client creation is not long enough!");
|
|
return null;
|
|
}
|
|
|
|
int pID = -2; // apparently falling = -1 cID so i can't use it now
|
|
int.TryParse(L[cIDPos].Trim(), out pID);
|
|
|
|
if (pID == -1) // special case similar to mod_suicide
|
|
int.TryParse(L[2], out pID);
|
|
|
|
if (pID < 0 || pID > 17)
|
|
{
|
|
Logger.WriteError("Event player index " + pID + " is out of bounds!");
|
|
Logger.WriteDebug("Offending line -- " + String.Join(";", L));
|
|
return null;
|
|
}
|
|
|
|
return Players[pID];
|
|
}
|
|
|
|
//Process requested command correlating to an event
|
|
// todo: this needs to be removed out of here
|
|
override public async Task<Command> ValidateCommand(Event E)
|
|
{
|
|
string CommandString = E.Data.Substring(1, E.Data.Length - 1).Split(' ')[0];
|
|
E.Message = E.Data;
|
|
|
|
Command C = null;
|
|
foreach (Command cmd in Manager.GetCommands())
|
|
{
|
|
if (cmd.Name == CommandString.ToLower() || cmd.Alias == CommandString.ToLower())
|
|
C = cmd;
|
|
}
|
|
|
|
if (C == null)
|
|
{
|
|
await E.Origin.Tell("You entered an unknown command");
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} entered unknown command \"{CommandString}\"");
|
|
}
|
|
|
|
E.Data = E.Data.RemoveWords(1);
|
|
String[] Args = E.Data.Trim().Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
|
|
|
|
if (E.Origin.Level < C.Permission)
|
|
{
|
|
await E.Origin.Tell("You do not have access to that command");
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} does not have access to \"{C.Name}\"");
|
|
}
|
|
|
|
if (Args.Length < (C.RequiredArgumentCount))
|
|
{
|
|
await E.Origin.Tell($"Not enough arguments supplied");
|
|
await E.Origin.Tell(C.Syntax);
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} did not supply enough arguments for \"{C.Name}\"");
|
|
}
|
|
|
|
if (C.RequiresTarget || Args.Length > 0)
|
|
{
|
|
int cNum = -1;
|
|
try
|
|
{
|
|
cNum = Convert.ToInt32(Args[0]);
|
|
}
|
|
|
|
catch (FormatException)
|
|
{
|
|
|
|
}
|
|
|
|
if (Args[0][0] == '@') // user specifying target by database ID
|
|
{
|
|
int dbID = -1;
|
|
int.TryParse(Args[0].Substring(1, Args[0].Length - 1), out dbID);
|
|
|
|
var found = await Manager.GetClientService().Get(dbID);
|
|
if (found != null)
|
|
{
|
|
E.Target = found.AsPlayer();
|
|
E.Target.CurrentServer = this as IW4MServer;
|
|
E.Owner = this as IW4MServer;
|
|
E.Data = String.Join(" ", Args.Skip(1));
|
|
}
|
|
}
|
|
|
|
else if (Args[0].Length < 3 && cNum > -1 && cNum < MaxClients) // user specifying target by client num
|
|
{
|
|
if (Players[cNum] != null)
|
|
{
|
|
E.Target = Players[cNum];
|
|
E.Data = String.Join(" ", Args.Skip(1));
|
|
}
|
|
}
|
|
|
|
List<Player> matchingPlayers;
|
|
|
|
if (E.Target == null) // Find active player including quotes (multiple words)
|
|
{
|
|
matchingPlayers = GetClientByName(E.Data.Trim());
|
|
if (matchingPlayers.Count > 1)
|
|
{
|
|
await E.Origin.Tell("Multiple players match that name");
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} had multiple players found for {C.Name}");
|
|
}
|
|
else if (matchingPlayers.Count == 1)
|
|
{
|
|
E.Target = matchingPlayers.First();
|
|
|
|
string escapedName = Regex.Escape(E.Target.Name);
|
|
var reg = new Regex($"(\"{escapedName}\")|({escapedName})", RegexOptions.IgnoreCase);
|
|
E.Data = reg.Replace(E.Data, "", 1).Trim();
|
|
|
|
if (E.Data.Length == 0 && C.RequiredArgumentCount > 1)
|
|
{
|
|
await E.Origin.Tell($"Not enough arguments supplied!");
|
|
await E.Origin.Tell(C.Syntax);
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} did not supply enough arguments for \"{C.Name}\"");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (E.Target == null) // Find active player as single word
|
|
{
|
|
matchingPlayers = GetClientByName(Args[0]);
|
|
if (matchingPlayers.Count > 1)
|
|
{
|
|
await E.Origin.Tell("Multiple players match that name");
|
|
foreach (var p in matchingPlayers)
|
|
await E.Origin.Tell($"[^3{p.ClientNumber}^7] {p.Name}");
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} had multiple players found for {C.Name}");
|
|
}
|
|
else if (matchingPlayers.Count == 1)
|
|
{
|
|
E.Target = matchingPlayers.First();
|
|
|
|
string escapedName = Regex.Escape(E.Target.Name);
|
|
string escapedArg = Regex.Escape(Args[0]);
|
|
var reg = new Regex($"({escapedName})|({escapedArg})", RegexOptions.IgnoreCase);
|
|
E.Data = reg.Replace(E.Data, "", 1).Trim();
|
|
|
|
if ((E.Data.Trim() == E.Target.Name.ToLower().Trim() ||
|
|
E.Data == String.Empty) &&
|
|
C.RequiresTarget)
|
|
{
|
|
await E.Origin.Tell($"Not enough arguments supplied!");
|
|
await E.Origin.Tell(C.Syntax);
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} did not supply enough arguments for \"{C.Name}\"");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (E.Target == null && C.RequiresTarget)
|
|
{
|
|
await E.Origin.Tell("Unable to find specified player.");
|
|
throw new SharedLibraryCore.Exceptions.CommandException($"{E.Origin} specified invalid player for \"{C.Name}\"");
|
|
}
|
|
}
|
|
E.Data = E.Data.Trim();
|
|
return C;
|
|
}
|
|
|
|
public override async Task ExecuteEvent(Event E)
|
|
{
|
|
if (Throttled)
|
|
return;
|
|
|
|
await ProcessEvent(E);
|
|
Manager.GetEventApi().OnServerEvent(this, E);
|
|
|
|
foreach (IPlugin P in SharedLibraryCore.Plugins.PluginImporter.ActivePlugins)
|
|
{
|
|
#if !DEBUG
|
|
try
|
|
#endif
|
|
{
|
|
if (cts.IsCancellationRequested)
|
|
break;
|
|
|
|
await P.OnEventAsync(E, this);
|
|
}
|
|
#if !DEBUG
|
|
catch (Exception Except)
|
|
{
|
|
Logger.WriteError(String.Format("The plugin \"{0}\" generated an error. ( see log )", P.Name));
|
|
Logger.WriteDebug(String.Format("Error Message: {0}", Except.Message));
|
|
Logger.WriteDebug(String.Format("Error Trace: {0}", Except.StackTrace));
|
|
continue;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
async Task<int> PollPlayersAsync()
|
|
{
|
|
var now = DateTime.Now;
|
|
|
|
List<Player> CurrentPlayers = null;
|
|
try
|
|
{
|
|
CurrentPlayers = await this.GetStatusAsync();
|
|
}
|
|
|
|
// when the server has lost connection
|
|
catch (SharedLibraryCore.Exceptions.NetworkException)
|
|
{
|
|
Throttled = true;
|
|
return ClientNum;
|
|
}
|
|
#if DEBUG
|
|
Logger.WriteInfo($"Polling players took {(DateTime.Now - now).TotalMilliseconds}ms");
|
|
#endif
|
|
Throttled = false;
|
|
for (int i = 0; i < Players.Count; i++)
|
|
{
|
|
if (CurrentPlayers.Find(p => p.ClientNumber == i) == null && Players[i] != null)
|
|
await RemovePlayer(i);
|
|
}
|
|
|
|
for (int i = 0; i < CurrentPlayers.Count; i++)
|
|
{
|
|
await AddPlayer(CurrentPlayers[i]);
|
|
}
|
|
|
|
return CurrentPlayers.Count;
|
|
}
|
|
|
|
long l_size = -1;
|
|
String[] lines = new String[8];
|
|
String[] oldLines = new String[8];
|
|
DateTime start = DateTime.Now;
|
|
DateTime playerCountStart = DateTime.Now;
|
|
DateTime lastCount = DateTime.Now;
|
|
DateTime tickTime = DateTime.Now;
|
|
bool firstRun = true;
|
|
|
|
override public async Task<bool> ProcessUpdatesAsync(CancellationToken cts)
|
|
{
|
|
this.cts = cts;
|
|
//#if DEBUG == false
|
|
try
|
|
//#endif
|
|
{
|
|
// first start
|
|
if (firstRun)
|
|
{
|
|
await ExecuteEvent(new Event(Event.GType.Start, "Server started", null, null, this));
|
|
firstRun = false;
|
|
}
|
|
|
|
if ((DateTime.Now - LastPoll).TotalMinutes < 2 && ConnectionErrors >= 1)
|
|
return true;
|
|
|
|
try
|
|
{
|
|
int polledPlayerCount = await PollPlayersAsync();
|
|
|
|
if (ConnectionErrors > 0)
|
|
{
|
|
Logger.WriteVerbose($"Connection has been reestablished with {IP}:{Port}");
|
|
Throttled = false;
|
|
}
|
|
ConnectionErrors = 0;
|
|
LastPoll = DateTime.Now;
|
|
}
|
|
|
|
catch (SharedLibraryCore.Exceptions.NetworkException e)
|
|
{
|
|
ConnectionErrors++;
|
|
if (ConnectionErrors == 1)
|
|
{
|
|
Logger.WriteError($"{e.Message} {IP}:{Port}, reducing polling rate");
|
|
Logger.WriteDebug($"Internal Exception: {e.Data["internal_exception"]}");
|
|
Throttled = true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
LastMessage = DateTime.Now - start;
|
|
lastCount = DateTime.Now;
|
|
|
|
if ((DateTime.Now - tickTime).TotalMilliseconds >= 1000)
|
|
{
|
|
foreach (var Plugin in SharedLibraryCore.Plugins.PluginImporter.ActivePlugins)
|
|
{
|
|
if (cts.IsCancellationRequested)
|
|
break;
|
|
|
|
await Plugin.OnTickAsync(this);
|
|
}
|
|
tickTime = DateTime.Now;
|
|
}
|
|
|
|
if ((lastCount - playerCountStart).TotalMinutes >= SharedLibraryCore.Helpers.PlayerHistory.UpdateInterval)
|
|
{
|
|
while (PlayerHistory.Count > ((60 / SharedLibraryCore.Helpers.PlayerHistory.UpdateInterval) * 12)) // 12 times a hour for 12 hours
|
|
PlayerHistory.Dequeue();
|
|
PlayerHistory.Enqueue(new SharedLibraryCore.Helpers.PlayerHistory(ClientNum));
|
|
playerCountStart = DateTime.Now;
|
|
}
|
|
|
|
if (LastMessage.TotalSeconds > Manager.GetApplicationSettings().Configuration().AutoMessagePeriod
|
|
&& BroadcastMessages.Count > 0
|
|
&& ClientNum > 0)
|
|
{
|
|
await Broadcast(Utilities.ProcessMessageToken(Manager.GetMessageTokens(), BroadcastMessages[NextMessage]));
|
|
NextMessage = NextMessage == (BroadcastMessages.Count - 1) ? 0 : NextMessage + 1;
|
|
start = DateTime.Now;
|
|
}
|
|
|
|
if (LogFile == null)
|
|
return true;
|
|
|
|
if (l_size != LogFile.Length())
|
|
{
|
|
// this should be the longest running task
|
|
await Task.FromResult(lines = LogFile.Tail(12));
|
|
if (lines != oldLines)
|
|
{
|
|
l_size = LogFile.Length();
|
|
int end = (lines.Length == oldLines.Length) ? lines.Length - 1 : Math.Abs((lines.Length - oldLines.Length)) - 1;
|
|
|
|
for (int count = 0; count < lines.Length; count++)
|
|
{
|
|
if (lines.Length < 1 && oldLines.Length < 1)
|
|
continue;
|
|
|
|
if (lines[count] == oldLines[oldLines.Length - 1])
|
|
continue;
|
|
|
|
if (lines[count].Length < 10) // it's not a needed line
|
|
continue;
|
|
|
|
else
|
|
{
|
|
string[] game_event = lines[count].Split(';');
|
|
Event event_ = Event.ParseEventString(game_event, this);
|
|
if (event_ != null)
|
|
{
|
|
if (event_.Origin == null)
|
|
continue;
|
|
|
|
await ExecuteEvent(event_);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
oldLines = lines;
|
|
l_size = LogFile.Length();
|
|
if (Manager.ShutdownRequested())
|
|
{
|
|
foreach (var plugin in SharedLibraryCore.Plugins.PluginImporter.ActivePlugins)
|
|
await plugin.OnUnloadAsync();
|
|
|
|
for (int i = 0; i < Players.Count; i++)
|
|
await RemovePlayer(i);
|
|
}
|
|
return true;
|
|
}
|
|
//#if !DEBUG
|
|
catch (SharedLibraryCore.Exceptions.NetworkException)
|
|
{
|
|
Logger.WriteError($"Could not communicate with {IP}:{Port}");
|
|
return false;
|
|
}
|
|
|
|
catch (Exception E)
|
|
{
|
|
Logger.WriteError($"Encountered error on {IP}:{Port}");
|
|
Logger.WriteDebug("Error Message: " + E.Message);
|
|
Logger.WriteDebug("Error Trace: " + E.StackTrace);
|
|
return false;
|
|
}
|
|
//#endif
|
|
}
|
|
|
|
public async Task Initialize()
|
|
{
|
|
var version = await this.GetDvarAsync<string>("version");
|
|
GameName = Utilities.GetGame(version.Value);
|
|
|
|
if (GameName == Game.UKN)
|
|
Logger.WriteWarning($"Game name not recognized: {version}");
|
|
|
|
var shortversion = await this.GetDvarAsync<string>("shortversion");
|
|
var hostname = await this.GetDvarAsync<string>("sv_hostname");
|
|
var mapname = await this.GetDvarAsync<string>("mapname");
|
|
var maxplayers = (GameName == Game.IW4) ? // gotta love IW4 idiosyncrasies
|
|
await this.GetDvarAsync<int>("party_maxplayers") :
|
|
await this.GetDvarAsync<int>("sv_maxclients");
|
|
var gametype = await this.GetDvarAsync<string>("g_gametype");
|
|
var basepath = await this.GetDvarAsync<string>("fs_basepath");
|
|
WorkingDirectory = basepath.Value;
|
|
var game = await this.GetDvarAsync<string>("fs_game");
|
|
var logfile = await this.GetDvarAsync<string>("g_log");
|
|
var logsync = await this.GetDvarAsync<int>("g_logsync");
|
|
|
|
DVAR<int> onelog = null;
|
|
if (GameName == Game.IW4)
|
|
{
|
|
try
|
|
{
|
|
onelog = await this.GetDvarAsync<int>("iw4x_onelog");
|
|
}
|
|
|
|
catch (Exception)
|
|
{
|
|
onelog = new DVAR<int>("iw4x_onelog")
|
|
{
|
|
Value = -1
|
|
};
|
|
}
|
|
}
|
|
|
|
try
|
|
{
|
|
var website = await this.GetDvarAsync<string>("_website");
|
|
Website = website.Value;
|
|
}
|
|
|
|
catch (SharedLibraryCore.Exceptions.DvarException)
|
|
{
|
|
Website = "this server's website";
|
|
}
|
|
|
|
InitializeMaps();
|
|
|
|
this.Hostname = hostname.Value.StripColors();
|
|
this.CurrentMap = Maps.Find(m => m.Name == mapname.Value) ?? new Map() { Alias = mapname.Value, Name = mapname.Value };
|
|
this.MaxClients = maxplayers.Value;
|
|
this.FSGame = game.Value;
|
|
|
|
await this.SetDvarAsync("sv_kickbantime", 60);
|
|
|
|
if (logsync.Value == 0 || logfile.Value == string.Empty)
|
|
{
|
|
// this DVAR isn't set until the a map is loaded
|
|
await this.SetDvarAsync("logfile", 2);
|
|
await this.SetDvarAsync("g_logsync", 2); // set to 2 for continous in other games, clamps to 1 for IW4
|
|
await this.SetDvarAsync("g_log", "games_mp.log");
|
|
Logger.WriteWarning("Game log file not properly initialized, restarting map...");
|
|
await this.ExecuteCommandAsync("map_restart");
|
|
logfile = await this.GetDvarAsync<string>("g_log");
|
|
}
|
|
|
|
CustomCallback = await ScriptLoaded();
|
|
|
|
string mainPath = (GameName == Game.IW4 && onelog.Value >= 0) ? "userraw" : "main";
|
|
// patch for T5M:V2 log path
|
|
mainPath = (GameName == Game.T5M) ? "rzodemo" : mainPath;
|
|
|
|
string logPath = (game.Value == "" || onelog?.Value == 1) ?
|
|
$"{basepath.Value.Replace('\\', Path.DirectorySeparatorChar)}{Path.DirectorySeparatorChar}{mainPath}{Path.DirectorySeparatorChar}{logfile.Value}" :
|
|
$"{basepath.Value.Replace('\\', Path.DirectorySeparatorChar)}{Path.DirectorySeparatorChar}{game.Value.Replace('/', Path.DirectorySeparatorChar)}{Path.DirectorySeparatorChar}{logfile.Value}";
|
|
|
|
// fix to prevent wine drive prefix when running in mono
|
|
if (Utilities.IsRunningOnMono())
|
|
{
|
|
logPath = Regex.Replace(logPath, @"[A-Z]:", "");
|
|
}
|
|
|
|
if (!File.Exists(logPath))
|
|
{
|
|
Logger.WriteError($"Gamelog {logPath} does not exist!");
|
|
#if !DEBUG
|
|
throw new SharedLibraryCore.Exceptions.ServerException($"Invalid gamelog file {logPath}");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
LogFile = new IFile(logPath);
|
|
}
|
|
|
|
Logger.WriteInfo($"Log file is {logPath}");
|
|
#if DEBUG
|
|
//LogFile = new RemoteFile("https://raidmax.org/IW4MAdmin/getlog.php");
|
|
#else
|
|
await Broadcast("IW4M Admin is now ^2ONLINE");
|
|
#endif
|
|
}
|
|
|
|
//Process any server event
|
|
override protected async Task ProcessEvent(Event E)
|
|
{
|
|
if (E.Type == Event.GType.Connect)
|
|
{
|
|
ChatHistory.Add(new ChatInfo()
|
|
{
|
|
Name = E.Origin.Name,
|
|
Message = "CONNECTED",
|
|
Time = DateTime.UtcNow
|
|
});
|
|
|
|
if (E.Origin.Level > Player.Permission.Moderator)
|
|
await E.Origin.Tell($"There are ^5{Reports.Count} ^7recent reports");
|
|
}
|
|
|
|
else if (E.Type == Event.GType.Disconnect)
|
|
{
|
|
ChatHistory.Add(new ChatInfo()
|
|
{
|
|
Name = E.Origin.Name,
|
|
Message = "DISCONNECTED",
|
|
Time = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
else if (E.Type == Event.GType.Script)
|
|
{
|
|
await ExecuteEvent(new Event(Event.GType.Kill, E.Data, E.Origin, E.Target, this));
|
|
}
|
|
|
|
if (E.Type == Event.GType.Say && E.Data.Length >= 2)
|
|
{
|
|
if (E.Data.Substring(0, 1) == "!" || E.Data.Substring(0, 1) == "@" || E.Origin.Level == Player.Permission.Console)
|
|
{
|
|
Command C = null;
|
|
|
|
try
|
|
{
|
|
C = await ValidateCommand(E);
|
|
}
|
|
|
|
catch (SharedLibraryCore.Exceptions.CommandException e)
|
|
{
|
|
Logger.WriteInfo(e.Message);
|
|
}
|
|
|
|
if (C != null)
|
|
{
|
|
if (C.RequiresTarget && E.Target == null)
|
|
{
|
|
Logger.WriteWarning("Requested event (command) requiring target does not have a target!");
|
|
}
|
|
|
|
try
|
|
{
|
|
await C.ExecuteAsync(E);
|
|
}
|
|
|
|
catch (Exception Except)
|
|
{
|
|
Logger.WriteError(String.Format("A command request \"{0}\" generated an error.", C.Name));
|
|
Logger.WriteDebug(String.Format("Error Message: {0}", Except.Message));
|
|
Logger.WriteDebug(String.Format("Error Trace: {0}", Except.StackTrace));
|
|
await E.Origin.Tell("^1An internal error occured while processing your command^7");
|
|
#if DEBUG
|
|
await E.Origin.Tell(Except.Message);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
else // Not a command
|
|
{
|
|
E.Data = E.Data.StripColors();
|
|
|
|
ChatHistory.Add(new ChatInfo()
|
|
{
|
|
Name = E.Origin.Name,
|
|
Message = E.Data,
|
|
Time = DateTime.UtcNow
|
|
});
|
|
}
|
|
}
|
|
|
|
if (E.Type == Event.GType.MapChange)
|
|
{
|
|
Logger.WriteInfo($"New map loaded - {ClientNum} active players");
|
|
|
|
Gametype = (await this.GetDvarAsync<string>("g_gametype")).Value.StripColors();
|
|
Hostname = (await this.GetDvarAsync<string>("sv_hostname")).Value.StripColors();
|
|
FSGame = (await this.GetDvarAsync<string>("fs_game")).Value.StripColors();
|
|
|
|
string mapname = this.GetDvarAsync<string>("mapname").Result.Value;
|
|
CurrentMap = Maps.Find(m => m.Name == mapname) ?? new Map() { Alias = mapname, Name = mapname };
|
|
}
|
|
|
|
if (E.Type == Event.GType.MapEnd)
|
|
{
|
|
Logger.WriteInfo("Game ending...");
|
|
}
|
|
|
|
//todo: move
|
|
while (ChatHistory.Count > Math.Ceiling((double)ClientNum / 2))
|
|
ChatHistory.RemoveAt(0);
|
|
|
|
// the last client hasn't fully disconnected yet
|
|
// so there will still be at least 1 client left
|
|
if (ClientNum < 2)
|
|
ChatHistory.Clear();
|
|
}
|
|
|
|
public override async Task Warn(String Reason, Player Target, Player Origin)
|
|
{
|
|
// ensure player gets warned if command not performed on them in game
|
|
if (Target.ClientNumber < 0)
|
|
{
|
|
var ingameClient = Manager.GetActiveClients()
|
|
.FirstOrDefault(c => c.ClientId == Target.ClientId);
|
|
|
|
if (ingameClient != null)
|
|
{
|
|
await Warn(Reason, ingameClient, Origin);
|
|
return;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
if (Target.Warnings >= 4)
|
|
await Target.Kick("Too many warnings!", (await Manager.GetClientService().Get(1)).AsPlayer());
|
|
|
|
Target.Warnings++;
|
|
String Message = String.Format("^1WARNING ^7[^3{0}^7]: ^3{1}^7, {2}", Target.Warnings, Target.Name, Reason);
|
|
await Target.CurrentServer.Broadcast(Message);
|
|
}
|
|
|
|
Penalty newPenalty = new Penalty()
|
|
{
|
|
Type = Penalty.PenaltyType.Warning,
|
|
Expires = DateTime.UtcNow,
|
|
Offender = Target,
|
|
Offense = Reason,
|
|
Punisher = Origin,
|
|
Active = true,
|
|
When = DateTime.UtcNow,
|
|
Link = Target.AliasLink
|
|
};
|
|
|
|
await Manager.GetPenaltyService().Create(newPenalty);
|
|
}
|
|
|
|
public override async Task Kick(String Reason, Player Target, Player Origin)
|
|
{
|
|
// ensure player gets kicked if command not performed on them in game
|
|
if (Target.ClientNumber < 0)
|
|
{
|
|
var ingameClient = Manager.GetActiveClients()
|
|
.FirstOrDefault(c => c.ClientId == Target.ClientId);
|
|
|
|
if (ingameClient != null)
|
|
{
|
|
await Kick(Reason, ingameClient, Origin);
|
|
return;
|
|
}
|
|
}
|
|
#if !DEBUG
|
|
else
|
|
await Target.CurrentServer.ExecuteCommandAsync($"clientkick {Target.ClientNumber} \"Player Kicked: ^5{Reason}^7\"");
|
|
#endif
|
|
|
|
#if DEBUG
|
|
await Target.CurrentServer.RemovePlayer(Target.ClientNumber);
|
|
#endif
|
|
|
|
var newPenalty = new Penalty()
|
|
{
|
|
Type = Penalty.PenaltyType.Kick,
|
|
Expires = DateTime.UtcNow,
|
|
Offender = Target,
|
|
Offense = Reason,
|
|
Punisher = Origin,
|
|
Active = true,
|
|
When = DateTime.UtcNow,
|
|
Link = Target.AliasLink
|
|
};
|
|
|
|
await Manager.GetPenaltyService().Create(newPenalty);
|
|
}
|
|
|
|
public override async Task TempBan(String Reason, TimeSpan length, Player Target, Player Origin)
|
|
{
|
|
// ensure player gets banned if command not performed on them in game
|
|
if (Target.ClientNumber < 0)
|
|
{
|
|
var ingameClient = Manager.GetActiveClients()
|
|
.FirstOrDefault(c => c.ClientId == Target.ClientId);
|
|
|
|
if (ingameClient != null)
|
|
{
|
|
await TempBan(Reason, length, ingameClient, Origin);
|
|
return;
|
|
}
|
|
}
|
|
#if !DEBUG
|
|
else
|
|
await Target.CurrentServer.ExecuteCommandAsync($"clientkick {Target.ClientNumber } \"^7Player Temporarily Banned: ^5{ Reason }\"");
|
|
#else
|
|
await Target.CurrentServer.RemovePlayer(Target.ClientNumber);
|
|
#endif
|
|
|
|
Penalty newPenalty = new Penalty()
|
|
{
|
|
Type = Penalty.PenaltyType.TempBan,
|
|
Expires = DateTime.UtcNow + length,
|
|
Offender = Target,
|
|
Offense = Reason,
|
|
Punisher = Origin,
|
|
Active = true,
|
|
When = DateTime.UtcNow,
|
|
Link = Target.AliasLink
|
|
};
|
|
|
|
await Manager.GetPenaltyService().Create(newPenalty);
|
|
}
|
|
|
|
override public async Task Ban(String Message, Player Target, Player Origin)
|
|
{
|
|
// ensure player gets banned if command not performed on them in game
|
|
if (Target.ClientNumber < 0)
|
|
{
|
|
Player ingameClient = null;
|
|
|
|
ingameClient = Manager.GetServers()
|
|
.Select(s => s.GetPlayersAsList())
|
|
.FirstOrDefault(l => l.FirstOrDefault(c => c.ClientId == Target.ClientId) != null)
|
|
?.First(c => c.ClientId == Target.ClientId);
|
|
|
|
if (ingameClient != null)
|
|
{
|
|
await Ban(Message, ingameClient, Origin);
|
|
return;
|
|
}
|
|
}
|
|
|
|
else
|
|
{
|
|
// this is set only because they're still in the server.
|
|
Target.Level = Player.Permission.Banned;
|
|
#if !DEBUG
|
|
await Target.CurrentServer.ExecuteCommandAsync($"clientkick {Target.ClientNumber} \"Player Banned: ^5{Message} ^7(appeal at {Website}) ^7\"");
|
|
#else
|
|
await Target.CurrentServer.RemovePlayer(Target.ClientNumber);
|
|
#endif
|
|
}
|
|
|
|
Penalty newPenalty = new Penalty()
|
|
{
|
|
Type = Penalty.PenaltyType.Ban,
|
|
Expires = DateTime.MaxValue,
|
|
Offender = Target,
|
|
Offense = Message,
|
|
Punisher = Origin,
|
|
Active = true,
|
|
When = DateTime.UtcNow,
|
|
Link = Target.AliasLink
|
|
};
|
|
|
|
await Manager.GetPenaltyService().Create(newPenalty);
|
|
}
|
|
|
|
override public async Task Unban(string reason, Player Target, Player Origin)
|
|
{
|
|
var unbanPenalty = new Penalty()
|
|
{
|
|
Type = Penalty.PenaltyType.Unban,
|
|
Expires = DateTime.UtcNow,
|
|
Offender = Target,
|
|
Offense = reason,
|
|
Punisher = Origin,
|
|
When = DateTime.UtcNow,
|
|
Active = true,
|
|
Link = Target.AliasLink
|
|
};
|
|
|
|
await Manager.GetPenaltyService().Create(unbanPenalty);
|
|
await Manager.GetPenaltyService().RemoveActivePenalties(Target.AliasLink.AliasLinkId);
|
|
}
|
|
|
|
override public void InitializeTokens()
|
|
{
|
|
Manager.GetMessageTokens().Add(new SharedLibraryCore.Helpers.MessageToken("TOTALPLAYERS", Manager.GetClientService().GetTotalClientsAsync().Result.ToString));
|
|
Manager.GetMessageTokens().Add(new SharedLibraryCore.Helpers.MessageToken("VERSION", IW4MAdmin.Application.Program.Version.ToString));
|
|
}
|
|
}
|
|
}
|