public void OnMapChange(TrackingServerInfo args)
{
// Tuple<string,string,string> entry = new Tuple<string, string, string>()
PlayEntry entry = new PlayEntry(args.playerCount.ToString(), args.serverIP, System.DateTime.Now.ToShortDateString() + " : " + System.DateTime.Now.ToShortTimeString());
AddEntry(args.currentMap, entry);
savePersistentData();
UpdateList();
}
public void ServerUpdated(object sender, TrackingServerInfo args)
{
if (MapChangeEventListiners.Count > 0)
{
foreach (ServerMapChangeListiner Listiner in MapChangeEventListiners)
{
Listiner.OnMapChange(args);
}
}
}
// queries a server and returns a <string, int> Tuple (filename, playercount)
public TrackingServerInfo ServerQuery(TrackingServerInfo server)
{
if (IsEmulating) //For testing purposes, we can assign and set an emulated TrackingServerInfo response
{
return(EmulatedTrackingServerInfo);
}
else
{
TrackingServerInfo updatedServer = null;
// request server infos
IPEndPoint localEndpoint = new IPEndPoint(IPAddress.Any, 0);
using (var client = new UdpClient(new IPEndPoint(IPAddress.Any, 0)))
{
client.Client.ReceiveTimeout = 5000;
client.Client.SendTimeout = 5000;
client.Connect(new IPEndPoint(System.Net.IPAddress.Parse(server.serverIP), server.port));
var request = new List <byte>();
request.AddRange(new byte[] { 0xFF, 0xFF, 0xFF, 0xFF, 0x54 });
request.AddRange(Encoding.ASCII.GetBytes("Source Engine Query\0"));
var requestArr = request.ToArray();
client.Send(requestArr, requestArr.Length);
try
{
var data = client.Receive(ref localEndpoint).Skip(6).ToArray();
updatedServer = new TrackingServerInfo(server.serverIP, server.port, server.tag);
string[] TrackingServerInfos = Encoding.ASCII.GetString(data).Split(new char[] { '\0' }, 5);
// getting and sanitizing filename
updatedServer.currentMap = TrackingServerInfos[1].Split('.')[0].Replace("workshop/", "");
// getting playerount
updatedServer.playerCount = (int)Encoding.ASCII.GetBytes(TrackingServerInfos[4]).Skip(2).ToArray()[0];
// getting server capacity
updatedServer.capacity = (int)Encoding.ASCII.GetBytes(TrackingServerInfos[4]).Skip(2).ToArray()[1];
client.Close();
}
catch (Exception ex)
{
Console.WriteLine(string.Format("Error from: {0}: {1}", server.tag, ex.Message));
client.Close();
}
}
return(updatedServer);
}
}
public void SyncTrackingServerInfo(object sender, EventArgs e)
{
for (int x = 0; x < TrackedServers.Servers.Count; x++)
{
TrackingServerInfo currentserverstate = ServerQuery(TrackedServers.Servers[x]);
if (currentserverstate != null)
{
if (!(TrackedServers.Servers[x].currentMap.Equals(currentserverstate.currentMap)) && currentserverstate.playerCount > 8)
{
ServerMapChanged(this, currentserverstate);
TrackedServers.Servers[x].update(currentserverstate);
}
}
}
}
public override void loadPersistentData()
{
try
{
Tuple <string, string, int>[] servers = JsonConvert.DeserializeObject <Tuple <string, string, int>[]>(System.IO.File.ReadAllText(ModuleSavedDataFilePath()));
foreach (Tuple <string, string, int> servconf in servers)
{
IPEndPoint ep = new IPEndPoint(System.Net.IPAddress.Parse(servconf.Item2), servconf.Item3);
TrackingServerInfo TrackingServerInfo = new TrackingServerInfo(servconf.Item2, servconf.Item3, servconf.Item1);
TrackedServers.Add(TrackingServerInfo);
}
}
catch
{
Console.WriteLine("There was an error loading the TrackingServerList");
}
}
public void OnMapChange(TrackingServerInfo args)
{
Console.WriteLine("Going to possibly remove {0} Map...", args.currentMap);
Map map = mapList.GetMapByFilename(args.currentMap);
if (map != null && args.playerCount > 8)
{
User Submitter = new User(map.Submitter, null);
Console.WriteLine("Found map, sending message to {0}", Submitter);
string ReasonForDeletion = string.Format("Map {0} is being tested on the {1} server and has been DELETED.", map.Filename, args.tag);
userhandler.SendPrivateMessageProcessEvent(new MessageEventArgs(null)
{
Destination = Submitter, ReplyMessage = ReasonForDeletion
});
mapList.RemoveMap(map, ReasonForDeletion);
Console.WriteLine("Map {0} is being tested on the {1} server and has been DELETED.", map.Filename, args.tag);
savePersistentData();
}
Console.Write("...Not Found");
return;
}
protected override string exec(MessageEventArgs Msg, string param)
{
string[] parameters = param.Split(new char[] { ' ' });
if (parameters.Length > 2)
{
try
{
IPEndPoint ep = new IPEndPoint(System.Net.IPAddress.Parse(parameters[1]), int.Parse(parameters[2]));
TrackingServerInfo Server = new TrackingServerInfo(parameters[1], int.Parse(parameters[2]), parameters[0]);
module.TrackedServers.Add(Server);
return(string.Format("Server {0} has been successfully added at: {1}", Server.tag, Server.serverIP));
}
catch
{
return("Your data types were invalid!");
}
}
else
{
return("Your Server was not added, remember the command is: !serveradd servername serverIP serverPort");
}
}
public void Remove(TrackingServerInfo server)
{
TrackingServerListObject.Remove(server);
ServerTrackingModule.savePersistentData();
}
void ModuleHandler.ServerUpdated(object sender, TrackingServerInfo args)
{
}
public void EmulateServerQuery(TrackingServerInfo Response)
{
EmulatedTrackingServerInfo = Response;
IsEmulating = true;
}
private void ServerTrackingModule_ServerMapChanged(object sender, TrackingServerInfo e)
{
string TableLabel = e.tag + " History";
TableDataValue HeaderName = new TableDataValue();
HeaderName.VisibleValue = "Map Name";
TableDataValue HeaderNamePlayerCount = new TableDataValue();
HeaderNamePlayerCount.VisibleValue = "PlayerCount";
TableDataValue HeaderTime = new TableDataValue();
HeaderTime.VisibleValue = "Time (UTC)";
SetTableHeader tableheaderSetter = new SetTableHeader();
tableheaderSetter.TableIdentifier = TableLabel;
tableheaderSetter.Header = new TableDataValue[] { HeaderName, HeaderNamePlayerCount, HeaderTime };
WebServer.HandleCommand(tableheaderSetter);
TableDataValue MapName = new TableDataValue();
MapName.VisibleValue = e.currentMap;
TableDataValue PlayerCount = new TableDataValue();
PlayerCount.VisibleValue = e.playerCount.ToString();
TableDataValue Time = new TableDataValue();
Time.VisibleValue = DateTime.UtcNow.ToLongDateString() + " " + DateTime.UtcNow.ToLongTimeString();
AddWebsiteEntry AddSiteEntry = new AddWebsiteEntry();
AddSiteEntry.Data = new TableDataValue[] { MapName, PlayerCount, Time };
AddSiteEntry.limit = 10;
AddSiteEntry.Identifier = TableLabel;
WebServer.HandleCommand(AddSiteEntry);
if (e.playerCount > 8)
{
userhandler.BroadcastMessageProcessEvent(e.ToString());
TableDataValue HeaderServer = new TableDataValue();
HeaderServer.VisibleValue = "Server";
TableDataValue ServerLabel = new TableDataValue();
ServerLabel.VisibleValue = e.tag;
ServerLabel.Link = "steam://connect/" + e.serverIP + ":" + e.port;
string RecentlyTestedTableLabel = "Recently Tested";
SetTableHeader tableheader = new SetTableHeader();
tableheader.TableIdentifier = RecentlyTestedTableLabel;
tableheader.Header = new TableDataValue[] { HeaderName, HeaderNamePlayerCount, HeaderTime, HeaderServer };
WebServer.HandleCommand(tableheader);
AddWebsiteEntry WebSiteEntryToAdd = new AddWebsiteEntry();
WebSiteEntryToAdd.Data = new TableDataValue[] { MapName, PlayerCount, Time, ServerLabel };
WebSiteEntryToAdd.limit = 10;
WebSiteEntryToAdd.Identifier = RecentlyTestedTableLabel;
WebServer.HandleCommand(WebSiteEntryToAdd);
}
}
public void update(TrackingServerInfo updated)
{
this.playerCount = updated.playerCount;
this.capacity = updated.capacity;
this.currentMap = updated.currentMap;
}
