Esempio n. 1
0
 // Token: 0x0600284E RID: 10318 RVA: 0x000F4AEC File Offset: 0x000F2EEC
 private void onRegionUpdated(Player player, byte old_x, byte old_y, byte new_x, byte new_y, byte step, ref bool canIncrementIndex)
 {
     if (step == 0)
     {
         for (byte b = 0; b < Regions.WORLD_SIZE; b += 1)
         {
             for (byte b2 = 0; b2 < Regions.WORLD_SIZE; b2 += 1)
             {
                 if (player.channel.isOwner && ItemManager.regions[(int)b, (int)b2].isNetworked && !Regions.checkArea(b, b2, new_x, new_y, ItemManager.ITEM_REGIONS))
                 {
                     ItemManager.regions[(int)b, (int)b2].destroy();
                     ItemManager.regions[(int)b, (int)b2].isNetworked = false;
                 }
                 if (Provider.isServer && player.movement.loadedRegions[(int)b, (int)b2].isItemsLoaded && !Regions.checkArea(b, b2, new_x, new_y, ItemManager.ITEM_REGIONS))
                 {
                     player.movement.loadedRegions[(int)b, (int)b2].isItemsLoaded = false;
                 }
             }
         }
     }
     if (step == 5 && Provider.isServer && Regions.checkSafe((int)new_x, (int)new_y))
     {
         for (int i = (int)(new_x - ItemManager.ITEM_REGIONS); i <= (int)(new_x + ItemManager.ITEM_REGIONS); i++)
         {
             for (int j = (int)(new_y - ItemManager.ITEM_REGIONS); j <= (int)(new_y + ItemManager.ITEM_REGIONS); j++)
             {
                 if (Regions.checkSafe((int)((byte)i), (int)((byte)j)) && !player.movement.loadedRegions[i, j].isItemsLoaded)
                 {
                     if (player.channel.isOwner)
                     {
                         this.generateItems((byte)i, (byte)j);
                     }
                     player.movement.loadedRegions[i, j].isItemsLoaded = true;
                     this.askItems(player.channel.owner.playerID.steamID, (byte)i, (byte)j);
                 }
             }
         }
     }
 }
Esempio n. 2
0
        public void calculateBounds()
        {
            this.cullMagnitude    = 64f * this.bias;
            this.sqrCullMagnitude = this.cullMagnitude * this.cullMagnitude;
            if (this.lod == EObjectLOD.MESH)
            {
                ObjectsLOD.meshes.Clear();
                base.GetComponentsInChildren <MeshFilter>(true, ObjectsLOD.meshes);
                if (ObjectsLOD.meshes.Count == 0)
                {
                    base.enabled = false;
                    return;
                }
                Bounds item = default(Bounds);
                for (int i = 0; i < ObjectsLOD.meshes.Count; i++)
                {
                    Mesh sharedMesh = ObjectsLOD.meshes[i].sharedMesh;
                    if (!(sharedMesh == null))
                    {
                        Bounds bounds = sharedMesh.bounds;
                        item.Encapsulate(bounds.min);
                        item.Encapsulate(bounds.max);
                    }
                }
                item.Expand(-1f);
                item.center += this.center;
                item.size   += this.size;
                if (item.size.x < 1f || item.size.y < 1f || item.size.z < 1f)
                {
                    base.enabled = false;
                    return;
                }
                this.bounds = new List <Bounds>();
                this.bounds.Add(item);
            }
            else if (this.lod == EObjectLOD.AREA)
            {
                ObjectsLOD.areas.Clear();
                base.GetComponentsInChildren <OcclusionArea>(true, ObjectsLOD.areas);
                if (ObjectsLOD.areas.Count == 0)
                {
                    base.enabled = false;
                    return;
                }
                this.bounds = new List <Bounds>();
                for (int j = 0; j < ObjectsLOD.areas.Count; j++)
                {
                    OcclusionArea occlusionArea = ObjectsLOD.areas[j];
                    Bounds        item2;
                    item2..ctor(occlusionArea.transform.localPosition + occlusionArea.center, new Vector3(occlusionArea.size.x, occlusionArea.size.z, occlusionArea.size.y));
                    this.bounds.Add(item2);
                }
            }
            this.objects = new List <LevelObject>();
            for (int k = 0; k < this.bounds.Count; k++)
            {
                Bounds bounds2 = this.bounds[k];
                this.cullCenter += bounds2.center;
            }
            this.cullCenter /= (float)this.bounds.Count;
            this.cullCenter  = base.transform.TransformPoint(this.cullCenter);
            byte b;
            byte b2;

            Regions.tryGetCoordinate(this.cullCenter, out b, out b2);
            for (int l = (int)(b - 1); l <= (int)(b + 1); l++)
            {
                for (int m = (int)(b2 - 1); m <= (int)(b2 + 1); m++)
                {
                    for (int n = 0; n < LevelObjects.objects[l, m].Count; n++)
                    {
                        LevelObject levelObject = LevelObjects.objects[l, m][n];
                        if (levelObject.asset != null && !(levelObject.transform == null) && levelObject.asset.type != EObjectType.LARGE)
                        {
                            if (!levelObject.isSpeciallyCulled)
                            {
                                Vector3 vector = base.transform.InverseTransformPoint(levelObject.transform.position);
                                bool    flag   = false;
                                for (int num = 0; num < this.bounds.Count; num++)
                                {
                                    if (this.bounds[num].Contains(vector))
                                    {
                                        flag = true;
                                        break;
                                    }
                                }
                                if (flag)
                                {
                                    levelObject.isSpeciallyCulled = true;
                                    this.objects.Add(levelObject);
                                }
                            }
                        }
                    }
                }
            }
            if (this.objects.Count == 0)
            {
                base.enabled = false;
                return;
            }
        }
Esempio n. 3
0
 public void send(ESteamCall mode, byte x, byte y, byte area, ESteamPacket type, int size, byte[] packet)
 {
     if (mode == ESteamCall.SERVER)
     {
         if (Provider.isServer)
         {
             this.receive(Provider.server, packet, 0, size);
         }
         else
         {
             Provider.send(Provider.server, type, packet, size, this.id);
         }
     }
     else if (mode == ESteamCall.ALL)
     {
         if (!Provider.isServer)
         {
             Provider.send(Provider.server, type, packet, size, this.id);
         }
         for (int i = 0; i < Provider.clients.Count; i++)
         {
             if (Provider.clients[i].playerID.steamID != Provider.client && Provider.clients[i].player != null && Regions.checkArea(x, y, Provider.clients[i].player.movement.region_x, Provider.clients[i].player.movement.region_y, area))
             {
                 Provider.send(Provider.clients[i].playerID.steamID, type, packet, size, this.id);
             }
         }
         if (Provider.isServer)
         {
             this.receive(Provider.server, packet, 0, size);
         }
         else
         {
             this.receive(Provider.client, packet, 0, size);
         }
     }
     else if (mode == ESteamCall.OTHERS)
     {
         if (!Provider.isServer)
         {
             Provider.send(Provider.server, type, packet, size, this.id);
         }
         for (int j = 0; j < Provider.clients.Count; j++)
         {
             if (Provider.clients[j].playerID.steamID != Provider.client && Provider.clients[j].player != null && Regions.checkArea(x, y, Provider.clients[j].player.movement.region_x, Provider.clients[j].player.movement.region_y, area))
             {
                 Provider.send(Provider.clients[j].playerID.steamID, type, packet, size, this.id);
             }
         }
     }
     else if (mode == ESteamCall.OWNER)
     {
         if (this.isOwner)
         {
             this.receive(this.owner.playerID.steamID, packet, 0, size);
         }
         else
         {
             Provider.send(this.owner.playerID.steamID, type, packet, size, this.id);
         }
     }
     else if (mode == ESteamCall.NOT_OWNER)
     {
         if (!Provider.isServer)
         {
             Provider.send(Provider.server, type, packet, size, this.id);
         }
         for (int k = 0; k < Provider.clients.Count; k++)
         {
             if (Provider.clients[k].playerID.steamID != this.owner.playerID.steamID && Provider.clients[k].player != null && Regions.checkArea(x, y, Provider.clients[k].player.movement.region_x, Provider.clients[k].player.movement.region_y, area))
             {
                 Provider.send(Provider.clients[k].playerID.steamID, type, packet, size, this.id);
             }
         }
     }
     else if (mode == ESteamCall.CLIENTS)
     {
         for (int l = 0; l < Provider.clients.Count; l++)
         {
             if (Provider.clients[l].playerID.steamID != Provider.client && Provider.clients[l].player != null && Regions.checkArea(x, y, Provider.clients[l].player.movement.region_x, Provider.clients[l].player.movement.region_y, area))
             {
                 Provider.send(Provider.clients[l].playerID.steamID, type, packet, size, this.id);
             }
         }
         if (Provider.isClient)
         {
             this.receive(Provider.client, packet, 0, size);
         }
     }
     else if (mode == ESteamCall.PEERS)
     {
         for (int m = 0; m < Provider.clients.Count; m++)
         {
             if (Provider.clients[m].playerID.steamID != Provider.client && Provider.clients[m].player != null && Regions.checkArea(x, y, Provider.clients[m].player.movement.region_x, Provider.clients[m].player.movement.region_y, area))
             {
                 Provider.send(Provider.clients[m].playerID.steamID, type, packet, size, this.id);
             }
         }
     }
 }
