예제 #1
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.ShowUsage());
            }

            var target = args[0].ToPlayer;

            if (target == null)
            {
                return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
            }

            var pmSettings = UEssentials.Config.PrivateMessage;
            var formatFrom = pmSettings.FormatFrom;
            var formatTo   = pmSettings.FormatTo;
            var formatSpy  = pmSettings.FormatSpy;

            var formatFromColor = ColorUtil.GetColorFromString(ref formatFrom);
            var formatToColor   = ColorUtil.GetColorFromString(ref formatTo);
            var formatSpyColor  = ColorUtil.GetColorFromString(ref formatSpy);

            var targetName = src.IsConsole ? pmSettings.ConsoleDisplayName : target.DisplayName;
            var srcName    = src.IsConsole ? pmSettings.ConsoleDisplayName : src.DisplayName;

            formatFrom = string.Format(formatFrom, srcName, args.Join(1));
            formatTo   = string.Format(formatTo, targetName, args.Join(1));
            formatSpy  = string.Format(formatSpy, srcName, targetName, args.Join(1));

            target.SendMessage(formatFrom, formatFromColor);
            src.SendMessage(formatTo, formatToColor);

            Spies.ForEach(p => {
                UPlayer.From(p).SendMessage(formatSpy, formatSpyColor);
            });

            if (src.IsConsole)
            {
                return(CommandResult.Success());
            }

            var srcPlayer = src.ToPlayer();
            var srcId     = srcPlayer.CSteamId.m_SteamID;

            if (Conversations.ContainsKey(srcId))
            {
                if (!Conversations[srcId].Equals(target.CSteamId.m_SteamID))
                {
                    Conversations[srcId] = target.CSteamId.m_SteamID;
                }
            }
            else
            {
                Conversations.Add(srcId, target.CSteamId.m_SteamID);
            }

            return(CommandResult.Success());
        }
예제 #2
0
 public CommandResult OnExecute(ICommandSource src, ICommandArgs args)
 {
     Data.Text.ForEach(txt => {
         var color = ColorUtil.GetColorFromString(ref txt);
         src.SendMessage(txt, color);
     });
     return(CommandResult.Success());
 }
예제 #3
0
        public void SendTo(ICommandSource source, params object[] replacers)
        {
            var message = _message.Clone() as string;
            var color   = ColorUtil.GetColorFromString(ref message);

            source.SendMessage(replacers == null ? message :
                               string.Format(message, replacers), color);
        }
예제 #4
0
        private CommandResult TpsCommand(ICommandSource src, ICommandArgs args)
        {
            var tps   = Provider.debugTPS;
            var color =
                tps > 40 ? Color.green :
                tps > 25 ? Color.yellow :
                Color.red;

            src.SendMessage($"Ticks per second: {tps}", color);
            return(CommandResult.Success());
        }
예제 #5
0
        private CommandResult ItemInfoCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
        {
            if (src.IsConsole && args.Length != 1)
            {
                return(CommandResult.ShowUsage());
            }

            ItemAsset asset;

            if (args.Length == 0)
            {
                var equipment = src.ToPlayer().Equipment;

                if (equipment.HoldingItemID == 0)
                {
                    return(CommandResult.Lang("EMPTY_HANDS"));
                }

                asset = equipment.asset;
            }
            else
            {
                if (!args[0].IsUShort ||
                    (asset = Assets.find(EAssetType.ITEM, args[0].ToUShort) as ItemAsset) == null)
                {
                    return(CommandResult.Lang("INVALID_ITEM_ID", args[0]));
                }
            }

            var color       = Color.yellow;
            var name        = WrapMessage(src, asset.Name);
            var description = WrapMessage(src, asset.Description);
            var type        = WrapMessage(src, asset.ItemType.ToString());

            src.SendMessage($"Name: {name}", color);
            src.SendMessage($"Description: {description}", color);
            src.SendMessage($"Id: {asset.id}", color);
            src.SendMessage($"Type: {type}", color);

            return(CommandResult.Success());
        }
예제 #6
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.ShowUsage());
            }

            var target = args[0].ToPlayer;

            if (target == null)
            {
                return(CommandResult.Lang("PLAYER_NOT_FOUND", args[0]));
            }

            var formatFrom      = UEssentials.Config.PMFormatFrom;
            var formatTo        = UEssentials.Config.PMFormatTo;
            var formatFromColor = ColorUtil.GetColorFromString(ref formatFrom);
            var formatToColor   = ColorUtil.GetColorFromString(ref formatTo);

            var message  = string.Format(formatFrom, src.DisplayName, args.Join(1));
            var message2 = string.Format(formatTo, target.DisplayName, args.Join(1));

            target.SendMessage(message, formatFromColor);
            src.SendMessage(message2, formatToColor);

            Spies.ForEach(p => {
                UPlayer.From(p).SendMessage($"Spy: ({src.DisplayName} -> " +
                                            $"{target.CharacterName}): {args.Join(1)}", Color.gray);
            });

            if (src.IsConsole)
            {
                return(CommandResult.Success());
            }

            var srcPlayer = src.ToPlayer();
            var srcId     = srcPlayer.CSteamId.m_SteamID;

            if (Conversations.ContainsKey(srcId))
            {
                if (!Conversations[srcId].Equals(target.CSteamId.m_SteamID))
                {
                    Conversations[srcId] = target.CSteamId.m_SteamID;
                }
            }
            else
            {
                Conversations.Add(srcId, target.CSteamId.m_SteamID);
            }

            return(CommandResult.Success());
        }
예제 #7
0
 public CommandResult OnExecute(ICommandSource src, ICommandArgs args)
 {
     foreach (var entry in _texts)
     {
         src.SendMessage(ReplaceVariables(entry.Text, src, args), entry.Color);
     }
     foreach (var entry in _commands)
     {
         var source = entry.IsConsoleExecutor ? UEssentials.ConsoleSource : src;
         source.DispatchCommand(ReplaceVariables(entry.Command, src, args));
     }
     return(CommandResult.Success());
 }
예제 #8
0
 public CommandResult OnExecute(ICommandSource src, ICommandArgs args)
 {
     foreach (var entry in _texts)
     {
         src.SendMessage(entry.Text, entry.Color);
     }
     foreach (var entry in _commands)
     {
         var source = entry.IsConsoleExecutor ? UEssentials.ConsoleSource : src;
         source.DispatchCommand(entry.Command);
         Console.WriteLine($"'{entry.Command}'");
     }
     return(CommandResult.Success());
 }
예제 #9
0
        public static void Send(ICommandSource target, string key, params object[] args)
        {
            var   message = Translate(key, args);
            Color color;

            if (message == null)
            {
                color   = Color.red;
                message = string.Format(KEY_NOT_FOUND_MESSAGE, key);
            }
            else
            {
                color = ColorUtil.GetColorFromString(ref message);
            }

            target.SendMessage(message, color);
        }
예제 #10
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.ShowUsage());
            }

            var target = args[0].ToPlayer;

            if (target == null)
            {
                return(CommandResult.Lang(EssLang.PLAYER_NOT_FOUND, args[0]));
            }

            var rawMsg1 = UEssentials.Config.PrivateMessageFormat;
            var rawMsg2 = UEssentials.Config.PrivateMessageFormat2;
            var color1  = ColorUtil.GetColorFromString(ref rawMsg1);
            var color2  = ColorUtil.GetColorFromString(ref rawMsg2);

            var message  = string.Format(rawMsg1, src.DisplayName, args.Join(1));
            var message2 = string.Format(rawMsg2, target.DisplayName, args.Join(1));

            target.SendMessage(message, color1);
            src.SendMessage(message2, color2);

            Spies.ForEach(p => {
                UPlayer.From(p).SendMessage($"Spy: ({src.DisplayName} -> " +
                                            $"{target.CharacterName}): {args.Join( 1 )}", Color.gray);
            });

            if (Conversations.ContainsKey(src.DisplayName))
            {
                if (!Conversations[src.DisplayName].Equals(target.DisplayName))
                {
                    Conversations[src.DisplayName] = target.CharacterName;
                }
            }
            else
            {
                Conversations.Add(src.DisplayName, target.DisplayName);
            }

            return(CommandResult.Success());
        }
