craftinc/craftinc-borderprotection
5
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: craftinc:master
Branches Tags
craftinc:master
craftinc:development
craftinc:world-generation
craftinc:1.1.1
craftinc:1.1
craftinc:1.0.3-1
craftinc:1.0.3
craftinc:1.0.2
craftinc:1.0.1
craftinc:1.0.0
craftinc:0.9.9
..
compare: craftinc:1.1
Branches Tags
craftinc:master
craftinc:development
craftinc:world-generation
craftinc:1.1.1
craftinc:1.1
craftinc:1.0.3-1
craftinc:1.0.3
craftinc:1.0.2
craftinc:1.0.1
craftinc:1.0.0
craftinc:0.9.9

No commits in common. "master" and "1.1" have entirely different histories.
master ... 1.1

35 changed files with 910 additions and 2002 deletions
Show Stats Expand all files Collapse all files

1
.gitignore vendored
View File

@ -2,4 +2,3 @@ lib/
target/
*.iml
.idea/
bukkit-testserver/

BIN
CraftincBorderProtection.jar Normal file
View File

Binary file not shown.

17
LICENSE Normal file
View File

@ -0,0 +1,17 @@
# GPLv3
* src/main/java/de/craftinc/borderprotection/Border.java
* src/main/java/de/craftinc/borderprotection/BorderManager.java
* src/main/java/de/craftinc/borderprotection/Commands.java
* src/main/java/de/craftinc/borderprotection/Messages.java
* src/main/java/de/craftinc/borderprotection/PlayerMoveListener.java
* src/main/java/de/craftinc/borderprotection/PlayerTeleportListener.java
* src/main/java/de/craftinc/borderprotection/Plugin.java
* src/main/resources/plugin.yml
full text of GPLv3 can be found in the file "GPLv3"
# LGPLv3
* src/main/java/de/craftinc/borderprotection/LocationSerializer.java
full text of LGPLv3 can be found in the file "LGPLv3"

10
LICENSE.md
View File

@ -1,10 +0,0 @@
# GPLv3
* All files except the files listed under LGPLv3 are licensed under GPLv3
full text of GPLv3 can be found in the file "GPLv3"
# LGPLv3
* src/main/java/de/craftinc/borderprotection/util/LocationSerializer2D.java
full text of LGPLv3 can be found in the file "LGPLv3"

2
README.md
View File

@ -2,7 +2,7 @@
A border protection plugin for bukkit. All players (except those with ignoreborders permission) cannot go beyond the border.
Read the [full user guide](https://craftinc.comff.net/border-protection/) for more information.
Read the [full user guide](http://www.craftinc.de/border-protection/) for more information.
## License

64
pom.xml
View File

@ -4,78 +4,36 @@
<modelVersion>4.0.0</modelVersion>
<groupId>de.craftinc</groupId>
<artifactId>CraftincBorderProtection</artifactId>
<name>CraftInc-BorderProtection</name>
<packaging>jar</packaging>
<version>2.0</version>
<version>1.1</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<build>
<finalName>${project.name}-${project.version}</finalName>
<resources>
<resource>
<directory>src/main/resources</directory>
<filtering>true</filtering>
</resource>
</resources>
<plugins>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>copy-dependencies</goal>
</goals>
<configuration>
<outputDirectory>${project.build.directory}/lib</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>exec-maven-plugin</artifactId>
<groupId>org.codehaus.mojo</groupId>
<version>1.2.1</version>
<executions>
<execution>
<id>Run Test Bukkit Server</id>
<phase>install</phase>
<goals>
<goal>exec</goal>
</goals>
<configuration>
<executable>${basedir}/scripts/test-deployment.sh</executable>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
</repository>
</repositories>
<dependencies>
<!--Spigot API-->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.10.2-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!--Bukkit API-->
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<version>1.10.2-R0.1-SNAPSHOT</version>
<scope>provided</scope>
<version>RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
</dependencies>
<repositories>
<repository>
<id>bukkit-repo</id>
<url>http://repo.bukkit.org/content/groups/public</url>
</repository>
</repositories>
</project>

202
scripts/minecraft.sh
View File

@ -1,202 +0,0 @@
#!/bin/bash
# Craft Inc. BorderProtection
# Copyright (C) 2016 Paul Schulze
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
SERVICE='craftbukkit-1.10.2.jar'
# numbers of CPU cores; used only for the parallel garbage collector threads
CPU_COUNT=8
# maximum memory which the JAVA VM is allowed to allocate (M is megabyte)
XMX=-Xmx10000M
# initial memory which the JAVA VM is allocating (M is megabyte)
XMS=-Xms3000M
# Replace with path which contains your craftbukkit.jar
MCPATH="$(dirname "$0")/../bukkit-testserver"
# ========================================================================
# == Don't change anything below this line unless you know what you do. ==
# ========================================================================
BUKKIT="$MCPATH/$SERVICE"
INVOCATION="java $XMX $XMS -XX:+UseConcMarkSweepGC -XX:+CMSIncrementalPacing -XX:ParallelGCThreads=$CPU_COUNT -XX:+AggressiveOpts -jar $BUKKIT nogui"
if [[ "$MCPATH" == '/my/path/to/craftbukkit' ]]; then
echo "Please configure the \"MCPATH\" variable in the $0 file." >&2
exit 1
fi
SCREEN_NAME="$(cat "$MCPATH/screen_name" 2> /dev/null)"
if [[ -z "$SCREEN_NAME" ]]; then
SCREEN_NAME="minecraft.$(head -c12 /dev/urandom | xxd -p)"
echo -n "$SCREEN_NAME" > "$MCPATH/screen_name"
fi
psgrep() {
psgreptmp=$(mktemp)
ps auxww > "$psgreptmp"
grep -v "$$" "$psgreptmp" | egrep --color=auto -i "$1"
rm "$psgreptmp"
}
send_to_screen() {
screen -p 0 -S "$SCREEN_NAME" -X stuff "$1
"
}
mc_service_running() {
psgrep "$SERVICE" | grep -v -i 'screen' | grep 'java' | grep -- "$XMX" | grep -- "$XMS" | grep "$BUKKIT" > /dev/null
return $?
}
mc_start() {
if ! mc_status; then
echo "Starting..."
cd "$MCPATH"
screen -dmS "$SCREEN_NAME" $INVOCATION
sleep 2
mc_status
fi
}
mc_stop() {
if mc_status; then
# echo "Sending message to users..."
# send_to_screen 'say SERVER SHUTTING DOWN IN 10 SECONDS!'
# sleep 10
echo "Saving..."
send_to_screen 'save-all'
sleep 1
echo "Stopping..."
send_to_screen 'stop'
sleep 3
mc_status
fi
}
mc_save() {
if mc_status; then
echo "Saving..."
send_to_screen 'save-all'
fi
}
mc_restart_or_start() {
if mc_service_running; then
mc_stop
sleep 1
mc_start
else
mc_start
fi
}
mc_reset_permissions() {
if mc_status; then
echo "Unbanning ddidderr..."
send_to_screen 'pardon ddidderr'
echo "Unbanning mice_on_drugs..."
send_to_screen 'pardon mice_on_drugs'
echo "Unbanning Mochaccino..."
send_to_screen 'pardon Mochaccino'
echo "ddidder -> admin"
send_to_screen 'pex user ddidderr group set admin'
echo "mice_on_drugs -> mod"
send_to_screen 'pex user mice_on_drugs group set mod'
echo "Mochaccino -> mod"
send_to_screen 'pex user Mochaccino group set mod'
echo "Reloading permissions..."
send_to_screen 'pex reload'
echo "DONE"
fi
}
mc_custom_command() {
if mc_status; then
if [[ -z "$1" ]]; then
echo "You must specify a command." >&2
exit 1
fi
echo "Trying to issue command: \"$1\""
send_to_screen "$1"
tail -fn50 "$MCPATH/logs/latest.log"
fi
}
mc_status() {
if mc_service_running; then
echo "$SERVICE is running."
return 0
else
echo "$SERVICE is stopped."
return 1
fi
}
mc_online() {
if mc_status; then
send_to_screen 'list'
sleep 2s
tac "$MCPATH/logs/latest.log" | egrep -om 1 "There are.*players online"
fi
}
case "$1" in
start)
mc_start
;;
stop)
mc_stop
;;
restart)
$0 stop
sleep 2
$0 start
;;
restart_or_start)
mc_restart_or_start
;;
reset_permissions)
mc_reset_permissions
;;
custom)
mc_custom_command "${*:2}"
;;
online)
mc_online
;;
status)
mc_status
;;
save)
mc_save
;;
*)
echo "Usage: $0 {start|stop|restart|save|online|status|reset_permissions}"
exit 1
;;
esac

57
scripts/test-deployment.sh
View File

