Adam's Lair Forum

void onUpdate(){
//Do whatever we need to do
String information = myIp + "-" + transform.pos.X + "-" + transform.pos.Y //We condense our player's information to a string that can be read by the Server, in this case, our IP, and //our position X and Y
byte[] condensed = information.transformToByteArray(); //Not actual function, is just to demonstrate what will we do
socket.send(condensed, serverIP, port) //serverIP is the server's IP, something like //192.168.0.1 and wich port we are using to send those informations
}

void threadMethod(){ //This is our thread method, this will be running parallel to other //threads in the game, we will use this to receive server's information
while(true){//a loop so we can always be receiving new information
byte[] info = socket.receive(serverIP, port);// Again, not real methods, just using to //explain what we are doing
String data = into.toString()//dont know if this work (probably no)

Player p = players.get(data.split("-")[0]) //"players" is a hashmap wich contains all //players, keyed by its IP so we can retreive the players position by simply searching its IP
p.position.x = parseInt(data.split("-")[1]);
p.position.y = parseInt(data.split("-")[2]);
//If you want to retreive more information about the players, for example name, HP,MP, //etc you just need to send those informations to the server, by the fact that every client is //running this same code, if you send your name, then it means that everyone is sending //their name, and you just need to get it from the server
}
}

HashMap<Players> players;
void onUpdate(){

foreach(Player p in players){
String information = p.IP+ "-" + p.transform.pos.X + "-" + p.transform.pos.Y  //For every player, we get their information
byte[] condensed = information.transformToByteArray();
foreach(Player p2 in players){
if(p2 != p){
socket.send(condensed, p2.IP, port) //and send their information to every other player //(that is not itself for obvious reasons)
}
}
}
}
void threadMethod(){
while(true){//same loop of client so we can always receive new information

byte[] info = socket.receive(serverIP, port);
String data = into.toString()

Player p = players.get(data.split("-")[0])
p.position.x = parseInt(data.split("-")[1]);
p.position.y = parseInt(data.split("-")[2]);
}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Diagnostics;
using System.Net;
using System.Net.Sockets;

using Duality;
using Duality.Components;

namespace MyGame.Multiplayer
{
    public class HostWaitRoom : Component, ICmpUpdatable, ICmpInitializable
    {
        Socket sender;//This socket is used to send server information
        IPAddress send_to_address;//wich ip are we sending to? [SPOILER] Everyone [/SPOILER]
        IPEndPoint sending_end_point;//really dont know why we need this, but we need it :/

        bool end = false;

        float timer = 0;//this is a timer that caps the sending to every 100ms (we dont need to refresh the page that often as once every frame)

        int NumPlayers = 0;//The number of player currently connected to your server

        public void OnInit(Component.InitContext context)
        {
            if (context == InitContext.Activate)
            {
                send_to_address = IPAddress.Parse("255.255.255.255");//255.255.255.255 is what we call a "Broadcast" IP, by sending
                //information to this ip, it sends to EVERY ip on the LAN
                sender = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp);//we define wich protocol we are sending, UDP in our case
                sending_end_point = new IPEndPoint(send_to_address, 11000);//we are sending to our broadcast using the port 11000
                sender.EnableBroadcast = true;//rember to enable broadcast to receive our information
            }
        }
        public static string GetLocalIPAddress()//this function return the local ip in a string format (not 127.0.0.1, but our actual IP)
        {//you can simply copy/paste this to your code, is a useful method...
            var host = Dns.GetHostEntry(Dns.GetHostName());
            foreach (var ip in host.AddressList)
            {
                if (ip.AddressFamily == AddressFamily.InterNetwork)
                {
                    return ip.ToString();
                }
            }
            throw new Exception("Local IP Address Not Found!");
        }

        public void OnUpdate()
        {
            timer += Time.LastDelta;

            if (timer > 100)//cap our sending to 100ms
            {
                timer = 0;

                String data = "SERVER-" + GetLocalIPAddress() + "-Server Teste-" + NumPlayers;//That's our information compacted to a string
                byte[] send_buffer = Encoding.ASCII.GetBytes(data);//Converting our string to a byte array
                bool sent = true;
                try
                {
                    sender.SendTo(send_buffer, sending_end_point);//we TRY to send (it may give some errors)
                }
                catch (Exception e)
                {
                    sent = false;
                    Log.Game.Write(e.Message);//if we cant send, simply prints the error on the log (cmd file that opens with your game)
                }
                Log.Game.Write(sent + " - Sending to: " + sending_end_point.Address + " with port: " + sending_end_point.Port);//if we
                //got here, we sent succesfully
            }
        }

        public void OnShutdown(Component.ShutdownContext context)//We have to remember that when we close our game or change Scenes
            //we need to send to everyone that our server is not available anymore
        {
            String data = "SHUTDOWN-" + GetLocalIPAddress() + "-Server Teste-" + NumPlayers;
            byte[] send_buffer = Encoding.ASCII.GetBytes(data);
            bool sent = true;
            try
            {
                sender.SendTo(send_buffer, sending_end_point);
            }
            catch (Exception e)
            {
                sent = false;
                Log.Game.Write(e.Message);
            }
            sender.Close();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Net;
using System.Net.Sockets;

using Duality;
using Duality.Components;
using Duality.Components.Renderers;
using Duality.Resources;

namespace MyGame.Multiplayer
{
    public class ServersList : Component, ICmpInitializable
    {

        bool end = false;
        List<ServerInfo> servers;//thats the list of all available servers
        UdpClient listener;//this receives information from servers
        IPEndPoint groupEP;//also dont really know the purpose of this
        List<String> ips;//the same list of servers, but only by IP, so we can see if the ip being received is already on the serversList

        const int port = 11000;//the port we are receiving (must be the same we are sending);

        List<GameObject> renderers;//this is a gameobject list so we can put a button to click for every server in list

        public void OnInit(Component.InitContext context)
        {
            if (context == InitContext.Activate)
            {
                servers = new List<ServerInfo>();//just initialize everything
                renderers = new List<GameObject>();
                end = false;
                listener = new UdpClient(port);
                ips = new List<string>();
                Thread thread = new Thread(new ThreadStart(run));//here we create our thread and point it to run() method, so it will run
                //the code inside parallel to the main thread
                thread.Start();//actually starts the thread and calls the method
            }
        }

        void createServerObject(ServerInfo si)//just create a button and put it on the Game scene based on server information received
        {
            ContentRef<Prefab> ServerButton = ContentProvider.RequestContent<Prefab>(@"Data\Prefabs\GUI\ServerButton.Prefab.res");
            GameObject serverObj = ServerButton.Res.Instantiate();
            Transform trans = serverObj.GetComponent<Transform>();
            TextRenderer trend = serverObj.GetComponent<TextRenderer>();
            SpriteRenderer sprite = serverObj.GetComponent<SpriteRenderer>();


            sprite.Rect = new Rect(-250, -15, 500, 30);
            trans.Pos = new Vector3(100, renderers.Count * 30 - 250, 0);
            trend.Text.SourceText = si.RoomName + " - " + si.numPlayers + " players - IP: " + si.ip.ToString();

            Scene.Current.AddObject(serverObj);

            renderers.Add(serverObj);
        }

        void run()//our parallel code running
        {
            try
            {
                Log.Game.Write("Thread start " + end);

                listener.EnableBroadcast = true;
             
                groupEP = new IPEndPoint(IPAddress.Any, port);//we can receive from any IP that is sending server information
           
                string received_data;
                byte[] receive_byte_array;

                while (!end)//our loop so we can always receive information
                {
                    receive_byte_array = listener.Receive(ref groupEP);//the information being received in byte[]
                    received_data = Encoding.ASCII.GetString(receive_byte_array, 0, receive_byte_array.Length);//just converting to string

                    if (received_data.StartsWith("SERVER"))//we have 2 types of information that we can receive, the SERVER
                        //that is information about the availiable servers and SHUTDOWN, that receives an information that some server
                        //is closing and need to be put out of the list, and remove the button from the game scene
                    {
                        bool hasAlready = false;//check if the server being received is not already being displayed on screen
                        foreach (string si in ips)
                        {
                            if (si.Equals(received_data.Split('-')[1]))
                            {
                                hasAlready = true;
                            }
                        }
                        if (!hasAlready)//if not
                        {
                            ServerInfo newServer = new ServerInfo(received_data);//receive the server information
                            servers.Add(newServer);//put it on the list
                            ips.Add(received_data.Split('-')[1]);//put its ip on the list
                            Log.Game.Write("Server " + newServer.ip.ToString() + " Created, num servers active: " + servers.Count);
                            //printing just for debug
                            createServerObject(newServer);//create button to put in game scene
                        }

                    }
                    if (received_data.StartsWith("SHUTDOWN"))//if some server is closing
                    {
                        try
                        {
                            int i = 0;
                            foreach (ServerInfo si in servers)//loop through all servers to find the one being closed
                            {
                                if (si.hasSameIp(received_data))
                                {
                                    servers.Remove(si);//remove from servers list
                                    ips.Remove(si.ip.ToString());//remove from ips list
                                    Log.Game.Write("Server " + si.ip.ToString() + " Shutdown");//log just for debug
                                    Scene.Current.RemoveObject(renderers.ElementAt(i));//remove object from scene
                                    renderers.Remove(renderers.ElementAt(i));//remove object from objects list
                                    break;
                                }
                                i++;
                            }
                        }
                        catch (Exception e)
                        {
                            Log.Game.Write("--------------------------------" + e.Message);//just put those big lines so i can differ from other log things
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Log.Game.Write("--------------------------------"+e.Message);
            }

        }

        public void OnShutdown(Component.ShutdownContext context)
        {
            end = true;
            listener.Close();//always close your listener
           
        }
    }
}