// helper method for above.  allows visualization blocks to sit underneath partly transparent
 // blocks like grass and fence
 private static boolean isTransparent(Block block) {
   WorldConfig applicableWorld = GriefPrevention.instance.getWorldCfg(block.getWorld());
   if (applicableWorld.getModsContainerTrustIds() != null
       && applicableWorld.getModsContainerTrustIds().contains(block.getType())) return true;
   if (applicableWorld.getModsAccessTrustIds() != null
       && applicableWorld.getModsAccessTrustIds().contains(block.getType())) return true;
   return (block.getType() == Material.AIR
       || block.getType() == Material.LONG_GRASS
       || block.getType() == Material.FENCE
       || block.getType() == Material.LEAVES
       || block.getType() == Material.RED_ROSE
       || block.getType() == Material.CHEST
       || block.getType() == Material.TORCH
       || block.getType() == Material.VINE
       || block.getType() == Material.YELLOW_FLOWER
       || block.getType() == Material.CHEST
       || block.getType() == Material.ENDER_CHEST);
 }
  public String allowBuild(Player player, Location location) {
    PlayerData playerData = this.dataStore.getPlayerData(player.getName());
    Claim claim = this.dataStore.getClaimAt(location, false, playerData.lastClaim);
    WorldConfig wc = GriefPrevention.instance.getWorldCfg(player.getWorld());
    // exception: administrators in ignore claims mode and special player accounts created by server
    // mods
    if (playerData.ignoreClaims || wc.getModsIgnoreClaimsAccounts().contains(player.getName()))
      return null;

    // wilderness rules
    if (claim == null) {
      // no building in the wilderness in creative mode
      if (this.creativeRulesApply(location)) {
        String reason =
            this.dataStore.getMessage(Messages.NoBuildOutsideClaims)
                + "  "
                + this.dataStore.getMessage(Messages.CreativeBasicsDemoAdvertisement);
        if (player.hasPermission("griefprevention.ignoreclaims"))
          reason += "  " + this.dataStore.getMessage(Messages.IgnoreClaimsAdvertisement);
        return reason;
      }

      // no building in survival wilderness when that is configured
      else if (wc.getApplyTrashBlockRules() && wc.getClaimsEnabled()) {
        if (wc.getTrashBlockPlacementBehaviour().Allowed(location, player).Denied())
          return this.dataStore.getMessage(Messages.NoBuildOutsideClaims)
              + "  "
              + this.dataStore.getMessage(Messages.SurvivalBasicsDemoAdvertisement);
        else return null;
      } else {
        // but it's fine in creative
        return null;
      }
    }

    // if not in the wilderness, then apply claim rules (permissions, etc)
    else {
      // cache the claim for later reference
      playerData.lastClaim = claim;
      return claim.allowBuild(player);
    }
  }
  // called when a player spawns, applies protection for that player if necessary
  public void checkPvpProtectionNeeded(Player player) {
    WorldConfig wc = GriefPrevention.instance.getWorldCfg(player.getWorld());
    // if pvp is disabled, do nothing
    if (!player.getWorld().getPVP()) return;

    // if player is in creative mode, do nothing
    if (player.getGameMode() == GameMode.CREATIVE) return;

    // if anti spawn camping feature is not enabled, do nothing
    if (!wc.getProtectFreshSpawns()) return;

    // if the player has the damage any player permission enabled, do nothing
    if (player.hasPermission("griefprevention.nopvpimmunity")) return;

    // check inventory for well, anything
    PlayerInventory inventory = player.getInventory();
    ItemStack[] armorStacks = inventory.getArmorContents();

    // check armor slots, stop if any items are found
    for (int i = 0; i < armorStacks.length; i++) {
      if (!(armorStacks[i] == null || armorStacks[i].getType() == Material.AIR)) return;
    }

    // check other slots, stop if any items are found
    ItemStack[] generalStacks = inventory.getContents();
    for (int i = 0; i < generalStacks.length; i++) {
      if (!(generalStacks[i] == null || generalStacks[i].getType() == Material.AIR)) return;
    }

    // otherwise, apply immunity
    PlayerData playerData = this.dataStore.getPlayerData(player.getName());
    playerData.pvpImmune = true;

    // inform the player
    GriefPrevention.sendMessage(player, TextMode.Success, Messages.PvPImmunityStart);
  }
  // initializes well...   everything
  public void onEnable() {
    instance = this;
    AddLogEntry("Grief Prevention enabled.");

    cmdHandler = new CommandHandler();
    // if the old data folder exists and the new one doesn't...
    File oldData = new File(dataStore.oldDataLayerFolderPath);
    File newData = new File(dataStore.dataLayerFolderPath);
    if (oldData.exists() && !newData.exists()) {
      // migrateData();
      AddLogEntry(
          "Found old GriefPrevention 7.7 or Earlier Data, but no 7.8 or later data. Attempting to copy to new folder.");
      AddLogEntry(
          "This will Copy your GriefPrevention 7.7 Data to the new GriefPrevention 7.8 and Later location.");
      AddLogEntry(
          "You will need to reconfigure your settings using the new World-based Configuration.");
      try {
        RecursiveCopyResult copied = recursiveCopy(oldData, newData, true);
        AddLogEntry(
            "Migration complete. Copied "
                + copied.FileCount
                + " Files in "
                + copied.DirCount
                + " Directories.");
      } catch (IOException exx) {
        AddLogEntry("Exception occured attempting to copy config data.");
        exx.printStackTrace();
      }
    }

    // MinecraftMMO = (mcMMO) Bukkit.getPluginManager().getPlugin("mcMMO");
    Debugger.Write(new File(DataStore.configFilePath).getAbsolutePath(), DebugLevel.Verbose);
    Debugger.Write(
        "File Exists:" + new File(DataStore.configFilePath).exists(), DebugLevel.Verbose);
    // load the config if it exists
    FileConfiguration config =
        YamlConfiguration.loadConfiguration(new File(DataStore.configFilePath));
    FileConfiguration outConfig = new YamlConfiguration();

    // read configuration settings (note defaults)

    // load player groups.
    // System.out.println("reading player groups...");
    this.config_player_groups = new PlayerGroups(config, "GriefPrevention.Groups");
    this.config_player_groups.Save(outConfig, "GriefPrevention.Groups");
    // optional database settings
    String databaseUrl = config.getString("GriefPrevention.Database.URL", "");
    String databaseUserName = config.getString("GriefPrevention.Database.UserName", "");
    String databasePassword = config.getString("GriefPrevention.Database.Password", "");
    // sea level
    String AcquiredLevel = config.getString("GriefPrevention.DebugLevel", "None");
    this.DebuggingLevel = Debugger.DebugLevel.valueOf(AcquiredLevel);
    config.set("GriefPrevention.DebugLevel", DebuggingLevel.name());
    this.debug = new Debugger(DebuggingLevel);
    outConfig.set("GriefPrevention.Database.URL", databaseUrl);
    outConfig.set("GriefPrevention.Database.UserName", databaseUserName);
    outConfig.set("GriefPrevention.Database.Password", databasePassword);

    this.config_economy_claimBlocksPurchaseCost =
        config.getDouble("GriefPrevention.Economy.ClaimBlocksPurchaseCost", 0);
    this.config_economy_claimBlocksSellValue =
        config.getDouble("GriefPrevention.Economy.ClaimBlocksSellValue", 0);
    this.config_claims_maxAccruedBlocks =
        config.getInt("GriefPrevention.Claims.MaxAccruedBlocks", 5000);
    outConfig.set("GriefPrevention.Claims.MaxAccruedBlocks", config_claims_maxAccruedBlocks);

    this.ModdedBlockRegexHelper =
        new RegExTestHelper(
            config,
            outConfig,
            "GriefPrevention.Mods.Containers",
            RegExTestHelper.DefaultContainers);
    this.AccessRegexPattern =
        new RegExTestHelper(
            config, outConfig, "GriefPrevention.Mods.Access", RegExTestHelper.DefaultAccess);
    this.OreBlockRegexHelper =
        new RegExTestHelper(
            config, outConfig, "GriefPrevention.Mods.Trash", RegExTestHelper.DefaultTrash);

    this.config_claims_initialBlocks = config.getInt("GriefPrevention.Claims.InitialBlocks", 100);
    this.config_mod_config_search =
        config.getBoolean("GriefPrevention.Mods.PerformConfigSearch", true);
    this.config_claims_deleteclaimswithunrecognizedowners =
        config.getBoolean("GriefPrevention.Claims.DeleteWithUnrecognizedOwner", false);
    this.config_autosubclaims =
        config.getBoolean("GriefPrevention.Claims.AutoSubClaimSwitch", false);
    outConfig.set("GriefPrevention.Claims.AutoSubClaimsSwitch", this.config_autosubclaims);
    outConfig.set(
        "GriefPrevention.Claims.DeleteWithUnrecognizedOwner",
        this.config_claims_deleteclaimswithunrecognizedowners);
    outConfig.set(
        "GriefPrevention.Economy.ClaimBlocksPurchaseCost",
        this.config_economy_claimBlocksPurchaseCost);
    outConfig.set(
        "GriefPrevention.Economy.ClaimBlocksSellValue", this.config_economy_claimBlocksSellValue);
    outConfig.set("GriefPrevention.Claims.InitialBlocks", config_claims_initialBlocks);
    outConfig.set("GriefPrevention.Mods.PerformConfigSearch", false);
    this.ModdedBlocks = new ModdedBlocksSearchResults();
    if (config_mod_config_search) {
      // Show message indicating what will happen. With mod_config_search enabled, we will search
      // for configs and find
      // IDs according to a regular expression, but for this entire session all World Configuration
      // loads will
      // change the configured values for modded containers and access blocks, so mention that.
      AddLogEntry("Performing Configuration Search.");
      AddLogEntry(
          "World Configurations Loaded during this session will have their current Container and Access IDs Overwritten!");

      this.ModdedBlocks = ModBlockHelper.ScanCfgs();

      // save these to _template.

    }
    Configuration = new ConfigData(config, outConfig);

    if (config_mod_config_search) { // if specified, to search, save the results to the template
                                    // file.
      // WorldConfig's will save the ModdedBlock Contents when they are created,
      // therefore we will set the template in this manner. Otherwise, this setting (ModdedBlock
      // search results)
      // will only be valid for this one server session.
      WorldConfig templatefile = WorldConfig.fromFile(Configuration.getTemplateFile());
      // we don't actually need to do anything with the variable, all the work was done in
      // fromFile() and the WorldConfig constructors.

    }

    // when datastore initializes, it loads player and claim data, and posts some stats to the log
    if (databaseUrl.length() > 0) {
      try {
        DatabaseDataStore databaseStore =
            new DatabaseDataStore(databaseUrl, databaseUserName, databasePassword);

        if (FlatFileDataStore.hasData()) {
          GriefPrevention.AddLogEntry(
              "There appears to be some data on the hard drive.  Migrating those data to the database...");
          FlatFileDataStore flatFileStore = new FlatFileDataStore();
          flatFileStore.migrateData(databaseStore);
          GriefPrevention.AddLogEntry(
              "Data migration process complete.  Reloading data from the database...");
          databaseStore.close();
          databaseStore = new DatabaseDataStore(databaseUrl, databaseUserName, databasePassword);
        }

        this.dataStore = databaseStore;
      } catch (Exception e) {
        GriefPrevention.AddLogEntry(
            "Because there was a problem with the database, GriefPrevention will not function properly.  Either update the database config settings resolve the issue, or delete those lines from your config.yml so that GriefPrevention can use the file system to store data.");
        return;
      }
    }

    // if not using the database because it's not configured or because there was a problem, use the
    // file system to store data
    // this is the preferred method, as it's simpler than the database scenario
    if (this.dataStore == null) {
      try {
        this.dataStore = new FlatFileDataStore();
      } catch (Exception e) {
        GriefPrevention.AddLogEntry("Unable to initialize the file system data store.  Details:");
        GriefPrevention.AddLogEntry(e.getMessage());
      }
    }

    // start the recurring cleanup event for entities in creative worlds, if enabled.

    // start recurring cleanup scan for unused claims belonging to inactive players
    // if the option is enabled.
    // look through all world configurations.
    boolean claimcleanupOn = false;
    boolean entitycleanupEnabled = false;

    if (entitycleanupEnabled) {
      EntityCleanupTask task = new EntityCleanupTask(0);
      this.getServer().getScheduler().scheduleSyncDelayedTask(GriefPrevention.instance, task, 20L);
    }

    // register for events
    if (!eventsRegistered) {
      eventsRegistered = true;
      PluginManager pluginManager = this.getServer().getPluginManager();

      // player events
      PlayerEventHandler playerEventHandler = new PlayerEventHandler(this.dataStore, this);
      pluginManager.registerEvents(playerEventHandler, this);

      // block events
      BlockEventHandler blockEventHandler = new BlockEventHandler(this.dataStore);
      pluginManager.registerEvents(blockEventHandler, this);

      // entity events
      EntityEventHandler entityEventHandler = new EntityEventHandler(this.dataStore);
      pluginManager.registerEvents(entityEventHandler, this);
    }

    // if economy is enabled
    if (this.config_economy_claimBlocksPurchaseCost > 0
        || this.config_economy_claimBlocksSellValue > 0) {
      // try to load Vault
      GriefPrevention.AddLogEntry("GriefPrevention requires Vault for economy integration.");
      GriefPrevention.AddLogEntry("Attempting to load Vault...");
      RegisteredServiceProvider<Economy> economyProvider =
          getServer()
              .getServicesManager()
              .getRegistration(net.milkbowl.vault.economy.Economy.class);
      GriefPrevention.AddLogEntry("Vault loaded successfully!");

      // ask Vault to hook into an economy plugin
      GriefPrevention.AddLogEntry("Looking for a Vault-compatible economy plugin...");
      if (economyProvider != null) {
        GriefPrevention.economy = economyProvider.getProvider();

        // on success, display success message
        if (GriefPrevention.economy != null) {
          GriefPrevention.AddLogEntry(
              "Hooked into economy: " + GriefPrevention.economy.getName() + ".");
          GriefPrevention.AddLogEntry("Ready to buy/sell claim blocks!");
        }

        // otherwise error message
        else {
          GriefPrevention.AddLogEntry(
              "ERROR: Vault was unable to find a supported economy plugin.  Either install a Vault-compatible economy plugin, or set both of the economy config variables to zero.");
        }
      }

      // another error case
      else {
        GriefPrevention.AddLogEntry(
            "ERROR: Vault was unable to find a supported economy plugin.  Either install a Vault-compatible economy plugin, or set both of the economy config variables to zero.");
      }
    }
    MetaHandler = new ClaimMetaHandler();
    try {
      // new File(DataStore.configFilePath).delete();
      outConfig.save(new File(DataStore.configFilePath).getAbsolutePath());
    } catch (IOException exx) {
      this.log.log(
          Level.SEVERE, "Failed to save primary configuration file:" + DataStore.configFilePath);
    }
    ww = new WorldWatcher();
    Bukkit.getPluginManager().registerEvents(ww, this);
    // go through all available worlds, and fire a "world load" event for them.
    for (World iterate : Bukkit.getWorlds()) {
      WorldLoadEvent wle = new WorldLoadEvent(iterate);
      ww.WorldLoad(wle);
    }

    Bukkit.getPluginManager().callEvent(new GPLoadEvent(this));
  }