@ -1,57 +0,0 @@
#!/bin/bash
# Craft Inc. BorderProtection
# Copyright (C) 2016 Paul Schulze
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
SCRIPT_DIR="$(dirname "$0")"
DEVELOPER="$(whoami)"
BUKKIT_DIR="$SCRIPT_DIR/../bukkit-testserver"
PLUGIN_DIR="$SCRIPT_DIR/../bukkit-testserver/plugins"
START_STOP_SCRIPT="$SCRIPT_DIR/minecraft.sh"
BUILD_TOOLS_DIR="$BUKKIT_DIR/buildtools"
mkdir -p "$BUILD_TOOLS_DIR"
# get build tools
if [ ! -f "$BUILD_TOOLS_DIR/BuildTools.jar" ]; then
wget -O- 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar' > "$BUILD_TOOLS_DIR/BuildTools.jar"
fi
cp -f "$BUILD_TOOLS_DIR"/craftbukkit*.jar "$BUKKIT_DIR/"
# run build tools
if [ ! -f "$BUKKIT_DIR"/craftbukkit*.jar ]; then
cd "$BUILD_TOOLS_DIR"
java -jar ./BuildTools.jar
fi
echo 'eula=TRUE' > "$BUKKIT_DIR/eula.txt"
# TODO: This is a bad solution! Maven should write necessary information into an extra file.
ARTIFACT_ID="$(grep -C5 '<groupId>de.craftinc' "$SCRIPT_DIR/../pom.xml" | grep '<name>' | sed 's/[ \t]*<name>//g' | sed 's/<\/name>[ \t]*//g')"
# TODO: This is a bad solution! Maven should write necessary information into an extra file.
VERSION="$(grep -C5 '<groupId>de.craftinc' "$SCRIPT_DIR/../pom.xml" | grep '<version>' | sed 's/[ \t]*<version>//g' | sed 's/<\/version>[ \t]*//g')"
rm -rf "$PLUGIN_DIR"
mkdir -p "$PLUGIN_DIR"
cp "$SCRIPT_DIR/../target/$ARTIFACT_ID-$VERSION".jar "$PLUGIN_DIR/"
echo -e "ddidderr\nmice_on_drugs\nMochaccino" > "$BUKKIT_DIR/ops.txt"
$START_STOP_SCRIPT restart_or_start

153
src/main/java/de/craftinc/borderprotection/Border.java Normal file
View File

@ -0,0 +1,153 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public class Border implements ConfigurationSerializable
{
private static final String dataFileName = "borders.yml";
private Boolean isActive;
private static String isActiveKey = "enabled";
private Location rectPoint1;
private static String rectPoint1Name = "p1";
private Location rectPoint2;
private static String rectPoint2Name = "p2";
private static String rectBordersKey = "rectBorders";
private static final HashMap<World, Border> borders = new HashMap<World, Border>();
private static File bordersFile = new File(Plugin.getPlugin().getDataFolder(), dataFileName);
private static FileConfiguration bordersFileConf = YamlConfiguration.loadConfiguration(bordersFile);
public static HashMap<World, Border> getBorders()
{
return borders;
}
public Location getRectPoint1()
{
return rectPoint1;
}
public Location getRectPoint2()
{
return rectPoint2;
}
public Boolean isActive()
{
return isActive;
}
@SuppressWarnings("unchecked unused")
public Border( Map<String, Object> map )
{
try
{
rectPoint1 = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(rectPoint1Name));
rectPoint2 = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(rectPoint2Name));
isActive = (Boolean) map.get(isActiveKey);
if ( rectPoint1.getWorld().equals(rectPoint2.getWorld()) )
{
borders.put(rectPoint1.getWorld(), this);
}
else
{
throw new Exception("Border points are at different worlds.");
}
}
catch ( Exception e )
{
Plugin.getPlugin().getLogger().severe(e.getMessage());
}
}
public Border( Location p1, Location p2 ) throws Exception
{
rectPoint1 = p1;
rectPoint2 = p2;
// new border is active by default
isActive = true;
if ( rectPoint1.getWorld().equals(rectPoint2.getWorld()) )
{
borders.put(rectPoint1.getWorld(), this);
}
else
{
throw new Exception("Border points are at different worlds.");
}
}
@SuppressWarnings("unused")
public Map<String, Object> serialize()
{
Map<String, Object> map = new HashMap<String, Object>();
map.put(rectPoint1Name, LocationSerializer.serializeLocation(rectPoint1));
map.put(rectPoint2Name, LocationSerializer.serializeLocation(rectPoint2));
map.put(isActiveKey, isActive);
return map;
}
public static void loadBorders()
{
bordersFileConf.getList(rectBordersKey);
}
public static void saveBorders() throws IOException
{
bordersFileConf.set(rectBordersKey, new ArrayList<Object>(borders.values()));
bordersFileConf.save(bordersFile);
}
public String toString()
{
return rectPoint1.getX() + "," + rectPoint1.getZ() + " " + rectPoint2.getX() + "," + rectPoint2.getZ();
}
public void enable()
{
isActive = true;
}
public void disable()
{
isActive = false;
}
}

172
src/main/java/de/craftinc/borderprotection/BorderManager.java Normal file
View File

@ -0,0 +1,172 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import java.util.Calendar;
import java.util.HashMap;
public class BorderManager
{
/**
* *********************************************************
* GLOBAL VARIABLES
* **********************************************************
*/
/**
* For every player save the time when he got the last borderMessage
*/
public HashMap<String, Long> lastBorderMessage = new HashMap<String, Long>();
/**
* The buffer in blocks which applies when a player is teleported inside the border. 0 means the player
* will be teleported directly to the border.
*/
public static final double buffer = 0.5;
/**
* A timeout for the border message. When a player tries to cross the border and sees the border message,
* the earliest possible time the message will show up again is after <code>timeout</code> milliseconds.
*/
public static final Long timeout = 10000L;
/**
* *********************************************************
* CONSTRUCTOR
* **********************************************************
*/
public BorderManager()
{
// load borders
Border.loadBorders();
}
/**
* *********************************************************
* GETTERS AND SETTERS
* **********************************************************
*/
public void setBorder( World world, double border ) throws Exception
{
new Border(new Location(world, border, 0, border), new Location(world, -border, 0, -border));
}
public void setBorder( World world, String p1, String p2 ) throws Exception
{
String[] coordinatesP1 = p1.split(",");
Location l1 = new Location(world, Double.parseDouble(coordinatesP1[0]), 0, Double.parseDouble(coordinatesP1[1]));
String[] coordinatesP2 = p2.split(",");
Location l2 = new Location(world, Double.parseDouble(coordinatesP2[0]), 0, Double.parseDouble(coordinatesP2[1]));
new Border(l1, l2);
}
/**
* Checks if the given location is inside the border rectangle. Returns null if yes, otherwise new coordinates.
*
* @param location location to check
* @param border Border object which defines the border
* @param buffer if the player will be teleported back, then he will be <code>buffer</code> far away
* from the border he tried to cross
* @return null if the player is inside, otherwise a new player location
*/
public Double[] checkBorder( Location location, Border border, double buffer )
{
// New x and z: null by default
Double[] newXZ = { null, null };
// check if player is withing the X borders
newXZ[0] = _checkBorder(location.getX(), border.getRectPoint1().getX(), border.getRectPoint2().getX(), buffer);
// check if player is withing the Z borders
newXZ[1] = _checkBorder(location.getZ(), border.getRectPoint1().getZ(), border.getRectPoint2().getZ(), buffer);
// Do nothing, if no new coordinates have been calculated.
if ( newXZ[0] == null && newXZ[1] == null )
{
return null;
}
return newXZ;
}
/**
* Checks if the given location is between one specific border pair.
*
* @param location part of the location coordinates
* @param border1 one side of the rectangle
* @param border2 opposite side of the rectangle
* @return null if the location is inside, otherwise a new location
*/
public Double _checkBorder( double location, double border1, double border2, double buffer )
{
double bigBorder = Math.max(border1, border2);
double smallBorder = Math.min(border1, border2);
// if location is between borders do nothing
if ( location >= smallBorder && location <= bigBorder )
{
return null;
}
else
{
if ( location > bigBorder )
{
// if location is outside of the bigBorder, teleport to the bigBorder
return bigBorder - buffer;
}
else
{
// if location is outside of the smallBorder, teleport to the smallBorder
return smallBorder + buffer;
}
}
}
/**
* Show the border message to a player and respect the timeout.
*
* @param player Player who will see the border message.
*/
public void showMessageWithTimeout( Player player, String message )
{
// get the current time
Long now = Calendar.getInstance().getTimeInMillis();
if ( ( lastBorderMessage.get(player.getName()) != null &&
now - timeout > lastBorderMessage.get(player.getName()) ) ||
lastBorderMessage.get(player.getName()) == null )
{
// show message
player.sendMessage(message);
// set last sent message for this player to now
lastBorderMessage.put(player.getName(), now);
}
}
}

