public static bool ParseServerArguments_modded(FejdStartup __instance, ref bool __result)
        {
            __instance.m_minimumPasswordLength = -1;

            string location = config.Location;

            if (!location.IsNullOrWhiteSpace())
            {
                Utils.SetSaveDataPath(location);
            }

            World createWorld = World.GetCreateWorld(config.WorldName);

            string serverName = config.ServerName;
            string password   = config.Password;

            if (!helper.isPasswordValid(password, createWorld, serverName))
            {
                ZLog.LogError("Error bad password because its displayd in server/map name or seed");
                Application.Quit();

                __result = false;
                return(false);
            }

            bool publiclyVisable = config.Visable;

            ZNet.SetServer(true, true, publiclyVisable, serverName, password, createWorld);
            ZNet.ResetServerHost();
            ZSteamSocket.SetDataPort(config.ServerPort);
            SteamManager.SetServerPort(config.ServerPort);

            __result = true;
            return(false);
        }
Esempio n. 2
0
 static void Postfix(ZNet __instance, ref ZNetPeer peer, ref RectTransform ___m_connectingDialog, ref RectTransform ___m_passwordDialog)
 {
     peer.m_rpc.Register <bool>("ClientHandshake", RPC_ClientHandshake);
     m_connectingDialog = ___m_connectingDialog;
     m_passwordDialog   = ___m_passwordDialog;
     m_instance         = __instance;
 }
 // ReSharper disable once InconsistentNaming
 private static void Postfix(ZRpc rpc, ZNet __instance)
 {
     if (__instance.IsServer())
     {
         SendPinsToClient(rpc);
     }
 }
Esempio n. 4
0
        private static void ZNet__SendPeerInfo(ZNet __instance, ZRpc rpc)
        {
            // Run away clients, we don't want you here!?!?ZoneHandler.Serialize
            if (!__instance.IsServer())
            {
                return;
            }

            // Syncing Zone Handler Settings.
#if DEBUG
            Debug.Log("S2C ZoneHandler (SendPeerInfo)");
            ZoneHandler._debug();
#endif
            Game.instance.StartCoroutine(Util.ZoneHandler2(rpc));
            // Syncing the Client State with the server defaults.
#if DEBUG
            Debug.Log("S2C ClientState (SendPeerInfo)");
            Client._debug();
#endif
            Game.instance.StartCoroutine(Util.Client2(rpc));
            Util.Connections.Add(new Util.ConnectionData
            {
                rpc = rpc
            });
        }
Esempio n. 5
0
            // ReSharper disable once InconsistentNaming
            private static void Postfix(ZNetPeer peer, ZNet __instance)
            {
                if (__instance.IsServer())
                {
                    Utility.Log("Registered Server Events");

                    if (Store.IsSharingMap())
                    {
                        peer.m_rpc.Register <int, int>("OnClientExplore", new Action <ZRpc, int, int>(ExplorationMapSync.OnClientExplore));
                        peer.m_rpc.Register <ZPackage>("OnClientInitialData", new Action <ZRpc, ZPackage>(InitialMapSync.OnClientInitialData));
                    }

                    peer.m_rpc.Register <ZPackage>("OnClientInitialDataPin", new Action <ZRpc, ZPackage>(InitialPinSync.OnClientInitialDataPin));
                    peer.m_rpc.Register <ZPackage>("OnClientAddPin", new Action <ZRpc, ZPackage>(PinSync.OnClientAddPin));
                    peer.m_rpc.Register <ZPackage>("OnClientRemovePin", new Action <ZRpc, ZPackage>(PinSync.OnClientRemovePin));
                    peer.m_rpc.Register <ZPackage>("OnClientCheckPin", new Action <ZRpc, ZPackage>(PinSync.OnClientCheckPin));
                }
                else
                {
                    Utility.Log("Registered Client Events");

                    if (Store.IsSharingMap())
                    {
                        peer.m_rpc.Register <ZPackage>("OnReceiveMapData", new Action <ZRpc, ZPackage>(ExplorationDatabase.OnReceiveMapData));
                        peer.m_rpc.Register <ZPackage>("OnReceiveMapDataInitial", new Action <ZRpc, ZPackage>(InitialMapSync.OnReceiveMapDataInitial));
                    }

                    peer.m_rpc.Register <ZPackage>("OnReceiveInitialDataPin", new Action <ZRpc, ZPackage>(InitialPinSync.OnReceiveInitialDataPin));
                    peer.m_rpc.Register <ZPackage>("OnServerAddPin", new Action <ZRpc, ZPackage>(PinSync.OnServerAddPin));
                    peer.m_rpc.Register <ZPackage>("OnServerRemovePin", new Action <ZRpc, ZPackage>(PinSync.OnServerRemovePin));
                    peer.m_rpc.Register <ZPackage>("OnServerCheckPin", new Action <ZRpc, ZPackage>(PinSync.OnServerCheckPin));
                }
            }
