private void onReceiveTracker(IAsyncResult ar)
{
try
{
peerToTrackerSocket.EndReceive(ar);
msgReceived = new Message(msgByte);
msgResponse = new Message();
byte[] message;
switch (msgReceived.msgType)
{
case MessageType.HandshakeResponse:
this.peerInfo = new PeerInfo(msgReceived.peer);
this.keepAliveSender.Start();
this.keepAliveResponse.Start();
gotoLobby();
break;
case MessageType.KeepAlive:
this.keepAliveResponse.Stop();
this.keepAliveResponse.Start();
break;
case MessageType.Room:
drawLobby(msgReceived.roomList);
this.state = GameState.Lobby;
break;
case MessageType.Success:
switch (lastMessage)
{
case MessageType.Create:
isCreator = true;
drawRoom();
this.state = GameState.Room;
break;
case MessageType.CreatorQuit:
gotoLobby();
break;
}
break;
case MessageType.Failed:
switch (lastMessage)
{
case MessageType.Create:
System.Console.WriteLine("Failed to create room");
System.Console.WriteLine("Maximum number of room has been reached or roomID already exists");
break;
case MessageType.Join:
System.Console.WriteLine("Failed to join room");
System.Console.WriteLine("Maximum number of player has been reached or room not found");
break;
}
break;
case MessageType.Check:
if (currentRoom.getConnectedPeers().Count < currentRoom.getMaxPlayer())
{
msgResponse = new Message(MessageType.CheckResponse, msgReceived.peerIDJoinRoom, true, this.peerInfo.getPort());
}
else
{
msgResponse = new Message(MessageType.CheckResponse, msgReceived.peerIDJoinRoom, false, this.peerInfo.getPort());
}
message = msgResponse.toByte();
peerToTrackerSocket.BeginSend(message, 0, message.Length, SocketFlags.None,
new AsyncCallback(onSendTracker), null);
break;
case MessageType.JoinSuccess:
connectToCreator(msgReceived.room.getCreator().getIP(), msgReceived.room.getCreator().getPort());
break;
case MessageType.CreatorQuit:
if (this.peerInfo.getID() == msgReceived.peer.getID())
{
this.currentRoom.setCreator(this.peerInfo);
this.currentRoom.getConnectedPeers().Clear();
this.currentRoom.getConnectedPeers().Add(this.peerInfo);
this.isCreator = true;
this.peerList = new List<PeerHandler>();
initializeP2PConnection();
}
else
{
this.currentRoom.setCreator(new PeerInfo(msgReceived.peer));
connectToCreator(msgReceived.peer.getIP(), msgReceived.peer.getPort());
}
return;
}
Array.Clear(msgByte, 0, msgByte.Length);
peerToTrackerSocket.BeginReceive(msgByte, 0, msgByte.Length, SocketFlags.None,
new AsyncCallback(onReceiveTracker), null);
}
catch (Exception e)
{
Console.WriteLine("onReceiveTracker exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
private void sendKeepAliveCreator(object source, ElapsedEventArgs e)
{
byte[] msg = new Message(MessageType.KeepAlive, this.peerInfo.getID()).toByte();
peerToPeerSocketClient.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendPeerClient), null);
}
private void onReceivePeerClient(IAsyncResult ar)
{
try
{
peerToPeerSocketClient.EndReceive(ar);
msgReceived = new Message(msgByteP2PClient);
switch (msgReceived.msgType)
{
case MessageType.RoomInfo:
this.currentRoom = new Room(msgReceived.room);
drawRoom();
this.state = GameState.Room;
break;
case MessageType.KeepAlive:
this.keepAliveResponseCreator.Stop();
this.keepAliveResponseCreator.Start();
break;
case MessageType.Success:
if (this.lastMessageClient == MessageType.Quit)
{
gotoLobby();
this.currentRoom = null;
this.state = GameState.Lobby;
}
break;
case MessageType.CreatorQuit:
if (this.peerInfo.getID() == msgReceived.peer.getID())
{
this.currentRoom.setCreator(this.peerInfo);
bool hitoriBochi = false;
if (this.currentRoom.getConnectedPeers().Count == 2) hitoriBochi = true;
this.currentRoom.getConnectedPeers().Clear();
this.currentRoom.getConnectedPeers().Add(this.peerInfo);
this.isCreator = true;
this.peerList = new List<PeerHandler>();
if (hitoriBochi) drawRoom();
}
else
{
this.currentRoom.setCreator(new PeerInfo(msgReceived.peer));
connectToCreator(msgReceived.peer.getIP(), msgReceived.peer.getPort());
}
break;
case MessageType.Start:
Console.WriteLine("Starting game...\nMembers : \n");
foreach(PeerInfo peer in this.currentRoom.getConnectedPeers()) {
Console.WriteLine(peer.getID());
Console.WriteLine(peer.getIP());
Console.WriteLine(peer.getUsername());
}
/*
Thread t = new Thread( () => {
Thread.CurrentThread.IsBackground = true;
game = new Game1 (this.currentRoom.getIDOnRoom(this.peerInfo.getID ()),
this.currentRoom.getConnectedPeers().Count, msgReceived.turn);
game.Run ();
});
t.Start();
*/
break;
case MessageType.GameUpdate:
foreach (PeerInfo peer in this.currentRoom.getConnectedPeers())
{
if (cubenode[this.currentRoom.getIDOnRoom(this.peerInfo.getID())].Contains(this.currentRoom.getIDOnRoom(peer.getID())))
System.Console.WriteLine(peer.ToString() + " -> " + this.peerInfo.ToString() + " : " + msgReceived.timestamp + msgReceived.gameUpdate.ToString());
}
addQueue(msgReceived);
break;
}
if (msgReceived.msgType != MessageType.CreatorQuit)
peerToPeerSocketClient.BeginReceive(msgByteP2PClient, 0, msgByteP2PClient.Length, SocketFlags.None,
new AsyncCallback(onReceivePeerClient), null);
}
catch (Exception e)
{
Console.WriteLine("onreceivepeerclient exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
private void onReceivePeerServer(IAsyncResult ar)
{
try
{
Socket peerSocket = (Socket)ar.AsyncState;
peerSocket.EndReceive(ar);
msgReceived = new Message(msgByteP2PServer);
msgResponse = new Message();
switch (msgReceived.msgType)
{
case MessageType.HandshakeCreator:
PeerInfo newPlayer = new PeerInfo(msgReceived.peer);
this.peerList.Add(new PeerHandler(peerSocket, newPlayer, this));
this.currentRoom.addPlayer(newPlayer);
msgResponse = new Message(MessageType.RoomInfo, this.currentRoom);
break;
case MessageType.KeepAlive:
msgResponse = new Message(MessageType.KeepAlive, msgReceived.peerID);
PeerHandler handler = getHandler(msgReceived.peerID);
handler.isAlive = true;
handler.isAliveTimer.Stop();
handler.isAliveTimer.Start();
break;
case MessageType.GameUpdate:
msgResponse = new Message(MessageType.GameUpdate, msgReceived.timestamp, msgReceived.gameUpdate);
foreach (PeerInfo peer in this.currentRoom.getConnectedPeers())
{
if (cubenode[this.currentRoom.getIDOnRoom(this.peerInfo.getID())].Contains(this.currentRoom.getIDOnRoom(peer.getID())))
System.Console.WriteLine(peer.ToString() + " -> " + this.peerInfo.ToString() + " : " + msgReceived.timestamp + " " + msgReceived.gameUpdate.ToString());
}
addQueue(msgReceived);
break;
case MessageType.Quit:
msgResponse = new Message(MessageType.Success);
this.currentRoom.removePlayer(msgReceived.peerID);
removePeerHandler(msgReceived.peerID);
break;
}
byte[] message = msgResponse.toByte();
peerSocket.BeginSend(message, 0, message.Length, SocketFlags.None,
new AsyncCallback(onSendPeerServer), peerSocket);
if (msgReceived.msgType != MessageType.Quit) {
peerSocket.BeginReceive(msgByteP2PServer, 0, msgByteP2PServer.Length, SocketFlags.None,
new AsyncCallback(onReceivePeerServer), peerSocket);
}
if (msgReceived.msgType == MessageType.Quit || msgReceived.msgType == MessageType.HandshakeCreator)
{
byte[] m = new Message(MessageType.RoomInfo, this.currentRoom).toByte();
foreach (PeerHandler peer in peerList)
{
if (peer.socket != peerSocket)
{
peer.socket.BeginSend(m, 0, m.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
}
byte[] msgTracker = new Message(MessageType.RoomInfo, this.currentRoom).toByte();
peerToTrackerSocket.BeginSend(msgTracker, 0, msgTracker.Length, SocketFlags.None,
new AsyncCallback(onSendTracker), null);
drawRoom();
}
if (msgReceived.msgType == MessageType.GameUpdate)
{
byte[] msg = new Message(MessageType.GameUpdate, msgReceived.timestamp, msgReceived.gameUpdate).toByte();
foreach (PeerHandler peer in peerList)
{
if (peer.socket != peerSocket)
{
peer.socket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("onReceivePeerServer exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
private void onConnectPeerClient(IAsyncResult ar)
{
try
{
peerToPeerSocketClient.EndConnect(ar);
Message msg = new Message(MessageType.HandshakeCreator, this.peerInfo);
byte[] message = msg.toByte();
peerToPeerSocketClient.BeginSend(message, 0, message.Length, SocketFlags.None,
new AsyncCallback(onSendPeerClient), null);
peerToPeerSocketClient.BeginReceive(msgByteP2PClient, 0, msgByteP2PClient.Length, SocketFlags.None,
new AsyncCallback(onReceivePeerClient), null);
this.keepAliveSenderCreator.Start();
this.keepAliveResponseCreator.Start();
}
catch (Exception e)
{
Console.WriteLine("onConnectPeerClient exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
private void onConnectTracker(IAsyncResult ar)
{
try
{
string username = (string)ar.AsyncState;
peerToTrackerSocket.EndConnect(ar);
byte[] msg = new Message(MessageType.Handshake, username).toByte();
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendTracker), null);
peerToTrackerSocket.BeginReceive(msgByte, 0, msgByte.Length, SocketFlags.None, new AsyncCallback(onReceiveTracker), null);
}
catch (Exception e)
{
Console.WriteLine("onConnectTracker exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void updateRoom(int param1, double param2)
{
try
{
if (isCreator)
{
this.lastMessage = MessageType.GameUpdate;
Message m = new Message(MessageType.GameUpdate, getCurrentTime(), new GameUpdate(param1,param2));
byte[] msg = m.toByte();
foreach (PeerHandler peer in peerList)
{
peer.socket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
foreach (PeerInfo peer in this.currentRoom.getConnectedPeers())
{
if (cubenode[this.currentRoom.getIDOnRoom(this.peerInfo.getID())].Contains(this.currentRoom.getIDOnRoom(peer.getID())))
System.Console.WriteLine(peer.ToString() + " -> " + this.peerInfo.ToString() + " : " + m.timestamp +" " + m.gameUpdate.ToString());
}
}
else
{
this.lastMessageClient = MessageType.GameUpdate;
byte[] msg = new Message(MessageType.GameUpdate, getCurrentTime(), new GameUpdate(param1, param2)).toByte();
peerToPeerSocketClient.BeginSend(msg, 0, msg.Length, SocketFlags.None,
new AsyncCallback(onSendPeerClient), null);
}
}
catch (Exception e)
{
Console.WriteLine("updateRoom exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
private void creatorDown(object source, ElapsedEventArgs e)
{
this.keepAliveResponseCreator.Stop();
if (this.peerInfo.getID() == this.currentRoom.getConnectedPeers()[1].getID())
{
this.currentRoom.setCreator(this.peerInfo);
this.currentRoom.getConnectedPeers().Clear();
this.currentRoom.getConnectedPeers().Add(this.peerInfo);
this.isCreator = true;
this.peerList = new List<PeerHandler>();
byte[] msgTracker = new Message(MessageType.SelfPromoteCreator, currentRoom.getCreator(), this.peerInfo).toByte();
peerToTrackerSocket.BeginSend(msgTracker, 0, msgTracker.Length, SocketFlags.None, new AsyncCallback(onSendTracker), null);
}
else
{
this.currentRoom.setCreator(new PeerInfo(this.currentRoom.getConnectedPeers()[1]));
connectToCreator(this.currentRoom.getConnectedPeers()[1].getIP(), this.currentRoom.getConnectedPeers()[1].getPort());
}
}
public void removeDeadPeer(int peerID)
{
removePeerHandler(peerID);
this.currentRoom.removePlayer(peerID);
byte[] m = new Message(MessageType.Player, this.currentRoom.getConnectedPeers()).toByte();
foreach (PeerHandler peer in peerList)
{
peer.socket.BeginSend(m, 0, m.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
drawRoom();
}
public void startRoom()
{
try
{
if (isCreator)
{
this.lastMessage = MessageType.Start;
if (this.currentRoom.getConnectedPeers().Count % 2 == 1)
{
Console.WriteLine("cannot start ! unbalance team");
}
else
{
Random r = new Random();
turn = r.Next(this.currentRoom.getConnectedPeers().Count);
byte[] msg = new Message(MessageType.Start, this.peerInfo.getID(), turn, this.currentRoom.getRoomID()).toByte();
foreach (PeerHandler peer in peerList)
{
peer.socket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
/*
Thread t = new Thread( () => {
Thread.CurrentThread.IsBackground = true;
game = new Game1 (this.currentRoom.getIDOnRoom(this.peerInfo.getID ()),
this.currentRoom.getConnectedPeers().Count, turn);
game.Run ();
});
t.Start();
*/
}
}
else
{
Console.WriteLine("start failed : not a room master !");
}
}
catch (Exception e)
{
Console.WriteLine("quitRoom exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void quitRoom()
{
try
{
if (isCreator)
{
this.lastMessage = MessageType.CreatorQuit;
this.isCreator = false;
if (this.currentRoom.getConnectedPeers().Count == 1)
{
byte[] msg = new Message(MessageType.CreatorQuit, this.peerInfo).toByte();
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendTracker), null);
}
else
{
byte[] msg = new Message(MessageType.CreatorQuit, this.currentRoom.getConnectedPeers()[1]).toByte();
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendTracker), null);
foreach (PeerHandler peer in peerList)
{
peer.socket.BeginSend(msg, 0, msg.Length, SocketFlags.None, new AsyncCallback(onSendPeerServer), peer.socket);
}
}
}
else
{
this.lastMessageClient = MessageType.Quit;
byte[] msg = new Message(MessageType.Quit, this.peerInfo.getID()).toByte();
peerToPeerSocketClient.BeginSend(msg, 0, msg.Length, SocketFlags.None,
new AsyncCallback(onSendPeerClient), null);
}
}
catch (Exception e)
{
Console.WriteLine("quitRoom exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void joinRoom(string roomID)
{
try
{
this.lastMessage = MessageType.Join;
byte[] msg = new Message(MessageType.Join, this.peerInfo.getID(), roomID).toByte();
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None,
new AsyncCallback(onSendTracker), null);
}
catch (Exception e)
{
Console.WriteLine("joinRoom exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void gotoLobby()
{
try
{
byte[] msg = new Message(MessageType.List, this.peerInfo.getID()).toByte();
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None,
new AsyncCallback(onSendTracker), null);
}
catch (Exception e)
{
Console.WriteLine("goToLobby exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void createRoom(string roomID, int maxPlayer)
{
try
{
initializeP2PConnection();
this.lastMessage = MessageType.Create;
this.peerList = new List<PeerHandler>();
byte[] msg = new Message(MessageType.Create, this.peerInfo.getID(), maxPlayer, roomID).toByte();
this.currentRoom = new Room(this.peerInfo, roomID, maxPlayer);
peerToTrackerSocket.BeginSend(msg, 0, msg.Length, SocketFlags.None,
new AsyncCallback(onSendTracker), null);
}
catch (Exception e)
{
Console.WriteLine("createRoom exception : {0}", e.Message);
Console.WriteLine(e.Source);
Console.WriteLine(e.InnerException);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.TargetSite);
}
}
public void addQueue(Message m)
{
messageQueue.Enqueue(m);
}