173
src/main/java/de/craftinc/borderprotection/Commands.java Normal file
View File

@ -0,0 +1,173 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.io.IOException;
public class Commands implements CommandExecutor
{
private BorderManager borderManager;
public Commands( BorderManager borderManager )
{
this.borderManager = borderManager;
}
@Override
public boolean onCommand( CommandSender sender, Command command, String label, String[] args )
{
// Check if command comes from a player.
if ( !( sender instanceof Player ) )
{
sender.sendMessage(Messages.commandIssuedByNonPlayer);
return true;
}
// command for all actions
if ( command.getName().equalsIgnoreCase("cibp") )
{
// help
if ( args.length == 0 || ( args.length > 0 && args[0].equalsIgnoreCase("help") ) )
{
sender.sendMessage(Messages.helpGeneral);
return true;
}
// set
if ( ( args.length == 2 || args.length == 3 ) && args[0].equalsIgnoreCase("set") )
{
if ( !sender.hasPermission("craftinc.borderprotection.set") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
// set <distance>
if ( args.length == 2 )
{
try
{
borderManager.setBorder(( (Player) sender ).getWorld(), Double.parseDouble(args[1]));
Border border = Border.getBorders().get(world);
sender.sendMessage(Messages.borderCreationSuccessful);
sender.sendMessage(Messages.borderInfo(world.getName(), border.toString(), border.isActive()));
}
catch ( Exception e )
{
sender.sendMessage(e.getMessage());
}
}
// set <point1> <point2>
else
{
try
{
borderManager.setBorder(( (Player) sender ).getWorld(), args[1], args[2]);
Border border = Border.getBorders().get(world);
sender.sendMessage(Messages.borderCreationSuccessful);
sender.sendMessage(Messages.borderInfo(world.getName(), border.toString(), border.isActive()));
}
catch ( Exception e )
{
sender.sendMessage(e.getMessage());
}
}
// save the new border
try
{
Border.saveBorders();
}
catch ( IOException e )
{
sender.sendMessage(Messages.borderSaveException);
}
return true;
}
// get
if ( args.length == 1 && ( args[0].equalsIgnoreCase("get") || args[0].equalsIgnoreCase("info") ) )
{
World world = ( (Player) sender ).getWorld();
// exit and send the player a message if no border is set
if ( !Border.getBorders().containsKey(world) )
{
sender.sendMessage(Messages.borderInfoNoBorderSet);
return true;
}
Border border = Border.getBorders().get(world);
sender.sendMessage(Messages.borderInfo(world.getName(), border.toString(), border.isActive()));
return true;
}
// on
if ( args.length == 1 && ( args[0].equalsIgnoreCase("on") || args[0].equalsIgnoreCase("off") ) )
{
if ( !sender.hasPermission("craftinc.borderprotection.set") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
Border border = Border.getBorders().get(world);
if ( border != null )
{
if ( args[0].equalsIgnoreCase("on") )
{
border.enable();
sender.sendMessage(Messages.borderEnabled);
}
else
{
border.disable();
sender.sendMessage(Messages.borderDisabled);
}
}
else
{
sender.sendMessage(Messages.borderInfoNoBorderSet);
}
// save the new border
try
{
Border.saveBorders();
}
catch ( IOException e )
{
sender.sendMessage(Messages.borderEnableDisableException);
}
return true;
}
}
sender.sendMessage(Messages.helpGeneral);
return false;
}
}

32
src/main/java/de/craftinc/borderprotection/util/LocationSerializer2D.java → src/main/java/de/craftinc/borderprotection/LocationSerializer.java
View File

@ -1,5 +1,5 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Tobias Ottenweller, Paul Schulze
Copyright (C) 2013 Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published
@ -14,9 +14,8 @@
You should have received a copy of the GNU Lesser General Public License
along with this program (LGPLv3). If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.util;
package de.craftinc.borderprotection;
import de.craftinc.borderprotection.Plugin;
import org.bukkit.Location;
import org.bukkit.World;
@ -24,16 +23,20 @@ import java.util.HashMap;
import java.util.Map;
public class LocationSerializer2D
/**
* NOTE: We do not care about yaw and pitch for gate locations. So we won't serialize them.
*/
public class LocationSerializer
{
private static final String worldKey = "world";
private static final String xKey = "x";
private static final String zKey = "z";
protected static String worldKey = "world";
protected static String xKey = "x";
protected static String yKey = "y";
protected static String zKey = "z";
private static World getWorld( String name ) throws Exception
protected static World getWorld( String name ) throws Exception
{
World world = Plugin.instance.getServer().getWorld(name);
World world = Plugin.getPlugin().getServer().getWorld(name);
if ( world == null )
{
@ -55,6 +58,7 @@ public class LocationSerializer2D
serializedLocation.put(worldKey, l.getWorld().getName());
serializedLocation.put(xKey, l.getX());
serializedLocation.put(yKey, l.getY());
serializedLocation.put(zKey, l.getZ());
return serializedLocation;
@ -73,21 +77,27 @@ public class LocationSerializer2D
// verbose loading of coordinates (they might be Double or Integer)
Object objX = map.get(xKey);
Object objY = map.get(yKey);
Object objZ = map.get(zKey);
double x, z;
double x, y, z;
if ( objX instanceof Integer )
x = (double) (Integer) objX;
else
x = (Double) objX;
if ( objY instanceof Integer )
y = (double) (Integer) objY;
else
y = (Double) objY;
if ( objZ instanceof Integer )
z = (double) (Integer) objZ;
else
z = (Double) objZ;
return new Location(w, x, 0d, z);
return new Location(w, x, y, z);
}
}

135
src/main/java/de/craftinc/borderprotection/Messages.java
View File

@ -1,5 +1,5 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -16,24 +16,12 @@
*/
package de.craftinc.borderprotection;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.ChatColor;
import org.bukkit.entity.Player;
import java.util.Calendar;
import java.util.HashMap;
public class Messages
{
private static final String NEWLINE = "\n";
private static final String pluginName = Plugin.instance.getDescription().getName();
/**
* For every player and every message of that player save the time when he got the last one.
*/
private static final HashMap<String, HashMap<String, Long>> lastMessage = new HashMap<String, HashMap<String, Long>>();
private static String makeCmd( String command, String explanation, String... args )
{
StringBuilder sb = new StringBuilder();
@ -65,122 +53,77 @@ public class Messages
return sb.toString();
}
private static final String borderExplanation =
private static String borderExplanation =
"One day the holy mods and administrators will expand the border. It is then your mission to explore " +
"strange new worlds, to seek out new life and new civilizations, to boldly go where no one has gone before.";
public static final String borderMessage =
ChatColor.YELLOW + "Sorry Dude! " +
ChatColor.WHITE + "This is the border... the final frontier! " + borderExplanation + NEWLINE +
public static String borderMessage =
"Sorry Dude! This is the border... the final frontier! " + borderExplanation + NEWLINE +
makeCmd("/cibp get", "shows the borders of the current world");
public static final String borderTeleportMessage =
ChatColor.YELLOW + "Sorry Dude! " +
ChatColor.WHITE + "You cannot teleport outside the border. " + borderExplanation + NEWLINE +
public static String borderTeleportMessage =
"Sorry Dude! You cannot teleport outside the border. " + borderExplanation + NEWLINE +
makeCmd("/cibp get", "shows the borders of the current world");
public static final String helpGeneral =
ChatColor.GREEN + pluginName + " - Usage:" + NEWLINE +
ChatColor.WHITE + "Commands are always related to the current world." + NEWLINE +
public static String helpGeneral =
ChatColor.GREEN + "CraftInc BorderProtection - Usage:" + NEWLINE +
makeCmd("help", "shows this help") +
makeCmd("get | info", "Shows information about the border.") +
makeCmd("generate", "Generate all not existing chunks inside the border.") +
makeCmd("cancelgenerate", "Cancels the generation of chunks.") +
makeCmd("on | off", "Enables/disables the border.") +
makeCmd("set", "Square border with distance (d) from 0,0.", "r", "<d>") +
makeCmd("set", "Rectangle defined by two points. Point=x,z.", "r", "<p1>", "<p2>") +
makeCmd("set", "Circle border with radius from 0,0.", "c", "<radius>") +
makeCmd("set", "Circle defined by center and radius. Center=x,z.", "c", "<c>", "<r>");
makeCmd("get | info", "shows the border of the current world") +
makeCmd("on | off", "enables/disables the border of the current world") +
makeCmd("set", "Border rectangle edges will be this far away from point of origin.", "<integer>") +
makeCmd("set", "Border rectangle is defined by the two points. A point is specified as: x,z",
"<point1>", "<point2>");
public static final String borderCreationSuccessful
public static String borderCreationSuccessful
= ChatColor.YELLOW + "New border was set " +
ChatColor.GREEN + "successfully" +
ChatColor.YELLOW + "!";
public static final String commandIssuedByNonPlayer
= ChatColor.RED + "Only a player can use " + pluginName + " commands!";
public static String commandIssuedByNonPlayer
= ChatColor.RED + "Only a player can use CraftInc BorderProtection commands!";
public static String borderInfo( String worldName, Border border )
public static String borderInfo( String worldName, String borderDef, Boolean isBorderEnabled )
{
String borderEnabled;
if ( border.isActive() )
if (isBorderEnabled)
{
borderEnabled = ChatColor.GREEN + "enabled";
else
} else {
borderEnabled = ChatColor.RED + "disabled";
}
return ChatColor.WHITE + "Border of world " + ChatColor.YELLOW + worldName + ChatColor.WHITE + ": " + NEWLINE +
ChatColor.YELLOW + "Type: " + ChatColor.WHITE + border.getBorderTypeString() + NEWLINE +
border.getBorderInfoString() + NEWLINE +
return ChatColor.WHITE + "Borders of world " +
ChatColor.YELLOW + worldName +
ChatColor.WHITE + ": " +
ChatColor.YELLOW + borderDef + ChatColor.WHITE + "." + NEWLINE +
ChatColor.WHITE + "Border is " + borderEnabled + ChatColor.WHITE + ".";
}
public static final String borderInfoNoBorderSet =
public static String borderInfoNoBorderSet =
ChatColor.YELLOW + "No border in this world.";
public static final String noPermissionSet =
public static String noPermissionSet =
ChatColor.RED + "Sorry, you don't have permission to change the border.";
public static final String borderEnabled =
public static String borderEnabled =
ChatColor.YELLOW + "Border enabled.";
public static final String borderDisabled =
public static String borderDisabled =
ChatColor.YELLOW + "Border disabled.";
public static final String borderSaveException =
public static String borderSaveException =
ChatColor.RED + "Error: Could not save border on server. After the next reload this border will be lost!";
public static final String borderEnableDisableException =
ChatColor.RED +
"Error: Could not save border state on server. After the next reload this border state will be lost!";
public static String borderEnableDisableException =
ChatColor.RED + "Error: Could not save border state on server. After the next reload this border state will be lost!";
public static final String generationCanceled =
ChatColor.GREEN + "World generation canceled!";
public static final String generationNotCanceled =
ChatColor.RED + "No world generation happening. Cannot cancel!";
public static final String generationAlreadyInProgress =
ChatColor.YELLOW +
"World generation is already in progress. It will continue after all players are logged out.";
public static final String generationStarted =
ChatColor.GREEN + "World generation will start after all players left the server.";
public static final String generationCouldNotBeStarted =
ChatColor.RED + "Could not start world generation! Is there a border?";
/**
* Display a message to a player and then wait for timeout seconds before displaying it again.
*
* @param player Player who will see the message.
* @param message The message String.
* @param timeout Timeout in seconds until the message will be displayed earliest.
*/
public static void showMessageWithTimeout( final Player player, final String message, final Integer timeout )
public static String UpdateMessage( String newVersion, String curVersion )
{
// get the current time
final Long now = Calendar.getInstance().getTimeInMillis();
if ( ( lastMessage.get(player.getName()) != null && lastMessage.get(player.getName()).get(message) != null &&
now - timeout * 1000 > lastMessage.get(player.getName()).get(message) ) ||
lastMessage.get(player.getName()) != null && lastMessage.get(player.getName()).get(message) == null ||
lastMessage.get(player.getName()) == null )
{
// show message
player.sendMessage(message);
// set last sent message for this player to now
if ( lastMessage.get(player.getName()) == null )
{
lastMessage.put(player.getName(), new HashMap<String, Long>()
{{
put(message, now);
}});
}
else
{
lastMessage.get(player.getName()).put(message, now);
}
}
return ChatColor.RED + "Craft Inc. BorderProtection: New version available!" + NEWLINE +
ChatColor.YELLOW + "Current version: " + ChatColor.WHITE + curVersion + NEWLINE +
ChatColor.YELLOW + "New version: " + ChatColor.WHITE + newVersion + NEWLINE +
ChatColor.YELLOW + "Please visit:" + NEWLINE +
ChatColor.AQUA + "http://dev.bukkit.org/server-mods/craftinc-borderprotection" + NEWLINE +
ChatColor.YELLOW + "to get the latest version!";
}
}

50
src/main/java/de/craftinc/borderprotection/PlayerLoginListener.java Normal file
View File

@ -0,0 +1,50 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerLoginEvent;
public class PlayerLoginListener implements Listener
{
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin( PlayerLoginEvent e )
{
final Player player = e.getPlayer();
if ( e.getPlayer().hasPermission("craftinc.borderprotection.update") )
{
if ( UpdateHelper.newVersionAvailable() )
{
// Schedule a task which delays 20 ticks (1 second) and then sends a message to the player
Bukkit.getScheduler().scheduleSyncDelayedTask(Plugin.getPlugin(), new Runnable()
{
@Override
public void run()
{
player.sendMessage(Messages.UpdateMessage(UpdateHelper.cachedLatestVersion,
UpdateHelper.getCurrentVersion()));
}
}, 20L);
}
}
}
}

128
src/main/java/de/craftinc/borderprotection/PlayerMoveListener.java Normal file
View File

@ -0,0 +1,128 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
public class PlayerMoveListener implements Listener
{
private BorderManager borderManager;
public PlayerMoveListener( BorderManager borderManager )
{
this.borderManager = borderManager;
}
private Double goUpUntilFreeSpot( Location newLocation )
{
// go up in height until the player can stand in AIR
Block footBlock = newLocation.getBlock();
Block headBlock = newLocation.getBlock().getRelative(BlockFace.UP);
while ( footBlock.getType() != Material.AIR || headBlock.getType() != Material.AIR )
{
byte offset = 1;
if ( headBlock.getType() != Material.AIR )
{
offset = 2;
}
footBlock = footBlock.getRelative(0, offset, 0);
headBlock = headBlock.getRelative(0, offset, 0);
}
// set the y value to a spot where the player can stand free
return (double) footBlock.getY();
}
@SuppressWarnings("unused")
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerMove( PlayerMoveEvent e )
{
// do nothing if the event is already cancelled
if (e.isCancelled())
{
return;
}
// do nothing if player has the ignoreborders permission
if ( e.getPlayer().hasPermission("craftinc.borderprotection.ignoreborders") )
{
return;
}
// do nothing if there are no border definitions at all
if ( Border.getBorders().isEmpty() )
{
return;
}
// player location
Location playerLocation = e.getPlayer().getLocation();
// world where the player is in
World world = e.getPlayer().getWorld();
// border of this world
Border border = Border.getBorders().get(world);
// do nothing if there are no borders for this specific world
if ( border == null )
{
return;
}
// do nothing if border is disabled
if ( !border.isActive() )
{
return;
}
// change x or z. default: do not change
Double[] newXZ;
// check if player is inside the borders. null if yes, otherwise a tuple which defines the new player position
newXZ = borderManager.checkBorder(playerLocation, border, BorderManager.buffer);
// Do nothing, if no new coordinates have been calculated.
if ( newXZ == null )
{
return;
}
// if one of the coordinates is null, set it to the player's value
newXZ[0] = newXZ[0] == null ? playerLocation.getX() : newXZ[0];
newXZ[1] = newXZ[1] == null ? playerLocation.getZ() : newXZ[1];
// change Y if necessary (when there is no free spot)
Double newY = goUpUntilFreeSpot(new Location(world, newXZ[0], e.getPlayer().getLocation().getY(), newXZ[1]));
// teleport the player to the new X and Z coordinates
e.getPlayer().teleport(
new Location(e.getPlayer().getWorld(), newXZ[0], newY, newXZ[1], playerLocation.getYaw(),
playerLocation.getPitch()));
// send a message to the player
borderManager.showMessageWithTimeout(e.getPlayer(), Messages.borderMessage);
}
}

39
src/main/java/de/craftinc/borderprotection/events/PlayerTeleportListener.java → src/main/java/de/craftinc/borderprotection/PlayerTeleportListener.java
View File

@ -1,5 +1,5 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -14,10 +14,8 @@
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.events;
package de.craftinc.borderprotection;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
@ -27,12 +25,19 @@ import org.bukkit.event.player.PlayerTeleportEvent;
public class PlayerTeleportListener implements Listener
{
private BorderManager borderManager;
public PlayerTeleportListener( BorderManager borderManager )
{
this.borderManager = borderManager;
}
@SuppressWarnings("unused")
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerTeleport( PlayerTeleportEvent e )
@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerMove( PlayerTeleportEvent e )
{
// do nothing if the event is already cancelled
if ( e.isCancelled() )
if (e.isCancelled())
{
return;
}
@ -64,22 +69,24 @@ public class PlayerTeleportListener implements Listener
return;
}
// do nothing if rectBorder is disabled
// do nothing if border is disabled
if ( !border.isActive() )
{
return;
}
// check if player is inside the borders and get a new location if not
Location destination = border.checkBorder(targetLocation);
// change x or z. default: do not change
Double[] newXZ;
// Do nothing, if no new location has been calculated.
if ( destination == null )
// check if target is inside the borders. null if yes, otherwise a tuple which defines the new position
newXZ = borderManager.checkBorder(targetLocation, border, BorderManager.buffer);
// Cancel event, if new coordinates have been calculated.
if ( newXZ != null )
{
return;
}
e.setCancelled(true);
Messages.showMessageWithTimeout(e.getPlayer(), Messages.borderTeleportMessage, 10);
borderManager.showMessageWithTimeout(e.getPlayer(), Messages.borderTeleportMessage);
}
}
}

37
src/main/java/de/craftinc/borderprotection/Plugin.java
View File

@ -1,5 +1,5 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
@ -16,26 +16,23 @@
*/
package de.craftinc.borderprotection;
import de.craftinc.borderprotection.borders.CircBorder;
import de.craftinc.borderprotection.borders.RectBorder;
import de.craftinc.borderprotection.commands.CommandSwitch;
import de.craftinc.borderprotection.events.PlayerJoinListener;
import de.craftinc.borderprotection.events.PlayerMoveListener;
import de.craftinc.borderprotection.events.PlayerQuitListener;
import de.craftinc.borderprotection.events.PlayerTeleportListener;
import org.bukkit.configuration.serialization.ConfigurationSerialization;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
public class Plugin extends JavaPlugin
{
public static Plugin instance;
private static JavaPlugin cibpPlugin;
public static JavaPlugin getPlugin()
{
return cibpPlugin;
}
@Override
public void onLoad()
{
ConfigurationSerialization.registerClass(RectBorder.class);
ConfigurationSerialization.registerClass(CircBorder.class);
ConfigurationSerialization.registerClass(Border.class);
}
@Override
@ -46,23 +43,21 @@ public class Plugin extends JavaPlugin
@Override
public void onEnable()
{
Plugin.instance = this;
Plugin.cibpPlugin = this;
// create listeners
PlayerMoveListener playerMoveListener = new PlayerMoveListener();
PlayerTeleportListener playerTeleportListener = new PlayerTeleportListener();
PlayerJoinListener playerJoinListener = new PlayerJoinListener();
PlayerQuitListener playerQuitListener = new PlayerQuitListener();
BorderManager borderManager = new BorderManager();
PlayerMoveListener playerMoveListener = new PlayerMoveListener(borderManager);
PlayerTeleportListener playerTeleportListener = new PlayerTeleportListener(borderManager);
PlayerLoginListener playerLoginListener = new PlayerLoginListener();
// commands
CommandSwitch commandExecutor = new CommandSwitch();
Commands commandExecutor = new Commands(borderManager);
getCommand("cibp").setExecutor(commandExecutor);
// register listeners
// listeners
PluginManager pm = this.getServer().getPluginManager();
pm.registerEvents(playerMoveListener, this);
pm.registerEvents(playerTeleportListener, this);
pm.registerEvents(playerJoinListener, this);
pm.registerEvents(playerQuitListener, this);
pm.registerEvents(playerLoginListener, this);
}
}

98
src/main/java/de/craftinc/borderprotection/UpdateHelper.java Normal file
View File

@ -0,0 +1,98 @@
/* Craft Inc. BorderProtection
Copyright (C) 2013 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
public class UpdateHelper
{
/**
* The URL from which the Plugin tries to get the latest version.
*/
@SuppressWarnings("FieldCanBeLocal")
private static final String updateUrl = "http://www.craftinc.de/plugins/update/craftinc-borderprotection";
/**
* The latest version which was seen on last check.
*/
public static String cachedLatestVersion = null;
/**
* Gets the latest version from the updateURL and returns it as <code>String</code>.
*
* @return latest version as <code>String</code>.
*/
@SuppressWarnings("StringBufferMayBeStringBuilder")
public static String getLatestVersion()
{
// StringBuffer is thread-safe. Don't know if this is really important here, but safe is safe :).
StringBuffer s = new StringBuffer();
try
{
URLConnection c = new URL(updateUrl).openConnection();
BufferedReader br = new BufferedReader(new InputStreamReader(c.getInputStream()));
String inputLine;
while ( ( inputLine = br.readLine() ) != null )
{
s.append(inputLine);
}
br.close();
}
catch ( MalformedURLException e )
{
Plugin.getPlugin().getLogger().warning("Could not check for latest version. Update URL is malformed.");
}
catch ( IOException e )
{
Plugin.getPlugin().getLogger().warning("Could not check for latest version. Update URL was not readable.");
}
// update cached latest version
cachedLatestVersion = s.toString();
return s.toString();
}
/**
* Gets the current version of this plugin directly from the plugin.yml version entry.
*
* @return current version as <code>String</code>.
*/
public static String getCurrentVersion()
{
return Plugin.getPlugin().getDescription().getVersion();
}
/**
* Checks if a newer version is available.
*
* @return Boolean
*/
public static Boolean newVersionAvailable()
{
return !getCurrentVersion().equals(getLatestVersion());
}
}

