Beispiel #1
0
  /** Load all the classes in the current jar file so it can be overwritten */
  private void loadAllClasses() {
    LWC lwc = LWC.getInstance();

    try {
      // Load the jar
      JarFile jar = new JarFile(lwc.getPlugin().getFile());

      // Walk through all of the entries
      Enumeration<JarEntry> enumeration = jar.entries();

      while (enumeration.hasMoreElements()) {
        JarEntry entry = enumeration.nextElement();
        String name = entry.getName();

        // is it a class file?
        if (name.endsWith(".class")) {
          // convert to package
          String path = name.replaceAll("/", ".");
          path = path.substring(0, path.length() - ".class".length());

          // Load it
          this.getClass().getClassLoader().loadClass(path);
        }
      }
    } catch (IOException e) {
      e.printStackTrace();
    } catch (ClassNotFoundException e) {
      e.printStackTrace();
    }
  }
Beispiel #2
0
  @Override
  public void onProtectionInteract(LWCProtectionInteractEvent event) {
    if (event.getResult() != Result.DEFAULT) {
      return;
    }

    if (!event.hasAction("forceowner")) {
      return;
    }

    LWC lwc = event.getLWC();
    Protection protection = event.getProtection();
    Player player = event.getPlayer();

    Action action = lwc.getMemoryDatabase().getAction("forceowner", player.getName());
    String newOwner = action.getData();

    protection.setOwner(newOwner);
    protection.save();

    lwc.sendLocale(player, "protection.interact.forceowner.finalize", "player", newOwner);
    lwc.removeModes(player);
    event.setResult(Result.CANCEL);

    return;
  }
Beispiel #3
0
  @Override
  public void load(LWC lwc) {
    configuration = Configuration.load("doors.yml");
    doors = new LinkedList<DoorAction>();
    enabled = configuration.getBoolean("doors.enabled", true);

    String action = configuration.getString("doors.action");

    if (action == null) {
      this.action = Action.NULL;
      return;
    }

    if (action.equalsIgnoreCase("openAndClose")) {
      this.action = Action.OPEN_AND_CLOSE;
      this.interval = configuration.getInt("doors.interval", 3);
    } else if (action.equalsIgnoreCase("toggle")) {
      this.action = Action.TOGGLE;
    }

    // start the task
    DoorTask doorTask = new DoorTask();
    lwc.getPlugin()
        .getServer()
        .getScheduler()
        .scheduleSyncRepeatingTask(lwc.getPlugin(), doorTask, 20, 20);
  }
Beispiel #4
0
  @Override
  public void onBlockInteract(LWCBlockInteractEvent event) {
    Player player = event.getPlayer();
    Set<String> actions = event.getActions();

    if (!actions.contains("dropTransferSelect")) {
      return;
    }

    lwc.sendLocale(player, "protection.interact.dropxfer.notprotected");
    lwc.removeModes(player);
  }
Beispiel #5
0
  @Override
  public void onRegisterProtection(LWCProtectionRegisterEvent event) {
    if (event.isCancelled()) {
      return;
    }

    LWC lwc = event.getLWC();
    Player player = event.getPlayer();
    Block block = event.getBlock();

    if (hasReachedLimit(player, block.getType())) {
      lwc.sendLocale(player, "protection.exceeded");
      event.setCancelled(true);
    }
  }
 public static boolean protectBlock(Block block, String name) {
   boolean protect = false;
   if (lwc != null) {
     lwc.getPhysicalDatabase()
         .registerProtection(
             block.getTypeId(),
             ProtectionTypes.PRIVATE,
             block.getWorld().getName(),
             name,
             "",
             block.getX(),
             block.getY(),
             block.getZ());
     protect = true;
     TDebug.debug(
         DebugDetailLevel.EVERYTHING,
         block.getType().name()
             + " block protected for "
             + name
             + ". ("
             + block.getX()
             + ", "
             + block.getY()
             + ", "
             + block.getZ()
             + ")");
   }
   return protect;
 }
