Upstream/NoCheatPlus
1
0
Fork 0
mirror of https://github.com/NoCheatPlus/NoCheatPlus.git synced 2025-01-01 05:18:00 +01:00
Code Issues Projects Releases Wiki Activity

Descriptions.txt file, written on startup.

Browse Source
This commit is contained in:
Evenprime 2012-02-01 00:10:14 +01:00
parent bacaf7a224
commit d05b0aacf6
5 changed files with 410 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

363
Instructions.txt Normal file
View File

@ -0,0 +1,363 @@
Configuration file description.
1) Important files, config.yml or "clean up your stuff"
- The config file for NoCheat is called "config.yml" now.
- You can have different config files for different worlds.
To achieve this, copy the "config.yml" and rename the copy to
"worldname_config.yml". Settings in that file will now only
affect the world with the name "worldname". You may also delete
all settings from that world-specific file that you won't use.
They'll be implicitely taken from the master "config.yml" file.
- If you have files ending with "config.txt", "actions.txt" or
"default_actions.txt", please delete them. They are no longer
used by NoCheat.
- Never change the amount of whitespaces in front of options in the config file
"config.yml". It will break the configuration.
2) How the "actions" work, how to modify them and how to write your own,
- NoCheat allows to define in detail what should happen when a player fails a
check in form of "actions". There are 4 possible things that may be done, read
on to learn in detail on how to define your own or modify the existing actions:
"cancel" = Depends on the check. Usually prevent something from happening
"log" = Create and show/log a message
"cmd" = Execute a command of Bukkit or another plugin as if it were
typed into the console by the admin.
"vl>" = Is meant to symbolize "violation level bigger than". Used to define
actions that will be executed only if players reached a certain
violation level. Failing a check usually increases their vl, not
failing checks reduces it over time.
- "cancel" action is just the word "cancel". Read in the detailed option
description to find out what it does depending on the check that it is
assigned to.
- "log" action is a string of the form "log:string:delay:repeat:target".
"log" = is simply used to let NoCheat know it is a log action.
"string" = is the message that will be logged. Because there is so little
space here, you only give a name here and define the actual
log message in the "strings" section of the config file.
"delay" = a number declaring how many times that action initially has
to be executed before it really leads to logging a message.
Use this for situations where it's common to have false
positives in checks and you only want the log message to be
shown if a player fails the check multiple times within a
short timeframe (1 minute)
"repeat" = a number declaring how many seconds have to pass after logging
the message before it will be logged again for that player.
This is needed to prevent "log-spam". Usually a value of 5
seconds is acceptable.
"target" = where should the message be logged to? You can use three letters
here. "c" means logging to console, "i" means logging to ingame
chat and "f" means logging to the log file.
- "cmd" action is a string of the form "cmd:string:delay:repeat"
"cmd" = is simply used to let NoCheat know it is a command action.
"string" = is the command that will be issued in the console.
Because there is so little space here, you only give a
name here and define the actual command in the "strings"
section of the config file.
"delay" = a number declaring how many times that action initially has
to be executed before it really leads to running the command
in the console. Use this to create e.g. a 3-strikes-law by
setting it to 3. Only if a player fails the check 3 times
within 1 minute, the command will be really run.
"repeat" = a number declaring how many seconds have to pass after running
the command before it can be run again for that player.
Because many commands are expensive (take time, resources), you
may want to limit how often they can be called.
- "vl>" isn't really an action. It limits all actions that are written
afterwards to be only executed if the players violation level has reached
the given value. This allows to define layers of actions and handle repeated
or severe failing of checks different. For example the spam check will kick
players if they reach a certain violation level (vl).
3) Now that you know the basics, here is the description of all
options that are available in the configuration file.
logging:
Anything that has to do with how and where NoCheat shows its messages
active:
Should messages get logged at all. If you are not interested in messages,
set this to false
prefix:
Will be placed in front of many log messages. To get colors, use "&" followed by
a number (0-9) or a letter (A-F)
filename:
The name of the logfile that NoCheat will use to log its messages
file:
Should the logfile be used at all. Set to false if you don't want to use a logfile
console:
Should the server console be used to display messages. Set to false if you don't
want NoCheat to show messages in the console.
ingamechat:
Should NoCheat display messages in the ingame chat? Set to false if you don't
want NoCheat to show messages ingame.
showactivechecks:
Should NoCheat display lists of checks that are enabled for each world. Set to true
if you are unsure if you setup your configuration correctly.
checks:
Anything that has to do with the checks that NoCheat executes
inventory:
All checks that have to do with the player inventory
drop:
The "inventory.drop" check. It limits how many seperate items a player can drop
onto the ground within a specific time. Dropping a lot of seperate items at once
can cause lag on the server.
active:
Should the check be enabled. Set to false if you are not interested in this at all
time:
Over how many seconds should dropped items be counted
limit:
How many items may be dropped in that timeframe. Please consider that dying causes
a player to drop up to 36 seperate items. Therefore this value shouldn't be set
below ~50.
actions:
What should happen when a player goes beyond the set limit. Default settings log
a message and kick the player from the server.
moving:
All checks that have to do with player movement
runfly:
This is a combined check for running, flying and "nofall" hacks
active:
Should players get checked for movement related hacks at all
allowfastsneaking:
Should sneaking players be allowed to move as fast as normal players. Set this to
true, if you use plugins that enable players to do that (e.g. RPG plugins tend
to do that)
actions:
What should happen when a player sneaks/swims/walks/runs faster than normally
or is flying. Default is to log messages (depending on how severe the cheating
is) and teleport the player to a location that he was before ("cancel" the
movement)
checknofall:
Should players be checked for a common type of "nofall" hack, that allows them to
avoid taking damage when falling.
nofallactions:
What should happen if a player is considered to be using a "nofall" hack. Default
is to log a message and encourage Bukkit to deal fall damage anyway ("cancel" the
hack).
flying:
Anything related specifically to players that are allowed to fly, but still should
be limited in their flying.
allowflyingalways:
Should all players be allowed to fly always.
allowflyingincreative:
Should players that are set to "creative mode" be allowed to fly.
flyingspeedlimithorizontal:
How many 1/100 blocks may a player fly horizontal within one "step". The
official "creative mode" flying reaches speeds of about 0.6 blocks
which means a value of 60 here.
flyingspeedlimitvertical:
How many 1/100 blocks may a player fly vertically up within one "step".
A value of 100 which means 1 block seems reasonable.
flyingheightlimit:
What is the maximum height (in blocks) that a player may reach by flying.
Some servers experience lag when players fly very, very high. The map is
usually 128 high, therefore a value of 250 seems reasonable.
actions:
What should happen if a player flies faster/higher than defined here?
Default is to log messages and to prevent the player from moving ("cancel"
his movement)
morepackets:
The morepackets check is complementary to the "runfly" check. While "runfly"
limits the distance a player can move per step, morepackets limits the number
of "steps" a player may take per second. A normal value is 20 steps per second.
active:
Should players be checked for this kind of cheating. If you are not interested
in players that cheat that way, set this to false.
actions:
What should happen if a player is considered to be cheating by taking more steps
per second than normal. Default is to log messages and teleport the player back
to a location where he was ~1 second before ("cancel" his movement).
blockbreak:
Anything related to checking if players cheat while breaking blocks
reach:
Players may slightly increase the distance at which they can break blocks. This check
will try to identify that by comparing player and block location.
active:
Should players get checked for this type of hack
actions:
What should happen if the player is considered to cheat. Default is to prevent him
from breaking the block ("cancel" the breaking) and on repeated offenses to log
messages about it.
direction:
Players may break blocks without really looking at them. This is often combined with
breaking a lot of blocks surrounding the player at the same time.
active:
Should players get checked for this type of hack
precision:
How strict should NoCheat be when comparing the players line of view with the broken
block location. The value represents (roughly) the amount of 1/100 blocks that the
player is allowed to look past the broken block. 50 (0.5 blocks) seems a good
default value.
penaltytime:
If a player fails this check, how long should he be prevented from breaking blocks
afterwards. In milliseconds. This is intended to make automated destruction of
blocks harder. 0.3 seconds, value 300 is the default. Set to 0, if you don't want
to limit players at all after failing this check.
actions:
What should happen if a player fails this check. Default is to prevent the breaking
of the block ("cancel" it) and after repeated/more severe offenses to log a message.
noswing:
Players may break blocks without moving their arm. This is confusing for nearby players,
as they won't see who broke the blocks.
active:
Should players get checked for this type of hack
actions:
What should happen if the player didn't swing his arm first? Default is to log a
message and prevent the breaking of the block ("cancel" it).
blockplace:
All checks related to placing blocks.
reach:
Players may place blocks over a bigger distance than usually possible.
active:
Should players be checked for this type of hack.
actions:
What should happen if a player placed blocks at bigger distances than usual.
Default is to log a message and stop the block placing ("cancel it).
direction:
Players may place blocks without looking at where they place them.
active:
Should players be checked for this type of hack.
precision:
How strict should NoCheat be when checking if a player is looking in the
correct direction. 75 (which means a player may be up to 0.75 blocks off)
seems to be an ok value.
penaltytime:
How long after failing this check should the player be prevented from
placing any further blocks. This value is in milliseconds, the default
is 100, which means 0.1 seconds. If you don't want to have this penalty
time, set it to 0.
actions:
What should be done if a player places blocks outside of his line of
sight. Default is to log a message and prevent ("cancel") the block
placing.
chat:
All checks related to sending chat messages.
color:
Players may use colorcodes to send colored messages. This may be used
to fool other players into believing they are admins or similar.
active:
Should player messages get checked for the use of colors in messages.
actions:
What should be done if a player sends messages with color codes.
Default is to log a message and prevent ("cancel") the use of the
color codes, by filtering them from the message.
spam:
Players may send a ton of messages/commands in a short time to cause
lag or even crash a server.
active:
Should player messages get checked for the sending of too many messages.
whitelist:
A " " (whitespace) seperated list of words. Messages that start with
these sequences will not be counted.
timeframe:
For how many seconds should messages and commands be counted.
messagelimit:
How many "normal" chat messages may be sent within the timeframe.
commandlimit:
How many commands may be issued within the timeframe. Some mods (e.g.
TooManyItems) send a command on every mouseclick, which may cause
problems if this is set too low.
actions:
What should happen if players send more messages/commands? Default is
to prevent the message/command from being processed ("cancel" them)
and for severe cases where players send a lot of messages/commands,
kick them.
fight:
Everything related to fighting
direction:
Players may attack enemies without looking at them. This check tries to
identify such behaviour.
active:
Should players get checked for such behaviour.
precision:
How strict should NoCheat be when comparing the line of sight with the
position of the target. Default is 75 which means a player may look
0.75 blocks past the actual target. Because the target is moving, this
value should be relatively high.
penaltytime:
If a player fails this check, how long should he be prevented from
attacking anything in milliseconds. Default is 500 and therefore 0.5
seconds. If you don't want to limit the player like this, set this
value to 0.
actions:
What should happen if the player fails this check. Default is to stop
the attack ("cancel" it) and log messages, depending on how much the
player fails this check.
noswing:
Players may attack enemies without moving their arm. This may confuse
other players as they can't see who is attacking them or monsters.
active:
Should players be checked for this behaviour.
actions:
What should happen if the player fails this check. Default is to stop
the attack ("cancel" it) and log messages.
reach:
Players may attack enemies over a greater distance than usual. This is
a significant advantage in fights. Normally attacks are only allowed
over a ~4 block distance, but these hacks may increase that to 6 blocks.
active:
Should players be checked for this behaviour.
distance:
What is the maximum distance that NoCheat should allow attacks for.
Default is 4 blocks (value 400). Setting this even lower will limit
the attack distance below the original "legal" distance.
penaltytime:
If a player fails this check, how long should he be prevented from
attacking anything. Default is 0.5 seconds (value 500). If you
don't want to limit players like this, set this value to 0.
actions:
What should happen if the player fails this check. Default is to stop
the attack ("cancel" it) and log messages.
speed:
Players may be attacking extremely fast within a short time by using
automated clicking or hacks. This is an advantage in many situations.
active:
Should players be checked for this behaviour.
attacklimit:
How many attacks may a player start within 1 second. Consider setting
this to a value that's close to how fast you believe players can click
their mouse.
actions:
What should happen if the player fails this check. Default is to stop
the attack ("cancel" it) and log messages.
strings:
This is the section that defines various strings for "log" or "cmd" actions.
Each has a name (the part in front of ":") and a definition (the part
behind the ":"). Whenever you use a "log" or "cmd" action in one of the
"actions: " options of this config file, the string will be taken from
this section. Arbitrary many additional strings may be defined here, or
existing strings may be changed.
Most messages/commands use placeholders in [ ], which will be replaced at
runtime with relevant information. Some of these may only be available in
certain circumstances, only "[player]" can be used everywhere, especially
in "cmd" actions.
4) Other stuff
- NoCheat isn't perfect and won't prevent all forms of cheating. It's a best
effort approach.
- NoCheat may make mistakes. Don't see everything NoCheat says or does as
indisputable fact that somebody cheated. It's not possible to be 100% sure
if somebody is cheating or not, NoCheat will try to be right most of the
time.