Esempio n. 4
0
 public void askTakeItem(CSteamID steamID, byte x, byte y, uint instanceID, byte to_x, byte to_y, byte to_rot, byte to_page)
 {
     if (Provider.isServer)
     {
         if (!Regions.checkSafe((int)x, (int)y))
         {
             return;
         }
         Player player = PlayerTool.getPlayer(steamID);
         if (player == null)
         {
             return;
         }
         if (player.life.isDead)
         {
             return;
         }
         if (!player.tryToPerformRateLimitedAction())
         {
             return;
         }
         if (player.animator.gesture == EPlayerGesture.ARREST_START)
         {
             return;
         }
         ItemRegion itemRegion = ItemManager.regions[(int)x, (int)y];
         ushort     num        = 0;
         while ((int)num < itemRegion.items.Count)
         {
             if (itemRegion.items[(int)num].instanceID == instanceID)
             {
                 if (Dedicator.isDedicated && (itemRegion.items[(int)num].point - player.transform.position).sqrMagnitude > 400f)
                 {
                     return;
                 }
                 bool flag;
                 if (to_page == 255)
                 {
                     flag = player.inventory.tryAddItem(ItemManager.regions[(int)x, (int)y].items[(int)num].item, true);
                 }
                 else
                 {
                     flag = player.inventory.tryAddItem(ItemManager.regions[(int)x, (int)y].items[(int)num].item, to_x, to_y, to_page, to_rot);
                 }
                 if (flag)
                 {
                     if (!player.equipment.wasTryingToSelect && !player.equipment.isSelected)
                     {
                         player.animator.sendGesture(EPlayerGesture.PICKUP, true);
                     }
                     EffectManager.sendEffect(7, EffectManager.SMALL, ItemManager.regions[(int)x, (int)y].items[(int)num].point);
                     ItemManager.regions[(int)x, (int)y].items.RemoveAt((int)num);
                     player.sendStat(EPlayerStat.FOUND_ITEMS);
                     base.channel.send("tellTakeItem", ESteamCall.CLIENTS, x, y, ItemManager.ITEM_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
                     {
                         x,
                         y,
                         instanceID
                     });
                 }
                 else
                 {
                     player.sendMessage(EPlayerMessage.SPACE);
                 }
                 return;
             }
             else
             {
                 num += 1;
             }
         }
     }
 }
Esempio n. 5
0
 private void onRegionUpdated(Player player, byte old_x, byte old_y, byte new_x, byte new_y, byte step, ref bool canIncrementIndex)
 {
     if (step == 0)
     {
         for (byte b = 0; b < Regions.WORLD_SIZE; b += 1)
         {
             for (byte b2 = 0; b2 < Regions.WORLD_SIZE; b2 += 1)
             {
                 if (Provider.isServer)
                 {
                     if (player.movement.loadedRegions[(int)b, (int)b2].isResourcesLoaded && !Regions.checkArea(b, b2, new_x, new_y, ResourceManager.RESOURCE_REGIONS))
                     {
                         player.movement.loadedRegions[(int)b, (int)b2].isResourcesLoaded = false;
                     }
                 }
                 else if (player.channel.isOwner && ResourceManager.regions[(int)b, (int)b2].isNetworked && !Regions.checkArea(b, b2, new_x, new_y, ResourceManager.RESOURCE_REGIONS))
                 {
                     ResourceManager.regions[(int)b, (int)b2].isNetworked = false;
                 }
             }
         }
     }
     if (step == 3 && Dedicator.isDedicated && Regions.checkSafe((int)new_x, (int)new_y))
     {
         for (int i = (int)(new_x - ResourceManager.RESOURCE_REGIONS); i <= (int)(new_x + ResourceManager.RESOURCE_REGIONS); i++)
         {
             for (int j = (int)(new_y - ResourceManager.RESOURCE_REGIONS); j <= (int)(new_y + ResourceManager.RESOURCE_REGIONS); j++)
             {
                 if (Regions.checkSafe((int)((byte)i), (int)((byte)j)) && !player.movement.loadedRegions[i, j].isResourcesLoaded)
                 {
                     player.movement.loadedRegions[i, j].isResourcesLoaded = true;
                     this.askResources(player.channel.owner.playerID.steamID, (byte)i, (byte)j);
                 }
             }
         }
     }
 }
Esempio n. 6
0
 private static void update(int x, int y)
 {
     for (int i = 0; i < (int)EditorLevelVisibilityUI.DEBUG_SIZE; i++)
     {
         for (int j = 0; j < (int)EditorLevelVisibilityUI.DEBUG_SIZE; j++)
         {
             int        num        = i * (int)EditorLevelVisibilityUI.DEBUG_SIZE + j;
             int        num2       = x - (int)(EditorLevelVisibilityUI.DEBUG_SIZE / 2) + i;
             int        num3       = y - (int)(EditorLevelVisibilityUI.DEBUG_SIZE / 2) + j;
             SleekLabel sleekLabel = EditorLevelVisibilityUI.regionLabels[num];
             if (Regions.checkSafe(num2, num3))
             {
                 int    num4 = LevelObjects.objects[num2, num3].Count + LevelGround.trees[num2, num3].Count;
                 int    num5 = LevelObjects.total + LevelGround.total;
                 double num6 = Math.Round((double)num4 / (double)num5 * 1000.0) / 10.0;
                 int    num7 = 0;
                 for (int k = 0; k < LevelObjects.objects[num2, num3].Count; k++)
                 {
                     LevelObject levelObject = LevelObjects.objects[num2, num3][k];
                     if (levelObject.transform)
                     {
                         levelObject.transform.GetComponents <MeshFilter>(EditorLevelVisibilityUI.meshes);
                         if (EditorLevelVisibilityUI.meshes.Count == 0)
                         {
                             Transform transform = levelObject.transform.FindChild("Model_0");
                             if (transform)
                             {
                                 transform.GetComponentsInChildren <MeshFilter>(true, EditorLevelVisibilityUI.meshes);
                             }
                         }
                         if (EditorLevelVisibilityUI.meshes.Count != 0)
                         {
                             for (int l = 0; l < EditorLevelVisibilityUI.meshes.Count; l++)
                             {
                                 Mesh sharedMesh = EditorLevelVisibilityUI.meshes[l].sharedMesh;
                                 if (sharedMesh)
                                 {
                                     num7 += sharedMesh.triangles.Length;
                                 }
                             }
                         }
                     }
                 }
                 for (int m = 0; m < LevelGround.trees[num2, num3].Count; m++)
                 {
                     ResourceSpawnpoint resourceSpawnpoint = LevelGround.trees[num2, num3][m];
                     if (resourceSpawnpoint.model)
                     {
                         resourceSpawnpoint.model.GetComponents <MeshFilter>(EditorLevelVisibilityUI.meshes);
                         if (EditorLevelVisibilityUI.meshes.Count == 0)
                         {
                             Transform transform2 = resourceSpawnpoint.model.FindChild("Model_0");
                             if (transform2)
                             {
                                 transform2.GetComponentsInChildren <MeshFilter>(true, EditorLevelVisibilityUI.meshes);
                             }
                         }
                         if (EditorLevelVisibilityUI.meshes.Count != 0)
                         {
                             for (int n = 0; n < EditorLevelVisibilityUI.meshes.Count; n++)
                             {
                                 Mesh sharedMesh2 = EditorLevelVisibilityUI.meshes[n].sharedMesh;
                                 if (sharedMesh2)
                                 {
                                     num7 += sharedMesh2.triangles.Length;
                                 }
                             }
                         }
                     }
                 }
                 long  num8    = (long)num4 * (long)num7;
                 float quality = Mathf.Clamp01((float)(1.0 - (double)num8 / 50000000.0));
                 sleekLabel.text = EditorLevelVisibilityUI.localization.format("Point", new object[]
                 {
                     num2,
                     num3
                 });
                 SleekLabel sleekLabel2 = sleekLabel;
                 sleekLabel2.text = sleekLabel2.text + "\n" + EditorLevelVisibilityUI.localization.format("Objects", new object[]
                 {
                     num4,
                     num6
                 });
                 SleekLabel sleekLabel3 = sleekLabel;
                 sleekLabel3.text = sleekLabel3.text + "\n" + EditorLevelVisibilityUI.localization.format("Triangles", new object[]
                 {
                     num7
                 });
                 if (num4 == 0 && num7 == 0)
                 {
                     sleekLabel.foregroundColor = Color.white;
                 }
                 else
                 {
                     sleekLabel.foregroundColor = ItemTool.getQualityColor(quality);
                 }
             }
         }
     }
 }
Esempio n. 7
0
 public void askForage(CSteamID steamID, byte x, byte y, ushort index)
 {
     if (Provider.isServer)
     {
         if (!Regions.checkSafe((int)x, (int)y))
         {
             return;
         }
         Player player = PlayerTool.getPlayer(steamID);
         if (player == null)
         {
             return;
         }
         if (player.life.isDead)
         {
             return;
         }
         List <ResourceSpawnpoint> list = LevelGround.trees[(int)x, (int)y];
         if ((int)index >= list.Count)
         {
             return;
         }
         if (list[(int)index].isDead)
         {
             return;
         }
         ResourceAsset resourceAsset = (ResourceAsset)Assets.find(EAssetType.RESOURCE, LevelGround.resources[(int)list[(int)index].type].id);
         if (resourceAsset == null || !resourceAsset.isForage)
         {
             return;
         }
         list[(int)index].askDamage(1);
         if (resourceAsset.explosion != 0)
         {
             EffectManager.sendEffect(resourceAsset.explosion, x, y, ResourceManager.RESOURCE_REGIONS, list[(int)index].point);
         }
         ushort num;
         if (resourceAsset.rewardID != 0)
         {
             num = SpawnTableTool.resolve(resourceAsset.rewardID);
         }
         else
         {
             num = resourceAsset.log;
         }
         if (num != 0)
         {
             player.inventory.forceAddItem(new Item(num, EItemOrigin.NATURE), true);
             if (Random.value < player.skills.mastery(2, 5))
             {
                 player.inventory.forceAddItem(new Item(num, EItemOrigin.NATURE), true);
             }
         }
         player.sendStat(EPlayerStat.FOUND_PLANTS);
         player.skills.askPay(1u);
         ResourceManager.manager.channel.send("tellResourceDead", ESteamCall.ALL, x, y, ResourceManager.RESOURCE_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
         {
             x,
             y,
             index,
             Vector3.zero
         });
     }
 }