Beispiel #7
0
  @Override
  @SuppressWarnings("deprecation")
  public void onDropItem(LWCDropItemEvent event) {
    Player bPlayer = event.getPlayer();
    Item item = event.getEvent().getItemDrop();
    ItemStack itemStack = item.getItemStack();

    LWCPlayer player = lwc.wrapPlayer(bPlayer);
    int protectionId = getPlayerDropTransferTarget(player);

    if (protectionId == -1) {
      return;
    }

    if (!isPlayerDropTransferring(player)) {
      return;
    }

    Protection protection = lwc.getPhysicalDatabase().loadProtection(protectionId);

    if (protection == null) {
      lwc.sendLocale(player, "lwc.nolongerexists");
      player.disableMode(player.getMode("dropTransfer"));
      return;
    }

    // load the world and the inventory
    World world = player.getServer().getWorld(protection.getWorld());

    if (world == null) {
      lwc.sendLocale(player, "lwc.invalidworld");
      player.disableMode(player.getMode("dropTransfer"));
      return;
    }

    // Don't allow them to transfer items across worlds
    if (bPlayer.getWorld() != world
        && !lwc.getConfiguration().getBoolean("modes.droptransfer.crossWorld", false)) {
      lwc.sendLocale(player, "lwc.dropxfer.acrossworlds");
      player.disableMode(player.getMode("dropTransfer"));
      return;
    }

    Block block = world.getBlockAt(protection.getX(), protection.getY(), protection.getZ());
    Map<Integer, ItemStack> remaining = lwc.depositItems(block, itemStack);

    if (remaining.size() > 0) {
      lwc.sendLocale(player, "lwc.dropxfer.chestfull");

      for (ItemStack temp : remaining.values()) {
        bPlayer.getInventory().addItem(temp);
      }
    }

    bPlayer.updateInventory(); // if they're in the chest and dropping items, this is required
    item.remove();
  }
Beispiel #8
0
  public Database() {
    currentType = DefaultType;

    prefix = LWC.getInstance().getConfiguration().getString("database.prefix", "");
    if (prefix == null) {
      prefix = "";
    }
  }
Beispiel #9
0
  @Override
  public void onProtectionInteract(LWCProtectionInteractEvent event) {
    if (event.getResult() != Result.DEFAULT) {
      return;
    }

    if (!event.hasAction("info")) {
      return;
    }

    LWC lwc = event.getLWC();
    Protection protection = event.getProtection();
    Player player = event.getPlayer();
    event.setResult(Result.CANCEL);

    String type =
        lwc.getPlugin().getMessageParser().parseMessage(protection.typeToString().toLowerCase());
    lwc.sendLocale(player, "lwc.info", "owner", protection.getOwner(), "type", type);

    if (event.canAdmin()) {
      if (protection.getType() == Protection.Type.PRIVATE
          || protection.getType() == Protection.Type.DONATION) {
        lwc.sendLocale(player, "lwc.acl", "size", protection.getPermissions().size());
        int index = 0;
        for (Permission permission : protection.getPermissions()) {
          if (index >= 9) {
            break;
          }

          player.sendMessage(permission.toString());
          index++;
        }

        if (index == 0) {
          lwc.sendLocale(player, "lwc.acl.empty");
        } else if (index >= 9) {
          lwc.sendLocale(player, "lwc.acl.limitreached");
        }

        player.sendMessage("");
      }
    }

    if (lwc.isAdmin(player)) {
      lwc.sendLocale(player, "protection.interact.info.raw", "raw", protection.toString());
    }

    lwc.removeModes(player);
  }
Beispiel #10
0
  @Override
  public void onBlockInteract(LWCBlockInteractEvent event) {
    if (event.getResult() != Result.DEFAULT) {
      return;
    }

    if (!event.hasAction("info")) {
      return;
    }

    LWC lwc = event.getLWC();
    Block block = event.getBlock();
    Player player = event.getPlayer();
    event.setResult(Result.CANCEL);

    lwc.sendLocale(
        player, "protection.interact.error.notregistered", "block", LWC.materialToString(block));
    lwc.removeModes(player);
  }
Beispiel #11
0
  @Override
  public void onCommand(LWCCommandEvent event) {
    if (event.isCancelled()) {
      return;
    }

    if (!event.hasFlag("i", "info")) {
      return;
    }

    LWC lwc = event.getLWC();
    CommandSender sender = event.getSender();
    String[] args = event.getArgs();

    if (!(sender instanceof Player)) {
      return;
    }

    event.setCancelled(true);

    if (!lwc.hasPlayerPermission(sender, "lwc.info")) {
      lwc.sendLocale(sender, "protection.accessdenied");
      return;
    }

    LWCPlayer player = lwc.wrapPlayer(sender);
    String type = "info";

    if (args.length > 0) {
      type = args[0].toLowerCase();
    }

    if (type.equals("info")) {
      Action action = new Action();
      action.setName("info");
      action.setPlayer(player);

      player.removeAllActions();
      player.addAction(action);

      lwc.sendLocale(player, "protection.info.finalize");
    }
  }
