private Peer()
{
this.state = GameState.Connect;
this.isCreator = false;
this.peerInfo = new PeerInfo(IPAddress.Loopback.ToString(), -1);
this.lastMessage = MessageType.Null;
this.currentRoom = null;
this.roomRequester = new Queue<PeerInfo>();
this.lastMessageClient = MessageType.Null;
this.keepAliveSender = new System.Timers.Timer(GameConstant.keepAliveInterval);
this.keepAliveSender.Elapsed += new ElapsedEventHandler(sendKeepAlive);
this.keepAliveSenderCreator = new System.Timers.Timer(GameConstant.keepAliveInterval);
this.keepAliveSenderCreator.Elapsed += new ElapsedEventHandler(sendKeepAliveCreator);
this.keepAliveResponse = new System.Timers.Timer(GameConstant.connectionTimeOut);
this.keepAliveResponse.Elapsed += new ElapsedEventHandler(trackerDown);
this.keepAliveResponseCreator = new System.Timers.Timer(GameConstant.connectionTimeOut);
this.keepAliveResponseCreator.Elapsed += new ElapsedEventHandler(creatorDown);
for (int i = 1; i <= 8; i++ )
{
cubenode[i] = new List<int>();
}
cubenode[1].Add(2); cubenode[1].Add(4); cubenode[1].Add(5); cubenode[1].Add(7);
cubenode[2].Add(1); cubenode[2].Add(3); cubenode[2].Add(6); cubenode[2].Add(8);
cubenode[3].Add(2); cubenode[3].Add(4); cubenode[3].Add(5); cubenode[3].Add(7);
cubenode[4].Add(1); cubenode[4].Add(3); cubenode[4].Add(6); cubenode[4].Add(8);
cubenode[5].Add(1); cubenode[5].Add(3); cubenode[5].Add(6); cubenode[5].Add(8);
cubenode[6].Add(2); cubenode[6].Add(4); cubenode[6].Add(5); cubenode[6].Add(7);
cubenode[7].Add(1); cubenode[7].Add(3); cubenode[7].Add(6); cubenode[7].Add(8);
cubenode[8].Add(2); cubenode[8].Add(4); cubenode[8].Add(5); cubenode[8].Add(7);
// there is a reason that takes long sentences to explain why I passed random object here
// instead of creating new random object when needed.
}
public Room(PeerInfo creator, string roomID, int maxPlayer, List<PeerInfo> connectedPeers)
{
this.creator = creator;
this.roomID = roomID;
this.maxPlayer = maxPlayer;
this.connectedPeers = connectedPeers;
}
public bool Equals(PeerInfo peer)
{
if ((this.peerID == peer.peerID) && (this.peerIP == peer.peerIP) && (this.port == peer.port))
{
return true;
}
return false;
}
public Room(PeerInfo creator, string roomID, int maxPlayer)
{
this.creator = creator;
this.roomID = roomID;
this.maxPlayer = maxPlayer;
this.connectedPeers = new List<PeerInfo>(maxPlayer);
addPlayer(creator);
}
// Copy constructor
public Room(Room room)
{
this.creator = new PeerInfo(room.creator.getIP(), room.creator.getID(), room.creator.getPort(), room.creator.getUsername());
this.roomID = room.roomID;
this.maxPlayer = room.maxPlayer;
this.connectedPeers = new List<PeerInfo>();
foreach (PeerInfo peer in room.connectedPeers)
{
this.connectedPeers.Add(new PeerInfo(peer.getIP(), peer.getID(), peer.getPort(), peer.getUsername()));
}
}
// Concstruct Room Object from ByteArray Data
public Room(byte[] roomByte)
{
int offset = 0;
int roomIDLength = BitConverter.ToInt32(roomByte, offset); offset += 4;
this.roomID = Encoding.ASCII.GetString(roomByte, offset, roomIDLength); offset += roomIDLength;
byte[] creator = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(roomByte, offset, creator, 0, GameConstant.peerInfoSize);
this.creator = new PeerInfo(creator);
offset += GameConstant.peerInfoSize;
int maxPlayer = BitConverter.ToInt32(roomByte, offset); offset += GameConstant.maxPlayerSize;
this.maxPlayer = maxPlayer;
int connectedPeersCount = BitConverter.ToInt32(roomByte, offset); offset += 4;
this.connectedPeers = new List<PeerInfo>(connectedPeersCount);
for (int i = 0; i < connectedPeersCount; i++)
{
byte[] peer = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(roomByte, offset, peer, 0, GameConstant.peerInfoSize);
offset += GameConstant.peerInfoSize;
this.connectedPeers.Add(new PeerInfo(peer));
}
}
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 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);
}
}
public PeerInfo(PeerInfo peer)
{
this.peerIP = peer.peerIP; this.peerID = peer.peerID; this.port = peer.port; this.username = peer.username;
}
public void addPlayer(PeerInfo newPlayer)
{
connectedPeers.Add(newPlayer);
}
// Construct message object from ByteArray
public Message(byte[] msg)
{
int offset = 0;
string pstr = Encoding.ASCII.GetString(msg, offset, GameConstant.pstr.Length);
offset += GameConstant.pstr.Length;
if (pstr.Equals(GameConstant.pstr))
{
this.pstr = pstr;
Buffer.BlockCopy(msg, offset, this.reservedByte, 0, 8);
offset += reservedByte.Length;
int messageCode = (int)msg[offset]; offset++;
switch (messageCode)
{
case GameConstant.handshakeCode:
this.msgType = MessageType.Handshake;
this.username = Encoding.ASCII.GetString(msg, offset, GameConstant.usernameSize).Trim();
break;
case GameConstant.handshakeResponseCode:
this.msgType = MessageType.HandshakeResponse;
byte[] peerHR = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(msg, offset, peerHR, 0, GameConstant.peerInfoSize);
this.peer = new PeerInfo(peerHR);
//this.peerID = BitConverter.ToInt32(msg, offset); offset += 4;
//this.port = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.keepAliveCode:
this.msgType = MessageType.KeepAlive;
this.peerID = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.createCode:
this.msgType = MessageType.Create;
this.peerID = BitConverter.ToInt32(msg, offset); offset += GameConstant.peerIdSize;
this.maxPlayer = BitConverter.ToInt32(msg, offset); offset += GameConstant.maxPlayerSize;
this.roomID = Encoding.ASCII.GetString(msg, offset, GameConstant.roomIDSize);
this.roomID = this.roomID.Replace("\0", String.Empty).Trim();
break;
case GameConstant.listCode:
this.msgType = MessageType.List;
this.peerID = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.roomCode:
this.msgType = MessageType.Room;
this.roomCount = BitConverter.ToInt32(msg, offset);
offset += GameConstant.roomCountSize;
for (int i = 0; i < this.roomCount; i++)
{
if ((int)msg[offset] == GameConstant.beginRoomCode)
{
offset++;
int beginRoom = offset;
int roomByteLength = 0;
while ((int)msg[offset] != GameConstant.endRoomCode)
{
roomByteLength++;
offset++;
}
offset++;
byte[] roomByte = new byte[roomByteLength];
Buffer.BlockCopy(msg, beginRoom, roomByte, 0, roomByteLength);
this.roomList.Add(new Room(roomByte));
}
}
break;
case GameConstant.successCode:
this.msgType = MessageType.Success;
break;
case GameConstant.failedCode:
this.msgType = MessageType.Failed;
break;
case GameConstant.joinCode:
this.msgType = MessageType.Join;
this.peerID = BitConverter.ToInt32(msg, offset);
offset += GameConstant.peerIdSize;
this.roomID = Encoding.ASCII.GetString(msg, offset, GameConstant.roomIDSize);
this.roomID = this.roomID.Replace("\0", String.Empty).Trim();
break;
case GameConstant.startCode:
this.msgType = MessageType.Start;
this.peerID = BitConverter.ToInt32(msg, offset);
offset += GameConstant.peerIdSize;
this.turn = BitConverter.ToInt32(msg, offset);
offset += 4;
this.roomID = Encoding.ASCII.GetString(msg, offset, GameConstant.startSize);
this.roomID = this.roomID.Replace("\0", String.Empty).Trim();
break;
case GameConstant.quitCode:
this.msgType = MessageType.Quit;
this.peerID = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.checkCode:
this.msgType = MessageType.Check;
this.peerIDJoinRoom = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.checkResponseCode:
this.msgType = MessageType.CheckResponse;
this.peerIDJoinRoom = BitConverter.ToInt32(msg, offset);
offset += GameConstant.peerIdSize;
this.isJoinAccepted = BitConverter.ToBoolean(msg, offset); offset += 1;
this.port = BitConverter.ToInt32(msg, offset);
break;
case GameConstant.handshakeCreatorCode:
this.msgType = MessageType.HandshakeCreator;
byte[] peer = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(msg, offset, peer, 0, GameConstant.peerInfoSize);
this.peer = new PeerInfo(peer);
break;
case GameConstant.playerCode:
this.msgType = MessageType.Player;
int players = BitConverter.ToInt32(msg, offset); offset += 4;
for (int i = 0; i < players; i++)
{
byte[] peerByte = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(msg, offset, peerByte, 0, GameConstant.peerInfoSize);
offset += GameConstant.peerInfoSize;
this.player.Add(new PeerInfo(peerByte));
}
break;
case GameConstant.joinSuccessCode:
this.msgType = MessageType.JoinSuccess;
if ((int)msg[offset] == GameConstant.beginRoomCode)
{
offset++;
int beginRoom = offset;
int roomByteLength = 0;
while ((int)msg[offset] != GameConstant.endRoomCode)
{
roomByteLength++; offset++;
}
offset++;
byte[] roomByte = new byte[roomByteLength];
Buffer.BlockCopy(msg, beginRoom, roomByte, 0, roomByteLength);
this.room = new Room(roomByte);
}
break;
case GameConstant.creatorQuitCode:
this.msgType = MessageType.CreatorQuit;
byte[] creatorPeer = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(msg, offset, creatorPeer, 0, GameConstant.peerInfoSize);
this.peer = new PeerInfo(creatorPeer);
break;
case GameConstant.RoomInfoCode:
this.msgType = MessageType.RoomInfo;
if ((int)msg[offset] == GameConstant.beginRoomCode)
{
offset++;
int beginRoom = offset;
int roomByteLength = 0;
while ((int)msg[offset] != GameConstant.endRoomCode)
{
roomByteLength++; offset++;
}
offset++;
byte[] roomByte = new byte[roomByteLength];
Buffer.BlockCopy(msg, beginRoom, roomByte, 0, roomByteLength);
this.room = new Room(roomByte);
}
break;
case GameConstant.SelfPromoteCreatorCode:
this.msgType = MessageType.SelfPromoteCreator;
byte[] promote = new byte[GameConstant.peerInfoSize];
Buffer.BlockCopy(msg, offset, promote, 0, GameConstant.peerInfoSize);
offset += GameConstant.peerInfoSize;
this.peer = new PeerInfo(promote);
Buffer.BlockCopy(msg, offset, promote, 0, GameConstant.peerInfoSize);
this.peer2 = new PeerInfo(promote);
break;
case GameConstant.GameUpdate:
this.msgType = MessageType.GameUpdate;
this.timestamp = BitConverter.ToInt64(msg, offset);
offset += GameConstant.timestampSize;
byte[] gameUpdate = new byte[GameConstant.gameUpdateSize];
Buffer.BlockCopy(msg, offset, gameUpdate, 0, GameConstant.gameUpdateSize);
this.gameUpdate = new GameUpdate(gameUpdate);
break;
}
}
}
public void setCreator(PeerInfo creator)
{
this.creator = creator;
}
// Construct message for SelfPromoteCreator message
private byte[] constructMessage(MessageType msgType, PeerInfo peer, PeerInfo peer2)
{
List<byte> msg = new List<byte>();
msg.AddRange(GameConstant.pstrByte);
msg.AddRange(GameConstant.reservedByte);
msg.Add((byte)GameConstant.SelfPromoteCreatorCode);
msg.AddRange(peer.toByte());
msg.AddRange(peer2.toByte());
return msg.ToArray();
}
// Construct message for HandshakeCreator, CreatorQuit message
private byte[] constructMessage(MessageType msgType, PeerInfo peer)
{
byte code;
switch (msgType)
{
case MessageType.HandshakeCreator:
code = (byte)GameConstant.handshakeCreatorCode; break;
case MessageType.CreatorQuit:
code = (byte)GameConstant.creatorQuitCode; break;
case MessageType.HandshakeResponse:
code = (byte)GameConstant.handshakeResponseCode; break;
default:
return null;
}
List<byte> msg = new List<byte>();
msg.AddRange(GameConstant.pstrByte);
msg.AddRange(GameConstant.reservedByte);
msg.Add(code);
msg.AddRange(peer.toByte());
return msg.ToArray();
}
public PeerHandler(Socket socket, PeerInfo info, Peer peer)
{
this.peer = peer;
this.socket = socket;
this.info = info;
this.isAlive = true;
this.isAliveTimer = new System.Timers.Timer(GameConstant.connectionTimeOut);
this.isAliveTimer.Elapsed += new ElapsedEventHandler(dead);
this.isAliveTimer.Start();
}
private void dead(object source, ElapsedEventArgs e)
{
peer.removeDeadPeer(this.info.getID());
this.isAliveTimer.Stop();
this.socket = null; this.info = null; this.isAliveTimer = null; this.peer = null;
}
// Constructor for SelfPromoteCreator message
public Message(MessageType msgType, PeerInfo peer, PeerInfo peer2)
{
this.msgType = msgType; this.peer = peer; this.peer2 = peer2;
}
