public void Execute(IRocketPlayer caller, string[] command)
        {
            // Get player elements list.
            DestructionProcessing.Wreck(caller, "", 0, Vector3.zero, WreckType.Counts, FlagType.SteamID, 0, 0);
            // Grab what we need from the list.
            Dictionary <ulong, int> shortenedList = DestructionProcessing.pElementCounts.Where(r => r.Value >= WreckingBall.Instance.Configuration.Instance.PlayerElementListCutoff).OrderBy(v => v.Value).ToDictionary(k => k.Key, v => v.Value);

            DestructionProcessing.pElementCounts.Clear();

            bool getPInfo = false;

            if (WreckingBall.Instance.Configuration.Instance.EnablePlayerInfo && WreckingBall.isPlayerInfoLibPresent && WreckingBall.isPlayerInfoLibLoaded)
            {
                getPInfo = true;
            }

            foreach (KeyValuePair <ulong, int> value in shortenedList)
            {
                string msg = string.Format("Element count: {0}, Player: {1}", value.Value, !getPInfo || value.Key == 0 ? value.Key.ToString() : WreckingBall.Instance.PInfoGenerateMessage(value.Key));
                if (caller is ConsolePlayer)
                {
                    Logger.Log(msg, ConsoleColor.Yellow);
                }
                else
                {
                    UnturnedChat.Say(caller, msg, Color.yellow);
                }
            }
        }
