Example #1
0
 public static void RemoveZone(NoPlacementZone zone)
 {
     if (NoPlacementZone._zones.Contains(zone))
     {
         NoPlacementZone._zones.Remove(zone);
     }
 }
Example #2
0
 public static void RemoveZone(NoPlacementZone zone)
 {
     if (_zones.Contains(zone))
     {
         _zones.Remove(zone);
     }
 }
Example #3
0
    public static bool ValidPos(Vector3 pos)
    {
        bool flag;

        List <NoPlacementZone> .Enumerator enumerator = NoPlacementZone._zones.GetEnumerator();
        try
        {
            while (enumerator.MoveNext())
            {
                NoPlacementZone current = enumerator.Current;
                if (Vector3.Distance(pos, current.transform.position) > current.GetRadius())
                {
                    continue;
                }
                flag = false;
                return(flag);
            }
            return(true);
        }
        finally
        {
            ((IDisposable)(object)enumerator).Dispose();
        }
        return(flag);
    }
Example #4
0
 public static void AddZone(NoPlacementZone zone)
 {
     if (_zones == null)
     {
         _zones = new System.Collections.Generic.List <NoPlacementZone>();
     }
     if (!_zones.Contains(zone))
     {
         _zones.Add(zone);
     }
 }
Example #5
0
 public static void AddZone(NoPlacementZone zone)
 {
     if (_zones == null)
     {
         _zones = new List <NoPlacementZone>();
     }
     if (!_zones.Contains(zone))
     {
         _zones.Add(zone);
     }
 }
Example #6
0
 public static void AddZone(NoPlacementZone zone)
 {
     if (NoPlacementZone._zones == null)
     {
         NoPlacementZone._zones = new List <NoPlacementZone>();
     }
     if (NoPlacementZone._zones.Contains(zone))
     {
         return;
     }
     NoPlacementZone._zones.Add(zone);
 }
Example #7
0
 public static void AddZone(NoPlacementZone zone)
 {
     if (NoPlacementZone._zones == null)
     {
         NoPlacementZone._zones = new List<NoPlacementZone>();
     }
     if (NoPlacementZone._zones.Contains(zone))
     {
         return;
     }
     NoPlacementZone._zones.Add(zone);
 }