Esempio n. 8
0
        public static void damage(Transform resource, Vector3 direction, float damage, float times, float drop, out EPlayerKill kill, out uint xp)
        {
            xp   = 0u;
            kill = EPlayerKill.NONE;
            byte b;
            byte b2;

            if (Regions.tryGetCoordinate(resource.position, out b, out b2))
            {
                List <ResourceSpawnpoint> list = LevelGround.trees[(int)b, (int)b2];
                ushort num = 0;
                while ((int)num < list.Count)
                {
                    if (resource == list[(int)num].model)
                    {
                        if (!list[(int)num].isDead)
                        {
                            ushort num2 = (ushort)(damage * times);
                            list[(int)num].askDamage(num2);
                            if (list[(int)num].isDead)
                            {
                                kill = EPlayerKill.RESOURCE;
                                ResourceAsset asset = list[(int)num].asset;
                                if (list[(int)num].asset != null)
                                {
                                    if (asset.explosion != 0)
                                    {
                                        if (asset.hasDebris)
                                        {
                                            EffectManager.sendEffect(asset.explosion, b, b2, ResourceManager.RESOURCE_REGIONS, resource.position + Vector3.up * 8f);
                                        }
                                        else
                                        {
                                            EffectManager.sendEffect(asset.explosion, b, b2, ResourceManager.RESOURCE_REGIONS, resource.position);
                                        }
                                    }
                                    if (asset.rewardID != 0)
                                    {
                                        direction.y = 0f;
                                        direction.Normalize();
                                        int num3 = (int)((float)Random.Range((int)asset.rewardMin, (int)(asset.rewardMax + 1)) * drop);
                                        for (int i = 0; i < num3; i++)
                                        {
                                            ushort num4 = SpawnTableTool.resolve(asset.rewardID);
                                            if (num4 != 0)
                                            {
                                                if (asset.hasDebris)
                                                {
                                                    ItemManager.dropItem(new Item(num4, EItemOrigin.NATURE), resource.position + direction * (float)(2 + i) + new Vector3(0f, 2f, 0f), false, Dedicator.isDedicated, true);
                                                }
                                                else
                                                {
                                                    ItemManager.dropItem(new Item(num4, EItemOrigin.NATURE), resource.position + new Vector3(Random.Range(-2f, 2f), 2f, Random.Range(-2f, 2f)), false, Dedicator.isDedicated, true);
                                                }
                                            }
                                        }
                                    }
                                    else
                                    {
                                        if (asset.log != 0)
                                        {
                                            int num5 = (int)((float)Random.Range(3, 7) * drop);
                                            for (int j = 0; j < num5; j++)
                                            {
                                                ItemManager.dropItem(new Item(asset.log, EItemOrigin.NATURE), resource.position + direction * (float)(2 + j * 2) + Vector3.up, false, Dedicator.isDedicated, true);
                                            }
                                        }
                                        if (asset.stick != 0)
                                        {
                                            int num6 = (int)((float)Random.Range(2, 5) * drop);
                                            for (int k = 0; k < num6; k++)
                                            {
                                                float num7 = Random.Range(0f, 6.28318548f);
                                                ItemManager.dropItem(new Item(asset.stick, EItemOrigin.NATURE), resource.position + new Vector3(Mathf.Sin(num7) * 3f, 1f, Mathf.Cos(num7) * 3f), false, Dedicator.isDedicated, true);
                                            }
                                        }
                                    }
                                    xp = asset.rewardXP;
                                }
                                ResourceManager.manager.channel.send("tellResourceDead", ESteamCall.ALL, b, b2, ResourceManager.RESOURCE_REGIONS, ESteamPacket.UPDATE_RELIABLE_BUFFER, new object[]
                                {
                                    b,
                                    b2,
                                    num,
                                    direction * (float)num2
                                });
                            }
                        }
                        break;
                    }
                    num += 1;
                }
            }
        }
Esempio n. 9
0
 private static void onRegionUpdated(Player player, byte old_x, byte old_y, byte new_x, byte new_y, byte step, ref bool canIncrementIndex)
 {
     if (step != 0)
     {
         return;
     }
     for (byte b = 0; b < Regions.WORLD_SIZE; b += 1)
     {
         for (byte b2 = 0; b2 < Regions.WORLD_SIZE; b2 += 1)
         {
             if (LevelObjects.regions[(int)b, (int)b2] && !Regions.checkArea(b, b2, new_x, new_y, LevelObjects.OBJECT_REGIONS))
             {
                 LevelObjects.regions[(int)b, (int)b2] = false;
                 if (LevelObjects.shouldInstantlyLoad)
                 {
                     List <LevelObject> list = LevelObjects.objects[(int)b, (int)b2];
                     for (int i = 0; i < list.Count; i++)
                     {
                         list[i].disableCollision();
                         if (!list[i].isSpeciallyCulled)
                         {
                             list[i].disableVisual();
                             if (list[i].isLandmarkQualityMet)
                             {
                                 list[i].enableSkybox();
                             }
                         }
                     }
                 }
                 else
                 {
                     LevelObjects.loads[(int)b, (int)b2] = 0;
                 }
                 if (Level.isEditor)
                 {
                     List <LevelBuildableObject> list2 = LevelObjects.buildables[(int)b, (int)b2];
                     for (int j = 0; j < list2.Count; j++)
                     {
                         list2[j].disable();
                     }
                 }
             }
         }
     }
     if (Regions.checkSafe((int)new_x, (int)new_y))
     {
         for (int k = (int)(new_x - LevelObjects.OBJECT_REGIONS); k <= (int)(new_x + LevelObjects.OBJECT_REGIONS); k++)
         {
             for (int l = (int)(new_y - LevelObjects.OBJECT_REGIONS); l <= (int)(new_y + LevelObjects.OBJECT_REGIONS); l++)
             {
                 if (Regions.checkSafe((int)((byte)k), (int)((byte)l)) && !LevelObjects.regions[k, l])
                 {
                     LevelObjects.regions[k, l] = true;
                     if (LevelObjects.shouldInstantlyLoad)
                     {
                         List <LevelObject> list3 = LevelObjects.objects[k, l];
                         for (int m = 0; m < list3.Count; m++)
                         {
                             list3[m].enableCollision();
                             if (!list3[m].isSpeciallyCulled)
                             {
                                 list3[m].enableVisual();
                                 list3[m].disableSkybox();
                             }
                         }
                     }
                     else
                     {
                         LevelObjects.loads[k, l] = 0;
                     }
                     if (Level.isEditor)
                     {
                         List <LevelBuildableObject> list4 = LevelObjects.buildables[k, l];
                         for (int n = 0; n < list4.Count; n++)
                         {
                             list4[n].enable();
                         }
                     }
                 }
             }
         }
     }
     Level.isLoadingArea = false;
     LevelObjects.shouldInstantlyLoad = false;
 }
