///// <summary>
        ///// Gets the center of mass of an array of Rigidbodies.
        ///// </summary>
        //public static Vector3 GetCenterOfMass(Rigidbody[] rigidbodies) {
        //	Vector3 CoM = Vector3.zero;
        //	float c = 0f;

        //	for (int i = 0; i < rigidbodies.Length; i++) {
        //		if (rigidbodies[i].gameObject.activeInHierarchy) {
        //			CoM += rigidbodies[i].worldCenterOfMass * rigidbodies[i].mass;

        //			c += rigidbodies[i].mass;
        //		}
        //	}

        //	return CoM / c;
        //}

        ///// <summary>
        ///// Gets the velocity of the center of mass of an array of Rigidbodies.
        ///// </summary>
        //public static Vector3 GetCenterOfMassVelocity(Rigidbody[] rigidbodies) {
        //	Vector3 CoM = Vector3.zero;
        //	float c = 0f;

        //	for (int i = 0; i < rigidbodies.Length; i++) {
        //		if (rigidbodies[i].gameObject.activeInHierarchy) {
        //			CoM += rigidbodies[i].velocity * rigidbodies[i].mass;

        //			c += rigidbodies[i].mass;
        //		}
        //	}

        //	return CoM / c;
        //}

        ///// <summary>
        ///// Divides an angular acceleration by an inertia tensor.
        ///// </summary>
        //public static void DivByInertia(ref Vector3 v, Quaternion rotation, Vector3 inertiaTensor) {
        //	v = rotation * Div(Quaternion.Inverse(rotation) * v, inertiaTensor);
        //}

        ///// <summary>
        ///// Scales an angular acceleration by an inertia tensor
        ///// </summary>
        //public static void ScaleByInertia(ref Vector3 v, Quaternion rotation, Vector3 inertiaTensor) {
        //	v = rotation * Vector3.Scale(Quaternion.Inverse(rotation) * v, inertiaTensor);
        //}

        ///// <summary>
        ///// Returns the angular acceleration from one vector to another.
        ///// </summary>
        //public static Vector3 GetFromToAcceleration(Vector3 fromV, Vector3 toV) {
        //	Quaternion fromTo = Quaternion.FromToRotation(fromV, toV);
        //	float requiredAccelerationDeg = 0f;
        //	Vector3 axis = Vector3.zero;
        //	fromTo.ToAngleAxis(out requiredAccelerationDeg, out axis);

        //	Vector3 requiredAcceleration = requiredAccelerationDeg * axis * Mathf.Deg2Rad;

        //	return requiredAcceleration / Time.fixedDeltaTime;
        //}

        ///// <summary>
        ///// Returns the angular acceleration from the current rigidbody rotation to Quaternion.identity.
        ///// Does not guarantee full accuracy with rotations around multiple axes).
        ///// </summary>
        //public static Vector3 GetAngularAcceleration(Quaternion fromR, Quaternion toR) {
        //	Vector3 axis = Vector3.Cross(fromR * Vector3.forward, toR * Vector3.forward);
        //	Vector3 axis2 = Vector3.Cross(fromR * Vector3.up, toR * Vector3.up);
        //	float angle = Quaternion.Angle(fromR, toR);
        //	Vector3 acc = Vector3.Normalize(axis + axis2) * angle * Mathf.Deg2Rad;

        //	return acc / Time.fixedDeltaTime;
        //}

        ///// <summary>
        ///// Returns the linear acceleration from one point to another.
        ///// </summary>
        //public static Vector3 GetLinearAcceleration(Vector3 fromPoint, Vector3 toPoint) {
        //	return (toPoint - fromPoint) / Time.fixedDeltaTime;
        //}


        //      /// <summary>
        //      /// The rotation expressed by the joint's axis and secondary axis
        //      /// </summary>
        //      public static Quaternion ToJointSpace(ConfigurableJoint joint) {
        //	Vector3 forward = Vector3.Cross (joint.axis, joint.secondaryAxis);
        //	Vector3 up = Vector3.Cross (forward, joint.axis);
        //	return Quaternion.LookRotation (forward, up);
        //}

        ///// <summary>
        ///// Calculates the inertia tensor for a cuboid.
        ///// </summary>
        //public static Vector3 CalculateInertiaTensorCuboid(Vector3 size, float mass) {
        //	float x2 = Mathf.Pow(size.x, 2);
        //	float y2 = Mathf.Pow(size.y, 2);
        //	float z2 = Mathf.Pow(size.z, 2);

        //	float mlp = 1f/12f * mass;

        //	return new Vector3(
        //		mlp * (y2 + z2),
        //		mlp * (x2 + z2),
        //		mlp * (x2 + y2));
        //}

        ///// <summary>
        ///// Divide all the values in v by the respective values in v2.
        ///// </summary>
        //public static Vector3 Div(Vector3 v, Vector3 v2) {
        //	return new Vector3(v.x / v2.x, v.y / v2.y, v.z / v2.z);
        //}



        /// <summary>
        /// align to vector
        /// </summary>
        /// <param name="r"></param>
        /// <param name="alignmentVector"></param>
        /// <param name="targetVector"></param>
        /// <param name="stability"></param>
        /// <param name="speed"></param>
        public static void AlignToVector(TSRigidBody r, TSVector alignmentVector, TSVector targetVector, FP stability, FP speed, bool debug = false)
        {
            if (r == null)
            {
                return;
            }

            // 围绕着某个轴进行了一个角度的旋转 angleAxis(x,y). x = 角度 y = 轴
            // x 角度值为 当前转向速度 * Stability 是一个 radian 值, * 57.29 转为角度值, 除以 speed 后 才是真正的角度值
            // part.angularVelocity 是当前旋转速度, 把旋转速度变为轴?
            Quaternion angleAxis = Quaternion.AngleAxis(r.angularVelocity.magnitude.AsFloat() * 57.29578f * stability.AsFloat() / speed.AsFloat(), r.angularVelocity.ToVector());



            // Vector3.Cross 是叉乘, alignmentVector 是当前我们把part 某个轴要对准target Vector 的向量, angleAxis 四元素乘以AlignmentVector 是把alignmentVector 方向调整为四元素方向
            // targetVector 是我们想要对准的角度
            // 叉乘出来的 a 就是 两个向量的九十度角的向量用来作为我们的旋转轴
            Vector3 a = Vector3.Cross(angleAxis * alignmentVector.ToVector(), targetVector.ToVector() * 10f);

            if (!float.IsNaN(a.x) && !float.IsNaN(a.y) && !float.IsNaN(a.z))
            {
                //Debug.Log(a.ToTSVector());

                r.AddTorque(a.ToTSVector() * speed * speed);

                Debug.DrawRay(r.position.ToVector(), alignmentVector.ToVector() * 0.3f, Color.red, 0f, false);
                Debug.DrawRay(r.position.ToVector(), targetVector.ToVector() * 0.3f, Color.green, 0f, false);
            }
        }
    /**
     * @brief Instantiates a new prefab in a deterministic way.
     *
     * @param prefab GameObject's prefab to instantiate.
     * @param position Position to place the new GameObject.
     * @param rotation Rotation to set in the new GameObject.
     **/
    public static GameObject SyncedInstantiate(GameObject prefab, TSVector position, TSQuaternion rotation)
    {
        GameObject go = GameObject.Instantiate(prefab, position.ToVector(), rotation.ToQuaternion()) as GameObject;

        InitializeGameObject(go, position, rotation);
        return(go);
    }