Beispiel #12
0
  /**
   * Sends the list of limits to the player
   *
   * @param sender the commandsender to send the limits to
   * @param target the player limits are being shown for, can be null
   * @param limits
   */
  public void sendLimits(CommandSender sender, Player target, List<Limit> limits) {
    LWC lwc = LWC.getInstance();

    for (Limit limit : limits) {
      if (limit == null) {
        continue;
      }

      String stringLimit =
          limit.getLimit() == UNLIMITED ? "Unlimited" : Integer.toString(limit.getLimit());
      String colour = Colors.Yellow;

      if (target != null) {
        boolean reachedLimit =
            hasReachedLimit(
                target,
                ((limit instanceof BlockLimit) ? ((BlockLimit) limit).getMaterial() : null));
        colour = reachedLimit ? Colors.Red : Colors.Green;
      }

      if (limit instanceof DefaultLimit) {
        String currentProtected =
            target != null ? (Integer.toString(limit.getProtectionCount(target, null)) + "/") : "";
        sender.sendMessage("Default: " + colour + currentProtected + stringLimit);
      } else if (limit instanceof BlockLimit) {
        BlockLimit blockLimit = (BlockLimit) limit;
        String currentProtected =
            target != null
                ? (Integer.toString(limit.getProtectionCount(target, blockLimit.getMaterial()))
                    + "/")
                : "";
        sender.sendMessage(
            lwc.materialToString(blockLimit.getMaterial())
                + ": "
                + colour
                + currentProtected
                + stringLimit);
      } else {
        sender.sendMessage(limit.getClass().getSimpleName() + ": " + Colors.Yellow + stringLimit);
      }
    }
  }
Beispiel #13
0
  @Override
  public void onCommand(LWCCommandEvent event) {
    if (event.isCancelled()) {
      return;
    }

    if (!event.hasFlag("limits")) {
      return;
    }

    LWC lwc = event.getLWC();
    CommandSender sender = event.getSender();
    String[] args = event.getArgs();
    event.setCancelled(true);

    if (args.length == 0 && !(sender instanceof Player)) {
      sender.sendMessage(Colors.Red + "Unsupported");
      return;
    }

    String playerName;

    if (args.length == 0) {
      playerName = sender.getName();
    } else {
      if (lwc.isAdmin(sender)) {
        playerName = args[0];
      } else {
        lwc.sendLocale(sender, "protection.accessdenied");
        return;
      }
    }

    Player player = lwc.getPlugin().getServer().getPlayer(playerName);

    if (player == null) {
      return;
    }

    // send their limits to them
    sendLimits(player, player, getPlayerLimits(player));
  }
Beispiel #14
0
  /**
   * Gets the list of limits that may apply to the player. For group limits, it uses the highest one
   * found.
   *
   * @param player
   * @return
   */
  public List<Limit> getPlayerLimits(Player player) {
    LWC lwc = LWC.getInstance();
    List<Limit> limits = new LinkedList<Limit>();

    // get all of their own limits
    String playerName = player.getName().toLowerCase();
    if (playerLimits.containsKey(playerName)) {
      limits.addAll(playerLimits.get(playerName));
    }

    // Look over the group limits
    for (String group : lwc.getPermissions().getGroups(player)) {
      if (groupLimits.containsKey(group)) {
        for (Limit limit : groupLimits.get(group)) {
          // try to match one already inside what we found
          Limit matched = findLimit(limits, limit);

          if (matched != null) {
            // Is our limit better?
            if (limit.getLimit() > matched.getLimit()) {
              limits.remove(matched);
              limits.add(limit);
            }
          } else {
            limits.add(limit);
          }
        }
      }
    }

    // Look at the default limits
    for (Limit limit : defaultLimits) {
      // try to match one already inside what we found
      Limit matched = findLimit(limits, limit);

      if (matched == null) {
        limits.add(limit);
      }
    }

    return limits;
  }
  public boolean lwcProtected(Block block) {
    if (lwc == null) {
      return false;
    }

    Protection protection = lwc.findProtection(block); // also accepts x, y, z

    if (protection != null) {
      return true;
    }
    return false;
  }
