示例#1
0
 public DestructionRequest(IUser user, string filter, uint radius, Vector3 position, WreckType wreckType, ulong steamID, ushort itemID)
 {
     User         = user;
     Filters      = filter.ToCharArray();
     Radius       = radius;
     Position     = position;
     WreckType    = wreckType;
     SteamID      = steamID;
     ItemID       = itemID;
     RequestAdded = DateTime.Now;
 }
示例#2
0
 internal static void Abort(WreckType type)
 {
     if (type == WreckType.Wreck)
     {
         processing = false;
         destroyList.Clear();
         dIdx           = 0;
         dIdxCount      = 0;
         originalCaller = null;
     }
     else
     {
         cleanupProcessingBuildables = false;
         cleanupProcessingFiles      = false;
         cleanupList.Clear();
         cdIdx      = 0;
         cdIdxCount = 0;
         playersListBuildables.Clear();
         playersListFiles.Clear();
         plbIdx = 0;
         plfIdx = 0;
     }
 }
示例#3
0
        internal static void DestructionLoop(WreckType type)
        {
            try
            {
                int         i = 0;
                EPlayerKill pKill;
                uint        xp;
                while (((dIdx < dIdxCount && type == WreckType.Wreck) || (cdIdx < cdIdxCount && type == WreckType.Cleanup)) && i < WreckingBall.Instance.Configuration.Instance.DestructionsPerInterval)
                {
                    Destructible element = type == WreckType.Wreck ? destroyList[dIdx] : cleanupList[cdIdx];

                    if (element.Type == ElementType.Structure)
                    {
                        try
                        {
                            if (WreckingBall.Instance.Configuration.Instance.EnableDestroyedElementDrop)
                            {
                                try
                                {
                                    Item item = new Item(element.ItemID, true);
                                    ItemManager.dropItem(item, element.Transform.position, false, true, true);
                                }
                                catch (Exception ex) { Logger.LogException(ex, "Error in dropping an item for a destroyed structure."); }
                            }
                            StructureManager.damage(element.Transform, element.Transform.position, ushort.MaxValue, 1, false);
                        }
                        catch (Exception ex) { Logger.LogException(ex, "Error in destroying structure."); }
                    }

                    else if (element.Type == ElementType.Barricade || element.Type == ElementType.VehicleBarricade)
                    {
                        try
                        {
                            if ((element.Type == ElementType.VehicleBarricade && WreckingBall.Instance.Configuration.Instance.EnableVehicleElementDrop) || (element.Type == ElementType.Barricade && WreckingBall.Instance.Configuration.Instance.EnableDestroyedElementDrop))
                            {
                                try
                                {
                                    Item item = new Item(element.ItemID, true);
                                    ItemManager.dropItem(item, element.Transform.position, false, true, true);
                                }
                                catch (Exception ex) { Logger.LogException(ex, "Error in dropping an item for a destroyed" + (element.Type == ElementType.VehicleBarricade ? " vehicle" : string.Empty) + " barricade."); }
                            }
                            BarricadeManager.damage(element.Transform, ushort.MaxValue, 1, false);
                        }
                        catch (Exception ex) { Logger.LogException(ex, "Error in destroying barricade."); }
                    }

                    else if (element.Type == ElementType.Vehicle)
                    {
                        try {
                            // Output log entry if a vehicle is destroyed by a cleanup.
                            if (type == WreckType.Cleanup)
                            {
                                bool getPInfo = WreckingBall.isPlayerInfoLibLoaded;
                                Logger.Log(string.Format("Cleanup: Vehicle with InstanceID: {0}, and Type: {1}({2}), at position: {3} destroyed, Element count: {4}, Sign By: {5}, Locked By: {6}.",
                                                         element.Vehicle.instanceID,
                                                         element.Vehicle.asset.vehicleName,
                                                         element.Vehicle.asset.id,
                                                         element.Vehicle.transform.position.ToString(),
                                                         BarricadeManager.tryGetPlant(element.Vehicle.transform, out byte x, out byte y, out ushort plant, out BarricadeRegion barricadeRegion) ? barricadeRegion.drops.Count : 0,
                                                         HasFlaggedElement(element.Vehicle.transform, out ulong vFlagOwner) ? (getPInfo ? WreckingBall.Instance.PInfoGenerateMessage(vFlagOwner) : vFlagOwner.ToString()) : "N/A",
                                                         element.Vehicle.isLocked ? (getPInfo ? WreckingBall.Instance.PInfoGenerateMessage((ulong)element.Vehicle.lockedOwner) : element.Vehicle.lockedOwner.ToString()) : "N/A"));
                            }
                            if (WreckingBall.Instance.Configuration.Instance.EnableVehicleElementDrop)
                            {
                                if (element.Vehicle.asset.engine == EEngine.TRAIN && element.Vehicle.trainCars != null && element.Vehicle.trainCars.Count() > 1)
                                {
                                    foreach (TrainCar car in element.Vehicle.trainCars)
                                    {
                                        WreckingBall.Instance.VehicleElementDrop(element.Vehicle, true, car.root);
                                    }
                                }
                                else
                                {
                                    WreckingBall.Instance.VehicleElementDrop(element.Vehicle);
                                }
                            }
                            if (!element.Vehicle.isDead)
                            {
                                element.Vehicle.askDamage(ushort.MaxValue, false);
                            }
                        }
                        catch (Exception ex) { Logger.LogException(ex, "Error in destroying vehicle."); }
                    }
                    else if (element.Type == ElementType.Zombie)
                    {
                        try
                        {
                            for (int z = 0; z < 1000 && !element.Zombie.isDead; z++)
                            {
                                element.Zombie.askDamage(ushort.MaxValue, element.Zombie.transform.up, out pKill, out xp);
                            }
                        }
                        catch (Exception ex) { Logger.LogException(ex, "Error in killing zombie."); }
                    }
                    else if (element.Type == ElementType.Animal)
                    {
                        try
                        {
                            for (int a = 0; a < 1000 && !element.Animal.isDead; a++)
                            {
                                element.Animal.askDamage(ushort.MaxValue, element.Animal.transform.up, out pKill, out xp);
                            }
                        }
                        catch (Exception ex) { Logger.LogException(ex, "Error in killing animal."); }
                    }
                    if (type == WreckType.Wreck)
                    {
                        dIdx++;
                    }
                    else
                    {
                        cdIdx++;
                    }
                    i++;
                }
                if (destroyList.Count == dIdx && type == WreckType.Wreck)
                {
                    if (originalCaller != null)
                    {
                        UnturnedChat.Say(originalCaller, WreckingBall.Instance.Translate("wreckingball_complete", dIdx));
                    }
                    else
                    {
                        Logger.Log(WreckingBall.Instance.Translate("wreckingball_complete", dIdx));
                    }
                    SaveManager.save();
                    Abort(WreckType.Wreck);
                }
            }
            catch (Exception ex) { Logger.LogException(ex, "General destruction loop error."); }
        }