예제 #11
0
        public override void OnExecute( ICommandSource source, ICommandArgs parameters )
        {
            if ( parameters.IsEmpty || parameters.Length > 1 )
            {
                if ( source.IsConsole )
                    source.SendMessage( "Use /ping [player]" );
                else
                    EssLang.PING.SendTo( source, source.ToPlayer().Ping );
            }
            else
            {
                var target = parameters[0].ToPlayer;

                if ( target == null )
                    EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0] );
                else
                    EssLang.PING_OTHER.SendTo( source, target.DisplayName, target.Ping );
            }
        }
예제 #12
0
        CommandResult TpsCommand(ICommandSource src, ICommandArgs args)
        {
            Color color;
            var   tps = Provider.debugTPS;

            if (tps > 40)
            {
                color = Color.green;
            }
            else if (tps < 40 && tps > 25)
            {
                color = Color.yellow;
            }
            else
            {
                color = Color.red;
            }

            src.SendMessage($"Ticks per second: {tps}", color);
            return(CommandResult.Success());
        }
예제 #13
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            var target = args[0].ToPlayer;

            if (target == null)
            {
                return(CommandResult.LangError("PLAYER_NOT_FOUND", args[0]));
            }

            var pmSettings = UEssentials.Config.PrivateMessage;
            var formatFrom = pmSettings.FormatFrom;
            var formatTo   = pmSettings.FormatTo;
            var formatSpy  = pmSettings.FormatSpy;

            var formatFromColor = ColorUtil.GetColorFromString(ref formatFrom);
            var formatToColor   = ColorUtil.GetColorFromString(ref formatTo);
            var formatSpyColor  = ColorUtil.GetColorFromString(ref formatSpy);

            var targetName = target.DisplayName;
            var srcName    = src.IsConsole ? pmSettings.ConsoleDisplayName : src.DisplayName;

            formatFrom = string.Format(formatFrom, srcName, args.Join(1));
            formatTo   = string.Format(formatTo, targetName, args.Join(1));
            formatSpy  = string.Format(formatSpy, srcName, targetName, args.Join(1));

            target.SendMessage(formatFrom, formatFromColor);
            src.SendMessage(formatTo, formatToColor);

            Spies.ForEach(p => {
                UPlayer.From(p).SendMessage(formatSpy, formatSpyColor);
            });

            if (!src.IsConsole)
            {
                ReplyTo[target.CSteamId.m_SteamID] = src.ToPlayer().CSteamId.m_SteamID;
            }

            return(CommandResult.Success());
        }
예제 #14
0
        private static void GiveItem( ICommandSource src, UPlayer target, ICommandArgument itemArg, 
                                      ICommandArgument amountArg, bool allPlayers = false )
        {
            ItemAsset asset;

            if ( itemArg.IsUshort )
            {
                var id = itemArg.ToUshort;
                asset = (ItemAsset) Assets.find( EAssetType.ITEM, id );
            }
            else
            {
                asset = UnturnedItems.GetItemAssetByName( itemArg.ToLowerString );
            }

            if ( asset == null )
            {
                src.SendMessage( $"Could not find an item with this name or id: {itemArg}" );
                return;
            }

            ushort amt = 1;

            if ( amountArg != null )
            {
                if ( !amountArg.IsShort )
                {
                    EssLang.INVALID_NUMBER.SendTo( src, amountArg );
                }
                else if ( amountArg.ToUshort <= 0 )
                {
                    EssLang.MUST_POSITIVE.SendTo( src );
                }
                else
                {
                    amt = amountArg.ToUshort;
                    goto give;
                }
                return;
            }

            give:
            var playersToReceive = new List<UPlayer>();
            var item = new Item( asset.id, true );

            if ( allPlayers )
            {
                UServer.Players.ForEach( playersToReceive.Add );
                EssLang.GIVEN_ITEM_ALL.SendTo( src, amt, asset.Name );
            }
            else
            {
                playersToReceive.Add( target );

                if ( !src.IsConsole && src.ToPlayer() != target )
                {
                    EssLang.GIVEN_ITEM.SendTo( src, amt, asset.Name, target.CharacterName );
                }
            }

            playersToReceive.ForEach( p =>
            {
                var success = p.GiveItem( item, amt, true );

                EssLang.RECEIVED_ITEM.SendTo( p, amt, asset.Name );

                if ( !success )
                {
                    EssLang.INVENTORY_FULL.SendTo( p );
                }
            } );
        }
예제 #15
0
 private CommandResult SystemTimeCommand(ICommandSource src, ICommandArgs args)
 {
     src.SendMessage(DateTime.Now, Color.yellow);
     return(CommandResult.Success());
 }
예제 #16
0
        public override void OnExecute( ICommandSource source, ICommandArgs parameters )
        {
            if ( parameters.IsEmpty )
            {
                ShowUsage( source );
            }
            else
            {
                switch (parameters[0].ToString().ToLower())
                {
                    case "start":
                        if ( source.HasPermission( "essentials.commands.poll.start" ) )
                        {
                            if ( parameters.Length < 4 )
                            {
                                source.SendMessage( "/poll start [name] [duration] [description]" );
                                return;
                            }

                            var pollName = parameters[1].ToString();

                            lock ( Polls )
                            {
                                if ( Polls.ContainsKey( pollName ) )
                                {
                                    EssLang.POLL_NAME_IN_USE.SendTo( source );
                                    return;
                                }
                            }

                            var pollDescription = parameters.Join( 3 );

                            if ( parameters[2].IsInt )
                            {
                                var poll = new Poll( 
                                    pollName, 
                                    pollDescription,
                                    parameters[2].ToInt 
                                );

                                poll.Start();
                            }
                            else
                            {
                                EssLang.INVALID_NUMBER.SendTo( source, parameters[2] );
                            }
                        }
                        else
                        {
                            EssLang.COMMAND_NO_PERMISSION.SendTo( source );
                        }
                        break;

                    case "stop":
                        if ( source.HasPermission( "essentials.commands.poll.stop" ) )
                        {
                            if ( parameters.Length < 2 )
                            {
                                source.SendMessage( "/poll stop [name]" );
                                return;
                            }

                            var pollName = parameters[1].ToString();

                            if ( !PollExists( pollName, source ) ) return;

                            lock ( Polls )
                            {
                                Polls[pollName].Stop();
                            }
                        }
                        else
                        {
                            EssLang.COMMAND_NO_PERMISSION.SendTo( source );
                        }
                        break;

                    case "list":
                        if ( source.HasPermission( "essentials.commands.poll.info" ) )
                        {
                            lock ( Polls )
                            {
                                if ( !Polls.Any() )
                                {
                                    EssLang.POLL_NONE.SendTo( source );
                                    return;
                                }

                                lock ( Polls )
                                {
                                    EssLang.POLL_LIST.SendTo( source );

                                    foreach ( var poll in Polls.Values )
                                    {
                                        EssLang.POLL_LIST_ENTRY.SendTo( 
                                            source,
                                            poll.Name,
                                            poll.Description, 
                                            poll.YesVotes,
                                            poll.NoVotes
                                        );
                                    }
                                }
                            }
                        }
                        else
                        {
                            EssLang.COMMAND_NO_PERMISSION.SendTo( source );
                        }                        
                        break;

                    case "info":
                        if ( source.HasPermission( "essentials.commands.poll.info" ) )
                        {
                            lock ( Polls )
                            {
                                if ( !Polls.Any() )
                                {
                                    EssLang.POLL_NONE.SendTo( source );
                                    return;
                                }

                                if ( parameters.Length < 2 )
                                {
                                    source.SendMessage( "Use /poll info [poll_name]");
                                }
                                else
                                {
                                    var pollName = parameters[1].ToString();

                                    if ( !PollExists( pollName, source ) ) return;

                                    var poll = Polls[pollName];

                                    EssLang.POLL_INFO.SendTo( source, pollName );

                                    EssLang.POLL_LIST_ENTRY.SendTo( 
                                        source, 
                                        pollName, 
                                        poll.Description, 
                                        poll.YesVotes, 
                                        poll.NoVotes 
                                    );
                                }
                            }
                        }
                        else
                        {
                            EssLang.COMMAND_NO_PERMISSION.SendTo( source );
                        }
                        break;

                    default:
                        ShowUsage( source );
                        break;
                }
            }
        }