Beispiel #16
0
  public void init() {
    LWC lwc = LWC.getInstance();
    updateBranch = UpdateBranch.match(lwc.getConfiguration().getString("updater.branch", "STABLE"));
    updateMethod = UpdateMethod.match(lwc.getConfiguration().getString("updater.method", "MANUAL"));

    if (updateMethod == UpdateMethod.AUTOMATIC) {
      this.loadVersions(
          true,
          new Runnable() {

            public void run() {
              tryAutoUpdate(false);
              logger.info("LWC: Latest version: " + latestVersion);
            }
          });
    }

    // verify we have local files (e.g sqlite.jar, etc)
    this.verifyFiles();
    this.downloadFiles();
  }
Beispiel #17
0
  @Override
  public Result onCommand(LWC lwc, CommandSender sender, String command, String[] args) {
    if (!StringUtils.hasFlag(command, "a") && !StringUtils.hasFlag(command, "admin")) {
      return DEFAULT;
    }

    if (args.length == 0) {
      if (lwc.isAdmin(sender)) {
        lwc.sendLocale(sender, "help.admin");
      }

      return CANCEL;
    } else if (args.length > 0) {
      // check for permissions
      if (!lwc.hasAdminPermission(sender, "lwc.admin." + args[0])) {
        return CANCEL;
      }
    }

    return DEFAULT;
  }
Beispiel #18
0
  /** @return the path where the database file should be saved */
  public String getDatabasePath() {
    Configuration lwcConfiguration = LWC.getInstance().getConfiguration();

    if (currentType == Type.MySQL) {
      return "//"
          + lwcConfiguration.getString("database.host")
          + "/"
          + lwcConfiguration.getString("database.database");
    }

    return lwcConfiguration.getString("database.path");
  }
Beispiel #19
0
  @Override
  public void onProtectionInteract(LWCProtectionInteractEvent event) {
    LWC lwc = event.getLWC();
    Protection protection = event.getProtection();
    Set<String> actions = event.getActions();
    boolean canAccess = event.canAccess();

    Player bPlayer = event.getPlayer();
    LWCPlayer player = lwc.wrapPlayer(bPlayer);

    if (!actions.contains("dropTransferSelect")) {
      return;
    }

    if (!canAccess) {
      lwc.sendLocale(player, "protection.interact.dropxfer.noaccess");
    } else {
      if (protection.getBlockId() != Material.CHEST.getId()) {
        lwc.sendLocale(player, "protection.interact.dropxfer.notchest");
        player.removeAllActions();
        event.setResult(Result.CANCEL);

        return;
      }

      Mode mode = new Mode();
      mode.setName("dropTransfer");
      mode.setData(protection.getId() + "");
      mode.setPlayer(bPlayer);
      player.enableMode(mode);
      mode = new Mode();
      mode.setName("+dropTransfer");
      mode.setPlayer(bPlayer);
      player.enableMode(mode);

      lwc.sendLocale(player, "protection.interact.dropxfer.finalize");
    }

    player.removeAllActions(); // ignore the persist mode
  }
Beispiel #20
0
  @Override
  public void onProtectionInteract(LWCProtectionInteractEvent event) {
    if (event.getResult() != Result.DEFAULT) {
      return;
    }

    if (!event.hasAction("create")) {
      return;
    }

    LWC lwc = event.getLWC();
    Protection protection = event.getProtection();
    Player player = event.getPlayer();

    if (protection.isOwner(player)) {
      lwc.sendLocale(
          player,
          "protection.interact.error.alreadyregistered",
          "block",
          LWC.materialToString(protection.getBlockId()));
    } else {
      lwc.sendLocale(
          player,
          "protection.interact.error.notowner",
          "block",
          LWC.materialToString(protection.getBlockId()));
    }

    lwc.removeModes(player);
    event.setResult(Result.CANCEL);
  }
Beispiel #21
0
  @Override
  public Result onDestroyProtection(
      LWC lwc,
      Player player,
      Protection protection,
      Block block,
      boolean canAccess,
      boolean canAdmin) {
    boolean isOwner = protection.isOwner(player);

    if (isOwner) {
      protection.remove();
      lwc.sendLocale(
          player,
          "protection.unregistered",
          "block",
          LWC.materialToString(protection.getBlockId()));
      return ALLOW;
    }

    return CANCEL;
  }
