Exemple #1
0
        private void OnNewProjectile(object sender, GetDataHandlers.NewProjectileEventArgs args)
        {
            var ply = TShock.Players[args.Owner];

            if (ply.CurrentRegion == null)
            {
                return;
            }
            var rt = RtRegions.GetRtRegionByRegionId(ply.CurrentRegion.ID);

            if (rt == null || !rt.HasEvent(Events.Projban))
            {
                return;
            }

            if (rt.ProjectileIsBanned(args.Type) && !ply.HasPermission("regiontrigger.bypass.projban"))
            {
                ply.Disable($"Create banned projectile in region {rt.Region.Name}.", DisableFlags.WriteToLogAndConsole);
                ply.SendErrorMessage("This projectile is banned here.");
                ply.RemoveProjectile(args.Index, args.Owner);
            }
        }
        private void RegionSetProperties(CommandArgs args)
        {
            if (args.Parameters.Count == 0)
            {
                args.Player.SendErrorMessage("Invalid syntax! Type /rt --help to get instructions.");
                return;
            }

            var cmd = args.Parameters[0].Trim().ToLowerInvariant();

            if (cmd.StartsWith("set-"))
            {
                #region set-prop
                if (args.Parameters.Count < 3)
                {
                    args.Player.SendErrorMessage("Invalid syntax! Proper syntax: /rt set-<prop> <region> [--del] <value>");
                    return;
                }
                var propset = cmd.Substring(4);
                // check the property
                if (!PropStrings.Any(strarray => strarray.Contains(propset)))
                {
                    args.Player.SendErrorMessage("Invalid property!");
                    return;
                }
                // get the shortest representation of property.
                // e.g. event => e, projban => pb
                propset = PropStrings.Single(props => props.Contains(propset))[0];
                // check existance of region
                var region = TShock.Regions.GetRegionByName(args.Parameters[1]);
                if (region == null)
                {
                    args.Player.SendErrorMessage("Invalid region!");
                    return;
                }
                // if region hasn't been added into database
                var rt = RtRegions.GetRtRegionByRegionId(region.ID);
                if (rt == null)
                {
                    RtRegions.AddRtRegion(region.ID);
                    rt = RtRegions.GetRtRegionByRegionId(region.ID);
                }
                // has parameter --del
                var isDel = string.Equals(args.Parameters[2], "--del", StringComparison.OrdinalIgnoreCase);
                // sometimes commands with --del don't need <value> e.g. /rt set-tg <region> --del
                if (isDel && args.Parameters.Count == 3 && !DoNotNeedDelValueProps.Contains(propset))
                {
                    args.Player.SendErrorMessage($"Invalid syntax! Proper syntax: /rt set-{propset} <region> [--del] <value>");
                    return;
                }
                var propValue = isDel && args.Parameters.Count == 3 ? null : isDel
                                        ? string.Join(" ", args.Parameters.GetRange(3, args.Parameters.Count - 3))
                                        : string.Join(" ", args.Parameters.GetRange(2, args.Parameters.Count - 2));

                try
                {
                    switch (propset)
                    {
                    case "e":
                        var validatedEvents = Events.ValidateEventWhenAdd(propValue, out var invalids);
                        if (!isDel)
                        {
                            RtRegions.AddEvents(rt, validatedEvents);
                        }
                        else
                        {
                            RtRegions.RemoveEvents(rt, validatedEvents);
                        }
                        args.Player.SendSuccessMessage("Region {0} has been modified successfully!", region.Name);
                        if (!string.IsNullOrWhiteSpace(invalids))
                        {
                            args.Player.SendErrorMessage("Invalid events: {0}", invalids);
                        }
                        break;

                    case "pb":
                        if (short.TryParse(propValue, out var id) && id > 0 && id < Main.maxProjectileTypes)
                        {
                            if (!isDel)
                            {
                                RtRegions.AddProjban(rt, id);
                                args.Player.SendSuccessMessage("Banned projectile {0} in region {1}.", id, region.Name);
                            }
                            else
                            {
                                RtRegions.RemoveProjban(rt, id);
                                args.Player.SendSuccessMessage("Unbanned projectile {0} in region {1}.", id, region.Name);
                            }
                        }
                        else
                        {
                            args.Player.SendErrorMessage("Invalid projectile ID!");
                        }
                        break;

                    case "ib":
                        var items = TShock.Utils.GetItemByIdOrName(propValue);
                        if (items.Count == 0)
                        {
                            args.Player.SendErrorMessage("Invalid item.");
                        }
                        else if (items.Count > 1)
                        {
                            TShock.Utils.SendMultipleMatchError(args.Player, items.Select(i => i.Name));
                        }
                        else
                        {
                            if (!isDel)
                            {
                                RtRegions.AddItemban(rt, items[0].Name);
                                args.Player.SendSuccessMessage("Banned {0} in region {1}.", items[0].Name, region.Name);
                            }
                            else
                            {
                                RtRegions.RemoveItemban(rt, items[0].Name);
                                args.Player.SendSuccessMessage("Unbanned {0} in region {1}.", items[0].Name, region.Name);
                            }
                        }
                        break;

                    case "tb":
                        if (short.TryParse(propValue, out var tileid) && tileid >= 0 && tileid < Main.maxTileSets)
                        {
                            if (!isDel)
                            {
                                RtRegions.AddTileban(rt, tileid);
                                args.Player.SendSuccessMessage("Banned tile {0} in region {1}.", tileid, region.Name);
                            }
                            else
                            {
                                RtRegions.RemoveTileban(rt, tileid);
                                args.Player.SendSuccessMessage("Unbanned tile {0} in region {1}.", tileid, region.Name);
                            }
                        }
                        else
                        {
                            args.Player.SendErrorMessage("Invalid tile ID!");
                        }
                        break;

                    case "em":
                        RtRegions.SetEnterMessage(rt, !isDel ? propValue : null);
                        if (!isDel)
                        {
                            args.Player.SendSuccessMessage("Set enter message of region {0} to '{1}'", region.Name, propValue);
                            if (!rt.HasEvent(Event.EnterMsg))
                            {
                                args.Player.SendWarningMessage("Add event ENTERMESSAGE if you want to make it work.");
                            }
                        }
                        else
                        {
                            args.Player.SendSuccessMessage("Removed enter message of region {0}.", region.Name);
                        }
                        break;

                    case "lm":
                        RtRegions.SetLeaveMessage(rt, !isDel ? propValue : null);
                        if (!isDel)
                        {
                            args.Player.SendSuccessMessage("Set leave message of region {0} to '{1}'", region.Name, propValue);
                            if (!rt.HasEvent(Event.LeaveMsg))
                            {
                                args.Player.SendWarningMessage("Add event LEAVEMESSAGE if you want to make it work.");
                            }
                        }
                        else
                        {
                            args.Player.SendSuccessMessage("Removed leave message of region {0}.", region.Name);
                        }
                        break;

                    case "msg":
                        RtRegions.SetMessage(rt, !isDel ? propValue : null);
                        if (!isDel)
                        {
                            args.Player.SendSuccessMessage("Set message of region {0} to '{1}'", region.Name, propValue);
                            if (!rt.HasEvent(Event.Message))
                            {
                                args.Player.SendWarningMessage("Add event MESSAGE if you want to make it work.");
                            }
                        }
                        else
                        {
                            args.Player.SendSuccessMessage("Removed message of region {0}.", region.Name);
                        }
                        break;

                    case "mi":
                        if (isDel)
                        {
                            throw new Exception("Invalid usage! Proper usage: /rt set-mi <region> <interval>");
                        }
                        if (!int.TryParse(propValue, out var itv) || itv < 0)
                        {
                            throw new Exception("Invalid interval. (Interval must be integer >= 0)");
                        }
                        RtRegions.SetMsgInterval(rt, itv);
                        args.Player.SendSuccessMessage("Set message interval of region {0} to {1}.", region.Name, itv);
                        if (!rt.HasEvent(Event.Message))
                        {
                            args.Player.SendWarningMessage("Add event MESSAGE if you want to make it work.");
                        }
                        break;

                    case "tg":
                        if (!isDel && propValue != "null")
                        {
                            RtRegions.SetTempGroup(rt, propValue);
                            args.Player.SendSuccessMessage("Set tempgroup of region {0} to {1}.", region.Name, propValue);
                            if (!rt.HasEvent(Event.TempGroup))
                            {
                                args.Player.SendWarningMessage("Add event TEMPGROUP if you want to make it work.");
                            }
                        }
                        else
                        {
                            RtRegions.SetTempGroup(rt, null);
                            args.Player.SendSuccessMessage("Removed tempgroup of region {0}.", region.Name);
                        }
                        break;

                    case "tp":
                        // ReSharper disable once PossibleNullReferenceException
                        var permissions = propValue.ToLower().Split(',').Where(s => !string.IsNullOrWhiteSpace(s)).ToList();
                        if (!isDel)
                        {
                            RtRegions.AddPermissions(rt, permissions);
                            args.Player.SendSuccessMessage("Region {0} has been modified successfully.", region.Name);
                        }
                        else
                        {
                            RtRegions.DeletePermissions(rt, permissions);
                            args.Player.SendSuccessMessage("Region {0} has been modified successfully.", region.Name);
                        }
                        break;
                    }
                }
                catch (Exception ex)
                {
                    args.Player.SendErrorMessage(ex.Message);
                }
                #endregion
            }
            else
            {
                switch (cmd)
                {
                case "show":
                    #region show
                {
                    if (args.Parameters.Count != 2)
                    {
                        args.Player.SendErrorMessage("Invalid syntax! Usage: /rt show <region>");
                        return;
                    }

                    var region = TShock.Regions.GetRegionByName(args.Parameters[1]);
                    if (region == null)
                    {
                        args.Player.SendErrorMessage("Invalid region!");
                        return;
                    }
                    var rt = RtRegions.GetRtRegionByRegionId(region.ID);
                    if (rt == null)
                    {
                        args.Player.SendInfoMessage("{0} has not been set up yet. Use: /rt set-<prop> <name> <value>", region.Name);
                        return;
                    }

                    var infos = new List <string> {
                        $"*** Information of region {rt.Region.Name} ***",
                        $" * Events: {rt.Events}",
                        $" * TempGroup: {rt.TempGroup?.Name ?? "None"}",
                        $" * Message & Interval: {rt.Message ?? "None"}({rt.MsgInterval}s)",
                        $" * EnterMessage: {rt.EnterMsg ?? "None"}",
                        $" * LeaveMessage: {rt.LeaveMsg ?? "None"}",
                        $" * Itembans: {(string.IsNullOrWhiteSpace(rt.Itembans) ? "None" : rt.Itembans)}",
                        $" * Projbans: {(string.IsNullOrWhiteSpace(rt.Projbans) ? "None" : rt.Projbans)}",
                        $" * Tilebans: {(string.IsNullOrWhiteSpace(rt.Tilebans) ? "None" : rt.Tilebans)}"
                    };
                    infos.ForEach(args.Player.SendInfoMessage);
                }
                    #endregion
                    break;

                case "reload":
                    RtRegions.Reload();
                    args.Player.SendSuccessMessage("Reloaded regions from database successfully.");
                    break;

                case "--help":
                    #region Help
                    if (!PaginationTools.TryParsePageNumber(args.Parameters, 1, args.Player, out var pageNumber))
                    {
                        return;
                    }

                    var lines = new List <string>
                    {
                        "*** Usage: /rt set-<prop> <region> [--del] <value>",
                        "           /rt show <region>",
                        "           /rt reload",
                        "           /rt --help [page]",
                        "*** Avaliable properties:"
                    };
                    lines.AddRange(PaginationTools.BuildLinesFromTerms(PropStrings, array =>
                    {
                        var strarray = (string[])array;
                        return($"{strarray[0]}({string.Join("/", strarray.Skip(1))})");
                    }, ",", 75).Select(s => s.Insert(0, "   * ")));
                    lines.Add("*** Available events:");
                    lines.AddRange(Events.EventsDescriptions.Select(pair => $"   * {pair.Key} - {pair.Value}"));

                    PaginationTools.SendPage(args.Player, pageNumber, lines,
                                             new PaginationTools.Settings
                    {
                        HeaderFormat = "RegionTrigger Instructions ({0}/{1}):",
                        FooterFormat = "Type {0}rt --help {{0}} for more instructions.".SFormat(Commands.Specifier)
                    }
                                             );
                    #endregion
                    break;

                default:
                    args.Player.SendErrorMessage("Invalid syntax! Type /rt --help for instructions.");
                    return;
                }
            }
        }