示例#4
0
        internal static void Wreck(IRocketPlayer caller, string filter, float radius, Vector3 position, WreckType type, FlagType flagtype, ulong steamID, ushort itemID)
        {
            bool pInfoLibLoaded = false;

            syncError = false;
            if (type == WreckType.Wreck)
            {
                if (DestructionProcessing.processing)
                {
                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_processing", originalCaller != null ? originalCaller.CharacterName : "???", (dIdxCount - dIdx), CalcProcessTime()));
                    return;
                }
                Abort(WreckType.Wreck);
            }
            else if (type == WreckType.Scan)
            {
                WreckingBall.ElementData.reportLists[BuildableType.Element].Clear();
                WreckingBall.ElementData.reportLists[BuildableType.VehicleElement].Clear();
                if (WreckingBall.Instance.Configuration.Instance.EnablePlayerInfo && WreckingBall.isPlayerInfoLibPresent && WreckingBall.isPlayerInfoLibLoaded)
                {
                    pInfoLibLoaded = true;
                }
            }
            UnturnedPlayer Player = null;

            if (!(caller is ConsolePlayer) && type != WreckType.Cleanup)
            {
                Player = (UnturnedPlayer)caller;
                if (Player.IsInVehicle)
                {
                    position = Player.CurrentVehicle.transform.position;
                }
                else
                {
                    position = Player.Position;
                }
            }

            List <char> Filter = new List <char>();

            Filter.AddRange(filter.ToCharArray());

            float           distance  = 0;
            float           vdistance = 0;
            StructureRegion structureRegion;
            BarricadeRegion barricadeRegion;

            for (int k = 0; k < StructureManager.regions.GetLength(0); k++)
            {
                for (int l = 0; l < StructureManager.regions.GetLength(1); l++)
                {
                    // check to see if the region is out of range, skip if it is.
                    if (!radius.IsNaN() && position.RegionOutOfRange(k, l, radius) && type != WreckType.Cleanup && type != WreckType.Counts)
                    {
                        continue;
                    }

                    structureRegion = StructureManager.regions[k, l];
                    ProcessElements(caller, itemID, radius, type, flagtype, Filter, pInfoLibLoaded, structureRegion, position, steamID, BuildableType.Element);
                }
            }

            for (int k = 0; k < BarricadeManager.BarricadeRegions.GetLength(0); k++)
            {
                for (int l = 0; l < BarricadeManager.BarricadeRegions.GetLength(1); l++)
                {
                    // check to see if the region is out of range, skip if it is.
                    if (!radius.IsNaN() && position.RegionOutOfRange(k, l, radius) && type != WreckType.Cleanup && type != WreckType.Counts)
                    {
                        continue;
                    }

                    barricadeRegion = BarricadeManager.BarricadeRegions[k, l];
                    ProcessElements(caller, itemID, radius, type, flagtype, Filter, pInfoLibLoaded, barricadeRegion, position, steamID, BuildableType.Element);
                }
            }


            foreach (InteractableVehicle vehicle in VehicleManager.vehicles)
            {
                bool validVehicleElements = BarricadeManager.tryGetPlant(vehicle.transform, out byte x, out byte y, out ushort plant, out barricadeRegion);
                // Process Vehicles.
                if ((Filter.Contains('V') || Filter.Contains('*')) && type != WreckType.Cleanup && type != WreckType.Counts && (flagtype == FlagType.Normal || (flagtype == FlagType.SteamID && vehicle.isLocked && vehicle.lockedOwner == (CSteamID)steamID)))
                {
                    vdistance = Vector3.Distance(vehicle.transform.position, position);
                    if ((!radius.IsNaN() && vdistance <= radius) || (radius.IsNaN() && (vehicle.transform.position.x.IsNaN() || vehicle.transform.position.y.IsNaN() || vehicle.transform.position.z.IsNaN())))
                    {
                        WreckProcess(caller, 999, vdistance, pInfoLibLoaded, BuildableType.Vehicle, type, vehicle, vehicle.transform, !validVehicleElements ? 0 : barricadeRegion.drops.Count, vehicle.isLocked ? (ulong)vehicle.lockedOwner : 0);
                    }
                    if (vehicle.asset.engine == EEngine.TRAIN && vehicle.trainCars != null && vehicle.trainCars.Length > 1)
                    {
                        for (int i = 1; i < vehicle.trainCars.Length; i++)
                        {
                            if (BarricadeManager.tryGetPlant(vehicle.trainCars[i].root, out x, out y, out plant, out BarricadeRegion barricadeRegion2))
                            {
                                float tcdistance = Vector3.Distance(vehicle.trainCars[i].root.position, position);
                                if (tcdistance <= radius)
                                {
                                    WreckProcess(caller, 999, tcdistance, pInfoLibLoaded, BuildableType.Vehicle, type, vehicle, vehicle.transform, barricadeRegion2 == null ? 0 : barricadeRegion2.drops.Count, 0, i);
                                }
                            }
                        }
                    }
                }

                if (type == WreckType.Cleanup && vehicle.asset.engine != EEngine.TRAIN && WreckingBall.Instance.Configuration.Instance.CleanupLockedCars && vehicle.isLocked && vehicle.lockedOwner == (CSteamID)steamID)
                {
                    cleanupList.Add(new Destructible(vehicle.transform, ElementType.Vehicle, vehicle.asset.id, vehicle));
                }
                // Add Locked vehicles to the top players count, if the cleanup locked vehicles feature is active.
                if (type == WreckType.Counts && vehicle.asset.engine != EEngine.TRAIN && WreckingBall.Instance.Configuration.Instance.CleanupLockedCars && vehicle.isLocked)
                {
                    ulong vOwner = (ulong)vehicle.lockedOwner;
                    if (pElementCounts.ContainsKey(vOwner))
                    {
                        pElementCounts[vOwner]++;
                    }
                    else
                    {
                        pElementCounts.Add(vOwner, 1);
                    }
                }
                // Process vehicles elements, remove distance limiting on vehicle placement for element scanning, to handle massively misplaced elements on vehicles.
                if (validVehicleElements)
                {
                    ProcessElements(caller, itemID, radius, type, flagtype, Filter, pInfoLibLoaded, barricadeRegion, position, steamID, BuildableType.VehicleElement);
                }

                if (vehicle.asset.engine == EEngine.TRAIN && vehicle.trainCars != null && vehicle.trainCars.Length > 1)
                {
                    for (int i = 1; i < vehicle.trainCars.Length; i++)
                    {
                        if (BarricadeManager.tryGetPlant(vehicle.trainCars[i].root, out x, out y, out plant, out BarricadeRegion barricadeRegion2))
                        {
                            ProcessElements(caller, itemID, radius, type, flagtype, Filter, pInfoLibLoaded, barricadeRegion2, position, steamID, BuildableType.VehicleElement);
                        }
                    }
                }
            }

            if (Filter.Contains('Z'))
            {
                for (int z = 0; z < ZombieManager.regions.Length; z++)
                {
                    foreach (Zombie zombie in ZombieManager.regions[z].zombies)
                    {
                        distance = Vector3.Distance(zombie.transform.position, position);
                        if (distance < radius)
                        {
                            WreckProcess(caller, 998, distance, pInfoLibLoaded, BuildableType.Element, type, zombie, zombie.transform);
                        }
                    }
                }
            }

            if (Filter.Contains('A'))
            {
                foreach (Animal animal in AnimalManager.animals)
                {
                    distance = Vector3.Distance(animal.transform.position, position);
                    if (distance <= radius)
                    {
                        WreckProcess(caller, 997, distance, pInfoLibLoaded, BuildableType.Element, type, animal, animal.transform);
                    }
                }
            }


            if (type == WreckType.Scan)
            {
                uint totalCount = 0;
                if (WreckingBall.ElementData.reportLists[BuildableType.Element].Count > 0 || WreckingBall.ElementData.reportLists[BuildableType.VehicleElement].Count > 0)
                {
                    foreach (KeyValuePair <BuildableType, Dictionary <char, uint> > reportDictionary in WreckingBall.ElementData.reportLists)
                    {
                        if (reportDictionary.Value.Count == 0)
                        {
                            continue;
                        }
                        foreach (KeyValuePair <char, uint> reportFilter in reportDictionary.Value)
                        {
                            totalCount += reportFilter.Value;
                        }
                    }
                }
                Logger.Log(string.Format("Player: {0}, ran scan at: {1}, with Radius: {7}, with Flag type: {2}, with Flags: {3}, with ItemID: {4}, with SteamID: {5}, number of elements scanned: {6}", caller is ConsolePlayer ? "Console" : Player.CharacterName + " [" + Player.SteamName + "] (" + Player.CSteamID.ToString() + ")", caller is ConsolePlayer ? "N/A" : Player.Position.ToString(), flagtype.ToString(), Filter.Count > 0 ? string.Join("", Filter.Select(i => i.ToString()).ToArray()) : "N/A", itemID, steamID, totalCount, radius.IsNaN() ? "NaN(NaN Check)" : radius.ToString()));
                return;
            }
            if (destroyList.Count >= 1 && type == WreckType.Wreck)
            {
                Logger.Log(string.Format("Player {0}, queued wreck at: {1}, with Radius: {7}, with Flag type: {2}, with Flags: {3}, with itemID: {4}, with StermID: {5}, number of elements queued: {6}", caller is ConsolePlayer ? "Console" : Player.CharacterName + " [" + Player.SteamName + "] (" + Player.CSteamID.ToString() + ")", caller is ConsolePlayer ? "N/A" : Player.Position.ToString(), flagtype.ToString(), Filter.Count > 0 ? string.Join("", Filter.Select(i => i.ToString()).ToArray()) : "N/A", itemID, steamID, destroyList.Count, radius.IsNaN() ? "NaN(NaN Check)" : radius.ToString()));
                dIdxCount = destroyList.Count;
                WreckingBall.Instance.Instruct(caller);
            }
            else if (type == WreckType.Cleanup)
            {
                cdIdxCount = cleanupList.Count;
            }
            else if (type != WreckType.Counts)
            {
                UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_not_found", radius));
            }
        }