Esempio n. 10
0
        // Token: 0x060033E3 RID: 13283 RVA: 0x00151418 File Offset: 0x0014F818
        public static void explode(Vector3 point, float damageRadius, EDeathCause cause, CSteamID killer, float playerDamage, float zombieDamage, float animalDamage, float barricadeDamage, float structureDamage, float vehicleDamage, float resourceDamage, float objectDamage, out List <EPlayerKill> kills, EExplosionDamageType damageType = EExplosionDamageType.CONVENTIONAL, float alertRadius = 32f, bool playImpactEffect = true, bool penetrateBuildables = false)
        {
            DamageTool.explosionKills.Clear();
            kills = DamageTool.explosionKills;
            DamageTool.explosionRangeComparator.point = point;
            float num = damageRadius * damageRadius;

            DamageTool.regionsInRadius.Clear();
            Regions.getRegionsInRadius(point, damageRadius, DamageTool.regionsInRadius);
            int layerMask;

            if (penetrateBuildables)
            {
                layerMask = RayMasks.BLOCK_EXPLOSION_PENETRATE_BUILDABLES;
            }
            else
            {
                layerMask = RayMasks.BLOCK_EXPLOSION;
            }
            if (structureDamage > 0.5f)
            {
                DamageTool.structuresInRadius.Clear();
                StructureManager.getStructuresInRadius(point, num, DamageTool.regionsInRadius, DamageTool.structuresInRadius);
                DamageTool.structuresInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int i = 0; i < DamageTool.structuresInRadius.Count; i++)
                {
                    Transform transform = DamageTool.structuresInRadius[i];
                    if (!(transform == null))
                    {
                        ushort id;
                        if (ushort.TryParse(transform.name, out id))
                        {
                            ItemStructureAsset itemStructureAsset = (ItemStructureAsset)Assets.find(EAssetType.ITEM, id);
                            if (itemStructureAsset != null && !itemStructureAsset.proofExplosion)
                            {
                                Vector3 a         = transform.transform.position - point;
                                float   magnitude = a.magnitude;
                                Vector3 direction = a / magnitude;
                                if (magnitude > 0.5f)
                                {
                                    RaycastHit raycastHit;
                                    PhysicsUtility.raycast(new Ray(point, direction), out raycastHit, magnitude - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                                    if (raycastHit.transform != null && raycastHit.transform != transform.transform)
                                    {
                                        goto IL_17D;
                                    }
                                }
                                StructureManager.damage(transform, a.normalized, structureDamage, 1f - magnitude / damageRadius, true);
                            }
                        }
                    }
                    IL_17D :;
                }
            }
            if (resourceDamage > 0.5f)
            {
                DamageTool.resourcesInRadius.Clear();
                ResourceManager.getResourcesInRadius(point, num, DamageTool.regionsInRadius, DamageTool.resourcesInRadius);
                DamageTool.resourcesInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int j = 0; j < DamageTool.resourcesInRadius.Count; j++)
                {
                    Transform transform2 = DamageTool.resourcesInRadius[j];
                    if (!(transform2 == null))
                    {
                        Vector3 a2         = transform2.transform.position - point;
                        float   magnitude2 = a2.magnitude;
                        Vector3 direction2 = a2 / magnitude2;
                        if (magnitude2 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, direction2), out raycastHit, magnitude2 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                            if (raycastHit.transform != null && raycastHit.transform != transform2.transform)
                            {
                                goto IL_2A2;
                            }
                        }
                        EPlayerKill eplayerKill;
                        uint        num2;
                        ResourceManager.damage(transform2, a2.normalized, resourceDamage, 1f - magnitude2 / damageRadius, 1f, out eplayerKill, out num2);
                        if (eplayerKill != EPlayerKill.NONE)
                        {
                            kills.Add(eplayerKill);
                        }
                    }
                    IL_2A2 :;
                }
            }
            if (objectDamage > 0.5f)
            {
                DamageTool.objectsInRadius.Clear();
                ObjectManager.getObjectsInRadius(point, num, DamageTool.regionsInRadius, DamageTool.objectsInRadius);
                DamageTool.objectsInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int k = 0; k < DamageTool.objectsInRadius.Count; k++)
                {
                    Transform transform3 = DamageTool.objectsInRadius[k];
                    if (!(transform3 == null))
                    {
                        InteractableObjectRubble component = transform3.GetComponent <InteractableObjectRubble>();
                        if (!(component == null))
                        {
                            if (!component.asset.rubbleProofExplosion)
                            {
                                for (byte b = 0; b < component.getSectionCount(); b += 1)
                                {
                                    Transform section = component.getSection(b);
                                    Vector3   a3      = section.position - point;
                                    if (a3.sqrMagnitude < num)
                                    {
                                        float   magnitude3 = a3.magnitude;
                                        Vector3 direction3 = a3 / magnitude3;
                                        if (magnitude3 > 0.5f)
                                        {
                                            RaycastHit raycastHit;
                                            PhysicsUtility.raycast(new Ray(point, direction3), out raycastHit, magnitude3 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                                            if (raycastHit.transform != null && raycastHit.transform != transform3.transform)
                                            {
                                                goto IL_40B;
                                            }
                                        }
                                        EPlayerKill eplayerKill;
                                        uint        num2;
                                        ObjectManager.damage(transform3, a3.normalized, b, objectDamage, 1f - magnitude3 / damageRadius, out eplayerKill, out num2);
                                        if (eplayerKill != EPlayerKill.NONE)
                                        {
                                            kills.Add(eplayerKill);
                                        }
                                    }
                                    IL_40B :;
                                }
                            }
                        }
                    }
                }
            }
            if (barricadeDamage > 0.5f)
            {
                DamageTool.barricadesInRadius.Clear();
                BarricadeManager.getBarricadesInRadius(point, num, DamageTool.regionsInRadius, DamageTool.barricadesInRadius);
                BarricadeManager.getBarricadesInRadius(point, num, DamageTool.barricadesInRadius);
                DamageTool.barricadesInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int l = 0; l < DamageTool.barricadesInRadius.Count; l++)
                {
                    Transform transform4 = DamageTool.barricadesInRadius[l];
                    if (!(transform4 == null))
                    {
                        Vector3 a4         = transform4.transform.position - point;
                        float   magnitude4 = a4.magnitude;
                        Vector3 direction4 = a4 / magnitude4;
                        if (magnitude4 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, direction4), out raycastHit, magnitude4 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                            if (raycastHit.transform != null && raycastHit.transform != transform4.transform)
                            {
                                goto IL_568;
                            }
                        }
                        ushort id2;
                        if (ushort.TryParse(transform4.name, out id2))
                        {
                            ItemBarricadeAsset itemBarricadeAsset = (ItemBarricadeAsset)Assets.find(EAssetType.ITEM, id2);
                            if (itemBarricadeAsset != null && !itemBarricadeAsset.proofExplosion)
                            {
                                BarricadeManager.damage(transform4, barricadeDamage, 1f - magnitude4 / damageRadius, true);
                            }
                        }
                    }
                    IL_568 :;
                }
            }
            if ((Provider.isPvP || damageType == EExplosionDamageType.ZOMBIE_ACID || damageType == EExplosionDamageType.ZOMBIE_FIRE || damageType == EExplosionDamageType.ZOMBIE_ELECTRIC) && playerDamage > 0.5f)
            {
                DamageTool.playersInRadius.Clear();
                PlayerTool.getPlayersInRadius(point, num, DamageTool.playersInRadius);
                for (int m = 0; m < DamageTool.playersInRadius.Count; m++)
                {
                    Player player = DamageTool.playersInRadius[m];
                    if (!(player == null) && !player.life.isDead)
                    {
                        if (damageType != EExplosionDamageType.ZOMBIE_FIRE || player.clothing.shirtAsset == null || !player.clothing.shirtAsset.proofFire || player.clothing.pantsAsset == null || !player.clothing.pantsAsset.proofFire)
                        {
                            Vector3 a5         = player.transform.position - point;
                            float   magnitude5 = a5.magnitude;
                            Vector3 vector     = a5 / magnitude5;
                            if (magnitude5 > 0.5f)
                            {
                                RaycastHit raycastHit;
                                PhysicsUtility.raycast(new Ray(point, vector), out raycastHit, magnitude5 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                                if (raycastHit.transform != null && raycastHit.transform != player.transform)
                                {
                                    goto IL_7AA;
                                }
                            }
                            if (playImpactEffect)
                            {
                                EffectManager.sendEffect(5, EffectManager.SMALL, player.transform.position + Vector3.up, -vector);
                                EffectManager.sendEffect(5, EffectManager.SMALL, player.transform.position + Vector3.up, Vector3.up);
                            }
                            float num3 = 1f - Mathf.Pow(magnitude5 / damageRadius, 2f);
                            if (player.movement.getVehicle() != null && player.movement.getVehicle().asset != null)
                            {
                                num3 *= player.movement.getVehicle().asset.passengerExplosionArmor;
                            }
                            EPlayerKill eplayerKill;
                            DamageTool.damage(player, cause, ELimb.SPINE, killer, vector, playerDamage, num3, out eplayerKill);
                            if (eplayerKill != EPlayerKill.NONE)
                            {
                                kills.Add(eplayerKill);
                            }
                        }
                    }
                    IL_7AA :;
                }
            }
            if (damageType == EExplosionDamageType.ZOMBIE_FIRE || zombieDamage > 0.5f)
            {
                DamageTool.zombiesInRadius.Clear();
                ZombieManager.getZombiesInRadius(point, num, DamageTool.zombiesInRadius);
                for (int n = 0; n < DamageTool.zombiesInRadius.Count; n++)
                {
                    Zombie zombie = DamageTool.zombiesInRadius[n];
                    if (!(zombie == null) && !zombie.isDead)
                    {
                        if (damageType == EExplosionDamageType.ZOMBIE_FIRE)
                        {
                            if (zombie.speciality == EZombieSpeciality.NORMAL)
                            {
                                ZombieManager.sendZombieSpeciality(zombie, EZombieSpeciality.BURNER);
                            }
                        }
                        else
                        {
                            Vector3 a6         = zombie.transform.position - point;
                            float   magnitude6 = a6.magnitude;
                            Vector3 vector2    = a6 / magnitude6;
                            if (magnitude6 > 0.5f)
                            {
                                RaycastHit raycastHit;
                                PhysicsUtility.raycast(new Ray(point, vector2), out raycastHit, magnitude6 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                                if (raycastHit.transform != null && raycastHit.transform != zombie.transform)
                                {
                                    goto IL_964;
                                }
                            }
                            if (playImpactEffect)
                            {
                                EffectManager.sendEffect((!zombie.isRadioactive) ? 5 : 95, EffectManager.SMALL, zombie.transform.position + Vector3.up, -vector2);
                                EffectManager.sendEffect((!zombie.isRadioactive) ? 5 : 95, EffectManager.SMALL, zombie.transform.position + Vector3.up, Vector3.up);
                            }
                            EPlayerKill eplayerKill;
                            uint        num2;
                            DamageTool.damage(zombie, vector2, zombieDamage, 1f - magnitude6 / damageRadius, out eplayerKill, out num2);
                            if (eplayerKill != EPlayerKill.NONE)
                            {
                                kills.Add(eplayerKill);
                            }
                        }
                    }
                    IL_964 :;
                }
            }
            if (animalDamage > 0.5f)
            {
                DamageTool.animalsInRadius.Clear();
                AnimalManager.getAnimalsInRadius(point, num, DamageTool.animalsInRadius);
                for (int num4 = 0; num4 < DamageTool.animalsInRadius.Count; num4++)
                {
                    Animal animal = DamageTool.animalsInRadius[num4];
                    if (!(animal == null) && !animal.isDead)
                    {
                        Vector3 a7         = animal.transform.position - point;
                        float   magnitude7 = a7.magnitude;
                        Vector3 vector3    = a7 / magnitude7;
                        if (magnitude7 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, vector3), out raycastHit, magnitude7 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                            if (raycastHit.transform != null && raycastHit.transform != animal.transform)
                            {
                                goto IL_ACC;
                            }
                        }
                        if (playImpactEffect)
                        {
                            EffectManager.sendEffect(5, EffectManager.SMALL, animal.transform.position + Vector3.up, -vector3);
                            EffectManager.sendEffect(5, EffectManager.SMALL, animal.transform.position + Vector3.up, Vector3.up);
                        }
                        EPlayerKill eplayerKill;
                        uint        num2;
                        DamageTool.damage(animal, vector3, animalDamage, 1f - magnitude7 / damageRadius, out eplayerKill, out num2);
                        if (eplayerKill != EPlayerKill.NONE)
                        {
                            kills.Add(eplayerKill);
                        }
                    }
                    IL_ACC :;
                }
            }
            if (vehicleDamage > 0.5f)
            {
                DamageTool.vehiclesInRadius.Clear();
                VehicleManager.getVehiclesInRadius(point, num, DamageTool.vehiclesInRadius);
                for (int num5 = 0; num5 < DamageTool.vehiclesInRadius.Count; num5++)
                {
                    InteractableVehicle interactableVehicle = DamageTool.vehiclesInRadius[num5];
                    if (!(interactableVehicle == null) && !interactableVehicle.isDead)
                    {
                        if (interactableVehicle.asset != null && interactableVehicle.asset.isVulnerableToExplosions)
                        {
                            Vector3 a8         = interactableVehicle.transform.position - point;
                            float   magnitude8 = a8.magnitude;
                            Vector3 direction5 = a8 / magnitude8;
                            if (magnitude8 > 0.5f)
                            {
                                RaycastHit raycastHit;
                                PhysicsUtility.raycast(new Ray(point, direction5), out raycastHit, magnitude8 - 0.5f, layerMask, QueryTriggerInteraction.UseGlobal);
                                if (raycastHit.transform != null && raycastHit.transform != interactableVehicle.transform)
                                {
                                    goto IL_BED;
                                }
                            }
                            VehicleManager.damage(interactableVehicle, vehicleDamage, 1f - magnitude8 / damageRadius, false);
                        }
                    }
                    IL_BED :;
                }
            }
            AlertTool.alert(point, alertRadius);
        }
