TotalFreedomMC/TF-EssentialsX
1
0
Fork 0
mirror of https://github.com/TotalFreedomMC/TF-EssentialsX.git synced 2025-04-25 07:59:44 +00:00
Code Issues Projects Releases Wiki Activity

[Breaking] Remove protect database functionality for protecting signs and rails.

Browse source 
- Removed config entries
- Removed c3p0 lib
This commit is contained in:
ementalo 2013-02-28 21:02:37 +00:00
parent 58b1b34e44
commit 8d77a3f941
17 changed files with 11 additions and 1548 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
Essentials/src/config.yml
View file

@ -497,19 +497,7 @@ chat:
############################################################
protect:
# Database settings for sign/rail protection.
# mysql or sqlite
# We strongly recommend against using mysql here, unless you have a good reason.
# Sqlite seems to be faster in almost all cases, and in some cases mysql can be much slower.
datatype: 'sqlite'
# If you specified MySQL above, you MUST enter the appropriate details here.
# If you specified SQLite above, these will be IGNORED.
username: 'root'
password: 'root'
mysqlDb: 'jdbc:mysql://localhost:3306/minecraft'
# General physics/behavior modifications.
prevent:
lava-flow: false
@ -574,25 +562,6 @@ protect:
creeper:
max-height: -1
# Protect various blocks.
protect:
# Protect all signs.
signs: false
# Prevent users from destroying rails.
rails: false
# Blocks below rails/signs are also protected if the respective rail/sign is protected.
# This makes it more difficult to circumvent protection, and should be enabled.
# This only has an effect if "rails" or "signs" is also enabled.
block-below: true
# Prevent placing blocks above protected rails, this is to stop a potential griefing.
prevent-block-on-rails: false
# Store blocks / signs in memory before writing.
memstore: false
# Disable various default physics and behaviors.
disable:
# Should fall damage be disabled?

2
EssentialsProtect/nbproject/project.properties
View file

@ -64,14 +64,12 @@ dist.javadoc.dir=${dist.dir}/javadoc
endorsed.classpath=
excludes=
file.reference.bukkit.jar=../lib/bukkit.jar
file.reference.c3p0-0.9.1.2.jar=..\\lib\\c3p0-0.9.1.2.jar
includes=**
jar.archive.disabled=${jnlp.enabled}
jar.compress=true
jar.index=${jnlp.enabled}
javac.classpath=\
${reference.Essentials.jar}:\
${file.reference.c3p0-0.9.1.2.jar}:\
${file.reference.bukkit.jar}
# Space-separated list of extra javac options
javac.compilerargs=

41
EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsConnect.java
View file

@ -3,10 +3,6 @@ package com.earth2me.essentials.protect;
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.IConf;
import com.earth2me.essentials.IEssentials;
import com.earth2me.essentials.protect.data.ProtectedBlockMemory;
import com.earth2me.essentials.protect.data.ProtectedBlockMySQL;
import com.earth2me.essentials.protect.data.ProtectedBlockSQLite;
import java.beans.PropertyVetoException;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.plugin.Plugin;
@ -41,10 +37,6 @@ public class EssentialsConnect
@Override
public void reloadConfig()
{
if (protect.getStorage() != null)
{
protect.getStorage().onPluginDeactivation();
}
for (ProtectConfig protectConfig : ProtectConfig.values())
{
if (protectConfig.isList())
@ -61,37 +53,6 @@ public class EssentialsConnect
}
}
if (protect.getSettingString(ProtectConfig.datatype).equalsIgnoreCase("mysql"))
{
try
{
protect.setStorage(new ProtectedBlockMySQL(
protect.getSettingString(ProtectConfig.mysqlDB),
protect.getSettingString(ProtectConfig.dbUsername),
protect.getSettingString(ProtectConfig.dbPassword)));
}
catch (PropertyVetoException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
else
{
try
{
protect.setStorage(new ProtectedBlockSQLite("jdbc:sqlite:plugins/Essentials/EssentialsProtect.db"));
}
catch (PropertyVetoException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (protect.getSettingBool(ProtectConfig.memstore))
{
protect.setStorage(new ProtectedBlockMemory(protect.getStorage(), protect));
}
}
}
}
}

57
EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtect.java
View file