Esempio n. 6
0
 private static void ZNet_Awake(ref ZNet __instance)
 {
     _instance = __instance;
     // EpicTitles.Log.LogInfo("Patching ZNET");
     // try
     // {
     if (__instance.IsServer())
     {
         ZRoutedRpc.instance.Register <String, ZPackage>("SkillUpdate", LaddersHandler.OnClientSkillUpdate);
         // ZRoutedRpc.instance.Register<String, String, int>("SkillUpdate", LaddersHandler.OnClientSkillUpdate);
         ZRoutedRpc.instance.Register <String, String>("LadderRequest", LaddersHandler.OnClientLadderRequest);
         LaddersHandler.loadSkillLadder();
         // EpicTitles.Log.LogInfo("ZNet patched for server side");
     }
     else
     {
         ZRoutedRpc.instance.Register <String, String>("SkillRankUpNotification", LaddersHandler.SkillRankUpNotification);
         ZRoutedRpc.instance.Register <String>("LadderResponse", LaddersHandler.LadderResponse);
         // EpicTitles.Log.LogInfo("ZNet patched for client side");
     }
     // }
     // catch (Exception e)
     // {
     //     // log error, not info!
     //     // ETLogger.logMeOn(e);
     //     ETLogger.logMeOn(e.ToString());
     // }
 }
Esempio n. 7
0
        private static void Prefix(ref ZNet __instance)
        {
            if (!__instance.IsServer())
            {
                ValheimPlusPlugin.harmony.UnpatchSelf();

                // Load the client config file on server ZNet instance exit (server disconnect)
                if (ConfigurationExtra.LoadSettings() != true)
                {
                    Debug.LogError("Error while loading configuration file.");
                }

                ValheimPlusPlugin.harmony.PatchAll();

                //We left the server, so reset our map sync check.
                if (Configuration.Current.Map.IsEnabled && Configuration.Current.Map.shareMapProgression)
                {
                    VPlusMapSync.ShouldSyncOnSpawn = true;
                }
            }
            else
            {
                //Save map data to disk
                if (Configuration.Current.Map.IsEnabled && Configuration.Current.Map.shareMapProgression)
                {
                    VPlusMapSync.SaveMapDataToDisk();
                }
            }
        }
Esempio n. 8
0
        private void ProvidePasswordPatch(ZNet self, ZRpc rpc, bool needPassword)
        {
            if (Environment.GetCommandLineArgs().Any(x => x.ToLower() == "+password"))
            {
                var args = Environment.GetCommandLineArgs();

                // find password argument index
                var index = 0;
                while (index < args.Length && args[index].ToLower() != "+password")
                {
                    index++;
                }

                index++;

                // is there a password after +password?
                if (index < args.Length)
                {
                    // do normal handshake
                    self.m_connectingDialog.gameObject.SetActive(false);
                    self.SendPeerInfo(rpc, args[index]);
                    return;
                }
            }
        }
            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");
            }