Esempio n. 11
0
 public static void load()
 {
     LevelObjects._models                 = new GameObject().transform;
     LevelObjects.models.name             = "Objects";
     LevelObjects.models.parent           = Level.level;
     LevelObjects.models.tag              = "Logic";
     LevelObjects.models.gameObject.layer = LayerMasks.LOGIC;
     LevelObjects._objects                = new List <LevelObject> [(int)Regions.WORLD_SIZE, (int)Regions.WORLD_SIZE];
     LevelObjects._buildables             = new List <LevelBuildableObject> [(int)Regions.WORLD_SIZE, (int)Regions.WORLD_SIZE];
     LevelObjects._total              = 0;
     LevelObjects._regions            = new bool[(int)Regions.WORLD_SIZE, (int)Regions.WORLD_SIZE];
     LevelObjects._loads              = new int[(int)Regions.WORLD_SIZE, (int)Regions.WORLD_SIZE];
     LevelObjects.shouldInstantlyLoad = true;
     LevelObjects.isHierarchyReady    = false;
     for (byte b = 0; b < Regions.WORLD_SIZE; b += 1)
     {
         for (byte b2 = 0; b2 < Regions.WORLD_SIZE; b2 += 1)
         {
             LevelObjects.loads[(int)b, (int)b2] = -1;
         }
     }
     for (byte b3 = 0; b3 < Regions.WORLD_SIZE; b3 += 1)
     {
         for (byte b4 = 0; b4 < Regions.WORLD_SIZE; b4 += 1)
         {
             LevelObjects.objects[(int)b3, (int)b4]    = new List <LevelObject>();
             LevelObjects.buildables[(int)b3, (int)b4] = new List <LevelBuildableObject>();
         }
     }
     if (Level.info.configData.Use_Legacy_Objects)
     {
         if (ReadWrite.fileExists(Level.info.path + "/Level/Objects.dat", false, false))
         {
             River river = new River(Level.info.path + "/Level/Objects.dat", false);
             byte  b5    = river.readByte();
             bool  flag  = true;
             if (b5 > 0)
             {
                 if (b5 > 1 && b5 < 3)
                 {
                     river.readSteamID();
                 }
                 if (b5 > 8)
                 {
                     LevelObjects.availableInstanceID = river.readUInt32();
                 }
                 else
                 {
                     LevelObjects.availableInstanceID = 1u;
                 }
                 for (byte b6 = 0; b6 < Regions.WORLD_SIZE; b6 += 1)
                 {
                     for (byte b7 = 0; b7 < Regions.WORLD_SIZE; b7 += 1)
                     {
                         ushort num = river.readUInt16();
                         for (ushort num2 = 0; num2 < num; num2 += 1)
                         {
                             Vector3    vector      = river.readSingleVector3();
                             Quaternion newRotation = river.readSingleQuaternion();
                             Vector3    newScale;
                             if (b5 > 3)
                             {
                                 newScale = river.readSingleVector3();
                             }
                             else
                             {
                                 newScale = Vector3.one;
                             }
                             ushort num3    = river.readUInt16();
                             string newName = string.Empty;
                             if (b5 > 5)
                             {
                                 newName = river.readString();
                             }
                             Guid newGUID = Guid.Empty;
                             if (b5 > 7)
                             {
                                 newGUID = river.readGUID();
                             }
                             ELevelObjectPlacementOrigin newPlacementOrigin = ELevelObjectPlacementOrigin.MANUAL;
                             if (b5 > 6)
                             {
                                 newPlacementOrigin = (ELevelObjectPlacementOrigin)river.readByte();
                             }
                             uint newInstanceID;
                             if (b5 > 8)
                             {
                                 newInstanceID = river.readUInt32();
                             }
                             else
                             {
                                 newInstanceID = LevelObjects.generateUniqueInstanceID();
                             }
                             if (num3 != 0)
                             {
                                 LevelObject levelObject = new LevelObject(vector, newRotation, newScale, num3, newName, newGUID, newPlacementOrigin, newInstanceID);
                                 if (levelObject.asset == null)
                                 {
                                     flag = false;
                                 }
                                 if (Level.isEditor)
                                 {
                                     byte b8;
                                     byte b9;
                                     Regions.tryGetCoordinate(vector, out b8, out b9);
                                     if (b8 != b6 || b9 != b7)
                                     {
                                         Debug.LogError(string.Concat(new object[]
                                         {
                                             num3,
                                             " should be in ",
                                             b8,
                                             ", ",
                                             b9,
                                             " but was in ",
                                             b6,
                                             ", ",
                                             b7,
                                             "!"
                                         }));
                                     }
                                     LevelObjects.objects[(int)b8, (int)b9].Add(levelObject);
                                 }
                                 else
                                 {
                                     LevelObjects.objects[(int)b6, (int)b7].Add(levelObject);
                                 }
                                 LevelObjects._total++;
                             }
                         }
                     }
                 }
             }
             if (flag)
             {
                 LevelObjects._hash = river.getHash();
             }
             else
             {
                 LevelObjects._hash = new byte[20];
             }
             river.closeRiver();
         }
         else
         {
             for (byte b10 = 0; b10 < Regions.WORLD_SIZE; b10 += 1)
             {
                 for (byte b11 = 0; b11 < Regions.WORLD_SIZE; b11 += 1)
                 {
                     if (ReadWrite.fileExists(string.Concat(new object[]
                     {
                         Level.info.path,
                         "/Objects/Objects_",
                         b10,
                         "_",
                         b11,
                         ".dat"
                     }), false, false))
                     {
                         River river2 = new River(string.Concat(new object[]
                         {
                             Level.info.path,
                             "/Objects/Objects_",
                             b10,
                             "_",
                             b11,
                             ".dat"
                         }), false);
                         byte b12 = river2.readByte();
                         if (b12 > 0)
                         {
                             ushort num4 = river2.readUInt16();
                             for (ushort num5 = 0; num5 < num4; num5 += 1)
                             {
                                 Vector3    position = river2.readSingleVector3();
                                 Quaternion rotation = river2.readSingleQuaternion();
                                 ushort     num6     = river2.readUInt16();
                                 string     empty    = string.Empty;
                                 Guid       empty2   = Guid.Empty;
                                 ELevelObjectPlacementOrigin placementOrigin = ELevelObjectPlacementOrigin.MANUAL;
                                 if (num6 != 0)
                                 {
                                     LevelObjects.addObject(position, rotation, Vector3.one, num6, empty, empty2, placementOrigin);
                                 }
                             }
                         }
                         river2.closeRiver();
                     }
                 }
             }
             LevelObjects._hash = new byte[20];
         }
     }
     else
     {
         LevelObjects._hash = new byte[20];
     }
     if ((Provider.isServer || Level.isEditor) && ReadWrite.fileExists(Level.info.path + "/Level/Buildables.dat", false, false))
     {
         River river3 = new River(Level.info.path + "/Level/Buildables.dat", false);
         river3.readByte();
         for (byte b13 = 0; b13 < Regions.WORLD_SIZE; b13 += 1)
         {
             for (byte b14 = 0; b14 < Regions.WORLD_SIZE; b14 += 1)
             {
                 ushort num7 = river3.readUInt16();
                 for (ushort num8 = 0; num8 < num7; num8 += 1)
                 {
                     Vector3    vector2      = river3.readSingleVector3();
                     Quaternion newRotation2 = river3.readSingleQuaternion();
                     ushort     num9         = river3.readUInt16();
                     if (num9 != 0)
                     {
                         LevelBuildableObject item = new LevelBuildableObject(vector2, newRotation2, num9);
                         if (Level.isEditor)
                         {
                             byte b15;
                             byte b16;
                             Regions.tryGetCoordinate(vector2, out b15, out b16);
                             if (b15 != b13 || b16 != b14)
                             {
                                 Debug.LogError(string.Concat(new object[]
                                 {
                                     num9,
                                     " should be in ",
                                     b15,
                                     ", ",
                                     b16,
                                     " but was in ",
                                     b13,
                                     ", ",
                                     b14,
                                     "!"
                                 }));
                             }
                             LevelObjects.buildables[(int)b15, (int)b16].Add(item);
                         }
                         else
                         {
                             LevelObjects.buildables[(int)b13, (int)b14].Add(item);
                         }
                         LevelObjects._total++;
                     }
                 }
             }
         }
         river3.closeRiver();
     }
     if (Level.info.configData.Use_Legacy_Objects && !Dedicator.isDedicated && !Level.isEditor)
     {
         for (byte b17 = 0; b17 < Regions.WORLD_SIZE; b17 += 1)
         {
             for (byte b18 = 0; b18 < Regions.WORLD_SIZE; b18 += 1)
             {
                 for (int i = 0; i < LevelObjects.objects[(int)b17, (int)b18].Count; i++)
                 {
                     LevelObject levelObject2 = LevelObjects.objects[(int)b17, (int)b18][i];
                     if (levelObject2.asset != null && !(levelObject2.transform == null))
                     {
                         if (levelObject2.asset.lod != EObjectLOD.NONE)
                         {
                             ObjectsLOD objectsLOD = levelObject2.transform.gameObject.AddComponent <ObjectsLOD>();
                             objectsLOD.lod    = levelObject2.asset.lod;
                             objectsLOD.bias   = levelObject2.asset.lodBias;
                             objectsLOD.center = levelObject2.asset.lodCenter;
                             objectsLOD.size   = levelObject2.asset.lodSize;
                             objectsLOD.calculateBounds();
                         }
                     }
                 }
             }
         }
     }
     if (Level.isEditor)
     {
         LevelObjects.reun  = new IReun[256];
         LevelObjects.step  = 0;
         LevelObjects.frame = 0;
     }
 }
Esempio n. 12
0
        public static void transformObject(Transform select, Vector3 toPosition, Quaternion toRotation, Vector3 toScale, Vector3 fromPosition, Quaternion fromRotation, Vector3 fromScale)
        {
            byte b;
            byte b2;

            if (Regions.tryGetCoordinate(fromPosition, out b, out b2))
            {
                byte b3;
                byte b4;
                if (Regions.tryGetCoordinate(toPosition, out b3, out b4))
                {
                    LevelObject levelObject = null;
                    int         index       = -1;
                    for (int i = 0; i < LevelObjects.objects[(int)b, (int)b2].Count; i++)
                    {
                        if (LevelObjects.objects[(int)b, (int)b2][i].transform == select)
                        {
                            levelObject = LevelObjects.objects[(int)b, (int)b2][i];
                            index       = i;
                            break;
                        }
                    }
                    if (levelObject != null)
                    {
                        if (b != b3 || b2 != b4)
                        {
                            LevelObjects.objects[(int)b, (int)b2].RemoveAt(index);
                            LevelObjects.objects[(int)b3, (int)b4].Add(levelObject);
                        }
                        if (levelObject.transform != null)
                        {
                            levelObject.transform.position   = toPosition;
                            levelObject.transform.rotation   = toRotation;
                            levelObject.transform.localScale = toScale;
                        }
                        if (levelObject.skybox != null)
                        {
                            levelObject.skybox.position   = toPosition;
                            levelObject.skybox.rotation   = toRotation;
                            levelObject.skybox.localScale = toScale;
                        }
                    }
                    else
                    {
                        LevelBuildableObject levelBuildableObject = null;
                        int index2 = -1;
                        for (int j = 0; j < LevelObjects.buildables[(int)b, (int)b2].Count; j++)
                        {
                            if (LevelObjects.buildables[(int)b, (int)b2][j].transform == select)
                            {
                                levelBuildableObject = LevelObjects.buildables[(int)b, (int)b2][j];
                                index2 = j;
                                break;
                            }
                        }
                        if (levelBuildableObject != null)
                        {
                            if (b != b3 || b2 != b4)
                            {
                                LevelObjects.buildables[(int)b, (int)b2].RemoveAt(index2);
                                LevelObjects.buildables[(int)b3, (int)b4].Add(levelBuildableObject);
                            }
                            if (levelBuildableObject.transform != null)
                            {
                                levelBuildableObject.transform.position = toPosition;
                                levelBuildableObject.transform.rotation = toRotation;
                            }
                        }
                        else
                        {
                            select.position   = fromPosition;
                            select.rotation   = fromRotation;
                            select.localScale = fromScale;
                        }
                    }
                }
                else
                {
                    select.position   = fromPosition;
                    select.rotation   = fromRotation;
                    select.localScale = fromScale;
                }
            }
            else
            {
                select.position   = fromPosition;
                select.rotation   = fromRotation;
                select.localScale = fromScale;
            }
        }
