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); } } }