示例#3
0
        public override void OnSyncedUpdate()
        {
            //FP x = TrueSyncInput.GetFP(HORIZONTAL);
            //FP z = TrueSyncInput.GetFP(VERTICAL);
            //if (x!=0||z!=0)
            //{
            //    animator.SetInteger("JSController", 1);
            //    if (x!=0)
            //    {
            //        tsRigidBody.velocity = new TSVector(x, tsTransform.position.y, tsTransform.position.z);
            //    }
            //    if (z != 0)
            //    {
            //        tsRigidBody.velocity = new TSVector(tsTransform.position.x, tsTransform.position.y, z);
            //    }

            //}
            //else
            //{
            //    animator.SetInteger("JSController", 0);
            //}
            TSVector screenPos         = Camera.main.WorldToScreenPoint(tsTransform.position.ToVector()).ToTSVector();
            TSVector mouseScreenPos    = Input.mousePosition.ToTSVector();
            TSVector mouseScreenVector = new TSVector(mouseScreenPos.x, mouseScreenPos.y, screenPos.z);

            mouseInputWordPos    = Camera.main.ScreenToWorldPoint(mouseScreenVector.ToVector()).ToTSVector();
            tsTransform.position = new TSVector(mouseInputWordPos.x, 0.74, mouseInputWordPos.z);
        }