예제 #17
0
        private CommandResult ClearCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
        {
            if (args.IsEmpty)
            {
                return(CommandResult.ShowUsage());
            }

            /*
             *  TODO: Options
             *      -i = items
             *      -v = vehicles
             *      -z = zombies
             *      -b = barricades
             *      -s = structures
             *      -a = ALL
             *
             *  /clear -i -z -v = items, zombies, vehicles
             */

            var distance = -1;

            if (args.Length > 1)
            {
                if (src.IsConsole)
                {
                    return(CommandResult.ShowUsage());
                }

                if (!args[1].IsInt)
                {
                    return(CommandResult.LangError("INVALID_NUMBER", args[1]));
                }

                if (args[1].ToInt < 1)
                {
                    return(CommandResult.LangError("NUMBER_BETWEEN", 1, int.MaxValue));
                }

                distance = args[1].ToInt;
            }

            switch (args[0].ToLowerString)
            {
            case "ev":
            case "emptyvehicles":
                if (!src.HasPermission(cmd.Permission + ".emptyvehicles"))
                {
                    return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
                }

                src.SendMessage("This command is unstable and can cause bugs.", Color.yellow);

                var numRemoved = 0;
                UWorld.Vehicles
                .Where(v => v.passengers.All(p => p?.player == null))         // Check if it's has no passengers
                .Where(v => {
                    if (v.id == 186 || v.id == 187)
                    {
                        return(false);                                    // Ignore trains; TODO: config blacklist for this?
                    }
                    if (distance == -1)
                    {
                        return(true);
                    }

                    return(Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance);
                })
                .Select(v => v.instanceID)
                .ToList()
                .ForEach(id => {
                    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
                    numRemoved++;
                });

                EssLang.Send(src, "CLEAR_EMPTY_VEHICLES", numRemoved);
                break;

            case "i":
            case "items":
                if (!src.HasPermission(cmd.Permission + ".items"))
                {
                    return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
                }

                ItemManager.askClearAllItems();
                EssLang.Send(src, "CLEAR_ITEMS");
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            return(CommandResult.Success());
        }
예제 #18
0
        private CommandResult ClearCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
        {
            if (args.IsEmpty)
            {
                return(CommandResult.ShowUsage());
            }

            /*
             *  TODO: Options
             *      -i = items
             *      -v = vehicles
             *      -z = zombies
             *      -b = barricades
             *      -s = structures
             *      -a = ALL
             *
             *  /clear -i -z -v = items, zombies, vehicles
             */

            var distance = -1;

            if (args.Length > 1)
            {
                if (src.IsConsole)
                {
                    return(CommandResult.ShowUsage());
                }

                if (!args[1].IsInt)
                {
                    return(CommandResult.Lang("INVALID_NUMBER", args[1]));
                }

                if (args[1].ToInt < 1)
                {
                    return(CommandResult.Lang("NUMBER_BETWEEN", 1, int.MaxValue));
                }

                distance = args[1].ToInt;
            }

            switch (args[0].ToLowerString)
            {
            case "ev":
            case "emptyvehicles":
                if (!src.HasPermission(cmd.Permission + ".emptyvehicles"))
                {
                    return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
                }

                src.SendMessage("This command is unstable and can cause bugs.", Color.red);

                var toRemove = new List <uint>();
                UWorld.Vehicles
                .Where(v => v.passengers.All(p => p?.player == null))
                .Where(v => {
                    if (distance == -1)
                    {
                        return(true);
                    }
                    return(Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance);
                })
                .Select(v => v.instanceID)
                .ForEach(toRemove.Add);

                toRemove.ForEach(id => {
                    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
                });

                EssLang.Send(src, "CLEAR_EMPTY_VEHICLES", toRemove.Count);
                break;

            /*case "v":
             * case "vehicle":
             *  return CommandResult.Generic("This option is currently disabled.");
             *
             *  if (!src.HasPermission(cmd.Permission + ".vehicles")) {
             *      return CommandResult.Lang("COMMAND_NO_PERMISSION");
             *  }
             *
             *  UWorld.Vehicles.ForEach(v => {
             *      for (byte i = 0; i < v.passengers.Length; i++) {
             *          if (v.passengers[i] == null ||
             *              v.passengers[i].player == null) continue;
             *
             *          Vector3 point;
             *          byte angle;
             *
             *          v.getExit(i, out point, out angle);
             *          VehicleManager.sendExitVehicle(v, i, point, angle, true);
             *      }
             *  });
             *
             *  VehicleManager.askVehicleDestroyAll();
             *  EssLang.Send(src, "CLEAR_VEHICLES");
             *  break;*/

            case "i":
            case "items":
                if (!src.HasPermission(cmd.Permission + ".items"))
                {
                    return(CommandResult.Lang("COMMAND_NO_PERMISSION"));
                }

                ItemManager.askClearAllItems();
                EssLang.Send(src, "CLEAR_ITEMS");
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            return(CommandResult.Success());
        }
예제 #19
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.Length < 2)
            {
                src.SendMessage(UsageMessage);
                src.SendMessage("SubCommands' Usage:");
                src.SendMessage(" - additem [type(normal|vehicle|xp)] ...");
                src.SendMessage("  * To add a vehicle: additem vehicle [id]");
                src.SendMessage("  * To add a item: additem normal [id] [amount] [durability]");
                src.SendMessage("  * To add a xp: additem xp [amount]");
                src.SendMessage("  * To add a money: additem money [amount]");
                src.SendMessage(" - delitem [itemIndex]");
                src.SendMessage("  * Use '/ekit [kit] view' to list valid indexes.");
                src.SendMessage(" - set [option] [value]");
                src.SendMessage("  * Valid options:");
                src.SendMessage("   - nm = Name | Accepts a string");
                src.SendMessage("   - cst = Cost | Accepts a Number");
                src.SendMessage("   - cd  = Cooldown | Accepts a Number");
                src.SendMessage("   - rwd = ResetCooldownWhenDie | Accepts a Boolean (true or false)");
                return(CommandResult.InvalidArgs());
            }

            var kitManager = KitModule.Instance.KitManager;
            var kitName    = args[0].ToString();

            if (!kitManager.Contains(kitName))
            {
                return(CommandResult.LangError("KIT_NOT_EXIST", kitName));
            }

            var kit = kitManager.GetByName(kitName);

            switch (args[1].ToLowerString)
            {
            case "view":
                src.SendMessage($"Name: {kit.Name}");
                src.SendMessage($"Cooldown: {kit.Cooldown}");
                src.SendMessage($"Cost: {kit.Cost}");
                src.SendMessage($"ResetCooldownWhenDie: {kit.ResetCooldownWhenDie}");
                src.SendMessage(string.Empty);

                if (kit.Items.Count > 0)
                {
                    src.SendMessage("Items:");

                    var index = 0;
                    kit.Items.ForEach(item => src.SendMessage(item.ToString().Insert(0, $" [{(++index)}] ")));
                }
                else
                {
                    src.SendMessage("This kit has no items.");
                }
                return(CommandResult.Success());

            /* ekit name additem normal id amount durability */
            case "additem":
                if (args.Length < 3)
                {
                    return(CommandResult.InvalidArgs("Use /ekit [kit] additem [type] [id] [amount] [durability]"));
                }

                byte?durability = null;
                byte?amount     = null;

                // Try to convert 'amount'
                if (args.Length >= 5 && args[4].TryConvertToByte(out amount, out var error))
                {
                    return(error);
                }

                // Try to convert 'durability'
                if (args.Length >= 6 && args[5].TryConvertToByte(out durability, out error))
                {
                    return(error);
                }

                switch (args[2].ToLowerString)
                {
                case "normal":
                    if (args.Length < 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem normal [id] [amount] [durability]"));
                    }

                    var optAsset = ItemUtil.GetItem(args[3].ToString());

                    if (optAsset.IsAbsent)
                    {
                        return(CommandResult.LangError("INVALID_ITEM_ID_NAME", args[3]));
                    }

                    kit.Items.Add(new KitItem(optAsset.Value.id, durability ?? 100, amount ?? 1));
                    src.SendMessage($"Added Id: {optAsset.Value.id}, Amount: {amount}, " +
                                    $"Durability: {durability}");
                    break;

                case "vehicle":
                    if (args.Length != 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem vehicle [id]"));
                    }

                    if (!args[3].IsInt)
                    {
                        return(CommandResult.LangError("INVALID_NUMBER", args[3]));
                    }

                    var argAsInt = args[3].ToInt;

                    if (argAsInt < 0 || argAsInt > ushort.MaxValue)
                    {
                        return(CommandResult.LangError("NEGATIVE_OR_LARGE"));
                    }

                    var vehicleAsset = Assets.find(EAssetType.VEHICLE, (ushort)argAsInt);

                    if (vehicleAsset == null)
                    {
                        return(CommandResult.LangError("INVALID_VEHICLE_ID", argAsInt));
                    }

                    kit.Items.Add(new KitItemVehicle((ushort)argAsInt));
                    src.SendMessage($"Added Vehicle item. Id: {argAsInt}");
                    break;

                case "money":
                    if (args.Length != 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem money [amount]"));
                    }

                    if (!args[3].IsInt)
                    {
                        return(CommandResult.LangError("INVALID_NUMBER", args[3]));
                    }

                    if (args[3].ToInt < 0)
                    {
                        return(CommandResult.LangError("MUST_POSITIVE"));
                    }

                    var moneyAmount = args[3].ToUInt;
                    kit.Items.Add(new KitItemMoney(moneyAmount));
                    src.SendMessage($"Added money item. Amount: {moneyAmount}");
                    break;

                case "xp":
                    if (args.Length != 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem xp [amount]"));
                    }

                    if (!args[3].IsInt)
                    {
                        return(CommandResult.LangError("INVALID_NUMBER", args[3]));
                    }

                    if (args[3].ToInt < 0)
                    {
                        return(CommandResult.LangError("MUST_POSITIVE"));
                    }

                    var expAmount = args[3].ToUInt;

                    kit.Items.Add(new KitItemExperience(expAmount));
                    src.SendMessage($"Added Xp item. Experience Amount: {expAmount}");
                    break;

                default:
                    return(CommandResult.Error($"Invalid type '{args[2]}'. Valid types are: 'normal', 'money', 'vehicle' and 'xp'"));
                }
                break;

            /* ekit name delitem [itemindex] */
            case "delitem":
                if (args.Length != 3)
                {
                    src.SendMessage("Use '/ekit [kit] delitem [itemIndex]'");
                    src.SendMessage("Use '/ekit [kit] view' to view valid indexes.");

                    return(CommandResult.InvalidArgs());
                }

                if (!args[2].IsInt)
                {
                    return(CommandResult.LangError("INVALID_NUMBER", args[2]));
                }

                var argAsInt2 = args[2].ToInt;

                if (argAsInt2 <= 0)
                {
                    return(CommandResult.LangError("MUST_POSITIVE"));
                }

                /* 1 to kitItems.Count */
                if ((argAsInt2 - 1) > kit.Items.Count)
                {
                    src.SendMessage($"Invalid index, index must be between 1 and {kit.Items.Count}");
                    src.SendMessage("Use '/ekit [kit] view' to view valid indexes.");

                    return(CommandResult.InvalidArgs());
                }

                kit.Items.RemoveAt(argAsInt2 - 1);
                src.SendMessage($"Removed item at index {argAsInt2}");
                break;

            case "set":
                if (args.Length < 3)
                {
                    src.SendMessage("Use /ekit [kit] set [option] [value]");
                    src.SendMessage("nm  = Name");
                    src.SendMessage("cst = Cost");
                    src.SendMessage("cd  = Cooldown");
                    src.SendMessage("rwd = ResetCooldownWhenDie");

                    return(CommandResult.InvalidArgs());
                }

                switch (args[2].ToLowerString)
                {
                case "cost":
                case "cst":
                    if (!args[3].IsDouble)
                    {
                        return(CommandResult.LangError("INVALID_NUMBER", args[3]));
                    }

                    kit.Cost = (decimal)args[3].ToDouble;
                    src.SendMessage("Cost set to " + kit.Cost);
                    break;

                case "name":
                case "nm":
                    kit.Name = args[3].ToString();
                    src.SendMessage("Name set to " + kit.Name);
                    break;

                case "cooldown":
                case "cd":
                    if (!args[3].IsInt)
                    {
                        return(CommandResult.LangError("INVALID_NUMBER", args[3]));
                    }

                    if (args[3].ToInt < 0)
                    {
                        return(CommandResult.LangError("MUST_POSITIVE"));
                    }

                    kit.Cooldown = args[3].ToUInt;
                    src.SendMessage("Cooldown set to " + kit.Cooldown);
                    break;

                case "resetcooldownwhendie":
                case "rwd":
                    if (!args[3].IsBool)
                    {
                        return(CommandResult.LangError("INVALID_BOOLEAN", args[3]));
                    }

                    kit.ResetCooldownWhenDie = args[3].ToBool;
                    src.SendMessage("ResetCooldownWhenDie set to " + kit.ResetCooldownWhenDie);
                    break;

                default:
                    src.SendMessage("nm  = Name");
                    src.SendMessage("cd  = Cooldown");
                    src.SendMessage("cst = Cost");
                    src.SendMessage("rwd = ResetCooldownWhenDie");
                    return(CommandResult.InvalidArgs());
                }
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            kitManager.SaveKits();
            kitManager.LoadKits();

            return(CommandResult.Success());
        }
예제 #20
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.IsEmpty)
            {
                return(CommandResult.ShowUsage());
            }

            switch (args[0].ToLowerString)
            {
            case "savedata":
                if (!src.HasPermission($"{Permission}.savedata"))
                {
                    return(CommandResult.NoPermission($"{Permission}.savedata"));
                }
                UEssentials.ModuleManager.GetModule <KitModule>().IfPresent(m => {
                    m.KitManager.CooldownData.Save();
                });
                UEssentials.ModuleManager.GetModule <WarpModule>().IfPresent(m => {
                    m.WarpManager.Save();
                });
                break;

            case "reload":
                if (!src.HasPermission($"{Permission}.reload"))
                {
                    return(CommandResult.NoPermission($"{Permission}.reload"));
                }
                if (args.Length == 1)
                {
                    src.SendMessage("Reloading all...");
                    ReloadConfig();
                    ReloadKits();
                    ReloadLang();
                    R.Permissions.Reload();
                    src.SendMessage("Reload finished...");
                }
                else
                {
                    switch (args[1].ToLowerString)
                    {
                    case "kits":
                    case "kit":
                        src.SendMessage("Reloading kits...");
                        ReloadKits();
                        src.SendMessage("Reload finished...");
                        break;

                    case "config":
                        src.SendMessage("Reloading config...");
                        ReloadConfig();
                        src.SendMessage("Reload finished...");
                        break;

                    case "lang":
                        src.SendMessage("Reloading translations...");
                        ReloadLang();
                        src.SendMessage("Reload finished...");
                        break;

                    default:
                        return(CommandResult.InvalidArgs("Use /ess reload <kits/config/lang>"));
                    }
                }
                break;

            case "commands":
                if (src.IsConsole)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine(_cachedCommands.Value);
                    Console.WriteLine("Use /ess help <command> to view help page.");
                }
                else if (args.Length != 2 || !args[1].IsInt)
                {
                    src.SendMessage("Use /ess commands [page]");
                }
                else
                {
                    var pages   = _ingameCommandPages.Value;
                    var pageArg = args[1].ToInt;

                    if (pageArg < 1 || pageArg > pages.Count - 1)
                    {
                        src.SendMessage($"Page must be between 1 and {pages.Count - 1}", Color.red);
                    }
                    else
                    {
                        pages[pageArg - 1].ForEach(s => {
                            src.SendMessage(s, Color.cyan);
                        });
                    }
                }
                break;

            case "info":
                if (src.IsConsole)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                }

                src.SendMessage("Author:  leonardosc", Color.yellow);
                src.SendMessage("Github:  github.com/leonardosnt", Color.yellow);
                src.SendMessage("uEssentials Github:  github.com/uEssentials", Color.yellow);
                src.SendMessage("Version: " + EssCore.PLUGIN_VERSION, Color.yellow);
                break;

            case "help":
                if (src.IsConsole)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                }

                if (args.Length == 1)
                {
                    src.SendMessage("Use /ess help <command>");
                }
                else
                {
                    var command = UEssentials.CommandManager.GetByName(args[1].ToString());

                    if (command == null)
                    {
                        src.SendMessage($"Command {args[1]} does not exists", Color.red);
                    }
                    else
                    {
                        src.SendMessage("Command: " + command.Name, Color.cyan);
                        src.SendMessage("  Usage Syntax: ", Color.cyan);
                        src.SendMessage("    - [arg] = required argument.", Color.cyan);
                        src.SendMessage("    - <arg> = optional argument.", Color.cyan);
                        src.SendMessage("    - | or / = means 'Or'.", Color.cyan);
                        src.SendMessage("  Description: " + command.Description, Color.cyan);
                        src.SendMessage("  Usage: /" + command.Name + " " + command.Usage, Color.cyan);
                        if (command.Aliases.Any())
                        {
                            src.SendMessage("  Aliases: " + string.Join(", ", command.Aliases), Color.cyan);
                        }
                    }
                }
                break;

            case "debug":
            case "dbg":
                if (!src.HasPermission($"{Permission}.debug"))
                {
                    return(CommandResult.NoPermission($"{Permission}.debug"));
                }

                if (args.Length < 3)
                {
                    return(CommandResult.InvalidArgs("Use /essentials debug [commands/tasks] [true/false]"));
                }

                if (!args[2].IsBool)
                {
                    return(CommandResult.Lang("INVALID_BOOLEAN", args[2]));
                }

                var flag = args[2].ToBool;
                switch (args[1].RawValue.ToLowerInvariant())
                {
                case "commands":
                    EssCore.Instance.DebugCommands = flag;
                    src.SendMessage($"DebugCommands set to {flag}");
                    break;

                case "tasks":
                    src.SendMessage($"DebugTasks set to {flag}");
                    EssCore.Instance.DebugTasks = flag;
                    break;

                default:
                    return(CommandResult.InvalidArgs($"Invalid option '{args[1]}'"));
                }
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            return(CommandResult.Success());
        }