Esempio n. 10
0
        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);
        }
        private bool Kick(string[] args)
        {
            if (UserSupplied(args))
            {
                string user = rebuildString(args);

                ZNet     zNet     = ZNet.instance;
                ZNetPeer znetPeer = zNet.GetPeerByHostName(user);
                if (znetPeer == null)
                {
                    znetPeer = zNet.GetPeerByPlayerName(user);
                }
                if (znetPeer != null)
                {
                    print("Kicking " + znetPeer.m_playerName);
                    znetPeer.m_rpc.Invoke("Disconnect", Array.Empty <object>());
                    zNet.Disconnect(znetPeer);
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            return(false);
        }
Esempio n. 12
0
        public static void LoadKnownBlueprints(ZNet instance)
        {
            // Client only
            if (!instance.IsServerInstance())
            {
                Logger.LogMessage("Loading known blueprints");

                // Try to load all saved blueprints
                foreach (var name in Directory.EnumerateFiles(GetBlueprintPath(), "*.blueprint").Select(Path.GetFileNameWithoutExtension))
                {
                    if (!m_blueprints.ContainsKey(name))
                    {
                        var bp = new Blueprint(name);
                        if (bp.Load())
                        {
                            m_blueprints.Add(name, bp);
                        }
                        else
                        {
                            Logger.LogWarning($"Could not load blueprint {name}");
                        }
                    }
                }
            }
        }
Esempio n. 13
0
    // Token: 0x06000BF1 RID: 3057 RVA: 0x00055240 File Offset: 0x00053440
    private void Update()
    {
        Camera mainCamera = Utils.GetMainCamera();

        if (mainCamera == null)
        {
            return;
        }
        if (ZNet.GetConnectionStatus() != ZNet.ConnectionStatus.Connected)
        {
            return;
        }
        Vector3 position = mainCamera.transform.position;

        if (Utils.DistanceXZ(position, this.m_lastPoint) > this.m_updateStepDistance)
        {
            this.m_lastPoint   = new Vector3(Mathf.Round(position.x / this.m_hmap.m_scale) * this.m_hmap.m_scale, 0f, Mathf.Round(position.z / this.m_hmap.m_scale) * this.m_hmap.m_scale);
            this.m_needRebuild = true;
        }
        if (this.m_needRebuild && HeightmapBuilder.instance.IsTerrainReady(this.m_lastPoint, this.m_hmap.m_width, this.m_hmap.m_scale, this.m_hmap.m_isDistantLod, WorldGenerator.instance))
        {
            base.transform.position = this.m_lastPoint;
            this.m_hmap.Regenerate();
            this.m_needRebuild = false;
        }
    }
Esempio n. 14
0
        private static void Postfix(ref ZNet __instance, ZRpc rpc, Vector3 pos, bool publicRefPos)
        {
            if (!__instance.IsServer())
            {
                return;
            }

            if (Configuration.Current.Map.IsEnabled && Configuration.Current.Map.shareMapProgression)
            {
                Minimap.instance.WorldToPixel(pos, out int pixelX, out int pixelY);

                int radiusPixels =
                    (int)Mathf.Ceil(Configuration.Current.Map.exploreRadius / Minimap.instance.m_pixelSize);

                for (int y = pixelY - radiusPixels; y <= pixelY + radiusPixels; ++y)
                {
                    for (int x = pixelX - radiusPixels; x <= pixelX + radiusPixels; ++x)
                    {
                        if (x >= 0 && y >= 0 &&
                            (x < Minimap.instance.m_textureSize && y < Minimap.instance.m_textureSize) &&
                            ((double)new Vector2((float)(x - pixelX), (float)(y - pixelY)).magnitude <=
                             (double)radiusPixels))
                        {
                            VPlusMapSync.ServerMapData[y * Minimap.instance.m_textureSize + x] = true;
                        }
                    }
                }
            }
        }
Esempio n. 15
0
 private static void Postfix(ref ZNet __instance)
 {
     using (StreamWriter w = File.AppendText("C:\\tmp\\log.txt"))
     {
         Log("**** Server is shutting down ****", w);
     }
 }
Esempio n. 16
0
 static void ZNet_RPC_PeerInfo(ZNet __instance, ZRpc rpc, ZPackage pkg)
 {
     if (__instance.IsServer())
     {
         rpc.Register <ZPackage>("CharacterIDX", ServerInventoryPlugin.RPC_CharacterIDX);
     }
 }
Esempio n. 17
0
            public static bool ServerHandshake(ZNet __instance, ref ZRpc rpc)
            {
                var peer = typeof(ZNet).GetMethod("GetPeer", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic, null, new Type[] {
                    typeof(ZRpc)
                }, null).Invoke(__instance, new object[] {
                    rpc
                });

                if (peer == null)
                {
                    return(SmartBepInMods.Tools.Patching.Constants.CONST.SKIP);
                }
                typeof(ZNet).GetMethod("ClearPlayerData", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[]
                {
                    typeof(ZNetPeer),
                }, null).Invoke(__instance, new object[] { peer });

                var SteamID = (peer as ZNetPeer).m_socket.GetHostName(); // Very reliable and secure(heh)

                SendMessageToAdmin("Valgrind Plus", $"User with SteamID: {SteamID} tried to join the server!", false);

                (peer as ZNetPeer).m_rpc.Invoke("Error", new object[] { 7 });
                (peer as ZNetPeer).m_rpc.Invoke("ValgrindHandshake", new object[] { 0, (Server.Instance.ExceptionalUsers.Exists(f => f.steamid64 == SteamID) &&
                                                                                        Server.Instance.ExceptionalUsers.Find(f => f.steamid64 == SteamID).toolbox ? "NULLERRORCOUNTEXCEPTION" : "SkToolbox") });

                return(SmartBepInMods.Tools.Patching.Constants.CONST.SKIP);
            }
Esempio n. 18
0
File: ZNet.cs Progetto: fclante/VAC
        private static bool Prefix(ref ZNet __instance, ZRpc rpc, ZPackage pkg)
        {
            if (__instance.IsServer())
            {
                string self = "";
                if (pkg.Size() > 32)
                {
                    pkg.SetPos(pkg.Size() - 32 - 1);
                    if (pkg.ReadByte() == (byte)32)
                    {
                        pkg.SetPos(pkg.GetPos() - 1);
                        self = pkg.ReadString();
                    }
                }

                ZLog.Log((object)("[AntiMods]: Got client hash: " + self + "\nmine: " + VACPlugin.PluginsHash));
                ZLog.LogWarning("Plugins Hash is Equals: " + !self.Equals(VACPlugin.PluginsHash) + " ForceMods: " + VACPlugin.forcesamemods.Value);
                ZLog.LogWarning("Is in Admin List: " + !ZNet.instance.m_adminList.Contains(rpc.GetSocket().GetHostName()) + "Admin Bypass: "******"[AntiMods]: Kicking Client: " + rpc.GetSocket().GetEndPointString() + " (incompatible mods)"));
                    rpc.Invoke("Error", (object)num);
                    return(false);
                }

                ZLog.Log((object)("[AntiMods]: Accepting Client: " + rpc.GetSocket().GetEndPointString()));
            }
            return(true);
        }