145
src/main/java/de/craftinc/borderprotection/borders/Border.java
View File

@ -1,145 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.borders;
import de.craftinc.borderprotection.Plugin;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
public abstract class Border
{
private static final String dataFileName = "borders.yml";
private Boolean isActive;
private static final String isActiveKey = "enabled";
private static final String bordersKey = "borders";
static final HashMap<World, Border> borders = new HashMap<World, Border>();
private static final File bordersFile = new File(Plugin.instance.getDataFolder(), dataFileName);
private static final FileConfiguration bordersFileConf = YamlConfiguration.loadConfiguration(bordersFile);
/**
* The buffer in blocks which applies when a player is teleported inside the border. 0 means the player
* will be teleported directly to the border.
*/
static final double buffer = 0.5;
public static HashMap<World, Border> getBorders()
{
return borders;
}
/**
* Returns a String which identifies the type of the border. Example: Rectangle
*/
public abstract String getBorderTypeString();
/**
* Returns a formatted String (colors and newlines) which fits into the borderInfo message and describes
* the border properties properly.
*/
public abstract String getBorderInfoString();
/**
* Checks if the given location is inside or outside the border. If it is outside a new location (inside the border)
* is returned, otherwise null.
*
* @param l Location to check if inside the border
* @return null if l is inside the border otherwise a new Location which is inside
*/
public Location checkBorder( Location l )
{
return checkBorder(l, 0.0);
}
/**
* Checks if the given location is inside or outside the border. If it is outside a new location (inside the border)
* is returned, otherwise null. Applies padding to the border. (Simulates a larger border using padding.)
*
* @param l Location to check if inside the border
* @param padding number of Blocks of padding applied to the border.
* @return null if l is inside the border otherwise a new Location which is inside
*/
public abstract Location checkBorder( Location l, double padding );
/**
* Returns an array of two Location objects defining a rectangle bigger or at size of the border. There are no
* locations outside the rectangle which are inside the border.
*/
public abstract Location[] getSurroundingRect();
public Boolean isActive()
{
return isActive;
}
Border( Map<String, Object> map )
{
try
{
isActive = (Boolean) map.get(isActiveKey);
}
catch ( Exception e )
{
// FIXME
Plugin.instance.getLogger().severe(e.getMessage());
}
}
Border()
{
// new borders are enabled by default
isActive = true;
}
@SuppressWarnings("unused")
public static void loadBorders()
{
bordersFileConf.getList(bordersKey);
}
public static void saveBorders() throws IOException
{
bordersFileConf.set(bordersKey, new ArrayList<Object>(borders.values()));
bordersFileConf.save(bordersFile);
}
public void enable()
{
isActive = true;
}
public void disable()
{
isActive = false;
}
void serialize( Map<String, Object> map )
{
map.put(isActiveKey, isActive);
}
}