예제 #21
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.IsEmpty)
            {
                return(CommandResult.ShowUsage());
            }

            switch (args[0].ToLowerString)
            {
            case "reload":
                if (!src.HasPermission("essentials.reload"))
                {
                    return(CommandResult.Lang(EssLang.COMMAND_NO_PERMISSION));
                }

                if (args.Length == 1)
                {
                    src.SendMessage("Reloading all...");
                    ReloadConfig();
                    ReloadKits();
                    ReloadLang();
                    R.Permissions.Reload();
                    src.SendMessage("Reload finished...");
                }
                else
                {
                    switch (args[1].ToLowerString)
                    {
                    case "kits":
                    case "kit":
                        src.SendMessage("Reloading kits...");
                        ReloadKits();
                        src.SendMessage("Reload finished...");
                        break;

                    case "config":
                        src.SendMessage("Reloading config...");
                        ReloadConfig();
                        src.SendMessage("Reload finished...");
                        break;

                    case "lang":
                        src.SendMessage("Reloading translations...");
                        ReloadLang();
                        src.SendMessage("Reload finished...");
                        break;

                    default:
                        return(CommandResult.InvalidArgs("Use /ess reload <kits/config/lang>"));
                    }
                }
                break;

            case "commands":
                if (src.IsConsole)
                {
                    if (_cachedCommands == null)
                    {
                        var builder = new StringBuilder("Commands: \n");

                        (
                            from command in UEssentials.CommandManager.Commands
                            where _isEssentialsCommand(command)
                            select command
                        ).ForEach(command => {
                            builder.Append("  /")
                            .Append(command.Name.ToLower())
                            .Append(command.Usage == "" ? "" : " " + command.Usage)
                            .Append(" - ").Append(command.Description)
                            .AppendLine();
                        });

                        _cachedCommands = builder.ToString();
                    }

                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine(_cachedCommands);
                    Console.WriteLine("Use /ess help <command> to view help page.");
                }
                else if (args.Length != 2 || !args[1].IsInt)
                {
                    src.SendMessage("Use /ess commands [page]");
                }
                else
                {
                    if (_ingameCommandPages == null)
                    {
                        const int PAGE_SIZE = 16;

                        _ingameCommandPages = new List <List <string> >(50)
                        {
                            new List <string>(PAGE_SIZE)
                        };

                        var builder = new StringBuilder("Commands: \n");
                        var count   = 0;
                        var page    = 0;

                        (
                            from command in UEssentials.CommandManager.Commands
                            where _isEssentialsCommand(command)
                            select command
                        ).ForEach(command => {
                            if (count >= (PAGE_SIZE - 1))
                            {
                                _ingameCommandPages[page++].Add("Use /ess help <command> to view help page.");
                                _ingameCommandPages.Add(new List <string>(PAGE_SIZE));
                                count = 0;
                            }

                            builder.Append("  /")
                            .Append(command.Name.ToLower())
                            .Append(command.Usage == "" ? "" : " " + command.Usage)
                            .Append(" - ").Append(command.Description)
                            .AppendLine();

                            _ingameCommandPages[page].Add(builder.ToString());
                            builder.Length = 0;
                            count++;
                        });
                    }

                    var pageArg = args[1].ToInt;

                    if (pageArg < 1 || pageArg > _ingameCommandPages.Count - 1)
                    {
                        src.SendMessage($"Page must be between 1 and {_ingameCommandPages.Count - 1}", Color.red);
                    }
                    else
                    {
                        _ingameCommandPages[pageArg - 1].ForEach(s => {
                            src.SendMessage(s, Color.cyan);
                        });
                    }
                }
                break;

            case "info":
                if (src.IsConsole)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                }

                src.SendMessage("Author:  leonardosc", Color.yellow);
                src.SendMessage("Skype:   devleeo", Color.yellow);
                src.SendMessage("Github:  github.com/leonardosnt", Color.yellow);
                src.SendMessage("Version: " + EssCore.PLUGIN_VERSION, Color.yellow);
                break;

            case "help":
                if (src.IsConsole)
                {
                    Console.ForegroundColor = ConsoleColor.Green;
                }

                if (args.Length == 1)
                {
                    src.SendMessage("Use /ess help <command>");
                }
                else
                {
                    var command = UEssentials.CommandManager.GetByName(args[1].ToString());

                    if (command == null)
                    {
                        src.SendMessage($"Command {args[1]} does not exists", Color.red);
                    }
                    else
                    {
                        src.SendMessage("Command: " + command.Name, Color.cyan);
                        src.SendMessage("  Arguments: <optional> [required]", Color.cyan);
                        src.SendMessage("  Help: " + command.Description, Color.cyan);
                        src.SendMessage("  Usage: /" + command.Name + " " + command.Usage, Color.cyan);
                        if (command.Aliases.Any())
                        {
                            src.SendMessage("  Aliases: " + string.Join(", ", command.Aliases), Color.cyan);
                        }
                    }
                }
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            return(CommandResult.Success());
        }