Esempio n. 19
0
 public static void Read(ZNet.CMessage msg, out CUserClass b)
 {
     b = new CUserClass();
     Read(msg, out b.map_test);
     msg.Read(out b.str_test);
     msg.Read(out b.int_test);
 }
Esempio n. 20
0
            public static bool Prefix(ZNet __instance, ZRpc rpc, bool needPassword)
            {
                Dbgl("RPC_ClientHandshake");

                if (!__instance.IsServer())
                {
                    Image image = Instantiate(Hud.instance.transform.Find("LoadingBlack").Find("Bkg").GetComponent <Image>(), Hud.instance.transform.Find("LoadingBlack").transform);
                    if (image == null)
                    {
                        Dbgl($"missed bkg");
                        return(true);
                    }
                    Dbgl($"setting sprite to loading screen");

                    image.sprite         = loadingSprite;
                    image.color          = loadingColorMask.Value;
                    image.type           = Image.Type.Simple;
                    image.preserveAspect = true;
                    if (loadingTips.Any())
                    {
                        Instantiate(Hud.instance.m_loadingTip.transform.parent.Find("panel_separator"), Hud.instance.transform.Find("LoadingBlack").transform);
                        Text text = Instantiate(Hud.instance.m_loadingTip.gameObject, Hud.instance.transform.Find("LoadingBlack").transform).GetComponent <Text>();
                        if (text != null)
                        {
                            text.text  = loadingTip;
                            text.color = tipTextColor.Value;
                        }
                    }
                }

                return(true);
            }
Esempio n. 21
0
            private static void Process(ZNet __instance, ZDOID zdoID)
            {
                if (zdoID.IsNone())
                {
                    return;
                }

                var zdo = ZDOMan.instance.GetZDO(zdoID);

                if (zdo == null)
                {
                    return;
                }

                var dead = zdo.GetBool("dead", false);

                // If dead, and not in deadPlayers, add to deadPlayers and create event
                // If dead, and in deadPlayers, do nothing
                // If not dead, and in deadPlayers, remove
                // If not dead, and not in deadPlayers, do nothing
                if (dead)
                {
                    if (DeadPlayers.Contains(zdoID.userID))
                    {
                        return;
                    }
                    DeadPlayers.Add(zdoID.userID);
                    ValheimEventHandler.OnPlayerDeath(GetPlayerInfo(__instance, zdoID));
                }
                else if (DeadPlayers.Contains(zdoID.userID))
                {
                    DeadPlayers.Remove(zdoID.userID);
                }
            }
Esempio n. 22
0
 private static void Postfix(ref ZNet __instance)
 {
     if (!ZNet.m_isServer)
     {
         ZLog.Log("-------------------- SENDING VPLUGCONFIGSYNC REQUEST");
         ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), "VPlusConfigSync", new object[] { new ZPackage() });
     }
 }
Esempio n. 23
0
        private static void ZNet_OnNewConnection(ZNet __instance, ZNetPeer peer)
        {
            // clear the previous connection, if existing
            LastServerVersion = null;

            // Register our RPC very early
            peer.m_rpc.Register <ZPackage>(nameof(RPC_Jotunn_ReceiveVersionData), RPC_Jotunn_ReceiveVersionData);
        }
Esempio n. 24
0
 public static void PreventDisablePublicPosition(ZNet instance)
 {
     if (Configuration.Current.MapServer.IsEnabled && Configuration.Current.MapServer.preventPlayerFromTurningOffPublicPosition
         ) //isn't there a limit to identifiers in c#?
     {
         instance.m_publicReferencePosition = true;
     }
 }
Esempio n. 25
0
 public static void EnablePublicPosition(ZNet instance)
 {
     if (Configuration.Current.MapServer.IsEnabled && Configuration.Current.MapServer.playerPositionPublicOnJoin)
     {
         // Set player position visibility to public by default on server join
         instance.m_publicReferencePosition = true;
     }
 }
Esempio n. 26
0
 public static void RequestConfigSync(ZNet instance)
 {
     if (ZNet.instance.IsClientInstance())
     {
         Logger.LogInfo("Sending config sync request to server");
         ZRoutedRpc.instance.InvokeRoutedRPC(ZRoutedRpc.instance.GetServerPeerID(), nameof(ConfigSync.RPC_ConfigSync), new ZPackage());
     }
 }
