private void UnsharePublicCommand_Exec(CommandArgs args)
        {
            if (args == null || this.IsDisposed)
            return;

              bool persistentMode = false;
              if (args.Parameters.Count > 0) {
            if (args.ContainsParameter("+p", StringComparison.InvariantCultureIgnoreCase)) {
              persistentMode = true;
            } else {
              args.Player.SendErrorMessage("Proper syntax: /unsharepublic [+p]");
              args.Player.SendInfoMessage("Type /unsharepublic help to get more help to this command.");
              return;
            }
              }

              this.StartShareCommandInteraction(args.Player, persistentMode, false, false, true);
        }
        private void SwapChestCommand_Exec(CommandArgs args)
        {
            if (args == null || this.IsDisposed)
            return;

              bool persistentMode = false;
              if (args.Parameters.Count > 0) {
            if (args.ContainsParameter("+p", StringComparison.InvariantCultureIgnoreCase)) {
              persistentMode = true;
            } else {
              args.Player.SendErrorMessage("Proper syntax: /swapchest [+p]");
              args.Player.SendInfoMessage("Type /swapchest help to get more help to this command.");
              return;
            }
              }

              CommandInteraction interaction = this.StartOrResetCommandInteraction(args.Player);
              interaction.DoesNeverComplete = persistentMode;
              interaction.TileEditCallback += (playerLocal, editType, tileId, location, objectStyle) => {
            if (
              editType != TileEditType.PlaceTile ||
              editType != TileEditType.PlaceWall ||
              editType != TileEditType.DestroyWall ||
              editType != TileEditType.PlaceActuator
            ) {
              IChest newChest;
              this.TrySwapChestData(playerLocal, location, out newChest);

              playerLocal.SendTileSquare(location);
              return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
            }

            playerLocal.SendTileSquare(location);
            return new CommandInteractionResult { IsHandled = false, IsInteractionCompleted = false };
              };
              interaction.ChestOpenCallback += (playerLocal, location) => {
            IChest newChest;
            this.TrySwapChestData(playerLocal, location, out newChest);
            playerLocal.SendTileSquare(location, 3);

            return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
              };
              interaction.TimeExpiredCallback += (playerLocal) => {
            playerLocal.SendErrorMessage("Waited too long. The next hit or opened chest will not swapped.");
              };

              args.Player.SendInfoMessage("Hit or open a chest to swap its data storage.");
        }
        private void DumpBankChestCommand_Exec(CommandArgs args)
        {
            if (args == null || this.IsDisposed)
            return;

              bool persistentMode = false;
              if (args.Parameters.Count > 0) {
            if (args.ContainsParameter("+p", StringComparison.InvariantCultureIgnoreCase)) {
              persistentMode = true;
            } else {
              args.Player.SendErrorMessage("Proper syntax: /dumpbankchest [+p]");
              args.Player.SendInfoMessage("Type /dumpbankchest help to get more help to this command.");
              return;
            }
              }

              Action<TSPlayer,DPoint> dumpBankChest = (playerLocal, chestLocation) => {
            foreach (ProtectionEntry protection in this.ProtectionManager.EnumerateProtectionEntries(chestLocation)) {
              if (protection.BankChestKey == BankChestDataKey.Invalid) {
            args.Player.SendErrorMessage("This is not a bank chest.");
            return;
              }

              protection.BankChestKey = BankChestDataKey.Invalid;
              args.Player.SendSuccessMessage("The bank chest content was sucessfully dumped and the bank chest instance was removed.");
              return;
            }

            args.Player.SendErrorMessage("This chest is not protected by Protector at all.");
              };

              CommandInteraction interaction = base.StartOrResetCommandInteraction(args.Player);
              interaction.DoesNeverComplete = persistentMode;
              interaction.TileEditCallback += (playerLocal, editType, tileId, location, objectStyle) => {
            if (
              editType != TileEditType.PlaceTile ||
              editType != TileEditType.PlaceWall ||
              editType != TileEditType.DestroyWall ||
              editType != TileEditType.PlaceActuator
            ) {
              dumpBankChest(playerLocal, location);
              playerLocal.SendTileSquare(location);

              return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
            }

            playerLocal.SendTileSquare(location);
            return new CommandInteractionResult { IsHandled = false, IsInteractionCompleted = false };
              };
              interaction.ChestOpenCallback += (playerLocal, chestLocation) => {
            dumpBankChest(playerLocal, chestLocation);
            return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
              };
              interaction.TimeExpiredCallback += (player) => {
            player.SendErrorMessage("Waited too long, no bank chest will be dumped.");
              };
              args.Player.SendInfoMessage("Open a bank chest to dump its content.");
        }
        private void ProtectionInfoCommand_Exec(CommandArgs args)
        {
            if (args == null || this.IsDisposed)
            return;

              bool persistentMode = false;
              if (args.Parameters.Count > 0) {
            if (args.ContainsParameter("+p", StringComparison.InvariantCultureIgnoreCase)) {
              persistentMode = true;
            } else {
              args.Player.SendErrorMessage("Proper syntax: /protectioninfo [+p]");
              args.Player.SendInfoMessage("Type /protectioninfo help to get more help to this command.");
              return;
            }
              }

              CommandInteraction interaction = this.StartOrResetCommandInteraction(args.Player);
              interaction.DoesNeverComplete = persistentMode;
              interaction.TileEditCallback += (playerLocal, editType, tileId, location, objectStyle) => {
            if (
              editType != TileEditType.PlaceTile ||
              editType != TileEditType.PlaceWall ||
              editType != TileEditType.DestroyWall ||
              editType != TileEditType.PlaceActuator
            ) {
              this.TryGetProtectionInfo(playerLocal, location);

              playerLocal.SendTileSquare(location);
              return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
            }

            playerLocal.SendTileSquare(location);
            return new CommandInteractionResult { IsHandled = false, IsInteractionCompleted = false };
              };
              Func<TSPlayer,DPoint,CommandInteractionResult> usageCallbackFunc = (playerLocal, location) => {
            this.TryGetProtectionInfo(playerLocal, location);
            playerLocal.SendTileSquare(location, 3);

            return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
              };
              interaction.SignReadCallback += usageCallbackFunc;
              interaction.ChestOpenCallback += usageCallbackFunc;
              interaction.HitSwitchCallback += usageCallbackFunc;
              interaction.SignEditCallback += (playerLocal, signIndex, location, newText) => {
            this.TryGetProtectionInfo(playerLocal, location);
            return new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
              };
              interaction.TimeExpiredCallback += (playerLocal) => {
            playerLocal.SendMessage("Waited too long. No protection info for the next object or block being hit will be shown.", Color.Red);
              };

              args.Player.SendInfoMessage("Hit or use a protected object or block to get some info about it.");
        }
        private bool TryExecuteSubCommand(string commandNameLC, CommandArgs args)
        {
            switch (commandNameLC) {
            case "commands":
            case "cmds":
              args.Player.SendMessage("Available Sub-Commands:", Color.White);
              args.Player.SendMessage("/ac blocks", Color.Yellow);
              args.Player.SendMessage("/ac toggle|switch", Color.Yellow);

              if (args.Player.Group.HasPermission(AdvancedCircuitsPlugin.ReloadCfg_Permission))
            args.Player.SendMessage("/ac reloadcfg", Color.Yellow);

              return true;
            case "reloadcfg":
              if (args.Player.Group.HasPermission(AdvancedCircuitsPlugin.ReloadCfg_Permission)) {
            this.PluginTrace.WriteLineInfo("Reloading configuration file.");
            try {
              this.ReloadConfigurationCallback();
              this.PluginTrace.WriteLineInfo("Configuration file successfully reloaded.");

              if (args.Player != TSPlayer.Server)
                args.Player.SendMessage("Configuration file successfully reloaded.", Color.Yellow);
            } catch (Exception ex) {
              this.PluginTrace.WriteLineError(
                "Reloading the configuration file failed. Keeping old configuration. Exception details:\n{0}", ex
              );
            }
              } else {
            args.Player.SendErrorMessage("You do not have the necessary permission to do that.");
              }

              return true;
            case "blocks":
            case "ores":
            case "tiles":
              int pageNumber;
              if (!PaginationUtil.TryParsePageNumber(args.Parameters, 1, args.Player, out pageNumber))
            return true;

              PaginationUtil.SendPage(
            args.Player, pageNumber,
            new List<string>() {
              "Copper Ore - OR-Gate",
              "Silver Ore - AND-Gate",
              "Gold Ore - XOR-Gate / XOR-Port",
              "Obsidian - NOT-Gate / NOT-Port",
              "Iron Ore - Swapper",
              "Spike - Crossover Bridge",
              "Glass - Input Port",
              "Active Stone - Active Stone and Block Activator",
              "Adamantite Ore - Wireless Transmitter"
            },
            new PaginationUtil.Settings {
              HeaderFormat = "Advanced Circuits Special Blocks (Page {0} of {1})",
              HeaderTextColor = Color.Lime,
              LineTextColor = Color.LightGray,
              MaxLinesPerPage = 4,
            }
              );

              return true;
            case "toggle":
            case "switch":
              args.Player.SendInfoMessage("Place or destroy a wire on the component you want to toggle.");

              if (args.Parameters.Count > 3) {
            args.Player.SendErrorMessage("Proper syntax: /ac switch [state] [+p]");
            args.Player.SendInfoMessage("Type /ac switch help to get more help to this command.");
            return true;
              }

              bool persistentMode = false;
              bool? newState = null;
              if (args.Parameters.Count > 1) {
            int newStateRaw;
            if (int.TryParse(args.Parameters[1], out newStateRaw))
              newState = (newStateRaw == 1);

            persistentMode = args.ContainsParameter("+p", StringComparison.InvariantCultureIgnoreCase);
              }

              CommandInteraction interaction = this.StartOrResetCommandInteraction(args.Player);
              interaction.DoesNeverComplete = persistentMode;
              interaction.TileEditCallback = (player, editType, blockType, location, blockStyle) => {
            if (
              editType != TileEditType.PlaceTile ||
              editType != TileEditType.PlaceWall ||
              editType != TileEditType.DestroyWall ||
              editType != TileEditType.PlaceActuator
            ) {
              CommandInteractionResult result = new CommandInteractionResult { IsHandled = true, IsInteractionCompleted = true };
              Tile tile = TerrariaUtils.Tiles[location];

              if (
                TShock.CheckTilePermission(args.Player, location.X, location.Y) || (
                  this.PluginCooperationHandler.IsProtectorAvailable &&
                  this.PluginCooperationHandler.Protector_CheckProtected(args.Player, location, false)
                )
              ) {
                player.SendErrorMessage("This object is protected.");
                player.SendTileSquare(location, 1);
                return result;
              }

              BlockType hitBlockType = (BlockType)tile.type;
              if (tile.active() && hitBlockType == BlockType.ActiveStone) {
                if (newState == null || newState == false)
                  TerrariaUtils.Tiles.SetBlock(location, BlockType.InactiveStone);
                else
                  args.Player.SendTileSquare(location);
              } else if (hitBlockType == BlockType.InactiveStone) {
                if (tile.active() &&  newState == null || newState == true)
                  TerrariaUtils.Tiles.SetBlock(location, BlockType.ActiveStone);
                else
                  args.Player.SendTileSquare(location);
              } else if (tile.active() && TerrariaUtils.Tiles.IsMultistateObject(hitBlockType)) {
                ObjectMeasureData measureData = TerrariaUtils.Tiles.MeasureObject(location);
                bool currentState = TerrariaUtils.Tiles.ObjectHasActiveState(measureData);
                if (newState == null)
                  newState = !TerrariaUtils.Tiles.ObjectHasActiveState(measureData);

                if (currentState != newState.Value)
                  TerrariaUtils.Tiles.SetObjectState(measureData, newState.Value);
                else
                  args.Player.SendTileSquare(location);
              } else if (
                hitBlockType == AdvancedCircuits.BlockType_ORGate ||
                hitBlockType == AdvancedCircuits.BlockType_ANDGate ||
                hitBlockType == AdvancedCircuits.BlockType_XORGate
              ) {
                if (
                  TShock.CheckTilePermission(args.Player, location.X, location.Y) || (
                  this.PluginCooperationHandler.IsProtectorAvailable &&
                  this.PluginCooperationHandler.Protector_CheckProtected(args.Player, location, false)
                )) {
                  player.SendErrorMessage("This gate is protected.");
                  player.SendTileSquare(location);
                  return result;
                }

                PaintColor paint = (PaintColor)TerrariaUtils.Tiles[location].color();
                if (paint == AdvancedCircuits.Paint_Gate_TemporaryState) {
                  player.SendErrorMessage("The gate is painted {0}, there's no point in initializing it.", AdvancedCircuits.Paint_Gate_TemporaryState);
                  args.Player.SendTileSquare(location);
                  return result;
                }

                GateStateMetadata gateState;
                if (!this.WorldMetadata.GateStates.TryGetValue(location, out gateState)) {
                  gateState = new GateStateMetadata();
                  this.WorldMetadata.GateStates.Add(location, gateState);
                }

                List<DPoint> gatePortLocations = new List<DPoint>(AdvancedCircuits.EnumerateComponentPortLocations(location, new DPoint(1, 1)));
                for (int i = 0; i < 4; i++) {
                  Tile gatePort = TerrariaUtils.Tiles[gatePortLocations[i]];
                  if (!gatePort.active() || gatePort.type != (int)AdvancedCircuits.BlockType_InputPort)
                    continue;

                  if (newState == null) {
                    if (gateState.PortStates[i] == null)
                      gateState.PortStates[i] = true;
                    else
                      gateState.PortStates[i] = !gateState.PortStates[i];
                  } else {
                    gateState.PortStates[i] = newState.Value;
                  }
                }

                player.SendSuccessMessage("The states of this gate's ports are now:");
                this.SendGatePortStatesInfo(args.Player, gateState);
                args.Player.SendTileSquare(location);
              } else if (tile.active() && tile.type == (int)AdvancedCircuits.BlockType_InputPort) {
                foreach (DPoint adjacentTileLocation in AdvancedCircuits.EnumerateComponentPortLocations(location, new DPoint(1, 1))) {
                  Tile adjacentTile = TerrariaUtils.Tiles[adjacentTileLocation];
                  if (!adjacentTile.active() || !AdvancedCircuits.IsLogicalGate((BlockType)adjacentTile.type))
                    continue;

                  if (
                    TShock.CheckTilePermission(args.Player, adjacentTileLocation.X, adjacentTileLocation.Y) || (
                      this.PluginCooperationHandler.IsProtectorAvailable &&
                      this.PluginCooperationHandler.Protector_CheckProtected(args.Player, adjacentTileLocation, false)
                    )
                  ) {
                    player.SendErrorMessage("This gate is protected.");
                    player.SendTileSquare(location);
                    return result;
                  }

                  PaintColor paint = (PaintColor)TerrariaUtils.Tiles[location].color();
                  if (paint == AdvancedCircuits.Paint_Gate_TemporaryState) {
                    player.SendErrorMessage("The gate is painted {0}, there's no point in initializing it.", AdvancedCircuits.Paint_Gate_TemporaryState);
                    args.Player.SendTileSquare(location);
                    return result;
                  }

                  GateStateMetadata gateState;
                  if (!this.WorldMetadata.GateStates.TryGetValue(adjacentTileLocation, out gateState)) {
                    gateState = new GateStateMetadata();
                    this.WorldMetadata.GateStates.Add(adjacentTileLocation, gateState);
                  }

                  int portIndex;
                  switch (AdvancedCircuits.DirectionFromTileLocations(adjacentTileLocation, location)) {
                    case Direction.Up:
                      portIndex = 0;
                      break;
                    case Direction.Down:
                      portIndex = 1;
                      break;
                    case Direction.Left:
                      portIndex = 2;
                      break;
                    case Direction.Right:
                      portIndex = 3;
                      break;
                    default:
                      return result;
                  }

                  if (newState == null) {
                    if (gateState.PortStates[portIndex] == null)
                      gateState.PortStates[portIndex] = true;
                    else
                      gateState.PortStates[portIndex] = !gateState.PortStates[portIndex];
                  } else {
                    gateState.PortStates[portIndex] = newState.Value;
                  }

                  player.SendSuccessMessage("The states of this gate's ports are now:");
                  this.SendGatePortStatesInfo(args.Player, gateState);
                  args.Player.SendTileSquare(location);
                  return result;
                }

                player.SendErrorMessage(string.Format(
                  "The state of \"{0}\" can not be changed.", TerrariaUtils.Tiles.GetBlockTypeName(hitBlockType)
                ));

                player.SendTileSquare(location);
              }

              return result;
            }

            return new CommandInteractionResult { IsHandled = false, IsInteractionCompleted = false };
              };
              interaction.TimeExpiredCallback = (player) => {
            player.SendErrorMessage("Waited too long, no component will be toggled.");
              };

              args.Player.SendSuccessMessage("Hit an object to change its state.");
              return true;
              }

              return false;
        }