Esempio n. 1
0
    private IEnumerator findCloseClimbingWall(Transform getTarget, GraphNode targetNode)
    {
        bool foundValidWall = false;
        int  randVal        = UnityEngine.Random.Range(0, Scene.SceneTracker.climbableStructures.Count);

        for (int i = 0; i < Scene.SceneTracker.climbableStructures.Count; i++)
        {
            if (randVal == Scene.SceneTracker.climbableStructures.Count)
            {
                randVal = 0;
            }
            if (!foundValidWall && getTarget && Scene.SceneTracker.climbableStructures[randVal] != null)
            {
                Vector3 position = getTarget.position;
                position.y = this.thisTr.position.y;
                Vector3 position2 = Scene.SceneTracker.climbableStructures[randVal].transform.position;
                position2.y = this.thisTr.position.y;
                Vector3 vector        = position - position2;
                Vector3 from          = this.thisTr.position - position2;
                Vector3 to            = this.thisTr.position - position;
                float   num           = Vector3.Angle(from, to);
                float   sqrMagnitude  = vector.sqrMagnitude;
                float   sqrMagnitude2 = from.sqrMagnitude;
                float   sqrMagnitude3 = to.sqrMagnitude;
                if (sqrMagnitude < sqrMagnitude3 && sqrMagnitude < 2500f && sqrMagnitude2 > 225f && num < 70f)
                {
                    Vector3 position3 = Scene.SceneTracker.climbableStructures[randVal].transform.position;
                    position3.y = getTarget.position.y;
                    uint         area         = targetNode.Area;
                    NNConstraint nnconstraint = new NNConstraint();
                    nnconstraint.constrainArea = true;
                    int area2 = (int)area;
                    nnconstraint.area = area2;
                    bool      flag = false;
                    GraphNode node = this.rg.GetNearest(position3, nnconstraint).node;
                    if (node != null)
                    {
                        Vector3 b = new Vector3((float)(node.position[0] / 1000), (float)(node.position[1] / 1000), (float)(node.position[2] / 1000));
                        if (Vector3.Distance(position3, b) < 8f)
                        {
                            flag = true;
                        }
                    }
                    climbableWallSetup component = Scene.SceneTracker.climbableStructures[randVal].GetComponent <climbableWallSetup>();
                    if (component && !component.occupied && !component.invalid && flag)
                    {
                        this.setup.pmCombat.FsmVariables.GetFsmGameObject("wallGo").Value = Scene.SceneTracker.climbableStructures[randVal];
                        this.setup.pmCombatScript.wallGo = Scene.SceneTracker.climbableStructures[randVal];
                        this.setup.pmCombat.FsmVariables.GetFsmBool("toClimbWall").Value = true;
                        foundValidWall = true;
                        if (component)
                        {
                            component.occupied = true;
                        }
                    }
                }
            }
            randVal++;
            yield return(null);
        }
        yield return(YieldPresets.WaitTenSeconds);

        this.climbingWallCooDown = false;
        yield break;
    }
Esempio n. 2
0
    public IEnumerator validateClimbingWalls(bool distanceCheck)
    {
        if (BoltNetwork.isClient)
        {
            yield break;
        }
        yield return(YieldPresets.WaitTwoSeconds);

        if (!this.validatingClimbingWalls)
        {
            this.validatingClimbingWalls = true;
            List <GameObject> removeMe = new List <GameObject>();
            bool switchSide            = false;
            for (int i = 0; i < this.climbableStructures.Count; i++)
            {
                if (this.climbableStructures[i])
                {
                    bool flag = true;
                    if (distanceCheck)
                    {
                        flag = ((this.climbableStructures[i].transform.position - LocalPlayer.Transform.position).sqrMagnitude < 2500f);
                    }
                    if (flag)
                    {
                        Vector3 vector = this.climbableStructures[i].transform.position;
                        vector.y = Terrain.activeTerrain.SampleHeight(vector) + Terrain.activeTerrain.transform.position.y;
                        if (switchSide)
                        {
                            vector -= this.climbableStructures[i].transform.right * 5.5f;
                        }
                        else
                        {
                            vector += this.climbableStructures[i].transform.right * 5.5f;
                        }
                        Vector3 runToPosition = vector;
                        vector.y  += 100f;
                        switchSide = !switchSide;
                        RaycastHit raycastHit;
                        if (Physics.SphereCast(vector, 4f, Vector3.down, out raycastHit, 110f, this.climbLayerMask))
                        {
                            removeMe.Add(this.climbableStructures[i].gameObject);
                        }
                        else
                        {
                            climbableWallSetup climbableWallSetup = this.climbableStructures[i].GetComponent <climbableWallSetup>();
                            if (!climbableWallSetup)
                            {
                                climbableWallSetup = this.climbableStructures[i].AddComponent <climbableWallSetup>();
                            }
                            climbableWallSetup.runToPosition = runToPosition;
                            Debug.DrawRay(vector, Vector3.down * 100f, Color.red, 15f);
                        }
                    }
                }
                yield return(null);

                yield return(null);

                yield return(null);
            }
            if (removeMe.Count == 0)
            {
                this.validatingClimbingWalls = false;
                yield break;
            }
            for (int j = 0; j < removeMe.Count; j++)
            {
                if (this.climbableStructures.Contains(removeMe[j]))
                {
                    this.climbableStructures.Remove(removeMe[j]);
                }
            }
            this.validatingClimbingWalls = false;
        }
        yield return(null);

        yield break;
    }