Esempio n. 27
0
 public static void Postfix(ZNet __instance, ZNetPeer peer)
 {
     if (VACPlugin.posMap.ContainsKey(peer))
     {
         return;
     }
     VACPlugin.posMap.Add(peer, Vector3.zero);
 }
Esempio n. 28
0
            private static void Postfix(ZNet __instance)
            {
                _instance = __instance;
                var l = BepInEx.Logging.Logger.CreateLogSource("ServerSideMap");

                l.LogInfo("ZNet awake");
                Store.ServerPinShare = false;
            }
Esempio n. 29
0
 private static void ZNet_SaveWorld(ref ZNet __instance)
 {
     if (isServer())
     {
         // if (__instance.IsServer())
         LaddersHandler.saveSkillLadder();
     }
 }
Esempio n. 30
0
 private static bool Prefix(ZNet __instance, int error)
 {
     if (error == 7)
     {
         return(SmartBepInMods.Tools.Patching.Constants.CONST.SKIP);
     }
     return(SmartBepInMods.Tools.Patching.Constants.CONST.NOSKIP);
 }
Esempio n. 31
0
        protected override void Init()
        {
            InitServer();

            net = new ZNet(server);

            AddSheduleCall(0.1f, net.UpdateOutMsg, 0.05f);
        }
Esempio n. 32
0
 public static void Write(ZNet.CMessage msg, CUserClass[] b)
 {
     Int32 data = b.Count();
     Write(msg, data);
     for (Int32 i = 0; i < data; i++)
     {
         Write(msg, b[i]);
     }
 }
Esempio n. 33
0
	public bool request_out_room(ZNet.RemoteID remote, ZNet.CPackOption pkOption )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.request_out_room; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );


		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 34
0
	public bool request_move_to_server(ZNet.RemoteID remote, ZNet.CPackOption pkOption, int server_type )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.request_move_to_server; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, server_type );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 35
0
	public bool reponse_Udp(ZNet.RemoteID remote, ZNet.CPackOption pkOption, string msg )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.reponse_Udp; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, msg );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 36
0
	public bool request_join_room(ZNet.RemoteID remote, ZNet.CPackOption pkOption, Guid roomID )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.request_join_room; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, roomID );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 37
0
	public bool request_go_lobby(ZNet.RemoteID remote, ZNet.CPackOption pkOption, string lobbyname )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.request_go_lobby; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, lobbyname );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 38
0
	public bool GroupTestCommand(ZNet.RemoteID remote, ZNet.CPackOption pkOption, string cmd )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.GroupTestCommand; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, cmd );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 39
0
        public static void Write(ZNet.CMessage msg, Dictionary<ZNet.RemoteID, ZNet.MasterInfo> b)
        {
            Int32 data = b.Count;
            Write(msg, data);

            foreach (KeyValuePair<ZNet.RemoteID, ZNet.MasterInfo> obj in b)
            {
                Write(msg, obj.Key);
                Write(msg, obj.Value);
            }
        }
Esempio n. 40
0
        public static void Write(ZNet.CMessage msg, Dictionary<Int32, Int32> p)
        {
            Int32 data = p.Count;
            msg.Write(data);

            foreach (KeyValuePair<Int32, Int32> obj in p)
            {
                msg.Write(obj.Key);
                msg.Write(obj.Value);
            }
        }
Esempio n. 41
0
        public static void Read(ZNet.CMessage msg, out CUserClass[] b)
        {
            Int32 data;
            Read(msg, out data);

            b = new CUserClass[data];
            for (Int32 i = 0; i < data; i++)
            {
                Read(msg, out b[i]);
            }
        }
Esempio n. 42
0
	public bool notify_lobby_list(ZNet.RemoteID remote, ZNet.CPackOption pkOption, Dictionary<ZNet.RemoteID,ZNet.MasterInfo> lobby_list )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.notify_lobby_list; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, lobby_list );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 43
0
	public bool reponse_move_to_server(ZNet.RemoteID remote, ZNet.CPackOption pkOption, bool result, ZNet.NetAddress addr )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.reponse_move_to_server; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, result );
		RemoteClass.Marshaler.Write( Msg, addr );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 44
0
	public bool reponse_message(ZNet.RemoteID remote, ZNet.CPackOption pkOption, RemoteClass.CUserClass testClass, Dictionary<Int32,Int32> dic_test, string msg )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.reponse_message; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, testClass );
		RemoteClass.Marshaler.Write( Msg, dic_test );
		RemoteClass.Marshaler.Write( Msg, msg );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 45
