static void Main(string[] args)
{
int port = 8888;
IPAddress ipAdd = IPAddress.Parse("127.0.0.1");
TcpListener listener = new TcpListener(ipAdd, port);
var clients = ClientConnectionHandler.FromListener(listener);
var disp =
clients
.Do(cl =>
{
Console.WriteLine($"Connection From: '{cl.Client.RemoteEndPoint}'");
SendMessage(cl, $"Hello: {cl.Client.RemoteEndPoint}");
})
.Select(cl => ClientMessageHandler.FromClient(cl))
.Merge()
.Do(msg =>
{
ProcessClientMessage(msg);
},
err =>
{
Console.WriteLine($"Error Occurred: {err.Message}");
})
.Retry()
.Subscribe();
Console.WriteLine($"Waiting for connection on: {port}");
Console.WriteLine("Enter 'q' to quit");
Console.ReadLine();
disp.Dispose();
}
public void ConnectionClearHandlersTest()
{
Assert.That(ClientMessageHandler._messageHandlers.Count > 0);
ClientMessageHandler.ClearHandlers();
Assert.That(ClientMessageHandler._messageHandlers.Count == 0);
}
public override void Initialize()
{
Log.Trace("Initializing Client Conceal Session", "Initialize");
GardenGateway.Commands.addCommands(Commands.FullTree);
Messenger = new ClientMessageHandler();
ModMessenger = new ModMessageHandler();
BuildPlayerList();
new SettingsRequest().SendToServer();
Instance = this;
Log.Trace("Finished Initializing Client Conceal Session", "Initialize");
}
void OnClientMessage(object sender, MessageHeader msghdr)
{
Type msgtype = msghdr.GetType();
if (MessageHandlers.ContainsKey(msgtype))
{
EventHandler <MessageHeader> MessageHandler = MessageHandlers[msgtype];
MessageHandler?.Invoke(sender, msghdr);
}
ClientMessageHandler?.Invoke(sender, msghdr);
}
public void RegisterMessageHandler(int msgID, ClientMessageHandler handler)
{
if (!messageHandlerDic.ContainsKey(msgID))
{
messageHandlerDic.Add(msgID, handler);
}
else
{
NetLogger.Error(LOG_TAG, $"The handler({msgID}) has been registed");
}
}
public IEnumerator SendToReadyTest() => UniTask.ToCoroutine(async() =>
{
readyComp = identity.gameObject.AddComponent <ObjectReady>();
lobby.ObjectReadyList.Add(readyComp);
readyComp.IsReady = true;
bool invokeWovenTestMessage = false;
ClientMessageHandler.RegisterHandler <SceneMessage>(msg => invokeWovenTestMessage = true);
lobby.SendToReady(identity, new SceneMessage(), true, Channel.Reliable);
await AsyncUtil.WaitUntilWithTimeout(() => invokeWovenTestMessage);
});
public IEnumerator SendToClientOfPlayer() => UniTask.ToCoroutine(async() =>
{
bool invoked = false;
ClientMessageHandler.RegisterHandler <WovenTestMessage>(msg => invoked = true);
serverIdentity.Owner.Send(message);
// todo assert correct message was sent using Substitute for socket or player
// connectionToServer.ProcessMessagesAsync().Forget();
await AsyncUtil.WaitUntilWithTimeout(() => invoked);
});
public IEnumerator ShowForPlayerTest() => UniTask.ToCoroutine(async() =>
{
bool invoked = false;
ClientMessageHandler.RegisterHandler <SpawnMessage>(msg => invoked = true);
serverPlayer.SceneIsReady = true;
// call ShowForConnection
serverObjectManager.ShowToPlayer(serverIdentity, serverPlayer);
// todo assert correct message was sent using Substitute for socket or player
await AsyncUtil.WaitUntilWithTimeout(() => invoked);
});
// Use this for initialization
void Start()
{
player = GameObject.Find("Player").GetComponent <Player>();
player.name = playerName;
outgoingMessages = new List <GameMessage>();
rq = new ReliableQueue(GlobalSettings.ReliableTimeout);
rq.AddQueueWithTimeout(new ClientConnectMessage(playerName, time, true), 0);
otherPlayers = new Dictionary <int, ServerPlayer>();
handler = new ClientMessageHandler(this);
SnapshotHandler.GetInstance().otherPlayers = this.otherPlayers;
SnapshotHandler.GetInstance().self = this.player;
SnapshotHandler.GetInstance().prediction = this.prediction;
Thread thread = new Thread(new ThreadStart(ThreadMethod));
thread.Start();
}
void Start()
{
DontDestroyOnLoad(this);
instance = this;
NetworkTransport.Init();
ConnectionConfig config = new ConnectionConfig();
unreliableChannelId = config.AddChannel(QosType.Unreliable);
reliableBigChannelId = config.AddChannel(QosType.ReliableFragmented);
reliableLittleChannelId = config.AddChannel(QosType.Reliable);
topology = new HostTopology(config, maxConnections);
handler = new ClientMessageHandler(this);
}
public void Process(IMessage message)
{
if (message is EmployeeMessage)
{
var handler = new EmployeeMessageHandler();
handler.Handle(message as EmployeeMessage);
}
else if (message is ClientMessage)
{
var handler = new ClientMessageHandler();
handler.Handle(message as ClientMessage);
}
else if (message is DepartmentMessage)
{
var handler = new DepartmentMessageHandler();
handler.Handle(message as DepartmentMessage);
}
}
public void ClientReadServerWriteTest(string ip, int port, string serverString, string convertedMessage)
{
//Run server in new thread
var task = Task.Factory.StartNew(() =>
{
Server server = new Server(ip, port);
server.StartServer();
server.SendMessage(serverString);
});
Client client = new Client(ip, port);
ClientMessageHandler messageHandler = new ClientMessageHandler();
client.MessageEvent += messageHandler.HandleMessage;
client.GetMessage();
Assert.AreEqual(convertedMessage, messageHandler.ConvertedMessage);
}
public GlobalManager()
{
if (Instance == null)
{
Instance = this;
}
else
{
return;
}
Console.WriteLine("Getting configuration...");
Config = Config.Parse();
Console.WriteLine("Configuration loaded");
DBClient = new DatabaseClient(Config.DatabaseURI);
Server = new TCPServer(Config.IP, Config.Port);
LobbyManager = new LobbyManager();
ClientMessageHandler = new ClientMessageHandler();
}
public override void Dispatch(ClientMessageHandler handler)
{
handler.Handle(this);
}
public abstract void Dispatch(ClientMessageHandler handler);
private void Awake()
{
this.messageHandler = new ClientMessageHandler(this.unityClient, this.playerPrefab);
this.messageHandler.OnLocalPlayerCreated += OnLocalPlayerCreated;
}
static void ReceiveRequestFromClient()
{
while (true)
{
Socket soc = listener.AcceptSocket();
Console.WriteLine("Connected: {0}", soc.RemoteEndPoint);
try
{
object locker = new object();
Stream s = new NetworkStream(soc);
StreamReader sr = new StreamReader(s);
StreamWriter sw = new StreamWriter(s);
sw.AutoFlush = true;
lock (locker) {
activeThread.Add(Thread.CurrentThread.ManagedThreadId, sw);
}
//Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
while (soc.Connected)
{
string recv = "";
while (soc.Connected)
{
string temp = sr.ReadLine();
if (temp == "$" || temp == "" || temp == null)
{
break;
}
else
{
recv += temp;
}
}
Console.WriteLine("Receive: " + recv);
JsonParser parser = new JsonParser(recv);
ClientMessageHandler msg = new ClientMessageHandler(parser.Parse(), sw);
ServerMessageHandler smsg = msg.ProcessClientMessage();
smsg.ProcessServerMessage();
}
}
catch { }
Console.WriteLine("Disconnected: {0}", soc.RemoteEndPoint);
lock (locker)
{
try
{
activeThread.Remove(Thread.CurrentThread.ManagedThreadId);
var playerName = playerNameList.FirstOrDefault(x => x.Value == Thread.CurrentThread.ManagedThreadId).Key;
if (playerName != null)
{
playerNameList.Remove(playerName);
playerPriority.Remove(playerName);
if (waitingList.ContainsKey(playerName))
{
waitingList.Remove(playerName);
}
if (playerGameStateIdMapping.ContainsKey(playerName))
{
int gameStateIdMapping = playerGameStateIdMapping[playerName];
playerGameStateIdMapping.Remove(playerName);
if (activeGameState.ContainsKey(gameStateIdMapping))
{
GameStateManager gameStateManager = activeGameState[gameStateIdMapping];
string opponentPlayerName;
if (gameStateManager.player1.playerName == playerName)
{
gameStateManager.player1.isOnline = false;
opponentPlayerName = gameStateManager.player2.playerName;
}
else
{
gameStateManager.player2.isOnline = false;
opponentPlayerName = gameStateManager.player1.playerName;
}
if (playerNameList.ContainsKey(opponentPlayerName))
{
int opponentThreadId = playerNameList[opponentPlayerName];
StreamWriter targetSW = activeThread[opponentThreadId];
ServerMessageHandler smsg = new ServerMessageHandler();
smsg.header = "Crashed";
smsg.swReceiver = targetSW;
smsg.ProcessServerMessage();
}
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
soc.Close();
}
}
public void AddHandler(byte id, ClientMessageHandler handler)
{
Assert.IsFalse(handlers.ContainsKey(id), "message handler already set");
handlers[id] = handler;
}