Exemplo n.º 2
0
 internal void Scan(IRocketPlayer caller, string filter, float radius, Vector3 position, FlagType flagType, ulong steamID, ushort itemID)
 {
     DestructionProcessing.Wreck(caller, filter, radius, position, WreckType.Scan, flagType, steamID, itemID);
     if (ElementData.reportLists[BuildableType.Element].Count > 0 || ElementData.reportLists[BuildableType.VehicleElement].Count > 0)
     {
         foreach (KeyValuePair <BuildableType, Dictionary <char, uint> > reportDictionary in ElementData.reportLists)
         {
             if (reportDictionary.Value.Count == 0)
             {
                 continue;
             }
             string report     = "";
             uint   totalCount = 0;
             foreach (KeyValuePair <char, uint> reportFilter in reportDictionary.Value)
             {
                 report     += " " + ElementData.categorys[reportFilter.Key].Name + ": " + reportFilter.Value + ",";
                 totalCount += reportFilter.Value;
             }
             if (report != "")
             {
                 report = report.Remove(report.Length - 1);
             }
             string type = reportDictionary.Key == BuildableType.VehicleElement ? "Vehicle Element" : "Element";
             if (radius.IsNaN())
             {
                 UnturnedChat.Say(caller, Translate("wreckingball_scan_nan_check"));
             }
             UnturnedChat.Say(caller, Translate("wreckingball_scan", totalCount, type, radius.ToString(), report));
             if (Instance.Configuration.Instance.LogScans && !(caller is ConsolePlayer))
             {
                 Logger.Log(Translate("wreckingball_scan", totalCount, type, radius.ToString(), report));
             }
         }
     }
     else
     {
         UnturnedChat.Say(caller, Translate("wreckingball_not_found", radius));
     }
 }
        public void Execute(IRocketPlayer caller, string[] cmd)
        {
            string command = String.Join(" ", cmd);

            if (!caller.IsAdmin && !WreckingBall.Instance.Configuration.Instance.Enabled)
            {
                return;
            }

            if (!caller.IsAdmin && !caller.HasPermission("wreck"))
            {
                return;
            }

            UnturnedPlayer player   = null;
            Vector3        position = Vector3.zero;

            if (!(caller is ConsolePlayer))
            {
                player   = (UnturnedPlayer)caller;
                position = player.Position;
            }


            if (String.IsNullOrEmpty(command.Trim()))
            {
                if (DestructionProcessing.processing)
                {
                    DestructionProcessing.Wreck(caller, "", 0, position, WreckType.Wreck, FlagType.Normal, 0, 0);
                }
                else
                {
                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help"));
                    return;
                }
            }
            else
            {
                string[] oper = command.Split(' ');

                if (oper.Length >= 1)
                {
                    switch (oper[0])
                    {
                    case "confirm":
                        if (!(caller.HasPermission("wreck.wreck") || caller.HasPermission("wreck.*")) && !(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_wreck_permission"), Color.red);
                            return;
                        }
                        WreckingBall.Instance.Confirm(caller);
                        break;

                    case "abort":
                        if (!(caller.HasPermission("wreck.wreck") || caller.HasPermission("wreck.*")) && !(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_wreck_permission"), Color.red);
                            return;
                        }
                        if (!(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_aborted"));
                        }
                        Logger.Log(WreckingBall.Instance.Translate("wreckingball_aborted"));
                        DestructionProcessing.Abort(WreckType.Wreck);
                        break;

                    case "scan":
                        if (!(caller.HasPermission("wreck.scan") || caller.HasPermission("wreck.*")) && !(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_scan_permission"), Color.red);
                            return;
                        }
                        if ((oper.Length == 3 && !(caller is ConsolePlayer)) || (oper.Length == 6 && caller is ConsolePlayer))
                        {
                            if (caller is ConsolePlayer)
                            {
                                if (!cmd.GetVectorFromCmd(3, out position))
                                {
                                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_scan_console"));
                                    break;
                                }
                            }
                            ushort itemID = 0;
                            if (ushort.TryParse(oper[1], out itemID))
                            {
                                WreckingBall.Instance.Scan(caller, oper[1], Convert.ToSingle(oper[2]), position, FlagType.ItemID, 0, itemID);
                            }
                            else
                            {
                                if (oper[2].ToLower() == "nan")
                                {
                                    WreckingBall.Instance.Scan(caller, oper[1], float.NaN, position, FlagType.Normal, 0, 0);
                                }
                                else
                                {
                                    WreckingBall.Instance.Scan(caller, oper[1], Convert.ToSingle(oper[2]), position, FlagType.Normal, 0, 0);
                                }
                            }
                        }
                        else if ((oper.Length == 4 && !(caller is ConsolePlayer)) || (oper.Length == 7 && caller is ConsolePlayer))
                        {
                            ulong steamID = 0;
                            if (caller is ConsolePlayer)
                            {
                                if (!cmd.GetVectorFromCmd(4, out position))
                                {
                                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_scan_console"));
                                    break;
                                }
                            }
                            if (oper[1].isCSteamID(out steamID))
                            {
                                WreckingBall.Instance.Scan(caller, oper[2], Convert.ToSingle(oper[3]), position, FlagType.SteamID, (ulong)steamID, 0);
                            }
                            else
                            {
                                UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_scan"));
                            }
                        }
                        else
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_scan"));
                        }

                        break;

                    case "teleport":
                        if (!(caller.HasPermission("wreck.teleport") || caller.HasPermission("wreck.*")) && !(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_teleport_permission"), Color.red);
                            return;
                        }
                        ulong ulSteamID    = 0;
                        bool  firstSteamID = false;
                        if (oper.Length > 1 && oper[1].isCSteamID(out ulSteamID))
                        {
                            firstSteamID = true;
                        }
                        if (oper.Length > 1)
                        {
                            if (caller is ConsolePlayer)
                            {
                                UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_teleport_not_allowed"));
                                break;
                            }
                            string ch = string.Empty;
                            if (firstSteamID && oper.Length > 2)
                            {
                                ch = oper[2];
                            }
                            else if (!firstSteamID)
                            {
                                ch = oper[1];
                            }
                            switch (ch)
                            {
                            case "b":
                                WreckingBall.Instance.Teleport(player, TeleportType.Barricades, ulSteamID);
                                break;

                            case "s":
                                WreckingBall.Instance.Teleport(player, TeleportType.Structures, ulSteamID);
                                break;

                            case "v":
                                WreckingBall.Instance.Teleport(player, TeleportType.Vehicles, ulSteamID);
                                break;

                            default:
                                UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_teleport2"));
                                break;
                            }
                        }
                        else
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_teleport2"));
                            break;
                        }
                        break;

                    default:
                        if (!(caller.HasPermission("wreck.wreck") || caller.HasPermission("wreck.*")) && !(caller is ConsolePlayer))
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_wreck_permission"), Color.red);
                            return;
                        }
                        if ((oper.Length == 2 && !(caller is ConsolePlayer)) || (oper.Length == 5 && caller is ConsolePlayer))
                        {
                            if (caller is ConsolePlayer)
                            {
                                if (!cmd.GetVectorFromCmd(2, out position))
                                {
                                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_console"));
                                    break;
                                }
                            }
                            ushort itemID = 0;
                            if (ushort.TryParse(oper[0], out itemID))
                            {
                                DestructionProcessing.Wreck(caller, oper[0], Convert.ToSingle(oper[1]), position, WreckType.Wreck, FlagType.ItemID, 0, itemID);
                            }
                            else
                            {
                                if (oper[1].ToLower() == "nan")
                                {
                                    DestructionProcessing.Wreck(caller, oper[0], float.NaN, position, WreckType.Wreck, FlagType.Normal, 0, 0);
                                }
                                else
                                {
                                    DestructionProcessing.Wreck(caller, oper[0], Convert.ToSingle(oper[1]), position, WreckType.Wreck, FlagType.Normal, 0, 0);
                                }
                            }
                        }
                        else if ((oper.Length == 3 && !(caller is ConsolePlayer)) || (oper.Length == 6 && caller is ConsolePlayer))
                        {
                            if (caller is ConsolePlayer)
                            {
                                if (!cmd.GetVectorFromCmd(3, out position))
                                {
                                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help_console"));
                                    break;
                                }
                            }
                            ulong steamID = 0;
                            if (oper[0].isCSteamID(out steamID))
                            {
                                DestructionProcessing.Wreck(caller, oper[1], Convert.ToSingle(oper[2]), position, WreckType.Wreck, FlagType.SteamID, steamID, 0);
                            }
                            else
                            {
                                UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help"));
                            }
                        }
                        else
                        {
                            UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help"));
                            break;
                        }
                        break;
                    }
                    return;
                }
                else
                {
                    UnturnedChat.Say(caller, WreckingBall.Instance.Translate("wreckingball_help"));
                }
            }
        }