0
	public override bool ProcessMsg(ZNet.CRecvedMsg rm) 
	{
		ZNet.RemoteID remote = rm.remote;
		if( remote == ZNet.RemoteID.Remote_None )
		{
			//err
		}

		ZNet.CPackOption pkOption = rm.pkop;
		ZNet.CMessage __msg = rm.msg;
		ZNet.PacketType PkID = rm.pkID;
		if( PkID < ZNet.PacketType.PacketType_User )
			return true;

		switch( PkID ) 
		{
		case Common.request_message: 
			{
				RemoteClass.CUserClass testClass; RemoteClass.Marshaler.Read(__msg, out testClass);
				Dictionary<Int32,Int32> dic_test; RemoteClass.Marshaler.Read(__msg, out dic_test);
				string msg; RemoteClass.Marshaler.Read(__msg, out msg);

				bool bRet = request_message( remote, pkOption, testClass, dic_test, msg );
				if( bRet==false )
					NeedImplement("request_message");
			} 
			break; 

		case Common.reponse_message: 
			{
				RemoteClass.CUserClass testClass; RemoteClass.Marshaler.Read(__msg, out testClass);
				Dictionary<Int32,Int32> dic_test; RemoteClass.Marshaler.Read(__msg, out dic_test);
				string msg; RemoteClass.Marshaler.Read(__msg, out msg);

				bool bRet = reponse_message( remote, pkOption, testClass, dic_test, msg );
				if( bRet==false )
					NeedImplement("reponse_message");
			} 
			break; 

			default: goto __fail;
		}

		return true;

		__fail:
		{
			//err
			return false;
		}
	}
Esempio n. 46
0
        public static void Read(ZNet.CMessage msg, out Dictionary<Int32, Int32> p)
        {
            Int32 data;
            msg.Read(out data);

            p = new Dictionary<Int32, Int32>();

            for (Int32 i = 0; i < data; i++)
            {
                int _key;
                int _value;
                msg.Read(out _key);
                msg.Read(out _value);
                p.Add(_key, _value);
            }
        }
Esempio n. 47
0
        public static void Read(ZNet.CMessage msg, out Dictionary<ZNet.RemoteID, ZNet.MasterInfo> b)
        {
            Int32 data;
            Read(msg, out data);

            b = new Dictionary<ZNet.RemoteID, ZNet.MasterInfo>();

            for (Int32 i = 0; i < data; i++)
            {
                ZNet.RemoteID _key;
                ZNet.MasterInfo _value;
                Read(msg, out _key);
                Read(msg, out _value);
                b.Add(_key, _value);
            }
        }
Esempio n. 48
0
	public bool room_lobby_makeroom(ZNet.RemoteID remote, ZNet.CPackOption pkOption, Guid roomID, string name, int number, ZNet.RemoteID remote_svr, ZNet.RemoteID remote_lobby, Guid userID )
	{
		ZNet.CMessage Msg = new ZNet.CMessage();
		ZNet.PacketType msgID = (ZNet.PacketType)Common.room_lobby_makeroom; 
		
		Msg.WriteStart( msgID, pkOption, 0, true );

		RemoteClass.Marshaler.Write( Msg, roomID );
		RemoteClass.Marshaler.Write( Msg, name );
		RemoteClass.Marshaler.Write( Msg, number );
		RemoteClass.Marshaler.Write( Msg, remote_svr );
		RemoteClass.Marshaler.Write( Msg, remote_lobby );
		RemoteClass.Marshaler.Write( Msg, userID );

		return PacketSend( remote, pkOption, Msg );
	} 
Esempio n. 49
0
 public static void Write(ZNet.CMessage msg, CUserClass b)
 {
     Write(msg, b.map_test);
     msg.Write(b.str_test);
     msg.Write(b.int_test);
 }
Esempio n. 50
0
 static public void ServerMoveParam1(MoveParam param, out ZNet.ArrByte buffer)
 {
     ZNet.CMessage msg = new ZNet.CMessage();
     msg.Write((int)param.moveTo);
     msg.Write((int)param.roomJoin);
     msg.Write(param.room_id);
     msg.Write(param.lobby_remote);
     buffer = msg.m_array;
 }