Example #8
0
 public bool CheckBlockers(Vector3 pos)
 {
     if (this._structureToPlace.type == StructureComponent.StructureComponentType.Foundation)
     {
         foreach (Collider collider in Physics.OverlapSphere(pos, 12f, 0x10360401))
         {
             IDMain main = IDBase.GetMain(collider.gameObject);
             if (main != null)
             {
                 float num2 = TransformHelpers.Dist2D(main.transform.position, pos);
                 if ((main.GetComponent <SpikeWall>() != null) && (num2 < 5f))
                 {
                     return(false);
                 }
             }
         }
     }
     if (!NoPlacementZone.ValidPos(pos))
     {
         return(false);
     }
     return(true);
 }
 public bool CheckBlockers(Vector3 pos)
 {
     if (this._structureToPlace.type == StructureComponent.StructureComponentType.Foundation)
     {
         Collider[] colliderArray = Physics.OverlapSphere(pos, 12f, 271975425);
         for (int i = 0; i < (int)colliderArray.Length; i++)
         {
             IDMain main = IDBase.GetMain(colliderArray[i].gameObject);
             if (main)
             {
                 float single = TransformHelpers.Dist2D(main.transform.position, pos);
                 if (main.GetComponent <SpikeWall>() && single < 5f)
                 {
                     return(false);
                 }
             }
         }
     }
     if (!NoPlacementZone.ValidPos(pos))
     {
         return(false);
     }
     return(true);
 }
    public void CheckPlacementResults(Ray ray, out Vector3 pos, out Quaternion rot, out TransCarrier carrier, out DeployPlaceResults results)
    {
        RaycastHit        hit;
        Vector3           position;
        Vector3           normal;
        bool              flag6;
        MeshBatchInstance instance;
        Quaternion        rotation;
        float             placeRange = this.placeRange;
        IDMain            main       = null;
        bool              flag       = false;
        bool              flag2      = false;
        bool              flag3      = false;
        DeployableObject  obj2       = null;
        bool              flag4      = false;
        bool              flag5      = false;
        bool              flag7      = this.minCastRadius >= float.Epsilon;
        bool              flag8      = !flag7?MeshBatchPhysics.Raycast(ray, out hit, placeRange, -472317957, out flag6, out instance) : MeshBatchPhysics.SphereCast(ray, this.minCastRadius, out hit, placeRange, -472317957, out flag6, out instance);

        Vector3 point = ray.GetPoint(placeRange);

        if (!flag8)
        {
            Vector3 origin = point;
            origin.y += 0.5f;
            flag4     = MeshBatchPhysics.Raycast(origin, Vector3.down, out hit, 5f, -472317957, out flag6, out instance);
        }
        if (flag8 || flag4)
        {
            main = !flag6?IDBase.GetMain(hit.collider) : instance.idMain;

            flag3    = (main is StructureComponent) || (main is StructureMaster);
            position = hit.point;
            normal   = hit.normal;
            flag     = !flag3 && ((bool)(obj2 = main as DeployableObject));
            if (((this.carrierSphereCastMode != CarrierSphereCastMode.Allowed) && flag8) && (flag7 && !NonVariantSphereCast(ray, position)))
            {
                Ray               ray2;
                float             num2;
                RaycastHit        hit2;
                bool              flag9;
                MeshBatchInstance instance2;
                bool              flag10;
                if (this.carrierSphereCastMode == CarrierSphereCastMode.AdjustedRay)
                {
                    Vector3 vector5   = ray.origin;
                    Vector3 direction = hit.point - vector5;
                    num2 = direction.magnitude + (this.minCastRadius * 2f);
                    ray2 = new Ray(vector5, direction);
                    Debug.DrawLine(ray.origin, ray.GetPoint(num2), Color.cyan);
                }
                else
                {
                    num2 = placeRange + this.minCastRadius;
                    ray2 = ray;
                }
                if (!(flag10 = MeshBatchPhysics.Raycast(ray2, out hit2, num2, -472317957, out flag9, out instance2)))
                {
                    Vector3 vector8 = position;
                    vector8.y += 0.5f;
                    flag10     = MeshBatchPhysics.Raycast(vector8, Vector3.down, out hit2, 5f, -472317957, out flag9, out instance2);
                }
                if (flag10)
                {
                    IDMain main2 = !flag9?IDBase.GetMain(hit2.collider) : instance2.idMain;

                    carrier = (main2 == null) ? hit2.collider.GetComponent <TransCarrier>() : main2.GetLocal <TransCarrier>();
                }
                else
                {
                    carrier = null;
                }
            }
            else
            {
                carrier = ((main == null) ? hit.collider.gameObject : main.gameObject).GetComponent <TransCarrier>();
            }
            flag2 = (hit.collider is TerrainCollider) || (hit.collider.gameObject.layer == 10);
            flag5 = true;
        }
        else
        {
            position = point;
            normal   = Vector3.up;
            carrier  = null;
        }
        bool      flag11           = false;
        Hardpoint hardpointFromRay = null;

        if (this.hardpointType != Hardpoint.hardpoint_type.None)
        {
            hardpointFromRay = Hardpoint.GetHardpointFromRay(ray, this.hardpointType);
            if (hardpointFromRay != null)
            {
                flag11   = true;
                position = hardpointFromRay.transform.position;
                normal   = hardpointFromRay.transform.up;
                carrier  = hardpointFromRay.GetMaster().GetTransCarrier();
                flag5    = true;
            }
        }
        bool flag12 = false;

        if (this.spacingRadius > 0f)
        {
            foreach (Collider collider in Physics.OverlapSphere(position, this.spacingRadius))
            {
                GameObject gameObject = collider.gameObject;
                IDBase     component  = collider.gameObject.GetComponent <IDBase>();
                if (component != null)
                {
                    gameObject = component.idMain.gameObject;
                }
                if (gameObject.CompareTag(this.ObjectToPlace.gameObject.tag) && (Vector3.Distance(position, gameObject.transform.position) < this.spacingRadius))
                {
                    flag12 = true;
                    break;
                }
            }
        }
        bool flag13 = false;

        if ((flag && !this.forcePlaceable) && obj2.cantPlaceOn)
        {
            flag13 = true;
        }
        pos = position;
        if (this.orientationMode == DeployableOrientationMode.Default)
        {
            if (this.uprightOnly)
            {
                this.orientationMode = DeployableOrientationMode.Upright;
            }
            else
            {
                this.orientationMode = DeployableOrientationMode.NormalUp;
            }
        }
        switch (this.orientationMode)
        {
        case DeployableOrientationMode.NormalUp:
            rotation = TransformHelpers.LookRotationForcedUp(ray.direction, normal);
            break;

        case DeployableOrientationMode.Upright:
            rotation = TransformHelpers.LookRotationForcedUp(ray.direction, Vector3.up);
            break;

        case DeployableOrientationMode.NormalForward:
            rotation = TransformHelpers.LookRotationForcedUp(Vector3.Cross(ray.direction, Vector3.up), normal);
            break;

        case DeployableOrientationMode.HardpointPosRot:
            if (!flag11)
            {
                rotation = TransformHelpers.LookRotationForcedUp(ray.direction, Vector3.up);
                break;
            }
            rotation = hardpointFromRay.transform.rotation;
            break;

        default:
            throw new NotImplementedException();
        }
        rot = rotation * this.ObjectToPlace.transform.localRotation;
        bool flag14 = false;

        if (this.checkPlacementZones)
        {
            flag14 = NoPlacementZone.ValidPos(pos);
        }
        float num4 = Vector3.Angle(normal, Vector3.up);

        results.falseFromDeployable      = (!this.CanStackOnDeployables && flag) || flag13;
        results.falseFromTerrian         = this.TerrainOnly && !flag2;
        results.falseFromClose           = (this.spacingRadius > 0f) && flag12;
        results.falseFromHardpoint       = this.requireHardpoint && !flag11;
        results.falseFromAngle           = !this.requireHardpoint && (num4 >= this.ObjectToPlace.maxSlope);
        results.falseFromPlacementZone   = this.checkPlacementZones && !flag14;
        results.falseFromHittingNothing  = !flag5;
        results.falseFromStructure       = this.StructureOnly && !flag3;
        results.falseFromFitRequirements = (this.fitRequirements != null) && !this.fitRequirements.Test(pos, !this.fitTestForcedUp ? rot : TransformHelpers.LookRotationForcedUp(rot, Vector3.up), this.ObjectToPlace.transform.localScale);
    }