示例#5
0
        private static void ProcessElements(IRocketPlayer caller, ushort itemID, float radius, WreckType type, FlagType flagtype, List <char> Filter, bool pInfoLibLoaded, object region, Vector3 position, ulong steamID, BuildableType buildType)
        {
            StructureRegion sRegion   = null;
            BarricadeRegion bRegion   = null;
            BarricadeData   bData     = null;
            StructureData   sData     = null;
            bool            isSRegion = region is StructureRegion;
            int             DataCount;
            int             transformCount;

            if (isSRegion)
            {
                sRegion        = region as StructureRegion;
                transformCount = sRegion.drops.Count;
                DataCount      = sRegion.structures.Count;
            }
            else
            {
                bRegion        = region as BarricadeRegion;
                transformCount = bRegion.drops.Count;
                DataCount      = bRegion.barricades.Count;
            }

            for (int i = 0; i < transformCount; i++)
            {
                Transform transform = isSRegion ? sRegion.drops[i].model : bRegion.drops[i].model;
                ulong     owner;
                if (i < DataCount)
                {
                    if (isSRegion)
                    {
                        sData = sRegion.structures[i];
                        owner = sData.owner;
                    }
                    else
                    {
                        bData = bRegion.barricades[i];
                        owner = bData.owner;
                    }
                }
                else
                {
                    Logger.LogWarning(WreckingBall.Instance.Translate(isSRegion ? "wreckingball_structure_array_sync_error" : "wreckingball_barricade_array_sync_error"));
                    syncError = true;
                    break;
                }
                float distance = Vector3.Distance(transform.position, position);
                if (((!radius.IsNaN() && distance <= radius) || (radius.IsNaN() && (transform.position.x.IsNaN() || transform.position.y.IsNaN() || transform.position.z.IsNaN()))) && type != WreckType.Cleanup && type != WreckType.Counts)
                {
                    ushort item = isSRegion ? sData.structure.id : bData.barricade.id;
                    if (WreckingBall.ElementData.FilterItem(item, Filter) || Filter.Contains('*') || flagtype == FlagType.ItemID)
                    {
                        if (flagtype == FlagType.Normal)
                        {
                            WreckProcess(caller, item, distance, pInfoLibLoaded, buildType, type, isSRegion ? (object)sData : bData, transform);
                        }
                        else if (flagtype == FlagType.SteamID && owner == steamID)
                        {
                            WreckProcess(caller, item, distance, pInfoLibLoaded, buildType, type, isSRegion ? (object)sData : bData, transform);
                        }
                        else if (flagtype == FlagType.ItemID && itemID == item)
                        {
                            WreckProcess(caller, item, distance, pInfoLibLoaded, buildType, type, isSRegion ? (object)sData : bData, transform);
                        }
                    }
                }
                else if (type == WreckType.Cleanup && owner == steamID)
                {
                    cleanupList.Add(new Destructible(transform, isSRegion ? ElementType.Structure : ElementType.Barricade, isSRegion ? sData.structure.id : bData.barricade.id));
                }
                else if (type == WreckType.Counts)
                {
                    if (pElementCounts.ContainsKey(owner))
                    {
                        pElementCounts[owner]++;
                    }
                    else
                    {
                        pElementCounts.Add(owner, 1);
                    }
                }
            }
        }