Beispiel #22
0
  @Override
  public void onCommand(LWCCommandEvent event) {
    if (event.isCancelled()) {
      return;
    }

    if (!event.hasFlag("a", "admin")) {
      return;
    }

    LWC lwc = event.getLWC();
    CommandSender sender = event.getSender();
    String[] args = event.getArgs();

    if (!args[0].equals("forceowner")) {
      return;
    }

    // we have the right command
    event.setCancelled(true);

    if (args.length < 2) {
      lwc.sendSimpleUsage(sender, "/lwc admin forceowner <player>");
      return;
    }

    if (!(sender instanceof Player)) {
      lwc.sendLocale(sender, "protection.admin.noconsole");
      return;
    }

    Player player = (Player) sender;
    String newOwner = args[1];

    lwc.getMemoryDatabase().registerAction("forceowner", player.getName(), newOwner);
    lwc.sendLocale(sender, "protection.admin.forceowner.finalize", "player", newOwner);

    return;
  }
Beispiel #23
0
  @Override
  public Result onCommand(LWC lwc, CommandSender sender, String command, String[] args) {
    if (!StringUtils.hasFlag(command, "a") && !StringUtils.hasFlag(command, "admin")) {
      return DEFAULT;
    }

    if (!args[0].equals("cmd")) {
      return DEFAULT;
    }

    sender.sendMessage(Colors.Green + "Flushing Update Thread..");
    lwc.getUpdateThread().flush();
    sender.sendMessage(Colors.Green + "Done.");
    return CANCEL;
  }
Beispiel #24
0
  public void onDestroyProtection(LWCProtectionDestroyEvent event) {
    if (event.isCancelled()) {
      return;
    }

    LWC lwc = event.getLWC();
    Protection protection = event.getProtection();
    Player player = event.getPlayer();

    boolean isOwner = protection.isOwner(player);

    if (isOwner) {
      protection.remove();
      lwc.sendLocale(
          player,
          "protection.unregistered",
          "block",
          LWC.materialToString(protection.getBlockId()));
      return;
    }

    event.setCancelled(true);
    return;
  }
 public static boolean isProtected(Block chest) {
   if (lwc != null) {
     Protection lwcProt = lwc.findProtection(chest);
     if (lwcProt != null) {
       return true;
     }
   }
   if (lockette != null) {
     boolean lockProt = Lockette.isProtected(chest);
     if (lockProt) {
       return true;
     }
   }
   return false;
 }
 public static String protectedByWho(Block chest) {
   if (chest == null) {
     return null;
   }
   String name = "";
   if (lwc != null) {
     Protection prot = lwc.findProtection(chest);
     if (prot != null) {
       name = prot.getOwner();
     }
   }
   if (lockette != null) {
     name = Lockette.getProtectedOwner(chest);
   }
   return name;
 }
Beispiel #27
0
  @Override
  public void execute(LWC lwc, CommandSender sender, String[] args) {
    if (args.length < 2) {
      lwc.sendSimpleUsage(sender, "/lwc -u <Password>");
      return;
    }

    Player player = (Player) sender;
    String password = join(args, 1);
    password = encrypt(password);

    if (!lwc.getMemoryDatabase().hasPendingUnlock(player.getName())) {
      player.sendMessage(Colors.Red + "Nothing selected. Open a locked protection first.");
      return;
    } else {
      int chestID = lwc.getMemoryDatabase().getUnlockID(player.getName());

      if (chestID == -1) {
        lwc.sendLocale(player, "protection.internalerror", "id", "ulock");
        return;
      }

      Protection entity = lwc.getPhysicalDatabase().loadProtection(chestID);

      if (entity.getType() != ProtectionTypes.PASSWORD) {
        lwc.sendLocale(player, "protection.unlock.notpassword");
        return;
      }

      if (entity.getData().equals(password)) {
        lwc.getMemoryDatabase().unregisterUnlock(player.getName());
        lwc.getMemoryDatabase().registerPlayer(player.getName(), chestID);
        lwc.sendLocale(player, "protection.unlock.password.valid");
      } else {
        lwc.sendLocale(player, "protection.unlock.password.invalid");
      }
    }
  }
Beispiel #28
0
  /**
   * Checks if a player has reached their protection limit
   *
   * @param player
   * @param material the material type the player has interacted with
   * @return
   */
  public boolean hasReachedLimit(Player player, Material material) {
    LWC lwc = LWC.getInstance();
    Limit limit = getEffectiveLimit(player, material);

    // if they don't have a limit it's not possible to reach it ^^
    //  ... but if it's null, what the hell did the server owner do?
    if (limit == null) {
      return false;
    }

    // Get the effective limit placed upon them
    int neverPassThisNumber = limit.getLimit();

    // get the amount of protections the player has
    int protections = limit.getProtectionCount(player, material);

    return protections >= neverPassThisNumber;
  }
