public void onSyncedFieldChanged(string fieldName, object fieldValue)
    {
        if (fieldValue == null)
        {
            QTDebugger.instance.debugWarning(QTDebugger.debugType.NETWORK, "Setting to null -> " + fieldName);
            return;
        }

        FieldInfoMessage message = QTUtils.getSyncFieldMessage(fieldName, fieldValue);

        message.objectID = component.obj.objectID;
        message.index    = component.index;
        WorkerServerManager.instance.sendMessageToAll(message);

        QTDebugger.instance.debug(QTDebugger.debugType.NETWORK, "Sending sync of value(" + fieldName + "=" + fieldValue + ")");
    }
    public void callNetworkFunction(string functionName, object[] parameters)
    {
        component.callFunction(functionName, parameters);

        List <FieldInfoMessage> parameterMessages = new List <FieldInfoMessage>();

        foreach (object parameter in parameters)
        {
            FieldInfoMessage fieldMessage = QTUtils.getSyncFieldMessage("parameter", parameter);
            parameterMessages.Add(fieldMessage);
        }

        CallFunctionMessage message = new CallFunctionMessage();

        message.objectID     = component.obj.objectID;
        message.index        = component.index;
        message.functionName = functionName;
        message.parameters   = parameterMessages.ToArray();
        WorkerServerManager.instance.sendMessageToAll(message);
    }
Beispiel #3
0
    public static FieldInfoMessage getSyncFieldMessage(string fieldName, object fieldValue)
    {
        FieldInfoMessage message = new FieldInfoMessage();

        if (fieldValue.GetType() == typeof(int))
        {
            message = new FieldInfoIntMessage();
            ((FieldInfoIntMessage)message).value = (int)fieldValue;
            message.syncedValueType = FieldInfoMessage.syncType.INT;
        }
        else if (fieldValue.GetType() == typeof(float))
        {
            message = new FieldInfoFloatMessage();
            ((FieldInfoFloatMessage)message).value = (float)fieldValue;
            message.syncedValueType = FieldInfoMessage.syncType.FLOAT;
        }
        else if (fieldValue.GetType() == typeof(bool))
        {
            message = new FieldInfoBoolMessage();
            ((FieldInfoBoolMessage)message).value = (bool)fieldValue;
            message.syncedValueType = FieldInfoMessage.syncType.BOOL;
        }
        else if (fieldValue.GetType() == typeof(string))
        {
            message = new FieldInfoStringMessage();
            ((FieldInfoStringMessage)message).value = (string)fieldValue;
            message.syncedValueType = FieldInfoMessage.syncType.STRING;
        }
        else if (fieldValue.GetType().IsArray)
        {
            message = new FieldInfoArrayMessage();

            List <FieldInfoMessage> messages           = new List <FieldInfoMessage>();
            IEnumerable             originalEnumerable = fieldValue as IEnumerable;
            object[] originalArray = originalEnumerable.OfType <object>().ToArray();

            for (int i = 0; i < originalArray.Length; i++)
            {
                messages.Add(getSyncFieldMessage(i.ToString(), originalArray[i]));
            }

            ((FieldInfoArrayMessage)message).value = messages.ToArray();
            message.syncedValueType = FieldInfoArrayMessage.syncType.ARRAY;
        }
        else if (typeof(IDictionary).IsAssignableFrom(fieldValue.GetType()))
        {
            message = new FieldInfoDictionaryMessage();

            Dictionary <FieldInfoMessage, FieldInfoMessage> messages = new Dictionary <FieldInfoMessage, FieldInfoMessage>();
            IDictionary originalDictionary = fieldValue as IDictionary;

            int i = 0;
            foreach (object key in originalDictionary.Keys)
            {
                messages.Add(getSyncFieldMessage(i + "-0", key), getSyncFieldMessage(i + "-1", originalDictionary[key]));
                i++;
            }

            ((FieldInfoDictionaryMessage)message).value = messages;
            message.syncedValueType = FieldInfoDictionaryMessage.syncType.DICTIONARY;
        }
        else
        {
            QTDebugger.instance.debugWarning(QTDebugger.debugType.NETWORK, "Unknown synced type -> " + fieldName + " of " + fieldValue.GetType().Name);
            return(null);
        }

        message.fieldName = fieldName;
        return(message);
    }
Beispiel #4
0
    public static object getValueFromSyncFieldMessage(FieldInfoMessage message)
    {
        switch (message.syncedValueType)
        {
        case FieldInfoMessage.syncType.INT: {
            FieldInfoIntMessage syncMessageDetailed = (FieldInfoIntMessage)message;
            return(syncMessageDetailed.value);
        }

        case FieldInfoMessage.syncType.FLOAT: {
            FieldInfoFloatMessage syncMessageDetailed = (FieldInfoFloatMessage)message;
            return(syncMessageDetailed.value);
        }

        case FieldInfoMessage.syncType.BOOL: {
            FieldInfoBoolMessage syncMessageDetailed = (FieldInfoBoolMessage)message;
            return(syncMessageDetailed.value);
        }

        case FieldInfoMessage.syncType.STRING: {
            FieldInfoStringMessage syncMessageDetailed = (FieldInfoStringMessage)message;
            return(syncMessageDetailed.value);
        }

        case FieldInfoMessage.syncType.ARRAY: {
            FieldInfoArrayMessage syncMessageDetailed = (FieldInfoArrayMessage)message;

            List <object> values = new List <object>();
            if (syncMessageDetailed.value == null)
            {
                return(values);
            }
            for (int i = 0; i < syncMessageDetailed.value.Length; i++)
            {
                values.Add(getValueFromSyncFieldMessage(syncMessageDetailed.value[i]));
            }

            return(values.ToArray());
        }

        case FieldInfoMessage.syncType.DICTIONARY: {
            FieldInfoDictionaryMessage syncMessageDetailed = (FieldInfoDictionaryMessage)message;

            Dictionary <object, object> values = new Dictionary <object, object>();
            if (syncMessageDetailed.value == null)
            {
                return(values);
            }
            foreach (FieldInfoMessage key in syncMessageDetailed.value.Keys)
            {
                values.Add(getValueFromSyncFieldMessage(key), getValueFromSyncFieldMessage(syncMessageDetailed.value[key]));
            }

            return(values);
        }

        default: {
            return(null);
        }
        }
    }
Beispiel #5
0
    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;
        }
        }
    }