From ae8cacb97bee2c5730da9a0fce632a67fe6b828c Mon Sep 17 00:00:00 2001 From: Evenprime Date: Sun, 6 Nov 2011 21:08:22 +0100 Subject: [PATCH] Massive rewrite part 1: Inheritance between checks, less entanglement between components, introduce "NoCheatPlayer" class for easier access to data and configuration --- .../co/evenprime/bukkit/nocheat/NoCheat.java | 44 ++--- .../bukkit/nocheat/NoCheatPlayer.java | 21 +++ .../bukkit/nocheat/actions/ActionManager.java | 67 ------- .../actions/types/ActionWithParameters.java | 117 +----------- .../actions/types/ConsolecommandAction.java | 7 +- .../nocheat/actions/types/LogAction.java | 7 +- .../nocheat/checks/BlockBreakCheck.java | 23 +++ .../nocheat/checks/BlockPlaceCheck.java | 66 +++++++ .../bukkit/nocheat/checks/ChatCheck.java | 38 ++++ .../bukkit/nocheat/checks/Check.java | 99 ++++++++++ .../bukkit/nocheat/checks/CheckUtil.java | 11 +- .../bukkit/nocheat/checks/FightCheck.java | 27 +++ .../bukkit/nocheat/checks/MovingCheck.java | 58 ++++++ .../bukkit/nocheat/checks/TimedCheck.java | 24 +++ .../checks/blockbreak/BlockBreakCheck.java | 58 ------ .../checks/blockbreak/DirectionCheck.java | 53 ++++-- .../checks/blockbreak/NoswingCheck.java | 54 ++++-- .../nocheat/checks/blockbreak/ReachCheck.java | 53 ++++-- .../checks/blockplace/BlockPlaceCheck.java | 54 ------ .../checks/blockplace/DirectionCheck.java | 65 ++++--- .../nocheat/checks/blockplace/ReachCheck.java | 52 ++++-- .../bukkit/nocheat/checks/chat/ChatCheck.java | 69 ------- .../bukkit/nocheat/checks/chat/SpamCheck.java | 63 +++++++ .../nocheat/checks/fight/DirectionCheck.java | 54 +++--- .../nocheat/checks/fight/FightCheck.java | 55 ------ .../nocheat/checks/fight/NoswingCheck.java | 47 +++-- .../nocheat/checks/fight/SelfhitCheck.java | 47 +++-- .../nocheat/checks/moving/FlyingCheck.java | 54 +++--- .../checks/moving/MorePacketsCheck.java | 123 +++++-------- .../nocheat/checks/moving/NoFallCheck.java | 85 +++++---- .../nocheat/checks/moving/RunFlyCheck.java | 130 ------------- .../nocheat/checks/moving/RunflyCheck.java | 48 +++++ .../nocheat/checks/moving/RunningCheck.java | 100 +++++----- .../nocheat/checks/timed/GodmodeCheck.java | 108 +++++++++++ .../nocheat/checks/timed/TimedCheck.java | 97 ---------- .../bukkit/nocheat/config/Configuration.java | 4 - .../nocheat/config/DefaultConfiguration.java | 7 - .../bukkit/nocheat/config/Explainations.java | 3 - .../bukkit/nocheat/config/Permissions.java | 14 +- .../bukkit/nocheat/config/cache/CCTimed.java | 1 + .../nocheat/config/util/ActionList.java | 4 +- .../bukkit/nocheat/data/BaseData.java | 6 +- .../bukkit/nocheat/data/BlockBreakData.java | 7 +- .../bukkit/nocheat/data/BlockPlaceData.java | 1 + .../bukkit/nocheat/data/ChatData.java | 2 + .../bukkit/nocheat/data/DataManager.java | 90 --------- .../bukkit/nocheat/data/FightData.java | 13 +- .../bukkit/nocheat/data/LogData.java | 16 -- .../bukkit/nocheat/data/MovingData.java | 5 + .../bukkit/nocheat/data/PlayerManager.java | 89 +++++++++ .../events/BlockBreakEventManager.java | 88 ++++++--- .../events/BlockPlaceEventManager.java | 82 +++++---- ...entManager.java => FightEventManager.java} | 80 +++++--- .../events/PlayerChatEventManager.java | 65 ++++--- .../events/PlayerMoveEventManager.java | 172 +++++++++++++----- .../events/PlayerTeleportEventManager.java | 2 +- .../nocheat/events/SwingEventManager.java | 2 +- .../nocheat/events/TimedEventManager.java | 61 ++++--- .../nocheat/player/NoCheatPlayerImpl.java | 43 +++++ 59 files changed, 1595 insertions(+), 1340 deletions(-) create mode 100644 src/cc/co/evenprime/bukkit/nocheat/NoCheatPlayer.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/actions/ActionManager.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/BlockBreakCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/BlockPlaceCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/ChatCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/Check.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/FightCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/MovingCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/TimedCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/BlockBreakCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/BlockPlaceCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/chat/ChatCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/chat/SpamCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/fight/FightCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunFlyCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunflyCheck.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/timed/GodmodeCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/checks/timed/TimedCheck.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/data/DataManager.java delete mode 100644 src/cc/co/evenprime/bukkit/nocheat/data/LogData.java create mode 100644 src/cc/co/evenprime/bukkit/nocheat/data/PlayerManager.java rename src/cc/co/evenprime/bukkit/nocheat/events/{EntityDamageEventManager.java => FightEventManager.java} (52%) create mode 100644 src/cc/co/evenprime/bukkit/nocheat/player/NoCheatPlayerImpl.java diff --git a/src/cc/co/evenprime/bukkit/nocheat/NoCheat.java b/src/cc/co/evenprime/bukkit/nocheat/NoCheat.java index 6f53784b..059ae0bc 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/NoCheat.java +++ b/src/cc/co/evenprime/bukkit/nocheat/NoCheat.java @@ -10,14 +10,10 @@ import org.bukkit.entity.Player; import org.bukkit.plugin.PluginDescriptionFile; import org.bukkit.plugin.java.JavaPlugin; -import cc.co.evenprime.bukkit.nocheat.actions.ActionManager; import cc.co.evenprime.bukkit.nocheat.command.CommandHandler; import cc.co.evenprime.bukkit.nocheat.config.ConfigurationManager; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.config.util.ActionList; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; -import cc.co.evenprime.bukkit.nocheat.data.DataManager; -import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; +import cc.co.evenprime.bukkit.nocheat.data.PlayerManager; import cc.co.evenprime.bukkit.nocheat.debug.ActiveCheckPrinter; import cc.co.evenprime.bukkit.nocheat.debug.LagMeasureTask; import cc.co.evenprime.bukkit.nocheat.debug.Performance; @@ -26,7 +22,7 @@ import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; import cc.co.evenprime.bukkit.nocheat.events.BlockPlaceEventManager; import cc.co.evenprime.bukkit.nocheat.events.BlockBreakEventManager; -import cc.co.evenprime.bukkit.nocheat.events.EntityDamageEventManager; +import cc.co.evenprime.bukkit.nocheat.events.FightEventManager; import cc.co.evenprime.bukkit.nocheat.events.EventManager; import cc.co.evenprime.bukkit.nocheat.events.PlayerChatEventManager; import cc.co.evenprime.bukkit.nocheat.events.PlayerMoveEventManager; @@ -47,9 +43,8 @@ public class NoCheat extends JavaPlugin { private ConfigurationManager conf; private LogManager log; - private DataManager data; + private PlayerManager players; private PerformanceManager performance; - private ActionManager action; private List eventManagers; @@ -94,7 +89,7 @@ public class NoCheat extends JavaPlugin { log.logToConsole(LogLevel.LOW, "[NoCheat] This version is for CB #1337. It may break at any time and for any other version."); // Then set up in memory per player data storage - this.data = new DataManager(); + this.players = new PlayerManager(this); // Then read the configuration files this.conf = new ConfigurationManager(this.getDataFolder().getPath()); @@ -102,9 +97,6 @@ public class NoCheat extends JavaPlugin { // Then set up the performance counters this.performance = new PerformanceManager(); - // Then set up the Action Manager - this.action = new ActionManager(this); - eventManagers = new ArrayList(8); // Big enough // Then set up the event listeners eventManagers.add(new PlayerMoveEventManager(this)); @@ -112,7 +104,7 @@ public class NoCheat extends JavaPlugin { eventManagers.add(new PlayerChatEventManager(this)); eventManagers.add(new BlockBreakEventManager(this)); eventManagers.add(new BlockPlaceEventManager(this)); - eventManagers.add(new EntityDamageEventManager(this)); + eventManagers.add(new FightEventManager(this)); eventManagers.add(new SwingEventManager(this)); TimedEventManager m = new TimedEventManager(this); taskId = m.taskId; // There's a bukkit task, remember its id @@ -132,7 +124,7 @@ public class NoCheat extends JavaPlugin { } public ConfigurationCache getConfig(Player player) { - return getConfig(player.getWorld()); + return conf.getConfigurationCacheForWorld(player.getWorld().getName()); } public ConfigurationCache getConfig(World world) { @@ -143,12 +135,8 @@ public class NoCheat extends JavaPlugin { log.log(level, message, cc); } - public BaseData getData(String playerName) { - return data.getData(playerName); - } - public void clearCriticalData(String playerName) { - data.clearCriticalData(playerName); + players.clearCriticalData(playerName); } public Performance getPerformance(Type type) { @@ -178,13 +166,6 @@ public class NoCheat extends JavaPlugin { return 1000L; } - public boolean execute(Player player, ActionList actions, int violationLevel, ExecutionHistory history, ConfigurationCache cc) { - if(action != null) { - return action.executeActions(player, actions, violationLevel, history, cc); - } - return false; - } - public void logToConsole(LogLevel low, String message) { if(log != null) { log.logToConsole(low, message); @@ -194,8 +175,8 @@ public class NoCheat extends JavaPlugin { public void reloadConfiguration() { conf.cleanup(); this.conf = new ConfigurationManager(this.getDataFolder().getPath()); - data.cleanDataMap(); - data.clearCriticalData(); + players.cleanDataMap(); + players.clearCriticalData(); } /** @@ -204,7 +185,12 @@ public class NoCheat extends JavaPlugin { * */ public void cleanDataMap() { - data.cleanDataMap(); + players.cleanDataMap(); } + + public NoCheatPlayer getPlayer(String playerName) { + return players.getPlayer(playerName); + } + } diff --git a/src/cc/co/evenprime/bukkit/nocheat/NoCheatPlayer.java b/src/cc/co/evenprime/bukkit/nocheat/NoCheatPlayer.java new file mode 100644 index 00000000..84e8dc4e --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/NoCheatPlayer.java @@ -0,0 +1,21 @@ +package cc.co.evenprime.bukkit.nocheat; + +import org.bukkit.entity.Player; + +import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.BaseData; + +public interface NoCheatPlayer { + + public boolean hasPermission(String permission); + + public String getName(); + + public Player getPlayer(); + + public BaseData getData(); + + public ConfigurationCache getConfiguration(); + + +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/actions/ActionManager.java b/src/cc/co/evenprime/bukkit/nocheat/actions/ActionManager.java deleted file mode 100644 index d35e702a..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/actions/ActionManager.java +++ /dev/null @@ -1,67 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.actions; - -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.actions.types.Action; -import cc.co.evenprime.bukkit.nocheat.actions.types.ConsolecommandAction; -import cc.co.evenprime.bukkit.nocheat.actions.types.LogAction; -import cc.co.evenprime.bukkit.nocheat.actions.types.SpecialAction; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.config.util.ActionList; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; -import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; - -/** - * Will trace the history of action executions to decide if an action 'really' - * gets executed. - * - */ -public class ActionManager { - - private final NoCheat plugin; - - public ActionManager(NoCheat plugin) { - this.plugin = plugin; - } - - public boolean executeActions(final Player player, final ActionList actions, final int violationLevel, final ExecutionHistory history, final ConfigurationCache cc) { - - boolean special = false; - - final BaseData data = plugin.getData(player.getName()); - // Always set this here "by hand" - data.log.violationLevel = violationLevel; - - final long time = System.currentTimeMillis() / 1000; - - for(Action ac : actions.getActions(violationLevel)) { - - if(history.executeAction(ac, time)) { - if(ac instanceof LogAction) { - executeLogAction((LogAction) ac, data, cc); - } else if(ac instanceof SpecialAction) { - special = true; - } else if(ac instanceof ConsolecommandAction) { - executeConsoleCommand((ConsolecommandAction) ac, data); - } - } - } - - return special; - } - - private void executeLogAction(LogAction l, BaseData data, ConfigurationCache cc) { - plugin.log(l.level, cc.logging.prefix + l.getLogMessage(data), cc); - } - - private void executeConsoleCommand(ConsolecommandAction action, BaseData data) { - String command = action.getCommand(data); - try { - plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), command); - } catch(Exception e) { - System.out.println("[NoCheat] failed to execute the command '" + command + "', please check if everything is setup correct. "); - e.printStackTrace(); - } - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/actions/types/ActionWithParameters.java b/src/cc/co/evenprime/bukkit/nocheat/actions/types/ActionWithParameters.java index bb5daf81..9813c160 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/actions/types/ActionWithParameters.java +++ b/src/cc/co/evenprime/bukkit/nocheat/actions/types/ActionWithParameters.java @@ -1,21 +1,13 @@ package cc.co.evenprime.bukkit.nocheat.actions.types; import java.util.ArrayList; -import java.util.Locale; -import org.bukkit.Bukkit; -import org.bukkit.Location; -import org.bukkit.Material; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.data.BaseData; -import cc.co.evenprime.bukkit.nocheat.data.LogData; -import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; -import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.Check; public abstract class ActionWithParameters extends Action { - private enum WildCard { + public enum WildCard { PLAYER("player"), LOCATION("location"), WORLD("world"), VIOLATIONS("violations"), MOVEDISTANCE("movedistance"), REACHDISTANCE("reachdistance"), FALLDISTANCE("falldistance"), LOCATION_TO("locationto"), CHECK("check"), PACKETS("packets"), TEXT("text"), PLACE_LOCATION("placelocation"), PLACE_AGAINST("placeagainst"), BLOCK_TYPE("blocktype"); private final String s; @@ -84,7 +76,9 @@ public abstract class ActionWithParameters extends Action { * @param data * @return */ - protected String getMessage(final BaseData data) { + + protected String getMessage(NoCheatPlayer player, Check check) { + StringBuilder log = new StringBuilder(100); // Should be big enough most // of the time @@ -92,107 +86,10 @@ public abstract class ActionWithParameters extends Action { if(part instanceof String) { log.append((String) part); } else { - log.append(getParameter((WildCard) part, data)); + log.append(check.getParameter((WildCard) part, player)); } } return log.toString(); } - - private String getParameter(WildCard wildcard, BaseData bdata) { - // The == is correct here, as these really are identical objects, not - // only equal - final LogData data = bdata.log; - - switch (wildcard) { - - case PLAYER: - return data.playerName; - - case CHECK: - return data.check; - - case LOCATION: { - Player player = Bukkit.getPlayer(data.playerName); - if(player != null) { - Location l = player.getLocation(); - return String.format(Locale.US, "%.2f,%.2f,%.2f", l.getX(), l.getY(), l.getZ()); - } - return "unknown"; - } - - case WORLD: { - Player player = Bukkit.getPlayer(data.playerName); - if(player != null) { - return player.getWorld().getName(); - } - return "unknown"; - } - case VIOLATIONS: - return String.format(Locale.US, "%d", data.violationLevel); - - case MOVEDISTANCE: { - Player player = Bukkit.getPlayer(data.playerName); - if(player != null) { - Location l = player.getLocation(); - PreciseLocation t = data.toLocation; - if(t.isSet()) { - return String.format(Locale.US, "%.2f,%.2f,%.2f", t.x - l.getX(), t.y - l.getY(), t.z - l.getZ()); - } else { - return "null"; - } - } - return "unknown"; - } - - case REACHDISTANCE: - return String.format(Locale.US, "%.2f", data.reachdistance); - - case FALLDISTANCE: - return String.format(Locale.US, "%.2f", data.falldistance); - - case LOCATION_TO: - PreciseLocation to = data.toLocation; - if(to.isSet()) { - return String.format(Locale.US, "%.2f,%.2f,%.2f", to.x, to.y, to.z); - } else { - return "unknown"; - } - - case PACKETS: - return String.valueOf(data.packets); - - case TEXT: - return data.text; - - case PLACE_LOCATION: { - SimpleLocation l = bdata.blockplace.blockPlaced; - if(l.isSet()) { - return String.format(Locale.US, "%d %d %d", l.x, l.y, l.z); - } else { - return "null"; - } - } - - case PLACE_AGAINST: { - SimpleLocation l = bdata.blockplace.blockPlacedAgainst; - if(l.isSet()) { - return String.format(Locale.US, "%d %d %d", l.x, l.y, l.z); - } else { - return "null"; - } - } - - case BLOCK_TYPE: { - Material type = bdata.blockplace.placedType; - if(type == null) { - return "null"; - } - return type.toString(); - } - - default: - return "Evenprime was lazy and forgot to define " + wildcard + "."; - } - } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/actions/types/ConsolecommandAction.java b/src/cc/co/evenprime/bukkit/nocheat/actions/types/ConsolecommandAction.java index e9d7fccf..94e94667 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/actions/types/ConsolecommandAction.java +++ b/src/cc/co/evenprime/bukkit/nocheat/actions/types/ConsolecommandAction.java @@ -1,6 +1,7 @@ package cc.co.evenprime.bukkit.nocheat.actions.types; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.Check; /** * Execute a command by imitating an admin typing the command directly into the @@ -14,8 +15,8 @@ public class ConsolecommandAction extends ActionWithParameters { } - public String getCommand(BaseData data) { + public String getCommand(NoCheatPlayer player, Check check) { - return super.getMessage(data); + return super.getMessage(player, check); } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/actions/types/LogAction.java b/src/cc/co/evenprime/bukkit/nocheat/actions/types/LogAction.java index 3fff5891..dc53a01f 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/actions/types/LogAction.java +++ b/src/cc/co/evenprime/bukkit/nocheat/actions/types/LogAction.java @@ -1,6 +1,7 @@ package cc.co.evenprime.bukkit.nocheat.actions.types; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.Check; import cc.co.evenprime.bukkit.nocheat.log.Colors; import cc.co.evenprime.bukkit.nocheat.log.LogLevel; @@ -19,7 +20,7 @@ public class LogAction extends ActionWithParameters { this.level = level; } - public String getLogMessage(final BaseData data) { - return super.getMessage(data); + public String getLogMessage(NoCheatPlayer player, Check check) { + return super.getMessage(player, check); } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/BlockBreakCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/BlockBreakCheck.java new file mode 100644 index 00000000..93ff8181 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/BlockBreakCheck.java @@ -0,0 +1,23 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockBreak; +import cc.co.evenprime.bukkit.nocheat.data.BlockBreakData; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; + +public abstract class BlockBreakCheck extends Check { + + public BlockBreakCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + public abstract boolean check(NoCheatPlayer player, BlockBreakData data, CCBlockBreak cc); + + public abstract boolean isEnabled(CCBlockBreak cc); + + @Override + protected final ExecutionHistory getHistory(NoCheatPlayer player) { + return player.getData().blockbreak.history; + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/BlockPlaceCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/BlockPlaceCheck.java new file mode 100644 index 00000000..fa6c1b88 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/BlockPlaceCheck.java @@ -0,0 +1,66 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import java.util.Locale; + +import org.bukkit.Material; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockPlace; +import cc.co.evenprime.bukkit.nocheat.data.BlockPlaceData; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; +import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; + +/** + * + */ +public abstract class BlockPlaceCheck extends Check { + + public BlockPlaceCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + public abstract boolean check(NoCheatPlayer player, BlockPlaceData data, CCBlockPlace cc); + + public abstract boolean isEnabled(CCBlockPlace cc); + + @Override + protected final ExecutionHistory getHistory(NoCheatPlayer player) { + return player.getData().blockplace.history; + } + + @Override + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + switch (wildcard) { + + case PLACE_LOCATION: { + SimpleLocation l = player.getData().blockplace.blockPlaced; + if(l.isSet()) { + return String.format(Locale.US, "%d %d %d", l.x, l.y, l.z); + } else { + return "null"; + } + } + + case PLACE_AGAINST: { + SimpleLocation l = player.getData().blockplace.blockPlacedAgainst; + if(l.isSet()) { + return String.format(Locale.US, "%d %d %d", l.x, l.y, l.z); + } else { + return "null"; + } + } + + case BLOCK_TYPE: { + Material type = player.getData().blockplace.placedType; + if(type == null) { + return "null"; + } + return type.toString(); + } + default: + return super.getParameter(wildcard, player); + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/ChatCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/ChatCheck.java new file mode 100644 index 00000000..6d07ee96 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/ChatCheck.java @@ -0,0 +1,38 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCChat; +import cc.co.evenprime.bukkit.nocheat.data.ChatData; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; + +public abstract class ChatCheck extends Check { + + public ChatCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + public abstract boolean check(NoCheatPlayer player, ChatData data, CCChat cc); + + public abstract boolean isEnabled(CCChat cc); + + @Override + protected final ExecutionHistory getHistory(NoCheatPlayer player) { + return player.getData().chat.history; + } + + @Override + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + switch (wildcard) { + + case TEXT: { + return player.getData().chat.message; + } + + default: + return super.getParameter(wildcard, player); + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/Check.java b/src/cc/co/evenprime/bukkit/nocheat/checks/Check.java new file mode 100644 index 00000000..50c3949b --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/Check.java @@ -0,0 +1,99 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import java.util.Locale; + +import org.bukkit.Location; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.Action; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.actions.types.ConsolecommandAction; +import cc.co.evenprime.bukkit.nocheat.actions.types.LogAction; +import cc.co.evenprime.bukkit.nocheat.actions.types.SpecialAction; +import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; + +public abstract class Check { + + private final String name; + private final String permission; + protected final NoCheat plugin; + + public Check(NoCheat plugin, String name, String permission) { + + this.plugin = plugin; + this.name = name; + this.permission = permission; + } + + public final String getName() { + return name; + } + + public final String getPermission() { + return permission; + } + + protected final boolean executeActions(NoCheatPlayer player, Action[] actions) { + + boolean special = false; + + final long time = System.currentTimeMillis() / 1000; + + final ConfigurationCache cc = player.getConfiguration(); + + for(Action ac : actions) { + if(getHistory(player).executeAction(ac, time)) { + if(ac instanceof LogAction) { + executeLogAction((LogAction) ac, this, player, cc); + } else if(ac instanceof SpecialAction) { + special = true; + } else if(ac instanceof ConsolecommandAction) { + executeConsoleCommand((ConsolecommandAction) ac, this, player, cc); + } + } + } + + return special; + } + + protected abstract ExecutionHistory getHistory(NoCheatPlayer player); + + private final void executeLogAction(LogAction l, Check check, NoCheatPlayer player, ConfigurationCache cc) { + plugin.log(l.level, cc.logging.prefix + l.getLogMessage(player, check), cc); + } + + private final void executeConsoleCommand(ConsolecommandAction action, Check check, NoCheatPlayer player, ConfigurationCache cc) { + String command = action.getCommand(player, check); + try { + plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), command); + } catch(Exception e) { + System.out.println("[NoCheat] failed to execute the command '" + command + "', please check if everything is setup correct. "); + e.printStackTrace(); + } + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + case PLAYER: + return player.getName(); + + case CHECK: + return getName(); + + case LOCATION: { + Location l = player.getPlayer().getLocation(); + return String.format(Locale.US, "%.2f,%.2f,%.2f", l.getX(), l.getY(), l.getZ()); + } + + case WORLD: { + return player.getPlayer().getWorld().getName(); + } + + default: + return "Evenprime was lazy and forgot to define " + wildcard + "."; + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/CheckUtil.java b/src/cc/co/evenprime/bukkit/nocheat/checks/CheckUtil.java index 6a272d95..0cad95f7 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/CheckUtil.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/CheckUtil.java @@ -9,6 +9,7 @@ import org.bukkit.craftbukkit.entity.CraftPlayer; import org.bukkit.entity.Player; import org.bukkit.util.Vector; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; /** @@ -21,15 +22,15 @@ public class CheckUtil { * Check if a player looks at a target of a specific size, with a specific * precision value (roughly) */ - public static final double directionCheck(final Player player, final double targetX, final double targetY, final double targetZ, final double targetWidth, final double targetHeight, final double precision) { + public static final double directionCheck(final NoCheatPlayer player, final double targetX, final double targetY, final double targetZ, final double targetWidth, final double targetHeight, final double precision) { // Eye location of the player - final Location eyes = player.getEyeLocation(); + final Location eyes = player.getPlayer().getEyeLocation(); final double factor = Math.sqrt(Math.pow(eyes.getX() - targetX, 2) + Math.pow(eyes.getY() - targetY, 2) + Math.pow(eyes.getZ() - targetZ, 2)); // View direction of the player - final Vector direction = player.getEyeLocation().getDirection(); + final Vector direction = eyes.getDirection(); final double x = ((double) targetX) - eyes.getX(); final double y = ((double) targetY) - eyes.getY(); @@ -52,9 +53,9 @@ public class CheckUtil { return off; } - public static final double reachCheck(final Player player, final double targetX, final double targetY, final double targetZ, final double limit) { + public static final double reachCheck(final NoCheatPlayer player, final double targetX, final double targetY, final double targetZ, final double limit) { - final Location eyes = player.getEyeLocation(); + final Location eyes = player.getPlayer().getEyeLocation(); final double distance = Math.sqrt(Math.pow(eyes.getX() - targetX, 2) + Math.pow(eyes.getY() - targetY, 2) + Math.pow(eyes.getZ() - targetZ, 2)); diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/FightCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/FightCheck.java new file mode 100644 index 00000000..d633b6f1 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/FightCheck.java @@ -0,0 +1,27 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCFight; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; +import cc.co.evenprime.bukkit.nocheat.data.FightData; + +/** + * Check various things related to fighting players/entities + * + */ +public abstract class FightCheck extends Check { + + public FightCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + public abstract boolean check(NoCheatPlayer player, FightData data, CCFight cc); + + public abstract boolean isEnabled(CCFight cc); + + @Override + protected final ExecutionHistory getHistory(NoCheatPlayer player) { + return player.getData().fight.history; + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/MovingCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/MovingCheck.java new file mode 100644 index 00000000..f306a9dd --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/MovingCheck.java @@ -0,0 +1,58 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import java.util.Locale; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; +import cc.co.evenprime.bukkit.nocheat.data.MovingData; +import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; + +public abstract class MovingCheck extends Check { + + public MovingCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + /** + * Return a new destination location or null + * + * @param event + * @return + */ + public abstract PreciseLocation check(final NoCheatPlayer player, MovingData data, CCMoving cc); + + public abstract boolean isEnabled(CCMoving moving); + + @Override + protected ExecutionHistory getHistory(NoCheatPlayer player) { + return player.getData().moving.history; + } + + @Override + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case LOCATION: { + PreciseLocation from = player.getData().moving.from; + return String.format(Locale.US, "%.2f,%.2f,%.2f", from.x, from.y, from.z); + } + + case MOVEDISTANCE: { + PreciseLocation from = player.getData().moving.from; + PreciseLocation to = player.getData().moving.to; + return String.format(Locale.US, "%.2f,%.2f,%.2f", to.x - from.x, to.y - from.y, to.z - from.z); + } + + case LOCATION_TO: + PreciseLocation to = player.getData().moving.to; + return String.format(Locale.US, "%.2f,%.2f,%.2f", to.x, to.y, to.z); + + default: + return super.getParameter(wildcard, player); + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/TimedCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/TimedCheck.java new file mode 100644 index 00000000..596ad7f9 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/TimedCheck.java @@ -0,0 +1,24 @@ +package cc.co.evenprime.bukkit.nocheat.checks; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCTimed; +import cc.co.evenprime.bukkit.nocheat.data.ExecutionHistory; +import cc.co.evenprime.bukkit.nocheat.data.TimedData; + +public abstract class TimedCheck extends Check { + + public TimedCheck(NoCheat plugin, String name, String permission) { + super(plugin, name, permission); + } + + public abstract boolean check(final NoCheatPlayer player, TimedData data, CCTimed cc); + + public abstract boolean isEnabled(CCTimed cc); + + @Override + protected ExecutionHistory getHistory(NoCheatPlayer player) { + // TODO Auto-generated method stub + return player.getData().timed.history; + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/BlockBreakCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/BlockBreakCheck.java deleted file mode 100644 index a3991fb1..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/BlockBreakCheck.java +++ /dev/null @@ -1,58 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.blockbreak; - -import org.bukkit.block.Block; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; - -/** - * The main Check class for blockbreak event checking. It will decide which - * checks need to be executed and in which order. It will also precalculate - * some values that are needed by multiple checks. - * - */ -public class BlockBreakCheck { - - private final ReachCheck reachCheck; - private final DirectionCheck directionCheck; - private final NoswingCheck noswingCheck; - private final NoCheat plugin; - - public BlockBreakCheck(NoCheat plugin) { - - this.plugin = plugin; - this.reachCheck = new ReachCheck(plugin); - this.directionCheck = new DirectionCheck(plugin); - this.noswingCheck = new NoswingCheck(plugin); - } - - public boolean check(final Player player, final Block brokenBlock, final ConfigurationCache cc) { - - boolean cancel = false; - - // Reach check only if not in creative mode! - final boolean reach = cc.blockbreak.reachCheck && !player.hasPermission(Permissions.BLOCKBREAK_REACH); - final boolean direction = cc.blockbreak.directionCheck && !player.hasPermission(Permissions.BLOCKBREAK_DIRECTION); - final boolean noswing = cc.blockbreak.noswingCheck && !player.hasPermission(Permissions.BLOCKBREAK_NOSWING); - - if((noswing || reach || direction) && brokenBlock != null) { - - final BaseData data = plugin.getData(player.getName()); - - if(noswing) { - cancel = noswingCheck.check(player, data, cc); - } - if(!cancel && reach) { - cancel = reachCheck.check(player, data, brokenBlock, cc); - } - - if(!cancel && direction) { - cancel = directionCheck.check(player, data, brokenBlock, cc); - } - } - return cancel; - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/DirectionCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/DirectionCheck.java index d4534f9d..555b9dd8 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/DirectionCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/DirectionCheck.java @@ -1,35 +1,33 @@ package cc.co.evenprime.bukkit.nocheat.checks.blockbreak; -import org.bukkit.block.Block; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.BlockBreakCheck; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockBreak; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; import cc.co.evenprime.bukkit.nocheat.data.BlockBreakData; +import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; /** * The DirectionCheck will find out if a player tried to interact with something * that's not in his field of view. * */ -public class DirectionCheck { - - private final NoCheat plugin; +public class DirectionCheck extends BlockBreakCheck { public DirectionCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "blockbreak.direction", Permissions.BLOCKBREAK_DIRECTION); } - public boolean check(final Player player, final BaseData data, final Block brokenBlock, final ConfigurationCache cc) { + public boolean check(final NoCheatPlayer player, final BlockBreakData blockbreak, final CCBlockBreak ccblockbreak) { - final BlockBreakData blockbreak = data.blockbreak; - final CCBlockBreak ccblockbreak = cc.blockbreak; - + final SimpleLocation brokenBlock = blockbreak.brokenBlockLocation; final boolean isInstaBreak = blockbreak.instaBrokeBlockLocation.equals(brokenBlock); - + // If the block is instabreak and we don't check instabreak, return if(isInstaBreak && !ccblockbreak.checkinstabreakblocks) { return false; @@ -37,7 +35,7 @@ public class DirectionCheck { boolean cancel = false; - double off = CheckUtil.directionCheck(player, brokenBlock.getX() + 0.5D, brokenBlock.getY() + 0.5D, brokenBlock.getZ() + 0.5D, 1D, 1D, ccblockbreak.directionPrecision); + double off = CheckUtil.directionCheck(player, brokenBlock.x + 0.5D, brokenBlock.y + 0.5D, brokenBlock.z + 0.5D, 1D, 1D, ccblockbreak.directionPrecision); final long time = System.currentTimeMillis(); @@ -49,15 +47,13 @@ public class DirectionCheck { // Player failed the check // Increment violation counter if(isInstaBreak) { - // Instabreak block failures are very common, so don't be as hard on people failing them + // Instabreak block failures are very common, so don't be as + // hard on people failing them off /= 10; } blockbreak.directionViolationLevel += off; - // Prepare some event-specific values for logging and custom actions - data.log.check = "blockbreak.direction"; - - cancel = plugin.execute(player, ccblockbreak.directionActions, (int) blockbreak.directionViolationLevel, blockbreak.history, cc); + cancel = executeActions(player, ccblockbreak.directionActions.getActions(blockbreak.directionViolationLevel)); if(cancel) { // Needed to calculate penalty times @@ -66,10 +62,27 @@ public class DirectionCheck { } // If the player is still in penalty time, cancel the event anyway - if(blockbreak.directionLastViolationTime + ccblockbreak.directionPenaltyTime >= time) { + if(blockbreak.directionLastViolationTime + ccblockbreak.directionPenaltyTime > time) { return true; } return cancel; } + + public boolean isEnabled(CCBlockBreak cc) { + return cc.directionCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().blockbreak.directionViolationLevel); + + default: + return super.getParameter(wildcard, player); + + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/NoswingCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/NoswingCheck.java index 5f19d014..d1c6c0d0 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/NoswingCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/NoswingCheck.java @@ -1,36 +1,56 @@ package cc.co.evenprime.bukkit.nocheat.checks.blockbreak; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.BlockBreakCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockBreak; import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.data.BlockBreakData; -public class NoswingCheck { - - private final NoCheat plugin; +public class NoswingCheck extends BlockBreakCheck { public NoswingCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "blockbreak.noswing", Permissions.BLOCKBREAK_NOSWING); } - public boolean check(final Player player, final BaseData data, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, BlockBreakData data, CCBlockBreak cc) { boolean cancel = false; - // did he swing his arm before? - if(data.armswung) { - data.armswung = false; - data.blockbreak.noswingVL *= 0.90D; - } else { - data.blockbreak.noswingVL += 1; - // Prepare some event-specific values for logging and custom - // actions - data.log.check = "blockbreak.noswing"; + BaseData d = player.getData(); - cancel = plugin.execute(player, cc.blockbreak.noswingActions, (int) data.blockbreak.noswingVL, data.blockbreak.history, cc); + // did he swing his arm before? + if(d.armswung) { + d.armswung = false; + data.noswingVL *= 0.90D; + } else { + data.noswingVL += 1; + + cancel = executeActions(player, cc.noswingActions.getActions(data.noswingVL)); } return cancel; } + + public boolean isEnabled(CCBlockBreak cc) { + return cc.noswingCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().blockbreak.noswingVL); + + default: + return super.getParameter(wildcard, player); + + } + } + } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/ReachCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/ReachCheck.java index b7b864cd..dc7a545f 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/ReachCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/blockbreak/ReachCheck.java @@ -1,52 +1,69 @@ package cc.co.evenprime.bukkit.nocheat.checks.blockbreak; +import java.util.Locale; + import org.bukkit.GameMode; -import org.bukkit.block.Block; -import org.bukkit.entity.Player; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.BlockBreakCheck; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockBreak; import cc.co.evenprime.bukkit.nocheat.data.BlockBreakData; +import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; /** * The reach check will find out if a player interacts with something that's too * far away * */ -public class ReachCheck { - - private final NoCheat plugin; +public class ReachCheck extends BlockBreakCheck { public ReachCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "blockbreak.reach", Permissions.BLOCKBREAK_REACH); } - public boolean check(final Player player, final BaseData data, final Block brokenBlock, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, BlockBreakData data, CCBlockBreak cc) { boolean cancel = false; - final BlockBreakData blockbreak = data.blockbreak; + final SimpleLocation brokenBlock = data.brokenBlockLocation; - final double distance = CheckUtil.reachCheck(player, brokenBlock.getX() + 0.5D, brokenBlock.getY() + 0.5D, brokenBlock.getZ() + 0.5D, player.getGameMode() == GameMode.CREATIVE ? cc.blockbreak.reachDistance + 2 : cc.blockbreak.reachDistance); + final double distance = CheckUtil.reachCheck(player, brokenBlock.x + 0.5D, brokenBlock.y + 0.5D, brokenBlock.z + 0.5D, player.getPlayer().getGameMode() == GameMode.CREATIVE ? cc.reachDistance + 2 : cc.reachDistance); if(distance > 0D) { // Player failed the check // Increment violation counter - blockbreak.reachViolationLevel += distance; + data.reachVL += distance; + data.reachDistance = distance; - // Setup data for logging - data.log.check = "blockbreak.reach"; - data.log.reachdistance = distance; - - cancel = plugin.execute(player, cc.blockbreak.reachActions, (int) blockbreak.reachViolationLevel, blockbreak.history, cc); + cancel = executeActions(player, cc.reachActions.getActions(data.reachVL)); } else { - blockbreak.reachViolationLevel *= 0.9D; + data.reachVL *= 0.9D; } return cancel; } + public boolean isEnabled(CCBlockBreak cc) { + return cc.reachCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().blockbreak.reachVL); + + case REACHDISTANCE: + return String.format(Locale.US, "%.2f", player.getData().blockbreak.reachDistance); + + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/BlockPlaceCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/BlockPlaceCheck.java deleted file mode 100644 index 120f031b..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/BlockPlaceCheck.java +++ /dev/null @@ -1,54 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.blockplace; - -import org.bukkit.block.Block; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; - -/** - * - */ -public class BlockPlaceCheck { - - private final ReachCheck reachCheck; - private final DirectionCheck directionCheck; - private final NoCheat plugin; - - public BlockPlaceCheck(NoCheat plugin) { - - this.plugin = plugin; - - reachCheck = new ReachCheck(plugin); - directionCheck = new DirectionCheck(plugin); - } - - public boolean check(final Player player, final Block blockPlaced, final Block blockPlacedAgainst, final ConfigurationCache cc) { - - boolean cancel = false; - - // Which checks are going to be executed? - final boolean reach = cc.blockplace.reachCheck && !player.hasPermission(Permissions.BLOCKPLACE_REACH); - final boolean direction = cc.blockplace.directionCheck && !player.hasPermission(Permissions.BLOCKPLACE_DIRECTION); - - final BaseData data = plugin.getData(player.getName()); - - if(blockPlaced != null && blockPlacedAgainst != null) { - data.blockplace.blockPlaced.set(blockPlaced); - data.blockplace.blockPlacedAgainst.set(blockPlacedAgainst); - data.blockplace.placedType = blockPlaced.getType(); - - if(!cancel && direction) { - cancel = directionCheck.check(player, data, cc); - } - - if(!cancel && reach) { - cancel = reachCheck.check(player, data, cc); - } - } - - return cancel; - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/DirectionCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/DirectionCheck.java index aabc21cd..bab7ca1e 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/DirectionCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/DirectionCheck.java @@ -1,35 +1,32 @@ package cc.co.evenprime.bukkit.nocheat.checks.blockplace; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.BlockPlaceCheck; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockPlace; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; import cc.co.evenprime.bukkit.nocheat.data.BlockPlaceData; import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; -public class DirectionCheck { - - private final NoCheat plugin; +public class DirectionCheck extends BlockPlaceCheck { public DirectionCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "blockplace.direction", Permissions.BLOCKPLACE_DIRECTION); } - public boolean check(final Player player, final BaseData data, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, BlockPlaceData data, CCBlockPlace cc) { boolean cancel = false; - final CCBlockPlace ccblockplace = cc.blockplace; - final BlockPlaceData blockplace = data.blockplace; - - final SimpleLocation blockPlaced = blockplace.blockPlaced; - final SimpleLocation blockPlacedAgainst = blockplace.blockPlacedAgainst; + final SimpleLocation blockPlaced = data.blockPlaced; + final SimpleLocation blockPlacedAgainst = data.blockPlacedAgainst; // First check if the crosshair matches (roughly) the clicked block - double off = CheckUtil.directionCheck(player, blockPlacedAgainst.x + 0.5D, blockPlacedAgainst.y + 0.5D, blockPlacedAgainst.z + 0.5D, 1D, 1D, ccblockplace.directionPrecision); + double off = CheckUtil.directionCheck(player, blockPlacedAgainst.x + 0.5D, blockPlacedAgainst.y + 0.5D, blockPlacedAgainst.z + 0.5D, 1D, 1D, cc.directionPrecision); // now check if the player is looking at the block from the correct side @@ -38,17 +35,17 @@ public class DirectionCheck { // Find out against which face the player tried to build, and if he // stood on the correct side if(blockPlaced.x > blockPlacedAgainst.x) { - off2 = blockPlacedAgainst.x + 0.5D - player.getEyeLocation().getX(); + off2 = blockPlacedAgainst.x + 0.5D - player.getPlayer().getEyeLocation().getX(); } else if(blockPlaced.x < blockPlacedAgainst.x) { - off2 = -(blockPlacedAgainst.x + 0.5D - player.getEyeLocation().getX()); + off2 = -(blockPlacedAgainst.x + 0.5D - player.getPlayer().getEyeLocation().getX()); } else if(blockPlaced.y > blockPlacedAgainst.y) { - off2 = blockPlacedAgainst.y + 0.5D - player.getEyeLocation().getY(); + off2 = blockPlacedAgainst.y + 0.5D - player.getPlayer().getEyeLocation().getY(); } else if(blockPlaced.y < blockPlacedAgainst.y) { - off2 = -(blockPlacedAgainst.y + 0.5D - player.getEyeLocation().getY()); + off2 = -(blockPlacedAgainst.y + 0.5D - player.getPlayer().getEyeLocation().getY()); } else if(blockPlaced.z > blockPlacedAgainst.z) { - off2 = blockPlacedAgainst.z + 0.5D - player.getEyeLocation().getZ(); + off2 = blockPlacedAgainst.z + 0.5D - player.getPlayer().getEyeLocation().getZ(); } else if(blockPlaced.z < blockPlacedAgainst.z) { - off2 = -(blockPlacedAgainst.z + 0.5D - player.getEyeLocation().getZ()); + off2 = -(blockPlacedAgainst.z + 0.5D - player.getPlayer().getEyeLocation().getZ()); } if(off2 > 0.0D) { @@ -60,28 +57,44 @@ public class DirectionCheck { if(off < 0.1D) { // Player did nothing wrong // reduce violation counter - blockplace.directionViolationLevel *= 0.9D; + data.directionViolationLevel *= 0.9D; } else { // Player failed the check // Increment violation counter - blockplace.directionViolationLevel += off; + data.directionViolationLevel += off; // Prepare some event-specific values for logging and custom actions - data.log.check = "blockplace.direction"; - cancel = plugin.execute(player, ccblockplace.directionActions, (int) blockplace.directionViolationLevel, blockplace.history, cc); + cancel = executeActions(player, cc.directionActions.getActions(data.directionViolationLevel)); if(cancel) { // Needed to calculate penalty times - blockplace.directionLastViolationTime = time; + data.directionLastViolationTime = time; } } // If the player is still in penalty time, cancel the event anyway - if(blockplace.directionLastViolationTime + ccblockplace.directionPenaltyTime >= time) { + if(data.directionLastViolationTime + cc.directionPenaltyTime > time) { return true; } return cancel; } + + @Override + public boolean isEnabled(CCBlockPlace cc) { + return cc.directionCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().blockplace.directionViolationLevel); + + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/ReachCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/ReachCheck.java index 284ae505..5d9b8f89 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/ReachCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/blockplace/ReachCheck.java @@ -1,11 +1,14 @@ package cc.co.evenprime.bukkit.nocheat.checks.blockplace; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.BlockPlaceCheck; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockPlace; import cc.co.evenprime.bukkit.nocheat.data.BlockPlaceData; import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; @@ -14,39 +17,52 @@ import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; * far away * */ -public class ReachCheck { - - private final NoCheat plugin; +public class ReachCheck extends BlockPlaceCheck { public ReachCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "blockplace.reach", Permissions.BLOCKPLACE_REACH); } - public boolean check(final Player player, final BaseData data, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, BlockPlaceData data, CCBlockPlace cc) { boolean cancel = false; - final SimpleLocation placedAgainstBlock = data.blockplace.blockPlacedAgainst; - final double distance = CheckUtil.reachCheck(player, placedAgainstBlock.x + 0.5D, placedAgainstBlock.y + 0.5D, placedAgainstBlock.z + 0.5D, cc.blockplace.reachDistance); + final SimpleLocation placedAgainstBlock = data.blockPlacedAgainst; - BlockPlaceData blockplace = data.blockplace; + final double distance = CheckUtil.reachCheck(player, placedAgainstBlock.x + 0.5D, placedAgainstBlock.y + 0.5D, placedAgainstBlock.z + 0.5D, cc.reachDistance); if(distance > 0D) { // Player failed the check // Increment violation counter - blockplace.reachViolationLevel += distance; + data.reachViolationLevel += distance; + data.reachdistance = distance; - // Prepare some event-specific values for logging and custom actions - data.log.check = "blockplace.reach"; - data.log.reachdistance = distance; - - cancel = plugin.execute(player, cc.blockplace.reachActions, (int) blockplace.reachViolationLevel, blockplace.history, cc); + cancel = executeActions(player, cc.reachActions.getActions(data.reachViolationLevel)); } else { - blockplace.reachViolationLevel *= 0.9D; + data.reachViolationLevel *= 0.9D; } return cancel; } + @Override + public boolean isEnabled(CCBlockPlace cc) { + return cc.reachCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().blockplace.reachViolationLevel); + + case REACHDISTANCE: + return String.format(Locale.US, "%.2f", player.getData().blockplace.reachdistance); + + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/chat/ChatCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/chat/ChatCheck.java deleted file mode 100644 index 6c9d1a06..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/chat/ChatCheck.java +++ /dev/null @@ -1,69 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.chat; - -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.CCChat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; -import cc.co.evenprime.bukkit.nocheat.data.ChatData; - -/** - * - */ -public class ChatCheck { - - private final NoCheat plugin; - - public ChatCheck(NoCheat plugin) { - - this.plugin = plugin; - } - - public boolean check(final Player player, final String message, final ConfigurationCache cc) { - - boolean cancel = false; - - final CCChat ccchat = cc.chat; - - final boolean spamCheck = ccchat.spamCheck && !player.hasPermission(Permissions.CHAT_SPAM); - - if(spamCheck) { - - // Maybe it's a command and on the whitelist - for(String s : ccchat.spamWhitelist) { - if(message.startsWith(s)) { - // It is - return false; - } - } - - final int time = plugin.getIngameSeconds(); - - final BaseData data = plugin.getData(player.getName()); - final ChatData chat = data.chat; - - if(chat.spamLasttime + ccchat.spamTimeframe <= time) { - chat.spamLasttime = time; - chat.messageCount = 0; - } - - chat.messageCount++; - - if(chat.messageCount > ccchat.spamLimit) { - - // Prepare some event-specific values for logging and custom - // actions - - data.log.check = "chat.spam"; - data.log.text = message; - - cancel = plugin.execute(player, ccchat.spamActions, chat.messageCount - ccchat.spamLimit, chat.history, cc); - } - } - - return cancel; - } - -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/chat/SpamCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/chat/SpamCheck.java new file mode 100644 index 00000000..9d60aa0a --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/chat/SpamCheck.java @@ -0,0 +1,63 @@ +package cc.co.evenprime.bukkit.nocheat.checks.chat; + +import java.util.Locale; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.ChatCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCChat; +import cc.co.evenprime.bukkit.nocheat.data.ChatData; + +public class SpamCheck extends ChatCheck { + + public SpamCheck(NoCheat plugin) { + super(plugin, "chat.spam", Permissions.CHAT_SPAM); + } + + public boolean check(NoCheatPlayer player, ChatData data, CCChat cc) { + + boolean cancel = false; + // Maybe it's a command and on the whitelist + for(String s : cc.spamWhitelist) { + if(data.message.startsWith(s)) { + // It is + return false; + } + } + + final int time = plugin.getIngameSeconds(); + + if(data.spamLasttime + cc.spamTimeframe <= time) { + data.spamLasttime = time; + data.messageCount = 0; + } + + data.messageCount++; + + if(data.messageCount > cc.spamLimit) { + + data.spamVL = data.messageCount - cc.spamLimit; + cancel = executeActions(player, cc.spamActions.getActions(data.spamVL)); + } + + return cancel; + } + + @Override + public boolean isEnabled(CCChat cc) { + return cc.spamCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().chat.spamVL); + default: + return super.getParameter(wildcard, player); + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/DirectionCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/DirectionCheck.java index bf30c1d9..fb861519 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/DirectionCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/DirectionCheck.java @@ -1,30 +1,31 @@ package cc.co.evenprime.bukkit.nocheat.checks.fight; -import org.bukkit.craftbukkit.entity.CraftEntity; -import org.bukkit.entity.Entity; -import org.bukkit.entity.Player; +import java.util.Locale; +import net.minecraft.server.Entity; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.checks.FightCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCFight; +import cc.co.evenprime.bukkit.nocheat.data.FightData; -public class DirectionCheck { - - private final NoCheat plugin; +public class DirectionCheck extends FightCheck { public DirectionCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "fight.direction", Permissions.FIGHT_DIRECTION); } - public boolean check(final Player player, final BaseData data, final Entity damagee, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, FightData data, CCFight cc) { boolean cancel = false; final long time = System.currentTimeMillis(); // Get the width of the damagee - net.minecraft.server.Entity entity = ((CraftEntity) damagee).getHandle(); + Entity entity = data.damagee; final float width = entity.length > entity.width ? entity.length : entity.width; @@ -32,37 +33,48 @@ public class DirectionCheck { // and that should be enough. Because entityLocations are always set // to center bottom of the hitbox, increase "y" location by 1/2 // height to get the "center" of the hitbox - final double off = CheckUtil.directionCheck(player, entity.locX, entity.locY + 1.0D, entity.locZ, width, 2.0D, cc.fight.directionPrecision); + final double off = CheckUtil.directionCheck(player, entity.locX, entity.locY + 1.0D, entity.locZ, width, 2.0D, cc.directionPrecision); if(off < 0.1D) { // Player did probably nothing wrong // reduce violation counter - data.fight.violationLevel *= 0.80D; + data.directionVL *= 0.80D; } else { // Player failed the check // Increment violation counter if(!plugin.skipCheck()) { - data.fight.violationLevel += Math.sqrt(off); + data.directionVL += Math.sqrt(off); } - // Prepare some event-specific values for logging and custom - // actions - data.log.check = "fight.direction"; - - cancel = plugin.execute(player, cc.fight.directionActions, (int) data.fight.violationLevel, data.fight.history, cc); + cancel = executeActions(player, cc.directionActions.getActions(data.directionVL)); if(cancel) { // Needed to calculate penalty times - data.fight.directionLastViolationTime = time; + data.directionLastViolationTime = time; } } // If the player is still in penalty time, cancel the event anyway - if(data.fight.directionLastViolationTime + cc.fight.directionPenaltyTime >= time) { + if(data.directionLastViolationTime + cc.directionPenaltyTime > time) { return true; } return cancel; } + @Override + public boolean isEnabled(CCFight cc) { + return cc.directionCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().fight.directionVL); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/FightCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/FightCheck.java deleted file mode 100644 index 4ff7af5d..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/FightCheck.java +++ /dev/null @@ -1,55 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.fight; - -import org.bukkit.entity.Entity; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; - -/** - * Check various things related to fighting players/entities - * - */ -public class FightCheck { - - private final NoCheat plugin; - - private final DirectionCheck directionCheck; - private final SelfhitCheck selfhitCheck; - private final NoswingCheck noswingCheck; - - public FightCheck(NoCheat plugin) { - - this.plugin = plugin; - - this.directionCheck = new DirectionCheck(plugin); - this.selfhitCheck = new SelfhitCheck(plugin); - this.noswingCheck = new NoswingCheck(plugin); - } - - public boolean check(final Player player, final Entity damagee, final ConfigurationCache cc) { - - boolean cancel = false; - - final boolean selfhitcheck = cc.fight.selfhitCheck && !player.hasPermission(Permissions.FIGHT_SELFHIT); - final boolean directioncheck = cc.fight.directionCheck && !player.hasPermission(Permissions.FIGHT_DIRECTION); - final boolean noswingcheck = cc.fight.noswingCheck && !player.hasPermission(Permissions.FIGHT_NOSWING); - - BaseData data = plugin.getData(player.getName()); - - if(noswingcheck) { - cancel = noswingCheck.check(player, data, cc); - } - if(!cancel && directioncheck) { - cancel = directionCheck.check(player, data, damagee, cc); - } - - if(!cancel && selfhitcheck) { - cancel = selfhitCheck.check(player, data, damagee, cc); - } - - return cancel; - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/NoswingCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/NoswingCheck.java index 1343b782..01a6ae52 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/NoswingCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/NoswingCheck.java @@ -1,36 +1,53 @@ package cc.co.evenprime.bukkit.nocheat.checks.fight; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.FightCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCFight; import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.data.FightData; -public class NoswingCheck { - - private final NoCheat plugin; +public class NoswingCheck extends FightCheck { public NoswingCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "fight.noswing", Permissions.FIGHT_NOSWING); } - public boolean check(final Player player, final BaseData data, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, FightData data, CCFight cc) { boolean cancel = false; + BaseData d = player.getData(); // did he swing his arm before? - if(data.armswung) { - data.armswung = false; - data.fight.noswingVL *= 0.90D; + if(d.armswung) { + d.armswung = false; + data.noswingVL *= 0.90D; } else { - data.fight.noswingVL += 1; - // Prepare some event-specific values for logging and custom - // actions - data.log.check = "fight.noswing"; + data.noswingVL += 1; - cancel = plugin.execute(player, cc.fight.noswingActions, (int) data.fight.noswingVL, data.fight.history, cc); + cancel = executeActions(player, cc.noswingActions.getActions(data.noswingVL)); } return cancel; } + + @Override + public boolean isEnabled(CCFight cc) { + return cc.noswingCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().fight.noswingVL); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/SelfhitCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/SelfhitCheck.java index 6656d785..dd3393ae 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/fight/SelfhitCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/fight/SelfhitCheck.java @@ -1,39 +1,50 @@ package cc.co.evenprime.bukkit.nocheat.checks.fight; -import org.bukkit.entity.Entity; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.FightCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCFight; +import cc.co.evenprime.bukkit.nocheat.data.FightData; -public class SelfhitCheck { - - private final NoCheat plugin; +public class SelfhitCheck extends FightCheck { public SelfhitCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "fight.selfhit", Permissions.FIGHT_SELFHIT); } - public boolean check(final Player player, final BaseData data, final Entity damagee, final ConfigurationCache cc) { + public boolean check(NoCheatPlayer player, FightData data, CCFight cc) { boolean cancel = false; - if(player.equals(damagee)) { - + if(player.getPlayer().equals(data.damagee)) { // Player failed the check obviously - data.fight.selfhitviolationLevel += 1; - // Prepare some event-specific values for logging and custom - // actions - data.log.check = "fight.selfhit"; - - cancel = plugin.execute(player, cc.fight.selfhitActions, (int) data.fight.selfhitviolationLevel, data.fight.history, cc); + data.selfhitVL += 1; + cancel = executeActions(player, cc.selfhitActions.getActions(data.selfhitVL)); } else { - data.fight.selfhitviolationLevel *= 0.99D; + data.selfhitVL *= 0.99D; } return cancel; } + @Override + public boolean isEnabled(CCFight cc) { + return cc.selfhitCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().fight.selfhitVL); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/FlyingCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/FlyingCheck.java index 8970f292..dfb25f52 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/FlyingCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/FlyingCheck.java @@ -1,17 +1,18 @@ package cc.co.evenprime.bukkit.nocheat.checks.moving; +import java.util.Locale; + import net.minecraft.server.EntityPlayer; import net.minecraft.server.MobEffectList; import org.bukkit.GameMode; import org.bukkit.craftbukkit.entity.CraftPlayer; -import org.bukkit.entity.Player; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; import cc.co.evenprime.bukkit.nocheat.data.MovingData; import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; @@ -21,24 +22,19 @@ import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; * therefore have tighter rules to obey. * */ -public class FlyingCheck { +public class FlyingCheck extends MovingCheck { - private final NoCheat plugin; + public FlyingCheck(NoCheat plugin) { + super(plugin, "moving.flying", null); + } private static final double creativeSpeed = 0.60D; - public FlyingCheck(NoCheat plugin) { - this.plugin = plugin; - } + public PreciseLocation check(NoCheatPlayer player, MovingData moving, CCMoving ccmoving) { - public PreciseLocation check(final Player player, final BaseData data, final ConfigurationCache cc) { - - final MovingData moving = data.moving; - final PreciseLocation to = moving.to; - final PreciseLocation from = moving.from; final PreciseLocation setBack = moving.runflySetBackPoint; - - final CCMoving ccmoving = cc.moving; + final PreciseLocation from = moving.from; + final PreciseLocation to = moving.to; if(!setBack.isSet()) { setBack.set(from); @@ -56,7 +52,7 @@ public class FlyingCheck { // In case of creative gamemode, give at least 0.60 speed limit // horizontal - double speedLimitHorizontal = player.getGameMode() == GameMode.CREATIVE ? Math.max(creativeSpeed, ccmoving.flyingSpeedLimitHorizontal) : ccmoving.flyingSpeedLimitHorizontal; + double speedLimitHorizontal = player.getPlayer().getGameMode() == GameMode.CREATIVE ? Math.max(creativeSpeed, ccmoving.flyingSpeedLimitHorizontal) : ccmoving.flyingSpeedLimitHorizontal; EntityPlayer p = ((CraftPlayer) player).getHandle(); @@ -67,7 +63,7 @@ public class FlyingCheck { result += Math.max(0.0D, horizontalDistance - moving.horizFreedom - speedLimitHorizontal); - boolean sprinting = CheckUtil.isSprinting(player); + boolean sprinting = player.getPlayer().isSprinting(); moving.bunnyhopdelay--; @@ -90,10 +86,7 @@ public class FlyingCheck { // Increment violation counter moving.runflyViolationLevel += result; - data.log.toLocation.set(to); - data.log.check = "flying/toofast"; - - boolean cancel = plugin.execute(player, ccmoving.flyingActions, (int) moving.runflyViolationLevel, moving.history, cc); + boolean cancel = executeActions(player, ccmoving.flyingActions.getActions(moving.runflyViolationLevel)); // Was one of the actions a cancel? Then really do it if(cancel) { @@ -111,4 +104,21 @@ public class FlyingCheck { return newToLocation; } + + @Override + public boolean isEnabled(CCMoving moving) { + // TODO Auto-generated method stub + return moving.allowFlying && moving.runflyCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().moving.runflyViolationLevel); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/MorePacketsCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/MorePacketsCheck.java index e934b366..696c3fde 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/MorePacketsCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/MorePacketsCheck.java @@ -1,10 +1,13 @@ package cc.co.evenprime.bukkit.nocheat.checks.moving; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; import cc.co.evenprime.bukkit.nocheat.data.MovingData; import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; @@ -18,60 +21,16 @@ import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; * compares it to the "legal" number of packets for that timeframe (22). * */ -public class MorePacketsCheck { +public class MorePacketsCheck extends MovingCheck { private final static int packetsPerTimeframe = 22; private final static int bufferLimit = 30; - private final NoCheat plugin; public MorePacketsCheck(NoCheat plugin) { - - this.plugin = plugin; + super(plugin, "moving.morepackets", Permissions.MOVE_MOREPACKETS); } /** - * Ok, lets write down the internal logic, to not forget what I wanted to - * do when I started it: - * - * A second on the server has 20 ticks - * A second on the client has 20 ticks - * A unmodified client with no lag will send 1 packet per tick = 20 packets - * Ideally checking for 20 packets/second on the server would work - * - * But a client may send 10 packets in second 1, and 30 packets in second 2 - * due to lag. This should still be allowed, therefore we give a "buffer". - * If a player doesn't use all of his 20 move packets in one second, he may - * carry over unused packets to the next (the buffer is limited in size for - * obvious reasons). - * - * But the server may not be able to process all packets in time, e.g. - * because it is busy saving the world. - * - * Well that sounded strange... - * Admin: "Hey server, what is taking you so long?" - * Server: "I'm saving the world!" - * Admin: "o_O" - * - * Contrary to client lag, serverside lag could be measured. So let's do - * that. A task will be executed every 20 server ticks, storing the time it - * took the server to process those ticks. If it's much more than 1 second, - * the server was busy, and packets may have piled up during that time. So a - * good idea would be to ignore the following second completely, as it will - * be used to process the stacked-up packets, getting the server back in - * sync with the timeline. - * - * Server identified as being busy -> ignore the second that follows. If - * that second the server is still busy -> ignore the second after that too. - * - * What's with the second during which the server is busy? Can there be more - * packets during that time? Sure. But should we care? No, this initial lag - * can be mitigated by using the time it took to do the 20 ticks and factor - * it with the limit for packets. Problem solved. The only real problem are - * packets that stack up in one second to get processed in the next, which - * is what the "ignoring" is for. - * - * So the general course of action would be: - * * 1. Collect packets processed within 20 server ticks = packetCounter * 2. Measure time taken for those 20 server ticks = elapsedTime * 3. elapsedTime >> 1 second -> ignore next check @@ -82,65 +41,79 @@ public class MorePacketsCheck { * 8. reset packetCounter, wait for next 20 ticks to pass by. * */ - public PreciseLocation check(final Player player, final BaseData data, final ConfigurationCache cc) { + public PreciseLocation check(NoCheatPlayer player, MovingData data, CCMoving cc) { PreciseLocation newToLocation = null; - final MovingData moving = data.moving; - - moving.morePacketsCounter++; - if(!moving.morePacketsSetbackPoint.isSet()) { - moving.morePacketsSetbackPoint.set(moving.from); + data.morePacketsCounter++; + if(!data.morePacketsSetbackPoint.isSet()) { + data.morePacketsSetbackPoint.set(data.from); } int ingameSeconds = plugin.getIngameSeconds(); // Is at least a second gone by and has the server at least processed 20 // ticks since last time - if(ingameSeconds != moving.lastElapsedIngameSeconds) { + if(ingameSeconds != data.lastElapsedIngameSeconds) { int limit = (int) ((packetsPerTimeframe * plugin.getIngameSecondDuration()) / 1000L); - int difference = limit - moving.morePacketsCounter; + int difference = limit - data.morePacketsCounter; - moving.morePacketsBuffer += difference; - if(moving.morePacketsBuffer > bufferLimit) - moving.morePacketsBuffer = bufferLimit; + data.morePacketsBuffer += difference; + if(data.morePacketsBuffer > bufferLimit) + data.morePacketsBuffer = bufferLimit; // Are we over the 22 event limit for that time frame now? (limit // increases with time) - int packetsAboveLimit = (int) -moving.morePacketsBuffer; + int packetsAboveLimit = (int) -data.morePacketsBuffer; - if(moving.morePacketsBuffer < 0) - moving.morePacketsBuffer = 0; + if(data.morePacketsBuffer < 0) + data.morePacketsBuffer = 0; // Should we react? Only if the check doesn't get skipped and we // went over the limit if(!plugin.skipCheck() && packetsAboveLimit > 0) { - moving.morePacketsViolationLevel += packetsAboveLimit; + data.morePacketsViolationLevel += packetsAboveLimit; + + data.packets = packetsAboveLimit; - // Packets above limit - data.log.packets = moving.morePacketsCounter - limit; - data.log.check = "moving/morepackets"; - - final boolean cancel = plugin.execute(player, cc.moving.morePacketsActions, (int) moving.morePacketsViolationLevel, moving.history, cc); + final boolean cancel = executeActions(player, cc.morePacketsActions.getActions(data.morePacketsViolationLevel)); if(cancel) - newToLocation = moving.morePacketsSetbackPoint; + newToLocation = data.morePacketsSetbackPoint; } // No new setbackLocation was chosen if(newToLocation == null) { - moving.morePacketsSetbackPoint.set(player.getLocation()); + data.morePacketsSetbackPoint.set(data.from); } - if(moving.morePacketsViolationLevel > 0) + if(data.morePacketsViolationLevel > 0) // Shrink the "over limit" value by 20 % every second - moving.morePacketsViolationLevel *= 0.8; + data.morePacketsViolationLevel *= 0.8; - moving.morePacketsCounter = 0; // Count from zero again - moving.lastElapsedIngameSeconds = ingameSeconds; + data.morePacketsCounter = 0; // Count from zero again + data.lastElapsedIngameSeconds = ingameSeconds; } return newToLocation; } + + @Override + public boolean isEnabled(CCMoving moving) { + return moving.morePacketsCheck; + } + + @Override + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().moving.morePacketsViolationLevel); + case PACKETS: + return String.valueOf(player.getData().moving.packets); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/NoFallCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/NoFallCheck.java index f28200c1..07a3431f 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/NoFallCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/NoFallCheck.java @@ -1,70 +1,66 @@ package cc.co.evenprime.bukkit.nocheat.checks.moving; -import org.bukkit.entity.Player; +import java.util.Locale; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; import cc.co.evenprime.bukkit.nocheat.data.MovingData; +import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; /** * A check to see if people cheat by tricking the server to not deal them * fall damage. * */ -public class NoFallCheck { - - private final NoCheat plugin; +public class NoFallCheck extends MovingCheck { public NoFallCheck(NoCheat plugin) { - this.plugin = plugin; + super(plugin, "moving.nofall", Permissions.MOVE_NOFALL); } /** * Calculate if and how much the player "failed" this check. * */ - public void check(final Player player, final BaseData data, final boolean fromOnOrInGround, final boolean toOnOrInGround, final ConfigurationCache cc) { - - final MovingData moving = data.moving; + public PreciseLocation check(NoCheatPlayer player, MovingData data, CCMoving cc) { // This check is pretty much always a step behind for technical reasons. - if(fromOnOrInGround) { + if(data.fromOnOrInGround) { // Start with zero fall distance - moving.fallDistance = 0F; + data.fallDistance = 0F; } // If we increased fall height before for no good reason, reduce now by // the same amount - if(player.getFallDistance() > moving.lastAddedFallDistance) { - player.setFallDistance(player.getFallDistance() - moving.lastAddedFallDistance); + if(player.getPlayer().getFallDistance() > data.lastAddedFallDistance) { + player.getPlayer().setFallDistance(player.getPlayer().getFallDistance() - data.lastAddedFallDistance); } - moving.lastAddedFallDistance = 0; + data.lastAddedFallDistance = 0; // We want to know if the fallDistance recorded by the game is smaller // than the fall distance recorded by the plugin - final float difference = moving.fallDistance - player.getFallDistance(); + final float difference = data.fallDistance - player.getPlayer().getFallDistance(); - if(difference > 1.0F && toOnOrInGround && moving.fallDistance > 2.0F) { - moving.nofallViolationLevel += difference; + if(difference > 1.0F && data.toOnOrInGround && data.fallDistance > 2.0F) { + data.nofallViolationLevel += difference; - // Prepare some event-specific values for logging and custom actions - data.log.falldistance = moving.fallDistance; - data.log.check = "moving/nofall"; - - final boolean cancel = plugin.execute(player, cc.moving.nofallActions, (int) moving.nofallViolationLevel, moving.history, cc); + final boolean cancel = executeActions(player, cc.nofallActions.getActions(data.nofallViolationLevel)); // If "cancelled", the fall damage gets dealt in a way that's // visible to other plugins if(cancel) { // Increase the fall distance a bit :) - final float totalDistance = moving.fallDistance + difference * (cc.moving.nofallMultiplier - 1.0F); + final float totalDistance = data.fallDistance + difference * (cc.nofallMultiplier - 1.0F); - player.setFallDistance(totalDistance); + player.getPlayer().setFallDistance(totalDistance); } - data.moving.fallDistance = 0F; + data.fallDistance = 0F; } // Increase the fall distance that is recorded by the plugin, AND set @@ -77,24 +73,45 @@ public class NoFallCheck { // anyway, as to avoid to much deviation // from the original Minecraft feeling. - final double oldY = moving.from.y; - final double newY = moving.to.y; + final double oldY = data.from.y; + final double newY = data.to.y; if(oldY > newY) { final float dist = (float) (oldY - newY); - moving.fallDistance += dist; + data.fallDistance += dist; if(dist > 1.0F) { - moving.lastAddedFallDistance = dist; - player.setFallDistance(player.getFallDistance() + dist); + data.lastAddedFallDistance = dist; + player.getPlayer().setFallDistance(player.getPlayer().getFallDistance() + dist); } else { - moving.lastAddedFallDistance = 0.0F; + data.lastAddedFallDistance = 0.0F; } } else { - moving.lastAddedFallDistance = 0.0F; + data.lastAddedFallDistance = 0.0F; } // Reduce falldamage violation level - moving.nofallViolationLevel *= 0.99D; + data.nofallViolationLevel *= 0.99D; + + return null; + } + + @Override + public boolean isEnabled(CCMoving moving) { + // TODO Auto-generated method stub + return moving.nofallCheck; + } + + @Override + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().moving.nofallViolationLevel); + case FALLDISTANCE: + return String.format(Locale.US, "%.2f", player.getData().moving.fallDistance); + default: + return super.getParameter(wildcard, player); + } } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunFlyCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunFlyCheck.java deleted file mode 100644 index 7d412e1d..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunFlyCheck.java +++ /dev/null @@ -1,130 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.moving; - -import org.bukkit.GameMode; -import org.bukkit.block.Block; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; -import cc.co.evenprime.bukkit.nocheat.data.MovingData; -import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; -import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; - -/** - * The main Check class for Move event checking. It will decide which checks - * need to be executed and in which order. It will also precalculate some values - * that are needed by multiple checks. - * - */ -public class RunFlyCheck { - - private final FlyingCheck flyingCheck; - private final RunningCheck runningCheck; - private final NoFallCheck noFallCheck; - private final MorePacketsCheck morePacketsCheck; - - private final NoCheat plugin; - - public RunFlyCheck(NoCheat plugin) { - this.plugin = plugin; - - this.flyingCheck = new FlyingCheck(plugin); - this.noFallCheck = new NoFallCheck(plugin); - this.runningCheck = new RunningCheck(plugin, noFallCheck); - this.morePacketsCheck = new MorePacketsCheck(plugin); - } - - /** - * Return the a new destination location or null - * - * @param event - * @return - */ - public PreciseLocation check(final Player player, final BaseData data, final ConfigurationCache cc) { - - // Players in vehicles are of no interest - if(player.isInsideVehicle()) - return null; - - /** - * If not null, this will be used as the new target location - */ - PreciseLocation newTo = null; - - final MovingData moving = data.moving; - - /******** DO GENERAL DATA MODIFICATIONS ONCE FOR EACH EVENT *****/ - if(moving.horizVelocityCounter > 0) { - moving.horizVelocityCounter--; - } else { - moving.horizFreedom *= 0.90; - } - - if(moving.vertVelocityCounter > 0) { - moving.vertVelocityCounter--; - moving.vertFreedom += moving.vertVelocity; - moving.vertVelocity *= 0.90; - } else { - moving.vertFreedom = 0; - } - - final CCMoving ccmoving = cc.moving; - - /************* DECIDE WHICH CHECKS NEED TO BE RUN *************/ - final boolean runflyCheck = ccmoving.runflyCheck && !player.hasPermission(Permissions.MOVE_RUNFLY); - final boolean flyAllowed = ccmoving.allowFlying || player.hasPermission(Permissions.MOVE_FLY) || (player.getGameMode() == GameMode.CREATIVE && ccmoving.identifyCreativeMode); - final boolean morepacketsCheck = ccmoving.morePacketsCheck && !player.hasPermission(Permissions.MOVE_MOREPACKETS); - - /********************* EXECUTE THE FLY/JUMP/RUNNING CHECK ********************/ - // If the player is not allowed to fly and not allowed to run - if(runflyCheck) { - if(flyAllowed) { - newTo = flyingCheck.check(player, data, cc); - } else { - newTo = runningCheck.check(player, data, cc); - } - } - - /********* EXECUTE THE MOREPACKETS CHECK ********************/ - - if(newTo == null && morepacketsCheck) { - newTo = morePacketsCheck.check(player, data, cc); - } - - return newTo; - } - - /** - * This is a workaround for people placing blocks below them causing false - * positives - * with the move check(s). - */ - public void blockPlaced(Player player, Block blockPlaced) { - - BaseData data = plugin.getData(player.getName()); - - if(blockPlaced == null || !data.moving.runflySetBackPoint.isSet()) { - return; - } - - SimpleLocation lblock = new SimpleLocation(); - lblock.set(blockPlaced); - SimpleLocation lplayer = new SimpleLocation(); - lplayer.setLocation(player.getLocation()); - - if(Math.abs(lplayer.x - lblock.x) <= 1 && Math.abs(lplayer.z - lblock.z) <= 1 && lplayer.y - lblock.y >= 0 && lplayer.y - lblock.y <= 2) { - - int type = CheckUtil.getType(blockPlaced.getTypeId()); - if(CheckUtil.isSolid(type) || CheckUtil.isLiquid(type)) { - if(lblock.y + 1 >= data.moving.runflySetBackPoint.y) { - data.moving.runflySetBackPoint.y = (lblock.y + 1); - data.moving.jumpPhase = 0; - } - } - } - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunflyCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunflyCheck.java new file mode 100644 index 00000000..812bcb6e --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunflyCheck.java @@ -0,0 +1,48 @@ +package cc.co.evenprime.bukkit.nocheat.checks.moving; + +import org.bukkit.GameMode; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; +import cc.co.evenprime.bukkit.nocheat.data.MovingData; +import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; + +public class RunflyCheck extends MovingCheck { + + private final FlyingCheck flyingCheck; + private final RunningCheck runningCheck; + + public RunflyCheck(NoCheat plugin) { + super(plugin, "moving.runfly", Permissions.MOVE_RUNFLY); + + flyingCheck = new FlyingCheck(plugin); + runningCheck = new RunningCheck(plugin); + } + + @Override + public PreciseLocation check(NoCheatPlayer player, MovingData data, CCMoving cc) { + + final boolean runflyCheck = cc.runflyCheck && !player.hasPermission(Permissions.MOVE_RUNFLY); + final boolean flyAllowed = cc.allowFlying || player.hasPermission(Permissions.MOVE_FLY) || (player.getPlayer().getGameMode() == GameMode.CREATIVE && cc.identifyCreativeMode); + + /********************* EXECUTE THE FLY/JUMP/RUNNING CHECK ********************/ + // If the player is not allowed to fly and not allowed to run + if(runflyCheck) { + if(flyAllowed) { + return flyingCheck.check(player, data, cc); + } else { + return runningCheck.check(player, data, cc); + } + } + + return null; + } + + @Override + public boolean isEnabled(CCMoving moving) { + return runningCheck.isEnabled(moving) || flyingCheck.isEnabled(moving); + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunningCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunningCheck.java index 5761522c..873494a5 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunningCheck.java +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/moving/RunningCheck.java @@ -1,17 +1,19 @@ package cc.co.evenprime.bukkit.nocheat.checks.moving; +import java.util.Locale; + import net.minecraft.server.EntityPlayer; import net.minecraft.server.MobEffectList; import org.bukkit.craftbukkit.entity.CraftPlayer; -import org.bukkit.entity.Player; import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; import cc.co.evenprime.bukkit.nocheat.data.MovingData; import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; @@ -22,7 +24,7 @@ import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; * normal ground, while sprinting, sneaking or swimming. * */ -public class RunningCheck { +public class RunningCheck extends MovingCheck { private final static double maxBonus = 1D; @@ -30,26 +32,24 @@ public class RunningCheck { // lose altitude (or eventually land somewhere) private final static int jumpingLimit = 6; - private final NoCheat plugin; - private final NoFallCheck noFallCheck; - public RunningCheck(NoCheat plugin, NoFallCheck noFallCheck) { - this.plugin = plugin; - this.noFallCheck = noFallCheck; + public RunningCheck(NoCheat plugin) { + + super(plugin, "moving.running", Permissions.MOVE_RUNFLY); + + this.noFallCheck = new NoFallCheck(plugin); } - public PreciseLocation check(final Player player, final BaseData data, final ConfigurationCache cc) { + public PreciseLocation check(NoCheatPlayer player, MovingData data, CCMoving cc) { // Some shortcuts: - final MovingData moving = data.moving; - final PreciseLocation to = moving.to; - final PreciseLocation from = moving.from; - final PreciseLocation setBack = moving.runflySetBackPoint; - final CCMoving ccmoving = cc.moving; + final PreciseLocation setBack = data.runflySetBackPoint; + final PreciseLocation to = data.to; + final PreciseLocation from = data.from; // Calculate some distances - final double xDistance = to.x - from.x; + final double xDistance = data.to.x - from.x; final double zDistance = to.z - from.z; final double horizontalDistance = Math.sqrt((xDistance * xDistance + zDistance * zDistance)); @@ -58,8 +58,8 @@ public class RunningCheck { } // To know if a player "is on ground" is useful - final int fromType = CheckUtil.isLocationOnGround(player.getWorld(), from); - final int toType = CheckUtil.isLocationOnGround(player.getWorld(), to); + final int fromType = CheckUtil.isLocationOnGround(player.getPlayer().getWorld(), from); + final int toType = CheckUtil.isLocationOnGround(player.getPlayer().getWorld(), to); final boolean fromOnGround = CheckUtil.isOnGround(fromType); final boolean fromInGround = CheckUtil.isInGround(fromType); @@ -68,32 +68,22 @@ public class RunningCheck { PreciseLocation newToLocation = null; - final double resultHoriz = Math.max(0.0D, checkHorizontal(player, data, CheckUtil.isLiquid(fromType) && CheckUtil.isLiquid(toType), horizontalDistance, ccmoving)); - final double resultVert = Math.max(0.0D, checkVertical(moving, fromOnGround, toOnGround, ccmoving)); + final double resultHoriz = Math.max(0.0D, checkHorizontal(player, data, CheckUtil.isLiquid(fromType) && CheckUtil.isLiquid(toType), horizontalDistance, cc)); + final double resultVert = Math.max(0.0D, checkVertical(data, fromOnGround, toOnGround, cc)); final double result = (resultHoriz + resultVert) * 100; - moving.jumpPhase++; + data.jumpPhase++; // Slowly reduce the level with each event - moving.runflyViolationLevel *= 0.97; + data.runflyViolationLevel *= 0.97; if(result > 0) { // Increment violation counter - moving.runflyViolationLevel += result; + data.runflyViolationLevel += result; - // Prepare some event-specific values for logging and custom actions - data.log.toLocation.set(to); - if(resultHoriz > 0 && resultVert > 0) - data.log.check = "runfly/both"; - else if(resultHoriz > 0) { - // We already set the correct value for this - // data.log.check = "runfly/something" - } else if(resultVert > 0) - data.log.check = "runfly/vertical"; - - boolean cancel = plugin.execute(player, cc.moving.actions, (int) moving.runflyViolationLevel, moving.history, cc); + boolean cancel = executeActions(player, cc.actions.getActions(data.runflyViolationLevel)); // Was one of the actions a cancel? Then do it if(cancel) { @@ -102,28 +92,30 @@ public class RunningCheck { // In case it only gets logged, not stopped by NoCheat // Update the setback location at least a bit setBack.set(to); - moving.jumpPhase = 0; + data.jumpPhase = 0; } } else { if((toInGround && from.y >= to.y) || CheckUtil.isLiquid(toType)) { setBack.set(to); setBack.y = Math.ceil(setBack.y); - moving.jumpPhase = 0; + data.jumpPhase = 0; } else if(toOnGround && (from.y >= to.y || setBack.y <= Math.floor(to.y))) { setBack.set(to); setBack.y = Math.floor(setBack.y); - moving.jumpPhase = 0; + data.jumpPhase = 0; } else if(fromOnGround || fromInGround || toOnGround || toInGround) { - moving.jumpPhase = 0; + data.jumpPhase = 0; } } /********* EXECUTE THE NOFALL CHECK ********************/ - final boolean checkNoFall = cc.moving.nofallCheck && !player.hasPermission(Permissions.MOVE_NOFALL); + final boolean checkNoFall = cc.nofallCheck && !player.hasPermission(Permissions.MOVE_NOFALL); if(checkNoFall && newToLocation == null) { - noFallCheck.check(player, data, fromOnGround || fromInGround, toOnGround || toInGround, cc); + data.fromOnOrInGround = fromOnGround || fromInGround; + data.toOnOrInGround = toOnGround || toInGround; + noFallCheck.check(player, data, cc); } return newToLocation; @@ -133,31 +125,25 @@ public class RunningCheck { * Calculate how much the player failed this check * */ - private double checkHorizontal(final Player player, final BaseData data, final boolean isSwimming, final double totalDistance, final CCMoving ccmoving) { + private double checkHorizontal(final NoCheatPlayer player, final MovingData moving, final boolean isSwimming, final double totalDistance, final CCMoving ccmoving) { // How much further did the player move than expected?? double distanceAboveLimit = 0.0D; - final boolean sprinting = CheckUtil.isSprinting(player); + final boolean sprinting = player.getPlayer().isSprinting(); double limit = 0.0D; final EntityPlayer p = ((CraftPlayer) player).getHandle(); - final MovingData moving = data.moving; - - if(ccmoving.sneakingCheck && player.isSneaking() && !player.hasPermission(Permissions.MOVE_SNEAK)) { + if(ccmoving.sneakingCheck && player.getPlayer().isSneaking() && !player.hasPermission(Permissions.MOVE_SNEAK)) { limit = ccmoving.sneakingSpeedLimit; - data.log.check = "runfly/sneak"; } else if(ccmoving.swimmingCheck && isSwimming && !player.hasPermission(Permissions.MOVE_SWIM)) { limit = ccmoving.swimmingSpeedLimit; - data.log.check = "runfly/swim"; } else if(!sprinting) { limit = ccmoving.walkingSpeedLimit; - data.log.check = "runfly/walk"; } else { limit = ccmoving.sprintingSpeedLimit; - data.log.check = "runfly/sprint"; } if(p.hasEffect(MobEffectList.FASTER_MOVEMENT)) { @@ -224,4 +210,20 @@ public class RunningCheck { return distanceAboveLimit; } + + @Override + public boolean isEnabled(CCMoving moving) { + return moving.runflyCheck && !moving.allowFlying; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().moving.runflyViolationLevel); + default: + return super.getParameter(wildcard, player); + } + } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/timed/GodmodeCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/timed/GodmodeCheck.java new file mode 100644 index 00000000..8caa5728 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/checks/timed/GodmodeCheck.java @@ -0,0 +1,108 @@ +package cc.co.evenprime.bukkit.nocheat.checks.timed; + +import java.util.Locale; + +import net.minecraft.server.EntityPlayer; + +import org.bukkit.craftbukkit.entity.CraftPlayer; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.actions.types.ActionWithParameters.WildCard; +import cc.co.evenprime.bukkit.nocheat.checks.TimedCheck; +import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCTimed; +import cc.co.evenprime.bukkit.nocheat.data.TimedData; + +public class GodmodeCheck extends TimedCheck { + + public GodmodeCheck(NoCheat plugin) { + super(plugin, "timed.godmode", Permissions.TIMED_GODMODE); + } + + @Override + public boolean check(NoCheatPlayer player, TimedData data, CCTimed cc) { + // server lag(ged), skip this, or player dead, therefore it's reasonable + // for him to not move :) + if(plugin.skipCheck() || player.getPlayer().isDead()) + return false; + + EntityPlayer p = ((CraftPlayer) player).getHandle(); + // Haven't been checking before + if(data.ticksLived == 0) { + // setup data for next time + data.ticksLived = p.ticksLived; + + // And give up already + return false; + } + + boolean cancel = false; + + // Compare ingame record of players ticks to our last observed value + int difference = p.ticksLived - data.ticksLived; + + // difference should be >= tickTime for perfect synchronization + if(difference > cc.tickTime) { + // player was faster than expected, give him credit for the + // difference + data.ticksBehind -= (difference - cc.tickTime); + // Reduce violation level over time + data.godmodeVL *= 0.9D; + + } else if(difference >= cc.tickTime / 2) { + // close enough, let it pass + data.ticksBehind -= cc.tickTime / 2; + // Reduce violation level over time + data.godmodeVL *= 0.9D; + } else { + // That's a bit suspicious, why is the player more than half the + // ticktime behind? Keep that in mind + data.ticksBehind += cc.tickTime - difference; + + // Is he way too far behind, then correct that + if(data.ticksBehind > cc.godmodeTicksLimit) { + + data.godmodeVL += cc.tickTime - difference; + + cancel = executeActions(player, cc.godmodeActions.getActions(data.godmodeVL)); + + // Reduce the time the player is behind accordingly + data.ticksBehind -= cc.tickTime; + } + } + + if(data.ticksBehind < 0) { + data.ticksBehind = 0; + } + + if(cancel) { + // Catch up for at least some of the ticks + for(int i = 0; i < cc.tickTime; i++) { + p.b(true); // Catch up with the server, one tick at a time + } + } + + // setup data for next time + data.ticksLived = p.ticksLived; + + return cancel; + + } + + @Override + public boolean isEnabled(CCTimed cc) { + return cc.godmodeCheck; + } + + public String getParameter(WildCard wildcard, NoCheatPlayer player) { + + switch (wildcard) { + + case VIOLATIONS: + return String.format(Locale.US, "%d", player.getData().timed.godmodeVL); + default: + return super.getParameter(wildcard, player); + } + } +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/checks/timed/TimedCheck.java b/src/cc/co/evenprime/bukkit/nocheat/checks/timed/TimedCheck.java deleted file mode 100644 index c2c3e328..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/checks/timed/TimedCheck.java +++ /dev/null @@ -1,97 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.checks.timed; - -import net.minecraft.server.EntityPlayer; - -import org.bukkit.craftbukkit.entity.CraftPlayer; -import org.bukkit.entity.Player; - -import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.config.Permissions; -import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; - -public class TimedCheck { - - private final NoCheat plugin; - - public TimedCheck(NoCheat plugin) { - - this.plugin = plugin; - } - - public void check(Player player, int tickTime, ConfigurationCache cc) { - - // server lag(ged), skip this, or player dead, therefore it's reasonable for him to not move :) - if(plugin.skipCheck() || player.isDead()) - return; - - if(cc.timed.godmodeCheck && !player.hasPermission(Permissions.TIMED_GODMODE)) { - - - BaseData data = plugin.getData(player.getName()); - - EntityPlayer p = ((CraftPlayer) player).getHandle(); - // Haven't been checking before - if(data.timed.ticksLived == 0) { - // setup data for next time - data.timed.ticksLived = p.ticksLived; - - // And give up already - return; - } - - boolean cancel = false; - - // Compare ingame record of players ticks to our last observed value - int difference = p.ticksLived - data.timed.ticksLived; - - // difference should be >= tickTime for perfect synchronization - if(difference > tickTime) { - // player was faster than expected, give him credit for the - // difference - data.timed.ticksBehind -= (difference - tickTime); - // Reduce violation level over time - data.timed.godmodeVL *= 0.9D; - - } else if(difference >= tickTime / 2) { - // close enough, let it pass - data.timed.ticksBehind -= tickTime/2; - // Reduce violation level over time - data.timed.godmodeVL *= 0.9D; - } else { - // That's a bit suspicious, why is the player more than half the - // ticktime behind? Keep that in mind - data.timed.ticksBehind += tickTime - difference; - - // Is he way too far behind, then correct that - if(data.timed.ticksBehind > cc.timed.godmodeTicksLimit) { - - data.timed.godmodeVL += tickTime - difference; - - // Enough is enough - data.log.check = "timed.godmode"; - - cancel = plugin.execute(player, cc.timed.godmodeActions, (int) data.timed.godmodeVL, data.timed.history, cc); - - // Reduce the time the player is behind accordingly - data.timed.ticksBehind -= tickTime; - } - } - - if(data.timed.ticksBehind < 0) { - data.timed.ticksBehind = 0; - } - - if(cancel) { - // Catch up for at least some of the ticks - for(int i = 0; i < tickTime; i++) { - p.b(true); // Catch up with the server, one tick at a time - } - } - - // setup data for next time - data.timed.ticksLived = p.ticksLived; - - } - } -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/Configuration.java b/src/cc/co/evenprime/bukkit/nocheat/config/Configuration.java index 77b5f785..aeff669e 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/Configuration.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/Configuration.java @@ -84,10 +84,6 @@ public abstract class Configuration { public final static OptionNode BLOCKPLACE_REACH_LIMIT = new OptionNode("limit", BLOCKPLACE_REACH, DataType.INTEGER); public final static OptionNode BLOCKPLACE_REACH_ACTIONS = new OptionNode("actions", BLOCKPLACE_REACH, DataType.ACTIONLIST); - private final static OptionNode BLOCKPLACE_ONLIQUID = new OptionNode("onliquid", BLOCKPLACE, DataType.PARENT); - public final static OptionNode BLOCKPLACE_ONLIQUID_CHECK = new OptionNode("check", BLOCKPLACE_ONLIQUID, DataType.BOOLEAN); - public final static OptionNode BLOCKPLACE_ONLIQUID_ACTIONS = new OptionNode("actions", BLOCKPLACE_ONLIQUID, DataType.ACTIONLIST); - private final static OptionNode BLOCKPLACE_DIRECTION = new OptionNode("direction", BLOCKPLACE, DataType.PARENT); public static final OptionNode BLOCKPLACE_DIRECTION_CHECK = new OptionNode("check", BLOCKPLACE_DIRECTION, DataType.BOOLEAN); ; public static final OptionNode BLOCKPLACE_DIRECTION_PENALTYTIME = new OptionNode("penaltytime", BLOCKPLACE_DIRECTION, DataType.INTEGER); diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/DefaultConfiguration.java b/src/cc/co/evenprime/bukkit/nocheat/config/DefaultConfiguration.java index 7c3bd385..9080a981 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/DefaultConfiguration.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/DefaultConfiguration.java @@ -123,13 +123,6 @@ public class DefaultConfiguration extends Configuration { reachActionList.setActions(5, action.getActions("reachLog blockplaceCancel".split(" "))); setValue(BLOCKPLACE_REACH_ACTIONS, reachActionList); - setValue(BLOCKPLACE_ONLIQUID_CHECK, true); - - ActionList onliquidActionList = new ActionList(); - onliquidActionList.setActions(0, action.getActions("blockplaceCancel".split(" "))); - onliquidActionList.setActions(3, action.getActions("onliquidLog blockplaceCancel".split(" "))); - setValue(BLOCKPLACE_ONLIQUID_ACTIONS, onliquidActionList); - setValue(BLOCKPLACE_DIRECTION_CHECK, true); setValue(BLOCKPLACE_DIRECTION_PRECISION, 75); setValue(BLOCKPLACE_DIRECTION_PENALTYTIME, 100); diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/Explainations.java b/src/cc/co/evenprime/bukkit/nocheat/config/Explainations.java index d1fad824..fcbcc9a2 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/Explainations.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/Explainations.java @@ -72,9 +72,6 @@ public class Explainations { set(Configuration.BLOCKPLACE_REACH_LIMIT, "Set the distance limit for placing blocks.\nUnit is 1/100 of a block, default is 485"); set(Configuration.BLOCKPLACE_REACH_ACTIONS, "What should be done if a player is placing blocks that are too far away.\nUnit is number of place(attempt)s beyond the limit."); - set(Configuration.BLOCKPLACE_ONLIQUID_CHECK, "If true, check if a player is trying to place non-liquid blocks against liquid blocks\nIn a normal Minecraft game, it is impossible to place a block without it touching something that is considered solid (neither air nor a liquid).\nBut if people use a modified client, to can do that. This check tries to identify that trick."); - set(Configuration.BLOCKPLACE_ONLIQUID_ACTIONS, "What should be done if a player is is trying to place non-liquid blocks against liquid blocks.\nUnit is number of place(attempt)s."); - set(Configuration.BLOCKPLACE_DIRECTION_CHECK, "If true, check if a player is looking at the block that he's placing."); set(Configuration.BLOCKPLACE_DIRECTION_PRECISION, "Define how precise a player has to be when placing blocks. Lower values mean more precision, higher values less precision. Default 75."); set(Configuration.BLOCKPLACE_DIRECTION_PENALTYTIME, "Define how long after a failed attempt to place blocks a player will be disallowed to place another block. \nUnit is milliseconds, default is 100."); diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/Permissions.java b/src/cc/co/evenprime/bukkit/nocheat/config/Permissions.java index 7cc08804..cb8baa98 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/Permissions.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/Permissions.java @@ -10,13 +10,13 @@ public class Permissions { private final static String ADMIN = NOCHEAT + ".admin"; private final static String CHECKS = NOCHEAT + ".checks"; - public final static String MOVE = CHECKS + ".moving"; - public final static String MOVE_RUNFLY = MOVE + ".runfly"; - public final static String MOVE_SNEAK = MOVE + ".sneaking"; - public final static String MOVE_SWIM = MOVE + ".swimming"; - public final static String MOVE_FLY = MOVE + ".flying"; - public final static String MOVE_NOFALL = MOVE + ".nofall"; - public final static String MOVE_MOREPACKETS = MOVE + ".morepackets"; + public final static String MOVING = CHECKS + ".moving"; + public final static String MOVE_RUNFLY = MOVING + ".runfly"; + public final static String MOVE_SNEAK = MOVING + ".sneaking"; + public final static String MOVE_SWIM = MOVING + ".swimming"; + public final static String MOVE_FLY = MOVING + ".flying"; + public final static String MOVE_NOFALL = MOVING + ".nofall"; + public final static String MOVE_MOREPACKETS = MOVING + ".morepackets"; public final static String BLOCKBREAK = CHECKS + ".blockbreak"; public final static String BLOCKBREAK_REACH = BLOCKBREAK + ".reach"; diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/cache/CCTimed.java b/src/cc/co/evenprime/bukkit/nocheat/config/cache/CCTimed.java index 460dca07..21ace224 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/cache/CCTimed.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/cache/CCTimed.java @@ -9,6 +9,7 @@ public class CCTimed { public final boolean godmodeCheck; public final double godmodeTicksLimit; public final ActionList godmodeActions; + public final int tickTime = 10; public CCTimed(Configuration data) { diff --git a/src/cc/co/evenprime/bukkit/nocheat/config/util/ActionList.java b/src/cc/co/evenprime/bukkit/nocheat/config/util/ActionList.java index 7b10677d..fbd1150c 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/config/util/ActionList.java +++ b/src/cc/co/evenprime/bukkit/nocheat/config/util/ActionList.java @@ -47,12 +47,12 @@ public class ActionList { * @param violationLevel * @return */ - public Action[] getActions(int vl) { + public Action[] getActions(double violationLevel) { Integer result = null; for(Integer treshold : tresholds) { - if(treshold <= vl) { + if(treshold <= violationLevel) { result = treshold; } } diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/BaseData.java b/src/cc/co/evenprime/bukkit/nocheat/data/BaseData.java index ed440ef2..3125f5bd 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/BaseData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/BaseData.java @@ -5,7 +5,6 @@ public class BaseData extends Data { public final BlockBreakData blockbreak; public final BlockPlaceData blockplace; public final ChatData chat; - public final LogData log; public final MovingData moving; public final FightData fight; public final TimedData timed; @@ -20,13 +19,14 @@ public class BaseData extends Data { this.blockbreak = new BlockBreakData(); this.blockplace = new BlockPlaceData(); this.chat = new ChatData(); - this.log = new LogData(); this.moving = new MovingData(); this.fight = new FightData(); this.timed = new TimedData(); data = new Data[] {this.blockbreak, this.blockplace, this.chat, - this.log, this.moving, this.fight, this.timed}; + this.moving, this.fight, this.timed}; + + this.lastUsedTime = System.currentTimeMillis(); } public void clearCriticalData() { diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/BlockBreakData.java b/src/cc/co/evenprime/bukkit/nocheat/data/BlockBreakData.java index de968c50..9e704bd2 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/BlockBreakData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/BlockBreakData.java @@ -6,13 +6,16 @@ package cc.co.evenprime.bukkit.nocheat.data; */ public class BlockBreakData extends Data { - public double reachViolationLevel = 0.0D; + public double reachVL = 0.0D; public double directionViolationLevel = 0.0D; public long directionLastViolationTime = 0; public final SimpleLocation instaBrokeBlockLocation = new SimpleLocation(); + // Verified + public final SimpleLocation brokenBlockLocation = new SimpleLocation(); + public final ExecutionHistory history = new ExecutionHistory(); public double noswingVL = 0.0D; - + public double reachDistance; } diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/BlockPlaceData.java b/src/cc/co/evenprime/bukkit/nocheat/data/BlockPlaceData.java index f127931b..ee732905 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/BlockPlaceData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/BlockPlaceData.java @@ -16,6 +16,7 @@ public class BlockPlaceData extends Data { public final SimpleLocation blockPlacedAgainst = new SimpleLocation(); public final SimpleLocation blockPlaced = new SimpleLocation(); public Material placedType; + public double reachdistance; public void clearCriticalData() { blockPlacedAgainst.reset(); diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/ChatData.java b/src/cc/co/evenprime/bukkit/nocheat/data/ChatData.java index 4d6f96aa..99ef1a75 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/ChatData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/ChatData.java @@ -8,5 +8,7 @@ public class ChatData extends Data { public int messageCount = 0; public int spamLasttime = 0; public final ExecutionHistory history = new ExecutionHistory(); + public String message = ""; + public int spamVL; } diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/DataManager.java b/src/cc/co/evenprime/bukkit/nocheat/data/DataManager.java deleted file mode 100644 index 72bf9097..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/data/DataManager.java +++ /dev/null @@ -1,90 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.data; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Map.Entry; - -/** - * Provide secure access to player-specific data objects for various checks or - * check groups. - */ -public class DataManager { - - // Store data between Events - private final Map map; - private final List removals; - - public DataManager() { - this.map = new HashMap(); - this.removals = new ArrayList(5); - } - - /** - * Get a data object of the specified class. If none is stored yet, create - * one. - */ - public BaseData getData(String playerName) { - - BaseData data = this.map.get(playerName); - - // intentionally not thread-safe, because bukkit events are handled - // in sequence anyway, so zero chance of two events of the same - // player being handled at the same time - // And if it still happens by accident, it's no real loss anyway, as - // losing data of one instance doesn't really hurt at all - if(data == null) { - data = new BaseData(); - data.log.playerName = playerName; - this.map.put(playerName, data); - } - - data.lastUsedTime = System.currentTimeMillis(); - - return data; - } - - /** - * Reset data that may cause problems after e.g. changing the config - * - */ - public void clearCriticalData() { - for(BaseData b : this.map.values()) { - b.clearCriticalData(); - } - } - - /** - * check if some data hasn't been used for a while and remove it - * - */ - public void cleanDataMap() { - synchronized(removals) { - long time = System.currentTimeMillis(); - try { - for(Entry p : this.map.entrySet()) { - if(p.getValue().shouldBeRemoved(time)) { - removals.add(p.getKey()); - } - } - - for(String p : removals) { - this.map.remove(p); - } - - removals.clear(); - } catch(Exception e) { - e.printStackTrace(); - } - } - } - - public void clearCriticalData(String playerName) { - BaseData data = this.map.get(playerName); - if(data != null) { - data.clearCriticalData(); - } - } - -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/FightData.java b/src/cc/co/evenprime/bukkit/nocheat/data/FightData.java index 04e0aa8f..c63bc155 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/FightData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/FightData.java @@ -1,11 +1,14 @@ package cc.co.evenprime.bukkit.nocheat.data; +import net.minecraft.server.Entity; + public class FightData extends Data { - public double violationLevel = 0; - public long directionLastViolationTime = 0; - public final ExecutionHistory history = new ExecutionHistory(); - public double selfhitviolationLevel = 0; - public double noswingVL = 0.0D; + public double directionVL = 0; + public long directionLastViolationTime = 0; + public final ExecutionHistory history = new ExecutionHistory(); + public double selfhitVL = 0; + public double noswingVL = 0.0D; + public Entity damagee; } diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/LogData.java b/src/cc/co/evenprime/bukkit/nocheat/data/LogData.java deleted file mode 100644 index 959907f6..00000000 --- a/src/cc/co/evenprime/bukkit/nocheat/data/LogData.java +++ /dev/null @@ -1,16 +0,0 @@ -package cc.co.evenprime.bukkit.nocheat.data; - -/** - * Everything that could be relevant for logging or consolecommand actions - */ -public class LogData extends Data { - - public String check; - public int violationLevel; - public final PreciseLocation toLocation = new PreciseLocation(); - public int packets; - public String text; - public double reachdistance; - public float falldistance; - public String playerName; -} diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/MovingData.java b/src/cc/co/evenprime/bukkit/nocheat/data/MovingData.java index ab3f40c8..a8f87d8e 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/data/MovingData.java +++ b/src/cc/co/evenprime/bukkit/nocheat/data/MovingData.java @@ -26,6 +26,8 @@ public class MovingData extends Data { public int morePacketsCounter; public int morePacketsBuffer = 50; + public int packets; + public final PreciseLocation morePacketsSetbackPoint = new PreciseLocation(); public double morePacketsViolationLevel; @@ -38,6 +40,9 @@ public class MovingData extends Data { public final PreciseLocation from = new PreciseLocation(); public final PreciseLocation to = new PreciseLocation(); + public boolean fromOnOrInGround; + public boolean toOnOrInGround; + @Override public void clearCriticalData() { teleportTo.reset(); diff --git a/src/cc/co/evenprime/bukkit/nocheat/data/PlayerManager.java b/src/cc/co/evenprime/bukkit/nocheat/data/PlayerManager.java new file mode 100644 index 00000000..aa61f203 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/data/PlayerManager.java @@ -0,0 +1,89 @@ +package cc.co.evenprime.bukkit.nocheat.data; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.player.NoCheatPlayerImpl; + +/** + * Provide secure access to player-specific data objects for various checks or + * check groups. + */ +public class PlayerManager { + + // Store data between Events + private final Map map; + private final NoCheat plugin; + private final List removals; + + public PlayerManager(NoCheat plugin) { + this.map = new HashMap(); + this.removals = new ArrayList(5); + this.plugin = plugin; + } + + /** + * Get a data object of the specified class. If none is stored yet, create + * one. + */ + public NoCheatPlayer getPlayer(String playerName) { + + NoCheatPlayer p = this.map.get(playerName); + + if(p == null) { + // TODO: Differentiate which player"type" should be created + p = new NoCheatPlayerImpl(playerName, plugin, new BaseData()); + this.map.put(playerName, p); + } + + return p; + } + + /** + * Reset data that may cause problems after e.g. changing the config + * + */ + public void clearCriticalData() { + for(NoCheatPlayer b : this.map.values()) { + b.getData().clearCriticalData(); + } + } + + /** + * check if some data hasn't been used for a while and remove it + * + */ + public void cleanDataMap() { + synchronized(removals) { + long time = System.currentTimeMillis(); + try { + for(Entry p : this.map.entrySet()) { + if(p.getValue().getData().shouldBeRemoved(time)) { + removals.add(p.getKey()); + } + } + + for(String p : removals) { + this.map.remove(p); + } + + removals.clear(); + } catch(Exception e) { + e.printStackTrace(); + } + } + } + + public void clearCriticalData(String playerName) { + NoCheatPlayer p = this.map.get(playerName); + if(p != null) { + p.getData().clearCriticalData(); + } + } + +} diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/BlockBreakEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/BlockBreakEventManager.java index 6dec4288..0156ff3d 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/BlockBreakEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/BlockBreakEventManager.java @@ -1,9 +1,9 @@ package cc.co.evenprime.bukkit.nocheat.events; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.Event.Priority; import org.bukkit.event.block.BlockBreakEvent; @@ -12,10 +12,15 @@ import org.bukkit.event.block.BlockListener; import org.bukkit.plugin.PluginManager; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.BlockBreakCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.BlockBreakCheck; +import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.DirectionCheck; +import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.NoswingCheck; +import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.ReachCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockBreak; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; -import cc.co.evenprime.bukkit.nocheat.data.BaseData; +import cc.co.evenprime.bukkit.nocheat.data.BlockBreakData; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; @@ -26,15 +31,21 @@ import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; */ public class BlockBreakEventManager extends BlockListener implements EventManager { - private final BlockBreakCheck blockBreakCheck; - private final NoCheat plugin; - private final Performance blockBreakPerformance; - private final Performance blockDamagePerformance; + private final List checks; + private final NoCheat plugin; + private final Performance blockBreakPerformance; + private final Performance blockDamagePerformance; public BlockBreakEventManager(NoCheat plugin) { this.plugin = plugin; - this.blockBreakCheck = new BlockBreakCheck(plugin); + + // Three checks exist for this event type + this.checks = new ArrayList(3); + this.checks.add(new DirectionCheck(plugin)); + this.checks.add(new NoswingCheck(plugin)); + this.checks.add(new ReachCheck(plugin)); + this.blockBreakPerformance = plugin.getPerformance(Type.BLOCKBREAK); this.blockDamagePerformance = plugin.getPerformance(Type.BLOCKDAMAGE); @@ -44,6 +55,45 @@ public class BlockBreakEventManager extends BlockListener implements EventManage pm.registerEvent(Event.Type.BLOCK_DAMAGE, this, Priority.Monitor, plugin); } + private void handleEvent(BlockBreakEvent event) { + + boolean cancelled = false; + + NoCheatPlayer player = plugin.getPlayer(event.getPlayer().getName()); + + ConfigurationCache c = player.getConfiguration(); + + if(!c.blockbreak.check || player.hasPermission(Permissions.BLOCKBREAK)) { + return; + } + + CCBlockBreak cc = player.getConfiguration().blockbreak; + BlockBreakData data = player.getData().blockbreak; + + data.brokenBlockLocation.set(event.getBlock()); + + for(BlockBreakCheck check : checks) { + // If it should be executed, do it + if(!cancelled && check.isEnabled(cc) && !player.hasPermission(check.getPermission())) { + check.check(player, data, cc); + } + } + + if(cancelled) { + event.setCancelled(cancelled); + } + + } + + private void handleEvent(BlockDamageEvent event) { + // Get the player-specific stored data that applies here + final BlockBreakData data = plugin.getPlayer(event.getPlayer().getName()).getData().blockbreak; + + // Remember this location. We ignore block breaks in the block-break + // direction check that are insta-breaks + data.instaBrokeBlockLocation.set(event.getBlock()); + } + @Override public void onBlockBreak(BlockBreakEvent event) { @@ -58,20 +108,7 @@ public class BlockBreakEventManager extends BlockListener implements EventManage if(performanceCheck) nanoTimeStart = System.nanoTime(); - final Player player = event.getPlayer(); - final ConfigurationCache cc = plugin.getConfig(player); - - // Find out if checks need to be done for that player - if(cc.blockbreak.check && !player.hasPermission(Permissions.BLOCKBREAK)) { - - boolean cancel = false; - - cancel = blockBreakCheck.check(player, event.getBlock(), cc); - - if(cancel) { - event.setCancelled(true); - } - } + handleEvent(event); // store performance time if(performanceCheck) @@ -93,12 +130,7 @@ public class BlockBreakEventManager extends BlockListener implements EventManage if(performanceCheck) nanoTimeStart = System.nanoTime(); - // Get the player-specific stored data that applies here - final BaseData data = plugin.getData(event.getPlayer().getName()); - - // Remember this location. We ignore block breaks in the block-break - // direction check that are insta-breaks - data.blockbreak.instaBrokeBlockLocation.set(event.getBlock()); + handleEvent(event); // store performance time if(performanceCheck) diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/BlockPlaceEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/BlockPlaceEventManager.java index f1c35254..c21d18bc 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/BlockPlaceEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/BlockPlaceEventManager.java @@ -1,9 +1,9 @@ package cc.co.evenprime.bukkit.nocheat.events; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.Event.Priority; import org.bukkit.event.block.BlockListener; @@ -11,10 +11,14 @@ import org.bukkit.event.block.BlockPlaceEvent; import org.bukkit.plugin.PluginManager; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.blockplace.BlockPlaceCheck; -import cc.co.evenprime.bukkit.nocheat.checks.moving.RunFlyCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.BlockPlaceCheck; +import cc.co.evenprime.bukkit.nocheat.checks.blockplace.DirectionCheck; +import cc.co.evenprime.bukkit.nocheat.checks.blockplace.ReachCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCBlockPlace; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.BlockPlaceData; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; @@ -25,45 +29,30 @@ import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; */ public class BlockPlaceEventManager extends BlockListener implements EventManager { - private final NoCheat plugin; - private final RunFlyCheck movingCheck; - private final BlockPlaceCheck blockPlaceCheck; + private final List checks; + private final NoCheat plugin; - private final Performance blockPlacePerformance; + private final Performance blockPlacePerformance; public BlockPlaceEventManager(NoCheat p) { this.plugin = p; - this.movingCheck = new RunFlyCheck(plugin); - this.blockPlaceCheck = new BlockPlaceCheck(plugin); + this.checks = new ArrayList(2); + this.checks.add(new DirectionCheck(plugin)); + this.checks.add(new ReachCheck(plugin)); this.blockPlacePerformance = p.getPerformance(Type.BLOCKPLACE); PluginManager pm = plugin.getServer().getPluginManager(); pm.registerEvent(Event.Type.BLOCK_PLACE, this, Priority.Lowest, plugin); - - // This is part of a workaround for the moving check - pm.registerEvent(Event.Type.BLOCK_PLACE, new BlockListener() { - - @Override - public void onBlockPlace(BlockPlaceEvent event) { - if(event.isCancelled()) - return; - - final Player player = event.getPlayer(); - // Get the player-specific stored data that applies here - movingCheck.blockPlaced(player, event.getBlockPlaced()); - - } - }, Priority.Monitor, plugin); } @Override public void onBlockPlace(BlockPlaceEvent event) { - if(event.isCancelled()) + if(event.isCancelled() || event.getBlock() == null) return; // Performance counter setup @@ -73,25 +62,42 @@ public class BlockPlaceEventManager extends BlockListener implements EventManage if(performanceCheck) nanoTimeStart = System.nanoTime(); - boolean cancel = false; - - final Player player = event.getPlayer(); - final ConfigurationCache cc = plugin.getConfig(player); - - // Find out if checks need to be done for that player - if(cc.blockplace.check && !player.hasPermission(Permissions.BLOCKPLACE)) { - cancel = blockPlaceCheck.check(player, event.getBlockPlaced(), event.getBlockAgainst(), cc); - } - - if(cancel) { - event.setCancelled(true); - } + handleEvent(event); // store performance time if(performanceCheck) blockPlacePerformance.addTime(System.nanoTime() - nanoTimeStart); } + private void handleEvent(BlockPlaceEvent event) { + + boolean cancelled = false; + + NoCheatPlayer player = plugin.getPlayer(event.getPlayer().getName()); + + if(!player.getConfiguration().blockplace.check || player.hasPermission(Permissions.BLOCKPLACE)) { + return; + } + + CCBlockPlace cc = player.getConfiguration().blockplace; + BlockPlaceData data = player.getData().blockplace; + + data.blockPlaced.set(event.getBlock()); + data.blockPlacedAgainst.set(event.getBlockAgainst()); + data.placedType = event.getBlock().getType(); + + for(BlockPlaceCheck check : checks) { + // If it should be executed, do it + if(!cancelled && check.isEnabled(cc) && !player.hasPermission(check.getPermission())) { + check.check(player, data, cc); + } + } + + if(cancelled) { + event.setCancelled(cancelled); + } + } + public List getActiveChecks(ConfigurationCache cc) { LinkedList s = new LinkedList(); diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/EntityDamageEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/FightEventManager.java similarity index 52% rename from src/cc/co/evenprime/bukkit/nocheat/events/EntityDamageEventManager.java rename to src/cc/co/evenprime/bukkit/nocheat/events/FightEventManager.java index 00037918..819c8472 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/EntityDamageEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/FightEventManager.java @@ -1,9 +1,12 @@ package cc.co.evenprime.bukkit.nocheat.events; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import org.bukkit.entity.Entity; +import net.minecraft.server.Entity; + +import org.bukkit.craftbukkit.entity.CraftEntity; import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.Event.Priority; @@ -14,22 +17,32 @@ import org.bukkit.event.entity.EntityListener; import org.bukkit.plugin.PluginManager; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.fight.FightCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.FightCheck; +import cc.co.evenprime.bukkit.nocheat.checks.fight.DirectionCheck; +import cc.co.evenprime.bukkit.nocheat.checks.fight.NoswingCheck; +import cc.co.evenprime.bukkit.nocheat.checks.fight.SelfhitCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCFight; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.FightData; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; -public class EntityDamageEventManager extends EntityListener implements EventManager { +public class FightEventManager extends EntityListener implements EventManager { - private final NoCheat plugin; - private final FightCheck fightCheck; - private final Performance fightPerformance; + private final NoCheat plugin; + private final List checks; + private final Performance fightPerformance; - public EntityDamageEventManager(NoCheat plugin) { + public FightEventManager(NoCheat plugin) { this.plugin = plugin; - this.fightCheck = new FightCheck(plugin); + + this.checks = new ArrayList(3); + this.checks.add(new NoswingCheck(plugin)); + this.checks.add(new DirectionCheck(plugin)); + this.checks.add(new SelfhitCheck(plugin)); this.fightPerformance = plugin.getPerformance(Type.FIGHT); @@ -58,30 +71,45 @@ public class EntityDamageEventManager extends EntityListener implements EventMan if(performanceCheck) nanoTimeStart = System.nanoTime(); - final Entity damagee = event.getEntity(); - // We can cast like crazy here because we ruled out all other - // possibilities above - final Player player = (Player) ((EntityDamageByEntityEvent) event).getDamager(); - - final ConfigurationCache cc = plugin.getConfig(player); - - // Find out if checks need to be done for that player - if(cc.fight.check && !player.hasPermission(Permissions.FIGHT)) { - - boolean cancel = false; - - cancel = fightCheck.check(player, damagee, cc); - - if(cancel) { - event.setCancelled(true); - } - } + handleEvent(event); // store performance time if(performanceCheck) fightPerformance.addTime(System.nanoTime() - nanoTimeStart); } + private void handleEvent(EntityDamageEvent event) { + + final Entity damagee = ((CraftEntity) event.getEntity()).getHandle(); + + // We can cast like crazy here because we ruled out all other + // possibilities above + final NoCheatPlayer player = plugin.getPlayer(((Player) ((EntityDamageByEntityEvent) event).getDamager()).getName()); + final FightData data = player.getData().fight; + final CCFight cc = player.getConfiguration().fight; + + if(!cc.check || player.hasPermission(Permissions.FIGHT)) { + return; + } + + boolean cancelled = false; + + data.damagee = damagee; + + for(FightCheck check : checks) { + // If it should be executed, do it + if(!cancelled && check.isEnabled(cc) && !player.hasPermission(check.getPermission())) { + check.check(player, data, cc); + } + } + + data.damagee = null; + + if(cancelled) { + event.setCancelled(cancelled); + } + } + public List getActiveChecks(ConfigurationCache cc) { LinkedList s = new LinkedList(); diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerChatEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerChatEventManager.java index e9f51462..9805106e 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerChatEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerChatEventManager.java @@ -1,9 +1,9 @@ package cc.co.evenprime.bukkit.nocheat.events; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import org.bukkit.entity.Player; import org.bukkit.event.Event; import org.bukkit.event.Event.Priority; import org.bukkit.event.player.PlayerChatEvent; @@ -12,9 +12,13 @@ import org.bukkit.event.player.PlayerListener; import org.bukkit.plugin.PluginManager; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.chat.ChatCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.ChatCheck; +import cc.co.evenprime.bukkit.nocheat.checks.chat.SpamCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCChat; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.ChatData; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; @@ -23,14 +27,16 @@ import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; */ public class PlayerChatEventManager extends PlayerListener implements EventManager { - private final NoCheat plugin; - private final ChatCheck chatCheck; - private final Performance chatPerformance; + private final NoCheat plugin; + private final List checks; + private final Performance chatPerformance; public PlayerChatEventManager(NoCheat plugin) { this.plugin = plugin; - this.chatCheck = new ChatCheck(plugin); + + this.checks = new ArrayList(1); + this.checks.add(new SpamCheck(plugin)); this.chatPerformance = plugin.getPerformance(Type.CHAT); @@ -40,6 +46,13 @@ public class PlayerChatEventManager extends PlayerListener implements EventManag pm.registerEvent(Event.Type.PLAYER_COMMAND_PREPROCESS, this, Priority.Lowest, plugin); } + @Override + public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event) { + // We redirect to the other method anyway, so no need to set up a + // performance counter here + onPlayerChat(event); + } + @Override public void onPlayerChat(final PlayerChatEvent event) { @@ -54,29 +67,37 @@ public class PlayerChatEventManager extends PlayerListener implements EventManag if(performanceCheck) nanoTimeStart = System.nanoTime(); - final Player player = event.getPlayer(); - final ConfigurationCache cc = plugin.getConfig(player); - - // Find out if checks need to be done for that player - if(cc.chat.check && !player.hasPermission(Permissions.CHAT)) { - - final boolean cancel = chatCheck.check(player, event.getMessage(), cc); - - if(cancel) { - event.setCancelled(true); - } - } + handleEvent(event); // store performance time if(performanceCheck) chatPerformance.addTime(System.nanoTime() - nanoTimeStart); } - public void onPlayerCommandPreprocess(final PlayerCommandPreprocessEvent event) { + private void handleEvent(PlayerChatEvent event) { + boolean cancelled = false; - // We redirect to the other method anyway, so no need to set up a - // performance counter here - onPlayerChat(event); + NoCheatPlayer player = plugin.getPlayer(event.getPlayer().getName()); + + if(!player.getConfiguration().chat.check || player.hasPermission(Permissions.CHAT)) { + return; + } + + CCChat cc = player.getConfiguration().chat; + ChatData data = player.getData().chat; + + data.message = event.getMessage(); + + for(ChatCheck check : checks) { + // If it should be executed, do it + if(!cancelled && check.isEnabled(cc) && !player.hasPermission(check.getPermission())) { + check.check(player, data, cc); + } + } + + if(cancelled) { + event.setCancelled(cancelled); + } } public List getActiveChecks(ConfigurationCache cc) { diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerMoveEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerMoveEventManager.java index 5526abcc..268deb5c 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerMoveEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerMoveEventManager.java @@ -1,12 +1,15 @@ package cc.co.evenprime.bukkit.nocheat.events; +import java.util.ArrayList; import java.util.LinkedList; import java.util.List; import org.bukkit.Location; -import org.bukkit.entity.Player; +import org.bukkit.block.Block; import org.bukkit.event.Event; import org.bukkit.event.Event.Priority; +import org.bukkit.event.block.BlockListener; +import org.bukkit.event.block.BlockPlaceEvent; import org.bukkit.event.player.PlayerListener; import org.bukkit.event.player.PlayerMoveEvent; import org.bukkit.event.player.PlayerVelocityEvent; @@ -14,12 +17,18 @@ import org.bukkit.plugin.PluginManager; import org.bukkit.util.Vector; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.moving.RunFlyCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.CheckUtil; +import cc.co.evenprime.bukkit.nocheat.checks.MovingCheck; +import cc.co.evenprime.bukkit.nocheat.checks.moving.MorePacketsCheck; +import cc.co.evenprime.bukkit.nocheat.checks.moving.RunflyCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCMoving; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; import cc.co.evenprime.bukkit.nocheat.data.BaseData; import cc.co.evenprime.bukkit.nocheat.data.MovingData; import cc.co.evenprime.bukkit.nocheat.data.PreciseLocation; +import cc.co.evenprime.bukkit.nocheat.data.SimpleLocation; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; @@ -32,16 +41,19 @@ import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; */ public class PlayerMoveEventManager extends PlayerListener implements EventManager { - private final NoCheat plugin; - private final RunFlyCheck movingCheck; + private final NoCheat plugin; + private final List checks; - private final Performance movePerformance; - private final Performance velocityPerformance; + private final Performance movePerformance; + private final Performance velocityPerformance; - public PlayerMoveEventManager(NoCheat plugin) { + public PlayerMoveEventManager(final NoCheat plugin) { this.plugin = plugin; - this.movingCheck = new RunFlyCheck(plugin); + this.checks = new ArrayList(5); + + checks.add(new RunflyCheck(plugin)); + checks.add(new MorePacketsCheck(plugin)); this.movePerformance = plugin.getPerformance(Type.MOVING); this.velocityPerformance = plugin.getPerformance(Type.VELOCITY); @@ -50,6 +62,21 @@ public class PlayerMoveEventManager extends PlayerListener implements EventManag pm.registerEvent(Event.Type.PLAYER_MOVE, this, Priority.Lowest, plugin); pm.registerEvent(Event.Type.PLAYER_VELOCITY, this, Priority.Monitor, plugin); + + // This is part of a workaround for the moving check + pm.registerEvent(Event.Type.BLOCK_PLACE, new BlockListener() { + + @Override + public void onBlockPlace(BlockPlaceEvent event) { + if(event.isCancelled()) + return; + + final NoCheatPlayer player = plugin.getPlayer(event.getPlayer().getName()); + // Get the player-specific stored data that applies here + blockPlaced(player, event.getBlockPlaced()); + + } + }, Priority.Monitor, plugin); } @Override @@ -66,43 +93,69 @@ public class PlayerMoveEventManager extends PlayerListener implements EventManag if(performanceCheck) nanoTimeStart = System.nanoTime(); - // Get the world-specific configuration that applies here - final Player player = event.getPlayer(); - final ConfigurationCache cc = plugin.getConfig(player); - - // Find out if checks need to be done for that player - if(cc.moving.check && !player.hasPermission(Permissions.MOVE)) { - - // Get some data that's needed from this event, to avoid passing the - // event itself on to the checks (and risk to - // accidentally modifying the event there) - final BaseData data = plugin.getData(player.getName()); - final MovingData moving = data.moving; - - final Location to = event.getTo(); - - moving.from.set(event.getFrom()); - moving.to.set(to); - - // This variable will have the modified data of the event (new - // "to"-location) - final PreciseLocation newTo = movingCheck.check(player, data, cc); - - // Did the check(s) decide we need a new "to"-location? - if(newTo != null) { - // Compose a new location based on coordinates of "newTo" and - // viewing direction of "event.getTo()" - event.setTo(new Location(player.getWorld(), newTo.x, newTo.y, newTo.z, to.getYaw(), to.getPitch())); - - data.moving.teleportTo.set(newTo); - } - } + handleEvent(event); // store performance time if(performanceCheck) movePerformance.addTime(System.nanoTime() - nanoTimeStart); } + public void handleEvent(PlayerMoveEvent event) { + + // Get the world-specific configuration that applies here + final NoCheatPlayer player = plugin.getPlayer(event.getPlayer().getName()); + final CCMoving cc = player.getConfiguration().moving; + + if(!cc.check || player.hasPermission(Permissions.MOVING)) { + return; + } + + final MovingData data = player.getData().moving; + + /******** DO GENERAL DATA MODIFICATIONS ONCE FOR EACH EVENT *****/ + if(data.horizVelocityCounter > 0) { + data.horizVelocityCounter--; + } else { + data.horizFreedom *= 0.90; + } + + if(data.vertVelocityCounter > 0) { + data.vertVelocityCounter--; + data.vertFreedom += data.vertVelocity; + data.vertVelocity *= 0.90; + } else { + data.vertFreedom = 0; + } + + // Get some data that's needed from this event, to avoid passing the + // event itself on to the checks (and risk to + // accidentally modifying the event there) + + final Location to = event.getTo(); + + data.from.set(event.getFrom()); + data.to.set(to); + + // This variable will have the modified data of the event (new + // "to"-location) + PreciseLocation newTo = null; + + for(MovingCheck check : checks) { + if(newTo == null && check.isEnabled(cc) && !player.hasPermission(check.getPermission())) { + newTo = check.check(player, data, cc); + } + } + + // Did the check(s) decide we need a new "to"-location? + if(newTo != null) { + // Compose a new location based on coordinates of "newTo" and + // viewing direction of "event.getTo()" + event.setTo(new Location(player.getPlayer().getWorld(), newTo.x, newTo.y, newTo.z, to.getYaw(), to.getPitch())); + + data.teleportTo.set(newTo); + } + } + @Override public void onPlayerVelocity(PlayerVelocityEvent event) { if(event.isCancelled()) @@ -115,22 +168,22 @@ public class PlayerMoveEventManager extends PlayerListener implements EventManag if(performanceCheck) nanoTimeStart = System.nanoTime(); - BaseData data = plugin.getData(event.getPlayer().getName()); + MovingData data = plugin.getPlayer(event.getPlayer().getName()).getData().moving; Vector v = event.getVelocity(); double newVal = v.getY(); if(newVal >= 0.0D) { - data.moving.vertVelocity += newVal; - data.moving.vertFreedom += data.moving.vertVelocity; + data.vertVelocity += newVal; + data.vertFreedom += data.vertVelocity; } - data.moving.vertVelocityCounter = 50; + data.vertVelocityCounter = 50; newVal = Math.sqrt(Math.pow(v.getX(), 2) + Math.pow(v.getZ(), 2)); if(newVal > 0.0D) { - data.moving.horizFreedom += newVal; - data.moving.horizVelocityCounter = 30; + data.horizFreedom += newVal; + data.horizVelocityCounter = 30; } // store performance time @@ -138,6 +191,35 @@ public class PlayerMoveEventManager extends PlayerListener implements EventManag velocityPerformance.addTime(System.nanoTime() - nanoTimeStart); } + /** + * This is a workaround for people placing blocks below them causing false + * positives with the move check(s). + */ + public void blockPlaced(final NoCheatPlayer player, Block blockPlaced) { + + BaseData data = player.getData(); + + if(blockPlaced == null || !data.moving.runflySetBackPoint.isSet()) { + return; + } + + SimpleLocation lblock = new SimpleLocation(); + lblock.set(blockPlaced); + SimpleLocation lplayer = new SimpleLocation(); + lplayer.setLocation(player.getPlayer().getLocation()); + + if(Math.abs(lplayer.x - lblock.x) <= 1 && Math.abs(lplayer.z - lblock.z) <= 1 && lplayer.y - lblock.y >= 0 && lplayer.y - lblock.y <= 2) { + + int type = CheckUtil.getType(blockPlaced.getTypeId()); + if(CheckUtil.isSolid(type) || CheckUtil.isLiquid(type)) { + if(lblock.y + 1 >= data.moving.runflySetBackPoint.y) { + data.moving.runflySetBackPoint.y = (lblock.y + 1); + data.moving.jumpPhase = 0; + } + } + } + } + public List getActiveChecks(ConfigurationCache cc) { LinkedList s = new LinkedList(); diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerTeleportEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerTeleportEventManager.java index d2251286..cbb051b8 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/PlayerTeleportEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/PlayerTeleportEventManager.java @@ -47,7 +47,7 @@ public class PlayerTeleportEventManager extends PlayerListener implements EventM return; } - final BaseData data = plugin.getData(event.getPlayer().getName()); + final BaseData data = plugin.getPlayer(event.getPlayer().getName()).getData(); if(data.moving.teleportTo.isSet() && data.moving.teleportTo.equals(event.getTo())) { event.setCancelled(false); diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/SwingEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/SwingEventManager.java index d175bf72..571acbe8 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/SwingEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/SwingEventManager.java @@ -34,7 +34,7 @@ public class SwingEventManager extends PlayerListener implements EventManager { @Override public void onPlayerAnimation(final PlayerAnimationEvent event) { - plugin.getData(event.getPlayer().getName()).armswung = true; + plugin.getPlayer(event.getPlayer().getName()).getData().armswung = true; } public List getActiveChecks(ConfigurationCache cc) { diff --git a/src/cc/co/evenprime/bukkit/nocheat/events/TimedEventManager.java b/src/cc/co/evenprime/bukkit/nocheat/events/TimedEventManager.java index 21fc279d..bb5c1294 100644 --- a/src/cc/co/evenprime/bukkit/nocheat/events/TimedEventManager.java +++ b/src/cc/co/evenprime/bukkit/nocheat/events/TimedEventManager.java @@ -8,30 +8,28 @@ import java.util.List; import net.minecraft.server.EntityPlayer; import org.bukkit.craftbukkit.CraftServer; -import org.bukkit.craftbukkit.entity.CraftEntity; -import org.bukkit.entity.Player; import cc.co.evenprime.bukkit.nocheat.NoCheat; -import cc.co.evenprime.bukkit.nocheat.checks.timed.TimedCheck; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.checks.TimedCheck; +import cc.co.evenprime.bukkit.nocheat.checks.timed.GodmodeCheck; import cc.co.evenprime.bukkit.nocheat.config.Permissions; +import cc.co.evenprime.bukkit.nocheat.config.cache.CCTimed; import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.TimedData; import cc.co.evenprime.bukkit.nocheat.debug.Performance; import cc.co.evenprime.bukkit.nocheat.debug.PerformanceManager.Type; public class TimedEventManager implements EventManager { - private final NoCheat plugin; - - private final TimedCheck check; - - private final Performance timedPerformance; - - public final int taskId; + private final List checks; + private final Performance timedPerformance; + public final int taskId; public TimedEventManager(final NoCheat plugin) { - this.plugin = plugin; - check = new TimedCheck(plugin); + checks = new ArrayList(1); + checks.add(new GodmodeCheck(plugin)); this.timedPerformance = plugin.getPerformance(Type.TIMED); @@ -71,7 +69,20 @@ public class TimedEventManager implements EventManager { // Now initialize the checks one by one for(EntityPlayer p : entities) { try { - onTimedEvent((Player) CraftEntity.getEntity(server, p), loopsize); + + // Performance counter setup + long nanoTimeStart = 0; + final boolean performanceCheck = timedPerformance.isEnabled(); + + if(performanceCheck) + nanoTimeStart = System.nanoTime(); + + handleEvent(plugin.getPlayer(p.name)); + + // store performance time + if(performanceCheck) + timedPerformance.addTime(System.nanoTime() - nanoTimeStart); + } catch(Exception e) { e.printStackTrace(); } @@ -83,24 +94,20 @@ public class TimedEventManager implements EventManager { }, 0, 1); } - private void onTimedEvent(Player player, int elapsedTicks) { + private void handleEvent(NoCheatPlayer player) { - // Performance counter setup - long nanoTimeStart = 0; - final boolean performanceCheck = timedPerformance.isEnabled(); + TimedData data = player.getData().timed; + CCTimed cc = player.getConfiguration().timed; - if(performanceCheck) - nanoTimeStart = System.nanoTime(); - - ConfigurationCache cc = plugin.getConfig(player); - - if(cc.timed.check && !player.hasPermission(Permissions.TIMED)) { - check.check(player, elapsedTicks, cc); + if(!cc.check || player.hasPermission(Permissions.TIMED)) { + return; } - // store performance time - if(performanceCheck) - timedPerformance.addTime(System.nanoTime() - nanoTimeStart); + for(TimedCheck check : checks) { + if(cc.check && !player.hasPermission(Permissions.TIMED)) { + check.check(player, data, cc); + } + } } public List getActiveChecks(ConfigurationCache cc) { diff --git a/src/cc/co/evenprime/bukkit/nocheat/player/NoCheatPlayerImpl.java b/src/cc/co/evenprime/bukkit/nocheat/player/NoCheatPlayerImpl.java new file mode 100644 index 00000000..ba52aa64 --- /dev/null +++ b/src/cc/co/evenprime/bukkit/nocheat/player/NoCheatPlayerImpl.java @@ -0,0 +1,43 @@ +package cc.co.evenprime.bukkit.nocheat.player; + +import org.bukkit.Bukkit; +import org.bukkit.entity.Player; + +import cc.co.evenprime.bukkit.nocheat.NoCheat; +import cc.co.evenprime.bukkit.nocheat.NoCheatPlayer; +import cc.co.evenprime.bukkit.nocheat.config.cache.ConfigurationCache; +import cc.co.evenprime.bukkit.nocheat.data.BaseData; + +public class NoCheatPlayerImpl implements NoCheatPlayer { + + private final Player player; + private final NoCheat plugin; + private final BaseData data; + + public NoCheatPlayerImpl(String playerName, NoCheat plugin, BaseData data) { + this.player = Bukkit.getServer().getPlayer(playerName); + this.plugin = plugin; + this.data = data; + } + + public boolean hasPermission(String permission) { + return player.hasPermission(permission); + } + + public BaseData getData() { + return data; + } + + public Player getPlayer() { + return player; + } + + public ConfigurationCache getConfiguration() { + return plugin.getConfig(player); + } + + public String getName() { + return player.getName(); + } + +}