public void logSentMessage(BaseQTClient client, QTMessage message)
{
QTMessageLog log = new QTMessageLog(1, message, client);
log.direction = QTMessageLog.messageDirection.SERVERTOCLIENT;
messageLog.Add(log);
}
public void logReceivedMessage(BaseQTClient client, QTMessage message)
{
QTMessageLog log = new QTMessageLog(1, message, client);
log.direction = QTMessageLog.messageDirection.CLIENTTOSERVER;
messageLog.Add(log);
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_SYNC:
WorkerServerQTClient qtRemoteClient = (WorkerServerQTClient)client;
foreach (ServerQTObject obj in WorkerServerManager.instance.spawnManager.spawnedObjects.Values)
{
SpawnMessage spawnMessage = new SpawnMessage();
spawnMessage.objectID = obj.objectID;
spawnMessage.prefabName = obj.prefabName;
spawnMessage.spawnPosition = QTUtils.getSyncPositionMessageFromObject(obj);
spawnMessage.spawnRotation = QTUtils.getSyncRotationMessageFromObject(obj);
spawnMessage.active = obj.gameObject.activeSelf;
qtRemoteClient.sendMessage(spawnMessage);
foreach (BaseQTObjectComponent comp in obj.objectComponents.Values)
{
comp.serverComponent.syncAllFields();
}
}
break;
}
}
public void handleStream()
{
while (true)
{
try {
byte[] sizeData = new byte[4];
int sizeBytes = stream.Read(sizeData, 0, sizeData.Length);
int nextPacketSize = BitConverter.ToInt32(sizeData, 0);
if (nextPacketSize == 0)
{
continue;
}
byte[] data = new byte[nextPacketSize];
int bytes = stream.Read(data, 0, data.Length);
debugRecieved(sizeData, data);
QTMessage message = QTUtils.ByteArrayToMessage(data);
qtClient.queuedMessages.Add(message);
} catch (Exception e) {
QTDebugger.instance.debugWarning(QTDebugger.debugType.NETWORK, "[" + qtClient.type.ToString() + "_thread] Error while reading the NetworkStream-");
QTDebugger.instance.debugError(QTDebugger.debugType.NETWORK, e);
qtClient.closeConnection();
break;
}
}
}
public void sendMessageToAll(QTMessage message)
{
foreach (ServerQTClient qtRemoteClient in connections.clients.ToList())
{
qtRemoteClient.sendMessage(message);
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.WORKER_READY: {
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
WorkerReadyMessage workerReadyMessage = (WorkerReadyMessage)message;
qtRemoteClient.remoteType = QTClient.clientType.WORKER_SERVER;
MasterServerWorker worker = MasterServerManager.instance.workersManager.workers[workerReadyMessage.id];
RoomInfoMessage roomInfoMessage = new RoomInfoMessage();
roomInfoMessage.room = worker.room;
qtRemoteClient.sendMessage(roomInfoMessage);
worker.onWorkerReady();
break;
}
case QTMessage.type.WORKER_INFO: {
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
WorkerInfoMessage workerInfoMessage = (WorkerInfoMessage)message;
MasterServerWorker worker = MasterServerManager.instance.workersManager.workers[workerInfoMessage.id];
worker.room.ip = workerInfoMessage.ip;
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Recieved info from Worker(" + worker.room.id + ")...");
break;
}
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.READY:
WorkerServerQTClient qtRemoteClient = (WorkerServerQTClient)client;
ReadyMessage readyMessage = (ReadyMessage)message;
if (!qtRemoteClient.ready && readyMessage.state)
{
qtRemoteClient.ready = readyMessage.state;
SessionMessage sessionMessage = new SessionMessage();
sessionMessage.session = qtRemoteClient.session;
qtRemoteClient.sendMessage(sessionMessage);
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Client(" + client.getIP() + ") is ready...");
WorkerServerManager.instance.onClientReady(qtRemoteClient);
}
else
{
qtRemoteClient.ready = readyMessage.state;
}
break;
}
}
public QTMessageLog(int _index, QTMessage _message, BaseQTClient _client)
{
index = _index;
type = _message.messageType;
messageSize = QTUtils.ObjectToByteArray(_message).Length;
identity = _client.getIP();
}
public void debugRecievedMessage(QTMessage message)
{
if (message.messageType != QTMessage.type.WORKER_DEBUG)
{
//QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Recieved message of type " + message.messageType.ToString());
}
}
public void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_HEARTBEAT:
double currentTimestamp = (DateTime.Now - DateTime.MinValue).TotalMilliseconds;
RequestHeartbeatMessage requestMessage = (RequestHeartbeatMessage)message;
HeartbeatMessage heartbeatMessage = new HeartbeatMessage(requestMessage);
heartbeatMessage.serverTimestamp = ((RequestHeartbeatMessage)message).createdTimestamp;
heartbeatMessage.createdTimestamp = currentTimestamp;
sendMessage(heartbeatMessage);
break;
case QTMessage.type.ROOM_INFO:
RoomInfoMessage infoMessage = (RoomInfoMessage)message;
WorkerServerManager.instance.room = infoMessage.room;
WorkerInfoMessage workerMessage = new WorkerInfoMessage();
workerMessage.id = WorkerServerManager.instance.room.id;
workerMessage.ip = "127.0.0.1";
sendMessage(workerMessage);
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Sending worker info message...");
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.EVENT:
onEvent((EventMessage)message);
break;
}
}
public void sendMessageToAllReady(QTMessage message)
{
foreach (ServerQTClient qtRemoteClient in connections.clients.ToList())
{
WorkerServerQTClient workerClient = (WorkerServerQTClient)qtRemoteClient;
if (workerClient.ready)
{
qtRemoteClient.sendMessage(message);
}
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.OWNER:
QTClient qtClient = (QTClient)client;
OwnerMessage ownerMessage = (OwnerMessage)message;
ClientManager.instance.spawnManager.spawnedObjects[ownerMessage.objectID].setOwner(ownerMessage.ownerID);
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.WORKER_DEBUG:
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
WorkerDebugMessage debugMessage = (WorkerDebugMessage)message;
QTDebugger.instance._debug(debugMessage.debugType, QTDebugger.debugType.NETWORK_WORKER, debugMessage.message);
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.SESSION:
QTClient qtClient = (QTClient)client;
SessionMessage sessionMessage = (SessionMessage)message;
qtClient.session = sessionMessage.session;
QTDebugger.instance.debug(QTDebugger.debugType.BASE, "Recieved new session(" + sessionMessage.session.id + ")-");
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_ROOMS:
RequestRoomsMessage requestMessage = (RequestRoomsMessage)message;
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
RoomsMessage roomsMessage = new RoomsMessage(requestMessage);
roomsMessage.rooms = MasterServerManager.instance.workersManager.getRooms();
qtRemoteClient.sendMessage(roomsMessage);
break;
}
}
public void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_HEARTBEAT:
double currentTimestamp = (DateTime.Now - DateTime.MinValue).TotalMilliseconds;
RequestHeartbeatMessage requestMessage = (RequestHeartbeatMessage)message;
HeartbeatMessage heartbeatMessage = new HeartbeatMessage(requestMessage);
heartbeatMessage.serverTimestamp = ((RequestHeartbeatMessage)message).createdTimestamp;
heartbeatMessage.createdTimestamp = currentTimestamp;
sendMessage(heartbeatMessage);
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.SPAWN:
SpawnMessage spawnMessage = (SpawnMessage)message;
BaseQTObject obj = ClientManager.instance.spawnManager.spawnObject(spawnMessage.objectID, spawnMessage.prefabName, spawnMessage.spawnPosition, spawnMessage.spawnRotation);
obj.gameObject.SetActive(spawnMessage.active);
break;
case QTMessage.type.DESPAWN:
DespawnMessage despawnMessage = (DespawnMessage)message;
ClientManager.instance.spawnManager.despawnObject(despawnMessage.objectID);
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REQUEST_NEW_INSTANCE:
MasterServerQTClient qtRemoteClient = (MasterServerQTClient)client;
RequestNewInstanceMessage requestMessage = (RequestNewInstanceMessage)message;
MasterServerWorker worker = MasterServerManager.instance.workersManager.spawnWorker(Guid.NewGuid().ToString());
InstanceMessage instanceMessage = new InstanceMessage(requestMessage);
instanceMessage.room = worker.room;
worker.onWorkerReady += () => {
sendRequestInstanceResponse(qtRemoteClient, instanceMessage);
};
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.INPUT:
InputMessage inputMessage = (InputMessage)message;
if (inputMessage.active)
{
onClientKeyDown(inputMessage.keyCode);
}
else
{
onClientKeyUp(inputMessage.keyCode);
}
break;
case QTMessage.type.INPUT_AXIS:
InputAxisMessage inputAxisMessage = (InputAxisMessage)message;
updateAxisState(inputAxisMessage.axis, inputAxisMessage.value);
break;
case QTMessage.type.VR_ACTION:
VRActionMessage actionMessage = (VRActionMessage)message;
updateVRAction(actionMessage.actionName, QTUtils.getValueFromVRActionMessage(actionMessage));
break;
case QTMessage.type.SYNC_VR_POSITION:
SyncVRPositionMessage positionMessage = (SyncVRPositionMessage)message;
updateVRPosition(positionMessage.source, new Vector3(positionMessage.posX, positionMessage.posY, positionMessage.posZ));
break;
case QTMessage.type.SYNC_VR_ROTATION:
SyncVRRotationMessage rotationMessage = (SyncVRRotationMessage)message;
updateVRRotation(rotationMessage.source, new Vector3(rotationMessage.rotX, rotationMessage.rotY, rotationMessage.rotZ));
break;
}
}
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.REGISTER:
RegisterMessage registerMessage = (RegisterMessage)message;
UserInfo info = new UserInfo();
info.username = registerMessage.username;
info.password = registerMessage.password;
info.permissions = UserInfo.userPermissions.USER;
RegisterReplyMessage replyMessage = MasterServerManager.instance.authManager.addUser(registerMessage, info);
client.sendMessage(replyMessage);
break;
case QTMessage.type.LOGIN:
LoginMessage loginMessage = (LoginMessage)message;
LoginReplyMessage loginReplyMessage = MasterServerManager.instance.authManager.loginUser(loginMessage);
client.sendMessage(loginReplyMessage);
break;
}
}
public void sendMessage(QTMessage message)
{
lock (sendLock) {
try {
if (client.Connected == false)
{
return;
}
byte[] bytes = QTUtils.MessageToByteArray(message);
byte[] sizeBytes = BitConverter.GetBytes(bytes.Length);
try {
debugSent(sizeBytes, bytes);
thread.stream.Write(sizeBytes, 0, sizeBytes.Length);
thread.stream.Write(bytes, 0, bytes.Length);
} catch (Exception e) {
QTDebugger.instance.debugWarning(QTDebugger.debugType.NETWORK, "[" + type + "_base] Error while writing the NetworkStream-");
QTDebugger.instance.debugError(QTDebugger.debugType.NETWORK, e);
closeConnection();
}
var responsableValid = message as QTResponsableMessage;
if (responsableValid != null)
{
QTResponsableMessage responseMessage = (QTResponsableMessage)message;
awaitingResponse.Add(responseMessage.responseID, responseMessage);
}
onMessageSent(message);
} catch (Exception e) {
Debug.LogWarning(e);
}
}
}
public void handleSentMessage(QTMessage message)
{
manager.onMessageSent(this, message);
}
public void handleMessage(QTMessage message)
{
manager.onMessageReceived(this, message);
}
public override void handleMessage(QTMessage message)
{
}
public static byte[] MessageToByteArray(QTMessage message)
{
//return Compress(ObjectToByteArray(message));
return(ObjectToByteArray(message));
}
public abstract void handleMessage(QTMessage message);
public override void handleMessage(QTMessage message)
{
switch (message.messageType)
{
case QTMessage.type.SYNC_POSITION: {
SyncPositionMessage syncMessage = (SyncPositionMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(syncMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[syncMessage.objectID];
SyncGameobject syncComponent = (SyncGameobject)clientObject.objectComponents[syncMessage.index];
syncComponent.syncedPosition = new Vector3(syncMessage.posX, syncMessage.posY, syncMessage.posZ);
break;
}
case QTMessage.type.SYNC_ROTATION: {
SyncRotationMessage syncMessage = (SyncRotationMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(syncMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[syncMessage.objectID];
SyncGameobject syncComponent = (SyncGameobject)clientObject.objectComponents[syncMessage.index];
syncComponent.syncedRotation = new Vector3(syncMessage.rotX, syncMessage.rotY, syncMessage.rotZ);
break;
}
case QTMessage.type.SYNC_ACTIVE: {
SyncActiveMessage syncMessage = (SyncActiveMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(syncMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[syncMessage.objectID];
SyncGameobject syncComponent = (SyncGameobject)clientObject.objectComponents[syncMessage.index];
syncComponent.gameObject.SetActive(syncMessage.value);
break;
}
case QTMessage.type.SYNC_FIELD: {
FieldInfoMessage syncMessage = (FieldInfoMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(syncMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[syncMessage.objectID];
BaseQTObjectComponent component = clientObject.objectComponents[syncMessage.index];
component.clientComponent.setSyncedField(syncMessage.fieldName, QTUtils.getValueFromSyncFieldMessage(syncMessage));
break;
}
case QTMessage.type.SYNC_ANIMATION: {
AnimationParameterInfoMessage syncMessage = (AnimationParameterInfoMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(syncMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[syncMessage.objectID];
SyncAnimation component = (SyncAnimation)clientObject.objectComponents[syncMessage.index];
QTUtils.applySyncAnimationMessageToAnimator(component.animator, syncMessage);
break;
}
case QTMessage.type.CALL_FUNCTION: {
try {
CallFunctionMessage callMessage = (CallFunctionMessage)message;
if (ClientManager.instance.spawnManager.spawnedObjects.ContainsKey(callMessage.objectID) == false)
{
return;
}
ClientQTObject clientObject = (ClientQTObject)ClientManager.instance.spawnManager.spawnedObjects[callMessage.objectID];
BaseQTObjectComponent component = clientObject.objectComponents[callMessage.index];
List <object> parameters = new List <object>();
if (callMessage.parameters != null)
{
foreach (FieldInfoMessage fieldMessage in callMessage.parameters)
{
parameters.Add(QTUtils.getValueFromSyncFieldMessage(fieldMessage));
}
}
component.callFunction(callMessage.functionName, parameters.ToArray());
} catch (Exception e) {
Debug.LogError(e);
}
break;
}
}
}