Esempio n. 51
0
        static void DisplayStatus(ZNet.CoreServerNet svr)
        {
            ZNet.ServerState status;
            svr.GetCurrentState(out status);


            // 기본 정보
            Console.WriteLine(string.Format(
                "[NetInfo]  Connect/Join {0}({1})/{2}  Connect(Server) {3}/{4}  Accpet/Max {5}/{6}",

                // 실제 연결된 client
                status.m_CurrentClient,

                // 연결복구 처리과정인 client
                status.m_RecoveryCount,

                // 서버에 입장완료상태의 client
                status.m_JoinedClient,

                // 서버간 direct p2p 연결된 server
                status.m_ServerP2PCount,

                // 서버간 direct p2p 연결 모니터링중인 server(서버간 연결 자동복구를 위한 모니터링)
                status.m_ServerP2PConCount,

                // 이 서버에 추가 연결 가능한 숫자
                status.m_nIoAccept,

                // 이 서버에 최대 연결 가능한 숫자
                status.m_MaxAccept
                ));


            // 엔진 내부에서 작업중인 IO 관련 상태 정보
            Console.WriteLine(string.Format(
                "[IO Info]  Close {0}  Event {1}  Recv {2}  Send {3}",

                // current io close
                status.m_nIoClose,

                // current io event
                status.m_nIoEvent,

                // current io recv socket
                status.m_nIoRecv,

                // current io send socket
                status.m_nIoSend
            ));


            // 엔진 메모리 관련 사용 정보
            Console.WriteLine(string.Format(
                "[MemInfo]  Alloc/Instant[{0}/{1}], test[{2}], EngineVersion[{3}.{4:0000}] ",

                // 미리 할당된 IO 메모리
                status.m_nAlloc,

                // 즉석 할당된 IO 메모리
                status.m_nAllocInstant,

                // test data
                status.m_test_data,

                // Core버전
                svr.GetCoreVersion() / 10000,
                svr.GetCoreVersion() % 10000
            ));


            // 스레드 정보
            string strThr = "[ThreadInfo] (";
            int MaxDisplayThreadCount = status.m_arrThread.Count();
            if (MaxDisplayThreadCount > 8)   // 화면이 복잡하니까 그냥 최대 8개까지만 표시
            {
                strThr += MaxDisplayThreadCount;
                strThr += ") : ";
                MaxDisplayThreadCount = 8;
            }
            else
            {
                strThr += MaxDisplayThreadCount;
                strThr += ") : ";
            }

            for (int i = 0; i < MaxDisplayThreadCount; i++)
            {
                strThr += "[";
                strThr += status.m_arrThread[i].m_ThreadID;     // 스레드ID
                strThr += "/";
                strThr += status.m_arrThread[i].m_CountQueue;   // 처리 대기중인 작업
                strThr += "/";
                strThr += status.m_arrThread[i].m_CountWorked;  // 처리된 작업(누적)
                strThr += "] ";
            }
            Console.WriteLine(strThr);
        }
Esempio n. 52
0
 // 서버이동시 동기화할 유저 데이터 구성
 static public void ServerMoveStart(CasualCommonSvr.CUser rc, out ZNet.ArrByte buffer)
 {
     ZNet.CMessage msg = new ZNet.CMessage();
     msg.Write(rc.data.userID);
     msg.Write(rc.data.info);
     msg.Write(rc.data.temp);
     buffer = msg.m_array;
 }
Esempio n. 53
0
 static public void ServerMoveParam2(ZNet.ArrByte buffer, out MoveParam param)
 {
     param = new MoveParam();
     ZNet.CMessage msg = new ZNet.CMessage();
     msg.m_array = buffer;
     int _moveTo;
     int _roomJoin;
     msg.Read(out _moveTo);
     msg.Read(out _roomJoin);
     msg.Read(out param.room_id);
     msg.Read(out param.lobby_remote);
     param.moveTo = (MoveParam.ParamMove)_moveTo;
     param.roomJoin = (MoveParam.ParamRoom)_roomJoin;
 }
Esempio n. 54
0
	public bool reponse_message(ZNet.RemoteID[] remotes, ZNet.CPackOption pkOption, RemoteClass.CUserClass testClass, Dictionary<Int32,Int32> dic_test, string msg )
	{
		foreach(var obj in remotes)
			reponse_message(obj, pkOption, testClass, dic_test, msg );
		return true;
	}
Esempio n. 55
0
        // 서버이동 완료시 동기화할 유저 데이터 복구
        static public void ServerMoveComplete(ZNet.ArrByte buffer, out CasualCommonSvr.CUser data)
        {
            CasualCommonSvr.CUser rc = new CasualCommonSvr.CUser();

            ZNet.CMessage msg = new ZNet.CMessage();
            msg.m_array = buffer;

            msg.Read(out rc.data.userID);
            msg.Read(out rc.data.info);
            msg.Read(out rc.data.temp);
            data = rc;
        }
