private void ReceiveCallback(IAsyncResult ar)
{
ReceiverState receiverState = (ReceiverState)ar.AsyncState;
try
{
if (isRouterUp)
{
int bytesRead = receiverState.WorkSocket.EndReceive(ar);
NetworkPackage networkPackage = DeserializeMessage(receiverState, bytesRead);
if (networkPackage.helloMessage)
{
TimeStamp.WriteLine("Connected to cloud");
}
if (networkPackage.managementMessage)
{
ProcessReceivedManagementMessage(networkPackage);
}
if (!networkPackage.managementMessage && !networkPackage.helloMessage)
{
ProcessReceivedClientMessage(networkPackage);
}
}
else
{
Console.WriteLine("Router is down. Message discarded");
}
receiverState.WorkSocket.BeginReceive(receiverState.Buffer, 0, receiverState.Buffer.Length, 0, new AsyncCallback(ReceiveCallback), receiverState);
}
catch (Exception e)
{
TimeStamp.WriteLine(e.Message);
}
}
public void PathSet(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received PATH SET from {1}", CC_Name, networkPackage.sendingClientId);
RCPath currentPath = domain.domainRC.paths.Find(x => x.status == ConnectionStatus.InProgress);
Connection c = connections.Find(x => x.status == ConnectionStatus.InProgress);
c.confirmationsNeeded--;
if (c.confirmationsNeeded > 0)
{
Console.WriteLine("{0} {1} :: {2} more SET PATH RESPONSE needed", TimeStamp.TAB, CC_Name, c.confirmationsNeeded);
}
else
{
TimeStamp.WriteLine("{0} >> LINK CONNECTION REQUEST sent to {1}", CC_Name, "LRMs");
c.confirmationsNeeded = 2;
NetworkPackage message = new NetworkPackage(
CC_Name,
"LRMs",
Command.Link_Connection_Request,
String.Join(" ", currentPath.LRMids) + ":" + currentPath.startCrack + " " + currentPath.endCrack
);
domain.Send(message);
}
}
// send object to connected server
public bool Send(NetworkPackage objectToSend)
{
// make sure we have a valid connection id
if (GameData.g_ConnectionID == 0)
{
Exception e = new Exception("Trying to send data without a valid connection! Trying to generate one now");
OnNetworkError(e);
// try to assign new connectionID
GenerateConnectionID();
objectToSend.m_ConnectionID = GameData.g_ConnectionID;
}
try
{
// start listening thread
m_tClientThread = new Thread(new ParameterizedThreadStart(SendTask));
m_tClientThread.IsBackground = true;
m_tClientThread.Name = "OfficeChessClientSendThread";
m_tClientThread.Start(objectToSend);
}
catch (Exception e)
{
OnNetworkError(e);
return(false);
}
return(true);
}
static void Main(string[] args)
{
try
{
LRMCommunicator communicator = new LRMCommunicator(args[0]);
communicator.Start();
TimeStamp.WriteLine("LRMs working.");
Console.WriteLine(String.Format("{0} choose link from 1 to {1} to be DEVASTATED by MONSTROUS DIGGER", TimeStamp.TAB, communicator.LRMs.Count));
char c = Console.ReadKey().KeyChar;
NetworkPackage networkPackage = new NetworkPackage(
"LRMs",
"Cloud",
Command.Break_The_Link,
c.ToString()
);
communicator.Send(networkPackage);
Console.WriteLine();
TimeStamp.WriteLine("Link {0} destroyed. MWAHAHAAHAHA!", c.ToString());
Console.WriteLine("{0} CC is not informed yet. Press anything to acknowledge", TimeStamp.TAB);
Console.ReadKey().KeyChar.ToString();
communicator.AlarmCC(Int32.Parse(c.ToString()));
Console.WriteLine();
Console.WriteLine("Press anything to close");
Console.ReadKey();
communicator.Stop();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
Console.ReadKey();
}
private void ServerDataReceived(NetworkPackage nwPackage)
{
// if we have not yet received any data, start playing with this client
if (GameData.g_ConnectionID == 0 && nwPackage.m_Command == NetworkCommand.CONNECT_REQUEST)
{
// store our new connection ID, blocking transmissions from other sources
GameData.g_ConnectionID = nwPackage.m_ConnectionID;
// let other side know we agree
nwPackage.m_Command = NetworkCommand.CONNECT_ACCEPT;
m_Client.Send(nwPackage);
m_bNetworkGame = true;
}
// game in progress
else if (GameData.g_ConnectionID != 0)
{
// make sure connection ID's match up
if (GameData.g_ConnectionID != nwPackage.m_ConnectionID)
{
Exception e = new Exception("Received data from unknown client, discarding...");
NetworkError(e);
}
else
{
// process data
ProcessNetworkData(nwPackage);
}
}
}
private void UsedCracksRequest(NetworkPackage networkPackage)
{
string[] lrmIds = networkPackage.message.Split(' ');
List <int> usedCracks = new List <int>();
for (int i = 0; i < lrmIds.Length; i++)
{
//TimeStamp.WriteLine("{0} >> Received USED SLOTS REQUEST from {1}", "LRM_" + lrmIds[i], networkPackage.sendingClientId);
usedCracks.AddRange(LRMs.Find(x => x.linkId == Int32.Parse(lrmIds[i])).busyCracks);
}
List <int> distinctList = usedCracks.Distinct().ToList();
StringBuilder sb = new StringBuilder();
foreach (int crack in distinctList)
{
if (distinctList.Count > 0)
{
sb.Append(" ");
}
sb.Append(crack);
}
NetworkPackage response = new NetworkPackage(
"LRMs",
networkPackage.sendingClientId,
Command.Used_Cracks_Response,
sb.ToString()
);
TimeStamp.WriteLine("{0} >> USED SLOTS RESPONSE sent to {1}", "LRMs", networkPackage.sendingClientId);
Send(response);
}
// send object to connected server
public bool Send(NetworkPackage objectToSend)
{
// make sure we have a valid connection id
if (GameData.g_ConnectionID == 0)
{
Exception e = new Exception("Trying to send data without a valid connection! Trying to generate one now");
OnNetworkError(e);
// try to assign new connectionID
GenerateConnectionID();
objectToSend.m_ConnectionID = GameData.g_ConnectionID;
}
try
{
// start listening thread
m_tClientThread = new Thread(new ParameterizedThreadStart(SendTask));
m_tClientThread.IsBackground = true;
m_tClientThread.Name = "OfficeChessClientSendThread";
m_tClientThread.Start(objectToSend);
}
catch (Exception e)
{
OnNetworkError(e);
return false;
}
return true;
}
private void AllocateSlots(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received L CON REQ from {1} {2}", "LRMs", networkPackage.sendingClientId, networkPackage.message);
string[] splittedMessage = networkPackage.message.Split(':');
string[] MessageLRMs = splittedMessage[0].Split(' ');
for (int i = 0; i < MessageLRMs.Length; i++)
{
//TimeStamp.WriteLine("{0} >> Received ALLOCATE SLOTS from {1}", "LRM_" + MessageLRMs[i], networkPackage.sendingClientId);
LRM lrm = LRMs.Find(x => x.linkId == Int32.Parse(MessageLRMs[i]));
if (lrm.AddCracks(splittedMessage[1]))
{
Console.WriteLine("{0} {1} :: slots from {2} to {3} allocated", TimeStamp.TAB, "LRM_" + MessageLRMs[i], splittedMessage[1].Split(' ')[0], splittedMessage[1].Split(' ')[1]);
}
lrm.contacts.Add(networkPackage.sendingClientId);
}
TimeStamp.WriteLine("{0} >> LINK CONNECTION RESPONSE sent to {1}", "LRMs", networkPackage.sendingClientId);
if (splittedMessage.Length != 3)
{
NetworkPackage response = new NetworkPackage(
"LRMs",
networkPackage.sendingClientId,
Command.Slots_Allocated
);
Send(response);
}
}
public void Commit()
{
var storage = NetworkPackage.GetModule().GetLoad <Storage>(Seed);
storage.Update(Storage);
storage.Commit();
}
void ProcessData(byte[] data, EndPoint sender)
{
try {
NetworkPackage package = NetworkPackage.Deserialize(data);
package.sender = sender;
if (package.isImportant)
{
throw new System.NotImplementedException();
/*if (package.packageID >= freePackageID) {
* freePackageID = package.packageID + 1;
* OnRecieveData(package, sender);
* }
* NetworkPackage confirm = new NetworkPackage() {
* packageID = package.packageID,
* packageType = NetworkDataType.Confirm,
* isImportant = false
* };
* SendTo(confirm, sender);*/
}
else
{
RecieveData(package);
}
}
catch (Exception e) {
Debug.Log(e);
Debug.Log(e.StackTrace);
Debug.Log(e.Message);
}
}
internal void SetPath(NetworkPackage networkPackage)
{
networkPackage.sendingClientId = CC_Name;
networkPackage.receivingClientId = subnetwork.rc.RC_Name;
TimeStamp.WriteLine("{0} >> SET PATH REQUEST sent to {1}", CC_Name, networkPackage.receivingClientId);
subnetwork.rc.SetPath(networkPackage);
}
private void NetworkInterface_OnRecieveData(NetworkPackage package)
{
switch (package.packageType)
{
case NetworkDataType.Moving:
if (OnMovingPackage != null)
{
OnMovingPackage((MovingPackage)package);
}
break;
case NetworkDataType.Shooting:
break;
case NetworkDataType.Register:
if (OnRegisterPackage != null)
{
OnRegisterPackage((RegisterPackage)package, package.sender);
}
break;
case NetworkDataType.Confirm:
break;
case NetworkDataType.TankLoad:
if (OnNewTank != null)
{
OnNewTank((RegisterPackage)package);
}
break;
default:
break;
}
}
internal void CheckLink(NetworkPackage networkPackage)
{
// TimeStamp.WriteLine("{0} >> Received CHECK LINK REQUEST from {1}", RC_Name, networkPackage.sendingClientId);
// Console.WriteLine(networkPackage.message);
Edge affectedEdge = graph.edges.Find(x => x.id == Int32.Parse(networkPackage.message));
RCPath affectedPath = paths.Find(x => x.LRMids.Contains(affectedEdge.id));
affectedPath.status = ConnectionStatus.InProgress;
// Console.WriteLine("Edge: {0} {1} {2}", affectedEdge.id, affectedEdge.start, affectedEdge.end);
Node node1 = graph.nodes.Find(x => String.Equals(x.id, affectedEdge.start));
Node node2 = graph.nodes.Find(x => String.Equals(x.id, affectedEdge.end));
Node node11 = node1.neighbors.Find(x => String.Equals(x.id, node2.id));
Node node22 = node2.neighbors.Find(x => String.Equals(x.id, node1.id));
node1.neighbors.Remove(node11);
node2.neighbors.Remove(node22);
graph.edges.Remove(affectedEdge);
TimeStamp.WriteLine("{0} >> CHECK LINK RESPONSE sent to {1}", RC_Name, subnetwork.cc.CC_Name);
subnetwork.cc.connections.Find(x => x.id == affectedPath.CCConnectionId).status = ConnectionStatus.InProgress;
NetworkPackage message = new NetworkPackage(
subnetwork.cc.CC_Name,
"LRMs",
Command.Remove_Link_Connection_Request,
String.Join(" ", affectedPath.LRMids) + ":" + affectedPath.startCrack + " " + affectedPath.endCrack
);
TimeStamp.WriteLine("{0} >> REMOVE LINK CONNECTION REQUEST sent to {1}", message.sendingClientId, message.receivingClientId);
subnetwork.domain.Send(message);
}
public void SetPath(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received SET PATH from {1}", RC_Name, networkPackage.sendingClientId);
messagesToSend.Clear();
connectionMessage = networkPackage.message;
string lambda = connectionMessage.Split(' ')[0];
RCPath path = paths.Find(x => x.status == ConnectionStatus.InProgress);
path.lambda = lambda;
for (int i = 1; i < path.LRMids.Count; i++)
{
if (path.nodes[i].Contains("OXC"))
{
string portConfig = GetPorts(path.LRMids[i - 1], path.nodes[i], path.LRMids[i]);
if (portConfig.Length > 0)
{
messagesToSend.Push(new NetworkPackage(
RC_Name,
path.nodes[i],
Command.Set_OXC,
portConfig + " " + lambda
));
}
else
{
Console.WriteLine("PORT CONFIG ERROR");
}
}
}
string communicate = String.Join(" ", messagesToSend.ToList().Select(x => x.receivingClientId));
Console.WriteLine("{0} {1} :: SET PATH will be send to: {2}", TimeStamp.TAB, RC_Name, communicate);
subnetwork.domain.Send(messagesToSend.Pop());
}
public static byte[] Serialize(NetworkPackage package)
{
MemoryStream stream = new MemoryStream();
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, package);
return(stream.ToArray());
}
private void Send(Socket socket, NetworkPackage received)
{
ReceiverState state = new ReceiverState();
state.WorkSocket = socket;
state.Buffer = SerializeMessage(received);
socket.BeginSend(state.Buffer, 0, state.Buffer.Length, 0, new AsyncCallback(SendCallback), state);
}
public void PathFound(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received PATH FOUND from {1}", CC_Name, networkPackage.sendingClientId);
TimeStamp.WriteLine("{0} >> mini CONNECTION REQUEST RESPONSE sent to {1}", CC_Name, "CC_" + subnetwork.domain.emulationNodeId);
networkPackage.sendingClientId = CC_Name;
networkPackage.receivingClientId = "CC_" + subnetwork.domain.emulationNodeId;
networkPackage.MMsgType = Command.Path_Found;
subnetwork.domain.domainCC.PathFound(networkPackage);
}
private void SendPackage(NetworkPackage package)
{
var devices = DevicesWithReceiveAll(package.NetId, package.Frequency);
var device = DeviceWithAddress(package.NetId, package.Frequency, package.Address);
devices.Add(device);
SendToDevices(devices, package, false);
}
public void UsedSlotsResponse(NetworkPackage networkPackage)
{
//path found
string busyCracks = networkPackage.message;
networkPackage.message = paths.Find(x => x.status == ConnectionStatus.InProgress).length.ToString() + ":" + busyCracks;
//Console.WriteLine(networkPackage.message);
subnetwork.cc.PathFound(networkPackage);
}
internal void LinkDown(NetworkPackage networkPackage)
{
Console.WriteLine("----------------");
TimeStamp.WriteLine("{0} >> Received LINK DOWN from {1}", CC_Name, networkPackage.sendingClientId);
TimeStamp.WriteLine("{0} >> CHECK LINK REQUEST sent to {1}", CC_Name, subnetwork.rc.RC_Name);
networkPackage.sendingClientId = CC_Name;
networkPackage.receivingClientId = subnetwork.rc.RC_Name;
networkPackage.MMsgType = Command.Check_Link_Request;
subnetwork.rc.CheckLink(networkPackage);
}
private void button3_Click(object sender, EventArgs e)
{
// send take back move request message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.CONNECT_REQUEST;
m_Client.Send(nwpack);
// TODO: build timer for connection request time-out
}
public void Send(NetworkPackage networkPackage)
{
sendDone.Reset();
ReceiverState state = new ReceiverState();
state.WorkSocket = clientSocket;
state.Buffer = SerializeMessage(networkPackage);
clientSocket.BeginSend(state.Buffer, 0, state.Buffer.Length, 0, new AsyncCallback(SendCallback), state);
sendDone.WaitOne();
}
private byte[] SerializeMessage(NetworkPackage networkPackage)
{
BinaryFormatter bf = new BinaryFormatter();
using (var ms = new MemoryStream())
{
bf.Serialize(ms, networkPackage);
return(ms.ToArray());
}
}
public void CallIndication(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received CALL ACCEPT RESPONSE from {1}", NCC_Name, networkPackage.sendingClientId);
TimeStamp.WriteLine("{0} >> CONNECTION REQUEST REQUEST sent to {1}", NCC_Name, "CC_" + domain.emulationNodeId);
domain.domainCC.ConnectionRequest(new NetworkPackage(
NCC_Name,
"CC_" + domain.emulationNodeId,
Command.Connection_Request,
networkPackage.message + " " + currentBandwidth
));
}
public void CallAccept(NetworkPackage networkPackage)
{
TimeStamp.WriteLine("{0} >> received CALL ACCEPT REQUEST from {1}", CPCC_Name, networkPackage.sendingClientId);
clientNode.cloudCommunicator.Send(new NetworkPackage(
CPCC_Name,
networkPackage.sendingClientId,
Command.Call_Accept_Confirmed,
networkPackage.message
));
TimeStamp.WriteLine("{0} >> CALL ACCEPT RESPONSE sent to {1}", CPCC_Name, networkPackage.sendingClientId);
}
private void ReceivePackage(byte[] bytes)
{
try
{
NetworkPackage networkPackage = _packageGenerator.Generate(bytes);
PackageReceived?.Invoke(networkPackage);
}
catch
{
}
}
private void button3_Click(object sender, EventArgs e)
{
// send take back move request message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.CONNECT_REQUEST;
m_Client.Send(nwpack);
// TODO: build timer for connection request time-out
}
private NetworkPackage DeserializeMessage(ReceiverState receiverState, int byteRead)
{
using (var memoryStream = new MemoryStream())
{
var bf = new BinaryFormatter();
memoryStream.Write(receiverState.Buffer, 0, byteRead);
memoryStream.Seek(0, SeekOrigin.Begin);
NetworkPackage obj = (NetworkPackage)bf.Deserialize(memoryStream);
return(obj);
}
}
public void SendTo(NetworkPackage package, EndPoint to)
{
byte[] datagram = NetworkPackage.Serialize(package);
try {
client.Send(datagram, datagram.Length, (IPEndPoint)to);
}
catch (Exception e) {
Debug.Log(e);
Debug.Log(e.StackTrace);
Debug.Log(e.Message);
}
}
public override void Send(int type, byte[] data)
{
if (data.Length <= 0 || !_connected)
{
return;
}
NetworkPackage pack = new NetworkPackage();
pack.type = type;
pack.data = data;
Send(pack.Encode());
}
public void CallRequest(string toNode, string bandwidth)
{
NetworkPackage networkPackage = new NetworkPackage(
CPCC_Name,
"NCC_" + clientNode.subnetwork.Split('_')[0],
Command.Call_Request_Request,
toNode + " " + bandwidth
);
TimeStamp.WriteLine("{0} >> CALL REQUEST REQUEST sent to {1}", CPCC_Name, networkPackage.receivingClientId);
clientNode.cloudCommunicator.Send(networkPackage);
}
public void ConnectionConfirmed(NetworkPackage networkPackage)
{
//TimeStamp.WriteLine("{0} >> Received CONNECTION CONFIRMED from {1}", NCC_Name, networkPackage.sendingClientId);
string[] connectedClients = currentCall.Split(' ');
TimeStamp.WriteLine("{0} >> CALL REQUEST RESPONSE sent to {1}", NCC_Name, requestingCPCC);
domain.Send(new NetworkPackage(
NCC_Name,
requestingCPCC,
Command.Call_Confirmed,
connectedClients[1]
));
}
private void takeBackMoveToolStripMenuItem_Click(object sender, EventArgs e)
{
// send take back move request message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.TAKE_BACK_MOVE_REQUEST;
nwpack.m_FromSquare = (byte)GameData.g_LastMove.FromSquare;
nwpack.m_ToSquare = (byte)GameData.g_LastMove.ToSquare;
nwpack.m_ConnectionID = GameData.g_ConnectionID;
m_Client.Send(nwpack);
this.ChessRules.TakeBackLastMove();
}
private void ServerDataReceived(NetworkPackage nwPackage)
{
// if we have not yet received any data, start playing with this client
if (GameData.g_ConnectionID == 0 && nwPackage.m_Command == NetworkCommand.CONNECT_REQUEST)
{
// store our new connection ID, blocking transmissions from other sources
GameData.g_ConnectionID = nwPackage.m_ConnectionID;
// let other side know we agree
nwPackage.m_Command = NetworkCommand.CONNECT_ACCEPT;
m_Client.Send(nwPackage);
m_bNetworkGame = true;
}
// game in progress
else if (GameData.g_ConnectionID != 0)
{
// make sure connection ID's match up
if (GameData.g_ConnectionID != nwPackage.m_ConnectionID)
{
Exception e = new Exception("Received data from unknown client, discarding...");
NetworkError(e);
}
else
{
// process data
ProcessNetworkData(nwPackage);
}
}
}
private void resignToolStripMenuItem_Click(object sender, EventArgs e)
{
// send resign message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.RESIGN_REQUEST;
nwpack.m_FromSquare = 0;
nwpack.m_ToSquare = 0;
nwpack.m_ConnectionID = GameData.g_ConnectionID;
m_Client.Send(nwpack);
}
private void ProcessNetworkData(NetworkPackage nwPackage)
{
// process network data
switch (nwPackage.m_Command)
{
case NetworkCommand.CONNECT_ACCEPT:
{
// if these aren't the same there is a problem
if (GameData.g_ConnectionID != nwPackage.m_ConnectionID)
{
Exception e = new Exception("Connection ID's do not match up while connecting... abort.");
NetworkError(e);
GameData.g_ConnectionID = 0;
}
Console.WriteLine("Connection synchronized...");
m_bNetworkGame = true;
break;
}
case NetworkCommand.NEW_GAME_REQUEST:
{
// reset board
this.ChessRules.NewGame();
// let other side know we agree
nwPackage.m_Command = NetworkCommand.NEW_GAME_ACCEPT;
m_Client.Send(nwPackage);
break;
}
case NetworkCommand.NEW_GAME_ACCEPT:
{
// other side accepted, reset board
this.ChessRules.NewGame();
break;
}
case NetworkCommand.MAKE_MOVE_REQUEST:
{
bool bMoveAllowed = this.ChessRules.IsMoveAllowed(nwPackage.m_FromSquare, nwPackage.m_ToSquare);
if (bMoveAllowed)
{
// move is allowed, let other side know
nwPackage.m_Command = NetworkCommand.MAKE_MOVE_ACCEPT;
m_Client.Send(nwPackage);
// make the actual move
this.ChessRules.DoMove(nwPackage.m_FromSquare, nwPackage.m_ToSquare);
// update the board
this.Chessboard.Invalidate();
// notify user
string from = Etc.SquareToString(nwPackage.m_FromSquare);
string to = Etc.SquareToString(nwPackage.m_ToSquare);
notifyIcon1.ShowBalloonTip(1, "OfficeChess", "A move was made from " + from + " to " + to, ToolTipIcon.Info);
}
else
{
// let other side know we do not agree with this move
nwPackage.m_Command = NetworkCommand.MAKE_MOVE_DENY;
m_Client.Send(nwPackage);
}
break;
}
case NetworkCommand.MAKE_MOVE_ACCEPT:
{
// move was accepted by the other side, make move
this.ChessRules.DoMove(nwPackage.m_FromSquare, nwPackage.m_ToSquare);
// update the board
this.Chessboard.Invalidate();
break;
}
case NetworkCommand.MAKE_MOVE_DENY:
{
Exception e = new Exception("Other side reports move is invalid, boards could be out of sync.");
NetworkError(e);
break;
}
default:
{
Exception e = new Exception("Handling unspecified case!");
NetworkError(e);
break;
}
}
}
private void offerDrawToolStripMenuItem_Click(object sender, EventArgs e)
{
// send draw offer message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.OFFER_DRAW_REQUEST;
nwpack.m_FromSquare = 0;
nwpack.m_ToSquare = 0;
nwpack.m_ConnectionID = GameData.g_ConnectionID;
m_Client.Send(nwpack);
}
private void newGameToolStripMenuItem1_Click(object sender, EventArgs e)
{
// send new game request message to other side
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.NEW_GAME_REQUEST;
nwpack.m_FromSquare = 0;
nwpack.m_ToSquare = 0;
nwpack.m_ConnectionID = GameData.g_ConnectionID;
m_Client.Send(nwpack);
engInt.ResetEngine();
}
// try to make the move
private void Chessboard_OnMoveMade(int CurrSquare, int TargetSquare)
{
Console.WriteLine("A move was made from " + CurrSquare.ToString() + " to " + TargetSquare.ToString());
bool bMoveAllowed = this.ChessRules.IsMoveAllowed(CurrSquare, TargetSquare);
Console.WriteLine("The rules says... " + ((bMoveAllowed == true) ? "allowed :-)" : "not allowed :-("));
// send through network
if (bMoveAllowed)
{
// if network game, ask other side to concur with this move
if (m_bNetworkGame)
{
NetworkPackage nwpack = new NetworkPackage();
nwpack.m_Command = NetworkCommand.MAKE_MOVE_REQUEST;
nwpack.m_FromSquare = (byte)CurrSquare;
nwpack.m_ToSquare = (byte)TargetSquare;
nwpack.m_ConnectionID = GameData.g_ConnectionID;
m_Client.Send(nwpack);
}
// otherwise just do the move
else
{
this.ChessRules.DoMove(CurrSquare, TargetSquare);
// notify user
string from = Etc.SquareToString(CurrSquare);
string to = Etc.SquareToString(TargetSquare);
notifyIcon1.ShowBalloonTip(1, "OfficeChess", "A move was made from " + from + " to " + to, ToolTipIcon.Info);
}
engInt.CalculateBestMove();
}
}
void SendS2C(NetworkPackage package)
{
s2cBytesTransmitted += 20 + package.Size;
s2cPending.Add(package);
}
// listens for incoming transmissions
private void ServerTask()
{
try
{
// initialize tcp listener
m_TCPListener = new TcpListener(m_ServerIP, m_ServerPort);
m_TCPListener.Start();
Console.WriteLine("Listening for incoming data...");
while (m_bRunThread)
{
// block until connection established
m_ClientSocket = m_TCPListener.AcceptSocket();
// if client connected start receiving thread
if (m_ClientSocket.Connected)
{
Console.WriteLine("Receiving data from: " + m_ClientSocket.RemoteEndPoint.ToString());
// get bytes
int numbytes = m_ClientSocket.Receive(m_LastReceivedData);
Console.WriteLine("Received " + numbytes.ToString() + " bytes from: " + m_ClientSocket.RemoteEndPoint.ToString());
// disconnect
m_ClientSocket.Disconnect(true);
// try to parse incoming data to network package struct
NetworkPackage nwPackage = new NetworkPackage();
nwPackage = (NetworkPackage)Etc.ByteArrayToObject(m_LastReceivedData, nwPackage.GetType());
// trigger event
OnNetworkReceivedData(nwPackage);
}
}
}
catch (SocketException se)
{
OnNetworkError(se);
}
catch (SystemException e)
{
OnNetworkError(e);
}
}
