private static void RetrieveAllModTagsAsync(Action <IDictionary <string, ISet <string> >, bool> onCompletion)
{
Action <Exception, string> onGetFail = (e, output) => {
if (e is JsonReaderException)
{
LogHelpers.Alert("Bad JSON: " + (output.Length > 256 ? output.Substring(0, 256) : output));
}
else if (e is WebException || e is NullReferenceException)
{
LogHelpers.Alert((output ?? "...") + " - " + e.Message);
}
else
{
LogHelpers.Alert((output ?? "...") + " - " + e.ToString());
}
};
Action <IDictionary <string, ISet <string> >, bool> onGetCompletion = (responseVal, found) => {
if (responseVal == null)
{
responseVal = new Dictionary <string, ISet <string> >();
}
onCompletion(responseVal, found);
};
NetHelpers.MakeGetRequestAsync(GetModTags.ModTagsUrl, GetModTags.HandleModTagsReceipt, onGetFail, onGetCompletion);
}
internal bool TryMark(EndPoint endPoint, ProtocolTypes protocolTypes, ServerQuality quality)
{
lock ( listLock )
{
ServerInfo[] serverInfos;
if (quality == ServerQuality.Good)
{
serverInfos = servers.Where(x => x.Record.EndPoint.Equals(endPoint) && x.Protocol.HasFlagsFast(protocolTypes)).ToArray();
}
else
{
// If we're marking this server for any failure, mark all endpoints for the host at the same time
var host = NetHelpers.ExtractEndpointHost(endPoint).host;
serverInfos = servers.Where(x => x.Record.GetHost().Equals(host)).ToArray();
}
if (serverInfos.Length == 0)
{
return(false);
}
foreach (var serverInfo in serverInfos)
{
MarkServerCore(serverInfo, quality);
}
return(true);
}
}
private static void RetrieveBadModsAsync(Action <IDictionary <string, int>, bool> onSuccess)
{
Action <Exception, string> onFail = (e, output) => {
if (e is JsonReaderException)
{
LogHelpers.Alert("Bad JSON: " + (output.Length > 256 ? output.Substring(0, 256) : output));
}
else if (e is WebException || e is NullReferenceException)
{
LogHelpers.Alert((output ?? "") + " - " + e.Message);
}
else
{
LogHelpers.Alert((output ?? "") + " - " + e.ToString());
}
};
Action <IDictionary <string, int>, bool> onCompletion = (responseVal, success) => {
if (responseVal == null)
{
responseVal = new Dictionary <string, int>();
}
onSuccess(responseVal, success);
};
NetHelpers.MakeGetRequestAsync(GetModInfo.BadModsUrl, GetModInfo.HandleBadModsReceipt, onFail, onCompletion);
}
void HandleLogOnResponse(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
// a non proto ClientLogonResponse can come in as a result of connecting but never sending a ClientLogon
// in this case, it always fails, so we don't need to do anything special here
DebugLog.WriteLine("CMClient", "Got non-proto logon response, this is indicative of no logon attempt after connecting.");
return;
}
var logonResp = new ClientMsgProtobuf <CMsgClientLogonResponse>(packetMsg);
if (logonResp.Body.eresult == ( int )EResult.OK)
{
SessionID = logonResp.ProtoHeader.client_sessionid;
SteamID = logonResp.ProtoHeader.steamid;
CellID = logonResp.Body.cell_id;
PublicIP = NetHelpers.GetIPAddress(logonResp.Body.public_ip);
IPCountryCode = logonResp.Body.ip_country_code;
int hbDelay = logonResp.Body.out_of_game_heartbeat_seconds;
// restart heartbeat
heartBeatFunc.Stop();
heartBeatFunc.Delay = TimeSpan.FromSeconds(hbDelay);
heartBeatFunc.Start();
}
}
public static void SubmitModInfo(string modName, ISet <string> modTags, Action <string> onSuccess, Action <Exception, string> onError, Action onCompletion = null)
{
string url = "http://hamstar.pw/hamstarhelpers/mod_info_submit/";
var json = new PostModTagsData {
modname = modName,
modtags = string.Join(",", modTags)
};
string jsonStr = JsonConvert.SerializeObject(json, Formatting.Indented);
byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonStr);
Action <String> onResponse = (output) => {
JObject respJson = JObject.Parse(output);
JToken msg = respJson.SelectToken("Msg");
if (msg == null)
{
onSuccess("Failure.");
}
else
{
onSuccess(msg.ToObject <string>());
}
};
Action <Exception, string> wrappedOnError = (Exception e, string str) => {
LogHelpers.Log("!ModHelpers.PostModInfo.SubmitModInfo - Failed for post: " + jsonStr);
onError(e, str);
};
NetHelpers.MakePostRequestAsync(url, jsonBytes, onResponse, wrappedOnError, onCompletion);
}
void HandleLogOnResponse(IPacketMsg packetMsg)
{
if (!packetMsg.IsProto)
{
// a non proto ClientLogonResponse can come in as a result of connecting but never sending a ClientLogon
// in this case, it always fails, so we don't need to do anything special here
LogDebug("CMClient", "Got non-proto logon response, this is indicative of no logon attempt after connecting.");
return;
}
var logonResp = new ClientMsgProtobuf <CMsgClientLogonResponse>(packetMsg);
var logonResult = ( EResult )logonResp.Body.eresult;
if (logonResult == EResult.OK)
{
SessionID = logonResp.ProtoHeader.client_sessionid;
SteamID = logonResp.ProtoHeader.steamid;
CellID = logonResp.Body.cell_id;
PublicIP = NetHelpers.GetIPAddress(logonResp.Body.deprecated_public_ip);
IPCountryCode = logonResp.Body.ip_country_code;
int hbDelay = logonResp.Body.out_of_game_heartbeat_seconds;
// restart heartbeat
heartBeatFunc.Stop();
heartBeatFunc.Delay = TimeSpan.FromSeconds(hbDelay);
heartBeatFunc.Start();
}
else if (logonResult == EResult.TryAnotherCM || logonResult == EResult.ServiceUnavailable)
{
Servers.TryMark(connection.CurrentEndPoint, connection.ProtocolTypes, ServerQuality.Bad);
}
}
public static void ReportIssue(Mod mod, string issueTitle, string issueBody, Action <string> onSuccess, Action <Exception, string> onError, Action onCompletion = null)
{
if (!ModFeaturesHelpers.HasGithub(mod))
{
throw new HamstarException("Mod is not eligable for submitting issues.");
}
int maxLines = ModHelpersMod.Instance.Config.ModIssueReportErrorLogMaxLines;
IEnumerable <Mod> mods = ModListHelpers.GetAllLoadedModsPreferredOrder();
string bodyInfo = string.Join("\n \n", InfoHelpers.GetGameData(mods).ToArray());
string bodyErrors = string.Join("\n", InfoHelpers.GetErrorLog(maxLines).ToArray());
string url = "http://hamstar.pw/hamstarhelpers/issue_submit/";
string title = "Reported from in-game: " + issueTitle;
string body = bodyInfo;
body += "\n \n \n \n" + "Recent error logs:\n```\n" + bodyErrors + "\n```";
body += "\n \n" + issueBody;
var json = new GithubModIssueReportData {
githubuser = ModFeaturesHelpers.GetGithubUserName(mod),
githubproject = ModFeaturesHelpers.GetGithubProjectName(mod),
title = title,
body = body
};
string jsonStr = JsonConvert.SerializeObject(json, Formatting.Indented);
byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonStr);
Action <String> onResponse = (output) => {
JObject respJson = JObject.Parse(output);
//JToken data = respJson.SelectToken( "Data.html_url" );
JToken msg = respJson.SelectToken("Msg");
/*if( data != null ) {
* string post_at_url = data.ToObject<string>();
* if( !string.IsNullOrEmpty( post_at_url ) ) {
* SystemHelpers.Start( post_at_url );
* }
* }*/
if (msg == null)
{
onSuccess("Failure.");
}
else
{
onSuccess(msg.ToObject <string>());
}
};
Action <Exception, string> wrappedOnError = (Exception e, string str) => {
LogHelpers.Log("!ModHelpers.PostGithubModIssueReports.ReportIssue - Failed for POST to " + url + " : " + jsonStr);
onError(e, str);
};
NetHelpers.MakePostRequestAsync(url, jsonBytes, onResponse, wrappedOnError, onCompletion);
}
public void TryParseIPEndPoint()
{
Assert.True(NetHelpers.TryParseIPEndPoint("127.0.0.1:1337", out var parsedIp));
Assert.Equal(new IPEndPoint(IPAddress.Loopback, 1337), parsedIp);
Assert.True(NetHelpers.TryParseIPEndPoint("[::1]:1337", out var parsedIpv6));
Assert.Equal(new IPEndPoint(IPAddress.IPv6Loopback, 1337), parsedIpv6);
}
/// <summary>
/// Parses data when Discord sends a message.
/// </summary>
private void Socket_OnDataReceived(object sender, MessageEventArgs e)
{
var json = e.Data;
if (json == null)
{
return;
}
if (json.Length <= 1)
{
return;
}
if (debug)
{
Console.WriteLine("\n" + json + "\n");
}
if (!DiscordMessageFactory.TryParseDispatchMessage(json, out var msg))
{
return;
}
LastSequenceNumber = msg.SequenceNumber;
var chatmsg = msg.GetChatMessageData();
if (chatmsg != null && Channel_IDs.Contains(chatmsg.ChannelId))
{
if (!chatmsg.Author.IsBot)
{
string msgout = chatmsg.Message;
// Lazy add commands until I take time to design a command service properly
//if (ExecuteCommand(chatmsg))
// return;
msgout = chatParser.ConvertUserIdsToNames(msgout, chatmsg.UsersMentioned);
msgout = chatParser.ShortenEmojisToName(msgout);
msgout = $"<{chatmsg.Author.Username}> {msgout}";
NetHelpers.BroadcastChatMessageWithoutTCRFormattable(
("[c/7489d8:Discord] - " + msgout), -1);
if (Channel_IDs.Count > 1)
{
messageQueue.QueueMessage(
Channel_IDs.Where(x => x != chatmsg.ChannelId),
$"**[Discord]** <{chatmsg.Author.Username}> {chatmsg.Message}");
}
Console.ForegroundColor = ConsoleColor.Blue;
Console.Write("[Discord] ");
Console.ResetColor();
Console.Write(msgout);
Console.WriteLine();
}
}
}
public void CreateMarker()
{
PlayerPerformAction p = new PlayerPerformAction(PacketTypes.SET);
p.id = PlayerName;
p.key = PassKey;
p.ActionID = 0;
StreamController.StreamWrite(NetHelpers.ConvertStructToBytes(p));
}
public void GetPlayerInfo()
{
PlayerInfo playa = new PlayerInfo(PacketTypes.REQUEST);
playa.id = PlayerName;
playa.key = PassKey;
byte[] b = NetHelpers.ConvertStructToBytes(playa);
StreamController.StreamWrite(b);
}
static ILuaMultiValue _read(int[] opts, StreamReader s, ILuaEnvironment E)
{
List <ILuaValue> ret = new List <ILuaValue>();
foreach (var item in opts)
{
switch (item)
{
case -4:
ret.Add(E.Runtime.CreateValue(s.EndOfStream ? null : s.ReadLine() + "\n"));
break;
case -3:
ret.Add(E.Runtime.CreateValue(s.EndOfStream ? null : s.ReadLine()));
break;
case -2:
ret.Add(E.Runtime.CreateValue(s.EndOfStream ? null : s.ReadToEnd()));
break;
case -1:
if (s.EndOfStream)
{
ret.Add(null);
}
else
{
double?d = NetHelpers.ReadNumber(s);
if (d.HasValue)
{
ret.Add(E.Runtime.CreateValue(d.Value));
}
else
{
ret.Add(LuaNil.Nil);
}
}
break;
default:
if (s.EndOfStream)
{
ret.Add(null);
}
else
{
char[] c = new char[item];
s.Read(c, 0, item);
ret.Add(E.Runtime.CreateValue(new string(c)));
}
break;
}
}
return(E.Runtime.CreateMultiValue(ret.ToArray()));
}
public void ObfuscatePrivateIP()
{
Assert.Equal(3316510732u, NetHelpers.GetMsgIPAddress(IPAddress.Loopback).ObfuscatePrivateIP().v4);
Assert.Equal(new byte[] {
0x0D, 0xF0, 0xAD, 0xBA,
0x0D, 0xF0, 0xAD, 0xBA,
0x0D, 0xF0, 0xAD, 0xBA,
0x0D, 0xF0, 0xAD, 1 ^ 0xBA
}, NetHelpers.GetMsgIPAddress(IPAddress.IPv6Loopback).ObfuscatePrivateIP().v6);
}
public void GetMsgIPAddress()
{
Assert.Equal(2130706433u, NetHelpers.GetMsgIPAddress(IPAddress.Loopback).v4);
Assert.Equal(new byte[] {
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 0,
0, 0, 0, 1
}, NetHelpers.GetMsgIPAddress(IPAddress.IPv6Loopback).v6);
}
public void SetPlayerDirection(int dir, int moveCount)
{
PlayerControl playa = new PlayerControl(PacketTypes.SET);
playa.id = PlayerName;
playa.key = PassKey;
playa.direction = dir;
playa.paces = moveCount;
byte[] b = NetHelpers.ConvertStructToBytes(playa);
StreamController.StreamWrite(b);
}
public override void Generate(ItemData data)
{
var field = AddMethodArg(data, Method);
// define a non-conflict named method that will back the given method.
string name = Name;
if (data.Names.Contains(name))
{
name = name + "_" + (data.FID++);
}
data.Names.Add(name);
// Define the new method.
var param = BoundTo.GetParameters();
var meth = NetHelpers.CloneMethod(data.TB, name, BoundTo);
ILGenerator gen = meth.GetILGenerator();
// ILuaValue[] loc = new ILuaValue[{param.length}];
LocalBuilder loc = gen.CreateArray(typeof(ILuaValue), param.Length);
for (int ind = 0; ind < param.Length; ind++)
{
// loc[{ind}] = E.Runtime.CreateValue(arg_{ind});
gen.Emit(OpCodes.Ldloc, loc);
gen.Emit(OpCodes.Ldc_I4, ind);
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldfld, data.EnvField);
gen.Emit(OpCodes.Callvirt, typeof(ILuaEnvironment).GetProperty(nameof(ILuaEnvironment.Runtime)).GetGetMethod());
gen.Emit(OpCodes.Ldarg, ind + 1);
if (!param[ind].ParameterType.IsClass)
{
gen.Emit(OpCodes.Box, param[ind].ParameterType);
}
gen.Emit(OpCodes.Callvirt, typeof(ILuaRuntime).GetMethod(nameof(ILuaRuntime.CreateValue)));
gen.Emit(OpCodes.Stelem, typeof(ILuaValue));
}
// ILuaMultiValue args = E.Runtime.CreateMultiValue(loc);
var args = gen.DeclareLocal(typeof(ILuaMultiValue));
gen.Emit(OpCodes.Ldarg_0);
gen.Emit(OpCodes.Ldfld, data.EnvField);
gen.Emit(OpCodes.Callvirt, typeof(ILuaEnvironment).GetProperty(nameof(ILuaEnvironment.Runtime)).GetGetMethod());
gen.Emit(OpCodes.Ldloc, loc);
gen.Emit(OpCodes.Callvirt, typeof(ILuaRuntime).GetMethod(nameof(ILuaRuntime.CreateMultiValue)));
gen.Emit(OpCodes.Stloc, args);
CallFieldAndReturn(gen, BoundTo.ReturnType, field, args, data.EnvField);
// link our new method to the method it's bound to.
data.TB.DefineMethodOverride(meth, BoundTo);
data.Methods.Add(BoundTo);
}
/// <summary>
/// Creates a Socket server given an IP endpoint.
/// </summary>
/// <param name="address">The IP address and port of the server, as a string.</param>
/// <param name="serverRecord">A new <see cref="ServerRecord"/>, if the address was able to be parsed. <c>null</c> otherwise.</param>
/// <returns><c>true</c> if the address was able to be parsed, <c>false</c> otherwise.</returns>
public static bool TryCreateSocketServer(string address, [NotNullWhen(true)] out ServerRecord?serverRecord)
{
if (!NetHelpers.TryParseIPEndPoint(address, out var endPoint))
{
serverRecord = default(ServerRecord);
return(false);
}
serverRecord = new ServerRecord(endPoint, ProtocolTypes.Tcp | ProtocolTypes.Udp);
return(true);
}
public void Startup()
{
_telemetryData = new TelemetryData();
_timingData = new TimingData();
_analysisData = new AnalysisManager();
lsvPlugins.Items.Clear();
_plugins = new Dictionary <string, IGame>();
ICollection <IGame> plugins = PluginLoader <IGame> .LoadPlugins("Plugins");
if (plugins.Count > 0)
{
foreach (var item in plugins)
{
_plugins.Add(item.Name, item);
string[] lvText = new string[4];
lvText[0] = "";
lvText[1] = item.DisplayName;
lvText[2] = item.Version;
ListViewItem lvItem = new ListViewItem(lvText);
Bitmap pluginIcon = item.Icon;
if (pluginIcon != null)
{
imageListPlugins.Images.Add(item.Name, pluginIcon);
lvItem.ImageKey = item.Name;
}
else
{
lvItem.ImageKey = "missing";
}
lsvPlugins.Items.Add(lvItem);
}
_processMonitor = new ProcessMonitor(_plugins);
_processMonitor.GameLoadedEvent += new ProcessMonitor.GameLoaded(GameLoaded);
_processMonitor.GameClosedEvent += new ProcessMonitor.GameClosed(GameClosed);
_processMonitor.StartProcessMonitor();
_ipAddress = NetHelpers.GetLocalIpAddress();
StartWebServer();
}
else
{
MessageBox.Show("No Plugins Were Found, Application will now exit", "Plugin Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
this.Close();
}
}
void HandleCMList(IPacketMsg packetMsg)
{
var cmMsg = new ClientMsgProtobuf <CMsgClientCMList>(packetMsg);
DebugLog.Assert(cmMsg.Body.cm_addresses.Count == cmMsg.Body.cm_ports.Count, "CMClient", "HandleCMList received malformed message");
var cmList = cmMsg.Body.cm_addresses
.Zip(cmMsg.Body.cm_ports, (addr, port) => new IPEndPoint(NetHelpers.GetIPAddress(addr), ( int )port));
// update our list with steam's list of CMs
Servers.MergeWithList(cmList);
}
//What we should do instead is get a larger region (if not the whole region)
//Reduce the amount of times the cells need paged in.
public void GetRegionCells(int x1, int x2, int y1, int y2)
{
//pauseAsync = true;
RegionInfo ri = new RegionInfo(PacketTypes.REQUEST);
ri.x1 = x1;
ri.x2 = x2;
ri.y1 = y1;
ri.y2 = y2;
ri.regionDataTypes = WorldConstants.REGION_INFO_ALL;
StreamController.StreamWrite(NetHelpers.ConvertStructToBytes(ri));
}
public bool ProcessPacket(StreamWriter s, PacketTypes p, DataTypes d, byte[] buff, ref int offset)
{
try
{
switch (d)
{
//Package the Region Data and Send it
case DataTypes.REGION_INFO:
{
RegionInfo ri = NetHelpers.ConvertBytesToStruct <RegionInfo>(buff, ref offset);
ProcessRegionInfo(s, p, ri);
return(true);
}
case DataTypes.PLAYER_INFO:
{
PlayerInfo pi = NetHelpers.ConvertBytesToStruct <PlayerInfo>(buff, ref offset);
ProcessPlayerInfo(s, p, pi);
return(true);
}
case DataTypes.OBJECT_INFO:
{
ObjectInfo oi = NetHelpers.ConvertBytesToStruct <ObjectInfo>(buff, ref offset);
ProcessObjectInfo(s, p, oi);
return(true);
}
case DataTypes.PLAYER_CONTROL:
{
PlayerControl oi = NetHelpers.ConvertBytesToStruct <PlayerControl>(buff, ref offset);
ProcessPlayerControl(s, p, oi);
return(true);
}
case DataTypes.PLAYER_PERFORM_ACTION:
{
PlayerPerformAction oi = NetHelpers.ConvertBytesToStruct <PlayerPerformAction>(buff, ref offset);
ProcessPlayerAction(s, p, oi);
return(true);
}
default:
return(false);
}
}
catch
{
//Convert Bytes throws an exception if there isn't enough bytes to convert
return(false);
}
}
public void ObjectAdded(WorldObject o)
{
//At Some point restrict to only updates around players
var coord = o.GetPosition();
var pi = new ObjectInfo(PacketTypes.UPDATE)
{
id = o.Id,
objecttype = (int)o.ObjectType,
x = coord.x,
y = coord.y,
};
Net.BroadcastToClients(NetHelpers.ConvertStructToBytes(pi));
}
private bool ProcessPlayerInfo(StreamWriter s, PacketTypes p, PlayerInfo pi)
{
switch (p)
{
case PacketTypes.REQUEST:
{
Player playa = WorldInterface.GetPlayer(pi.id, pi.key);
if (playa != null)
{
PlayerID = pi.id;
var coord = playa.GetPosition();
var vel = playa.GetVelocity();
pi = new PlayerInfo(PacketTypes.REQUESTED)
{
id = playa.Id,
x = coord.x,
y = coord.y,
vx = vel.x,
vy = vel.y
};
s(NetHelpers.ConvertStructToBytes(pi));
//Send over object positions in the region surrounding our player
//DON'T DO THIS YET... Still thinking about it, Client needs to support it
foreach (var obj in WorldInterface.GetRegionObjects(coord.x - 10, coord.x + 10, coord.y - 10, coord.y + 10))
{
if (obj == null)
{
continue;
}
var oc = obj.GetPosition();
var oi = new ObjectInfo(PacketTypes.REQUESTED)
{
id = obj.Id,
objecttype = (int)obj.ObjectType,
x = oc.x,
y = oc.y,
vx = 0,
vy = 0,
};
s(NetHelpers.ConvertStructToBytes(oi));
}
}
return(true);
}
}
return(false);
}
void HandleServerList(IPacketMsg packetMsg)
{
var listMsg = new ClientMsgProtobuf <CMsgClientServerList>(packetMsg);
foreach (var server in listMsg.Body.servers)
{
var type = ( EServerType )server.server_type;
if (!serverMap.TryGetValue(type, out var endpointSet))
{
serverMap[type] = endpointSet = new HashSet <IPEndPoint>();
}
endpointSet.Add(new IPEndPoint(NetHelpers.GetIPAddress(server.server_ip), ( int )server.server_port));
}
}
public void UnloadOuter()
{
this.ReflectionHelpers = null;
this.PacketProtocolMngr = null;
this.ExceptionMngr = null;
this.Timers = null;
this.ConfigJson = null;
this.LogHelpers = null;
this.ModFeaturesHelpers = null;
this.BuffHelpers = null;
this.NetHelpers = null;
this.ItemIdentityHelpers = null;
this.NPCIdentityHelpers = null;
this.ProjectileIdentityHelpers = null;
this.BuffIdentityHelpers = null;
this.NPCBannerHelpers = null;
this.RecipeIdentityHelpers = null;
this.RecipeGroupHelpers = null;
this.PlayerHooks = null;
this.LoadHelpers = null;
this.GetModInfo = null;
this.GetModTags = null;
this.WorldStateHelpers = null;
this.ModLock = null;
this.EntityGroups = null;
this.AnimatedColors = null;
this.PlayerMessages = null;
this.Inbox = null;
this.ControlPanel = null;
this.MenuItemMngr = null;
this.MenuContextMngr = null;
this.MusicHelpers = null;
this.PlayerIdentityHelpers = null;
this.CustomEntMngr = null;
this.Promises = null;
this.DataStore = null;
this.CustomHotkeys = null;
this.XnaHelpers = null;
this.ServerInfo = null;
//this.PlayerDataMngr = null;
this.SupportInfo = null;
this.RecipeHack = null;
this.ModListHelpers = null;
this.ControlPanelHotkey = null;
this.DataDumpHotkey = null;
}
public void PlayerUpdated(Player p)
{
//Determine what information needs to be sent
//Back to the Client
var coord = p.GetPosition();
var v = p.GetVelocity();
var pi = new PlayerInfo(PacketTypes.UPDATE)
{
id = p.Id,
x = coord.x,
y = coord.y,
vx = v.x,
vy = v.y
};
Net.SendToPlayer(p.Id, NetHelpers.ConvertStructToBytes(pi));
}
public void MoverUpdated(Moveable m)
{
//At Some point restrict to only updates around players
var coord = m.GetPosition();
var v = m.GetVelocity();
var pi = new ObjectInfo(PacketTypes.UPDATE)
{
id = m.Id,
objecttype = (int)m.ObjectType,
x = coord.x,
y = coord.y,
vx = v.x,
vy = v.y
};
Net.BroadcastToClients(NetHelpers.ConvertStructToBytes(pi));
}
public static bool ProcessPacket(StreamWriter s, PacketTypes p, DataTypes d, byte[] buff, ref int offset)
{
try
{
switch (d)
{
//Package the Region Data and Send it
case DataTypes.CELL_INFO:
{
CellInfo ci = NetHelpers.ConvertBytesToStruct <CellInfo>(buff, ref offset);
ProcessCellInfo(s, p, ci);
return(true);
}
case DataTypes.REGION_INFO:
{
RegionInfo ri = NetHelpers.ConvertBytesToStruct <RegionInfo>(buff, ref offset);
ProcessRegionInfo(s, p, ri);
return(true);
}
case DataTypes.PLAYER_INFO:
{
PlayerInfo pi = NetHelpers.ConvertBytesToStruct <PlayerInfo>(buff, ref offset);
ProcessPlayerInfo(s, p, pi);
return(true);
}
case DataTypes.OBJECT_INFO:
{
ObjectInfo pi = NetHelpers.ConvertBytesToStruct <ObjectInfo>(buff, ref offset);
ProcessObjectInfo(s, p, pi);
return(true);
}
default:
return(false);
}
}
catch
{
//Convert Bytes throws an exception if there isn't enough bytes to convert
return(false);
}
}
private static void DoWorkToValidateServer(ServerBrowserEntry server_data, string hash)
{
string hash_base = "";
bool found = false;
for (int i = 0; i < 1000000; i++)
{
hash_base = i + "";
string test_hash = SystemHelpers.ComputeSHA256Hash(hash_base);
if (hash == test_hash)
{
found = true;
break;
}
}
if (!found)
{
LogHelpers.Log("Server browser processing failed; no matching hash.");
return;
}
var output_obj = new ServerBrowserWorkProof {
ServerIP = server_data.ServerIP,
Port = server_data.Port,
WorldName = server_data.WorldName,
HashBase = hash_base
};
string json_str = JsonConvert.SerializeObject(output_obj, Formatting.None);
byte[] json_bytes = Encoding.UTF8.GetBytes(json_str);
Thread.Sleep(1500);
NetHelpers.MakePostRequestAsync(ServerBrowserReporter.URL, json_bytes, delegate(string output) {
LogHelpers.Log("Server browser processing complete.");
}, delegate(Exception e, string output) {
LogHelpers.Log("Server browser reply returned error: " + e.ToString());
});
ServerBrowserReporter.LastSendTimestamp = SystemHelpers.TimeStampInSeconds();
}
private void LoadOuter()
{
this.ReflectionHelpers = new ReflectionHelpers();
this.DataStore = new DataStore();
this.Promises = new Promises();
this.LoadHelpers = new LoadHelpers();
this.Timers = new Timers();
this.LogHelpers = new LogHelpers();
this.ModFeaturesHelpers = new ModFeaturesHelpers();
this.PacketProtocolMngr = new PacketProtocolManager();
this.BuffHelpers = new BuffHelpers();
this.NetHelpers = new NetHelpers();
this.ItemIdentityHelpers = new ItemIdentityHelpers();
this.NPCIdentityHelpers = new NPCIdentityHelpers();
this.ProjectileIdentityHelpers = new ProjectileIdentityHelpers();
this.BuffIdentityHelpers = new BuffIdentityHelpers();
this.NPCBannerHelpers = new NPCBannerHelpers();
this.RecipeIdentityHelpers = new RecipeIdentityHelpers();
this.RecipeGroupHelpers = new RecipeGroupHelpers();
this.PlayerHooks = new ExtendedPlayerHooks();
this.WorldStateHelpers = new WorldStateHelpers();
this.ControlPanel = new UIControlPanel();
this.ModLock = new ModLockService();
this.EntityGroups = new EntityGroups();
this.PlayerMessages = new PlayerMessages();
this.Inbox = new InboxControl();
this.GetModInfo = new GetModInfo();
this.GetModTags = new GetModTags();
this.MenuItemMngr = new MenuItemManager();
this.MenuContextMngr = new MenuContextServiceManager();
this.MusicHelpers = new MusicHelpers();
this.PlayerIdentityHelpers = new PlayerIdentityHelpers();
this.CustomEntMngr = new CustomEntityManager();
this.CustomHotkeys = new CustomHotkeys();
this.XnaHelpers = new XnaHelpers();
this.ServerInfo = new ServerInfo();
//this.PlayerDataMngr = new PlayerDataManager();
this.SupportInfo = new SupportInfoDisplay();
this.RecipeHack = new RecipeHack();
this.ModListHelpers = new ModListHelpers();
}