134
src/main/java/de/craftinc/borderprotection/borders/CircBorder.java
View File

@ -1,134 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.borders;
import de.craftinc.borderprotection.Plugin;
import de.craftinc.borderprotection.util.LocationSerializer2D;
import de.craftinc.borderprotection.util.PlayerMovementUtil;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import java.util.HashMap;
import java.util.Map;
public class CircBorder extends Border implements ConfigurationSerializable
{
private Double radius;
private Location center;
private static final String centerKey = "center";
private static final String radiusKey = "radius";
@SuppressWarnings("unchecked unused")
public CircBorder( Map<String, Object> map )
{
super(map);
try
{
center = LocationSerializer2D.deserializeLocation((Map<String, Object>) map.get(centerKey));
radius = (Double) map.get(radiusKey);
borders.put(center.getWorld(), this);
}
catch ( Exception e )
{
// FIXME
Plugin.instance.getLogger().severe(e.getMessage());
}
}
public CircBorder( Location center, Double radius )
{
super();
this.center = center;
this.radius = radius;
borders.put(center.getWorld(), this);
}
@SuppressWarnings("unused")
public Map<String, Object> serialize()
{
Map<String, Object> map = new HashMap<String, Object>();
super.serialize(map);
map.put(centerKey, LocationSerializer2D.serializeLocation(center));
map.put(radiusKey, radius);
return map;
}
public String toString()
{
return "CircBorder(" + "center: " + center.getX() + "," + center.getZ() + ", radius: " + radius + ")";
}
@Override
public String getBorderTypeString()
{
return "Circle";
}
@Override
public String getBorderInfoString()
{
return ChatColor.YELLOW + "Center: " + ChatColor.WHITE + center.getX() + "," + center.getZ() + "\n" +
ChatColor.YELLOW + "Raduis: " + ChatColor.WHITE + radius;
}
@Override
public Location checkBorder( Location l, double padding )
{
double paddedRadius = radius + padding;
double distX = l.getX() - center.getX();
double distZ = l.getZ() - center.getZ();
double distanceFromCenterSquared = distX * distX + distZ * distZ;
double radiusSquared = paddedRadius * paddedRadius;
// inside the border
if ( distanceFromCenterSquared <= radiusSquared )
{
return null;
}
// outside the border: it's ok to use square-root function here, because this only happens very few times
double ratio = paddedRadius / Math.sqrt(distanceFromCenterSquared);
double newX = center.getX() + ( ratio * distX );
double newZ = center.getZ() + ( ratio * distZ );
Location newLocation = new Location(l.getWorld(), newX, l.getY(), newZ, l.getYaw(), l.getPitch());
// ensure that the player will not appear in a block
// TODO: Should hook into another Plugin maybe or implement something better
newLocation.setY(PlayerMovementUtil.goUpUntilFreeSpot(newLocation));
return newLocation;
}
@Override
public Location[] getSurroundingRect()
{
Location l1 = new Location(center.getWorld(), center.getX() + radius, center.getY(), center.getX() + radius);
Location l2 = new Location(center.getWorld(), center.getX() - radius, center.getY(), center.getX() - radius);
return new Location[] { l1, l2 };
}
}

