Esempio n. 1
0
    //private void FixedUpdate()
    //{

    //}

    private void Fire()
    {
        Vector3 firePosition  = m_cameraFOV.transform.position;
        Vector3 fireDirection = m_cameraFOV.transform.forward;

        // Do server side hit detection only when there is a hit on client side. Just to save some server performance
        bool shouldVerifyHitOnServer = true;

        if (IVGameManager.Instance.m_useHitScan)
        {
            shouldVerifyHitOnServer = FireHitScan(firePosition, fireDirection);
        }
        else
        {
            shouldVerifyHitOnServer = InstantiateBullet(firePosition, fireDirection); // Instantiate bullet immediately on the client who is firing
        }
        using (PooledBitStream stream = PooledBitStream.Get())
        {
            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
            {
                writer.WriteBool(shouldVerifyHitOnServer);
                writer.WriteVector3Packed(firePosition);
                writer.WriteVector3Packed(fireDirection);

                InvokeServerRpcPerformance(FireOnServer, stream);
            }
        }
    }
Esempio n. 2
0
        void InvokeApplyTransform(ulong clientId, Vector3 position, Quaternion rotation, string channelName)
        {
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    if (TransformTypeToSync == TransformType.Transform2D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector2Packed(position);
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector2Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }

                        InvokeClientRpcOnClientPerformance("ApplyTransform2D", clientId, stream, channelName, Security.SecuritySendFlags.None);
                    }
                    else if (TransformTypeToSync == TransformType.Transform3D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector3Packed(position);
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSingle(rotation.eulerAngles.y);
                            }
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector3Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSingle(rotation.eulerAngles.y);
                            }
                        }

                        InvokeClientRpcOnClientPerformance("ApplyTransform", clientId, stream, channelName, Security.SecuritySendFlags.None);
                    }
                }
            }
        }
Esempio n. 3
0
    public void Write(Stream stream)
    {
        using (PooledBitWriter writer = PooledBitWriter.Get(stream))
        {
            writer.WriteInt32Packed(TeamID);

            writer.WriteBool(isRightHanded);
            writer.WriteBool(isMoving);
            writer.WriteBool(isSprinting);
            writer.WriteBool(isDribbling);
            writer.WriteBool(isScreening);
            writer.WriteBool(isHardScreening);
            writer.WriteBool(isShooting);
            writer.WriteBool(isHelping);

            writer.WriteBool(isMovementFrozen);
            writer.WriteBool(isBallInLeftHand);
            writer.WriteBool(isCtrlDown);
            writer.WriteBool(isAltDown);
            writer.WriteBool(isDribUp);
            writer.WriteBool(isDribDown);
            writer.WriteBool(isDribLeft);
            writer.WriteBool(isDribRight);

            writer.WriteBool(isAI);

            writer.WriteVector3Packed(m_target);
        }
    }
Esempio n. 4
0
    void FireOnServer(ulong clientId, Stream stream)
    {
        using (PooledBitReader reader = PooledBitReader.Get(stream))
        {
            bool    shouldDoHitDetection = reader.ReadBool();
            Vector3 shootPos             = reader.ReadVector3Packed();
            Vector3 shootDirection       = reader.ReadVector3Packed();

            // Call fire rpc on other clients to instantiate the bullet
            using (PooledBitWriter writer = PooledBitWriter.Get(stream))
            {
                writer.WriteVector3Packed(shootPos);
                writer.WriteVector3Packed(shootDirection);

                InvokeClientRpcOnEveryoneExceptPerformance(FireOnClient, clientId, stream);
            }

            if (shouldDoHitDetection)
            {
                PerformShootRaycast(0f, shootPos, shootDirection);
            }
        }
    }
Esempio n. 5
0
        void InvokeApplyTransformOnEveryone(Vector3 position, Quaternion rotation, string channelName)
        {
            using (PooledBitStream stream = PooledBitStream.Get())
            {
                using (PooledBitWriter writer = PooledBitWriter.Get(stream))
                {
                    if (TransformTypeToSync == TransformType.Transform2D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector2Packed(position);
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector2Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            writer.WriteSinglePacked(rotation.eulerAngles.z);
                        }
                    }
                    else if (TransformTypeToSync == TransformType.Transform3D)
                    {
                        if (SyncPosition && SyncRotation)
                        {
                            writer.WriteVector3Packed(position);
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSinglePacked(rotation.eulerAngles.y);
                            }
                        }
                        else if (SyncPosition)
                        {
                            writer.WriteVector3Packed(position);
                        }
                        else if (SyncRotation)
                        {
                            if (FullRotation)
                            {
                                writer.WriteVector3Packed(rotation.eulerAngles);
                            }
                            else
                            {
                                writer.WriteSinglePacked(rotation.eulerAngles.y);
                            }
                        }
                    }

                    if (EnableMinDistanceBetweenClients)
                    {
                        Vector3?senderPosition = transform.position;

                        for (int i = 0; i < NetworkingManager.Singleton.ConnectedClientsList.Count; i++)
                        {
                            Vector3?receiverPosition = NetworkingManager.Singleton.ConnectedClientsList[i].PlayerObject == null ? null : new Vector3?(NetworkingManager.Singleton.ConnectedClientsList[i].PlayerObject.transform.position);
                            if (receiverPosition == null || senderPosition == null || Vector3.Distance((Vector3)senderPosition, (Vector3)receiverPosition) < MinDistanceBetweenClients)
                            {
                                InvokeClientRpcOnClientPerformance(TransformTypeToSync == TransformType.Transform2D ? "ApplyTransform2D" : "ApplyTransform", NetworkingManager.Singleton.ConnectedClientsList[i].ClientId, stream, channelName, Security.SecuritySendFlags.None);
                            }
                        }
                    }
                    else
                    {
                        InvokeClientRpcOnEveryonePerformance(TransformTypeToSync == TransformType.Transform2D ? "ApplyTransform2D" : "ApplyTransform", stream, channelName, Security.SecuritySendFlags.None);
                    }
                }
            }
        }