Esempio n. 13
0
 public static void load()
 {
     LevelNodes._models                 = new GameObject().transform;
     LevelNodes.models.name             = "Nodes";
     LevelNodes.models.parent           = Level.level;
     LevelNodes.models.tag              = "Logic";
     LevelNodes.models.gameObject.layer = LayerMasks.LOGIC;
     LevelNodes._nodes = new List <Node>();
     if (ReadWrite.fileExists(Level.info.path + "/Environment/Nodes.dat", false, false))
     {
         River river = new River(Level.info.path + "/Environment/Nodes.dat", false);
         byte  b     = river.readByte();
         if (b > 0)
         {
             ushort num = (ushort)river.readByte();
             for (ushort num2 = 0; num2 < num; num2 += 1)
             {
                 Vector3   vector    = river.readSingleVector3();
                 ENodeType enodeType = (ENodeType)river.readByte();
                 if (enodeType == ENodeType.LOCATION)
                 {
                     string newName = river.readString();
                     LevelNodes.nodes.Add(new LocationNode(vector, newName));
                 }
                 else if (enodeType == ENodeType.SAFEZONE)
                 {
                     float newRadius = river.readSingle();
                     bool  newHeight = false;
                     if (b > 1)
                     {
                         newHeight = river.readBoolean();
                     }
                     bool newNoWeapons = true;
                     if (b > 4)
                     {
                         newNoWeapons = river.readBoolean();
                     }
                     bool newNoBuildables = true;
                     if (b > 4)
                     {
                         newNoBuildables = river.readBoolean();
                     }
                     LevelNodes.nodes.Add(new SafezoneNode(vector, newRadius, newHeight, newNoWeapons, newNoBuildables));
                 }
                 else if (enodeType == ENodeType.PURCHASE)
                 {
                     float  newRadius2 = river.readSingle();
                     ushort newID      = river.readUInt16();
                     uint   newCost    = river.readUInt32();
                     LevelNodes.nodes.Add(new PurchaseNode(vector, newRadius2, newID, newCost));
                 }
                 else if (enodeType == ENodeType.ARENA)
                 {
                     float newRadius3 = river.readSingle();
                     LevelNodes.nodes.Add(new ArenaNode(vector, newRadius3));
                 }
                 else if (enodeType == ENodeType.DEADZONE)
                 {
                     float newRadius4 = river.readSingle();
                     LevelNodes.nodes.Add(new DeadzoneNode(vector, newRadius4));
                 }
                 else if (enodeType == ENodeType.AIRDROP)
                 {
                     ushort num3 = river.readUInt16();
                     byte   b2;
                     byte   b3;
                     if (SpawnTableTool.resolve(num3) == 0 && Regions.tryGetCoordinate(vector, out b2, out b3))
                     {
                         Assets.errors.Add(string.Concat(new object[]
                         {
                             Level.info.name,
                             " airdrop references invalid spawn table ",
                             num3,
                             " at (",
                             b2,
                             ", ",
                             b3,
                             ")!"
                         }));
                     }
                     LevelNodes.nodes.Add(new AirdropNode(vector, num3));
                 }
                 else if (enodeType == ENodeType.EFFECT)
                 {
                     byte newShape = 0;
                     if (b > 2)
                     {
                         newShape = river.readByte();
                     }
                     float   newRadius5 = river.readSingle();
                     Vector3 newBounds  = Vector3.one;
                     if (b > 2)
                     {
                         newBounds = river.readSingleVector3();
                     }
                     ushort newID2        = river.readUInt16();
                     bool   newNoWater    = river.readBoolean();
                     bool   newNoLighting = false;
                     if (b > 3)
                     {
                         newNoLighting = river.readBoolean();
                     }
                     LevelNodes.nodes.Add(new EffectNode(vector, (ENodeShape)newShape, newRadius5, newBounds, newID2, newNoWater, newNoLighting));
                 }
             }
         }
         river.closeRiver();
     }
 }