184
src/main/java/de/craftinc/borderprotection/borders/RectBorder.java
View File

@ -1,184 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.borders;
import de.craftinc.borderprotection.Plugin;
import de.craftinc.borderprotection.util.LocationSerializer2D;
import de.craftinc.borderprotection.util.PlayerMovementUtil;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import java.util.HashMap;
import java.util.Map;
public class RectBorder extends Border implements ConfigurationSerializable
{
private Location rectPoint1;
private Location rectPoint2;
private static final String rectPoint1Name = "p1";
private static final String rectPoint2Name = "p2";
@SuppressWarnings("unchecked unused")
public RectBorder( Map<String, Object> map )
{
super(map);
try
{
rectPoint1 = LocationSerializer2D.deserializeLocation((Map<String, Object>) map.get(rectPoint1Name));
rectPoint2 = LocationSerializer2D.deserializeLocation((Map<String, Object>) map.get(rectPoint2Name));
if ( rectPoint1.getWorld().equals(rectPoint2.getWorld()) )
{
borders.put(rectPoint1.getWorld(), this);
}
else
{
throw new Exception("RectBorder points are at different worlds.");
}
}
catch ( Exception e )
{
Plugin.instance.getLogger().severe(e.getMessage());
}
}
public RectBorder( Location p1, Location p2 ) throws Exception
{
super();
rectPoint1 = p1;
rectPoint2 = p2;
if ( rectPoint1.getWorld().equals(rectPoint2.getWorld()) )
{
borders.put(rectPoint1.getWorld(), this);
}
else
{
throw new Exception("RectBorder points are at different worlds.");
}
}
@SuppressWarnings("unused")
public Map<String, Object> serialize()
{
Map<String, Object> map = new HashMap<String, Object>();
super.serialize(map);
map.put(rectPoint1Name, LocationSerializer2D.serializeLocation(rectPoint1));
map.put(rectPoint2Name, LocationSerializer2D.serializeLocation(rectPoint2));
return map;
}
public String toString()
{
return "RectBorder(" + rectPoint1.getX() + "," + rectPoint1.getZ() + ";" + rectPoint2.getX() + "," +
rectPoint2.getZ() + ")";
}
@Override
public String getBorderTypeString()
{
return "Rectangle";
}
@Override
public String getBorderInfoString()
{
return ChatColor.YELLOW + "Point 1: " + ChatColor.WHITE + rectPoint1.getX() + "," + rectPoint1.getZ() + "\n" +
ChatColor.YELLOW + "Point 2: " + ChatColor.WHITE + rectPoint2.getX() + "," + rectPoint2.getZ();
}
@Override
public Location checkBorder( Location l, double padding )
{
// New x and z: null by default
Double[] newXZ = { null, null };
// check if player is withing the X borders
newXZ[0] = _checkBorder(l.getX(), this.rectPoint1.getX(), this.rectPoint2.getX(), padding);
// check if player is withing the Z borders
newXZ[1] = _checkBorder(l.getZ(), this.rectPoint1.getZ(), this.rectPoint2.getZ(), padding);
// Do nothing, if no new coordinates have been calculated.
if ( newXZ[0] == null && newXZ[1] == null )
{
return null;
}
// if one of the coordinates is null, set it to the player's value
newXZ[0] = newXZ[0] == null ? l.getX() : newXZ[0];
newXZ[1] = newXZ[1] == null ? l.getZ() : newXZ[1];
// new location
Location newLocation = new Location(l.getWorld(), newXZ[0], l.getY(), newXZ[1], l.getYaw(), l.getPitch());
// change Y if necessary (when there is no free spot)
newLocation.setY(PlayerMovementUtil.goUpUntilFreeSpot(newLocation));
return newLocation;
}
/**
* Checks if the given location is between one specific border pair.
*
* @param location part of the location coordinates
* @param border1 one side of the rectangle
* @param border2 opposite side of the rectangle
* @param padding a padding (number of block) used to enlarge the border
* @return null if the location is inside, otherwise a new location
*/
private static Double _checkBorder( double location, double border1, double border2, double padding )
{
double bigBorder = Math.max(border1, border2) + padding;
double smallBorder = Math.min(border1, border2) - padding;
// if location is between borders do nothing
if ( location >= smallBorder && location <= bigBorder )
{
return null;
}
else
{
if ( location > bigBorder )
{
// if location is outside of the bigBorder, teleport to the bigBorder
if ( buffer > bigBorder )
return bigBorder;
return bigBorder - buffer;
}
else
{
// if location is outside of the smallBorder, teleport to the smallBorder
if ( buffer > Math.abs(smallBorder) )
return smallBorder;
return smallBorder + buffer;
}
}
}
@Override
public Location[] getSurroundingRect()
{
return new Location[] { rectPoint1, rectPoint2 };
}
}

61
src/main/java/de/craftinc/borderprotection/commands/CancelGenerateCommand.java
View File

@ -1,61 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.util.ChunkGenerator;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
class CancelGenerateCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
if ( !sender.hasPermission("craftinc.borderprotection.generate") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
if ( !ChunkGenerator.isGenerating(world) )
{
sender.sendMessage(Messages.generationNotCanceled);
}
else
{
ChunkGenerator.cancelRender(world);
sender.sendMessage(Messages.generationCanceled);
}
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("cancelgenerate");
return names;
}
}

85
src/main/java/de/craftinc/borderprotection/commands/CommandSwitch.java
View File

@ -1,85 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.HashMap;
import java.util.Map;
public class CommandSwitch implements CommandExecutor
{
private final Map<String, SubCommand> subCommandsMap = new HashMap<String, SubCommand>();
public CommandSwitch()
{
registerCommand(new CancelGenerateCommand());
registerCommand(new GenerateCommand());
registerCommand(new GetCommand());
registerCommand(new HelpCommand());
registerCommand(new OnOffCommand());
registerCommand(new SetCommand());
}
private void registerCommand( SubCommand command )
{
for ( String commandName : command.commandNames() )
{
subCommandsMap.put(commandName, command);
}
}
public boolean onCommand( CommandSender sender, Command command, String label, String[] args )
{
// Check if command comes from a player.
if ( !( sender instanceof Player ) )
{
sender.sendMessage(Messages.commandIssuedByNonPlayer);
return true;
}
boolean success = false;
// command for all actions
if ( command.getName().equalsIgnoreCase("cibp") )
{
if ( args.length > 0 )
{
String lowerCaseSubCommandName = args[0].toLowerCase();
SubCommand subCommand = subCommandsMap.get(lowerCaseSubCommandName);
if ( subCommand != null )
{
success = subCommand.execute(sender, args);
}
}
if ( !success )
{
subCommandsMap.get("help").execute(sender, args);
}
return success;
}
return false;
}
}

