コード例 #1
0
        bool CalculateVelocityWater(ref Vector3 velocity)
        {
            if (velocity.sqrMagnitude > 0.01f * 0.01f)
            {
                float   maxSpeed = m_MotionMove.motor.maxForwardSpeed;
                Vector3 pos      = m_Trans.trans.TransformPoint(m_Trans.bound.center) - Vector3.up * m_Trans.bound.extents.y;
                Vector3 v        = pos + Vector3.up * (m_Trans.bound.size.y + 0.5f) + Vector3.up * Time.deltaTime * maxSpeed * 5;
                if (!PEUtil.CheckPositionUnderWater(v))
                {
                    if (velocity.y > PETools.PEMath.Epsilon)
                    {
                        velocity.y = 0.0f;
                    }

                    Vector3 movement = new Vector3(velocity.x, 0.0f, velocity.z);
                    if (movement.sqrMagnitude > 0.01f * 0.01f)
                    {
                        Vector3 dir      = movement.normalized * maxSpeed * Time.deltaTime * 5.0f;
                        float   distance = Mathf.Max(m_Trans.bound.extents.x, m_Trans.bound.extents.z) + dir.magnitude + 1.0f;
                        if (Physics.Raycast(pos, dir, distance, GameConfig.GroundLayer))
                        {
                            return(false);
                        }
                    }
                }
            }

            return(true);
        }
コード例 #2
0
        Vector3 GetFixedPosition(Vector3 pos1, Vector3 direction1, Vector3 pos2, Vector3 direction2, float height)
        {
            Vector3 pos         = pos1;
            Vector3 newPosition = PEUtil.GetRandomPosition(pos1 + m_Data.Anchor, direction1, m_Data.firRadius, m_Data.sndRadius - 0.5f, -90.0f, 90.0f);

            if (PEUtil.CheckPositionNearCliff(newPosition))
            {
                pos         = pos2;
                newPosition = PEUtil.GetRandomPosition(pos2 + m_Data.Anchor, direction2, m_Data.firRadius, m_Data.sndRadius - 0.5f, -90.0f, 90.0f);
            }

            RaycastHit hitInfo;
            Ray        ray = new Ray(pos, Vector3.up);

            //Target in the hole
            if (Physics.Raycast(ray, out hitInfo, 128.0f, PEConfig.GroundedLayer))
            {
                ray = new Ray(newPosition, Vector3.up);
                if (Physics.Raycast(ray, out hitInfo, 128.0f, PEConfig.GroundedLayer))
                {
                    //hole in water
                    if (PEUtil.CheckPositionUnderWater(hitInfo.point - Vector3.up))
                    {
                        return(newPosition);
                    }
                    else
                    {
                        ray = new Ray(newPosition, Vector3.down);
                        if (Physics.Raycast(ray, out hitInfo, 128.0f, PEConfig.GroundedLayer))
                        {
                            return(hitInfo.point + Vector3.up);
                        }
                    }
                }
                else
                {
                    return(Vector3.zero);
                }
            }
            else
            {
                //Target not in the hole
                Ray rayStart = new Ray(newPosition + 128.0f * Vector3.up, -Vector3.up);
                if (Physics.Raycast(rayStart, out hitInfo, 256.0f, PEConfig.GroundedLayer))
                {
                    if (PEUtil.CheckPositionUnderWater(hitInfo.point))
                    {
                        return(newPosition);
                    }
                    else
                    {
                        return(hitInfo.point + Vector3.up);
                    }
                }
            }
            return(Vector3.zero);
        }
コード例 #3
0
        Vector3 GetRetreatPos(Vector3 TargetPos, Transform selfTrans, float minr, float maxr)
        {
            Vector3 selfPos = selfTrans.position;
            Vector3 dir     = (selfPos - TargetPos).normalized;
            Vector3 retreat = PEUtil.GetRandomPosition(selfTrans.position, dir, minr, maxr, -90.0f, 90.0f);

            if (PEUtil.CheckPositionUnderWater(retreat) || PEUtil.CheckPositionInSky(retreat))
            {
                dir     = Random.value > 0.5 ? selfTrans.right : -selfTrans.right;
                retreat = selfPos + dir * 20.0f;
            }

//			Vector3 newpos;
//			if(AiUtil.GetNearNodePosWalkable(retreat,out newpos))
//			{
//				return newpos;
//			}
            return(retreat);
        }
コード例 #4
0
        bool CalculateVelocityLand(ref Vector3 velocity)
        {
            Vector3 v = new Vector3(velocity.x, 0.0f, velocity.z);

            if (v.sqrMagnitude > 0.01f * 0.01f)
            {
                Vector3 vv = v.normalized * Time.deltaTime * m_MotionMove.motor.maxForwardSpeed * 5.0f;

                Vector3 vff = m_Trans.forwardBottom;
                Vector3 vfc = m_Trans.forwardCenter;

                Vector3 nvff = vff + vv;
                Vector3 nvfc = vfc + vv;

                Vector3 vg;
                if (!PEUtil.CheckPositionOnGround(nvff, out vg, 5.0f, 5.0f, GameConfig.GroundLayer))
                {
                    return(false);
                }
                else
                {
                    if (PEUtil.CheckPositionUnderWater(nvfc))
                    {
                        if (!RandomDungenMgrData.InDungeon)
                        {
                            if (PEUtil.CheckPositionOnGround(nvfc + v.normalized * 32.0f, out vg, 128.0f, 128.0f, GameConfig.GroundLayer))
                            {
                                if (PEUtil.CheckPositionUnderWater(vg))
                                {
                                    return(false);
                                }
                            }
                        }
                        else
                        {
                            return(false);
                        }
                    }
                }
            }

            return(true);
        }
コード例 #5
0
    bool CalculateVelocityWater(ref Vector3 velocity)
    {
        if (m_Entity != null && m_Entity.peTrans != null && velocity.sqrMagnitude > 0.01f * 0.01f)
        {
            float   maxSpeed = m_Motor.maxForwardSpeed;
            Vector3 pos      = m_Entity.peTrans.trans.TransformPoint(m_Entity.peTrans.bound.center) - Vector3.up * m_Entity.peTrans.bound.extents.y;
            Vector3 top      = pos + Vector3.up * (m_Entity.peTrans.bound.size.y + 0.5f);
            Vector3 vel      = Vector3.up * Time.deltaTime * maxSpeed * 5;
            if (!PEUtil.CheckPositionUnderWater(top + vel))
            {
                if (velocity.y > PETools.PEMath.Epsilon)
                {
                    velocity.y = 0.0f;
                }

                if (m_Rigidbody.velocity.y > PETools.PEMath.Epsilon)
                {
                    velocity.y = -m_Rigidbody.velocity.y;
                }

                float height = VFVoxelWater.self.DownToWaterSurface(top.x, top.y, top.z);
                if (height > PETools.PEMath.Epsilon)
                {
                    velocity -= Vector3.up * Mathf.Clamp01(height);
                }

                Vector3 movement = new Vector3(velocity.x, 0.0f, velocity.z);
                if (movement.sqrMagnitude > 0.01f * 0.01f)
                {
                    Vector3 dir      = movement.normalized * maxSpeed * Time.deltaTime * 5.0f;
                    float   distance = Mathf.Max(m_Entity.peTrans.bound.extents.x, m_Entity.peTrans.bound.extents.z) + dir.magnitude + 1.0f;
                    if (Physics.Raycast(pos, dir, distance, GameConfig.GroundLayer))
                    {
                        return(false);
                    }
                }
            }
        }

        return(true);
    }