private static IEnumerator SendChunkToServer(ZRpc client, int chunk)
{
if (chunk >= CHUNKS)
{
yield break;
}
var size = ExplorationDatabase.MapSizeSquared / CHUNKS;
var startIndex = chunk * (ExplorationDatabase.MapSizeSquared / CHUNKS);
var explored = Traverse.Create(_Minimap._instance).Field("m_explored").GetValue() as bool[];
var z = ExplorationDatabase.PackBoolArray(explored, chunk, startIndex, size);
if (client == null)
{
OnClientInitialData(null, z);
}
else
{
yield return(new WaitUntil(() => _ZNet.GetServerRPC(_ZNet._instance) != null));
var server = _ZNet.GetServerRPC(_ZNet._instance);
server.Invoke("OnClientInitialData", (object)z);
}
}
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);
}
public static void OnServerRemovePin(ZRpc _, ZPackage pinData)
{
if (!Store.IsSharingPin())
{
return;
}
pinData.SetPos(0);
Utility.Log("Client deleted pin by server");
var pin = ExplorationDatabase.UnpackPin(pinData);
foreach (var clientPin in ExplorationDatabase.ClientPins.ToList())
{
if (UtilityPin.ArePinsEqual(clientPin, pin))
{
ExplorationDatabase.ClientPins.Remove(clientPin);
}
}
var mapPin = UtilityPin.GetMapPin(pin);
if (mapPin == null)
{
return;
}
_Minimap.RemovePin(_Minimap._instance, mapPin);
}
public static void OnClientRemovePin(ZRpc client, ZPackage pinData)
{
if (!Store.IsSharingPin())
{
return;
}
pinData.SetPos(0);
var znet = Traverse.Create(typeof(ZNet)).Field("m_instance").GetValue() as ZNet;
var mPeers = Traverse.Create((znet)).Field("m_peers").GetValue() as List <ZNetPeer>;
var pin = ExplorationDatabase.UnpackPin(pinData);
ExplorationDatabase.RemovePinEqual(pin);
Utility.Log("Server deleted pin by client");
foreach (var peer in mPeers)
{
if (peer.IsReady())
{
if (peer.m_rpc == client)
{
continue;
}
peer.m_rpc.Invoke("OnServerRemovePin", (object)ExplorationDatabase.PackPin(pin));
}
}
if (client != null)
{
OnServerRemovePin(null, ExplorationDatabase.PackPin(pin));
}
}
private static void SendPinsToServer(ZRpc client)
{
var pins = Traverse.Create(_Minimap._instance).Field("m_pins").GetValue() as List <Minimap.PinData>;
var filteredPins = new List <PinData>();
foreach (var pin in pins)
{
if (pin.m_save)
{
filteredPins.Add(UtilityPin.ConvertPin(pin));
}
}
var z = ExplorationDatabase.PackPins(filteredPins);
if (client == null)
{
OnClientInitialDataPin(null, z);
}
else
{
var znet = Traverse.Create(typeof(ZNet)).Field("m_instance").GetValue() as ZNet;
var server = _ZNet.GetServerRPC(znet);
server.Invoke("OnClientInitialDataPin", (object)z);
}
}
public static void OnServerCheckPin(ZRpc client, ZPackage data)
{
if (!Store.IsSharingPin())
{
return;
}
data.SetPos(0);
Utility.Log("Client checked pin by server");
var pin = ExplorationDatabase.UnpackPin(data);
var state = data.ReadBool();
foreach (var clientPin in ExplorationDatabase.ClientPins.ToList())
{
if (UtilityPin.ArePinsEqual(clientPin, pin))
{
clientPin.Checked = state;
var mapPin = UtilityPin.GetMapPin(clientPin);
if (mapPin != null)
{
mapPin.m_checked = state;
}
}
}
}
public static void OnReceiveMapDataInitial(ZRpc client, ZPackage mapData)
{
if (!Store.IsSharingMap())
{
return;
}
mapData.SetPos(0);
var chunk = mapData.ReadInt();
//Utility.Log("Client received initial map data by server chunk " + (chunk+1) + "/" + CHUNKS);
var explored = ExplorationDatabase.UnpackBoolArray(mapData, ExplorationDatabase.MapSizeSquared / CHUNKS);
var startIndex = chunk * (ExplorationDatabase.MapSizeSquared / CHUNKS);
for (var index = 0; index < explored.Length; index++)
{
if (explored[index])
{
_Minimap.Explore(_Minimap._instance, (startIndex + index) % ExplorationDatabase.MapSize, (startIndex + index) / ExplorationDatabase.MapSize);
}
}
var fogTexture = Traverse.Create((_Minimap._instance)).Field("m_fogTexture").GetValue() as Texture2D;
fogTexture.Apply();
_ZNet._instance.StartCoroutine(SendChunkToServer(client, chunk));
// var explored = ExplorationDatabase.UnpackBoolArray(mapData);
//
// for (var index = 0; index < explored.Length; index++)
// {
// if (explored[index])
// {
// _Minimap.Explore(_Minimap._instance, index % ExplorationDatabase.MapSize, index / ExplorationDatabase.MapSize);
// }
// }
//
// var fogTexture = Traverse.Create((_Minimap._instance)).Field("m_fogTexture").GetValue() as Texture2D;
// fogTexture.Apply();
//
// explored = Traverse.Create(_Minimap._instance).Field("m_explored").GetValue() as bool[];
// var z = ExplorationDatabase.PackBoolArray(explored);
// if (_ZNet.IsServer(_ZNet._instance))
// {
// OnClientInitialData(null, z);
// }
// else
// {
// var znet = Traverse.Create(typeof(ZNet)).Field("m_instance").GetValue() as ZNet;
// ZRpc server = _ZNet.GetServerRPC(znet);
// server.Invoke("OnClientInitialData", (object) z);
// }
}
public static void OnServerAddPin(ZRpc client, ZPackage pinData)
{
if (!Store.IsSharingPin())
{
return;
}
pinData.SetPos(0);
var pin = ExplorationDatabase.UnpackPin(pinData);
_Minimap.AddPin(_Minimap._instance, pin.Pos, pin.Type, pin.Name, false, pin.Checked, 0);
ExplorationDatabase.ClientPins.Add(pin);
Utility.Log("Client received pin by server");
}
// ReSharper disable once InconsistentNaming
private static void Postfix()
{
var world = Traverse.Create(typeof(ZNet)).Field("m_world").GetValue() as World;
var worldSavePath = System.IO.Path.ChangeExtension(world.GetDBPath(), null);
var exploredPath = worldSavePath + ".mod.serversidemap.explored";
Utility.Log("World .explored save path: " + worldSavePath);
FileStream fileStream = File.Create(exploredPath);
BinaryWriter writer = new BinaryWriter(fileStream);
writer.Write(ExplorationDatabase.GetMapData().GetArray());
writer.Flush();
fileStream.Flush(true);
fileStream.Close();
fileStream.Dispose();
}
public static void OnReceiveInitialDataPin(ZRpc client, ZPackage pinData)
{
// SendPinsToServer(client);
Store.ServerPinShare = true;
if (!Store.IsSharingPin())
{
return;
}
var pins = ExplorationDatabase.UnpackPins(pinData);
Utility.Log("Client received initial pin data by server. Pins: " + pins.Count);
ExplorationDatabase.ClientPins = pins;
ClientAppendPins();
}
private static void SendPinsToClient(ZRpc client)
{
if (!Store.IsSharingPin())
{
return;
}
var z = ExplorationDatabase.PackPins(ExplorationDatabase.GetPins());
if (client == null)
{
OnReceiveInitialDataPin(null, z);
}
else
{
client.Invoke("OnReceiveInitialDataPin", (object)z);
}
}
public static void OnClientInitialData(ZRpc client, ZPackage mapData)
{
if (!Store.IsSharingMap())
{
return;
}
mapData.SetPos(0);
var chunk = mapData.ReadInt();
var startIndex = chunk * (ExplorationDatabase.MapSizeSquared / CHUNKS);
var size = ExplorationDatabase.MapSizeSquared / CHUNKS;
//Utility.Log("Server received initial map data by client chunk " + (chunk+1) + "/" + CHUNKS);
ExplorationDatabase.MergeExplorationArray(ExplorationDatabase.UnpackBoolArray(mapData, size), startIndex, size);
SendChunkToClient(client, chunk + 1);
}
private static void SendChunkToClient(ZRpc client, int chunk)
{
if (chunk >= CHUNKS)
{
return;
}
var size = ExplorationDatabase.MapSizeSquared / CHUNKS;
var startIndex = chunk * (ExplorationDatabase.MapSizeSquared / CHUNKS);
var z = ExplorationDatabase.PackBoolArray(ExplorationDatabase.GetExplorationArray(), chunk, startIndex, size);
if (client == null)
{
OnReceiveMapDataInitial(null, z);
}
else
{
client.Invoke("OnReceiveMapDataInitial", (object)z);
}
}
public static void RemovePinFromServer(PinData pin)
{
if (!Store.IsSharingPin())
{
return;
}
var data = ExplorationDatabase.PackPin(pin);
ExplorationDatabase.ClientPins.Remove(pin);
if (!_ZNet.IsServer(_ZNet._instance))
{
_ZNet.GetServerRPC(_ZNet._instance).Invoke("OnClientRemovePin", data);
}
else
{
OnClientRemovePin(null, data);
}
}
public static void CheckPinOnServer(PinData pin, bool state)
{
if (!Store.IsSharingPin())
{
return;
}
var data = ExplorationDatabase.PackPin(pin, true);
data.Write(state);
data.SetPos(0);
if (!_ZNet.IsServer(_ZNet._instance))
{
_ZNet.GetServerRPC(_ZNet._instance).Invoke("OnClientCheckPin", data);
}
else
{
OnClientCheckPin(null, data);
}
}
// ReSharper disable once InconsistentNaming
private static void Postfix(ZNet __instance)
{
var world = Traverse.Create(typeof(ZNet)).Field("m_world").GetValue() as World;
var worldSavePath = System.IO.Path.ChangeExtension(world.GetDBPath(), null);
Utility.Log("World .explored save path: " + worldSavePath);
var exploredPath = worldSavePath + ".mod.serversidemap.explored";
// Make one time backup before hs
var backupPath = exploredPath + ".beforehs";
if (File.Exists(exploredPath) && !File.Exists(backupPath))
{
File.Copy(exploredPath, backupPath);
}
//
FileStream fileStream;
try
{
fileStream = File.OpenRead(exploredPath);
}
catch
{
// ReSharper disable once RedundantCast
ExplorationDatabase.SetMapData(ExplorationDatabase.Default());
Utility.Log("new explore file generated");
__instance.Save(true);
return;
}
BinaryReader reader = new BinaryReader(fileStream);
// var data = reader.ReadBytes(int.MaxValue);
var data = reader.ReadAllBytes();
var z = new ZPackage(data);
ExplorationDatabase.SetMapData(z);
Utility.Log("loaded from existing explore file");
}
public static void SendPinToServer(Minimap.PinData pin, bool deletePin = true)
{
if (!Store.IsSharingPin())
{
return;
}
var convertedPin = UtilityPin.ConvertPin(pin);
var data = ExplorationDatabase.PackPin(convertedPin);
pin.m_save = !deletePin && pin.m_save;
ExplorationDatabase.ClientPins.Add(convertedPin);
if (!_ZNet.IsServer(_ZNet._instance))
{
_ZNet.GetServerRPC(_ZNet._instance).Invoke("OnClientAddPin", data);
}
else
{
OnClientAddPin(null, data);
}
}
public static void OnClientCheckPin(ZRpc client, ZPackage data)
{
if (!Store.IsSharingPin())
{
return;
}
data.SetPos(0);
Utility.Log("Server checked pin by client");
var pin = ExplorationDatabase.UnpackPin(data);
var state = data.ReadBool();
ExplorationDatabase.SetPinState(pin, state);
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 = ExplorationDatabase.PackPin(pin, true);
z.Write(state);
peer.m_rpc.Invoke("OnServerCheckPin", (object)z);
}
}
if (client != null)
{
var z = ExplorationDatabase.PackPin(pin, true);
z.Write(state);
OnServerCheckPin(null, z);
}
}
