using UnityEngine;
using System.Collections;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using System.Collections.Generic;
using System.Text;
using System;

public class Client {
     TcpClient client;
     HandlerClient hc;
     Thread reader;

     public Client(int port, string ip, HandlerClient hc)
     {
         client = new TcpClient();
         client.Connect(IPAddress.Parse(ip), port);

         this.hc=hc;
     }

     public void Start()
     {
         GetRoom();
         Work();
     }

     void GetRoom()
     {
         string request = "0";
         byte[] startMsg = Encoding.ASCII.GetBytes(request.ToCharArray());
         client.GetStream().Write(startMsg, 0, startMsg.Length);
         Debug.Log("Отправлен запрос на получение комнаты");
     }

     void Work()
     {
         reader = new Thread(Reader);
         reader.Start();
     }

     void Reader()
     {
         while (true)
         {
             NetworkStream ns = client.GetStream();
             List<byte> buffer = new List<byte>();
             while (ns.DataAvailable)
             {
                 int ReadByte = ns.ReadByte();
                 if (ReadByte != -1)
                 {
                     buffer.Add((byte)ReadByte);
                 }
             }
             if (buffer.Count > 0)
             {
                 string response = Encoding.ASCII.GetString(buffer.ToArray());
                 HandlerResponse(response);
                 Debug.Log("Получил ответ от сервера " + response);
             }
         }
     }

     public void HandlerResponse(string value)
     {
         string[] valueSplit = value.Split(new Char[] { ':' });
         switch (valueSplit[0])
         {
             case "0":
                 new Test();
                 //hc.HandlerResponse(value);
                 //reader.Join();
                 //Application.LoadLevel((int.Parse(valueSplit[1])));
                 break;
         }
     }

     ~Client()
     {
         if (client != null)
         {
             client.Close();
         }
     }    
}

using UnityEngine;
using System.Collections;
using System.Net.Sockets;
using System.Threading;
using System.Net;
using System.Collections.Generic;
using System.Text;

namespace ServerClient
{
     class Server
     {
         public TcpListener listener;
         public static Server server;

         public List<ClientInfo> clients = new List<ClientInfo>();
         public List<ClientInfo> newClient = new List<ClientInfo>();

         int idLoadedLevel;

         public Server(int port, string ip, int idLevel)
         {
             idLoadedLevel = idLevel;

             IPAddress ipAddress = IPAddress.Parse(ip);

             Server.server = this;
             listener = new TcpListener(ipAddress, port);
             listener.Start();
             Debug.Log("Слушатель запущен");
         }

         public void Start()
         {
             Thread work = new Thread(Work);
             work.Start();
         }

         public void Work()
         {
             Thread clientListener = new Thread(ListenerClients);
             clientListener.Start();
             while (true)
             {
                 foreach (ClientInfo client in clients)
                 {
                     NetworkStream stream = client.Client.GetStream();
                     while (stream.DataAvailable)
                     {
                         int ReadByte = stream.ReadByte();
                         if (ReadByte != -1)
                         {
                             client.buffer.Add((byte)ReadByte);
                         }
                     }
                     if (client.buffer.Count > 0)
                     {
                         Debug.Log("Принял сообщение");
                         byte[] msg = client.buffer.ToArray();
                         client.buffer.Clear();
                         try
                         {
                             string request = Encoding.ASCII.GetString(msg);
                             string response = HandlerRequest(int.Parse(request));
                             byte[] responseByte = Encoding.ASCII.GetBytes(response.ToCharArray(), 0, response.Length);
                             client.Client.GetStream().Write(responseByte, 0, responseByte.Length);
                         }
                         catch
                         {
                             client.isConnect = false;
                             client.Client.Close();
                         }
                     }
                 }
                 clients.RemoveAll(delegate(ClientInfo CI)
                 {
                     if (!CI.isConnect)
                     {
                         return true;
                     }
                     return false;
                 });
                 if (newClient.Count > 0)
                 {
                     clients.AddRange(newClient);
                     newClient.Clear();
                 }
             }
         }

         ~Server()
         {
             if (listener != null)
             {
                 listener.Stop();
             }
             foreach (ClientInfo client in clients)
             {
                 client.Client.Close();    
             }
         }

         string HandlerRequest(int value)
         {
             switch (value)
             {
                 case 0:
                     Debug.Log("Обработал запрос на получение комнаты");
                     return "0:"+idLoadedLevel;
             }
             return null;
         }

         static void ListenerClients()
         {
             while (true)
             {
                 server.newClient.Add(new ClientInfo(server.listener.AcceptTcpClient()));
                 Debug.Log("Новый клиент");
             }
         }
     }

     class ClientInfo
     {
         public TcpClient Client;
         public List<byte> buffer = new List<byte>();
         public bool isConnect;

         public ClientInfo(TcpClient Client)
         {
             this.Client = Client;
             isConnect = true;
         }
     }

}