66
src/main/java/de/craftinc/borderprotection/commands/GenerateCommand.java
View File

@ -1,66 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.util.ChunkGenerator;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
class GenerateCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
if ( !sender.hasPermission("craftinc.borderprotection.generate") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
if ( ChunkGenerator.isGenerating(world) )
{
sender.sendMessage(Messages.generationAlreadyInProgress);
}
else
{
if ( ChunkGenerator.generate(world) )
{
sender.sendMessage(Messages.generationStarted);
}
else
{
sender.sendMessage(Messages.generationCouldNotBeStarted);
}
}
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("generate");
return names;
}
}

55
src/main/java/de/craftinc/borderprotection/commands/GetCommand.java
View File

@ -1,55 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
class GetCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
World world = ( (Player) sender ).getWorld();
// exit and send the player a message if no border is set
if ( !Border.getBorders().containsKey(world) )
{
sender.sendMessage(Messages.borderInfoNoBorderSet);
return true;
}
Border border = Border.getBorders().get(world);
sender.sendMessage(Messages.borderInfo(world.getName(), border));
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("get");
names.add("info");
return names;
}
}

40
src/main/java/de/craftinc/borderprotection/commands/HelpCommand.java
View File

@ -1,40 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.List;
public class HelpCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
sender.sendMessage(Messages.helpGeneral);
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("help");
return names;
}
}

82
src/main/java/de/craftinc/borderprotection/commands/OnOffCommand.java
View File

@ -1,82 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
class OnOffCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
if ( !sender.hasPermission("craftinc.borderprotection.set") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
Border border = Border.getBorders().get(world);
if ( border != null )
{
if ( parameters[0].equalsIgnoreCase("on") )
{
border.enable();
sender.sendMessage(Messages.borderEnabled);
}
else
{
border.disable();
sender.sendMessage(Messages.borderDisabled);
}
}
else
{
sender.sendMessage(Messages.borderInfoNoBorderSet);
}
// save the changed border
try
{
Border.saveBorders();
}
catch ( IOException e )
{
sender.sendMessage(Messages.borderEnableDisableException);
}
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("on");
names.add("off");
return names;
}
}

142
src/main/java/de/craftinc/borderprotection/commands/SetCommand.java
View File

@ -1,142 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.borders.Border;
import de.craftinc.borderprotection.borders.CircBorder;
import de.craftinc.borderprotection.borders.RectBorder;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
class SetCommand implements SubCommand
{
public boolean execute( CommandSender sender, String[] parameters )
{
if ( !( parameters.length == 3 || parameters.length == 4 ) )
{
return false;
}
if ( !sender.hasPermission("craftinc.borderprotection.set") )
{
sender.sendMessage(Messages.noPermissionSet);
return false;
}
World world = ( (Player) sender ).getWorld();
// set [r|c] <distance>
if ( parameters.length == 3 )
{
try
{
Double distance = Double.parseDouble(parameters[2]);
Border newBorder = null;
// rect border
if ( parameters[1].equalsIgnoreCase("r") )
{
newBorder = new RectBorder(new Location(world, distance, 0, distance),
new Location(world, -distance, 0, -distance));
}
// circ border
else if ( parameters[1].equalsIgnoreCase("c") )
{
newBorder = new CircBorder(new Location(world, 0, 0, 0), distance);
}
if ( newBorder != null )
{
sender.sendMessage(Messages.borderCreationSuccessful);
sender.sendMessage(
Messages.borderInfo(world.getName(), newBorder));
}
}
catch ( Exception e )
{
sender.sendMessage(e.getMessage());
}
}
// set r <point1> <point2> | set c <center> <radius>
else
{
try
{
Border newBorder = null;
// rect border
if ( parameters[1].equalsIgnoreCase("r") )
{
Double p1X = Double.parseDouble(parameters[2].split(",")[0]);
Double p1Z = Double.parseDouble(parameters[2].split(",")[1]);
Double p2X = Double.parseDouble(parameters[3].split(",")[0]);
Double p2Z = Double.parseDouble(parameters[3].split(",")[1]);
newBorder = new RectBorder(new Location(world, p1X, 0, p1Z),
new Location(world, p2X, 0, p2Z));
}
// circ border
else if ( parameters[1].equalsIgnoreCase("c") )
{
Double centerX = Double.parseDouble(parameters[2].split(",")[0]);
Double centerZ = Double.parseDouble(parameters[2].split(",")[1]);
Double radius = Double.parseDouble(parameters[3]);
newBorder = new CircBorder(new Location(world, centerX, 0, centerZ), radius);
}
if ( newBorder != null )
{
sender.sendMessage(Messages.borderCreationSuccessful);
sender.sendMessage(
Messages.borderInfo(world.getName(), newBorder));
}
}
catch ( Exception e )
{
sender.sendMessage(e.getMessage());
}
}
// save the new border
try
{
Border.saveBorders();
}
catch ( IOException e )
{
sender.sendMessage(Messages.borderSaveException);
}
return true;
}
public List<String> commandNames()
{
ArrayList<String> names = new ArrayList<String>();
names.add("set");
return names;
}
}

38
src/main/java/de/craftinc/borderprotection/commands/SubCommand.java
View File

@ -1,38 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.commands;
import org.bukkit.command.CommandSender;
import java.util.List;
interface SubCommand
{
/**
* @param sender The sender (player) who executed the command.
* @param parameters All parameters for executing this subcommand. Includes the subcommand name at index 0.
* @return Returns an boolean indicating if the subcommand got could be executed.
*/
boolean execute( CommandSender sender, String[] parameters );
/**
* Returns a list of names of the command. All strings should be lowercase!
*/
List<String> commandNames();
}

33
src/main/java/de/craftinc/borderprotection/events/PlayerJoinListener.java
View File

@ -1,33 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.events;
import de.craftinc.borderprotection.util.ChunkGenerator;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
public class PlayerJoinListener implements Listener
{
@SuppressWarnings("unused")
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerLogin( PlayerJoinEvent e )
{
ChunkGenerator.pause();
}
}

90
src/main/java/de/craftinc/borderprotection/events/PlayerMoveListener.java
View File

@ -1,90 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.events;
import de.craftinc.borderprotection.Messages;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerMoveEvent;
public class PlayerMoveListener implements Listener
{
@SuppressWarnings("unused")
@EventHandler(priority = EventPriority.LOWEST)
public void onPlayerMove( PlayerMoveEvent e )
{
// do nothing if the event is already cancelled
if ( e.isCancelled() )
{
return;
}
// do nothing if player has the ignoreborders permission
if ( e.getPlayer().hasPermission("craftinc.borderprotection.ignoreborders") )
{
return;
}
// do nothing if there are no border definitions at all
if ( Border.getBorders().isEmpty() )
{
return;
}
// player location
Location playerLocation = e.getPlayer().getLocation();
// world where the player is in
World world = e.getPlayer().getWorld();
// Border of this world
Border border = Border.getBorders().get(world);
// do nothing if there are no borders for this specific world
if ( border == null )
{
return;
}
// do nothing if border is disabled
if ( !border.isActive() )
{
return;
}
// check if player is inside the borders and get a new location if not
Location destination = border.checkBorder(playerLocation);
// Do nothing, if no new location has been calculated.
if ( destination == null )
{
return;
}
// teleport the player to the new location within the borders
e.getPlayer().teleport(destination);
// send a message to the player
Messages.showMessageWithTimeout(e.getPlayer(), Messages.borderMessage, 10);
}
}

37
src/main/java/de/craftinc/borderprotection/events/PlayerQuitListener.java
View File

@ -1,37 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.events;
import de.craftinc.borderprotection.Plugin;
import de.craftinc.borderprotection.util.ChunkGenerator;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerQuitEvent;
public class PlayerQuitListener implements Listener
{
@SuppressWarnings("unused")
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerQuit( PlayerQuitEvent e )
{
if ( Plugin.instance.getServer().getOnlinePlayers().size() == 1 )
{
ChunkGenerator.resume();
}
}
}

289
src/main/java/de/craftinc/borderprotection/util/ChunkGenerator.java
View File