示例#6
0
 private static void WreckProcess(IRocketPlayer caller, ushort itemID, float distance, bool pInfoLibLoaded, BuildableType buildType, WreckType type, object data, Transform transform, int count = 0, ulong lockedOwner = 0, int vindex = 0)
 {
     if (type == WreckType.Scan)
     {
         if (distance <= 10)
         {
             WreckingBall.ElementData.Report(caller, itemID, distance, true, pInfoLibLoaded, data, buildType, count, lockedOwner, vindex);
         }
         else
         {
             WreckingBall.ElementData.Report(caller, itemID, distance, false, pInfoLibLoaded, data, buildType);
         }
     }
     else
     {
         if (data is StructureData)
         {
             destroyList.Add(new Destructible(transform, ElementType.Structure, itemID));
         }
         if (data is BarricadeData)
         {
             destroyList.Add(new Destructible(transform, ElementType.Barricade, itemID));
         }
         // Add the vehicle to the destruction list, as long as it's not a train. Allow a special case where you could destroy a train from using wreck on the console, only.
         if (data is InteractableVehicle && (((InteractableVehicle)data).asset.engine != EEngine.TRAIN || caller is ConsolePlayer && vindex == 0 && type != WreckType.Counts && type != WreckType.Cleanup))
         {
             destroyList.Add(new Destructible(transform, ElementType.Vehicle, itemID, data as InteractableVehicle));
         }
         if (data is Zombie)
         {
             destroyList.Add(new Destructible(transform, ElementType.Zombie, itemID, null, data as Zombie));
         }
         if (data is Animal)
         {
             destroyList.Add(new Destructible(transform, ElementType.Animal, itemID, null, null, data as Animal));
         }
     }
 }
 public void AddRequest(IUser user, string filter, uint radius, Vector3 position, WreckType wreckType, ulong steamID, ushort itemID)
 {
     if (_pendingConfirmation.Any(c => Equals(c.User, user)))
     {
         _pendingConfirmation.Remove(_pendingConfirmation.FirstOrDefault(c => Equals(c.User, user)));
         return;
     }
     _pendingConfirmation.Add(new DestructionRequest(user, filter, radius, position, wreckType, steamID, itemID));
 }