Esempio n. 14
0
 private void Update()
 {
     if (!this.isBuilding)
     {
         return;
     }
     this.ray = MainCamera.instance.ScreenPointToRay(Input.mousePosition);
     Physics.Raycast(this.ray, ref this.worldHit, 256f, RayMasks.EDITOR_WORLD);
     Physics.Raycast(this.ray, ref this.buildableHit, 256f, RayMasks.EDITOR_BUILDABLE);
     Physics.Raycast(this.ray, ref this.logicHit, 256f, RayMasks.VIEWMODEL);
     if (GUIUtility.hotControl == 0)
     {
         if (Input.GetKey(ControlsSettings.secondary))
         {
             this.handleType = EDragType.NONE;
             if (this.isDragging)
             {
                 this._dragStart  = Vector2.zero;
                 this._dragEnd    = Vector2.zero;
                 this._isDragging = false;
                 if (this.onDragStopped != null)
                 {
                     this.onDragStopped();
                 }
                 this.clearSelection();
             }
             return;
         }
         if (this.handleType != EDragType.NONE)
         {
             if (!Input.GetKey(ControlsSettings.primary))
             {
                 this.applySelection();
                 this.handleType = EDragType.NONE;
             }
             else
             {
                 if (this.handleType == EDragType.TRANSFORM_X)
                 {
                     this.transformGroup(this.handle.right, this.handle.up);
                 }
                 else if (this.handleType == EDragType.TRANSFORM_Y)
                 {
                     this.transformGroup(this.handle.up, this.handle.right);
                 }
                 else if (this.handleType == EDragType.TRANSFORM_Z)
                 {
                     this.transformGroup(this.handle.forward, this.handle.up);
                 }
                 else if (this.handleType == EDragType.PLANE_X)
                 {
                     this.planeGroup(this.handle.right);
                 }
                 else if (this.handleType == EDragType.PLANE_Y)
                 {
                     this.planeGroup(this.handle.up);
                 }
                 else if (this.handleType == EDragType.PLANE_Z)
                 {
                     this.planeGroup(this.handle.forward);
                 }
                 if (this.handleType == EDragType.ROTATION_X)
                 {
                     this.rotateGroup(this.handle.right, Vector3.right);
                 }
                 else if (this.handleType == EDragType.ROTATION_Y)
                 {
                     this.rotateGroup(this.handle.up, Vector3.up);
                 }
                 else if (this.handleType == EDragType.ROTATION_Z)
                 {
                     this.rotateGroup(this.handle.forward, Vector3.forward);
                 }
             }
         }
         if (Input.GetKeyDown(ControlsSettings.tool_0))
         {
             this.dragMode = EDragMode.TRANSFORM;
         }
         if (Input.GetKeyDown(ControlsSettings.tool_1))
         {
             this.dragMode = EDragMode.ROTATE;
         }
         if (Input.GetKeyDown(98) && this.selection.Count > 0 && Input.GetKey(306))
         {
             this.copyPosition = this.handle.position;
             this.copyRotation = this.handle.rotation;
         }
         if (Input.GetKeyDown(110) && this.selection.Count > 0 && this.copyPosition != Vector3.zero && Input.GetKey(306))
         {
             this.pointSelection();
             this.handle.position = this.copyPosition;
             this.handle.rotation = this.copyRotation;
             this.updateGroup();
             this.applySelection();
         }
         if (this.handleType == EDragType.NONE)
         {
             if (Input.GetKeyDown(ControlsSettings.primary))
             {
                 if (this.logicHit.transform != null && (this.logicHit.transform.name == "Arrow_X" || this.logicHit.transform.name == "Arrow_Y" || this.logicHit.transform.name == "Arrow_Z" || this.logicHit.transform.name == "Plane_X" || this.logicHit.transform.name == "Plane_Y" || this.logicHit.transform.name == "Plane_Z" || this.logicHit.transform.name == "Circle_X" || this.logicHit.transform.name == "Circle_Y" || this.logicHit.transform.name == "Circle_Z"))
                 {
                     this.mouseOrigin     = Input.mousePosition;
                     this.transformOrigin = this.handle.position;
                     this.rotateOrigin    = this.handle.rotation;
                     this.handleOffset    = this.logicHit.point - this.handle.position;
                     this.pointSelection();
                     if (this.logicHit.transform.name == "Arrow_X")
                     {
                         this.handleType = EDragType.TRANSFORM_X;
                     }
                     else if (this.logicHit.transform.name == "Arrow_Y")
                     {
                         this.handleType = EDragType.TRANSFORM_Y;
                     }
                     else if (this.logicHit.transform.name == "Arrow_Z")
                     {
                         this.handleType = EDragType.TRANSFORM_Z;
                     }
                     else if (this.logicHit.transform.name == "Plane_X")
                     {
                         this.handleType = EDragType.PLANE_X;
                     }
                     else if (this.logicHit.transform.name == "Plane_Y")
                     {
                         this.handleType = EDragType.PLANE_Y;
                     }
                     else if (this.logicHit.transform.name == "Plane_Z")
                     {
                         this.handleType = EDragType.PLANE_Z;
                     }
                     else if (this.logicHit.transform.name == "Circle_X")
                     {
                         this.rotateInverted = (Vector3.Dot(this.logicHit.point - this.handle.position, MainCamera.instance.transform.up) < 0f);
                         this.handleType     = EDragType.ROTATION_X;
                     }
                     else if (this.logicHit.transform.name == "Circle_Y")
                     {
                         this.rotateInverted = (Vector3.Dot(this.logicHit.point - this.handle.position, MainCamera.instance.transform.up) < 0f);
                         this.handleType     = EDragType.ROTATION_Y;
                     }
                     else if (this.logicHit.transform.name == "Circle_Z")
                     {
                         this.rotateInverted = (Vector3.Dot(this.logicHit.point - this.handle.position, MainCamera.instance.transform.up) < 0f);
                         this.handleType     = EDragType.ROTATION_Z;
                     }
                 }
                 else
                 {
                     Transform transform = this.buildableHit.transform;
                     if (transform != null && (transform.CompareTag("Barricade") || transform.CompareTag("Structure")))
                     {
                         InteractableDoorHinge component = transform.GetComponent <InteractableDoorHinge>();
                         if (component != null)
                         {
                             transform = component.transform.parent.parent;
                         }
                         if (Input.GetKey(ControlsSettings.modify))
                         {
                             if (this.containsSelection(transform))
                             {
                                 this.removeSelection(transform);
                             }
                             else
                             {
                                 this.addSelection(transform);
                             }
                         }
                         else if (this.containsSelection(transform))
                         {
                             this.clearSelection();
                         }
                         else
                         {
                             this.clearSelection();
                             this.addSelection(transform);
                         }
                     }
                     else
                     {
                         if (!this.isDragging)
                         {
                             this._dragStart.x = PlayerUI.window.mouse_x;
                             this._dragStart.y = PlayerUI.window.mouse_y;
                         }
                         if (!Input.GetKey(ControlsSettings.modify))
                         {
                             this.clearSelection();
                         }
                     }
                 }
             }
             else if (Input.GetKey(ControlsSettings.primary) && this.dragStart.x != 0f)
             {
                 this._dragEnd.x = PlayerUI.window.mouse_x;
                 this._dragEnd.y = PlayerUI.window.mouse_y;
                 if (this.isDragging || Mathf.Abs(this.dragEnd.x - this.dragStart.x) > 50f || Mathf.Abs(this.dragEnd.x - this.dragStart.x) > 50f)
                 {
                     int num  = (int)this.dragStart.x;
                     int num2 = (int)this.dragStart.y;
                     if (this.dragEnd.x < this.dragStart.x)
                     {
                         num = (int)this.dragEnd.x;
                     }
                     if (this.dragEnd.y < this.dragStart.y)
                     {
                         num2 = (int)this.dragEnd.y;
                     }
                     int num3 = (int)this.dragEnd.x;
                     int num4 = (int)this.dragEnd.y;
                     if (this.dragStart.x > this.dragEnd.x)
                     {
                         num3 = (int)this.dragStart.x;
                     }
                     if (this.dragStart.y > this.dragEnd.y)
                     {
                         num4 = (int)this.dragStart.y;
                     }
                     if (this.onDragStarted != null)
                     {
                         this.onDragStarted(num, num2, num3, num4);
                     }
                     if (!this.isDragging)
                     {
                         this._isDragging = true;
                         this.dragable.Clear();
                         byte region_x = Player.player.movement.region_x;
                         byte region_y = Player.player.movement.region_y;
                         if (Regions.checkSafe((int)region_x, (int)region_y))
                         {
                             for (int i = 0; i < BarricadeManager.plants.Count; i++)
                             {
                                 BarricadeRegion barricadeRegion = BarricadeManager.plants[i];
                                 for (int j = 0; j < barricadeRegion.drops.Count; j++)
                                 {
                                     BarricadeDrop barricadeDrop = barricadeRegion.drops[j];
                                     if (!(barricadeDrop.model == null))
                                     {
                                         Vector3 newScreen = MainCamera.instance.WorldToScreenPoint(barricadeDrop.model.position);
                                         if (newScreen.z >= 0f)
                                         {
                                             newScreen.y = (float)Screen.height - newScreen.y;
                                             this.dragable.Add(new EditorDrag(barricadeDrop.model, newScreen));
                                         }
                                     }
                                 }
                             }
                             for (int k = (int)(region_x - 1); k <= (int)(region_x + 1); k++)
                             {
                                 for (int l = (int)(region_y - 1); l <= (int)(region_y + 1); l++)
                                 {
                                     if (Regions.checkSafe((int)((byte)k), (int)((byte)l)))
                                     {
                                         for (int m = 0; m < BarricadeManager.regions[k, l].drops.Count; m++)
                                         {
                                             BarricadeDrop barricadeDrop2 = BarricadeManager.regions[k, l].drops[m];
                                             if (!(barricadeDrop2.model == null))
                                             {
                                                 Vector3 newScreen2 = MainCamera.instance.WorldToScreenPoint(barricadeDrop2.model.position);
                                                 if (newScreen2.z >= 0f)
                                                 {
                                                     newScreen2.y = (float)Screen.height - newScreen2.y;
                                                     this.dragable.Add(new EditorDrag(barricadeDrop2.model, newScreen2));
                                                 }
                                             }
                                         }
                                         for (int n = 0; n < StructureManager.regions[k, l].drops.Count; n++)
                                         {
                                             StructureDrop structureDrop = StructureManager.regions[k, l].drops[n];
                                             if (structureDrop != null)
                                             {
                                                 Vector3 newScreen3 = MainCamera.instance.WorldToScreenPoint(structureDrop.model.position);
                                                 if (newScreen3.z >= 0f)
                                                 {
                                                     newScreen3.y = (float)Screen.height - newScreen3.y;
                                                     this.dragable.Add(new EditorDrag(structureDrop.model, newScreen3));
                                                 }
                                             }
                                         }
                                     }
                                 }
                             }
                         }
                     }
                     if (!Input.GetKey(ControlsSettings.modify))
                     {
                         for (int num5 = 0; num5 < this.selection.Count; num5++)
                         {
                             if (!(this.selection[num5].transform == null))
                             {
                                 Vector3 vector = MainCamera.instance.WorldToScreenPoint(this.selection[num5].transform.position);
                                 if (vector.z < 0f)
                                 {
                                     this.removeSelection(this.selection[num5].transform);
                                 }
                                 else
                                 {
                                     vector.y = (float)Screen.height - vector.y;
                                     if (vector.x < (float)num || vector.y < (float)num2 || vector.x > (float)num3 || vector.y > (float)num4)
                                     {
                                         this.removeSelection(this.selection[num5].transform);
                                     }
                                 }
                             }
                         }
                     }
                     for (int num6 = 0; num6 < this.dragable.Count; num6++)
                     {
                         EditorDrag editorDrag = this.dragable[num6];
                         if (!(editorDrag.transform == null))
                         {
                             if (!(editorDrag.transform.parent == this.group))
                             {
                                 if (editorDrag.screen.x >= (float)num && editorDrag.screen.y >= (float)num2 && editorDrag.screen.x <= (float)num3 && editorDrag.screen.y <= (float)num4)
                                 {
                                     this.addSelection(editorDrag.transform);
                                 }
                             }
                         }
                     }
                 }
             }
             if (this.selection.Count > 0 && Input.GetKeyDown(ControlsSettings.tool_2) && this.worldHit.transform != null)
             {
                 this.pointSelection();
                 this.handle.position = this.worldHit.point;
                 if (Input.GetKey(ControlsSettings.snap))
                 {
                     this.handle.position += this.worldHit.normal * this.snapTransform;
                 }
                 this.updateGroup();
                 this.applySelection();
             }
         }
     }
     if (Input.GetKeyUp(ControlsSettings.primary) && this.dragStart.x != 0f)
     {
         this._dragStart = Vector2.zero;
         if (this.isDragging)
         {
             this._dragEnd    = Vector2.zero;
             this._isDragging = false;
             if (this.onDragStopped != null)
             {
                 this.onDragStopped();
             }
         }
     }
 }