예제 #22
0
        public override void OnExecute( ICommandSource src, ICommandArgs args )
        {
            if ( args.IsEmpty )
            {
                src.SendMessage( "Use /ess <commands/help/info/reload>" );
                return;
            }

            switch ( args[0].ToLowerString )
            {
                case "reload":
                    if ( args.Length == 1 )
                    {
                        src.SendMessage( "Reloading all..." );
                        ReloadConfig();
                        ReloadKits();
                        ReloadLang();
                        src.SendMessage( "Reload finished..." );
                    }
                    else
                    {
                        switch ( args[1].ToLowerString )
                        {
                            case "kits":
                            case "kit":
                                src.SendMessage( "Reloading kits..." );
                                ReloadKits();
                                src.SendMessage( "Reload finished..." );
                                break;

                            case "config":
                                src.SendMessage( "Reloading config..." );
                                ReloadConfig();
                                src.SendMessage( "Reload finished..." );
                                break;

                            case "lang":
                                src.SendMessage( "Reloading translations..." );
                                ReloadLang();
                                src.SendMessage( "Reload finished..." );
                                break;

                            default:
                                src.SendMessage( "Use /ess reload <kits/config/lang>" );
                                break;
                        }
                    }
                    break;

                case "commands":
                    if ( src.IsConsole )
                    {
                        if ( _cachedCommands == null )
                        {
                            var builder = new StringBuilder( "Commands: \n" );

                            Func<ICommand, bool> isEssentialsCommand = cmd =>
                            {
                                var asm = cmd.GetType().Assembly;

                                if ( cmd.GetType() == typeof (MethodCommand) )
                                {
                                    asm = ((MethodCommand) cmd).Owner.Assembly;
                                }

                                return asm.Equals( typeof(EssCore).Assembly );
                            };

                            EssProvider.CommandManager.Commands
                                .Where( isEssentialsCommand )
                                .ForEach( command => {
                                    builder.Append( "  /" )
                                            .Append( command.Name.ToLower() )
                                            .Append( command.Usage == "" ? "" : " " + command.Usage )
                                            .Append( " - " ).Append( command.Description )
                                            .AppendLine();
                                } );

                            _cachedCommands = builder.ToString();
                        }

                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine( _cachedCommands );
                        Console.WriteLine( "Use /ess help <command> to view help page." );
                    }
                    else
                    {
                        EssLang.PLAYER_CANNOT_EXECUTE.SendTo( src );
                    }
                    break;

                case "info":
                    if ( src.IsConsole )
                        Console.ForegroundColor = ConsoleColor.Green;

                    src.SendMessage( "Author:  leonardosc", Color.yellow );
                    src.SendMessage( "Skype:   devleeo", Color.yellow );
                    src.SendMessage( "Github:  github.com/leonardosnt", Color.yellow );
                    src.SendMessage( "Version: " + EssCore.PLUGIN_VERSION, Color.yellow );
                    break;

                case "help":
                    if ( src.IsConsole )
                        Console.ForegroundColor = ConsoleColor.Green;

                    if ( args.Length == 1 )
                    {
                        src.SendMessage( "Use /ess help <command>" );
                    }
                    else
                    {
                        var command = EssProvider.CommandManager.GetByName( args[1].ToString() );

                        if ( command == null )
                        {
                            src.SendMessage( $"Command {args[1]} does not exists", Color.red );
                        }
                        else
                        {
                            src.SendMessage( "Command: " + command.Name , Color.cyan);
                            src.SendMessage( "  Arguments: <optional> [required]", Color.cyan );
                            src.SendMessage( "  Help: " + command.Description, Color.cyan );
                            src.SendMessage( "  Usage: /" + command.Name + " " + command.Usage, Color.cyan );
                            if ( command.Aliases.Any() )
                                src.SendMessage( "  Aliases: " + string.Join( ", ", command.Aliases ), Color.cyan );
                        }
                    }
                    break;

                default:
                    src.SendMessage( "Use /ess <commands/help/info>" );
                    break;
            }
        }
