private static void Postfix(ZNet __instance)
{
var l = BepInEx.Logging.Logger.CreateLogSource("ServerSideMap");
var world = Traverse.Create(typeof(ZNet)).Field("m_world").GetValue() as World;
var m_worldSavePath = Traverse.Create(world).Field("m_worldSavePath").GetValue() as String;
string exploredPath = m_worldSavePath + "/" + world.m_name + ".mod.serversidemap.explored";
FileStream fileStream;
try
{
fileStream = File.OpenRead(exploredPath);
}
catch
{
var z = new ZPackage();
z.Write((int)3);
z.Write(mapSize);
for (var i = 0; i < mapSize * mapSize; i++)
{
z.Write(false);
}
z.Write(0);
mapData = z.GetArray();
l.LogInfo("new explore file generated");
__instance.Save(true);
return;
}
BinaryReader reader = new BinaryReader((Stream)fileStream);
mapData = reader.ReadBytes(int.MaxValue);
l.LogInfo("loaded from existing explore file");
}
public static void OnClientExplore(ZRpc client, int x, int y)
{
if (!Store.IsSharingMap())
{
return;
}
ExplorationDatabase.SetExplored(x, y);
var znet = Traverse.Create(typeof(ZNet)).Field("m_instance").GetValue() as ZNet;
var mPeers = Traverse.Create((znet)).Field("m_peers").GetValue() as List <ZNetPeer>;
foreach (var peer in mPeers)
{
if (peer.IsReady())
{
if (peer.m_rpc == client)
{
continue;
}
var z = new ZPackage();
z.Write(x);
z.Write(y);
peer.m_rpc.Invoke("OnReceiveMapData", (object)z);
}
}
var zz = new ZPackage();
zz.Write(x);
zz.Write(y);
ExplorationDatabase.OnReceiveMapData(null, zz);
}
private static void onClientExplore(ZRpc client, int x, int y)
{
setExplored(x, y);
// public bool IsConnected(long uid)
// {
// if (uid == this.GetUID())
// return true;
// foreach (ZNetPeer peer in this.m_peers)
// {
// if (peer.m_uid == uid)
// return true;
// }
// return false;
// }
var znet = Traverse.Create(typeof(ZNet)).Field("m_instance").GetValue() as ZNet;
var m_peers = Traverse.Create((znet)).Field("m_peers").GetValue() as List <ZNetPeer>;
foreach (ZNetPeer peer in m_peers)
{
if (peer.IsReady())
{
if (peer.m_rpc == client)
{
continue;
}
var z = new ZPackage();
z.Write(x);
z.Write(y);
peer.m_rpc.Invoke("OnReceiveMapData", (object)z);
}
}
}
static bool ZNet_SetCharacterID(ZNet __instance, ZDOID id, ISocket ___m_hostSocket, List <ZNetPeer> ___m_peers)
{
ZPackage characterIdPackage = new ZPackage();
characterIdPackage.Write(id);
Player myPlayer = Player.m_localPlayer;
if (myPlayer != null)
{
Inventory myInventory = myPlayer.GetInventory();
if (myInventory != null)
{
characterIdPackage.Write(Helper.PackageInventory(myPlayer.GetPlayerName(), myInventory));
if (Configs.ShowDebugMessages.Value)
{
UnityEngine.Debug.Log("Sent inventory to server.");
}
}
else if (Configs.ShowDebugMessages.Value)
{
UnityEngine.Debug.Log("Player inventory was null!");
}
}
else if (Configs.ShowDebugMessages.Value)
{
UnityEngine.Debug.Log("Player was null!");
}
___m_peers[0].m_rpc.Invoke("CharacterIDX", new object[] { characterIdPackage });
return(false);
}
public static void SendQueuedExploreData(Minimap instance)
{
if (explorationQueue.Count == 0)
{
return;
}
// disregard mini changes for now, lets build up some first
if (explorationQueue.Count < 10)
{
return;
}
Logger.LogDebug($"UpdateExplore - sending newly explored locations to server ({explorationQueue.Count})");
var toSend = new List <int>();
lock (explorationQueue)
{
toSend.AddRange(explorationQueue.Distinct());
explorationQueue.Clear();
}
var queueData = new ZPackage();
queueData.Write(toSend.Count);
foreach (var data in toSend)
{
queueData.Write(data);
}
// Invoke RPC on server and send data
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), nameof(RPC_ReceiveExploration_OnExplore), queueData);
}
public static ZPackage PackBoolArray(bool[] arr, int chunkId, int startIndex, int size)
{
ZPackage z = new ZPackage();
z.Write(chunkId);
byte currentByte = 0;
int currentIndex = 0;
for (var i = startIndex; i < startIndex + size; i++)
{
var value = arr[i];
if (value)
{
byte mask = (byte)(1 << currentIndex);
currentByte |= mask;
}
currentIndex += 1;
if (currentIndex >= 8)
{
z.Write(currentByte);
currentByte = 0;
currentIndex = 0;
}
}
if (currentIndex > 0)
{
z.Write(currentByte);
}
// Utility.Log("Compressed exploration array: " + size + ":" + z.Size());
return(z);
}
public void Save(ZPackage pkg)
{
var mutable = m_properties.Where((i) => i.Value.m_mutable);
pkg.Write(mutable.Count());
foreach (var item in mutable)
{
pkg.Write(item.Key);
var val = item.Value.m_value;
if (val is float)
{
pkg.Write((int)TyrDataType.FLOAT);
pkg.Write(item.Value.GetValue <float>());
}
else if (val is int)
{
pkg.Write((int)TyrDataType.INT);
pkg.Write(item.Value.GetValue <int>());
}
else if (val is long)
{
pkg.Write((int)TyrDataType.LONG);
pkg.Write(item.Value.GetValue <long>());
}
else if (val is string)
{
pkg.Write((int)TyrDataType.STRING);
pkg.Write(item.Value.GetValue <string>());
}
}
}
/// <summary>
/// Send queued exploration data to server
/// </summary>
private static void SendQueuedExploreData(On.Minimap.orig_UpdateExplore orig, Minimap self, float dt, Player player)
{
bool doPayload = self.m_exploreTimer + Time.deltaTime > self.m_exploreInterval;
orig(self, dt, player);
// disregard mini changes for now, lets build up some first
if (explorationQueue.Count >= 10 && doPayload)
{
Logger.LogDebug($"UpdateExplore - sending newly explored locations to server ({explorationQueue.Count})");
var toSend = new List <int>();
lock (explorationQueue)
{
toSend.AddRange(explorationQueue.Distinct());
explorationQueue.Clear();
}
var queueData = new ZPackage();
queueData.Write(toSend.Count);
foreach (var data in toSend)
{
queueData.Write(data);
}
// Invoke RPC on server and send data
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), nameof(RPC_Veilheim_ReceiveExploration_OnExplore), queueData);
}
}
public static void RPC_RequestSync(long sender, ZPackage pkg)
{
ZNetPeer peer = ZNet.instance.GetPeer(sender); // Get the Peer from the sender
if (peer != null)
{ // Confirm the peer exists
ZPackage timePkg = new ZPackage();
String tod_str = EnvMan.instance.m_debugTime.ToString();
timePkg.Write(tod_str);
ZPackage weatherPkg = new ZPackage();
String env_str = EnvMan.instance.m_debugEnv;
weatherPkg.Write(env_str);
UnityEngine.Debug.Log("syncing with clients...");
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "EventTestConnection", new object[] { new ZPackage() });
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "EventSetTime", new object[] { timePkg });
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "EventSetWeather", new object[] { weatherPkg });
foreach (string name in GamanMaker.invisible_players)
{
pkg.Write(name);
pkg.Write(false);
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "EventSetVisible", new object[] { pkg });
}
}
else
{
ZPackage newPkg = new ZPackage(); // Create a new ZPackage.
newPkg.Write("Peer doesn't exist"); // Tell them what's going on.
ZRoutedRpc.instance.InvokeRoutedRPC(sender, "BadRequestMsg", new object[] { newPkg }); // Send the error message.
}
}
/// <summary>
/// Coroutine to send a package to a list of peers. Compresses and fragments the package if necessary.
/// </summary>
/// <param name="peers"></param>
/// <param name="package"></param>
/// <returns></returns>
public IEnumerator SendPackageRoutine(List <ZNetPeer> peers, ZPackage package)
{
if (!ZNet.instance)
{
yield break;
}
if (peers.Count == 0)
{
yield break;
}
try
{
++SendCount;
byte[] originalData = package.GetArray();
ZPackage jotunnpackage = new ZPackage();
jotunnpackage.Write(JOTUNN_PACKAGE);
jotunnpackage.Write(originalData);
package = jotunnpackage;
const int compressMinSize = 10000;
if (package.Size() > compressMinSize)
{
byte[] rawData = package.GetArray();
Logger.LogDebug($"[{ID}] Compressing package with length {rawData.Length}");
ZPackage compressedPackage = new ZPackage();
compressedPackage.Write(COMPRESSED_PACKAGE);
MemoryStream output = new MemoryStream();
using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
{
deflateStream.Write(rawData, 0, rawData.Length);
}
compressedPackage.Write(output.ToArray());
package = compressedPackage;
}
List <IEnumerator <bool> > writers =
peers.Where(peer => peer.IsReady()).Select(p => SendToPeer(p, package)).ToList();
writers.RemoveAll(writer => !writer.MoveNext());
while (writers.Count > 0)
{
yield return(null);
writers.RemoveAll(writer => !writer.MoveNext());
}
}
finally
{
--SendCount;
}
}
public void Serialize(ZPackage pkg)
{
noiseSettings.Serialize(pkg);
pkg.Write(noiseWarpSettings != null);
noiseWarpSettings?.Serialize(pkg);
pkg.Write(maskSettings != null);
maskSettings?.Serialize(pkg);
pkg.Write(maskWarpSettings != null);
maskWarpSettings?.Serialize(pkg);
}
public byte[] GetMergedMapData(long profileId, bool bMergePins)
{
ZPackage zPackage = new ZPackage();
zPackage.Write(_mapData.m_mapVersion);
zPackage.Write(_mapData.m_textureSize);
for (int i = 0; i < (_mapData.m_textureSize * _mapData.m_textureSize); i++)
{
zPackage.Write(_mapData.m_mergedWorld[i]);
}
List <Pin> pins = _mapData.GetPins(profileId, bMergePins);
zPackage.Write(pins.Count);
foreach (Pin p in pins)
{
zPackage.Write(p.Name);
zPackage.Write(p.Pos);
zPackage.Write((int)p.Type);
zPackage.Write(p.IsChecked);
}
zPackage.Write(_mapData.m_isReferencePositionPublic);
return(zPackage.GetArray());
}
public ZPackage ToZPackage()
{
var package = new ZPackage();
package.Write(this.Count());
foreach (ZDOID zdoid in this)
{
package.Write(zdoid);
}
return(package);
}
public static void WriteServerKnownMats(Dictionary <long, HashSet <string> > dict, ZPackage pkg)
{
pkg.Write(dict.Count);
foreach (var kvp in dict)
{
var pkg2 = new ZPackage();
pkg2.Write(kvp.Key);
WriteKnownMats(kvp.Value, pkg2);
pkg.Write(pkg2);
}
}
public void Save(ZPackage pkg)
{
pkg.Write(2);
pkg.Write(this.m_skillData.Count);
foreach (KeyValuePair <Skills.SkillType, Skills.Skill> keyValuePair in this.m_skillData)
{
pkg.Write((int)keyValuePair.Value.m_info.m_skill);
pkg.Write(keyValuePair.Value.m_level);
pkg.Write(keyValuePair.Value.m_accumulator);
}
}
public static void WriteKnownRecipes(HashSet <string> known, ZPackage outPkg)
{
var pkg = new ZPackage();
pkg.Write(known.Count);
foreach (var s in known)
{
pkg.Write(s);
}
outPkg.Write(pkg);
}
public static void WriteKnown(HashSet <string> known, ZPackage outPkg)
{
ZPackage pkg = new ZPackage();
pkg.Write(known.Count);
foreach (string s in known)
{
pkg.Write(s);
}
outPkg.Write(pkg);
}
public static void Save(ZPackage pkg, Skills skills)
{
pkg.Write(2);
pkg.Write(skills.m_skillData.Count);
foreach (var skill in skills.m_skillData)
{
pkg.Write((int)skill.skillType);
pkg.Write(skill.m_level);
pkg.Write(skill.m_accumulator);
}
}
// Token: 0x06000E1F RID: 3615 RVA: 0x00064C2C File Offset: 0x00062E2C
private void SaveHealth()
{
ZPackage zpackage = new ZPackage();
zpackage.Write(this.m_hitAreas.Count);
foreach (MineRock5.HitArea hitArea in this.m_hitAreas)
{
zpackage.Write(hitArea.m_health);
}
this.m_nview.GetZDO().Set("health", zpackage.GetArray());
this.m_lastDataRevision = this.m_nview.GetZDO().m_dataRevision;
}
// Token: 0x0600073B RID: 1851 RVA: 0x0003A618 File Offset: 0x00038818
private void Ping()
{
IPEndPoint remoteEP = new IPEndPoint(IPAddress.Broadcast, 6542);
ZPackage zpackage = new ZPackage();
zpackage.Write('F');
zpackage.Write('E');
zpackage.Write('J');
zpackage.Write('D');
zpackage.Write(this.m_myPort);
this.m_socket.SendTo(zpackage.GetArray(), remoteEP);
}
// Token: 0x060004DC RID: 1244 RVA: 0x000284B8 File Offset: 0x000266B8
public void ShowText(DamageText.TextType type, Vector3 pos, float dmg, bool player = false)
{
ZPackage zpackage = new ZPackage();
zpackage.Write((int)type);
zpackage.Write(pos);
zpackage.Write(dmg);
zpackage.Write(player);
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.Everybody, "DamageText", new object[]
{
zpackage
});
}
public static ZPackage SerializeCacheList()
{
var items = GetCacheList();
var pkg = new ZPackage();
pkg.Write(items.Count);
foreach (var item in items)
{
pkg.Write(item);
}
return(pkg);
}
public static ZPackage Default()
{
var z = new ZPackage();
z.Write((int)3);
z.Write(MapSize);
for (var i = 0; i < MapSizeSquared; i++)
{
z.Write(false);
}
z.Write((int)0);
z.SetPos(0);
return(z);
}
public static ZPackage GetMapData()
{
var z = new ZPackage();
z.Write((int)3);
z.Write(MapSize);
foreach (var t in Explored)
{
z.Write(t);
}
z.Write((int)ServerPins.Count);
Utility.Log("Map saved. Pin Count: " + ServerPins.Count);
foreach (var pin in ServerPins)
{
z.Write(pin.Name);
z.Write(pin.Pos);
z.Write((int)pin.Type);
z.Write(pin.Checked);
}
return(z);
}
public static ZPackage PackPin(PinData pin, bool skipSetPos = false)
{
var z = new ZPackage();
z.Write(pin.Name);
z.Write(pin.Pos);
z.Write((int)pin.Type);
z.Write(pin.Checked);
if (!skipSetPos)
{
z.SetPos(0);
}
return(z);
}
public void Serialize(ZPackage to)
{
to.Write(RemainingSpawnAreas.Count);
foreach (var kv in RemainingSpawnAreas)
{
to.Write(kv.Key);
to.Write(kv.Value.Count);
foreach (var v in kv.Value)
{
to.Write(v.x);
to.Write(v.y);
}
}
}
private static void SyncToClients(string inputCopy)
{
var zPgk = new ZPackage();
zPgk.Write(inputCopy);
ZRoutedRpc.instance.InvokeRoutedRPC(nameof(RPC_SetConfigurationValue), zPgk);
}
public static void ReloadDefault()
{
ZPackage pkg = new ZPackage();
pkg.Write("ReloadDefault");
ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "ReloadDefault", new object[] { pkg });
}
public static ZPackage PackPins(List <PinData> pins)
{
var z = new ZPackage();
z.Write((int)pins.Count);
foreach (var pin in pins)
{
z.Write(pin.Name);
z.Write(pin.Pos);
z.Write((int)pin.Type);
z.Write(pin.Checked);
}
z.SetPos(0);
Utility.Log("Packing pins: " + pins.Count);
return(z);
}
public static void RPC_ConfigSync(long sender, ZPackage configPkg)
{
if (ZNet.m_isServer) //Server
{
Logger.LogInfo($"Sending configuration data to peer #{sender}");
if (Configuration.Current == null)
{
Configuration.LoadConfiguration();
}
var pkg = new ZPackage();
var data = Configuration.Current.GetSyncableSections();
//Add number of clean lines to package
pkg.Write(data);
ZRoutedRpc.instance.InvokeRoutedRPC(sender, nameof(RPC_ConfigSync), pkg);
}
else //Client
{
if (configPkg != null && configPkg.Size() > 0 && sender == ZRoutedRpc.instance.GetServerPeerID()
) // Validate the message is from the server and not another client.
{
Logger.LogInfo("Received configuration data from server.");
var receivedConfig = new Configuration();
Configuration.LoadFromIniString(receivedConfig, configPkg.ReadString());
Configuration.SetSyncableValues(receivedConfig);
}
}
}