Beispiel #29
0
  public static List<Protection> loadProtections(
      String arg0, int arg1, int arg2, int arg3, int arg4, int arg5, int arg6) {
    if (lwcPlugin == null) {
      loadPlugin();
    }

    if (lwcPlugin != null) {
      List<com.griefcraft.model.Protection> loadProtections =
          lwcPlugin.getPhysicalDatabase().loadProtections(arg0, arg1, arg2, arg3, arg4, arg5, arg6);

      List<Protection> protections = null;

      if (loadProtections != null) {
        protections = new ArrayList<Protection>();
        for (com.griefcraft.model.Protection loadProtection : loadProtections) {
          protections.add(new Protection(loadProtection));
        }
      }

      return protections;
    }
    return null;
  }
Beispiel #30
0
  @Override
  public void onBlockInteract(LWCBlockInteractEvent event) {
    if (event.getResult() != Result.DEFAULT) {
      return;
    }

    if (!event.hasAction("create")) {
      return;
    }

    LWC lwc = event.getLWC();
    Block block = event.getBlock();
    LWCPlayer player = lwc.wrapPlayer(event.getPlayer());

    if (!lwc.isProtectable(block)) {
      return;
    }

    PhysDB physDb = lwc.getPhysicalDatabase();

    Action action = player.getAction("create");
    String actionData = action.getData();
    String[] split = actionData.split(" ");
    String protectionType = split[0].toLowerCase();
    String protectionData = StringUtil.join(split, 1);

    // check permissions again (DID THE LITTLE SHIT MOVE WORLDS??!?!?!?!?!?)
    if (!lwc.hasPermission(
        event.getPlayer(), "lwc.create." + protectionType, "lwc.create", "lwc.protect")) {
      lwc.sendLocale(player, "protection.accessdenied");
      lwc.removeModes(player);
      event.setResult(Result.CANCEL);
      return;
    }

    // misc data we'll use later
    String playerName = player.getName();
    String worldName = block.getWorld().getName();
    int blockX = block.getX();
    int blockY = block.getY();
    int blockZ = block.getZ();

    lwc.removeModes(player);
    LWCProtectionRegisterEvent evt =
        new LWCProtectionRegisterEvent(player.getBukkitPlayer(), block);
    lwc.getModuleLoader().dispatchEvent(evt);

    // another plugin cancelled the registration
    if (evt.isCancelled()) {
      return;
    }

    // The created protection
    Protection protection = null;

    if (protectionType.equals("public")) {
      protection =
          physDb.registerProtection(
              block.getTypeId(),
              Protection.Type.PUBLIC,
              worldName,
              player.getUniqueId().toString(),
              "",
              blockX,
              blockY,
              blockZ);
      lwc.sendLocale(player, "protection.interact.create.finalize");
    } else if (protectionType.equals("password")) {
      String password = lwc.encrypt(protectionData);

      protection =
          physDb.registerProtection(
              block.getTypeId(),
              Protection.Type.PASSWORD,
              worldName,
              player.getUniqueId().toString(),
              password,
              blockX,
              blockY,
              blockZ);
      player.addAccessibleProtection(protection);

      lwc.sendLocale(player, "protection.interact.create.finalize");
      lwc.sendLocale(player, "protection.interact.create.password");
    } else if (protectionType.equals("private") || protectionType.equals("donation")) {
      String[] rights = protectionData.split(" ");

      protection =
          physDb.registerProtection(
              block.getTypeId(),
              Protection.Type.matchType(protectionType),
              worldName,
              player.getUniqueId().toString(),
              "",
              blockX,
              blockY,
              blockZ);

      lwc.sendLocale(player, "protection.interact.create.finalize");
      lwc.processRightsModifications(player, protection, rights);
    }

    // tell the modules that a protection was registered
    if (protection != null) {
      // Fix the blocks that match it
      protection.removeCache();
      LWC.getInstance().getProtectionCache().addProtection(protection);

      lwc.getModuleLoader().dispatchEvent(new LWCProtectionRegistrationPostEvent(protection));
    }

    event.setResult(Result.CANCEL);
  }