예제 #23
0
 private static void ShowUsage( ICommandSource src, ICommand cmd )
 {
     src.SendMessage( $"Use /{cmd.Name} {cmd.Usage}" );
 }
예제 #24
0
        public void SendTo( ICommandSource source, params object[] replacers )
        {
            var message = _message.Clone() as string;
            var color = ColorUtil.GetMessageColor( ref message );

            source.SendMessage( replacers == null ? message :
                string.Format( message, replacers ), color );
        }
예제 #25
0
    public override void OnExecute( ICommandSource source, ICommandArgs parameters )
    {
        var players = UServer.Players.ToList();

            if ( players.Count == ( source.IsConsole ? 0 : 1) )
            {
                EssLang.NO_PLAYERS_FOR_TELEPORT.SendTo( source );
            }
            else
            {
                switch ( parameters.Length )
                {
                    case 0:
                        if ( source.IsConsole )
                        {
                            source.SendMessage( "Use /tpall [player/position[x, y, z]]" );
                        }
                        else
                        {
                            TeleportAll( source.ToPlayer().RocketPlayer.Position, players );
                            EssLang.TELEPORTED_ALL_YOU.SendTo( source );
                        }
                        break;
                    case 1:
                        var found = UPlayer.TryGet( parameters[0], player => {
                            TeleportAll( player.Position, players );
                            EssLang.TELEPORTED_ALL_PLAYER.SendTo( source, player.DisplayName );
                        } );

                        if ( !found )
                        {
                            EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[0].ToString() );
                        }
                        break;
                    case 3:
                        try
                        {
                            var x = (float) parameters[0].ToDouble;
                            var y = (float) parameters[1].ToDouble;
                            var z = (float) parameters[2].ToDouble;

                            var pos = new Vector3( x, y, z );

                            TeleportAll( pos, players );
                            EssLang.TELEPORTED_ALL_COORDS.SendTo( source, x, y, z );
                        }
                        catch ( FormatException )
                        {
                            EssLang.INVALID_COORDS.SendTo(
                                source,
                                parameters[0],
                                parameters[1],
                                parameters[2]
                            );
                        }
                        break;

                    default:
                        source.SendMessage( "Use /tpall [player/position[x, y, z]]" );
                        break;
                }
            }
    }
예제 #26
0
        public void ItemInfoCommand( ICommandSource src, ICommandArgs args, ICommand cmd )
        {
            if ( src.IsConsole && args.Length != 1 )
            {
                ShowUsage( src, cmd );
                return;
            }

            ItemAsset asset;

            if ( args.Length == 0 )
            {
                var equipament = src.ToPlayer().Equipment;

                if ( equipament.HoldingItemID == 0 )
                {
                    EssLang.EMPTY_HANDS.SendTo( src );
                }

                asset = equipament.asset;
            }
            else
            {
                if ( !args[0].IsUshort ||
                    (asset = Assets.find( EAssetType.ITEM, args[0].ToUshort ) as ItemAsset) == null)
                {
                    EssLang.INVALID_ITEM_ID.SendTo( src, args[0] );
                    return;
                }
            }

            var color       = Color.yellow;
            var name        = WrapMessage( src, asset.name );
            var description = WrapMessage( src, asset.Description );
            var type        = WrapMessage( src, asset.ItemType.ToString() );
            var isPro       = WrapMessage( src, asset.isPro.ToString() );

            src.SendMessage( $"Name: {name}", color );
            src.SendMessage( $"Description: {description}", color );
            src.SendMessage( $"Id: {asset.id}", color );
            src.SendMessage( $"Type: {type}", color );
            src.SendMessage( $"IsPro: {isPro}", color );
        }