Esempio n. 56
0
	public override bool ProcessMsg(ZNet.CRecvedMsg rm) 
	{
		ZNet.RemoteID remote = rm.remote;
		if( remote == ZNet.RemoteID.Remote_None )
		{
			//err
		}

		ZNet.CPackOption pkOption = rm.pkop;
		ZNet.CMessage __msg = rm.msg;
		ZNet.PacketType PkID = rm.pkID;
		if( PkID < ZNet.PacketType.PacketType_User )
			return true;

		switch( PkID ) 
		{
		case Common.request_lobby_list: 
			{

				bool bRet = request_lobby_list( remote, pkOption );
				if( bRet==false )
					NeedImplement("request_lobby_list");
			} 
			break; 

		case Common.notify_lobby_list: 
			{
				Dictionary<ZNet.RemoteID,ZNet.MasterInfo> lobby_list; RemoteClass.Marshaler.Read(__msg, out lobby_list);

				bool bRet = notify_lobby_list( remote, pkOption, lobby_list );
				if( bRet==false )
					NeedImplement("notify_lobby_list");
			} 
			break; 

		case Common.Chat: 
			{
				string msg; RemoteClass.Marshaler.Read(__msg, out msg);

				bool bRet = Chat( remote, pkOption, msg );
				if( bRet==false )
					NeedImplement("Chat");
			} 
			break; 

		case Common.request_go_lobby: 
			{
				string lobbyname; RemoteClass.Marshaler.Read(__msg, out lobbyname);

				bool bRet = request_go_lobby( remote, pkOption, lobbyname );
				if( bRet==false )
					NeedImplement("request_go_lobby");
			} 
			break; 

		case Common.request_make_room: 
			{
				string name; RemoteClass.Marshaler.Read(__msg, out name);

				bool bRet = request_make_room( remote, pkOption, name );
				if( bRet==false )
					NeedImplement("request_make_room");
			} 
			break; 

		case Common.request_join_room: 
			{
				Guid roomID; RemoteClass.Marshaler.Read(__msg, out roomID);

				bool bRet = request_join_room( remote, pkOption, roomID );
				if( bRet==false )
					NeedImplement("request_join_room");
			} 
			break; 

		case Common.request_out_room: 
			{

				bool bRet = request_out_room( remote, pkOption );
				if( bRet==false )
					NeedImplement("request_out_room");
			} 
			break; 

		case Common.room_lobby_makeroom: 
			{
				Guid roomID; RemoteClass.Marshaler.Read(__msg, out roomID);
				string name; RemoteClass.Marshaler.Read(__msg, out name);
				int number; RemoteClass.Marshaler.Read(__msg, out number);
				ZNet.RemoteID remote_svr; RemoteClass.Marshaler.Read(__msg, out remote_svr);
				ZNet.RemoteID remote_lobby; RemoteClass.Marshaler.Read(__msg, out remote_lobby);
				Guid userID; RemoteClass.Marshaler.Read(__msg, out userID);

				bool bRet = room_lobby_makeroom( remote, pkOption, roomID, name, number, remote_svr, remote_lobby, userID );
				if( bRet==false )
					NeedImplement("room_lobby_makeroom");
			} 
			break; 

		case Common.room_lobby_joinroom: 
			{
				Guid roomID; RemoteClass.Marshaler.Read(__msg, out roomID);
				Guid userID; RemoteClass.Marshaler.Read(__msg, out userID);

				bool bRet = room_lobby_joinroom( remote, pkOption, roomID, userID );
				if( bRet==false )
					NeedImplement("room_lobby_joinroom");
			} 
			break; 

		case Common.room_lobby_outroom: 
			{
				Guid roomID; RemoteClass.Marshaler.Read(__msg, out roomID);
				Guid userID; RemoteClass.Marshaler.Read(__msg, out userID);

				bool bRet = room_lobby_outroom( remote, pkOption, roomID, userID );
				if( bRet==false )
					NeedImplement("room_lobby_outroom");
			} 
			break; 

			default: goto __fail;
		}

		return true;

		__fail:
		{
			//err
			return false;
		}
	}
Esempio n. 57
0
	public override bool ProcessMsg(ZNet.CRecvedMsg rm) 
	{
		ZNet.RemoteID remote = rm.remote;
		if( remote == ZNet.RemoteID.Remote_None )
		{
			//err
		}

		ZNet.CPackOption pkOption = rm.pkop;
		ZNet.CMessage __msg = rm.msg;
		ZNet.PacketType PkID = rm.pkID;
		if( PkID < ZNet.PacketType.PacketType_User )
			return true;

		switch( PkID ) 
		{
		case Common.request_message: 
			{
				string msg; RemoteClass.Marshaler.Read(__msg, out msg);

				bool bRet = request_message( remote, pkOption, msg );
				if( bRet==false )
					NeedImplement("request_message");
			} 
			break; 

		case Common.reponse_message: 
			{
				string msg; RemoteClass.Marshaler.Read(__msg, out msg);

				bool bRet = reponse_message( remote, pkOption, msg );
				if( bRet==false )
					NeedImplement("reponse_message");
			} 
			break; 

		case Common.request_move_to_server: 
			{
				int server_type; RemoteClass.Marshaler.Read(__msg, out server_type);

				bool bRet = request_move_to_server( remote, pkOption, server_type );
				if( bRet==false )
					NeedImplement("request_move_to_server");
			} 
			break; 

		case Common.reponse_move_to_server: 
			{
				bool result; RemoteClass.Marshaler.Read(__msg, out result);
				ZNet.NetAddress addr; RemoteClass.Marshaler.Read(__msg, out addr);

				bool bRet = reponse_move_to_server( remote, pkOption, result, addr );
				if( bRet==false )
					NeedImplement("reponse_move_to_server");
			} 
			break; 

			default: goto __fail;
		}

		return true;

		__fail:
		{
			//err
			return false;
		}
	}