@ -1,289 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.util;
import de.craftinc.borderprotection.Plugin;
import de.craftinc.borderprotection.borders.Border;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.World;
import java.util.Calendar;
import java.util.HashMap;
public class ChunkGenerator
{
private static final HashMap<World, Integer[]> chunkGenerationStatus = new HashMap<World, Integer[]>();
private static boolean isPaused = true;
private static final HashMap<World, Long> lastGenerationLogTime = new HashMap<World, Long>();
private static final long waitTicks = 5; // TODO: make adjustable via config file
private static final int batchGenerationSize = 5; //TODO: make adjustable via config file
private static final int paddingChunksAroundBorder = 15; // TODO: make adjustable via config file
public static void pause()
{
isPaused = true;
}
public static void resume()
{
if ( isPaused )
{
isPaused = false;
for ( World w : chunkGenerationStatus.keySet() )
{
slowLoadNextChunk(w);
}
}
}
public static void cancelRender( World w )
{
if ( w == null )
{
throw new IllegalArgumentException("World 'w' must not be null!");
}
chunkGenerationStatus.remove(w);
}
public static boolean isGenerating( World w )
{
if ( w == null )
{
throw new IllegalArgumentException("World 'w' must not be null!");
}
return chunkGenerationStatus.containsKey(w);
}
/**
* Starts the generation of all chunks inside a border.
*
* @param w The world in which chunks will be generated. Must not be 'null'. An exception will be thrown otherwise!
* @return A boolean indicating if the generation was successfully started. Will return false if no border exists
* for a given world. Will return true if the generation was already running but will not restart the generation.
*/
public static boolean generate( World w )
{
if ( w == null )
{
throw new IllegalArgumentException("World 'w' must not be null!");
}
Border border = Border.getBorders().get(w);
if ( border == null )
{
return false;
}
Location[] borderRect = border.getSurroundingRect();
int firstChunkX =
( Math.min(borderRect[0].getBlockX(), borderRect[1].getBlockX()) >> 4 ) - paddingChunksAroundBorder;
int firstChunkZ =
( Math.min(borderRect[0].getBlockZ(), borderRect[1].getBlockZ()) >> 4 ) - paddingChunksAroundBorder;
firstChunkX--;
chunkGenerationStatus.put(w, new Integer[] { firstChunkX, firstChunkZ });
// the actual generation will start when resume is called!
return true;
}
static void slowLoadNextChunk( World w )
{
if ( w == null )
{
throw new IllegalArgumentException("World 'w' must not be null!");
}
if ( isPaused )
{
return;
}
DelayedCall delayedCall = new DelayedCall();
delayedCall.w = w;
delayedCall.batchGenerationSize = batchGenerationSize;
Bukkit.getScheduler().scheduleSyncDelayedTask(Plugin.instance, delayedCall, waitTicks);
}
/**
* Will only load/generate the next chunks inside the border of the given world. Will stop if no border exists.
*/
static void loadNextChunk( World w )
{
if ( w == null )
{
throw new IllegalArgumentException("World 'w' must not be null!");
}
Border border = Border.getBorders().get(w);
if ( border == null )
{
return;
}
Integer[] lastGeneratedChunk = chunkGenerationStatus.get(w);
if ( lastGeneratedChunk == null )
{
return; // the generation got most likely canceled
}
int chunkX = lastGeneratedChunk[0];
int chunkZ = lastGeneratedChunk[1];
final Location[] borderRect = border.getSurroundingRect();
final int minChunkX =
( Math.min(borderRect[0].getBlockX(), borderRect[1].getBlockX()) >> 4 ) - paddingChunksAroundBorder;
final int minChunkZ =
( Math.min(borderRect[0].getBlockZ(), borderRect[1].getBlockZ()) >> 4 ) - paddingChunksAroundBorder;
final int maxChunkX =
( Math.max(borderRect[0].getBlockX(), borderRect[1].getBlockX()) >> 4 ) + paddingChunksAroundBorder;
final int maxChunkZ =
( Math.max(borderRect[0].getBlockZ(), borderRect[1].getBlockZ()) >> 4 ) + paddingChunksAroundBorder;
chunkX++;
while ( !chunkIsInsideBorder(chunkX, chunkZ, w, border)
&& chunkZ <= maxChunkZ )
{
chunkX++;
if ( chunkX > maxChunkX )
{
chunkZ++;
chunkX = minChunkX;
}
}
if ( chunkZ <= maxChunkZ )
{
chunkGenerationStatus.put(w, new Integer[] { chunkX, chunkZ });
Chunk chunk = w.getChunkAt(chunkX, chunkZ);
chunk.load(true);
loadSurroundingChunks(chunkX, chunkZ,
w); // this will get the server to generate trees, … inside the new chunk
logProgress(minChunkX, maxChunkX, minChunkZ, maxChunkZ, chunkX, chunkZ, w);
}
else
{
Plugin.instance.getLogger().info("Finished generating Chunks for world " + w.getName());
chunkGenerationStatus.remove(w);
}
}
private static boolean chunkIsInsideBorder( int x, int z, World w, Border b )
{
double xLoc = (double) ( x << 4 ) + 8.0;
double yLoc = 0.0;
double zLoc = (double) ( z << 4 ) + 8.0;
double padding = (double) ( paddingChunksAroundBorder << 4 );
Location l = new Location(w, xLoc, yLoc, zLoc);
return b.checkBorder(l, padding) == null;
}
private static void loadSurroundingChunks( int x, int z, World w )
{
int radius = 1;
for ( int i = -radius; i < radius; i++ )
{
for ( int j = -radius; j < radius; j++ )
{
if ( j == 0 && i == 0 )
{
continue;
}
w.loadChunk(i + x, j + z, false);
}
}
}
private static void logProgress( int minChunkX, int maxChunkX, int minChunkZ, int maxChunkZ, int chunkX,
int chunkZ, World world )
{
final Long now = Calendar.getInstance().getTimeInMillis();
final Long lastLogTime = lastGenerationLogTime.get(world);
if ( lastLogTime == null || ( now - lastLogTime ) > 30000 )
{
lastGenerationLogTime.put(world, now);
final int numXChunks, offsetX;
if ( ( ( maxChunkX > 0 ) && ( minChunkX > 0 ) ) || ( ( maxChunkX < 0 ) && ( minChunkX < 0 ) ) )
{
numXChunks = minChunkX * maxChunkX;
offsetX = 0;
}
else
{
numXChunks = Math.abs(minChunkX) + maxChunkX;
offsetX = Math.abs(minChunkX);
}
final int numZChunks, offsetZ;
if ( ( ( maxChunkZ > 0 ) && ( minChunkZ > 0 ) ) || ( ( maxChunkZ < 0 ) && ( minChunkZ < 0 ) ) )
{
numZChunks = minChunkZ * maxChunkZ;
offsetZ = 0;
}
else
{
numZChunks = Math.abs(minChunkZ) + maxChunkZ;
offsetZ = Math.abs(minChunkZ);
}
final int totalNumChunks = numXChunks * numZChunks;
final int currentChunk = ( ( offsetZ + chunkZ ) * numXChunks ) + offsetX + chunkX;
Plugin.instance.getLogger()
.info("Generation progress: " + currentChunk + "/" + totalNumChunks + " Chunks in World " +
world.getName());
}
}
}
class DelayedCall implements Runnable
{
public World w;
int batchGenerationSize;
public void run()
{
for ( int i = 0; i < batchGenerationSize; i++ )
{
ChunkGenerator.loadNextChunk(w);
}
ChunkGenerator.slowLoadNextChunk(w);
}
}

45
src/main/java/de/craftinc/borderprotection/util/PlayerMovementUtil.java
View File

@ -1,45 +0,0 @@
/* Craft Inc. BorderProtection
Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package de.craftinc.borderprotection.util;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
public class PlayerMovementUtil
{
public static Double goUpUntilFreeSpot( Location l )
{
// FIXME: Player should not be placed above lava or other harmful Materials
// go up in height until the player can stand in AIR
Block footBlock = l.getBlock();
Block headBlock = l.getBlock().getRelative(BlockFace.UP);
while ( footBlock.getType() != Material.AIR || headBlock.getType() != Material.AIR )
{
byte offset = 1;
if ( headBlock.getType() != Material.AIR )
{
offset = 2;
}
footBlock = footBlock.getRelative(0, offset, 0);
headBlock = headBlock.getRelative(0, offset, 0);
}
// return the y value to a spot where the player can stand free
return (double) footBlock.getY();
}
}

16
src/main/resources/plugin.yml
View File

@ -1,5 +1,5 @@
# Craft Inc. BorderProtection
# Copyright (C) 2016 Paul Schulze, Tobias Ottenweller
# Copyright (C) 2013 Paul Schulze, Tobias Ottenweller
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
@ -14,12 +14,12 @@
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
name: ${project.name}
name: Craft Inc. BorderProtection
main: de.craftinc.borderprotection.Plugin
version: ${project.version}
softdepend: []
softdepend: [Multiverse-Core]
authors: [ddidderr, mice_on_drugs]
website: https://www.craftinc.de/plugins/borderprotection
website: http://www.craftinc.de/plugins/borderprotection
commands:
@ -31,8 +31,8 @@ permissions:
default: op
description: Allows to set the border for a world.
craftinc.borderprotection.ignoreborders:
default: false
description: Allows to be everywhere on the map (ignoring the borders).
craftinc.borderprotection.generate:
default: op
description: Allows to generate the complete world inside the border.
description: Allows to be everywhere on the map (ignoring the borders).
craftinc.borderprotection.update:
default: op
description: Allows to get notified on login, when a new update is available.