Esempio n. 15
0
        public static void explode(Vector3 point, float damageRadius, EDeathCause cause, CSteamID killer, float playerDamage, float zombieDamage, float animalDamage, float barricadeDamage, float structureDamage, float vehicleDamage, float resourceDamage, float objectDamage, EExplosionDamageType damageType = EExplosionDamageType.CONVENTIONAL, float alertRadius = 32f, bool playImpactEffect = true)
        {
            DamageTool.explosionRangeComparator.point = point;
            float num = damageRadius * damageRadius;

            DamageTool.regionsInRadius.Clear();
            Regions.getRegionsInRadius(point, damageRadius, DamageTool.regionsInRadius);
            if (structureDamage > 0.5f)
            {
                DamageTool.structuresInRadius.Clear();
                StructureManager.getStructuresInRadius(point, num, DamageTool.regionsInRadius, DamageTool.structuresInRadius);
                DamageTool.structuresInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int i = 0; i < DamageTool.structuresInRadius.Count; i++)
                {
                    Transform transform = DamageTool.structuresInRadius[i];
                    if (!(transform == null))
                    {
                        ushort id;
                        if (ushort.TryParse(transform.name, out id))
                        {
                            ItemStructureAsset itemStructureAsset = (ItemStructureAsset)Assets.find(EAssetType.ITEM, id);
                            if (itemStructureAsset != null && !itemStructureAsset.proofExplosion)
                            {
                                Vector3 vector    = transform.transform.position - point;
                                float   magnitude = vector.magnitude;
                                Vector3 vector2   = vector / magnitude;
                                if (magnitude > 0.5f)
                                {
                                    RaycastHit raycastHit;
                                    PhysicsUtility.raycast(new Ray(point, vector2), out raycastHit, magnitude - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                                    if (raycastHit.transform != null && raycastHit.transform != transform.transform)
                                    {
                                        goto IL_154;
                                    }
                                }
                                StructureManager.damage(transform, vector.normalized, structureDamage, 1f - magnitude / damageRadius, true);
                            }
                        }
                    }
                    IL_154 :;
                }
            }
            if (resourceDamage > 0.5f)
            {
                DamageTool.resourcesInRadius.Clear();
                ResourceManager.getResourcesInRadius(point, num, DamageTool.regionsInRadius, DamageTool.resourcesInRadius);
                DamageTool.resourcesInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int j = 0; j < DamageTool.resourcesInRadius.Count; j++)
                {
                    Transform transform2 = DamageTool.resourcesInRadius[j];
                    if (!(transform2 == null))
                    {
                        Vector3 vector3    = transform2.transform.position - point;
                        float   magnitude2 = vector3.magnitude;
                        Vector3 vector4    = vector3 / magnitude2;
                        if (magnitude2 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, vector4), out raycastHit, magnitude2 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                            if (raycastHit.transform != null && raycastHit.transform != transform2.transform)
                            {
                                goto IL_26D;
                            }
                        }
                        EPlayerKill eplayerKill;
                        uint        num2;
                        ResourceManager.damage(transform2, vector3.normalized, resourceDamage, 1f - magnitude2 / damageRadius, 1f, out eplayerKill, out num2);
                    }
                    IL_26D :;
                }
            }
            if (objectDamage > 0.5f)
            {
                DamageTool.objectsInRadius.Clear();
                ObjectManager.getObjectsInRadius(point, num, DamageTool.regionsInRadius, DamageTool.objectsInRadius);
                DamageTool.objectsInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int k = 0; k < DamageTool.objectsInRadius.Count; k++)
                {
                    Transform transform3 = DamageTool.objectsInRadius[k];
                    if (!(transform3 == null))
                    {
                        InteractableObjectRubble component = transform3.GetComponent <InteractableObjectRubble>();
                        if (!(component == null))
                        {
                            if (!component.asset.rubbleProofExplosion)
                            {
                                for (byte b = 0; b < component.getSectionCount(); b += 1)
                                {
                                    Transform section = component.getSection(b);
                                    Vector3   vector5 = section.position - point;
                                    if (vector5.sqrMagnitude < num)
                                    {
                                        float   magnitude3 = vector5.magnitude;
                                        Vector3 vector6    = vector5 / magnitude3;
                                        if (magnitude3 > 0.5f)
                                        {
                                            RaycastHit raycastHit;
                                            PhysicsUtility.raycast(new Ray(point, vector6), out raycastHit, magnitude3 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                                            if (raycastHit.transform != null && raycastHit.transform != transform3.transform)
                                            {
                                                goto IL_3CA;
                                            }
                                        }
                                        EPlayerKill eplayerKill;
                                        uint        num2;
                                        ObjectManager.damage(transform3, vector5.normalized, b, objectDamage, 1f - magnitude3 / damageRadius, out eplayerKill, out num2);
                                    }
                                    IL_3CA :;
                                }
                            }
                        }
                    }
                }
            }
            if (barricadeDamage > 0.5f)
            {
                DamageTool.barricadesInRadius.Clear();
                BarricadeManager.getBarricadesInRadius(point, num, DamageTool.regionsInRadius, DamageTool.barricadesInRadius);
                BarricadeManager.getBarricadesInRadius(point, num, DamageTool.barricadesInRadius);
                DamageTool.barricadesInRadius.Sort(DamageTool.explosionRangeComparator);
                for (int l = 0; l < DamageTool.barricadesInRadius.Count; l++)
                {
                    Transform transform4 = DamageTool.barricadesInRadius[l];
                    if (!(transform4 == null))
                    {
                        Vector3 vector7    = transform4.transform.position - point;
                        float   magnitude4 = vector7.magnitude;
                        Vector3 vector8    = vector7 / magnitude4;
                        if (magnitude4 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, vector8), out raycastHit, magnitude4 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                            if (raycastHit.transform != null && raycastHit.transform != transform4.transform)
                            {
                                goto IL_52A;
                            }
                        }
                        ushort id2;
                        if (ushort.TryParse(transform4.name, out id2))
                        {
                            ItemBarricadeAsset itemBarricadeAsset = (ItemBarricadeAsset)Assets.find(EAssetType.ITEM, id2);
                            if (itemBarricadeAsset != null && !itemBarricadeAsset.proofExplosion)
                            {
                                BarricadeManager.damage(transform4, barricadeDamage, 1f - magnitude4 / damageRadius, true);
                            }
                        }
                    }
                    IL_52A :;
                }
            }
            if ((Provider.isPvP || damageType == EExplosionDamageType.ZOMBIE_ACID || damageType == EExplosionDamageType.ZOMBIE_FIRE || damageType == EExplosionDamageType.ZOMBIE_ELECTRIC) && playerDamage > 0.5f)
            {
                DamageTool.playersInRadius.Clear();
                PlayerTool.getPlayersInRadius(point, num, DamageTool.playersInRadius);
                for (int m = 0; m < DamageTool.playersInRadius.Count; m++)
                {
                    Player player = DamageTool.playersInRadius[m];
                    if (!(player == null) && !player.life.isDead)
                    {
                        if (damageType != EExplosionDamageType.ZOMBIE_FIRE || player.clothing.shirtAsset == null || !player.clothing.shirtAsset.proofFire || player.clothing.pantsAsset == null || !player.clothing.pantsAsset.proofFire)
                        {
                            Vector3 vector9    = player.transform.position - point;
                            float   magnitude5 = vector9.magnitude;
                            Vector3 vector10   = vector9 / magnitude5;
                            if (magnitude5 > 0.5f)
                            {
                                RaycastHit raycastHit;
                                PhysicsUtility.raycast(new Ray(point, vector10), out raycastHit, magnitude5 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                                if (raycastHit.transform != null && raycastHit.transform != player.transform)
                                {
                                    goto IL_760;
                                }
                            }
                            if (playImpactEffect)
                            {
                                EffectManager.sendEffect(5, EffectManager.SMALL, player.transform.position + Vector3.up, -vector10);
                                EffectManager.sendEffect(5, EffectManager.SMALL, player.transform.position + Vector3.up, Vector3.up);
                            }
                            float num3 = 1f - Mathf.Pow(magnitude5 / damageRadius, 2f);
                            if (player.movement.getVehicle() != null && player.movement.getVehicle().asset != null)
                            {
                                num3 *= player.movement.getVehicle().asset.passengerExplosionArmor;
                            }
                            EPlayerKill eplayerKill;
                            DamageTool.damage(player, cause, ELimb.SPINE, killer, vector10, playerDamage, num3, out eplayerKill);
                        }
                    }
                    IL_760 :;
                }
            }
            if (damageType == EExplosionDamageType.ZOMBIE_FIRE || zombieDamage > 0.5f)
            {
                DamageTool.zombiesInRadius.Clear();
                ZombieManager.getZombiesInRadius(point, num, DamageTool.zombiesInRadius);
                for (int n = 0; n < DamageTool.zombiesInRadius.Count; n++)
                {
                    Zombie zombie = DamageTool.zombiesInRadius[n];
                    if (!(zombie == null) && !zombie.isDead)
                    {
                        if (damageType == EExplosionDamageType.ZOMBIE_FIRE)
                        {
                            if (zombie.speciality == EZombieSpeciality.NORMAL)
                            {
                                ZombieManager.sendZombieSpeciality(zombie, EZombieSpeciality.BURNER);
                            }
                        }
                        else
                        {
                            Vector3 vector11   = zombie.transform.position - point;
                            float   magnitude6 = vector11.magnitude;
                            Vector3 vector12   = vector11 / magnitude6;
                            if (magnitude6 > 0.5f)
                            {
                                RaycastHit raycastHit;
                                PhysicsUtility.raycast(new Ray(point, vector12), out raycastHit, magnitude6 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                                if (raycastHit.transform != null && raycastHit.transform != zombie.transform)
                                {
                                    goto IL_90E;
                                }
                            }
                            if (playImpactEffect)
                            {
                                EffectManager.sendEffect((!zombie.isRadioactive) ? 5 : 95, EffectManager.SMALL, zombie.transform.position + Vector3.up, -vector12);
                                EffectManager.sendEffect((!zombie.isRadioactive) ? 5 : 95, EffectManager.SMALL, zombie.transform.position + Vector3.up, Vector3.up);
                            }
                            EPlayerKill eplayerKill;
                            uint        num2;
                            DamageTool.damage(zombie, vector12, zombieDamage, 1f - magnitude6 / damageRadius, out eplayerKill, out num2);
                        }
                    }
                    IL_90E :;
                }
            }
            if (animalDamage > 0.5f)
            {
                DamageTool.animalsInRadius.Clear();
                AnimalManager.getAnimalsInRadius(point, num, DamageTool.animalsInRadius);
                for (int num4 = 0; num4 < DamageTool.animalsInRadius.Count; num4++)
                {
                    Animal animal = DamageTool.animalsInRadius[num4];
                    if (!(animal == null) && !animal.isDead)
                    {
                        Vector3 vector13   = animal.transform.position - point;
                        float   magnitude7 = vector13.magnitude;
                        Vector3 vector14   = vector13 / magnitude7;
                        if (magnitude7 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, vector14), out raycastHit, magnitude7 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                            if (raycastHit.transform != null && raycastHit.transform != animal.transform)
                            {
                                goto IL_A6A;
                            }
                        }
                        if (playImpactEffect)
                        {
                            EffectManager.sendEffect(5, EffectManager.SMALL, animal.transform.position + Vector3.up, -vector14);
                            EffectManager.sendEffect(5, EffectManager.SMALL, animal.transform.position + Vector3.up, Vector3.up);
                        }
                        EPlayerKill eplayerKill;
                        uint        num2;
                        DamageTool.damage(animal, vector14, animalDamage, 1f - magnitude7 / damageRadius, out eplayerKill, out num2);
                    }
                    IL_A6A :;
                }
            }
            if (vehicleDamage > 0.5f)
            {
                DamageTool.vehiclesInRadius.Clear();
                VehicleManager.getVehiclesInRadius(point, num, DamageTool.vehiclesInRadius);
                for (int num5 = 0; num5 < DamageTool.vehiclesInRadius.Count; num5++)
                {
                    InteractableVehicle interactableVehicle = DamageTool.vehiclesInRadius[num5];
                    if (!(interactableVehicle == null) && !interactableVehicle.isDead)
                    {
                        Vector3 vector15   = interactableVehicle.transform.position - point;
                        float   magnitude8 = vector15.magnitude;
                        Vector3 vector16   = vector15 / magnitude8;
                        if (magnitude8 > 0.5f)
                        {
                            RaycastHit raycastHit;
                            PhysicsUtility.raycast(new Ray(point, vector16), out raycastHit, magnitude8 - 0.5f, RayMasks.BLOCK_EXPLOSION, 0);
                            if (raycastHit.transform != null && raycastHit.transform != interactableVehicle.transform)
                            {
                                goto IL_B6C;
                            }
                        }
                        VehicleManager.damage(interactableVehicle, vehicleDamage, 1f - magnitude8 / damageRadius, false);
                    }
                    IL_B6C :;
                }
            }
            AlertTool.alert(point, alertRadius);
        }