Example #11
0
 public void OnDestroy()
 {
     NoPlacementZone.RemoveZone(this);
 }
Example #12
0
 public void Awake()
 {
     NoPlacementZone.AddZone(this);
 }
Example #13
0
    public void CheckPlacementResults(Ray ray, out Vector3 pos, out Quaternion rot, out TransCarrier carrier, out DeployableItemDataBlock.DeployPlaceResults results)
    {
        results = new DeployableItemDataBlock.DeployPlaceResults();
        RaycastHit        raycastHit;
        Vector3           vector3;
        Vector3           vector31;
        bool              flag;
        MeshBatchInstance meshBatchInstance;
        Ray               ray1;
        float             single;
        RaycastHit        raycastHit1;
        bool              flag1;
        MeshBatchInstance meshBatchInstance1;
        Quaternion        quaternion;
        bool              flag2;
        float             single1          = this.placeRange;
        IDMain            dMain            = null;
        bool              flag3            = false;
        bool              flag4            = false;
        bool              flag5            = false;
        DeployableObject  deployableObject = null;
        bool              flag6            = false;
        bool              flag7            = false;
        bool              flag8            = this.minCastRadius >= 1.401298E-45f;
        bool              flag9            = (!flag8 ? Facepunch.MeshBatch.MeshBatchPhysics.Raycast(ray, out raycastHit, single1, -472317957, out flag, out meshBatchInstance) : Facepunch.MeshBatch.MeshBatchPhysics.SphereCast(ray, this.minCastRadius, out raycastHit, single1, -472317957, out flag, out meshBatchInstance));
        Vector3           point            = ray.GetPoint(single1);

        if (!flag9)
        {
            Vector3 vector32 = point;
            vector32.y = vector32.y + 0.5f;
            flag6      = Facepunch.MeshBatch.MeshBatchPhysics.Raycast(vector32, Vector3.down, out raycastHit, 5f, -472317957, out flag, out meshBatchInstance);
        }
        if (flag9 || flag6)
        {
            dMain    = (!flag ? IDBase.GetMain(raycastHit.collider) : meshBatchInstance.idMain);
            flag5    = (dMain is StructureComponent ? true : dMain is StructureMaster);
            vector3  = raycastHit.point;
            vector31 = raycastHit.normal;
            if (flag5)
            {
                flag2 = false;
            }
            else
            {
                DeployableObject deployableObject1 = dMain as DeployableObject;
                deployableObject = deployableObject1;
                flag2            = deployableObject1;
            }
            flag3 = flag2;
            if (this.carrierSphereCastMode == DeployableItemDataBlock.CarrierSphereCastMode.Allowed || !flag9 || !flag8 || DeployableItemDataBlock.NonVariantSphereCast(ray, vector3))
            {
                carrier = ((!dMain ? raycastHit.collider.gameObject : dMain.gameObject)).GetComponent <TransCarrier>();
            }
            else
            {
                if (this.carrierSphereCastMode != DeployableItemDataBlock.CarrierSphereCastMode.AdjustedRay)
                {
                    single = single1 + this.minCastRadius;
                    ray1   = ray;
                }
                else
                {
                    Vector3 vector33 = ray.origin;
                    Vector3 vector34 = raycastHit.point - vector33;
                    single = vector34.magnitude + this.minCastRadius * 2f;
                    ray1   = new Ray(vector33, vector34);
                    Debug.DrawLine(ray.origin, ray.GetPoint(single), Color.cyan);
                }
                bool flag10 = Facepunch.MeshBatch.MeshBatchPhysics.Raycast(ray1, out raycastHit1, single, -472317957, out flag1, out meshBatchInstance1);
                bool flag11 = flag10;
                if (!flag10)
                {
                    Vector3 vector35 = vector3;
                    vector35.y = vector35.y + 0.5f;
                    flag11     = Facepunch.MeshBatch.MeshBatchPhysics.Raycast(vector35, Vector3.down, out raycastHit1, 5f, -472317957, out flag1, out meshBatchInstance1);
                }
                if (!flag11)
                {
                    carrier = null;
                }
                else
                {
                    IDMain dMain1 = (!flag1 ? IDBase.GetMain(raycastHit1.collider) : meshBatchInstance1.idMain);
                    carrier = (!dMain1 ? raycastHit1.collider.GetComponent <TransCarrier>() : dMain1.GetLocal <TransCarrier>());
                }
            }
            flag4 = (raycastHit.collider is TerrainCollider ? true : raycastHit.collider.gameObject.layer == 10);
            flag7 = true;
        }
        else
        {
            vector3  = point;
            vector31 = Vector3.up;
            carrier  = null;
        }
        bool      flag12           = false;
        Hardpoint hardpointFromRay = null;

        if (this.hardpointType != Hardpoint.hardpoint_type.None)
        {
            hardpointFromRay = Hardpoint.GetHardpointFromRay(ray, this.hardpointType);
            if (hardpointFromRay)
            {
                flag12   = true;
                vector3  = hardpointFromRay.transform.position;
                vector31 = hardpointFromRay.transform.up;
                carrier  = hardpointFromRay.GetMaster().GetTransCarrier();
                flag7    = true;
            }
        }
        bool flag13 = false;

        if (this.spacingRadius > 0f)
        {
            Collider[] colliderArray = Physics.OverlapSphere(vector3, this.spacingRadius);
            int        num           = 0;
            while (num < (int)colliderArray.Length)
            {
                Collider   collider   = colliderArray[num];
                GameObject gameObject = collider.gameObject;
                IDBase     component  = collider.gameObject.GetComponent <IDBase>();
                if (component != null)
                {
                    gameObject = component.idMain.gameObject;
                }
                if (!gameObject.CompareTag(this.ObjectToPlace.gameObject.tag) || Vector3.Distance(vector3, gameObject.transform.position) >= this.spacingRadius)
                {
                    num++;
                }
                else
                {
                    flag13 = true;
                    break;
                }
            }
        }
        bool flag14 = false;

        if (flag3 && !this.forcePlaceable && deployableObject.cantPlaceOn)
        {
            flag14 = true;
        }
        pos = vector3;
        if (this.orientationMode == DeployableOrientationMode.Default)
        {
            if (!this.uprightOnly)
            {
                this.orientationMode = DeployableOrientationMode.NormalUp;
            }
            else
            {
                this.orientationMode = DeployableOrientationMode.Upright;
            }
        }
        switch (this.orientationMode)
        {
        case DeployableOrientationMode.NormalUp:
        {
            quaternion = TransformHelpers.LookRotationForcedUp(ray.direction, vector31);
            break;
        }

        case DeployableOrientationMode.Upright:
        {
            quaternion = TransformHelpers.LookRotationForcedUp(ray.direction, Vector3.up);
            break;
        }

        case DeployableOrientationMode.NormalForward:
        {
            Vector3 vector36 = Vector3.Cross(ray.direction, Vector3.up);
            quaternion = TransformHelpers.LookRotationForcedUp(vector36, vector31);
            break;
        }

        case DeployableOrientationMode.HardpointPosRot:
        {
            quaternion = (!flag12 ? TransformHelpers.LookRotationForcedUp(ray.direction, Vector3.up) : hardpointFromRay.transform.rotation);
            break;
        }

        default:
        {
            throw new NotImplementedException();
        }
        }
        rot = quaternion * this.ObjectToPlace.transform.localRotation;
        bool flag15 = false;

        if (this.checkPlacementZones)
        {
            flag15 = NoPlacementZone.ValidPos(pos);
        }
        float single2 = Vector3.Angle(vector31, Vector3.up);

        results.falseFromDeployable      = (this.CanStackOnDeployables || !flag3 ? flag14 : true);
        results.falseFromTerrian         = (!this.TerrainOnly ? false : !flag4);
        results.falseFromClose           = (this.spacingRadius <= 0f ? false : flag13);
        results.falseFromHardpoint       = (!this.requireHardpoint ? false : !flag12);
        results.falseFromAngle           = (this.requireHardpoint ? false : single2 >= this.ObjectToPlace.maxSlope);
        results.falseFromPlacementZone   = (!this.checkPlacementZones ? false : !flag15);
        results.falseFromHittingNothing  = !flag7;
        results.falseFromStructure       = (!this.StructureOnly ? false : !flag5);
        results.falseFromFitRequirements = (this.fitRequirements == null ? false : !this.fitRequirements.Test(pos, (!this.fitTestForcedUp ? rot : TransformHelpers.LookRotationForcedUp(rot, Vector3.up)), this.ObjectToPlace.transform.localScale));
    }