예제 #27
0
        private CommandResult ClearCommand(ICommandSource src, ICommandArgs args, ICommand cmd)
        {
            if (args.IsEmpty)
            {
                return(CommandResult.ShowUsage());
            }

            /*
             *  TODO: Options
             *      -i = items
             *      -v = vehicles
             *      -z = zombies
             *      -b = barricades
             *      -s = structures
             *      -a = ALL
             *
             *  /clear -i -z -v = items, zombies, vehicles
             */

            var distance = -1;

            if (args.Length > 1)
            {
                if (src.IsConsole)
                {
                    return(CommandResult.ShowUsage());
                }

                if (!args[1].IsInt)
                {
                    return(CommandResult.LangError("INVALID_NUMBER", args[1]));
                }

                if (args[1].ToInt < 1)
                {
                    return(CommandResult.LangError("NUMBER_BETWEEN", 1, int.MaxValue));
                }

                distance = args[1].ToInt;
            }

            switch (args[0].ToLowerString)
            {
            case "ev":
            case "emptyvehicles":
                if (!src.HasPermission(cmd.Permission + ".emptyvehicles"))
                {
                    return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
                }

                src.SendMessage("This command is unstable and can cause bugs.", Color.yellow);

                var numRemoved = 0;
                //VehicleManager.vehicles
                //    .Where(v => v.passengers.All(p => p?.player == null)) // Check if it's has no passengers
                //    .Where(v =>
                //    {
                //        if (v.id == 186 || v.id == 187) return false; // Ignore trains; TODO: config blacklist for this?
                //        if (distance == -1) return true;

                //        return Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance;
                //    })
                //    .Select(v => v.instanceID)
                //    .ToList()
                //    .ForEach(id =>
                //    {
                //        VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
                //        numRemoved++;
                //    });
                //VehicleManager.vehicles
                //   .Where(v => v.passengers.All(p => p?.player == null)) // Check if it's has no passengers
                //   .Where(v =>
                //   {
                //       if (v.id == 186 || v.id == 187) return false; // Ignore trains; TODO: config blacklist for this?
                //        if (distance == -1) return true;

                //       return Vector3.Distance(v.transform.position, src.ToPlayer().Position) <= distance;
                //   })
                //   .Select(v => v.instanceID)
                //   .ToList()
                //   .ForEach(id =>
                //   {
                //       VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, id);
                //       numRemoved++;
                //   });
                for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
                {
                    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
                    numRemoved++;
                }
                for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
                {
                    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
                    numRemoved++;
                }
                //while (VehicleManager.vehicles.Count != 0)
                //{
                //    for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
                //    {
                //        VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
                //        numRemoved++;
                //    }
                //}
                //for (byte i = (byte)(VehicleManager.vehicles.Count - 1); i >= 0 ; i--)
                //{
                //    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, VehicleManager.vehicles[i].instanceID);
                //    numRemoved++;
                //}

                //InteractableVehicle[] vehicles = new InteractableVehicle[VehicleManager.vehicles.Count];
                //for (byte i = 0; i < VehicleManager.vehicles.Count; i++)
                //{
                //    vehicles[i] = VehicleManager.vehicles[i];
                //}
                //Console.WriteLine($"VehicleManager.vehicles.Count: {VehicleManager.vehicles.Count}");
                //int len = (VehicleManager.vehicles.Count - 1);
                //for (int index1 = len; index1 >= 0; index1--)
                //{
                //    Console.WriteLine($"index1: {index1}");
                //    //VehicleManager.vehicles.Remove(VehicleManager.vehicles[index1]);
                //    UnityEngine.Object.Destroy((UnityEngine.Object)VehicleManager.vehicles[index1].gameObject);
                //}
                //Console.WriteLine($"VehicleManager.vehicles.Count: {VehicleManager.vehicles.Count}");
                //VehicleManager.respawnVehicleIndex = (ushort)0;
                //VehicleManager.vehicles.Clear();

                //for (byte i = 1; i < vehicles.Length - 1; i++)
                //{
                //    if (vehicles[i].passengers != null || vehicles[i].passengers.Length != 0 || vehicles[i].id == 186 || vehicles[i].id == 187)
                //        continue;
                //    VehicleManager.instance.channel.send("tellVehicleDestroy", ESteamCall.ALL, ESteamPacket.UPDATE_RELIABLE_BUFFER, vehicles[i].instanceID);
                //}

                EssLang.Send(src, "CLEAR_EMPTY_VEHICLES", numRemoved);
                break;

            case "i":
            case "items":
                if (!src.HasPermission(cmd.Permission + ".items"))
                {
                    return(CommandResult.LangError("COMMAND_NO_PERMISSION"));
                }

                ItemManager.askClearAllItems();
                EssLang.Send(src, "CLEAR_ITEMS");
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            return(CommandResult.Success());
        }
예제 #28
0
 protected virtual void ShowUsage(ICommandSource source)
 {
     source.SendMessage(UsageMessage);
 }
예제 #29
0
 protected virtual void ShowUsage( ICommandSource source )
 {
     source.SendMessage( UsageMessage );
 }
예제 #30
0
        public override CommandResult OnExecute(ICommandSource src, ICommandArgs args)
        {
            if (args.Length < 2)
            {
                return(CommandResult.ShowUsage());
            }

            var kitManager = KitModule.Instance.KitManager;
            var kitName    = args[0].ToString();

            if (!kitManager.Contains(kitName))
            {
                return(CommandResult.Lang("KIT_NOT_EXIST", kitName));
            }

            var kit = kitManager.GetByName(kitName);

            switch (args[1].ToLowerString)
            {
            case "view":
                src.SendMessage($"Name: {kit.Name}");
                src.SendMessage($"Cooldown: {kit.Cooldown}");
                src.SendMessage($"Cost: {kit.Cost}");
                src.SendMessage($"ResetCooldownWhenDie: {kit.ResetCooldownWhenDie}");
                src.SendMessage(string.Empty);
                src.SendMessage("Items:");

                var index = 0;

                kit.Items.ForEach(i => {
                    src.SendMessage(i.ToString().Insert(0, $" [{(index++) + 1}] "));
                });
                break;

            /* ekit name additem normal id amount durability */
            case "additem":
                if (args.Length < 3)
                {
                    return(CommandResult.InvalidArgs("Use /ekit [kit] additem [type] [id] [amount] [durability]"));
                }

                byte durability = 100;
                byte amount     = 1;

                if (args.Length >= 5)
                {
                    if (!args[4].IsInt)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[4]));
                    }

                    var argAsInt = args[4].ToInt;

                    if (argAsInt < 0 || argAsInt > 255)
                    {
                        return(CommandResult.Lang("NEGATIVE_OR_LARGE"));
                    }

                    amount = (byte)args[4].ToInt;
                }

                if (args.Length >= 6)
                {
                    if (!args[5].IsInt)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[5]));
                    }

                    var argAsInt = args[5].ToInt;

                    if (argAsInt < 0 || argAsInt > 255)
                    {
                        return(CommandResult.Lang("NEGATIVE_OR_LARGE"));
                    }

                    durability = (byte)args[5].ToInt;
                }

                switch (args[2].ToLowerString)
                {
                case "normal":
                    if (args.Length < 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem " +
                                                         "[type] [id] [amount] [durability]"));
                    }

                    var optAsset = ItemUtil.GetItem(args[3].ToString());

                    if (optAsset.IsAbsent)
                    {
                        return(CommandResult.Lang("INVALID_ITEM_ID_NAME", args[3]));
                    }

                    kit.Items.Add(new KitItem(optAsset.Value.id, durability, amount));
                    src.SendMessage($"Added Id: {optAsset.Value.id}, Amount: {amount}, " +
                                    $"Durability: {durability}");
                    break;

                case "vehicle":
                    if (args.Length != 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem vehicle [id]"));
                    }

                    if (!args[3].IsInt)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[3]));
                    }

                    var argAsInt = args[3].ToInt;

                    if (argAsInt < 0 || argAsInt > ushort.MaxValue)
                    {
                        return(CommandResult.Lang("NEGATIVE_OR_LARGE"));
                    }

                    var vehicleAsset = Assets.find(EAssetType.VEHICLE, (ushort)argAsInt);

                    if (vehicleAsset == null)
                    {
                        return(CommandResult.Lang("INVALID_VEHICLE_ID", argAsInt));
                    }

                    kit.Items.Add(new KitItemVehicle((ushort)argAsInt));
                    src.SendMessage($"Added Vehicle item. Id: {argAsInt}");
                    break;

                case "xp":
                    if (args.Length != 4)
                    {
                        return(CommandResult.InvalidArgs("Use /ekit [kit] additem xp [amount]"));
                    }

                    if (!args[3].IsInt)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[3]));
                    }

                    if (args[3].ToInt < 0)
                    {
                        return(CommandResult.Lang("MUST_POSITIVE"));
                    }

                    kit.Items.Add(new KitItemExperience(args[3].ToUInt));
                    src.SendMessage($"Added Xp item. Amount: {amount}");
                    break;

                default:
                    return(CommandResult.Error("Invalid type '{args[2]}'. Valid types are: 'normal', 'vehicle' and 'xp'"));
                }
                break;

            /* ekit name delitem [itemindex] */
            case "delitem":
                if (args.Length != 3)
                {
                    src.SendMessage("Use '/ekit [kit] delitem [itemIndex]'");
                    src.SendMessage("Use '/ekit [kit] view' to view valid indexes.");

                    return(CommandResult.InvalidArgs());
                }

                if (!args[2].IsInt)
                {
                    return(CommandResult.Lang("INVALID_NUMBER", args[2]));
                }

                var argAsInt2 = args[2].ToInt;

                if (argAsInt2 <= 0)
                {
                    return(CommandResult.Lang("MUST_POSITIVE"));
                }

                /* 1 to kitItems.Count */
                if ((argAsInt2 - 1) > kit.Items.Count)
                {
                    src.SendMessage($"Invalid index, index must be between 1 and {kit.Items.Count}");
                    src.SendMessage("Use '/ekit [kit] view' to view valid indexes.");

                    return(CommandResult.InvalidArgs());
                }

                kit.Items.RemoveAt(argAsInt2 - 1);
                src.SendMessage($"Removed item at index {argAsInt2}");
                break;

            case "set":
                if (args.Length < 3)
                {
                    src.SendMessage("Use /ekit [kit] set [option] [value]");
                    src.SendMessage("nm  = Name");
                    src.SendMessage("cst = Cost");
                    src.SendMessage("cd  = Cooldown");
                    src.SendMessage("rwd = ResetCooldownWhenDie");

                    return(CommandResult.InvalidArgs());
                }

                switch (args[2].ToLowerString)
                {
                case "cost":
                case "cst":
                    if (!args[3].IsDouble)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[3]));
                    }

                    kit.Cost = (decimal)args[3].ToDouble;
                    src.SendMessage("Cost set to " + kit.Cost);
                    break;

                case "name":
                case "nm":
                    kit.Name = args[3].ToString();
                    src.SendMessage("Name set to " + kit.Name);
                    break;

                case "cooldown":
                case "cd":
                    if (!args[3].IsInt)
                    {
                        return(CommandResult.Lang("INVALID_NUMBER", args[3]));
                    }

                    if (args[3].ToInt < 0)
                    {
                        return(CommandResult.Lang("MUST_POSITIVE"));
                    }

                    kit.Cooldown = args[3].ToUInt;
                    src.SendMessage("Cooldown set to " + kit.Cooldown);
                    break;

                case "resetcooldownwhendie":
                case "rwd":
                    if (!args[3].IsBool)
                    {
                        return(CommandResult.Lang("INVALID_BOOLEAN", args[3]));
                    }

                    kit.ResetCooldownWhenDie = args[3].ToBool;
                    src.SendMessage("ResetCooldownWhenDie set to " + kit.ResetCooldownWhenDie);
                    break;

                default:
                    src.SendMessage("nm  = Name");
                    src.SendMessage("cd  = Cooldown");
                    src.SendMessage("cst = Cost");
                    src.SendMessage("rwd = ResetCooldownWhenDie");
                    return(CommandResult.InvalidArgs());
                }
                break;

            default:
                return(CommandResult.ShowUsage());
            }

            kitManager.SaveKits();
            kitManager.LoadKits();

            return(CommandResult.Success());
        }
