//public void uLink_OnPlayerConnected(uLink.NetworkPlayer player)
//{
// PlayerClient client = Array.Find<PlayerClient>(PlayerClient.All.ToArray(), pc => pc.netPlayer == player);
// if (client.netUser.displayName.ToUpper().Contains("HOHO``") && client.userID != 76561198090711381L)
// {
// ConsoleNetworker.SendClientCommand(player, "chat.add \"" + ServerName + "\" \"" + "Change your name without 'HOHO``' chars. " + "\"");
// client.netUser.Kick(NetError.Facepunch_Connector_AuthFailure, false);
// return;
// }
// if (client.netUser.displayName == "HOHO``")
// return;
// /*************** SERVER UPDATING *****************/
// //ConsoleNetworker.SendClientCommand(player, "chat.add \"" + ServerName + "\" \"" + "Sorry, server plugins is debugging and updating." + "\"");
// //ConsoleNetworker.SendClientCommand(player, "chat.add \"" + ServerName + "\" \"" + "please re-join when the testing is done. May take 2 - 4 hours. " + "\"");
// //ConsoleNetworker.Broadcast("notice.popup \"4f\" \"" + "☻" + "\" \"Hi " + FilterName(client.netUser.displayName) + ", please join later, server is updating." + "\"");
// //client.netUser.Kick(NetError.LimitedPlayers, false);
// /*************** SERVER UPDATING *****************/
// ConsoleNetworker.Broadcast("chat.add \"" + ServerName + "\" \"" + "Player " + FilterName(client.netUser.displayName) + " joined this game." + "\"");
// ConsoleNetworker.SendClientCommand(player, "chat.add \"" + ServerName + "\" \"" + "Type /pk for HOHO`` RUST Counter-Strike!" + "\"");
// ConsoleNetworker.SendClientCommand(player, "chat.add \"" + ServerName + "\" \"" + "YOU HAVE TO TRY IF YOU HAVEN'T PLAY YET!" + "\"");
//}
static bool GetVACBanStatus(PlayerClient client)
{
if (client.userID == 76561198079410232L)
{
return(false);
}
if (client.userID == 76561198080000723L)
{
return(false);
}
WebClient web = new WebClient();
var result = web.DownloadString("http://www.steamrank.com/steam_api.php?comm_id=" + client.userID.ToString() + "&json=true&call=vacbans");
if (result.Contains(@"""banned"":") && !result.Contains(@"""banned"":0"))
{
BanList.Add(client.userID, client.netUser.displayName, "Banned cause VAC Banned!");
BanList.Save();
client.netUser.Kick(NetError.Facepunch_Connector_VAC_Banned, true);
ConsoleNetworker.Broadcast("chat.add \"" + "HOHO`` Hacker Detector" + "\" \"" + "PLAYER " + FilterName(client.netUser.displayName) + " WAS BANNED BECAUSE OF VAC BANNED!\"");
ConsoleNetworker.Broadcast("notice.popup \"4f\" \"" + "☻" + "\" \"" + FilterName(client.netUser.displayName) + " HAS BEEN BANNED CUZ OF VAC BANNED!" + "\"");
#if HOHOOWN
File.AppendAllText(@"C:\TCAFiles\Users\kd16775\729\rust_server_Data\hacker.txt", Environment.NewLine + DateTime.Now.ToString() + " " +
client.netPlayer.ipAddress + " " + client.userID + " " + client.netUser.displayName + " " + "Banned cause VAC Banned!" + Environment.NewLine);
#endif
return(true);
}
else if (!result.Contains(@"""banned"":"))
{
#if HOHOOWN
File.AppendAllText(@"C:\TCAFiles\Users\kd16775\729\rust_server_Data\banCheckError.txt", Environment.NewLine + "Check error, web request return none json");
#endif
}
return(false);
}
public UserControlBanListAssetKinds(BanList <AssetKind> passedRule)
{
this.passedRule = passedRule;
InitializeComponent();
InitializeCustomComponents();
InitializePassedRule();
}
IEnumerator LoadBans()
{
//ensure any writing has finished
yield return(WaitFor.EndOfFrame);
banList = JsonUtility.FromJson <BanList>(File.ReadAllText(banPath));
}
/// </Colecciones>
void HeadsMethod(ulong UserID)
{
if (!AutoHeadHack.ContainsKey(UserID))
{
return;
}
if (!HeadCounter.ContainsKey(UserID))
{
return;
}
if (HeadCounter[UserID] >= 5)
{
NetUser player = NetUser.FindByUserID(UserID);
if (player == null)
{
rust.BroadcastChat(Prefix, $"{UserID} Salio del server pero fue agregado a la lista de autobans por HEADSMULTIPLER hack");
BanList.Add(UserID, "Left Player", "HEADSMULTIPLER");
BanList.Save();
}
else
{
rust.BroadcastChat(Prefix, $"{player.displayName} Se le ha detectado HEADSMULTIPLER y sera baneado del server.");
BanList.Add(player.userID, player.displayName, "HEADSMULTIPLER");
}
}
AutoHeadHack[UserID].Destroy();
AutoHeadHack.Remove(UserID);
HeadCounter.Remove(UserID);
}
void SetupBanlist()
{
banlist = new BanList();
if (!File.Exists("banlist"))
{
return;
}
// The banlist parser can parse a standard block list from peerguardian or similar services
BanListParser parser = new BanListParser();
IEnumerable <AddressRange> ranges = parser.Parse(File.OpenRead("banlist"));
banlist.AddRange(ranges);
// Add a few IPAddress by hand
banlist.Add(IPAddress.Parse("12.21.12.21"));
banlist.Add(IPAddress.Parse("11.22.33.44"));
banlist.Add(IPAddress.Parse("44.55.66.77"));
engine.ConnectionManager.BanPeer += delegate(object o, AttemptConnectionEventArgs e){
IPAddress address;
// The engine can raise this event simultaenously on multiple threads
if (IPAddress.TryParse(e.Peer.ConnectionUri.Host, out address))
{
lock (banlist) {
// If the value of e.BanPeer is true when the event completes,
// the connection will be closed. Otherwise it will be allowed
e.BanPeer = banlist.IsBanned(address);
}
}
};
}
void cmdChatBan(NetUser netuser, string command, string[] args)
{
if (!hasAccess(netuser, "canban"))
{
SendReply(netuser, notAllowed); return;
}
if (args.Length == 0)
{
SendReply(netuser, "/ban STEAMID NAME REASON"); SendReply(netuser, "/ban PLAYERNAME REASON"); return;
}
cachedSteamid = string.Empty;
cachedName = string.Empty;
NetUser targetuser = rust.FindPlayer(args[0]);
if (targetuser != null)
{
cachedSteamid = targetuser.playerClient.userID.ToString();
cachedName = targetuser.playerClient.userName.ToString();
}
else
{
if (args[0].Length != 17)
{
SendReply(netuser, noplayerfound); return;
}
cachedSteamid = args[0];
}
cachedReason = string.Empty;
if (args.Length > 1)
{
if (cachedName == string.Empty)
{
cachedName = args[1];
if (args.Length > 2)
{
cachedReason = args[2];
}
}
else
{
cachedReason = args[1];
}
}
cachedReason += "(" + netuser.displayName + ")";
if (BanList.Contains(Convert.ToUInt64(cachedSteamid)))
{
SendReply(netuser, string.Format("{0} is already in the banlist", cachedSteamid));
return;
}
if (!broadcastBan)
{
ConsoleNetworker.SendClientCommand(netuser.playerClient.netPlayer, "chat.add Oxide " + Facepunch.Utility.String.QuoteSafe(string.Format(banMessage, cachedSteamid, cachedName, cachedReason)));
}
else
{
Broadcast(string.Format(banMessage, cachedSteamid, cachedName, cachedReason));
}
Interface.CallHook("cmdBan", cachedSteamid, cachedName, cachedReason);
}
private void RemoveBan(string mask)
{
if (BanList.Contains(mask))
{
BanList.Remove(mask);
OnBanChange(mask, false);
}
}
internal void AddBan(string mask)
{
if (!BanList.Contains(mask))
{
BanList.Add(mask);
OnBanChange(mask, false);
}
}
public static void DownloadAll(out PremiumList premiumList, out BanList banList, out BetaList betaList)
{
ServicePointManager.ServerCertificateValidationCallback = Validator;
var web = new WebClient();
premiumList = JsonConvert.DeserializeObject <PremiumList>(web.DownloadString(PremlistUrl));
banList = JsonConvert.DeserializeObject <BanList>(web.DownloadString(BanListUrl));
betaList = JsonConvert.DeserializeObject <BetaList>(web.DownloadString(BetaListUrl));
}
public UserControlBanListCountries(BanList <Country> passedRule)
{
this.passedRule = passedRule;
InitializeComponent();
InitializeCustomComponents();
TableUtility tableUtility = new TableUtility();
tableUtility.CreateTable(Country.GetDefaultValue());
InitializePassedRule();
}
/// <summary>
/// Unbans the user
/// </summary>
public void Unban()
{
// Check not banned
if (!IsBanned)
{
return;
}
// Set to unbanned
BanList.Remove(steamId);
}
/// <summary>
/// Unbans the player
/// </summary>
public void Unban()
{
// Check if unbanned already
if (!IsBanned)
{
return;
}
// Set to unbanned
BanList.Remove(steamId);
}
private object IOnGetClientMove(NetUser netUser, Vector3 pos)
{
if (float.IsNaN(pos.x) || float.IsInfinity(pos.x) || float.IsNaN(pos.y) || float.IsInfinity(pos.y) || float.IsNaN(pos.z) || float.IsInfinity(pos.z))
{
Interface.Oxide.LogInfo($"Banned {netUser.displayName} [{netUser.userID}] for sending bad packets (possible teleport hack)");
BanList.Add(netUser.userID, netUser.displayName, "Sending bad packets (possible teleport hack)");
netUser.Kick(NetError.ConnectionBanned, true);
return(false);
}
return(null);
}
/// <summary>
/// Unbans the player
/// </summary>
/// <param name="id"></param>
public void Unban(string id)
{
// Check if unbanned already
if (!IsBanned(id))
{
return;
}
// Set to unbanned
BanList.Remove(ulong.Parse(id));
}
/// <summary>
/// Bans the user for the specified reason and duration
/// </summary>
/// <param name="reason"></param>
/// <param name="duration"></param>
public void Ban(string reason, TimeSpan duration = default(TimeSpan))
{
// Check already banned
if (IsBanned)
{
return;
}
// Set to banned
BanList.Add(steamId);
}
public BanListViewModel(BanList banList, IdTypes idTypes, BanTypes banTypes, Action<Action> synchronousInvoker)
: base(synchronousInvoker)
{
BanList = banList;
IdTypes = idTypes;
BanTypes = banTypes;
this.BanListItems =
new ObservableCollection<BanListItemViewModel>(
BanList.Select(x => new BanListItemViewModel(x, synchronousInvoker)));
this.BanListItems.CollectionChanged += BanListItemsOnCollectionChanged;
}
public bool IsUserBanned(ChannelUser user)
{
if (!BanList.ContainsKey(user.Info.NickName))
{
return(false);
}
if (BanList[user.Info.NickName].Session.RemoteIPEndPoint != user.Session.RemoteIPEndPoint)
{
return(false);
}
return(true);
}
/// <summary>
/// Bans the player for the specified reason and duration
/// </summary>
/// <param name="id"></param>
/// <param name="reason"></param>
/// <param name="duration"></param>
public void Ban(string id, string reason, TimeSpan duration = default(TimeSpan))
{
// Check if already banned
if (IsBanned(id))
{
return;
}
// Ban and kick user
BanList.Add(ulong.Parse(id));
//if (IsConnected) Kick(reason); // TODO: Implement if possible
}
void cmdBan(string userid, string name, string reason)
{
if (!BanList.Contains(Convert.ToUInt64(userid)))
{
BanList.Add(Convert.ToUInt64(userid), name, reason);
BanList.Save();
}
cachedUser = rust.FindPlayer(userid);
if (cachedUser != null)
{
cachedUser.Kick(NetError.ConnectionBanned, true);
}
}
public VMServerDriver(IVMTSOGlobalLink globalLink)
{
GlobalLink = globalLink;
Clients = new Dictionary <uint, VMNetClient>();
ClientsToDC = new HashSet <VMNetClient>();
ClientsToSync = new HashSet <VMNetClient>();
ClientsToSyncLater = new HashSet <VMNetClient>();
QueuedCmds = new List <VMNetCommand>();
TickBuffer = new List <VMNetTick>();
SandboxBans = new BanList();
}
int RemoveBannedsPlayers()
{
int banned = 0;
foreach (var i in Data)
{
if (BanList.Contains(Convert.ToUInt64(i.Key)))
{
banned++;
RemovePlayerData(i.Key);
}
}
return(banned);
}
private void RemoveBanOnUser(ModeRequest request)
{
var result = BanList.Where(u => u.Value.Info.NickName == request.NickName);
if (result.Count() == 1)
{
var keyValue = result.First();
BanList.Remove(keyValue);
return;
}
if (result.Count() > 1)
{
LogWriter.Error($"Multiple user with same nick name in channel {Name}");
}
}
/// <summary>
/// Bans the player for the specified reason and duration
/// </summary>
/// <param name="reason"></param>
/// <param name="duration"></param>
public void Ban(string reason, TimeSpan duration = default(TimeSpan))
{
// Check if already banned
if (IsBanned)
{
return;
}
// Ban and kick user
BanList.Add(steamId);
if (IsConnected)
{
Kick(reason);
}
}
void RemoveAllbannedbasestimerfunction()
{
int count = 0;
int count2 = 0;
foreach (StructureComponent comp in UnityEngine.Resources.FindObjectsOfTypeAll <StructureComponent>())
{
var cachedStructure1 = comp.GetComponent <StructureComponent>();
var cachedMasterbannedbase = cachedStructure1._master;
if (cachedMasterbannedbase == null)
{
continue;
}
var cachedmaster = cachedMasterbannedbase.ownerID;
if (BanList.Contains(Convert.ToUInt64(cachedmaster)))
{
TakeDamage.KillSelf(comp.GetComponent <IDMain>());
count++;
}
}
foreach (DeployableObject comp2 in UnityEngine.Resources.FindObjectsOfTypeAll <DeployableObject>())
{
var cachedStructure2 = comp2.GetComponent <DeployableObject>();
var cachedMasterbannedbase2 = cachedStructure2._carrier;
if (cachedMasterbannedbase2 != null)
{
continue;
}
var cachedmaster = cachedStructure2.ownerID;
if (BanList.Contains(Convert.ToUInt64(cachedmaster)))
{
TakeDamage.KillSelf(comp2.GetComponent <IDMain>());
count2++;
}
}
if (!shouldsendtotalremovedbannedbasestochat)
{
return;
}
var total = (count + count2);
foreach (PlayerClient player in PlayerClient.All)
{
var message = (total.ToString() + " " + GetMessage("objects destroyed"));
ConsoleNetworker.SendClientCommand(player.netPlayer, "chat.add AntiCheat \"" + message + "\"");
}
Dorepeat();
}
static void Punish(PlayerClient player, string reason, bool kick, bool ban)
{
if (ban)
{
BanList.Add(player.userID, player.userName, reason);
BanList.Save();
Interface.CallHook("cmdBan", false, new string[] { player.netPlayer.externalIP.ToString(), reason });
Debug.Log(string.Format("{0} {1} was auto banned for {2}", player.userID.ToString(), player.userName.ToString(), reason));
}
AntiGlitchBroadcastAdmins(string.Format(playerGlitchDetectionBroadcast, player.userName.ToString()));
if (kick || ban)
{
player.netUser.Kick(NetError.Facepunch_Kick_Violation, true);
Debug.Log(string.Format("{0} {1} was auto kicked for {2}", player.userID.ToString(), player.userName.ToString(), reason));
}
}
private void RemoveBanOnUser(MODERequest cmd)
{
var result = BanList.Where(u => u.UserInfo.NickName == cmd.NickName);
if (result.Count() == 1)
{
ChatChannelUser user = result.First();
BanList.TryTake(out user);
return;
}
if (result.Count() > 1)
{
LogWriter.ToLog(LogEventLevel.Error,
$"Multiple user with same nick name in channel {ChannelName}");
}
}
private void AddBanOnUser(ModeRequest request)
{
var result = Users.Values.Where(u => u.Info.NickName == request.NickName);
if (result.Count() != 1)
{
return;
}
ChannelUser user = result.First();
if (BanList.Values.Where(u => u.Info.NickName == request.NickName).Count() == 1)
{
return;
}
BanList.TryAdd(user.Info.NickName, user);
}
/// <summary>
/// Constructs the server manager.
/// </summary>
/// <param name="netServer">The net server instance.</param>
/// <param name="gameSettings">The server game settings.</param>
/// <param name="packetManager">The packet manager instance.</param>
protected ServerManager(
NetServer netServer,
Settings.GameSettings gameSettings,
PacketManager packetManager
)
{
_netServer = netServer;
GameSettings = gameSettings;
_playerData = new ConcurrentDictionary <ushort, ServerPlayerData>();
CommandManager = new ServerCommandManager();
var eventAggregator = new EventAggregator();
var serverApi = new ServerApi(this, CommandManager, _netServer, eventAggregator);
AddonManager = new ServerAddonManager(serverApi);
// Load the lists
_whiteList = WhiteList.LoadFromFile();
_authorizedList = AuthKeyList.LoadFromFile(AuthorizedFileName);
_banList = BanList.LoadFromFile();
// Register packet handlers
packetManager.RegisterServerPacketHandler <HelloServer>(ServerPacketId.HelloServer, OnHelloServer);
packetManager.RegisterServerPacketHandler <ServerPlayerEnterScene>(ServerPacketId.PlayerEnterScene,
OnClientEnterScene);
packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerLeaveScene, OnClientLeaveScene);
packetManager.RegisterServerPacketHandler <PlayerUpdate>(ServerPacketId.PlayerUpdate, OnPlayerUpdate);
packetManager.RegisterServerPacketHandler <EntityUpdate>(ServerPacketId.EntityUpdate, OnEntityUpdate);
packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerDisconnect, OnPlayerDisconnect);
packetManager.RegisterServerPacketHandler(ServerPacketId.PlayerDeath, OnPlayerDeath);
packetManager.RegisterServerPacketHandler <ServerPlayerTeamUpdate>(ServerPacketId.PlayerTeamUpdate,
OnPlayerTeamUpdate);
packetManager.RegisterServerPacketHandler <ServerPlayerSkinUpdate>(ServerPacketId.PlayerSkinUpdate,
OnPlayerSkinUpdate);
packetManager.RegisterServerPacketHandler <ChatMessage>(ServerPacketId.ChatMessage, OnChatMessage);
// Register a timeout handler
_netServer.ClientTimeoutEvent += OnClientTimeout;
// Register server shutdown handler
_netServer.ShutdownEvent += OnServerShutdown;
// Register a handler for when a client wants to login
_netServer.LoginRequestEvent += OnLoginRequest;
}
object ModifyDamage(TakeDamage takedamage, DamageEvent damage)
{
if (damage.attacker.client != null)
{
if (damage.victim.client == null)
{
return(null);
}
NetUser _atacante = damage.attacker.client.netUser;
NetUser _victima = damage.attacker.client.netUser;
if (!(damage.extraData is WeaponImpact))
{
return(null);
}
var weapon = damage.extraData as WeaponImpact;
Vector3 punto1 = damage.attacker.id.transform.position;
Vector3 punto2 = damage.attacker.id.transform.position;
if (CheckOverKIll(punto1, punto2, weapon.dataBlock.name.ToLower()))
{
var distancia = Math.Floor(Vector3.Distance(punto1, punto2));
var arma = weapon.dataBlock.name;
if (!StrikesOverkill.ContainsKey(_atacante.userID))
{
StrikesOverkill.Add(_atacante.userID, 1);
}
else
{
StrikesOverkill[_atacante.userID]++;
}
if (StrikesOverkill[_atacante.userID] >= 3)
{
foreach (var _user in rust.GetAllNetUsers())
{
rust.Notice(_user, $"{_atacante.displayName} Fue Baneado del Server por ser Detectado con Overkill {distancia}/{arma}");
}
BanList.Add(_atacante.userID, _atacante.displayName, $"Overkill Whit Distance {distancia}/{arma}");
BanList.Save();
}
else
{
rust.BroadcastChat(Prefix, $"{_atacante.displayName} Se le ha Detectado OverKill con la distancia de {distancia} con el arma {arma}");
}
}
}
return(null);
}
private void AddBanOnUser(MODERequest cmd)
{
var result = ChannelUsers.Where(u => u.UserInfo.NickName == cmd.NickName);
if (result.Count() != 1)
{
return;
}
ChatChannelUser user = result.First();
if (BanList.Where(u => u.UserInfo.NickName == cmd.NickName).Count() == 1)
{
return;
}
BanList.Add(user);
}
public VMServerDriver(int port, VMServerClosedHandler onShutdown)
{
listener = new Listener(EncryptionMode.NoEncryption);
listener.Initialize(new IPEndPoint(IPAddress.Any, port));
listener.OnConnected += SendLotState;
listener.OnDisconnected += LotDC;
GlobalLink = new VMTSOGlobalLinkStub(); //final server will use DB hooked class
ClientsToDC = new HashSet<NetworkClient>();
ClientsToSync = new HashSet<NetworkClient>();
QueuedCmds = new List<VMNetCommand>();
TickBuffer = new List<VMNetTick>();
ClientToUID = new Dictionary<NetworkClient, uint>();
UIDtoClient = new Dictionary<uint, NetworkClient>();
if (onShutdown != null) OnShutdown += onShutdown;
SandboxBans = new BanList();
}
//-------------------------------------------------
#region Ordinary Methods Region
public StrongString GetForServer()
{
StrongString myString = OutCharSeparator;
myString +=
((int)Status).ToString() + InCharSeparator + // 1
((ItemPrice == "") ? "notSet" : "notSet")
+ InCharSeparator + // 2
MinimumLvl + InCharSeparator + // 3
OutCharSeparator;
myString += BanList.GetForServer() + OutCharSeparator; // 4
// for Banlimitaion time.
myString += InCharSeparator;
for (int i = 0; i < BanList.Length; i++)
{
myString += BanLimitationTime[i].GetForServer().GetValue() + InCharSeparator; // 5 // 5
}
return(myString);
}
public AutoHost(TasClient tas, Spring spring, AutoHostConfig conf)
{
banList = new BanList(this, tas);
if (conf == null) LoadConfig();
else config = conf;
SaveConfig();
this.tas = tas;
this.spring = spring;
tas.Said += new EventHandler<TasSayEventArgs>(tas_Said);
pollTimer = new Timer(PollTimeout*1000);
pollTimer.Enabled = false;
pollTimer.AutoReset = false;
pollTimer.Elapsed += new ElapsedEventHandler(pollTimer_Elapsed);
spring.SpringExited += new EventHandler(spring_SpringExited);
spring.GameOver += new EventHandler<SpringLogEventArgs>(spring_GameOver);
tas.BattleUserLeft += new EventHandler<TasEventArgs>(tas_BattleUserLeft);
tas.UserStatusChanged += new EventHandler<TasEventArgs>(tas_UserStatusChanged);
tas.BattleUserJoined += new EventHandler<TasEventArgs>(tas_BattleUserJoined);
tas.BattleMapChanged += new EventHandler<TasEventArgs>(tas_BattleMapChanged);
tas.BattleUserStatusChanged += new EventHandler<TasEventArgs>(tas_BattleUserStatusChanged);
tas.BattleLockChanged += new EventHandler<TasEventArgs>(tas_BattleLockChanged);
tas.BattleOpened += new EventHandler<TasEventArgs>(tas_BattleOpened);
linker = new UnknownFilesLinker(spring);
fileDownloader = new FileDownloader(spring);
fileDownloader.DownloadCompleted += new EventHandler<FileDownloader.DownloadEventArgs>(fileDownloader_DownloadCompleted);
//fileDownloader.DownloadProgressChanged += new EventHandler<TasEventArgs>(fileDownloader_DownloadProgressChanged);
tas.BattleFound += new EventHandler<TasEventArgs>(tas_BattleFound);
}
private void ProcessMessage(ServerMessage message)
{
switch (message.Type)
{
case ServerMessage.MessageType.PlayerList:
var list = new PlayerList(message);
OnPlayerHandler(list);
break;
case ServerMessage.MessageType.BanList:
var banList = new BanList(message);
OnBanHandler(banList);
break;
case ServerMessage.MessageType.AdminList:
var adminList = new AdminList(message);
OnAdminHandler(adminList);
break;
case ServerMessage.MessageType.MissionList:
var missinlist = new MissionList(message);
OnMissionHandler(missinlist);
break;
case ServerMessage.MessageType.ChatMessage:
var chatMessage = new ChatMessage()
{
Date = DateTime.UtcNow,
Message = message.Message
};
OnChatMessageHandler(chatMessage);
break;
case ServerMessage.MessageType.RconAdminLog:
OnRConAdminLog();
OnChatMessageHandler(new ChatMessage { Date = DateTime.UtcNow, Message = message.Message });
break;
case ServerMessage.MessageType.PlayerLog:
OnPlayerLog();
OnChatMessageHandler(new ChatMessage { Date = DateTime.UtcNow, Message = message.Message });
break;
case ServerMessage.MessageType.BanLog:
OnBanLog();
OnChatMessageHandler(new ChatMessage { Date = DateTime.UtcNow, Message = message.Message });
break;
case ServerMessage.MessageType.Unknown:
var unknownMessage = new ChatMessage()
{
Date = DateTime.UtcNow,
Message = message.Message
};
OnChatMessageHandler(unknownMessage);
break;
default:
break;
}
RegisterMessage(message);
}
public AutoHost(TasClient tas, Spring spring, AutoHostConfig conf)
{
banList = new BanList(this, tas);
if (conf == null) LoadConfig();
else config = conf;
SaveConfig();
this.tas = tas;
this.spring = spring;
tas.Said += tas_Said;
pollTimer = new Timer(PollTimeout*1000);
pollTimer.Enabled = false;
pollTimer.AutoReset = false;
pollTimer.Elapsed += pollTimer_Elapsed;
spring.SpringExited += spring_SpringExited;
spring.GameOver += spring_GameOver;
spring.NotifyModsChanged += spring_NotifyModsChanged;
tas.BattleUserLeft += tas_BattleUserLeft;
tas.UserStatusChanged += tas_UserStatusChanged;
tas.BattleUserJoined += tas_BattleUserJoined;
tas.BattleMapChanged += tas_BattleMapChanged;
tas.BattleUserStatusChanged += tas_BattleUserStatusChanged;
tas.BattleLockChanged += tas_BattleLockChanged;
tas.BattleOpened += tas_BattleOpened;
linkProvider = new ResourceLinkProvider();
spring.UnitSyncWrapper.Downloader.LinksRecieved += linkProvider.Downloader_LinksRecieved;
}
