Example #1
0
    public static void receiveObject(byte[] data, out IdentityAndTransform iat)
    {
        ByteReceiver br          = new ByteReceiver(data);
        var          objectID    = br.getInt();
        int          authorityID = br.getInt();
        var          type        = (ObjectType)br.getInt();
        var          prefabIndex = br.getInt();
        var          pos         = br.getVector3();
        var          rot         = br.getQuaternion();

        iat = NetTransportManager.instance.spawnObjectSync(prefabIndex, authorityID, pos, rot, objectID);
        switch (type)
        {
        case ObjectType.Planet:
            var mass   = br.getFloat();
            var linVel = br.getVector3();
            var angVel = br.getVector3();
            var seed   = br.getInt();
            var radius = br.getFloat();
            UniverseManager.instance.syncPlanet(iat, mass, linVel, angVel, seed, radius);
            break;

        case ObjectType.Rigidbody:
            var massR   = br.getFloat();
            var linVelR = br.getVector3();
            var angVelR = br.getVector3();
            makeRigidBody(iat.instance, massR, linVelR, angVelR);
            break;
        }
    }
    public IdentityAndTransform spawnObject(int prefabIndex, int authorityID, Vector3 pos, Quaternion rot)
    {
        if (!server)
        {
            return(null);
        }

//		GameObject rootObj = GameObject.FindGameObjectWithTag ("root");
        var instance = GameObject.Instantiate(spawnableObjects [prefabIndex], pos, rot);

        UniverseCenter.instance.allOthers.Add(instance.transform);
//		if (rootObj != null)
//			instance.transform.parent = rootObj.transform;

        var iat = new IdentityAndTransform(instance, prefabIndex, generateID(), authorityID, false);

        IDAndTransforms.Add(iat);
        coroutines.Add(StartCoroutine(syncCoroutine(iat)));

        foreach (GameObject gO in GeneralHelp.getAllChildren(instance.transform))
        {
            var netIdent = gO.GetComponent <NetIdentityCustom> ();
            if (netIdent != null)
            {
                IDAndTransforms.Add(new IdentityAndTransform(gO, prefabIndex, generateID(), authorityID, true));
            }
        }

        return(iat);
    }
    private byte[] getSpawnBytes(IdentityAndTransform iat)       // list index means index in the IDAndTransforms list, and conn
    {
        ByteConstructor bc = new ByteConstructor();

        bc.addLevels(new int[] { (int)DataType.Sync, (int)SyncType.Spawning });
        bc.add(NetObjBytes.defaultInfo(iat.netIdentity.objID, iat.netIdentity.AuthorityID, (int)iat.type, iat.prefabIndex, iat.netTrans.trans.position, iat.netTrans.trans.rotation));
        switch (iat.type)
        {
        case NetObjBytes.ObjectType.Planet:
            var pg3 = iat.netIdentity.GetComponent <PlanetGenerator3> ();

            if (pg3 != null)
            {
                var rb = iat.netIdentity.GetComponent <ConstraintTrans> ().otherTrans.GetComponent <Rigidbody> ();
                bc.add(NetObjBytes.planetSpawn(rb.mass, rb.velocity, rb.angularVelocity, pg3.seed, pg3.radius));
            }
            else
            {
                var rb = iat.netIdentity.GetComponent <Rigidbody> ();
                bc.add(NetObjBytes.planetSpawn(rb.mass, rb.velocity, rb.angularVelocity, 0, 0));
            }
            break;

        case NetObjBytes.ObjectType.Rigidbody:
            var rb1 = iat.netIdentity.GetComponent <ConstraintTrans> ().otherTrans.GetComponent <Rigidbody> ();
            bc.add(NetObjBytes.rigidbodySpawn(rb1.mass, rb1.velocity, rb1.angularVelocity));
            break;
        }

        return(bc.getBytes());
    }
    private IEnumerator syncCoroutine(IdentityAndTransform iat)
    {
        yield return(null);

        WaitForSeconds w4s = new WaitForSeconds(4f);

        while (iat != null)
        {
            if (iat.netTrans.sendRate > 0 && iat.netIdentity.HasAuthority && isConnected())
            {
                sendAllAdvanced(transUpdateBytes(iat));
                yield return(new WaitForSeconds(1f / iat.netTrans.sendRate));
            }
            else
            {
                yield return(w4s);
            }
        }
    }
//	private byte[] transUpdateBytes(IdentityAndTransform iat){
//		return transUpdateBytes (iat.netTrans.trans, iat.netTrans.updateType, iat.netIdentity.objID);
//	}
    private byte[] transUpdateBytes(IdentityAndTransform iat)
    {
        ByteConstructor bc = new ByteConstructor();

        bc.addLevels(new int[] { (int)DataType.Sync, (int)SyncType.TransUpdate });

        bc.add(iat.netIdentity.objID);
        bc.add((int)iat.netTrans.updateType);
        switch (iat.netTrans.updateType)
        {
        case TransUpdateType.Transform:
            bc.add(iat.netTrans.getPosition());
            bc.add(iat.netTrans.getRotation());
            bc.add(iat.netTrans.trans.localScale);
            break;

//		case TransUpdateType.Position:
//			bc.add (ByteHelper.vector3Bytes(transform.position));
//			break;
//		case TransUpdateType.Rotation:
//			bc.add (ByteHelper.quaternionBytes(transform.rotation));
//			break;
//		case TransUpdateType.Scale:
//
//			break;
        case TransUpdateType.TransAndRigidbody:
            bc.add(iat.netTrans.getPosition());
            bc.add(iat.netTrans.getRotation());
            bc.add(iat.netTrans.trans.localScale);

            var body = iat.netTrans.trans.GetComponent <Rigidbody> ();
            bc.add(body.velocity);
            bc.add(body.angularVelocity);
            break;

        default:
            break;
        }
        return(bc.getBytes());
    }