示例#4
0
    public override void OnSyncedUpdate()
    {
        TSVector screenPos         = Camera.main.WorldToScreenPoint(tsTransform.position.ToVector()).ToTSVector();
        TSVector mouseScreenPos    = Input.mousePosition.ToTSVector();
        TSVector mouseScreenVector = new TSVector(mouseScreenPos.x, mouseScreenPos.y, screenPos.z);

        mouseInputWordPos    = Camera.main.ScreenToWorldPoint(mouseScreenVector.ToVector()).ToTSVector();
        tsTransform.position = new TSVector(mouseInputWordPos.x, 0.74, mouseInputWordPos.z);
    }
示例#5
0
    /// <summary>
    /// OnTapLocation - call this to handle distributing and processing taps across a synchronized network game session
    /// Responds to taps and decides what to do
    /// </summary>
    /// <param name="tapLocation">location where tap/click took place</param>
    private void OnTapLocation(TSVector tapLocation)
    {
        // Handle powerup taps
        GameObject tlsc = TrueSyncManager.SyncedInstantiate(Resources.Load("Prefabs/TapLocationSphereCheck") as GameObject, tapLocation, TSQuaternion.identity);

        tlsc.GetComponent <TapLocationSphereCheck>().Owner = localOwner;

        // Find any status effect that may have been tapped
        FP           shortestDistance = 1000;
        StatusEffect nearestSe        = null;

        foreach (StatusEffect se in StatusEffectSystem.spawnedStatusEffects)
        {
            FP dist = TSVector.Distance(se.tsTransform.position, tapLocation);
            if (dist <= se.GetComponent <TSSphereCollider>().radius&& dist < shortestDistance)
            {
                shortestDistance = dist;
                nearestSe        = se;
            }
        }
        if (nearestSe != null) // Found a status effect to handle
        {
            return;            // exit this method to handle status effect within its own framework
        }
        // Shows where click took place (position marker):
        GameObject positionMarker = TrueSyncManager.SyncedInstantiate(PositionMarkerGO, tapLocation, TSQuaternion.identity);

        positionMarker.transform.position = tapLocation.ToVector();
        positionMarker.name = "Position Marker";    // Identify this marker game object in unity editor

        TSTransform tst = positionMarker.GetComponent <TSTransform>();

        tst.scale = TSVector.one * PlayerConfig.Instance.MinTapDistance;
        Renderer rend = positionMarker.GetComponent <Renderer>();

        if (TSVector.Distance(lastValidTapLocation, tapLocation) >= PlayerConfig.Instance.MinTapDistanceFromPrevious)
        {
            TapNearLine(tapLocation);
            rend.material.color = Color.black;
        }
        else
        {
            rend.material.color = Color.red;
        }

        DOTween.ToAlpha(() => rend.material.color, x => rend.material.color = x, 0, 5f).OnComplete(() =>
        {
            TrueSyncManager.Destroy(positionMarker);
        });

        lastValidTapLocation = tapLocation;
    }