@ -1,11 +1,8 @@
package com.earth2me.essentials.protect;
import com.earth2me.essentials.protect.data.IProtectedBlock;
import com.mchange.v2.log.MLevel;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.entity.Player;
@ -17,32 +14,11 @@ import org.bukkit.plugin.java.JavaPlugin;
public class EssentialsProtect extends JavaPlugin implements IProtect
{
private static final Logger LOGGER = Logger.getLogger("Minecraft");
private static com.mchange.v2.log.MLogger C3P0logger;
private final Map<ProtectConfig, Boolean> settingsBoolean = new EnumMap<ProtectConfig, Boolean>(ProtectConfig.class);
private final Map<ProtectConfig, String> settingsString = new EnumMap<ProtectConfig, String>(ProtectConfig.class);
private final Map<ProtectConfig, List<Integer>> settingsList = new EnumMap<ProtectConfig, List<Integer>>(ProtectConfig.class);
private IProtectedBlock storage = null;
private EssentialsConnect ess = null;
@Override
public void onLoad()
{
try
{
// Simple fix for the case that log4j is on the class path by another plugin
Class propertyConfiguratorClass = Class.forName("org.apache.log4j.PropertyConfigurator");
Properties properties = new Properties();
properties.load(this.getClass().getResourceAsStream("log4j.properties"));
propertyConfiguratorClass.getMethod("configure", Properties.class).invoke(null, properties);
}
catch (Exception ex)
{
//Ignore me, log4j not found on classloader.
}
C3P0logger = com.mchange.v2.log.MLog.getLogger(com.mchange.v2.c3p0.impl.AbstractPoolBackedDataSource.class);
C3P0logger.setLevel(MLevel.WARNING);
}
@Override
public void onEnable()
{
@ -55,9 +31,6 @@ public class EssentialsProtect extends JavaPlugin implements IProtect
}
ess = new EssentialsConnect(essPlugin, this);
final EssentialsProtectPlayerListener playerListener = new EssentialsProtectPlayerListener(this);
pm.registerEvents(playerListener, this);
final EssentialsProtectBlockListener blockListener = new EssentialsProtectBlockListener(this);
pm.registerEvents(blockListener, this);
@ -80,18 +53,6 @@ public class EssentialsProtect extends JavaPlugin implements IProtect
LOGGER.log(Level.SEVERE, "Essentials not installed or failed to load. Essenials Protect is in emergency mode now.");
}
@Override
public IProtectedBlock getStorage()
{
return storage;
}
@Override
public void setStorage(IProtectedBlock pb)
{
storage = pb;
}
@Override
public EssentialsConnect getEssentialsConnect()
{
@ -129,22 +90,4 @@ public class EssentialsProtect extends JavaPlugin implements IProtect
final String str = settingsString.get(protectConfig);
return str == null ? protectConfig.getDefaultValueString() : str;
}
@Override
public void onDisable()
{
if (storage != null)
{
storage.onPluginDeactivation();
}
// Sleep for a second to allow the database to close.
try
{
Thread.sleep(1000);
}
catch (InterruptedException ex)
{
Logger.getLogger(EssentialsProtect.class.getName()).log(Level.SEVERE, null, ex);
}
}
}

324
EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectBlockListener.java
View file