1
pom.xml
View File

@ -62,6 +62,7 @@
<include>plugin.yml</include>
<include>README.txt</include>
<include>LICENSE.txt</include>
<include>Instructions.txt</include>
</includes>
</resource>
</resources>

16
src/cc/co/evenprime/bukkit/nocheat/NoCheat.java
View File

@ -17,20 +17,15 @@ import org.bukkit.plugin.PluginDescriptionFile;
import org.bukkit.plugin.java.JavaPlugin;
import cc.co.evenprime.bukkit.nocheat.checks.WorkaroundsListener;
import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.BlockBreakCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.blockbreak.BlockBreakData;
import cc.co.evenprime.bukkit.nocheat.checks.blockplace.BlockPlaceCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.blockplace.BlockPlaceData;
import cc.co.evenprime.bukkit.nocheat.checks.chat.ChatCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.chat.ChatData;
import cc.co.evenprime.bukkit.nocheat.checks.fight.FightCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.fight.FightData;
import cc.co.evenprime.bukkit.nocheat.checks.inventory.InventoryCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.inventory.InventoryData;
import cc.co.evenprime.bukkit.nocheat.checks.moving.MovingCheckListener;
import cc.co.evenprime.bukkit.nocheat.checks.moving.MovingData;
import cc.co.evenprime.bukkit.nocheat.command.CommandHandler;
import cc.co.evenprime.bukkit.nocheat.config.ConfigurationCacheStore;
import cc.co.evenprime.bukkit.nocheat.config.ConfigurationManager;
import cc.co.evenprime.bukkit.nocheat.config.NoCheatConfiguration;
import cc.co.evenprime.bukkit.nocheat.config.Permissions;
import cc.co.evenprime.bukkit.nocheat.data.PlayerManager;
import cc.co.evenprime.bukkit.nocheat.debug.ActiveCheckPrinter;
@ -95,13 +90,6 @@ public class NoCheat extends JavaPlugin implements Listener {
eventManagers.add(new FightCheckListener(this));
eventManagers.add(new InventoryCheckListener(this));
new MovingData();
new BlockBreakData();
new BlockPlaceData();
new ChatData();
new FightData();
new InventoryData();
// Then set up a task to monitor server lag
if(lagMeasureTask == null) {
lagMeasureTask = new LagMeasureTask(this);
@ -118,6 +106,8 @@ public class NoCheat extends JavaPlugin implements Listener {
Bukkit.getPluginManager().registerEvents(this, this);
NoCheatConfiguration.writeInstructions(this.getDataFolder());
// Tell the server admin that we finished loading NoCheat now
System.out.println("[NoCheat] version [" + this.getDescription().getVersion() + "] is enabled.");
}

4
src/cc/co/evenprime/bukkit/nocheat/config/DefaultConfiguration.java
View File

@ -10,7 +10,9 @@ public class DefaultConfiguration extends NoCheatConfiguration {
public DefaultConfiguration() {
this.options().header("Main configuration file for NoCheat.");
super();
this.options().header("Main configuration file for NoCheat. Read \"Instructions.txt\"");
/** LOGGING **/
set(ConfPaths.LOGGING_ACTIVE, true);

42
src/cc/co/evenprime/bukkit/nocheat/config/NoCheatConfiguration.java
View File

@ -1,5 +1,8 @@
package cc.co.evenprime.bukkit.nocheat.config;
import java.io.File;
import java.io.FileWriter;
import java.io.InputStream;
import java.lang.reflect.Field;
import org.bukkit.configuration.MemorySection;
import org.bukkit.configuration.file.YamlConfiguration;
@ -14,7 +17,7 @@ public class NoCheatConfiguration extends YamlConfiguration {
@Override
public String saveToString() {
// Some reflection wizardry to avoid having a lot of
// linebreaks in the yml file
// linebreaks in the yml file, and get a "footer" into the file
try {
Field op;
op = YamlConfiguration.class.getDeclaredField("yamlOptions");
@ -23,7 +26,42 @@ public class NoCheatConfiguration extends YamlConfiguration {
options.setWidth(200);
} catch(Exception e) {}
return super.saveToString();
String result = super.saveToString();
return result;
}
public static void writeInstructions(File rootConfigFolder) {
InputStream fis = NoCheatConfiguration.class.getClassLoader().getResourceAsStream("Instructions.txt");
StringBuffer result = new StringBuffer();
try {
byte[] buf = new byte[1024];
int i = 0;
while((i = fis.read(buf)) != -1) {
result.append(new String(buf).substring(0, i));
}
File iFile = new File(rootConfigFolder, "Instructions.txt");
if(iFile.exists()) {
iFile.delete();
}
FileWriter output = new FileWriter(iFile);
String nl = System.getProperty("line.separator");
String instructions = result.toString();
instructions = instructions.replaceAll("\r\n", "\n");
String lines[] = instructions.split("\n");
for(String line : lines) {
output.append(line);
output.append(nl);
}
output.flush();
output.close();
} catch(Exception e) {
e.printStackTrace();
}
}
/**