//Wysyła obiekt do komputera o podanym ip
public void sendToComputer(object o, IPEndPoint ip)
{
string json = JsonUtility.ToJson(o);
QueryPack qp = new QueryPack();
qp.json = json;
qp.type = o.GetType().FullName;
qp.port = port;
qp.sendMode = SendMode.SM_COMPUTER;
QueuePack queue = new QueuePack();
queue.qp = qp;
queue.endpoint = ip;
sendQueue.Enqueue(queue);
}
public override void executeQuery(QueuePack queuePack)
{
Debug.Log("Q_JOIN_OK execute.");
if (NetworkManager.instance.getNetworkState() == NetworkState.NET_ENABLED)
{
IPEndPoint tmp = NetworkManager.instance.getJoinIp();
bool res = IPEndPoint.Equals(tmp, queuePack.endpoint);
if (res)
{
IPEndPoint ip = queuePack.endpoint;
NetworkManager.instance.acceptJoin(ip);
Debug.Log("Q_JOIN_OK done.");
}
}
}
//Pilnuje aby obiekt dotarł do każdego komputera w grze, poza komputerem z którego wysłano obiekt.
public void sendToAllComputers(object o)
{
if (networkState == NetworkState.NET_DISABLED || networkState == NetworkState.NET_ENABLED)
{
return;
}
string json = JsonUtility.ToJson(o);
QueryPack qp = new QueryPack();
qp.json = json;
qp.type = o.GetType().FullName;
qp.port = port;
qp.sendMode = SendMode.SM_ALL_IN_NETWORK;
QueuePack queue = new QueuePack();
queue.qp = qp;
//throw new NotImplementedException();
switch (networkState)
{
case NetworkState.NET_SERVER:
{
foreach (Computer comp in computers)
{
IPEndPoint ip = comp.ip;
if (IPEndPoint.Equals(ip, myIp))
{
continue;
}
QueuePack tmp = new QueuePack();
tmp.endpoint = ip;
tmp.qp = queue.qp;
sendQueue.Enqueue(tmp);
}
break;
}
case NetworkState.NET_CLIENT:
{
queue.endpoint = serverIp;
sendQueue.Enqueue(queue);
break;
}
default:
sendQueue.Enqueue(queue);
break;
}
}
//Wysyła obiekt do wszystkich urządzeń w domenie rozgłoszeniowej, nawet do samego siebie
public void sendBroadcast(object o)
{
string json = JsonUtility.ToJson(o);
QueryPack qp = new QueryPack();
qp.json = json;
qp.type = o.GetType().FullName;
qp.port = port;
qp.sendMode = SendMode.SM_BROADCAST;
QueuePack queue = new QueuePack();
queue.qp = qp;
queue.endpoint = new IPEndPoint(IPAddress.Broadcast, broadcastPort);
sendQueue.Enqueue(queue);
//Debug.Log("Broadcast");
}
//Wysyła obiekt do komputera o podanym ip
public void SendToComputer(object o, IPEndPoint ip)
{
var json = JsonUtility.ToJson(o);
var qp = new QueryPack
{
json = json,
type = o.GetType().FullName,
port = port,
sendMode = SendMode.SM_COMPUTER
};
var queue = new QueuePack
{
qp = qp,
endpoint = ip
};
sendQueue.Enqueue(queue);
}
//Wysyła obiekt do wszystkich urządzeń w domenie rozgłoszeniowej, nawet do samego siebie
public void SendBroadcast(object o)
{
var json = JsonUtility.ToJson(o);
var qp = new QueryPack
{
json = json,
type = o.GetType().FullName,
port = port,
sendMode = SendMode.SM_BROADCAST
};
var queue = new QueuePack
{
qp = qp,
endpoint = new IPEndPoint(IPAddress.Broadcast, broadcastPort)
};
sendQueue.Enqueue(queue);
}
public static void TopView(Node root, int level)
{
if (root == null)
{
return;
}
//each QueuePack will hold the distance from the root and the root
Queue <QueuePack> q = new Queue <QueuePack>();
//the dictionary will hold only unique values
Dictionary <int, Node> topView = new Dictionary <int, Node>();
if (root == null)
{
return;
}
else
{
q.Enqueue(new QueuePack(0, root));
}
while (q.Count > 0)
{
QueuePack temp = q.Dequeue();
Node tnode = temp.Root;
int lvl = temp.Level;
if (!topView.ContainsKey(lvl))
{
Console.WriteLine(tnode.Value + " ");
topView.Add(lvl, tnode);
}
if (tnode.Left != null)
{
q.Enqueue(new QueuePack(lvl - 1, tnode.Left));
}
if (tnode.Right != null)
{
q.Enqueue(new QueuePack(lvl + 1, tnode.Right));
}
}
}
//Wysyła obiekt do komputera na którym gra gracz o danym id, nawet jeżeli to komputer z którego wysłano obiekt.
public void SendToPlayer(object o, int playerId)
{
throw new NotImplementedException();
if (networkState == NetworkState.NET_DISABLED || networkState == NetworkState.NET_ENABLED)
{
return;
}
var json = JsonUtility.ToJson(o);
var qp = new QueryPack
{
json = json,
type = o.GetType().FullName,
targetPlayerId = playerId,
port = port,
sendMode = SendMode.SM_PLAYER
};
var queue = new QueuePack
{
qp = qp
};
switch (networkState)
{
case NetworkState.NET_CLIENT:
queue.endpoint = serverIp;
sendQueue.Enqueue(queue);
break;
case NetworkState.NET_SERVER:
foreach (var player in players)
{
if (player.id == playerId)
{
queue.endpoint = player.ip;
sendQueue.Enqueue(queue);
break;
}
}
break;
}
}
//Wysyła obiekt do serwera, jeżeli serwer to wysyła to wyśle sam do siebie.
public void sendToServer(object o)
{
if (networkState == NetworkState.NET_DISABLED || networkState == NetworkState.NET_ENABLED)
{
return;
}
string json = JsonUtility.ToJson(o);
QueryPack qp = new QueryPack();
qp.json = json;
qp.type = o.GetType().FullName;
qp.port = port;
qp.sendMode = SendMode.SM_TO_SERVER;
QueuePack queue = new QueuePack();
queue.qp = qp;
queue.endpoint = serverIp;
sendQueue.Enqueue(queue);
}
public override void ExecuteQuery(QueuePack queuePack)
{
//Debug.Log("Q_SERVER_INFO_REQUEST execute.");
if (NetworkManager.instance.GetNetworkState() == NetworkState.NET_SERVER)
{
try
{
var obj = GameObject.Find("MenuManager");
var mm = obj.GetComponent <MenuManager>();
var info = new Q_SERVER_INFO
{
serverName = mm.serverName,
color = mm.serverColor
};
NetworkManager.instance.SendToComputer(info, queuePack.endpoint);
}
catch { }
}
}
public override void ExecuteQuery(QueuePack queuePack)
{
//Debug.Log("Q_JOIN_REQUEST execute.");
if (NetworkManager.instance.GetNetworkState() == NetworkState.NET_SERVER)
{
if (NetworkManager.instance.IsKnownComputer(queuePack.endpoint))
{
NetworkManager.instance.AddComputer(queuePack.endpoint);
NetworkManager.instance.SendToComputer(new Q_JOIN_OK(), queuePack.endpoint);
}
Debug.Log("Connected");
NetworkManager.instance.AddComputer(queuePack.endpoint);
NetworkManager.instance.SendToComputer(new Q_JOIN_OK(), queuePack.endpoint);
SceneManager.LoadScene("MainMenu");
//Debug.Log("Q_JOIN_REQUEST done." + queuePack.endpoint.Address + "\t" + queuePack.endpoint.Port);
}
}
private void CloseClient(int id)
{
int idx = id;
ClientBuf clientPack = mClients[idx];
QueuePack info = new QueuePack();
info.ClientID = id;
info.buf = null;
info.ipAddr = clientPack.address;
info.type = NetType.DISCON;
mQueue.Enqueue(info);
mMRE.Set();
clientPack.client.Close();
clientPack.id = -1;
clientPack.client = null;
clientPack.buf = null;
clientPack.address = "";
mClients[idx] = null;
}
//Wysyła obiekt do serwera, jeżeli serwer to wysyła to wyśle sam do siebie.
public void SendToServer(object o)
{
if (networkState == NetworkState.NET_DISABLED || networkState == NetworkState.NET_ENABLED)
{
return;
}
var json = JsonUtility.ToJson(o);
var qp = new QueryPack
{
json = json,
type = o.GetType().FullName,
port = port,
sendMode = SendMode.SM_TO_SERVER
};
var queue = new QueuePack
{
qp = qp,
endpoint = serverIp
};
sendQueue.Enqueue(queue);
}
public override void executeQuery(QueuePack queuePack)
{
Debug.Log("Q_JOIN_REQUEST execute.");
if (NetworkManager.instance.getNetworkState() == NetworkState.NET_SERVER)
{
if (NetworkManager.instance.isKnownComputer(queuePack.endpoint))//może dołączyć nawet w trakcie gry, jeżeli na chwilę go wywali
{
NetworkManager.instance.addComputer(queuePack.endpoint);
NetworkManager.instance.sendToComputer(new Q_JOIN_OK(), queuePack.endpoint);
}
if (true /*jakis warunek typu, jak gra jest w toku false*/)
{
NetworkManager.instance.addComputer(queuePack.endpoint);
NetworkManager.instance.sendToComputer(new Q_JOIN_OK(), queuePack.endpoint);
Debug.Log("Q_JOIN_REQUEST done.");
}
else
{
Debug.Log("Q_JOIN_REQUEST fail.");
}
}
}
//Wysyła obiekt do komputera na którym gra gracz o danym id, nawet jeżeli to komputer z którego wysłano obiekt.
public void sendToPlayer(object o, int playerId)
{
throw new NotImplementedException();
if (networkState == NetworkState.NET_DISABLED || networkState == NetworkState.NET_ENABLED)
{
return;
}
string json = JsonUtility.ToJson(o);
QueryPack qp = new QueryPack();
qp.json = json;
qp.type = o.GetType().FullName;
qp.targetPlayerId = playerId;
qp.port = port;
qp.sendMode = SendMode.SM_PLAYER;
QueuePack queue = new QueuePack();
queue.qp = qp;
switch (networkState)
{
case NetworkState.NET_CLIENT:
queue.endpoint = serverIp;
sendQueue.Enqueue(queue);
break;
case NetworkState.NET_SERVER:
foreach (PlayerInfo player in players)
{
if (player.id == playerId)
{
queue.endpoint = player.ip;
sendQueue.Enqueue(queue);
break;
}
}
break;
}
}
private bool pushPacket(ref ClientBuf client)
{
long nRecvLen = client.mem.Length;
byte[] buf = client.mem.GetBuffer();
int headSize = ICD.HEADER.HeaderSize();
if (nRecvLen < headSize)
{
return(false);
}
ICD.HEADER head = ICD.HEADER.GetHeaderInfo(buf);
if (head.sof != (uint)ICD.MAGIC.SOF)
{
client.mem = new MemoryStream(MAX_CLIENT_BUF);
return(false);
}
uint msgSize = head.size;
if (nRecvLen < msgSize)
{
return(false);
}
QueuePack pack = new QueuePack();
pack.ClientID = client.id;
pack.size = msgSize;
pack.buf = new byte[msgSize];
Array.Copy(buf, pack.buf, msgSize);
mQueue.Enqueue(pack);
client.mem = new MemoryStream(MAX_CLIENT_BUF);
return(true);
}
public override void executeQuery(QueuePack queuePack)
{
Debug.Log("Q_IM_ALIVE_RESPONSE done.");
NetworkManager.instance.setServerTimeZero();
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("CROUCH");
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("RIGHT");
NetworkManager.instance.TurnRightCharacter();
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("JUMP");
//NetworkManager.instance.JumCharacter();
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("Q_IM_ALIVE_RESPONSE " + queuePack.endpoint.Address);
NetworkManager.instance.SetServerTimeZero();
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("Q_IM_ALIVE " + queuePack.endpoint.Address);
NetworkManager.instance.SetComputerTimeZero(queuePack.endpoint);
NetworkManager.instance.SendToComputer(new Q_IM_ALIVE_RESPONSE(), queuePack.endpoint);
}
public override void ExecuteQuery(QueuePack queuePack)
{
Debug.Log("HELLO " + text);
}
public abstract void ExecuteQuery(QueuePack queuePack);
public override void executeQuery(QueuePack queuePack)
{
Debug.Log("Q_IM_ALIVE done.");
NetworkManager.instance.setComputerTimeZero(queuePack.endpoint);
NetworkManager.instance.sendToComputer(new Q_IM_ALIVE_RESPONSE(), queuePack.endpoint);
}
private void processQueueMessage(QueuePack queuePack)
{
bool wtf = !IPEndPoint.Equals(queuePack.endpoint, serverIp);
if (networkState == NetworkState.NET_CLIENT && wtf)
{
return;
}
if (networkState == NetworkState.NET_SERVER && lockMode && !isKnownComputer(queuePack.endpoint))
{
return;
}
switch (queuePack.qp.sendMode)
{
case SendMode.SM_BROADCAST:
if (!IPEndPoint.Equals(queuePack.endpoint, myIp))
{
receiveQueue.Enqueue(queuePack);
}
break;
case SendMode.SM_ALL_IN_NETWORK:
receiveQueue.Enqueue(queuePack);
if (this.networkState == NetworkState.NET_SERVER)
{
IPEndPoint source = queuePack.endpoint;
foreach (Computer computer in computers)
{
if (IPEndPoint.Equals(source, computer.ip) || IPEndPoint.Equals(myIp, computer.ip))
{
continue;
}
QueuePack tmp2 = new QueuePack();
tmp2.endpoint = computer.ip;
tmp2.qp = queuePack.qp;
tmp2.qp.port = serverIp.Port;
sendQueue.Enqueue(tmp2);
}
}
break;
case SendMode.SM_PLAYER:
if (this.networkState == NetworkState.NET_SERVER)
{
foreach (PlayerInfo player in players)
{
if (player.id == queuePack.qp.targetPlayerId)
{
queuePack.endpoint = player.ip;
sendQueue.Enqueue(queuePack);
break;
}
}
}
else
{
receiveQueue.Enqueue(queuePack);
}
break;
case SendMode.SM_TO_SERVER_TO_ALL:
foreach (Computer comp in computers)
{
IPEndPoint ip = comp.ip;
QueryPack tmp = queuePack.qp;
tmp.sendMode = SendMode.SM_COMPUTER;
QueuePack queue = new QueuePack();
queue.qp = tmp;
queue.endpoint = ip;
sendQueue.Enqueue(queue);
}
break;
case SendMode.SM_TO_SERVER:
receiveQueue.Enqueue(queuePack);
break;
default:
receiveQueue.Enqueue(queuePack);
break;
}
}