@ -1,10 +1,6 @@
package com.earth2me.essentials.protect;
import com.earth2me.essentials.IEssentials;
import com.earth2me.essentials.User;
import com.earth2me.essentials.protect.data.IProtectedBlock;
import java.util.ArrayList;
import java.util.List;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
@ -24,68 +20,10 @@ public class EssentialsProtectBlockListener implements Listener
this.prot = parent;
this.ess = prot.getEssentialsConnect().getEssentials();
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockPlace(final BlockPlaceEvent event)
{
final User user = ess.getUser(event.getPlayer());
final Block blockPlaced = event.getBlockPlaced();
final Block below = blockPlaced.getRelative(BlockFace.DOWN);
if ((below.getType() == Material.RAILS || below.getType() == Material.POWERED_RAIL || below.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.prevent_block_on_rail)
&& isProtected(below, user))
{
event.setCancelled(true);
return;
}
final List<Block> protect = new ArrayList<Block>();
if ((blockPlaced.getType() == Material.RAILS || blockPlaced.getType() == Material.POWERED_RAIL || blockPlaced.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails)
&& user.isAuthorized("essentials.protect"))
{
protect.add(blockPlaced);
if (prot.getSettingBool(ProtectConfig.protect_below_rails)
&& !isProtected(blockPlaced.getRelative(BlockFace.DOWN), user))
{
protect.add(blockPlaced.getRelative(BlockFace.DOWN));
}
}
if ((blockPlaced.getType() == Material.SIGN_POST || blockPlaced.getType() == Material.WALL_SIGN)
&& prot.getSettingBool(ProtectConfig.protect_signs)
&& user.isAuthorized("essentials.protect"))
{
protect.add(blockPlaced);
if (prot.getSettingBool(ProtectConfig.protect_against_signs)
&& event.getBlockAgainst().getType() != Material.SIGN_POST
&& event.getBlockAgainst().getType() != Material.WALL_SIGN
&& !isProtected(event.getBlockAgainst(), user))
{
protect.add(event.getBlockAgainst());
}
}
for (Block block : protect)
{
prot.getStorage().protectBlock(block, user.getName());
}
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockIgnite(BlockIgniteEvent event)
{
final Block block = event.getBlock();
if ((block.getType() == Material.RAILS || block.getType() == Material.POWERED_RAIL || block.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if ((block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST)
&& prot.getSettingBool(ProtectConfig.protect_signs))
{
event.setCancelled(true);
return;
}
if (event.getBlock().getType() == Material.OBSIDIAN
|| event.getBlock().getRelative(BlockFace.DOWN).getType() == Material.OBSIDIAN)
{
@ -119,21 +57,8 @@ public class EssentialsProtectBlockListener implements Listener
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockFromTo(final BlockFromToEvent event)
{
final Block toBlock = event.getToBlock();
if ((toBlock.getType() == Material.RAILS || toBlock.getType() == Material.POWERED_RAIL || toBlock.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if ((toBlock.getType() == Material.WALL_SIGN || toBlock.getType() == Material.SIGN_POST)
&& prot.getSettingBool(ProtectConfig.protect_signs))
{
event.setCancelled(true);
return;
}
final Block block = event.getBlock();
if (block.getType() == Material.WATER || block.getType() == Material.STATIONARY_WATER)
{
event.setCancelled(prot.getSettingBool(ProtectConfig.prevent_water_flow));
@ -154,252 +79,11 @@ public class EssentialsProtectBlockListener implements Listener
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockBurn(final BlockBurnEvent event)
{
final Block block = event.getBlock();
if ((block.getType() == Material.RAILS || block.getType() == Material.POWERED_RAIL || block.getType() == Material.DETECTOR_RAIL) && prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if ((block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST)
&& prot.getSettingBool(ProtectConfig.protect_signs))
{
event.setCancelled(true);
return;
}
{
if (prot.getSettingBool(ProtectConfig.prevent_fire_spread))
{
event.setCancelled(true);
}
}
private final static BlockFace[] faces = new BlockFace[]
{
BlockFace.NORTH,
BlockFace.EAST,
BlockFace.SOUTH,
BlockFace.WEST,
BlockFace.UP,
BlockFace.DOWN,
BlockFace.SELF
};
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockBreak(final BlockBreakEvent event)
{
final User user = ess.getUser(event.getPlayer());
final Block block = event.getBlock();
final Material type = block.getType();
final IProtectedBlock storage = prot.getStorage();
if (user.isAuthorized("essentials.protect.admin"))
{
if (type == Material.WALL_SIGN || type == Material.SIGN_POST || type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL)
{
storage.unprotectBlock(block);
if (type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL || type == Material.SIGN_POST)
{
final Block below = block.getRelative(BlockFace.DOWN);
storage.unprotectBlock(below);
}
else
{
for (BlockFace blockFace : faces)
{
final Block against = block.getRelative(blockFace);
storage.unprotectBlock(against);
}
}
}
else
{
for (BlockFace blockFace : faces)
{
final Block against = block.getRelative(blockFace);
storage.unprotectBlock(against);
}
}
}
else
{
final boolean isProtected = isProtected(block, user);
if (isProtected)
{
event.setCancelled(true);
}
else
{
if (type == Material.WALL_SIGN || type == Material.SIGN_POST || type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL)
{
storage.unprotectBlock(block);
if (type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL || type == Material.SIGN_POST)
{
final Block below = block.getRelative(BlockFace.DOWN);
storage.unprotectBlock(below);
}
else
{
for (BlockFace blockFace : faces)
{
final Block against = block.getRelative(blockFace);
storage.unprotectBlock(against);
}
}
}
else
{
for (BlockFace blockFace : faces)
{
final Block against = block.getRelative(blockFace);
storage.unprotectBlock(against);
}
}
}
}
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockPistonExtend(BlockPistonExtendEvent event)
{
for (Block block : event.getBlocks())
{
if ((block.getRelative(BlockFace.UP).getType() == Material.RAILS
|| block.getType() == Material.RAILS
|| block.getRelative(BlockFace.UP).getType() == Material.POWERED_RAIL
|| block.getType() == Material.POWERED_RAIL
|| block.getRelative(BlockFace.UP).getType() == Material.DETECTOR_RAIL
|| block.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if (prot.getSettingBool(ProtectConfig.protect_signs))
{
for (BlockFace blockFace : faces)
{
if (blockFace == BlockFace.DOWN)
{
continue;
}
final Block sign = block.getRelative(blockFace);
if ((blockFace == BlockFace.UP || blockFace == BlockFace.SELF)
&& sign.getType() == Material.SIGN_POST)
{
event.setCancelled(true);
return;
}
if ((blockFace == BlockFace.NORTH || blockFace == BlockFace.EAST
|| blockFace == BlockFace.SOUTH || blockFace == BlockFace.WEST
|| blockFace == BlockFace.SELF)
&& sign.getType() == Material.WALL_SIGN)
{
event.setCancelled(true);
return;
}
}
}
}
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onBlockPistonRetract(BlockPistonRetractEvent event)
{
if (!event.isSticky())
{
return;
}
final Block block = event.getRetractLocation().getBlock();
if ((block.getRelative(BlockFace.UP).getType() == Material.RAILS
|| block.getType() == Material.RAILS
|| block.getRelative(BlockFace.UP).getType() == Material.POWERED_RAIL
|| block.getType() == Material.POWERED_RAIL
|| block.getRelative(BlockFace.UP).getType() == Material.DETECTOR_RAIL
|| block.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if (prot.getSettingBool(ProtectConfig.protect_signs))
{
for (BlockFace blockFace : faces)
{
if (blockFace == BlockFace.DOWN)
{
continue;
}
final Block sign = block.getRelative(blockFace);
if ((blockFace == BlockFace.UP || blockFace == BlockFace.SELF)
&& sign.getType() == Material.SIGN_POST)
{
event.setCancelled(true);
return;
}
if ((blockFace == BlockFace.NORTH || blockFace == BlockFace.EAST
|| blockFace == BlockFace.SOUTH || blockFace == BlockFace.WEST
|| blockFace == BlockFace.SELF)
&& sign.getType() == Material.WALL_SIGN)
{
event.setCancelled(true);
return;
}
}
}
}
private boolean isProtected(final Block block, final User user)
{
final Material type = block.getType();
if (prot.getSettingBool(ProtectConfig.protect_signs))
{
if (type == Material.WALL_SIGN || type == Material.SIGN_POST)
{
return prot.getStorage().isProtected(block, user.getName());
}
if (prot.getSettingBool(ProtectConfig.protect_against_signs))
{
final Block up = block.getRelative(BlockFace.UP);
if (up != null && up.getType() == Material.SIGN_POST)
{
return prot.getStorage().isProtected(block, user.getName());
}
final BlockFace[] directions = new BlockFace[]
{
BlockFace.NORTH,
BlockFace.EAST,
BlockFace.SOUTH,
BlockFace.WEST
};
for (BlockFace blockFace : directions)
{
final Block signblock = block.getRelative(blockFace);
if (signblock.getType() == Material.WALL_SIGN)
{
final org.bukkit.material.Sign signMat = (org.bukkit.material.Sign)signblock.getState().getData();
if (signMat != null && signMat.getFacing() == blockFace)
{
return prot.getStorage().isProtected(block, user.getName());
}
}
}
}
}
if (prot.getSettingBool(ProtectConfig.protect_rails))
{
if (type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL)
{
return prot.getStorage().isProtected(block, user.getName());
}
if (prot.getSettingBool(ProtectConfig.protect_below_rails))
{
final Block up = block.getRelative(BlockFace.UP);
if (up != null && (type == Material.RAILS || type == Material.POWERED_RAIL || type == Material.DETECTOR_RAIL))
{
return prot.getStorage().isProtected(block, user.getName());
}
}
}
return false;
}
}

42
EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectEntityListener.java
View file

@ -3,9 +3,6 @@ package com.earth2me.essentials.protect;
import com.earth2me.essentials.IEssentials;
import com.earth2me.essentials.User;
import java.util.Locale;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.entity.*;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
@ -204,7 +201,6 @@ public class EssentialsProtectEntityListener implements Listener
&& prot.getSettingBool(ProtectConfig.prevent_wither_spawnexplosion))
{
event.setCancelled(true);
return;
}
else if (event.getEntity() instanceof Creeper
&& (prot.getSettingBool(ProtectConfig.prevent_creeper_explosion)
@ -214,56 +210,26 @@ public class EssentialsProtectEntityListener implements Listener
//Nicccccccccce plaaacccccccccce..
event.setCancelled(true);
event.getLocation().getWorld().createExplosion(event.getLocation(), 0F);
return;
}
else if (event.getEntity() instanceof TNTPrimed
&& prot.getSettingBool(ProtectConfig.prevent_tnt_explosion))
{
event.setCancelled(true);
return;
}
else if ((event.getEntity() instanceof Fireball || event.getEntity() instanceof SmallFireball)
&& prot.getSettingBool(ProtectConfig.prevent_fireball_explosion))
{
event.setCancelled(true);
return;
}
else if ((event.getEntity() instanceof WitherSkull)
&& prot.getSettingBool(ProtectConfig.prevent_witherskull_explosion))
{
event.setCancelled(true);
return;
}
// This code will prevent explosions near protected rails, signs or protected chests
// TODO: Use protect db instead of this code
for (Block block : event.blockList())
{
if ((block.getRelative(BlockFace.UP).getType() == Material.RAILS
|| block.getType() == Material.RAILS
|| block.getRelative(BlockFace.UP).getType() == Material.POWERED_RAIL
|| block.getType() == Material.POWERED_RAIL
|| block.getRelative(BlockFace.UP).getType() == Material.DETECTOR_RAIL
|| block.getType() == Material.DETECTOR_RAIL)
&& prot.getSettingBool(ProtectConfig.protect_rails))
{
event.setCancelled(true);
return;
}
if ((block.getType() == Material.WALL_SIGN
|| block.getRelative(BlockFace.NORTH).getType() == Material.WALL_SIGN
|| block.getRelative(BlockFace.EAST).getType() == Material.WALL_SIGN
|| block.getRelative(BlockFace.SOUTH).getType() == Material.WALL_SIGN
|| block.getRelative(BlockFace.WEST).getType() == Material.WALL_SIGN
|| block.getType() == Material.SIGN_POST
|| block.getRelative(BlockFace.UP).getType() == Material.SIGN_POST)
&& prot.getSettingBool(ProtectConfig.protect_signs))
{
event.setCancelled(true);
return;
}
}
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)

52
EssentialsProtect/src/com/earth2me/essentials/protect/EssentialsProtectPlayerListener.java
View file

@ -1,52 +0,0 @@
package com.earth2me.essentials.protect;
import static com.earth2me.essentials.I18n._;
import com.earth2me.essentials.IEssentials;
import com.earth2me.essentials.User;
import org.bukkit.block.Block;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
public class EssentialsProtectPlayerListener implements Listener
{
private final IProtect prot;
private final IEssentials ess;
public EssentialsProtectPlayerListener(final IProtect prot)
{
this.prot = prot;
this.ess = prot.getEssentialsConnect().getEssentials();
}
@EventHandler(priority = EventPriority.LOW)
public void onPlayerInteract(final PlayerInteractEvent event)
{
// Do not return if cancelled, because the interact event has 2 cancelled states.
final User user = ess.getUser(event.getPlayer());
if (user.isAuthorized("essentials.protect.ownerinfo") && event.getAction() == Action.RIGHT_CLICK_BLOCK)
{
final StringBuilder stringBuilder = new StringBuilder();
boolean first = true;
final Block blockClicked = event.getClickedBlock();
for (String owner : prot.getStorage().getOwners(blockClicked))
{
if (!first)
{
stringBuilder.append(", ");
}
first = false;
stringBuilder.append(owner);
}
final String ownerNames = stringBuilder.toString();
if (ownerNames != null && !ownerNames.isEmpty())
{
user.sendMessage(_("protectionOwner", ownerNames));
}
}
}
}

7
EssentialsProtect/src/com/earth2me/essentials/protect/IProtect.java
View file

@ -1,6 +1,5 @@
package com.earth2me.essentials.protect;
import com.earth2me.essentials.protect.data.IProtectedBlock;
import java.util.List;
import java.util.Map;
import org.bukkit.plugin.Plugin;
@ -11,11 +10,7 @@ public interface IProtect extends Plugin
boolean getSettingBool(final ProtectConfig protectConfig);
String getSettingString(final ProtectConfig protectConfig);
IProtectedBlock getStorage();
void setStorage(IProtectedBlock pb);
EssentialsConnect getEssentialsConnect();
Map<ProtectConfig, Boolean> getSettingsBoolean();

9
EssentialsProtect/src/com/earth2me/essentials/protect/ProtectConfig.java
View file

@ -3,11 +3,6 @@ package com.earth2me.essentials.protect;
public enum ProtectConfig
{
datatype("protect.datatype", "sqlite"),
mysqlDB("protect.mysqlDb", "jdbc:mysql://localhost:3306/minecraft"),
dbUsername("protect.username", "root"),
dbPassword("protect.password", ""),
memstore("protect.memstore", false),
disable_contactdmg("protect.disable.contactdmg", false),
disable_lavadmg("protect.disable.lavadmg", false),
disable_pvp("protect.disable.pvp", false),
@ -46,10 +41,6 @@ public enum ProtectConfig
prevent_villager_death("protect.prevent.villager-death", false),
prevent_enderdragon_blockdmg("protect.prevent.enderdragon-blockdamage", true),
prevent_entitytarget("protect.prevent.entitytarget", false),
protect_rails("protect.protect.rails", true),
protect_below_rails("protect.protect.block-below", true),
protect_signs("protect.protect.signs", true),
protect_against_signs("protect.protect.block-below", true),
enderdragon_fakeexplosions("protect.enderdragon-fakeexplosions", false);
private final String configName;
private final String defValueString;

24
EssentialsProtect/src/com/earth2me/essentials/protect/data/IProtectedBlock.java
View file

@ -1,24 +0,0 @@
package com.earth2me.essentials.protect.data;
import java.util.List;
import org.bukkit.block.Block;
public interface IProtectedBlock
{
public void clearProtections();
public void importProtections(List<OwnedBlock> blocks);
public List<OwnedBlock> exportProtections();
public void protectBlock(Block block, String playerName);
public boolean isProtected(Block block, String playerName);
public List<String> getOwners(Block block);
public int unprotectBlock(Block block);
public void onPluginDeactivation();
}

20
EssentialsProtect/src/com/earth2me/essentials/protect/data/OwnedBlock.java
View file

@ -1,20 +0,0 @@
package com.earth2me.essentials.protect.data;
public class OwnedBlock
{
final int x;
final int y;
final int z;
final String world;
final String playerName;
public OwnedBlock(int x, int y, int z, String world, String playerName)
{
this.x = x;
this.y = y;
this.z = z;
this.world = world;
this.playerName = playerName;
}
}

426
EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockJDBC.java
View file

@ -1,426 +0,0 @@
package com.earth2me.essentials.protect.data;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.bukkit.block.Block;
public abstract class ProtectedBlockJDBC implements IProtectedBlock
{
protected static final Logger LOGGER = Logger.getLogger("Minecraft");
protected final ComboPooledDataSource cpds;
protected abstract PreparedStatement getStatementCreateTable(Connection conn) throws SQLException;
protected abstract PreparedStatement getStatementUpdateFrom2_0Table(Connection conn) throws SQLException;
protected abstract PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException;
protected abstract PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException;
protected abstract PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException;
protected abstract PreparedStatement getStatementPlayersByLocation(Connection conn, String name, int x, int y, int z) throws SQLException;
protected abstract PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException;
protected abstract PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException;
public ProtectedBlockJDBC(String driver, String url) throws PropertyVetoException
{
this(driver, url, null, null);
}
public ProtectedBlockJDBC(String driver, String url, String username, String password) throws PropertyVetoException
{
cpds = new ComboPooledDataSource();
cpds.setDriverClass(driver);
cpds.setJdbcUrl(url);
if (username != null)
{
cpds.setUser(username);
cpds.setPassword(password);
}
cpds.setMaxStatements(20);
createAndConvertTable();
}
private void createAndConvertTable()
{
Connection conn = null;
PreparedStatement ps = null;
try
{
conn = cpds.getConnection();
ps = getStatementCreateTable(conn);
ps.execute();
ps.close();
ps = getStatementUpdateFrom2_0Table(conn);
ps.execute();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
finally
{
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public void clearProtections()
{
Connection conn = null;
PreparedStatement ps = null;
try
{
conn = cpds.getConnection();
ps = getStatementDeleteAll(conn);
ps.executeUpdate();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
finally
{
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public void importProtections(List<OwnedBlock> blocks)
{
for (OwnedBlock ownedBlock : blocks)
{
if (ownedBlock.playerName == null)
{
continue;
}
protectBlock(ownedBlock.world, ownedBlock.x, ownedBlock.y, ownedBlock.z, ownedBlock.playerName);
}
}
@Override
public List<OwnedBlock> exportProtections()
{
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
List<OwnedBlock> blocks = new ArrayList<OwnedBlock>();
try
{
conn = cpds.getConnection();
ps = getStatementAllBlocks(conn);
rs = ps.executeQuery();
while (rs.next())
{
OwnedBlock ob = new OwnedBlock(
rs.getInt(2),
rs.getInt(3),
rs.getInt(4),
rs.getString(1),
rs.getString(5));
blocks.add(ob);
}
return blocks;
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
return blocks;
}
finally
{
if (rs != null)
{
try
{
rs.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public void protectBlock(Block block, String playerName)
{
protectBlock(block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), playerName);
}
private void protectBlock(String world, int x, int y, int z, String playerName)
{
Connection conn = null;
PreparedStatement ps = null;
try
{
conn = cpds.getConnection();
ps = getStatementInsert(conn, world, x, y, z, playerName);
ps.executeUpdate();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
finally
{
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public boolean isProtected(Block block, String playerName)
{
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
try
{
conn = cpds.getConnection();
ps = getStatementPlayerCountByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ(), playerName);
rs = ps.executeQuery();
return rs.next() && rs.getInt(1) > 0 && rs.getInt(2) == 0;
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
return true;
}
finally
{
if (rs != null)
{
try
{
rs.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public List<String> getOwners(Block block)
{
Connection conn = null;
PreparedStatement ps = null;
ResultSet rs = null;
List<String> owners = new ArrayList<String>();
try
{
conn = cpds.getConnection();
ps = getStatementPlayersByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ());
rs = ps.executeQuery();
while (rs.next())
{
owners.add(rs.getString(1));
}
return owners;
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
return owners;
}
finally
{
if (rs != null)
{
try
{
rs.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public int unprotectBlock(Block block)
{
Connection conn = null;
PreparedStatement ps = null;
try
{
conn = cpds.getConnection();
ps = getStatementDeleteByLocation(conn, block.getWorld().getName(), block.getX(), block.getY(), block.getZ());
return ps.executeUpdate();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
return 0;
}
finally
{
if (ps != null)
{
try
{
ps.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
if (conn != null)
{
try
{
conn.close();
}
catch (SQLException ex)
{
LOGGER.log(Level.SEVERE, null, ex);
}
}
}
}
@Override
public void onPluginDeactivation()
{
cpds.close();
}
}

258
EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMemory.java
View file

@ -1,258 +0,0 @@
package com.earth2me.essentials.protect.data;
import java.util.*;
import java.util.Map.Entry;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.plugin.Plugin;
public class ProtectedBlockMemory implements IProtectedBlock
{
private final List<String> worlds = new ArrayList<String>();
private final List<String> playerNames = new ArrayList<String>();
private final IProtectedBlock storage;
private final Plugin plugin;
static class ProtectedLocation
{
private final int x;
private final int y;
private final int z;
private final int w;
public ProtectedLocation(final Block block, final int worldId)
{
this.x = block.getX();
this.y = block.getY();
this.z = block.getZ();
this.w = worldId;
}
public ProtectedLocation(final OwnedBlock ownedBlock, final int worldId)
{
this.x = ownedBlock.x;
this.y = ownedBlock.y;
this.z = ownedBlock.z;
this.w = worldId;
}
@Override
public boolean equals(final Object object)
{
if (object instanceof ProtectedLocation)
{
final ProtectedLocation pLoc = (ProtectedLocation)object;
return x == pLoc.x && y == pLoc.y && z == pLoc.z && w == pLoc.w;
}
return false;
}
@Override
public int hashCode()
{
return x ^ y ^ z ^ w;
}
}
static class ProtectedBy
{
private int playerId = -1;
private Set<Integer> playerIds;
public void add(final int playerId)
{
if (this.playerId == -1 || this.playerId == playerId)
{
this.playerId = playerId;
}
else
{
if (playerIds == null)
{
playerIds = new HashSet<Integer>(4);
playerIds.add(this.playerId);
}
playerIds.add(playerId);
}
}
public boolean contains(final int playerId)
{
if (playerIds == null)
{
return this.playerId == playerId;
}
return playerIds.contains(playerId);
}
public List<String> getPlayers(final List<String> playerNames)
{
final List<String> list = new ArrayList<String>(2);
if (playerIds == null)
{
list.add(playerNames.get(playerId));
}
else
{
for (Integer integer : playerIds)
{
list.add(playerNames.get(integer));
}
}
return list;
}
public int size()
{
if (playerIds == null)
{
return 1;
}
return playerIds.size();
}
}
private final Map<ProtectedLocation, ProtectedBy> blocks = new HashMap<ProtectedLocation, ProtectedBy>();
public ProtectedBlockMemory(final IProtectedBlock storage, final Plugin plugin)
{
this.storage = storage;
this.plugin = plugin;
importProtections(storage.exportProtections());
}
@Override
public void clearProtections()
{
blocks.clear();
}
@Override
public final void importProtections(final List<OwnedBlock> blocks)
{
for (OwnedBlock ownedBlock : blocks)
{
final ProtectedLocation pl = new ProtectedLocation(ownedBlock, getWorldId(ownedBlock.world));
if (ownedBlock.playerName == null)
{
continue;
}
protectBlock(pl, ownedBlock.playerName);
}
}
@Override
public List<OwnedBlock> exportProtections()
{
final List<OwnedBlock> blockList = new ArrayList<OwnedBlock>(blocks.size());
for (Entry<ProtectedLocation, ProtectedBy> entry : blocks.entrySet())
{
for (String name : entry.getValue().getPlayers(playerNames))
{
final OwnedBlock ob = new OwnedBlock(
entry.getKey().x,
entry.getKey().y,
entry.getKey().z,
worlds.get(entry.getKey().w),
name);
blockList.add(ob);
}
}
return blockList;
}
@Override
public void protectBlock(final Block block, final String playerName)
{
final ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
protectBlock(pl, playerName);
plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable()
{
@Override
public void run()
{
storage.protectBlock(block, playerName);
}
});
}
private void protectBlock(ProtectedLocation pl, String playerName)
{
int playerId = getPlayerId(playerName);
ProtectedBy pb = blocks.get(pl);
if (pb == null)
{
pb = new ProtectedBy();
blocks.put(pl, pb);
}
pb.add(playerId);
}
@Override
public boolean isProtected(Block block, String playerName)
{
int playerId = getPlayerId(playerName);
ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
ProtectedBy pb = blocks.get(pl);
return !pb.contains(playerId);
}
@Override
public List<String> getOwners(Block block)
{
ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
ProtectedBy pb = blocks.get(pl);
return pb.getPlayers(playerNames);
}
@Override
public int unprotectBlock(final Block block)
{
ProtectedLocation pl = new ProtectedLocation(block, getWorldId(block.getWorld()));
ProtectedBy pb = blocks.remove(pl);
plugin.getServer().getScheduler().runTaskAsynchronously(plugin, new Runnable()
{
@Override
public void run()
{
storage.unprotectBlock(block);
}
});
return pb.size();
}
private int getPlayerId(String playername)
{
int id = playerNames.indexOf(playername);
if (id < 0)
{
playerNames.add(playername);
id = playerNames.indexOf(playername);
}
return id;
}
private int getWorldId(World world)
{
return getWorldId(world.getName());
}
private int getWorldId(String name)
{
int id = worlds.indexOf(name);
if (id < 0)
{
worlds.add(name);
id = worlds.indexOf(name);
}
return id;
}
@Override
public void onPluginDeactivation()
{
storage.onPluginDeactivation();
}
}

156
EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockMySQL.java
View file

@ -1,156 +0,0 @@
package com.earth2me.essentials.protect.data;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;
public class ProtectedBlockMySQL extends ProtectedBlockJDBC
{
public ProtectedBlockMySQL(String url, String username, String password) throws PropertyVetoException
{
super("com.mysql.jdbc.Driver", url, username, password);
}
private static final String QueryCreateTable =
"CREATE TABLE IF NOT EXISTS `EssentialsProtect` ("
+ "`worldName` varchar(60) NOT NULL,"
+ "`x` int(11) NOT NULL, `y` int(11) NOT NULL, `z` int(11) NOT NULL,"
+ "`playerName` varchar(150) DEFAULT NULL,"
+ "KEY `pos` (`worldName`,`x`,`z`,`y`)"
+ ") ENGINE=MyISAM DEFAULT CHARSET=utf8";
@Override
protected PreparedStatement getStatementCreateTable(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryCreateTable);
}
private static final String QueryUpdateFrom2_0TableCheck =
"SHOW COLUMNS FROM `EssentialsProtect` LIKE 'id';";
private static final String QueryUpdateFrom2_0Table =
"ALTER TABLE `EssentialsProtect` "
+ "CHARACTER SET = utf8, ENGINE = MyISAM,"
+ "DROP COLUMN `id`,"
+ "CHANGE COLUMN `playerName` `playerName` VARCHAR(150) NULL AFTER `z`,"
+ "CHANGE COLUMN `worldName` `worldName` VARCHAR(60) NOT NULL,"
+ "ADD INDEX `position` (`worldName` ASC, `x` ASC, `z` ASC, `y` ASC),"
+ "DROP PRIMARY KEY ;";
@Override
protected PreparedStatement getStatementUpdateFrom2_0Table(Connection conn) throws SQLException
{
PreparedStatement testPS = null;
ResultSet testRS = null;
try
{
testPS = conn.prepareStatement(QueryUpdateFrom2_0TableCheck);
testRS = testPS.executeQuery();
if (testRS.first())
{
return conn.prepareStatement(QueryUpdateFrom2_0Table);
}
else
{
return conn.prepareStatement("SELECT 1;");
}
}
finally
{
if (testRS != null)
{
try
{
testRS.close();
}
catch (SQLException ex)
{
Logger.getLogger(ProtectedBlockMySQL.class.getName()).log(Level.SEVERE, null, ex);
}
}
if (testPS != null)
{
try
{
testPS.close();
}
catch (SQLException ex)
{
Logger.getLogger(ProtectedBlockMySQL.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
}
private static final String QueryDeleteAll = "DELETE FROM EssentialsProtect;";
@Override
protected PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryDeleteAll);
}
private static final String QueryInsert =
"INSERT INTO EssentialsProtect (worldName, x, y, z, playerName) VALUES (?, ?, ?, ?, ?);";
@Override
protected PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryInsert);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
ps.setString(5, playerName);
return ps;
}
private static final String QueryCountByPlayer =
"SELECT COUNT(playerName), SUM(playerName = ?) FROM EssentialsProtect "
+ "WHERE worldName = ? AND x = ? AND y = ? AND z = ? GROUP BY x;";
@Override
protected PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryCountByPlayer);
ps.setString(1, playerName);
ps.setString(2, world);
ps.setInt(3, x);
ps.setInt(4, y);
ps.setInt(5, z);
return ps;
}
private static final String QueryPlayersByLocation =
"SELECT playerName FROM EssentialsProtect WHERE worldname = ? AND x = ? AND y = ? AND z = ?;";
@Override
protected PreparedStatement getStatementPlayersByLocation(Connection conn, String world, int x, int y, int z) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryPlayersByLocation);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
return ps;
}
private static final String QueryDeleteByLocation =
"DELETE FROM EssentialsProtect WHERE worldName = ? AND x = ? AND y = ? AND z = ?;";
@Override
protected PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryDeleteByLocation);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
return ps;
}
private static final String QueryAllBlocks =
"SELECT worldName, x, y, z, playerName FROM EssentialsProtect;";
@Override
protected PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryAllBlocks);
}
}

104
EssentialsProtect/src/com/earth2me/essentials/protect/data/ProtectedBlockSQLite.java
View file

@ -1,104 +0,0 @@
package com.earth2me.essentials.protect.data;
import java.beans.PropertyVetoException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class ProtectedBlockSQLite extends ProtectedBlockJDBC
{
public ProtectedBlockSQLite(String url) throws PropertyVetoException
{
super("org.sqlite.JDBC", url);
}
private static final String QueryCreateTable =
"CREATE TABLE IF NOT EXISTS EssentialsProtect ("
+ "worldName TEXT ,playerName TEXT, "
+ "x NUMERIC, y NUMERIC, z NUMERIC)";
@Override
protected PreparedStatement getStatementCreateTable(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryCreateTable);
}
private static final String QueryUpdateFrom2_0Table =
"CREATE INDEX IF NOT EXISTS position ON EssentialsProtect ("
+ "worldName, x, z, y)";
@Override
protected PreparedStatement getStatementUpdateFrom2_0Table(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryUpdateFrom2_0Table);
}
private static final String QueryDeleteAll = "DELETE FROM EssentialsProtect;";
@Override
protected PreparedStatement getStatementDeleteAll(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryDeleteAll);
}
private static final String QueryInsert =
"INSERT INTO EssentialsProtect (worldName, x, y, z, playerName) VALUES (?, ?, ?, ?, ?);";
@Override
protected PreparedStatement getStatementInsert(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryInsert);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
ps.setString(5, playerName);
return ps;
}
private static final String QueryPlayerCountByLocation =
"SELECT COUNT(playerName), SUM(playerName = ?) FROM EssentialsProtect "
+ "WHERE worldName = ? AND x = ? AND y = ? AND z = ? GROUP BY x;";
@Override
protected PreparedStatement getStatementPlayerCountByLocation(Connection conn, String world, int x, int y, int z, String playerName) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryPlayerCountByLocation);
ps.setString(1, playerName);
ps.setString(2, world);
ps.setInt(3, x);
ps.setInt(4, y);
ps.setInt(5, z);
return ps;
}
private static final String QueryPlayersByLocation =
"SELECT playerName FROM EssentialsProtect WHERE worldname = ? AND x = ? AND y = ? AND z = ?;";
@Override
protected PreparedStatement getStatementPlayersByLocation(Connection conn, String world, int x, int y, int z) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryPlayersByLocation);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
return ps;
}
private static final String QueryDeleteByLocation =
"DELETE FROM EssentialsProtect WHERE worldName = ? AND x = ? AND y = ? AND z = ?;";
@Override
protected PreparedStatement getStatementDeleteByLocation(Connection conn, String world, int x, int y, int z) throws SQLException
{
PreparedStatement ps = conn.prepareStatement(QueryDeleteByLocation);
ps.setString(1, world);
ps.setInt(2, x);
ps.setInt(3, y);
ps.setInt(4, z);
return ps;
}
private static final String QueryAllBlocks =
"SELECT worldName, x, y, z, playerName FROM EssentialsProtect;";
@Override
protected PreparedStatement getStatementAllBlocks(Connection conn) throws SQLException
{
return conn.prepareStatement(QueryAllBlocks);
}
}

4
EssentialsProtect/src/com/earth2me/essentials/protect/log4j.properties
View file

@ -1,4 +0,0 @@
log4j.rootLogger=INFO, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n

BIN
lib/c3p0-0.9.1.2.jar
View file

Binary file not shown.