예제 #31
0
        public override void OnExecute( ICommandSource source, ICommandArgs parameters )
        {
            if ( parameters.Length == 0 || ( parameters.Length == 1 && source.IsConsole ) )
            {
                source.SendMessage( source.IsAdmin ? 
                    UsageMessage : "Use /kit [kit_name]" );
            }
            else if ( parameters.Length == 1 )
            {
                var player = source.ToPlayer();

                if ( EssProvider.KitManager.Contains( parameters[0].ToString() ) )
                {
                    var kitName = parameters[0].ToLowerString;
                    var requestedKit = EssProvider.KitManager.GetByName(kitName);

                    if ( !requestedKit.CanUse( player ) )
                    {
                        EssLang.KIT_NO_PERMISSION.SendTo( player );
                    }
                    else
                    {
                        var steamPlayerId    = player.CSteamId.m_SteamID;
                        var kitCooldown      = requestedKit.Cooldown;

                        if ( !source.HasPermission("essentials.kits.bypasscooldown") )
                        {
                            if ( !Cooldowns.ContainsKey( steamPlayerId ) )
                            {
                                Cooldowns.Add( steamPlayerId, new Dictionary<string, DateTime>() );
                            }
                            if ( Cooldowns[steamPlayerId].ContainsKey( kitName ) )
                            {
                                var remainingTime = DateTime.Now - Cooldowns[steamPlayerId][kitName];
                                if ( remainingTime.TotalSeconds > kitCooldown )
                                {
                                    Console.WriteLine( "3" );
                                    Cooldowns[steamPlayerId][kitName] = DateTime.Now;
                                }
                                else
                                {
                                    EssLang.KIT_COOLDOWN.SendTo( source, FormatSeconds(
                                        (uint) (kitCooldown - remainingTime.TotalSeconds)
                                    ));
                                    return;
                                }
                            }
                            else
                            {
                                Cooldowns[steamPlayerId].Add( kitName, DateTime.Now );
                            }
                        }
                        EssProvider.KitManager.GetByName( kitName ).GiveTo( player );
                    }
                }
                else
                {
                    EssLang.KIT_NOT_EXIST.SendTo( player, parameters[0] );
                }
            }
            else if ( parameters.Length == 2 )
            {
                var kitName = parameters[0].ToString();

                if ( !source.HasPermission( $"essentials.kit.{kitName}.other" ) )
                {
                    return;
                }

                var target = parameters[1].ToPlayer;

                if ( target == null )
                {
                    EssLang.PLAYER_NOT_FOUND.SendTo( source, parameters[1] );
                }
                else if ( EssProvider.KitManager.Contains( kitName ) )
                {
                    EssProvider.KitManager.GetByName(kitName).GiveTo( target );
                    EssLang.KIT_GIVEN_SENDER.SendTo( source, kitName, target );
                }
                else
                {
                    EssLang.KIT_NOT_EXIST.SendTo( source, kitName );
                }
            }
        }