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

Compare commits

base: craftinc:development
Branches Tags
craftinc:development
craftinc:bugfix/material_names
craftinc:master
craftinc:version2.4.0
craftinc:version2.3.0
craftinc:version2.2.1
craftinc:version2.2.0
craftinc:version2.1.2
craftinc:version2.1.1
craftinc:version2.1.0
craftinc:version2.1.0-beta
craftinc:version2.0.1a
craftinc:version2.0.1
craftinc:version2.0.0
craftinc:version1.1.1
craftinc:bukkit1.2
..
compare: craftinc:version2.0.0
Branches Tags
craftinc:bugfix/material_names
craftinc:development
craftinc:master
craftinc:version2.4.0
craftinc:version2.3.0
craftinc:version2.2.1
craftinc:version2.2.0
craftinc:version2.1.2
craftinc:version2.1.1
craftinc:version2.1.0
craftinc:version2.1.0-beta
craftinc:version2.0.1a
craftinc:version2.0.1
craftinc:version2.0.0
craftinc:version1.1.1
craftinc:bukkit1.2

No commits in common. "development" and "version2.0.0" have entirely different histories.
developmen ... version2.0

68 changed files with 1994 additions and 3978 deletions
Show Stats Expand all files Collapse all files

5
.classpath
View File

@ -1,8 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" path="src"/>
<classpathentry kind="lib" path="/Users/tobi/Code/Vault.jar"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
<classpathentry kind="lib" path="/Users/tobi/Code/craftbukkit-1.5.1-R0.1.jar"/>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
<classpathentry kind="lib" path="/Users/tobi/Code/craftbukkit-1.4.5-R1.0.jar"/>
<classpathentry kind="output" path="bin"/>
</classpath>

4
.gitignore vendored
View File

@ -28,7 +28,3 @@ profile
# bukkit
bukkit/
# bukkit test-server
bukkit-testserver/
dependency-reduced-pom.xml

12
.settings/org.eclipse.jdt.core.prefs Normal file
View File

@ -0,0 +1,12 @@
#Wed Apr 06 16:59:25 CEST 2011
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
org.eclipse.jdt.core.compiler.compliance=1.6
org.eclipse.jdt.core.compiler.debug.lineNumber=generate
org.eclipse.jdt.core.compiler.debug.localVariable=generate
org.eclipse.jdt.core.compiler.debug.sourceFile=generate
org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
org.eclipse.jdt.core.compiler.source=1.6

13
AUTHORS.txt
View File

@ -1,13 +0,0 @@
The following persons contributed to Craft Inc. Gates (previously named Ancient Gates):
CURRENT MAINTAINERS
Tobias Ottenweller <mail@ottenweller.net>
Paul Schulze <info@paul-schulze.de>
FORMER CONTRIBUTORS (alphabetical order)
Jacob Brunson <jacob@dimensionsmachine.com>
locutus <bladedpenguin@gmail.com>
Olof Larsson <olof@sylt.nu>

82
README.md
View File

@ -1,85 +1,51 @@
# Craft Inc. Gates #
# Craft Inc. Gates – Easily create portals with custom design
This awesome plugin lets you _travel_ to far away places and worlds _faster than light_! Just create a gate at any location and set an exit somewhere else.
(previously known as __AncientGates__)
This has been made available by the hard work of the research and development department of the _Craft Inc. Corporation_. Under the lead of Professor Ddidderr Craftman scientists worked years to find a way to bend time and space inside the Minecraft universe to enable _ultra fast transportation_.
With this plugin players can create gates that will teleport anyone who enter the gate to specific a location.
The hightlights are: __It is so darn easy to use!__ and __The gates can look any way you like__
Now it is time for _you_ to try out this wonderful plugin. Simply install, create a gate and feel the funny tickle inside your brain while traveling.*
Try the ingame command: __/gate__
The key features of this are:
Also have a look at the full __[userguide](http://www.craftinc.de/blog/?p=255)__.
* Dynmap integration
* Gates with and without frames
* Gates consisting of portal blocks and gates made of air (so called hidden gates)
* Gates with destinations in different worlds
* Gates with custom shapes (gates can look any way you want)
* Riding through gates
Thought first you should take a look at the demonstration oloflarsson and karibu6 created:
__[http://www.youtube.com/watch?v=L4hyqTpeEaA](http://www.youtube.com/watch?v=L4hyqTpeEaA)__
*The Craft Inc. Corporation won't take any responsibility for seasickness, memory loss and sudden suffocation in walls while traveling with one of our gates!
## FAQ ##
## FAQ
__Who can create a gate?__
Have a look at the [_Permissions_](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/permissions/) page.
See the _Permissions_ section.
__Who can destroy a gate?__
Anyone if you do not use a third-party protection plugin like Grief Prevention.
__Is there a IConnomy integration? Features for user to dial other gates etc?__
__Are there IConnomy integration, Features for user to dial other gates etc?__
Nope. We currently don't plan to integrate such features. If you really need such an integration please inform us. If there are a lot of people requesting such features we might change our mind.
Nope. This plugin is very minimalistic and plain. Server operators manage the portals players use them any time they are open.
__Is there a list of all commands?__
## Permissions
Sure, type _/gate help_ in-game or have a look at the [_Commands_](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/commands/) page.
__craftincgates.info__
__When I destroy the frame of a gate it stops working. Shouldn't it still work?__
Gives access to info and list commands.
Yes and no. To make gates work without a frame you need to tweak the _checkForBrokenGateFrames_ setting. Have a look at the [_Configuration_](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/configuration/) page for more information.
__craftincgates.use__
Allows you to travel via gates.
## Usage ##
With this plugin you can create gates which will teleport players anywhere you want. The gates can look any way you like.
__craftincgates.manage__
To make the gate work place yourself inside a newly created gate frame and type __/gate new [id]__. Afterwards walk to the destination of your gate and type __/gate exit [id]__ to set the destination. With __/gate open [id]__ you can get your newly created gate to work.
Gives access to commands manipulating gates.
To hide a gate simply call __/gate hide [id]__. Now that gate won’t be made of purple portal blocks while open.
## Installing
Have a look at the [_Commands_](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/commands/) page to find out how to modify gates even further.
1. Download the latest release: __[https://github.com/tomco/minecraft-craftinc-gates/downloads](https://github.com/tomco/minecraft-craftinc-gates/downloads)__
2. Put AncientGates.jar in the plugins folder.
## License
## Installing ##
1. Download the latest release _[here](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/files/)_
2. Delete any old versions of _Craft Inc. Gates_ (only the .jar files) including the extra dynmap-plugin of this plugin.
3. Extract the content of the zip file into the plugins folder of your Bukkit server.
4. Start or reload the server.
## Craft Inc. ##
Check out our __[Craft Inc. Minecraft Server](http://www.craftinc.de)__. Everyone is welcome!
Also check out our other great plugins:
* [__Craft Inc. BorderProtection__](http://dev.bukkit.org/bukkit-mods/craftinc-borderprotection/)
protect your worlds with a border players cannot cross.
* [__Craft Inc. Replicator__](http://dev.bukkit.org/bukkit-mods/craftinc-replicator/)
allows players to build a replicator to replicate blocks and other items. (still experimental)
* __Craft Inc. Scarecrow__
coming soon!
## Roadmap ##
* Per player permissions for using and managing gates.
* Horizontal gates.
## Bugs and other Problems ##
Please use our [_issue tracker_](https://github.com/craftinc/craftinc-gates/issues?state=open) on GitHub.
## Legal Information ##
This project is a fork of the original [_Ancient Gates_](https://github.com/bladedpenguin/minecraft-ancient-gates). It is licensed under the [_LGPL_](http://www.gnu.org/licenses/lgpl-3.0.txt) just like the Bukkit project. Thanks to all current and previous [_contributors_](https://github.com/craftinc/craftinc-gates/blob/development/AUTHORS.txt).
The font used for the Craft Inc. Gates logo is called [_MineCrafter 3_](http://www.minecraftforum.net/topic/892789-minecrafter-3-font-simply-easy/) and has been made available under the creative commons license. Thanks to Asherz08, MadPixel and Ashley Denham for this great font.
This plugin utilizes [_Hidendra's plugin metrics system_](http://mcstats.org), which means that the following information is collected and sent to mcstats.org: a unique identifier, the server's version of Java, whether the server is in offline or online mode, the plugin's version, the server's version, the OS version/name and architecture, the core count for the CPU, the number of players online, the Metrics version. __You can disable the stat collection via /plugins/PluginMetrics/config.yml if you wish.__
This project has a LGPL license just like the Bukkit project.

51
changelog.md
View File

@ -1,51 +0,0 @@
## 2.4.0 ##
* Resolved issues with closing gates (special thanks to THCFrosD)
* Added support for riding through gates (with horses, mine carts, pigs and boats)
* Dynmap integration (extra plugin)
## 2.3.0 ##
* Added a command for setting the exit and opening a gate at once.
* Enabled the ability to change the gate block material.
* Added a command printing all nearby gates while highlighting them.
* Changed the info command to highlight gates.
* Updated the info command to print information about the nearest gate if no gate name got supplied.
## 2.2.1 ##
* Changed priority of some event listeners to solve problems with WorldGuard and other protection plugins.
## 2.2.0 ##
* Improved gate commands and shortcuts (have a look at the bukkit-dev page for more information).
* Improved overall performance.
* Added a configuration file (have a look at the bukkit-dev page for more information).
* Resolved issues with (random) teleports to the nether.
* Made it possible to create non hidden gates without a frame. (Turned off by default!)
* Changed the behavior regarding portal blocks. Starting with this version no blocks will be set by the plugin. All portal blocks will only be visible on client side.
* Added checks preventing the plugin from overwriting the gate storage file on error.
* Added the ability to change and disable messages on teleport and insufficient permissions via a config file.
## 2.1.2 ##
* Fixed a bug where players got teleported one block beside the real portal.
* Fixed a bug where gates with no location caused multiple exceptions.
## 2.1.1 ##
* Made the list command more reliable.
* Error messages will be displayed less frequent.
## 2.1.0 ##
* Command outputs are now colored.
* Fixed a bug where players in creative mode would not be teleported correctly.
* Made various commands available via the server console.
* Simplified command names.
* Improved permissions handling. (Added soft dependency for Vault.)
* A message will be displayed after a player has been teleported. There is also a message displayed if a player is not allowed to use a gate.
## 2.0.1a
* Fixed broken import for gates created with version 2.0.0
## 2.0.1
* Updated permissions to allow everyone to use gates by default.
* Fixed a bug where yaw had not been taken correctly into account while teleporting.
* Re-added persistence of yaw and pitch of gate locations and exits.
## 2.0.0
Initial release under new name

47
doc/Commands.md
View File

@ -1,47 +0,0 @@
* __/gate allowRiding, ar [id]__
Update a gate so players can travel through it while riding.
* __/gate close, c [id]__
Closes a gate to prevent players from using it.
* __/gate denyRiding, dr [id]__
Update a gate so players can NOT travel through it while riding.
* __/gate delete, del, remove [id]__
Removes the gate from the game.
* __/gate exit, e [id]__
Changes the location where the gate will teleport players to your current location.
* __/gate exitopen, eo [id]__
Changes the location where the gate will teleport players to your current location. Also tries to open that gate afterwards.
* __/gate help, ? [page]__
Prints help pages.
* __/gate hide, h [id]__
Makes a gate NOT consist of gate blocks while open.
* __/gate info, i [id]__
Prints details about a certain gate. Will print information about the nearest gate if no _id_ is supplied. Also highlights the gate you're requesting information about.
* __/gate list, ls [page]__
Prints all available gates.
* __/gate location, lo [id]__
Sets the entrance of the gate to your current location.
* __/gate nearby, nb__
Prints the name of nearby gates. Also highlights them.
* __/gate new, n [id]__
Creates a gate at your current location.
* __/gate open, o [id]__
Open a gate so players can use it.
* __/gate rename, rn [current name] [new name]__
Changes the name/id of the gate.
* __/gate unhide,uh [id]__
Makes that gate visible.

57
doc/Configuration.md
View File

@ -1,57 +0,0 @@
Starting with version 2.2.0 some features are customizable via a configuration file.
The configuration file will be automatically created on the the first startup after
installing or updating the plugin.
The following keys and values are available:
* __maxGateBlocks__
A positive integer defining the maximum number of blocks a gate can consist of.
Note that increasing this value might slow down your server!
* __playerGateBlockUpdateRadius__
Defines the radius around a player where portal blocks are visible to that player.
Adjust this value when increasing or decreasing the view-distance on the server.
Only positive integer values are allowed.
* __checkForBrokenGateFrames__
Allowed values are _true_ and _false_ only. Setting this value to _false_ will disable
all checks for broken frames for non-hidden gates. Disabling frame block checks
might increase you server performance.
* __saveOnChanges__
Allowed values are _true_ and _false_ only. Disabling _save on changes_ might
increase server performance but gates will only be saved to disk when the plugin
gets disabled! This might lead to data loss on error.
* __gateTeleportMessage__
A string value going to displayed every time when a player travels using a gate. Will
only be displayed if _showTeleportMessage_ is set to _true_.
* __showTeleportMessage__
A boolean (_true_ or _false_) determining wether the _teleport message_ will
be displayed.
* __gateTeleportNoPermissionMessage__
A string value going to displayed every time when a player enters a gate and is not allowed to use that gate. Will only be displayed if _showTeleportNoPermissionMessage_
is set to _true_.
* __gateTeleportVehicleNotAllowedMessage__
A string value being displayed when a player tries to go through a gate while riding when riding through this gate is disabled. Will only be displayed if _showTeleportNoPermissionMessage_ is set to _true_.
* __showTeleportNoPermissionMessage__
A boolean (_true_ or _false_) determining wether the _no permission message_ will
be displayed.
* __gateMaterial__
A String representing the material all gates will consist of. Have a look at our [_Gate Material Page_](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/gate-materials/) for all possible values.

27
doc/Gate Materials.md
View File

@ -1,27 +0,0 @@
Starting with version 2.3.0 different gate materials can be used. You can set them via the configuration file. The following Materials are currently defined:
* sapling
* water
* lava
* cobweb
* grass
* dead bush
* dandelion
* poppy
* brown mushroom
* red mushroom
* torch
* redstone torch (off)
* redstone torch (on)
* fence
* nether portal
* iron bars
* glass pane
* fence gate
* nether brick fence
* nether wart
* end portal
* cobblestone wall
Your favorite material is missing? Please contact us and we will see if we can add it.

12
doc/Permissions.md
View File

@ -1,12 +0,0 @@
The following permissions are available: (Also have a look at the [Commands Page](http://dev.bukkit.org/bukkit-plugins/craftinc-gates/pages/commands/) to see if which commands can be executed with which permission set.)
* __craftincgates.info__
Gives access to info and list commands.
* __craftincgates.use__
Allows you to travel via gates.
* __craftincgates.manage__
Gives access to commands manipulating gates.
Craft Inc. Gates will use __[Vault](http://dev.bukkit.org/bukkit-mods/vault/)__'s permission system if Vault is installed on your server.

10
plugin.yml
View File

@ -1,10 +1,9 @@
name: ${project.name}
version: ${project.version}
name: Craft Inc. Gates
version: 2.0.0
description: A plugin to create gates for fast traveling.
softdepend: [Vault, Multiverse-Core, MultiWorld, RoyalCommands]
author: tomco, s1m0ne
authors: [oloflarsson, locutus, DrAgonmoray, s1m0ne, tomco]
website: http://dev.bukkit.org/bukkit-plugins/craftinc-gates/
website: http://www.craftinc.de/craftinc-gates/
main: de.craftinc.gates.Plugin
database: false
@ -16,7 +15,7 @@ commands:
permissions:
craftincgates.*:
description: Gives access to all Craft Inc. Gates commands.
description: Gives access to all ancient gates commands and lets you use open gates.
children:
craftincgates.info: true
craftincgates.use: true
@ -24,7 +23,6 @@ permissions:
craftincgates.info:
description: Gives access to info and list commands.
craftincgates.use:
default: true
description: Allows you to use open gates.
craftincgates.manage:
description: Gives access to commands manipulating gates.

139
pom.xml
View File

@ -4,146 +4,39 @@
<modelVersion>4.0.0</modelVersion>
<groupId>de.craftinc</groupId>
<artifactId>CraftIncGates</artifactId>
<name>Craft Inc. Gates</name>
<url>http://dev.bukkit.org/bukkit-plugins/craftinc-gates/</url>
<packaging>jar</packaging>
<version>2.4.1</version>
<version>1.1.1</version>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.compiler.source>1.7</maven.compiler.source>
<maven.compiler.target>1.7</maven.compiler.target>
</properties>
<!-- License -->
<licenses>
<license>
<name>GNU Lesser General Public License Version 3</name>
<url>https://www.gnu.org/licenses/lgpl-3.0-standalone.html</url>
<distribution>repo</distribution>
</license>
</licenses>
<build>
<finalName>${project.name} ${project.version}</finalName>
<sourceDirectory>src</sourceDirectory>
<resources>
<resource>
<directory>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>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>1.7.1</version>
<configuration>
<artifactSet>
<includes>
<include>org.mcstats.bukkit:metrics</include>
</includes>
</artifactSet>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencies>
<!--Spigot API-->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.11-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!--Bukkit API-->
<dependency>
<groupId>org.bukkit</groupId>
<artifactId>bukkit</artifactId>
<version>1.11-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!--Vault-->
<dependency>
<groupId>net.milkbowl.vault</groupId>
<artifactId>Vault</artifactId>
<version>1.6.6</version>
<version>RELEASE</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<!--Metrics-->
<dependency>
<groupId>org.mcstats.bukkit</groupId>
<artifactId>metrics</artifactId>
<version>R8-SNAPSHOT</version>
<scope>compile</scope>
</dependency>
</dependencies>
<build>
<directory>target</directory>
<outputDirectory>target/classes</outputDirectory>
<finalName>${project.artifactId}</finalName>
<sourceDirectory>src</sourceDirectory>
<resources>
<resource>
<directory>src/resources</directory>
</resource>
</resources>
</build>
<repositories>
<repository>
<id>spigot-repo</id>
<url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
<id>bukkit-repo</id>
<url>http://repo.bukkit.org/content/groups/public</url>
</repository>
<repository>
<id>vault-repo</id>
<url>http://nexus.hc.to/content/repositories/pub_releases</url>
</repository>
<repository>
<id>Plugin Metrics</id>
<url>http://repo.mcstats.org/content/repositories/public</url>
</repository>
</repositories>
</project>

11
resources/config.yml
View File

@ -1,11 +0,0 @@
maxGateBlocks: 50
playerGateBlockUpdateRadius: 64
highlightDuration: 5
saveOnChanges: true
checkForBrokenGateFrames: true
gateTeleportMessage: "Thank you for traveling with Craft Inc. Gates."
showTeleportMessage: true
gateTeleportNoPermissionMessage: "You are not allowed to use this gate!"
showTeleportNoPermissionMessage: true
gateTeleportVehicleNotAllowedMessage: "You must not use that gate while riding!"
gateMaterial: "nether portal"

1
resources/plugin.yml
View File

@ -1 +0,0 @@
../plugin.yml

160
scripts/minecraft.sh
View File

@ -1,160 +0,0 @@
#!/bin/bash
SCRIPT_DIR=$(dirname "$0")
SERVICE='craftbukkit*.jar'
#USERNAME="minecraft"
CPU_COUNT=2
BUKKIT="$SCRIPT_DIR/../target/lib/$SERVICE"
INVOCATION="java -Xmx1000M -Xms300M -XX:+UseConcMarkSweepGC -XX:+CMSIncrementalPacing -XX:ParallelGCThreads=$CPU_COUNT -XX:+AggressiveOpts -jar $BUKKIT nogui"
MCPATH="$SCRIPT_DIR/../bukkit-testserver"
if [ ! -d "$MCPATH" ]; then
mkdir -p "$MCPATH"
fi
ME=$(whoami)
as_user() {
#if [ $ME == $USERNAME ] ; then
bash -c "$1"
#else
#su - $USERNAME -c "$1"
#fi
}
mc_start() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "Tried to start but $SERVICE was already running!"
else
echo "$SERVICE was not running... starting."
cd "$MCPATH"
as_user "cd "$MCPATH" && screen -dmS minecraft $INVOCATION"
sleep 7
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is now running."
else
echo "Could not start $SERVICE."
fi
fi
}
mc_stop() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is running... stopping."
as_user "screen -p 0 -S minecraft -X eval 'stuff \"save-all\"\015'"
sleep 2
as_user "screen -p 0 -S minecraft -X eval 'stuff \"stop\"\015'"
sleep 6
else
echo "$SERVICE was not running."
fi
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE could not be shut down... still running."
else
echo "$SERVICE is shut down."
fi
}
mc_save() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is running... saving."
as_user "screen -p 0 -S minecraft -X eval 'stuff \"save-all\"\015'"
else
echo "$SERVICE was not running."
fi
}
mc_reload() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is running... reloading."
as_user "screen -p 0 -S minecraft -X eval 'stuff \"reload\"\015'"
else
echo "$SERVICE was not running."
fi
}
mc_reload_or_start() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE was already running! Doing a reload now!"
mc_reload
else
echo "$SERVICE was not running... starting."
cd "$MCPATH"
as_user "cd \"$MCPATH\" && screen -dmS minecraft $INVOCATION"
sleep 7
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is now running."
else
echo "Could not start $SERVICE."
fi
fi
}
mc_ddidderr_admin() {
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is running... making ddidder to admin and reloading permissions."
as_user "screen -p 0 -S minecraft -X eval 'stuff \"pex user ddidderr group set admin\"\015'"
as_user "screen -p 0 -S minecraft -X eval 'stuff \"pex reload\"\015'"
else
echo "$SERVICE was not running."
fi
}
case "$1" in
start)
echo "Starting Minecraft..."
mc_start
echo "DONE"
;;
stop)
echo "Stopping Minecraft..."
as_user "screen -p 0 -S minecraft -X eval 'stuff \"say SERVER SHUTTING DOWN!\"\015'"
mc_stop
echo "DONE"
;;
restart)
as_user "screen -p 0 -S minecraft -X eval 'stuff \"say SERVER REBOOT IN 10 SECONDS.\"\015'"
$0 stop
sleep 1
$0 start
;;
reload)
mc_reload
;;
reload_or_start)
echo "Starting or reloading Minecraft..."
mc_reload_or_start
echo "DONE"
;;
ddidderr_admin)
mc_ddidderr_admin
;;
connected)
as_user "screen -p 0 -S minecraft -X eval 'stuff \"who\"\015'"
sleep 2s
tac "$MCPATH"/server.log | grep -m 1 "Connected"
;;
status)
if ps ax | grep -v grep | grep -v -i SCREEN | grep "craftbukkit" > /dev/null
then
echo "$SERVICE is running."
else
echo "$SERVICE is not running."
fi
;;
save)
mc_save
;;
*)
echo "Usage: /etc/init.d/minecraft {start|stop|restart|connected|status}"
exit 1
;;
esac

29
scripts/test-deployment.sh
View File

@ -1,29 +0,0 @@
#!/bin/bash
SCRIPT_DIR="$(dirname "$0")"
DEVELOPER=$(whoami)
if [ $DEVELOPER = "tobi" ]; then
BUKKIT_DIR="$HOME/minecraft/testbuk"
PLUGIN_DIR="$HOME/minecraft/testbuk/plugins"
START_STOP_SCRIPT="$BUKKIT_DIR/../minecraft.sh"
else
BUKKIT_DIR="$SCRIPT_DIR/../bukkit-testserver"
PLUGIN_DIR="$SCRIPT_DIR/../bukkit-testserver/plugins"
START_STOP_SCRIPT="$SCRIPT_DIR/minecraft.sh"
fi
# 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')"
mkdir -p "$PLUGIN_DIR"
cp "$SCRIPT_DIR/../target/$ARTIFACT_ID $VERSION".jar "$PLUGIN_DIR/"
echo -e "ddidderr\nmice_on_drugs\nMochaccino\nbeuth_el_max" > "$BUKKIT_DIR/ops.txt"
$START_STOP_SCRIPT reload_or_start

195
src/de/craftinc/gates/BaseGate.java Normal file
View File

@ -0,0 +1,195 @@
package de.craftinc.gates;
import java.util.HashSet;
import java.util.Set;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import de.craftinc.gates.util.FloodUtil;
public abstract class BaseGate
{
/*
* ATTRIBUTES
*/
protected Location location; /* saving both location and gateBlockLocations is redundant but makes it easy to allow players to reshape gates */
protected Set<Location> gateBlockLocations = new HashSet<Location>(); /* Locations of the blocks inside the gate */
protected Location exit;
protected boolean isHidden = false;
protected boolean isOpen = false;
/*
* SETTER & GETTER
*/
public Location getLocation()
{
return location;
}
public void setLocation(Location location) throws Exception
{
this.location = location;
if (isOpen) {
fillGate();
validate();
}
}
public Location getExit()
{
return exit;
}
public void setExit(Location exit) throws Exception
{
this.exit = exit;
validate();
}
public boolean isHidden()
{
return isHidden;
}
public void setHidden(boolean isHidden) throws Exception
{
this.isHidden = isHidden;
if (isHidden == true) {
emptyGate();
}
else if (isOpen()) {
fillGate();
}
validate();
}
public boolean isOpen()
{
return isOpen;
}
public void setOpen(boolean isOpen) throws Exception
{
if (isOpen == true && this.isOpen == false) {
findPortalBlocks();
if (!isHidden) {
fillGate();
}
}
else if (isOpen == false && this.isOpen == true) {
emptyGate();
}
this.isOpen = isOpen;
validate();
}
public Set<Location> getGateBlockLocations()
{
return gateBlockLocations;
}
/*
* GATE BLOCK HANDLING
*/
protected void fillGate()
{
emptyGate();
findPortalBlocks();
// This is not to do an effect
// It is to stop portal blocks from destroying themself as they cant rely on non created blocks :P
for (Location l : gateBlockLocations) {
l.getBlock().setType(Material.GLOWSTONE);
}
for (Location l : gateBlockLocations) {
l.getBlock().setType(Material.PORTAL);
}
}
protected void emptyGate()
{
for (Location l : gateBlockLocations) {
if (l.getBlock().getType() == Material.PORTAL) {
l.getBlock().setType(Material.AIR);
}
}
}
protected void findPortalBlocks()
{
gateBlockLocations = new HashSet<Location>();
Set<Block> gateBlocks = FloodUtil.getGateFrameBlocks(location.getBlock());
if (gateBlocks != null) {
for (Block b : gateBlocks) {
gateBlockLocations.add(b.getLocation());
}
}
}
/*
* VALIDATION
*/
/**
* Checks if valus attributes do add up; will close gate on wrong values.
*/
public void validate() throws Exception
{
if (!isOpen) {
return;
}
if (location == null) {
setOpen(false);
throw new Exception("Gate got closed. It has no location.");
}
if (exit == null) {
setOpen(false);
throw new Exception("Gate got closed. It has no exit.");
}
if (gateBlockLocations.size() == 0) {
setOpen(false);
throw new Exception("Gate got closed. The frame is missing or broken.");
}
if (isHidden == false) {
for (Location l : gateBlockLocations) {
if (l.getBlock().getType() == Material.AIR) {
setOpen(false);
throw new Exception("Gate got closed. The frame is missing or broken.");
}
}
}
}
}

183
src/de/craftinc/gates/Gate.java Normal file
View File

@ -0,0 +1,183 @@
package de.craftinc.gates;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.bukkit.Location;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import de.craftinc.gates.util.LocationSerializer;
/**
* Adds persistence and serialization to the base gate class.
*/
public class Gate extends BaseGate implements ConfigurationSerializable
{
/*
* ATTRIBUTES
*/
protected String id;
protected static Map<String, Gate> instances = new HashMap<String, Gate>();
/*
* CONSTRUCTORS
*/
public Gate(String id) throws Exception
{
setId(id);
}
/*
* SETTER & GETTER
*/
public String getId()
{
return id;
}
public void setId(String id) throws Exception
{
if (exists(id)) {
throw new Exception("A gate with '" + id + "' already exists");
}
this.id = id;
}
/*
* INTERFACE: ConfigurationSerializable
*/
static String idKey = "id";
static String locationKey = "location";
static String gateBlocksKey = "gateBlocks";
static String exitKey = "exit";
static String isHiddenKey = "hidden";
static String isOpenKey = "open";
@SuppressWarnings("unchecked")
public Gate(Map<String, Object> map)
{
try {
id = map.get(idKey).toString();
isHidden = (Boolean)map.get(isHiddenKey);
isOpen = (Boolean)map.get(isOpenKey);
location = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(locationKey));
exit = LocationSerializer.deserializeLocation((Map<String, Object>) map.get(exitKey));
gateBlockLocations = new HashSet<Location>();
List<Map<String, Object>> serializedGateBlocks = (List<Map<String, Object>>)map.get(gateBlocksKey);
for (Map<String, Object> sgb : serializedGateBlocks) {
gateBlockLocations.add(LocationSerializer.deserializeLocation(sgb));
}
}
catch (Exception e) {
Plugin.log("ERROR: Failed to load gate '" + id + "'! (" + e.getMessage() + ")");
Plugin.log("NOTE: This gate will be removed from 'gates.yml' and added to 'invalid_gates.yml'!");
Plugin.instance.storeInvalidGate(map);
return;
}
instances.put(id, this);
}
public Map<String, Object> serialize()
{
try {
validate(); // make sure to not write invalid stuff to disk
}
catch (Exception e) {
}
Map<String, Object> retVal = new HashMap<String, Object>();
retVal.put(idKey, id);
retVal.put(locationKey, LocationSerializer.serializeLocation(location));
retVal.put(exitKey, LocationSerializer.serializeLocation(exit));
retVal.put(isHiddenKey, isHidden);
retVal.put(isOpenKey, isOpen);
List<Map<String, Object>> serializedGateBlocks = new ArrayList<Map<String, Object>>();
for (Location l : gateBlockLocations) {
serializedGateBlocks.add(LocationSerializer.serializeLocation(l));
}
retVal.put(gateBlocksKey, serializedGateBlocks);
return retVal;
}
/*
* ENTITY MANAGEMENT
*/
public static Gate get(String id)
{
return instances.get(id);
}
public static boolean exists(String id)
{
return instances.containsKey(id);
}
public static Gate create(String id) throws Exception
{
Gate gate = new Gate(id);
instances.put(gate.id, gate);
return gate;
}
public static void rename(String oldId, String newId) throws Exception
{
Gate gate = get(oldId);
gate.setId(newId);
delete(oldId);
instances.put(gate.id, gate);
}
public static void delete(String id)
{
Gate g = get(id);
if (g != null) {
g.emptyGate();
}
instances.remove(id);
}
public static Collection<Gate> getAll()
{
return instances.values();
}
}

288
src/de/craftinc/gates/Plugin.java
View File

@ -1,172 +1,111 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import de.craftinc.gates.controllers.GatesManager;
import de.craftinc.gates.listeners.*;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.ConfigurationUtil;
import net.milkbowl.vault.permission.Permission;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.configuration.serialization.ConfigurationSerialization;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
import de.craftinc.gates.commands.*;
import org.mcstats.Metrics;
import de.craftinc.gates.listeners.PluginBlockListener;
import de.craftinc.gates.listeners.PluginPlayerListener;
import de.craftinc.gates.listeners.PluginPortalListener;
public class Plugin extends JavaPlugin {
private static Plugin instance;
public class Plugin extends JavaPlugin
{
public static Plugin instance;
public static final String permissionInfo = "craftincgates.info";
public static final String permissionManage = "craftincgates.manage";
public static final String permissionAll = "craftincgates.*";
public static final String permissionUse = "craftincgates.use";
public PluginPlayerListener playerListener = new PluginPlayerListener();
public PluginBlockListener blockListener = new PluginBlockListener();
public PluginPortalListener portalListener = new PluginPortalListener();
private String baseCommand;
protected List<BaseCommand> commands = new ArrayList<>();
private GatesManager gatesManager = new GatesManager();
private String gatesPath = "gates";
private PermissionController permissionController = new PermissionController();
private PlayerMoveListener moveListener;
private VehicleMoveListener vehicleListener;
private PlayerTeleportListener teleportListener = new PlayerTeleportListener();
private PlayerRespawnListener respawnListener = new PlayerRespawnListener();
private PlayerChangedWorldListener worldChangeListener = new PlayerChangedWorldListener();
private PlayerJoinListener joinListener = new PlayerJoinListener();
private BlockBreakListener blockBreakListener = new BlockBreakListener();
// Commands
public List<BaseCommand> commands = new ArrayList<BaseCommand>();
public Plugin() {
public Plugin()
{
instance = this;
moveListener = new PlayerMoveListener(this);
vehicleListener = new VehicleMoveListener(this);
}
public static Plugin getPlugin() {
return instance;
}
public GatesManager getGatesManager() {
return gatesManager;
}
@Override
public void onLoad() {
public void onLoad()
{
ConfigurationSerialization.registerClass(Gate.class);
}
private void setupPermissions() {
if (getServer().getPluginManager().getPlugin("Vault") == null) {
log("Not using setup permission provider provided by Vault.");
return;
}
RegisteredServiceProvider<Permission> rsp = getServer().getServicesManager().getRegistration(Permission.class);
if (rsp != null) {
log("Using permission provider provided by Vault.");
permissionController.setPermission(rsp.getProvider());
} else {
log("Not using setup permission provider provided by Vault.");
}
}
@Override
public void onDisable() {
gatesManager.saveGatesToDisk();
public void onDisable()
{
// Save gates
saveGates();
log("Disabled");
}
@Override
public void onEnable() {
// Setup Metrics
try {
Metrics metrics = new Metrics(this);
metrics.start();
} catch (IOException e) {
log("Failed to start metrics!");
}
// Setup configuration
this.saveDefaultConfig();
// Setup permissions
setupPermissions();
public void onEnable()
{
// Add the commands
commands.add(new CommandHelp());
commands.add(new CommandNew());
commands.add(new CommandRemove());
commands.add(new CommandLocation());
commands.add(new CommandExit());
commands.add(new CommandTriggerOpen());
commands.add(new CommandCreate());
commands.add(new CommandDelete());
commands.add(new CommandSetLocation());
commands.add(new CommandSetExit());
commands.add(new CommandOpen());
commands.add(new CommandRename());
commands.add(new CommandClose());
commands.add(new CommandList());
commands.add(new CommandInfo());
commands.add(new CommandNearby());
commands.add(new CommandTriggerVehicles());
commands.add(new CommandMaterial());
commands.add(new CommandTeleport());
commands.add(new CommandSetHidden());
commands.add(new CommandSetVisible());
// Register events
this.registerEventListeners();
PluginManager pm = this.getServer().getPluginManager();
pm.registerEvents(this.playerListener, this);
pm.registerEvents(this.blockListener, this);
pm.registerEvents(this.portalListener, this);
// Load gates
boolean success = gatesManager.loadGatesFromDisk();
loadGates();
if (success) {
log("Enabled");
} else {
PluginManager pm = this.getServer().getPluginManager();
pm.disablePlugin(this);
}
}
public PermissionController getPermissionController() {
return permissionController;
}
private void registerEventListeners() {
PluginManager pm = this.getServer().getPluginManager();
pm.registerEvents(this.moveListener, this);
pm.registerEvents(this.teleportListener, this);
pm.registerEvents(this.respawnListener, this);
pm.registerEvents(this.worldChangeListener, this);
pm.registerEvents(this.joinListener, this);
pm.registerEvents(this.vehicleListener, this);
if (getConfig().getBoolean(ConfigurationUtil.confCheckForBrokenGateFramesKey)) {
pm.registerEvents(this.blockBreakListener, this);
}
}
// -------------------------------------------- //
// Commands
// -------------------------------------------- //
public String getBaseCommand() {
public String getBaseCommand()
{
if (this.baseCommand != null)
return this.baseCommand;
@ -177,15 +116,20 @@ public class Plugin extends JavaPlugin {
return this.baseCommand;
}
@Override
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
List<String> parameters = new ArrayList<>(Arrays.asList(args));
public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args)
{
List<String> parameters = new ArrayList<String>(Arrays.asList(args));
this.handleCommand(sender, parameters);
return true;
}
private void handleCommand(CommandSender sender, List<String> parameters) {
if (parameters.size() == 0) {
public void handleCommand(CommandSender sender, List<String> parameters)
{
if (parameters.size() == 0)
{
this.commands.get(0).execute(sender, parameters);
return;
}
@ -193,25 +137,113 @@ public class Plugin extends JavaPlugin {
String commandName = parameters.get(0).toLowerCase();
parameters.remove(0);
for (BaseCommand command : this.commands) {
if (command.getAliases().contains(commandName)) {
command.execute(sender, parameters);
for (BaseCommand fcommand : this.commands)
{
if (fcommand.getAliases().contains(commandName))
{
fcommand.execute(sender, parameters);
return;
}
}
sender.sendMessage(ChatColor.RED + "Unknown gate-command \"" + commandName + "\"." +
ChatColor.GREEN + " Try " + "/" + getBaseCommand() + " help");
sender.sendMessage("Unknown gate-command \"" + commandName + "\". Try " + "/" + getBaseCommand() + " help");
}
/*
* Logging
*/
public static void log(String msg) {
public static void log(String msg)
{
log(Level.INFO, msg);
}
public static void log(Level level, String msg) {
Logger.getLogger("Minecraft").log(level, "[" + instance.getDescription().getFullName() + "] " + msg);
Logger.getLogger("Minecraft").log(level, "["+instance.getDescription().getFullName()+"] "+msg);
}
/*
* Saving and Loading Gates
*/
public void loadGates()
{
File gatesFile = new File(getDataFolder(), "gates.yml");
FileConfiguration gatesConfig = YamlConfiguration.loadConfiguration(gatesFile);
gatesConfig.getList(gatesPath); // this will create all the gates
}
public void saveGates()
{
File gatesFile = new File(getDataFolder(), "gates.yml");
FileConfiguration gatesConfig = YamlConfiguration.loadConfiguration(gatesFile);
gatesConfig.set(gatesPath, new ArrayList<Object>(Gate.getAll()));
try {
gatesConfig.save(gatesFile);
}
catch (IOException e) {
log("ERROR: Could not save gates to disk.");
e.printStackTrace();
}
}
public void storeInvalidGate(Map<String, Object> map)
{
File invalidGatesFile = new File(getDataFolder(), "invalid_gates.yml");
Boolean invalidGatesFileExists = invalidGatesFile.exists();
try {
FileWriter fileWriter = new FileWriter(invalidGatesFile, true);
if (!invalidGatesFileExists) {
fileWriter.write("gates:\n");
}
fileWriter.write("- ==: ");
fileWriter.write(map.get("==").toString() + "\n");
map.remove("==");
fileWriter.write("\topen: false\n");
map.remove("open");
fileWriter.write("\tgateBlocks: []\n");
map.remove("gateBlocks");
for (String key : map.keySet()) {
Object value = map.get(key);
fileWriter.write("\t" + key + ": ");
if (value instanceof Map) {
fileWriter.write("\n");
@SuppressWarnings("unchecked")
Map<String, Object> valueMap = (Map<String, Object>)value;
for (String k : valueMap.keySet()) {
Object v = valueMap.get(k);
fileWriter.write("\t\t" + k + ": " + v.toString() + "\n");
}
}
else {
fileWriter.write(value.toString() + "\n");
}
}
fileWriter.close();
}
catch (IOException e) {
log("ERROR: Could not save invalid gates to disk.");
e.printStackTrace();
}
}
}

225
src/de/craftinc/gates/commands/BaseCommand.java
View File

@ -1,192 +1,169 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import java.util.ArrayList;
import java.util.List;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.ConfigurationUtil;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Player;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.controllers.GatesManager;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.util.TextUtil;
public abstract class BaseCommand {
PermissionController permissionController;
GatesManager gatesManager;
public abstract class BaseCommand
{
public List<String> aliases;
public List<String> requiredParameters;
public List<String> optionalParameters;
List<String> aliases = new ArrayList<>();
List<String> requiredParameters = new ArrayList<>();
List<String> optionalParameters = new ArrayList<>();
public String helpDescription;
String helpDescription = "no description";
public CommandSender sender;
public boolean senderMustBePlayer;
public boolean hasGateParam;
public Player player;
public Gate gate;
List<String> parameters;
CommandSender sender;
Player player;
Gate gate;
public List<String> parameters;
boolean senderMustBePlayer = true;
boolean hasGateParam = true;
public String requiredPermission;
String requiredPermission;
boolean needsPermissionAtCurrentLocation;
boolean shouldPersistToDisk;
public BaseCommand() {
aliases = new ArrayList<String>();
requiredParameters = new ArrayList<String>();
optionalParameters = new ArrayList<String>();
senderMustBePlayer = true;
hasGateParam = true;
helpDescription = "no description";
}
public List<String> getAliases() {
return aliases;
}
public BaseCommand() {
gatesManager = Plugin.getPlugin().getGatesManager();
permissionController = Plugin.getPlugin().getPermissionController();
}
public void execute(CommandSender sender, List<String> parameters) {
this.sender = sender;
this.parameters = parameters;
if (!this.validateCall()) {
if ( ! validateCall()) {
return;
}
if (sender instanceof Player) {
if (this.senderMustBePlayer) {
this.player = (Player)sender;
}
this.perform();
if (this.shouldPersistToDisk && getSaveOnChanges()) {
gatesManager.saveGatesToDisk();
}
perform();
}
abstract protected void perform();
public void perform() {
void sendMessage(String message) {
}
public void sendMessage(String message) {
sender.sendMessage(message);
}
void sendMessage(List<String> messages) {
for (String message : messages) {
public void sendMessage(List<String> messages) {
for(String message : messages) {
this.sendMessage(message);
}
}
boolean setGateUsingParameter(String param) {
if (!gatesManager.gateExists(param)) {
public boolean validateCall()
{
// validate player
if ( this.senderMustBePlayer && ! (sender instanceof Player))
{
sendMessage("This command can only be used by ingame players.");
return false;
} else {
gate = gatesManager.getGateWithId(param);
}
// validate permission
if( !hasPermission(sender))
{
sendMessage("You lack the permissions to "+this.helpDescription.toLowerCase()+".");
return false;
}
// valide parameter count
if (parameters.size() < requiredParameters.size())
{
sendMessage("Usage: "+this.getUseageTemplate(true));
return false;
}
// validate gate parameter
if (this.hasGateParam)
{
String id = parameters.get(0);
if ( ! Gate.exists(id))
{
sendMessage("There exists no gate with id "+id);
return false;
}
gate = Gate.get(id);
}
return true;
}
public boolean hasPermission(CommandSender sender)
{
if (sender.hasPermission(Plugin.permissionAll)) {
return true;
}
/**
* This will return false if a gate is required for this command but this.gate == null.
*/
boolean hasPermission() {
if (needsPermissionAtCurrentLocation) {
return permissionController.hasPermission(sender, requiredPermission);
} else {
return permissionController.hasPermission(sender, gate, requiredPermission);
}
if (sender.hasPermission(requiredPermission)) {
return true;
}
/*
Help and usage description
*/
return false;
}
String getUsageTemplate(boolean withDescription) {
// -------------------------------------------- //
// Help and usage description
// -------------------------------------------- //
public String getUsageTemplate(boolean withColor, boolean withDescription) {
String ret = "";
ret += ChatColor.AQUA;
ret += "/" + Plugin.getPlugin().getBaseCommand() + " " + TextUtil.implode(getAliases(), ",") + " ";
// if (withColor) {
// ret += Conf.colorCommand;
// }
List<String> parts = new ArrayList<>();
ret += "/" + Plugin.instance.getBaseCommand() + " " + TextUtil.implode(this.getAliases(), ",")+" ";
for (String requiredParameter : requiredParameters) {
parts.add("[" + requiredParameter + "]");
List<String> parts = new ArrayList<String>();
for (String requiredParameter : this.requiredParameters) {
parts.add("["+requiredParameter+"]");
}
for (String optionalParameter : optionalParameters) {
parts.add("*[" + optionalParameter + "]");
for (String optionalParameter : this.optionalParameters) {
parts.add("*["+optionalParameter+"]");
}
// if (withColor) {
// ret += Conf.colorParameter;
// }
ret += ChatColor.DARK_AQUA;
ret += TextUtil.implode(parts, " ");
if (withDescription) {
ret += " ";
ret += ChatColor.YELLOW;
ret += helpDescription;
}
// if (withDescription) {
// ret += " "+Conf.colorSystem + this.helpDescription;
// }
return ret;
}
private boolean validateCall() {
boolean allParametersThere = parameters.size() >= requiredParameters.size();
boolean senderIsPlayer = this.sender instanceof Player;
boolean hasGateParameter = false;
if (this.hasGateParam && this.parameters.size() > 0 && this.setGateUsingParameter(this.parameters.get(0))) {
hasGateParameter = true;
public String getUseageTemplate(boolean withColor) {
return getUsageTemplate(withColor, false);
}
boolean senderHasPermission = this.hasPermission();
boolean valid;
if (this.senderMustBePlayer && !senderIsPlayer) {
sendMessage(ChatColor.RED + "This command can only be used by in-game players.");
valid = false;
} else {
if (!allParametersThere) {
sendMessage(ChatColor.RED + "Some parameters are missing! " +
ChatColor.AQUA + "Usage: " +
getUsageTemplate(false)
);
valid = false;
} else if ((!senderHasPermission && this.hasGateParam) ||
(!senderHasPermission) ||
(this.hasGateParam && !hasGateParameter)) {
sendMessage(ChatColor.RED +
"You either provided a invalid gate or do not have permission to " +
this.helpDescription.toLowerCase()
);
valid = false;
} else {
valid = true;
}
}
return valid;
}
private boolean getSaveOnChanges() {
FileConfiguration config = Plugin.getPlugin().getConfig();
return config.getBoolean(ConfigurationUtil.confSaveOnChangesKey);
public String getUseageTemplate() {
return getUseageTemplate(true);
}
}

46
src/de/craftinc/gates/commands/BaseLocationCommand.java
View File

@ -1,19 +1,3 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import org.bukkit.Location;
@ -21,21 +5,27 @@ import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
abstract class BaseLocationCommand extends BaseCommand {
Location getValidPlayerLocation() {
// The player might stand in a half block or a sign or whatever
// Therefore we load some extra locations and blocks
Location location = player.getLocation().clone();
Block playerBlock = location.getBlock();
public abstract class BaseLocationCommand extends BaseCommand
{
protected Location getValidPlayerLocation()
{
// The player might stand in a halfblock or a sign or whatever
// Therefore we load som extra locations and blocks
Block playerBlock = player.getLocation().getBlock();
Block upBlock = playerBlock.getRelative(BlockFace.UP);
if (playerBlock.getType() == Material.AIR) {
return location;
} else if (upBlock.getType() == Material.AIR) {
return location.add(0, 1, 0);
} else {
return player.getLocation();
}
else if (upBlock.getType() == Material.AIR) {
return new Location(player.getLocation().getWorld(),
player.getLocation().getX(),
player.getLocation().getY() + 1,
player.getLocation().getZ(),
player.getLocation().getYaw(),
player.getLocation().getPitch());
}
return null;
}
}
}

32
src/de/craftinc/gates/commands/CommandClose.java Normal file
View File

@ -0,0 +1,32 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Plugin;
public class CommandClose extends BaseCommand
{
public CommandClose()
{
aliases.add("close");
requiredParameters.add("id");
helpDescription = "Closes a gate to prevent players from using it.";
requiredPermission = Plugin.permissionManage;
}
@Override
public void perform()
{
try {
gate.setOpen(false);
}
catch(Exception e) {
}
sendMessage("The gate was closed.");
}
}

58
src/de/craftinc/gates/commands/CommandCreate.java Normal file
View File

@ -0,0 +1,58 @@
package de.craftinc.gates.commands;
import org.bukkit.Location;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
public class CommandCreate extends BaseLocationCommand
{
public CommandCreate()
{
aliases.add("create");
aliases.add("new");
requiredParameters.add("id");
senderMustBePlayer = true;
hasGateParam = false;
helpDescription = "Create a gate at your current location.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
String id = parameters.get(0);
try {
gate = Gate.create(id);
}
catch (Exception e) {
System.out.println(e.getMessage());
}
Location playerLocation = getValidPlayerLocation();
if (playerLocation != null) {
try {
gate.setLocation(playerLocation);
}
catch (Exception e) {
}
sendMessage("Gate with id \"" + id + "\" was created.");
sendMessage("The gates location has been set to your current location.");
}
else {
sendMessage("Gate with id \"" + id + "\" was created.");
sendMessage("Now you should build a frame and:");
sendMessage(new CommandSetLocation().getUsageTemplate(true, true));
}
}
}

31
src/de/craftinc/gates/commands/CommandDelete.java Normal file
View File

@ -0,0 +1,31 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
public class CommandDelete extends BaseCommand
{
public CommandDelete()
{
aliases.add("delete");
aliases.add("del");
aliases.add("remove");
aliases.add("rm");
requiredParameters.add("id");
senderMustBePlayer = false;
helpDescription = "Removes the gate from the game.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
Gate.delete(gate.getId());
sendMessage("Gate with id '" + gate.getId() + "' was deleted.");
}
}

54
src/de/craftinc/gates/commands/CommandExit.java
View File

@ -1,54 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import java.util.logging.Level;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
import de.craftinc.gates.Plugin;
import org.bukkit.Location;
public class CommandExit extends BaseCommand {
public CommandExit() {
aliases.add("exit");
aliases.add("e");
requiredParameters.add("id");
helpDescription = "Change exit of location.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = true;
shouldPersistToDisk = true;
senderMustBePlayer = true;
}
public void perform() {
try {
Location oldExit = gate.getExit();
gate.setExit(player.getLocation());
sendMessage(ChatColor.GREEN + "The exit of gate '" + gate.getId() + "' is now where you stand.");
gatesManager.handleGateExitChange(gate, oldExit);
} catch (Exception e) {
GateBlockChangeSender.updateGateBlocks(gate);
sendMessage(ChatColor.RED + "Setting the exit for the gate failed! See server log for more information");
Plugin.log(Level.WARNING, e.getMessage());
e.printStackTrace();
}
}
}

130
src/de/craftinc/gates/commands/CommandHelp.java
View File

@ -1,68 +1,94 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import java.util.ArrayList;
import org.bukkit.command.CommandSender;
import de.craftinc.gates.util.TextUtil;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CommandHelp extends BaseCommand
{
public class CommandHelp extends BaseCommand {
private static List<String> help;
public CommandHelp() {
public CommandHelp()
{
aliases.add("help");
aliases.add("h");
aliases.add("?");
helpDescription = "prints this help page";
requiredPermission = PermissionController.permissionInfo;
optionalParameters.add("page");
hasGateParam = false;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = false;
senderMustBePlayer = false;
helpDescription = "Prints a list of all availible commands.";
}
public void perform() {
sendMessage(TextUtil.titleSize("Craft Inc. Gates Help"));
sendMessage(getHelp());
@Override
public boolean hasPermission(CommandSender sender)
{
return true;
}
private List<String> getHelp() {
if (help == null) {
help = Arrays.asList(
new CommandHelp().getUsageTemplate(true),
new CommandNew().getUsageTemplate(true),
new CommandRemove().getUsageTemplate(true),
new CommandLocation().getUsageTemplate(true),
new CommandExit().getUsageTemplate(true),
new CommandTriggerOpen().getUsageTemplate(true),
new CommandRename().getUsageTemplate(true),
new CommandList().getUsageTemplate(true),
new CommandInfo().getUsageTemplate(true),
new CommandNearby().getUsageTemplate(true),
new CommandTriggerVehicles().getUsageTemplate(true),
new CommandTeleport().getUsageTemplate(true),
new CommandMaterial().getUsageTemplate(true)
);
Collections.sort(help);
public void perform()
{
int page = 1;
if (parameters.size() > 0)
{
try
{
page = Integer.parseInt(parameters.get(0));
}
catch (NumberFormatException e)
{
// wasn't an integer
}
}
return help;
sendMessage(TextUtil.titleize("Craft Inc. Gates Help ("+page+"/"+helpPages.size()+")"));
page -= 1;
if (page < 0 || page >= helpPages.size())
{
sendMessage("This page does not exist");
return;
}
sendMessage(helpPages.get(page));
}
//----------------------------------------------//
// Build the help pages
//----------------------------------------------//
public static ArrayList<ArrayList<String>> helpPages;
static
{
helpPages = new ArrayList<ArrayList<String>>();
ArrayList<String> pageLines;
pageLines = new ArrayList<String>();
pageLines.add( new CommandHelp().getUsageTemplate(true, true) );
pageLines.add( new CommandCreate().getUsageTemplate(true, true) );
pageLines.add( new CommandDelete().getUsageTemplate(true, true) );
pageLines.add( new CommandSetLocation().getUsageTemplate(true, true) );
pageLines.add( new CommandSetExit().getUsageTemplate(true, true) );
pageLines.add( new CommandOpen().getUsageTemplate(true, true) );
helpPages.add(pageLines);
pageLines = new ArrayList<String>();
pageLines.add( new CommandRename().getUsageTemplate(true, true) );
pageLines.add( new CommandClose().getUsageTemplate(true, true) );
pageLines.add( new CommandList().getUsageTemplate(true, true) );
pageLines.add( new CommandInfo().getUsageTemplate(true, true) );
pageLines.add( new CommandSetHidden().getUsageTemplate(true, true) );
pageLines.add( new CommandSetVisible().getUsageTemplate(true, true) );
helpPages.add(pageLines);
}
}

115
src/de/craftinc/gates/commands/CommandInfo.java
View File

@ -1,113 +1,52 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.util.TextUtil;
import org.bukkit.entity.Player;
import java.util.HashSet;
public class CommandInfo extends BaseCommand {
public CommandInfo() {
public class CommandInfo extends BaseCommand
{
public CommandInfo()
{
aliases.add("info");
aliases.add("i");
optionalParameters.add("id");
helpDescription = "Print detailed information about a certain or the closest gate.";
requiredPermission = PermissionController.permissionInfo;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = false;
senderMustBePlayer = false;
hasGateParam = false;
aliases.add("details");
requiredParameters.add("id");
helpDescription = "Prints detailed informations about a certain gate.";
requiredPermission = Plugin.permissionInfo;
}
public void perform() {
if (this.parameters.size() > 0) {
if (!this.setGateUsingParameter(this.parameters.get(0))) {
sendMessage(ChatColor.RED + "You either provided a invalid gate or do not have permission to " + this.helpDescription.toLowerCase());
return;
}
public void perform()
{
sendMessage(ChatColor.LIGHT_PURPLE + "Information about " + ChatColor.WHITE + gate.getId() + ChatColor.LIGHT_PURPLE + ":");
sendMessage(TextUtil.titleSize("Information about: '" + ChatColor.WHITE + gate.getId() + ChatColor.YELLOW + "'"));
} else {
boolean senderIsPlayer = this.sender instanceof Player;
if (!senderIsPlayer) {
sendMessage(ChatColor.RED + "Only ingame players can perform this command without a supplied gate id!");
return;
}
Player p = (Player) this.sender;
this.gate = gatesManager.getNearestGate(p.getLocation());
if (!this.hasPermission() || this.gate == null) {
sendMessage(ChatColor.RED + "There is either no gate nearby or you do not have permission to " + this.helpDescription.toLowerCase());
return;
}
Plugin.log(this.gate.toString());
sendMessage(TextUtil.titleSize("Information about closest gate: '" + ChatColor.WHITE + gate.getId() + ChatColor.YELLOW + "'"));
}
String openMessage = ChatColor.DARK_AQUA + "This gate is";
String openHiddenMessage = "This gate is";
if (gate.isOpen())
openMessage += ChatColor.AQUA + " open";
openHiddenMessage += " open";
else
openMessage += ChatColor.AQUA + " closed";
openHiddenMessage += " closed";
openMessage += ".\n";
if (gate.isHidden())
openHiddenMessage += " and hidden";
sendMessage(openMessage);
openHiddenMessage += ".";
sendMessage(openHiddenMessage);
if (gate.getLocation() != null)
sendMessage(ChatColor.DARK_AQUA + "location: " + ChatColor.AQUA + "( " + (int) gate.getLocation().getX() +
" | " + (int) gate.getLocation().getY() + " | " + (int) gate.getLocation().getZ() + " ) in " +
gate.getLocation().getWorld().getName());
sendMessage(ChatColor.GREEN + "'from' location: " + ChatColor.YELLOW + "( " + gate.getLocation().getBlockX() + " | " + gate.getLocation().getBlockY() + " | " + gate.getLocation().getBlockZ() + " ) in " + gate.getLocation().getWorld().getName());
else
sendMessage(ChatColor.DARK_AQUA + "NOTE: this gate has no location");
sendMessage(ChatColor.GREEN + "this gate has no 'from' location");
if (gate.getExit() != null)
sendMessage(ChatColor.DARK_AQUA + "exit: " + ChatColor.AQUA + "( " + (int) gate.getExit().getX() + " | "
+ (int) gate.getExit().getY() + " | " + (int) gate.getExit().getZ() + " ) in " +
gate.getExit().getWorld().getName());
sendMessage(ChatColor.GREEN + "'to' location: " + ChatColor.YELLOW + "( " + gate.getExit().getBlockX() + " | " + gate.getExit().getBlockY() + " | " + gate.getExit().getBlockZ() + " ) in " + gate.getExit().getWorld().getName());
else
sendMessage(ChatColor.DARK_AQUA + "NOTE: this gate has no exit");
if (gate.getAllowsVehicles())
sendMessage(ChatColor.DARK_AQUA + "You can ride through this gate.");
sendMessage(ChatColor.DARK_AQUA + "This gate is made of "
+ ChatColor.AQUA + gate.getMaterial() + ChatColor.DARK_AQUA + ".");
if (this.sender instanceof Player) {
HashSet<Gate> set = new HashSet<>();
set.add(this.gate);
GateBlockChangeSender.temporaryHighlightGatesFrames((Player)this.sender, set);
}
sendMessage(ChatColor.GREEN + "this gate has no 'to' location");
}
}

365
src/de/craftinc/gates/commands/CommandList.java
View File

@ -1,19 +1,3 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import java.util.ArrayList;
@ -21,276 +5,199 @@ import java.util.Collection;
import java.util.Collections;
import java.util.List;
import de.craftinc.gates.controllers.PermissionController;
import org.bukkit.ChatColor;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.util.TextUtil;
public class CommandList extends BaseCommand {
private static final int linesPerPage = 15;
/* this is actually not true. the font used by Minecraft is not
monospaced. but there seems to be no (easy) way to calculate
the drawing-size of a string.
*/
private static final int charactersPerLine = 52;
public CommandList() {
public class CommandList extends BaseCommand
{
public CommandList()
{
aliases.add("list");
aliases.add("ls");
optionalParameters.add("page");
hasGateParam = false;
needsPermissionAtCurrentLocation = false;
helpDescription = "lists all availible gates.";
helpDescription = "Prints a list of all availible gates.";
requiredPermission = PermissionController.permissionInfo;
shouldPersistToDisk = false;
senderMustBePlayer = false;
requiredPermission = Plugin.permissionInfo;
}
public void perform() {
int page = this.getPageParameter();
List<String> allPages = this.pagedGateIds();
if (allPages == null) { // no gates exist
sendMessage(ChatColor.RED + "There are no gates yet. " + ChatColor.RESET +
"(Note that you might not be allowed to get information about certain gates)");
return;
protected String intToTitleString(int i)
{
if ( i < 26 ) {
return ChatColor.GREEN + "" + (char)(i+65) + ":";
}
if (page > allPages.size() || page < 1) {
sendMessage(ChatColor.RED + "The requested page is not available");
return;
else if ( i == 26 ) {
return ChatColor.GREEN + "0 - 9:";
}
String message = TextUtil.titleSize("List of all gates (" + page + "/" + allPages.size() + ")") + "\n";
message += allPages.get(page - 1);
sendMessage(message);
}
private static List<String> linesOfGateIds(List<String> gates) {
List<String> lines = new ArrayList<>();
int index = 0;
List<String> gateIdsForCurrentLine = new ArrayList<>();
int numCharactersInCurrentLine = 0;
while (index < gates.size()) {
String gateId = gates.get(index);
int gateIdLength = gateId.length() + 2; // actual length + comma + whitespace
if (gateIdLength > charactersPerLine && numCharactersInCurrentLine == 0) { // special case: very long gate id
gateIdsForCurrentLine = new ArrayList<>();
numCharactersInCurrentLine = 0;
while ((gateId.length() + 2) > charactersPerLine) {
int cutPos = charactersPerLine;
// is the id too long to add comma and whitespace but not longer than the line?
if (gateId.length() <= charactersPerLine) {
cutPos -= 2;
}
lines.add(gateId.substring(0, cutPos));
gateId = gateId.substring(cutPos, gateId.length());
}
gateIdsForCurrentLine.add(gateId);
numCharactersInCurrentLine += gateId.length();
index++;
} else if ((numCharactersInCurrentLine + gateIdLength) <= charactersPerLine) { // gate fits into current line
gateIdsForCurrentLine.add(gateId);
numCharactersInCurrentLine += gateIdLength;
index++;
} else { // the current gate does not fit on the
lines.add(TextUtil.implode(gateIdsForCurrentLine, ", ") + ", ");
gateIdsForCurrentLine = new ArrayList<>();
numCharactersInCurrentLine = 0;
else {
return ChatColor.GREEN + "!@#$:";
}
}
lines.add(TextUtil.implode(gateIdsForCurrentLine, ", "));
return lines;
// pages start at 1
// will return null if requested page not availible
protected List<String> message(int page)
{
Collection<Gate> gates = Gate.getAll();
if (gates.size() == 0) {
return null;
}
private static String intToTitleString(int i, boolean addPreviousPageNote, boolean addNextPageNote) {
String retVal = ChatColor.DARK_AQUA + "";
if (i < 26) {
retVal += (char) (i + 65);
} else if (i == 26) {
retVal += "0-9";
} else {
retVal += "!@#$";
}
if (addPreviousPageNote && addNextPageNote) {
retVal += " (more on previous and next page)";
} else if (addPreviousPageNote) {
retVal += " (more on previous page)";
} else if (addNextPageNote) {
retVal += " (more on next page)";
}
return retVal + "\n";
}
/**
* Method for getting a collection of gates the player is allowed to see.
*/
private Collection<Gate> getAllGates() {
Collection<Gate> gates = gatesManager.allGates();
// create a copy since we cannot iterate over a collection while modifying it!
Collection<Gate> gatesCopy = new ArrayList<>(gates);
for (Gate gate : gatesCopy) {
if (!this.permissionController.hasPermission(this.sender, gate, this.requiredPermission)) {
gates.remove(gate);
}
}
return gates;
}
/**
* Sorts all gates by there first character.
* Puts gates in corresponding Lists: (all returned lists will be sorted alphabetically)
* list 0-25: a,b,c,..,z
/* sort all gates by there first character
* put gates in corresponding Lists
* list 0-25: a,b,c, ... ,z
* list 26: 0-9
* list 27: other
*/
private static List<List<String>> gatesSortedByName(Collection<Gate> allGates) {
// create the lists
List<List<String>> ids = new ArrayList<>();
List<List<String>> ids = new ArrayList<List<String>>();
for (int i = 0; i < 28; i++) {
for (int i=0; i<28; i++) {
ids.add(new ArrayList<String>());
}
// put all gates into correct lists
for (Gate gate : allGates) {
for (Gate gate : gates) {
String id = gate.getId();
int first = id.charAt(0);
if (first > 96 && first < 123) { // convert lower case chars
first -= 97;
} else if (first > 64 && first < 91) { // convert upper case chars
}
else if (first > 64 && first < 91) { // convert upper case chars
first -= 65;
} else if (first > 47 && first < 58) { // convert numbers
}
else if (first > 47 && first < 58) { // convert numbers
first = 26;
} else { // everything else
}
else { // everything else
first = 27;
}
ids.get(first).add(id);
}
// sort everything
for (int i = 0; i < 28; i++) {
Collections.sort(ids.get(i));
}
return ids;
}
/**
* Returns a list of strings.
* Each string is the text for a page.
* The maximum number of lines per page is 'linesPerPage' minus 1.
* Will return an empty list if no gates are availible.
/* calculating which gates will be displayed on which page.
* this is a little bit fuzzy. but hopefully it will look
* great. (tell me if there is a better way!)
*/
private List<String> pagedGateIds() {
Collection<Gate> gates = this.getAllGates();
if (gates.size() == 0) {
int currentPage = 1;
int currentStartingCharList = 0;
boolean finishedCurrentIds = true;
List<String> pageMessages = new ArrayList<String>();
while (currentStartingCharList < ids.size()) {
int linesLeftOnCurrentPage = 9;
while (linesLeftOnCurrentPage > 1 && currentStartingCharList < ids.size()) {
List<String> currentIds = ids.get(currentStartingCharList);
if (currentIds.size() > 0) {
// add header line
if (currentPage == page) {
pageMessages.add(intToTitleString(currentStartingCharList));
}
//sort
Collections.sort(currentIds);
// add ids
int numLinesForCurrentChar = TextUtil.implode(currentIds, ", ").length() / 52 + 2;
if (numLinesForCurrentChar <= linesLeftOnCurrentPage) { // all ids fit on current page
linesLeftOnCurrentPage -= numLinesForCurrentChar;
if (currentPage == page) {
pageMessages.add(TextUtil.implode(currentIds, ", "));
if (finishedCurrentIds == false) {
pageMessages.set(pageMessages.size() -2, pageMessages.get(pageMessages.size() -2) + " (more on previous page)");
}
}
finishedCurrentIds = true;
}
else { // NOT all ids fit on current page
int charsAvailible = (linesLeftOnCurrentPage - 1) * 52;
int idsPos = 0;
do {
charsAvailible -= currentIds.get(idsPos).length() + 2;
idsPos++;
} while (charsAvailible > 0);
List<String> idsToPutOnCurrentPage = currentIds.subList(0, idsPos);
currentIds.remove(idsToPutOnCurrentPage);
String stringToPutOnCurrentPage = TextUtil.implode(idsToPutOnCurrentPage, ", ");
if (currentPage == page) {
pageMessages.add(stringToPutOnCurrentPage);
pageMessages.set(pageMessages.size() -2, pageMessages.get(pageMessages.size() -2) + " (more on next page)");
}
linesLeftOnCurrentPage -= stringToPutOnCurrentPage.length() / 52 + 2;
finishedCurrentIds = false;
}
}
if (finishedCurrentIds) {
currentStartingCharList++;
}
}
currentPage++;
}
if (pageMessages.isEmpty()) {
return null;
}
else {
ArrayList<String> retVal = new ArrayList<String>();
retVal.add(ChatColor.LIGHT_PURPLE + "This is page " + ChatColor.WHITE + page + ChatColor.LIGHT_PURPLE + "/" + ChatColor.WHITE + --currentPage + ChatColor.LIGHT_PURPLE + ". There are " + gates.size() + " gates on this server: ");
retVal.addAll(pageMessages);
List<List<String>> gatesSortedByName = gatesSortedByName(gates);
List<String> allPages = new ArrayList<>();
int linesLeftOnPage = linesPerPage - 1;
String currentPageString = "";
for (int i = 0; i < gatesSortedByName.size(); i++) {
List<String> currentGates = gatesSortedByName.get(i);
if (currentGates.isEmpty()) {
continue;
}
List<String> currentGatesAsLines = linesOfGateIds(currentGates);
boolean moreGatesOnLastPage = false;
while (!currentGatesAsLines.isEmpty()) {
if (linesLeftOnPage < 2) {
currentPageString = currentPageString.substring(0, currentPageString.length() - 2); // remove newlines add the end of the page
allPages.add(currentPageString);
currentPageString = "";
linesLeftOnPage = linesPerPage - 1;
}
// calculate number of lines to add to current page
int linesNecessaryForCurrentGates = currentGatesAsLines.size();
int linesToFill;
boolean moreGatesOnNextPage;
if (linesNecessaryForCurrentGates < linesLeftOnPage) {
linesToFill = linesNecessaryForCurrentGates;
moreGatesOnNextPage = false;
} else {
linesToFill = linesLeftOnPage - 1;
moreGatesOnNextPage = true;
}
// add title
currentPageString += intToTitleString(i, moreGatesOnLastPage, moreGatesOnNextPage);
currentPageString += ChatColor.AQUA;
linesLeftOnPage--;
// add gate lines
for (int j = 0; j < linesToFill; j++) {
currentPageString += currentGatesAsLines.get(j) + "\n";
}
// remove lines added
for (int j = 0; j < linesToFill; j++) {
currentGatesAsLines.remove(0);
}
// cleanup
moreGatesOnLastPage = linesNecessaryForCurrentGates >= linesLeftOnPage;
linesLeftOnPage -= linesToFill;
return retVal;
}
}
// add the last page
if (!currentPageString.isEmpty()) {
currentPageString = currentPageString.substring(0, currentPageString.length() - 2); // remove newlines add the end of the page
allPages.add(currentPageString);
public void perform()
{
Collection<Gate> gates = Gate.getAll();
if (gates.size() == 0) {
sendMessage("There are no gates yet.");
}
return allPages;
}
private int getPageParameter() {
else {
int page = 1;
try {
page = new Integer(parameters.get(0));
} catch (Exception ignored) {
}
catch (Exception e) {
}
return page;
List<String> messages = message(page);
if (messages == null) {
sendMessage("The requested page is not availible");
}
else {
sendMessage(messages);
}
}
}
}

70
src/de/craftinc/gates/commands/CommandLocation.java
View File

@ -1,70 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import java.util.Set;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.block.Block;
public class CommandLocation extends BaseLocationCommand {
public CommandLocation() {
aliases.add("location");
aliases.add("lo");
requiredParameters.add("id");
helpDescription = "Set the entrance of the gate to your current location.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = true;
shouldPersistToDisk = true;
senderMustBePlayer = true;
}
public void perform() {
Location playerLocation = getValidPlayerLocation();
if (playerLocation == null) {
sendMessage("There is not enough room for a gate to open here");
return;
}
Location oldLocation = gate.getLocation();
Set<Location> oldGateBlockLocations = gate.getGateBlockLocations();
Set<Block> oldFrameBlocks = gate.getGateFrameBlocks();
try {
if (gate.isOpen()) {
GateBlockChangeSender.updateGateBlocks(gate, true);
}
gate.setLocation(playerLocation);
sendMessage(ChatColor.GREEN + "The location of '" + gate.getId() + "' is now at your current location.");
} catch (Exception e) {
sendMessage(ChatColor.RED + "There seems to be no frame at your new location! The gate got closed!" + ChatColor.AQUA + " You should build a frame now and execute:");
sendMessage(new CommandTriggerOpen().getUsageTemplate(true));
} finally {
gatesManager.handleGateLocationChange(gate, oldLocation, oldGateBlockLocations, oldFrameBlocks);
GateBlockChangeSender.updateGateBlocks(gate);
}
}
}

45
src/de/craftinc/gates/commands/CommandMaterial.java
View File

@ -1,45 +0,0 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.models.GateMaterial;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
import java.security.InvalidParameterException;
public class CommandMaterial extends BaseCommand {
public CommandMaterial() {
aliases.add("material");
aliases.add("m");
requiredParameters.add("id");
requiredParameters.add("material");
senderMustBePlayer = false;
hasGateParam = true;
helpDescription = "Change the material of a gate";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = true;
}
public void perform() {
GateMaterial material;
try {
material = new GateMaterial(parameters.get(1));
} catch (InvalidParameterException e) {
sendMessage(ChatColor.RED + "Invalid material!");
return;
}
try {
gate.setMaterial(material);
} catch (Exception e) {
sendMessage(ChatColor.RED + "Frame invalid. Gate is now closed!");
}
GateBlockChangeSender.updateGateBlocks(gate);
sendMessage(ChatColor.GREEN + "Gate " + gate.getId() + " uses now " + material.toString() + " as material.");
}
}

41
src/de/craftinc/gates/commands/CommandNearby.java
View File

@ -1,41 +0,0 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import de.craftinc.gates.util.TextUtil;
import java.util.ArrayList;
import java.util.Set;
public class CommandNearby extends BaseLocationCommand {
public CommandNearby() {
aliases.add("nearby");
aliases.add("nb");
helpDescription = "Highlight nearby gates";
requiredPermission = PermissionController.permissionInfo;
needsPermissionAtCurrentLocation = true;
shouldPersistToDisk = false;
senderMustBePlayer = true;
hasGateParam = false;
}
public void perform() {
Set<Gate> nearbyGates = gatesManager.getNearbyGates(player.getLocation().getChunk());
if (nearbyGates == null) {
player.sendMessage("There are no gates near you!");
} else {
GateBlockChangeSender.temporaryHighlightGatesFrames(player, nearbyGates);
ArrayList<String> gateNames = new ArrayList<>();
for (Gate g : nearbyGates) {
gateNames.add(g.getId());
}
player.sendMessage("Nearby gates: " + TextUtil.implode(gateNames, ", "));
}
}
}

69
src/de/craftinc/gates/commands/CommandNew.java
View File

@ -1,69 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import de.craftinc.gates.models.Gate;
public class CommandNew extends BaseLocationCommand {
public CommandNew() {
aliases.add("new");
aliases.add("create");
aliases.add("n");
requiredParameters.add("id");
senderMustBePlayer = true;
hasGateParam = false;
helpDescription = "Create a gate at your current location.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = true;
shouldPersistToDisk = true;
senderMustBePlayer = true;
}
public void perform() {
String id = parameters.get(0);
if (gatesManager.gateExists(id)) {
sendMessage(ChatColor.RED + "Creating the gate failed! " + "A gate with the supplied id already exists!");
return;
}
gate = new Gate(id);
sendMessage(ChatColor.GREEN + "Gate with id '" + id + "' was created.");
Location playerLocation = getValidPlayerLocation();
if (playerLocation != null) {
try {
gate.setLocation(playerLocation);
sendMessage(ChatColor.AQUA + "The gates location has been set to your current location.");
} catch (Exception ignored) {
}
} else {
sendMessage(ChatColor.RED + "Your location is invalid!" + ChatColor.AQUA + "Go somewhere else and execute:");
sendMessage(new CommandLocation().getUsageTemplate(true));
}
gatesManager.handleNewGate(gate);
}
}

34
src/de/craftinc/gates/commands/CommandOpen.java Normal file
View File

@ -0,0 +1,34 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Plugin;
public class CommandOpen extends BaseCommand
{
public CommandOpen()
{
aliases.add("open");
requiredParameters.add("id");
helpDescription = "Open a gate so players can use it.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
try {
gate.setOpen(true);
} catch (Exception e) {
sendMessage(e.getMessage());
return;
}
sendMessage("The gate was opened.");
}
}

48
src/de/craftinc/gates/commands/CommandRemove.java
View File

@ -1,48 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
public class CommandRemove extends BaseCommand {
public CommandRemove() {
aliases.add("delete");
aliases.add("del");
aliases.add("remove");
requiredParameters.add("id");
senderMustBePlayer = false;
helpDescription = "Removes the gate from the game.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = true;
senderMustBePlayer = false;
}
public void perform() {
gatesManager.handleDeletion(gate);
GateBlockChangeSender.updateGateBlocks(gate, true);
sendMessage(ChatColor.GREEN + "Gate with id '" + gate.getId() + "' was deleted.");
}
}

57
src/de/craftinc/gates/commands/CommandRename.java
View File

@ -1,52 +1,41 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import org.bukkit.ChatColor;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
public class CommandRename extends BaseCommand {
public CommandRename() {
public class CommandRename extends BaseCommand
{
public CommandRename()
{
aliases.add("rename");
aliases.add("rn");
aliases.add("changename");
aliases.add("cn");
hasGateParam = true;
senderMustBePlayer = false;
requiredParameters.add("current name");
requiredParameters.add("new name");
helpDescription = "Changes the id of a gate.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = true;
requiredPermission = Plugin.permissionManage;
}
public void perform() {
public void perform()
{
String newId = parameters.get(1);
if (gatesManager.gateExists(newId)) {
sendMessage(ChatColor.RED + "Cannot rename " + gate.getId() + ". There is already a gate named " + newId + ".");
} else {
String oldId = gate.getId();
gate.setId(newId);
gatesManager.handleGateIdChange(gate, oldId);
sendMessage(ChatColor.GREEN + "Gate " + gate.getId() + " is now known as " + newId + ".");
try {
Gate.rename(gate.getId(), newId);
}
catch (Exception e) {
sendMessage("Cannot rename " + gate.getId() + ". There is already a gate named " + newId + ".");
}
sendMessage("Gate " + gate.getId() + " is now known as " + newId + ".");
}
}

34
src/de/craftinc/gates/commands/CommandSetExit.java Normal file
View File

@ -0,0 +1,34 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Plugin;
public class CommandSetExit extends BaseCommand
{
public CommandSetExit()
{
aliases.add("setto");
aliases.add("st");
requiredParameters.add("id");
helpDescription = "Changes the location where the gate will teleport players to your current location.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
try {
gate.setExit(player.getLocation());
}
catch (Exception e) {
sendMessage(e.getMessage());
}
sendMessage("The exit of gate '" + gate.getId() + "' is now where you stand.");
}
}

32
src/de/craftinc/gates/commands/CommandSetHidden.java Normal file
View File

@ -0,0 +1,32 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Plugin;
public class CommandSetHidden extends BaseCommand
{
public CommandSetHidden()
{
aliases.add("setHidden");
aliases.add("sh");
requiredParameters.add("id");
helpDescription = "Makes a gate NOT consist of gate blocks while open.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
try {
gate.setHidden(true);
}
catch (Exception e) {
sendMessage(e.getMessage());
}
sendMessage("The gate '" + gate.getId() + "' is now hidden.");
}
}

45
src/de/craftinc/gates/commands/CommandSetLocation.java Normal file
View File

@ -0,0 +1,45 @@
package de.craftinc.gates.commands;
import org.bukkit.Location;
import de.craftinc.gates.Plugin;
public class CommandSetLocation extends BaseLocationCommand
{
public CommandSetLocation()
{
aliases.add("setlocation");
aliases.add("sl");
requiredParameters.add("id");
helpDescription = "Set the entrance of the gate to your current location.";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
Location playerLocation = getValidPlayerLocation();
if (playerLocation == null) {
sendMessage("There is not enough room for a gate to open here");
return;
}
try {
gate.setLocation(playerLocation);
}
catch (Exception e) {
sendMessage(e.getMessage());
}
sendMessage("The location of '" + gate.getId() + "' is now at your current location.");
}
}

34
src/de/craftinc/gates/commands/CommandSetVisible.java Normal file
View File

@ -0,0 +1,34 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.Plugin;
public class CommandSetVisible extends BaseCommand
{
public CommandSetVisible()
{
aliases.add("makevisible");
aliases.add("mv");
requiredParameters.add("id");
helpDescription = "Make that gate visible";
requiredPermission = Plugin.permissionManage;
}
public void perform()
{
try {
gate.setHidden(false);
}
catch (Exception e) {
sendMessage(e.getMessage());
}
sendMessage("The gate " + gate.getId() + " is now visible.");
}
}

23
src/de/craftinc/gates/commands/CommandTeleport.java
View File

@ -1,23 +0,0 @@
package de.craftinc.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
public class CommandTeleport extends BaseCommand {
public CommandTeleport() {
aliases.add("teleport");
aliases.add("t");
requiredParameters.add("id");
senderMustBePlayer = true;
hasGateParam = true;
helpDescription = "Teleport to the location of a gate";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = false;
}
public void perform() {
}
}

54
src/de/craftinc/gates/commands/CommandTriggerOpen.java
View File

@ -1,54 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.ChatColor;
public class CommandTriggerOpen extends BaseCommand {
public CommandTriggerOpen() {
aliases.add("triggerOpen");
aliases.add("o");
requiredParameters.add("id");
helpDescription = "Open/close a gate.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = true;
senderMustBePlayer = false;
}
public void perform() {
try {
if (!gate.isOpen() && gate.getExit() == null && player != null) {
gate.setExit(player.getLocation());
sendMessage(ChatColor.GREEN + "The exit of gate '" + gate.getId() + "' is now where you stand.");
}
gate.setOpen(!gate.isOpen());
GateBlockChangeSender.updateGateBlocks(gate);
gatesManager.handleGateLocationChange(gate, null, null, null);
sendMessage(ChatColor.GREEN + "The gate is now " + (gate.isOpen() ? "open." : "closed."));
} catch (Exception e) {
sendMessage(ChatColor.RED + e.getMessage());
}
}
}

47
src/de/craftinc/gates/commands/CommandTriggerVehicles.java
View File

@ -1,47 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.commands;
import de.craftinc.gates.controllers.PermissionController;
import org.bukkit.ChatColor;
public class CommandTriggerVehicles extends BaseCommand {
public CommandTriggerVehicles() {
aliases.add("vehicles");
aliases.add("v");
requiredParameters.add("id");
helpDescription = "Allow/deny players to travel while riding.";
requiredPermission = PermissionController.permissionManage;
needsPermissionAtCurrentLocation = false;
shouldPersistToDisk = true;
senderMustBePlayer = false;
}
@Override
protected void perform() {
gate.setAllowsVehicles(gate.getAllowsVehicles());
if (gate.getAllowsVehicles()) {
sendMessage(ChatColor.GREEN + "Traveling while riding is now enabled for this gate.");
} else {
sendMessage(ChatColor.GREEN + "Traveling while riding is now disabled for this gate.");
}
}
}

477
src/de/craftinc/gates/controllers/GatesManager.java
View File

@ -1,477 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.controllers;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.*;
import java.util.logging.Level;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.persistence.MigrationUtil;
import de.craftinc.gates.util.ConfigurationUtil;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import de.craftinc.gates.models.SimpleChunk;
import de.craftinc.gates.models.SimpleLocation;
public class GatesManager {
protected List<Gate> gates;
private static final String gatesPath = "gates"; // path to gates inside the yaml file
private static final String storageVersionPath = "version";
private static final int storageVersion = 3;
private File gatesConfigFile;
private FileConfiguration gatesConfig;
private int chunkRadius;
private Map<String, Gate> gatesById;
private Map<SimpleChunk, Set<Gate>> gatesByChunk;
private Map<SimpleLocation, Gate> gatesByLocation;
private Map<SimpleLocation, Gate> gatesByFrameLocation;
private boolean storageFileIsInvalid = false;
public Gate getGateWithId(final String id) {
return gatesById.get(id.toLowerCase());
}
public Set<Gate> getNearbyGates(final Chunk chunk) {
SimpleChunk simpleChunk = new SimpleChunk(chunk);
return gatesByChunk.get(simpleChunk);
}
/**
* Returns the closest gate.
*
* @param location The location at which to look for a gate.
* @return Might return null if there are no nearby gates.
*/
public Gate getNearestGate(final Location location) {
Set<Gate> nearbyGates = getNearbyGates(location.getChunk());
if (nearbyGates == null) {
return null;
}
double minDist = Double.MAX_VALUE;
Gate nearestGate = null;
for (Gate g : nearbyGates) {
double dist = location.distance(g.getLocation());
if (dist < minDist) {
minDist = dist;
nearestGate = g;
}
}
return nearestGate;
}
Gate getGateAtLocation(final Location location) {
SimpleLocation simpleLocation = new SimpleLocation(location);
return gatesByLocation.get(simpleLocation);
}
public Gate getGateAtFrameLocation(final Location location) {
SimpleLocation simpleLocation = new SimpleLocation(location);
return gatesByFrameLocation.get(simpleLocation);
}
public void saveGatesToDisk() {
if (storageFileIsInvalid) {
Plugin.log(Level.SEVERE, "ERROR: Not saving gates to disk. Storage file is invalid or corrupted!");
return;
}
gatesConfig.set(gatesPath, gates);
gatesConfig.set(storageVersionPath, storageVersion);
try {
gatesConfig.save(gatesConfigFile);
Plugin.log("Saved gates to disk.");
} catch (IOException e) {
Plugin.log(Level.SEVERE, "ERROR: Could not save gates to disk.");
e.printStackTrace();
}
}
@SuppressWarnings("unchecked")
public boolean loadGatesFromDisk() {
// TODO: refactor: move loading/saving logic into persistence package
this.gatesConfigFile = new File(Plugin.getPlugin().getDataFolder(), "gates.yml");
if (!this.gatesConfigFile.exists()) {
try {
boolean isNew = this.gatesConfigFile.createNewFile();
if (isNew) {
Plugin.log(Level.FINEST, "Created gate storage file.");
}
} catch (IOException e) {
this.storageFileIsInvalid = true;
Plugin.log(Level.SEVERE, "Cannot create gate storage file! No gates will be persisted.");
return false;
}
}
this.gatesConfig = new YamlConfiguration();
try {
this.gatesConfig.load(this.gatesConfigFile);
} catch (Exception e) {
this.storageFileIsInvalid = true;
Plugin.log(Level.SEVERE, "Gate file on disk is invalid. No gates loaded. Plugin will be disabled! (" + Arrays.toString(e.getStackTrace()) + ")");
return false;
}
this.gates = (List<Gate>) gatesConfig.getList(gatesPath);
if (this.gates == null) {
this.gates = new ArrayList<>();
}
for (Object o : this.gates) {
if (!(o instanceof Gate)) {
this.storageFileIsInvalid = true;
Plugin.log(Level.SEVERE, "Gate file on disk is invalid. No gates loaded. Plugin will be disabled! (Invalid gate class detected)");
return false;
}
}
for (Gate g : this.gates) {
try {
g.validate();
} catch (Exception e) {
try {
g.setOpen(false);
} catch (Exception ignored) {
}
Plugin.log(Level.FINER, "closed gate '" + g.getId() + "' reason: " + e.getMessage());
}
}
fillGatesById();
fillGatesByChunk();
fillGatesByLocation();
fillGatesByFrameLocation();
Plugin.log("Loaded " + this.gates.size() + " gates.");
// migration
int fileStorageVersion = gatesConfig.getInt(storageVersionPath);
if (fileStorageVersion > storageVersion) {
this.storageFileIsInvalid = true;
Plugin.log(Level.SEVERE, "Unsupported storage version detected! Make sure you have the latest version of Craft Inc. Gates installed. Plugin will be disabled!");
return false;
}
if (fileStorageVersion < storageVersion && !this.gates.isEmpty()) {
Plugin.log("Outdated storage version detected. Performing data migration...");
boolean success = MigrationUtil.performMigration(fileStorageVersion, storageVersion, this.gates);
this.storageFileIsInvalid = !success;
return success;
}
return true;
}
private int getChunkRadius() {
if (this.chunkRadius == 0) {
this.chunkRadius = Plugin.getPlugin().getConfig().getInt(ConfigurationUtil.confPlayerGateBlockUpdateRadiusKey);
this.chunkRadius = this.chunkRadius >> 4;
}
return this.chunkRadius;
}
private void fillGatesById() {
gatesById = new HashMap<>((int) (gates.size() * 1.25));
for (Gate g : gates) {
this.addGateWithId(g);
}
}
private void fillGatesByChunk() {
HashSet<SimpleChunk> chunksUsedByGates = new HashSet<>();
for (Gate g : gates) {
if (g.getLocation() != null) {
Chunk c = g.getLocation().getChunk();
int x = c.getX();
int z = c.getZ();
for (int i = x - getChunkRadius(); i < x + getChunkRadius(); i++) {
for (int j = z - getChunkRadius(); j < z + getChunkRadius(); j++) {
chunksUsedByGates.add(new SimpleChunk(i, j, c.getWorld()));
}
}
}
}
gatesByChunk = new HashMap<>((int) (chunksUsedByGates.size() * 1.25));
for (Gate g : gates) {
this.addGateByChunk(g);
}
}
private void fillGatesByLocation() {
Set<Location> gateBlocks = new HashSet<>();
for (Gate g : gates) {
for (Location l : g.getGateBlockLocations()) {
gateBlocks.add(l);
Location headLocation = l.clone().add(0, 1, 0);
gateBlocks.add(headLocation);
}
}
gatesByLocation = new HashMap<>((int) (gateBlocks.size() * 1.25));
for (Gate g : gates) {
this.addGateByLocations(g);
}
}
private void fillGatesByFrameLocation() {
int numFrameBlocks = 0;
for (Gate g : gates) {
numFrameBlocks += g.getGateFrameBlocks().size();
}
gatesByFrameLocation = new HashMap<>((int) (numFrameBlocks * 1.25));
for (Gate g : gates) {
this.addGateByFrameLocations(g);
}
}
private void removeGateById(final String id) {
gatesById.remove(id);
}
private void addGateWithId(final Gate g) {
gatesById.put(g.getId(), g);
}
private void removeGateByLocation(final Set<Location> gateBlocks) {
if (gateBlocks != null) {
for (Location l : gateBlocks) {
SimpleLocation sl = new SimpleLocation(l);
gatesByLocation.remove(sl);
SimpleLocation headLocation = new SimpleLocation(l, true);
gatesByLocation.remove(headLocation);
}
}
}
private void removeGateByFrameLocation(final Set<Block> gateFrameBlocks) {
if (gateFrameBlocks != null) {
for (Block block : gateFrameBlocks) {
SimpleLocation sl = new SimpleLocation(block.getLocation());
gatesByFrameLocation.remove(sl);
}
}
}
private void addGateByLocations(final Gate g) {
for (Location l : g.getGateBlockLocations()) {
SimpleLocation sl = new SimpleLocation(l);
gatesByLocation.put(sl, g);
SimpleLocation headLocation = new SimpleLocation(l, true);
gatesByLocation.put(headLocation, g);
}
}
private void addGateByFrameLocations(final Gate g) {
for (Block block : g.getGateFrameBlocks()) {
SimpleLocation sl = new SimpleLocation(block.getLocation());
gatesByFrameLocation.put(sl, g);
}
}
private void removeGateFromChunk(final Gate g, final Location l) {
if (l != null) {
Chunk c = l.getChunk();
int x = c.getX();
int z = c.getZ();
for (int i = x - getChunkRadius(); i < x + getChunkRadius(); i++) {
for (int j = z - getChunkRadius(); j < z + getChunkRadius(); j++) {
SimpleChunk sc = new SimpleChunk(i, j, c.getWorld());
Set<Gate> gatesInChunk = gatesByChunk.get(sc);
if (gatesInChunk != null) {
gatesInChunk.remove(g);
}
}
}
}
}
private void addGateByChunk(final Gate g) {
Location gateLocation = g.getLocation();
if (gateLocation != null) {
Chunk c = g.getLocation().getChunk();
int x = c.getX();
int z = c.getZ();
for (int i = x - getChunkRadius(); i < x + getChunkRadius(); i++) {
for (int j = z - getChunkRadius(); j < z + getChunkRadius(); j++) {
SimpleChunk sc = new SimpleChunk(i, j, c.getWorld());
Set<Gate> gatesForC = gatesByChunk.get(sc);
if (gatesForC == null) {
gatesForC = new HashSet<>(); // NOTE: not optimizing size here
gatesByChunk.put(sc, gatesForC);
}
gatesForC.add(g);
}
}
}
}
public void storeInvalidGate(Map<String, Object> map) {
File invalidGatesFile = new File(Plugin.getPlugin().getDataFolder(), "invalid_gates.yml");
Boolean invalidGatesFileExists = invalidGatesFile.exists();
try {
FileWriter fileWriter = new FileWriter(invalidGatesFile, true);
if (!invalidGatesFileExists) {
fileWriter.write("gates:\n");
}
fileWriter.write("- ==: ");
fileWriter.write(map.get("==").toString() + "\n");
map.remove("==");
fileWriter.write("\topen: false\n");
map.remove("open");
fileWriter.write("\tgateBlocks: []\n");
map.remove("gateBlocks");
for (String key : map.keySet()) {
Object value = map.get(key);
fileWriter.write("\t" + key + ": ");
if (value instanceof Map) {
fileWriter.write("\n");
@SuppressWarnings("unchecked")
Map<String, Object> valueMap = (Map<String, Object>) value;
for (String k : valueMap.keySet()) {
Object v = valueMap.get(k);
fileWriter.write("\t\t" + k + ": " + v.toString() + "\n");
}
} else {
fileWriter.write(value.toString() + "\n");
}
}
fileWriter.close();
} catch (IOException e) {
Plugin.log("ERROR: Could not save invalid gates to disk. Reason: \n" + Arrays.toString(e.getStackTrace()));
}
}
public void handleGateIdChange(final Gate g, final String oldId) {
this.removeGateById(oldId);
this.addGateWithId(g);
}
public void handleGateLocationChange(final Gate g,
final Location oldLocation,
final Set<Location> oldGateBlockLocations,
final Set<Block> oldGateFrameBlocks) {
this.removeGateFromChunk(g, oldLocation);
this.addGateByChunk(g);
this.removeGateByLocation(oldGateBlockLocations);
this.addGateByLocations(g);
this.removeGateByFrameLocation(oldGateFrameBlocks);
this.addGateByFrameLocations(g);
}
public void handleGateExitChange(final Gate g, final Location oldExit) {
// nothing to do
}
public void handleNewGate(final Gate g) {
this.gates.add(g);
this.addGateByChunk(g);
this.addGateByLocations(g);
this.addGateWithId(g);
this.addGateByFrameLocations(g);
}
public void handleDeletion(final Gate g) {
this.gates.remove(g);
this.removeGateById(g.getId());
this.removeGateFromChunk(g, g.getLocation());
this.removeGateByLocation(g.getGateBlockLocations());
this.removeGateByFrameLocation(g.getGateFrameBlocks());
}
public boolean gateExists(final String id) {
return gatesById.containsKey(id.toLowerCase());
}
public List<Gate> allGates() {
return gates;
}
}

58
src/de/craftinc/gates/controllers/PermissionController.java
View File

@ -1,58 +0,0 @@
package de.craftinc.gates.controllers;
import de.craftinc.gates.models.Gate;
import net.milkbowl.vault.permission.Permission;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
public class PermissionController {
public static final String permissionInfo = "craftincgates.info";
public static final String permissionManage = "craftincgates.manage";
public static final String permissionUse = "craftincgates.use";
private Permission permission;
public void setPermission(Permission permission) {
this.permission = permission;
}
public boolean hasPermission(CommandSender sender, Gate gate, String permission) {
assert(sender != null);
assert(permission != null);
if (gate == null) {
return hasPermission(sender, permission);
}
final Location location = gate.getLocation();
final Location exit = gate.getExit();
boolean permAtLocation = location == null || hasPermission(sender, location.getWorld(), permission);
boolean permAtExit = exit == null || hasPermission(sender, exit.getWorld(), permission);
return permAtLocation && permAtExit;
}
public boolean hasPermission(CommandSender sender, String permission) {
return hasPermission(sender, (World)null, permission);
}
private boolean hasPermission(CommandSender sender, World world, String permission) {
assert(sender != null);
assert(permission != null);
if (this.permission == null) {
// fallback - use the standard bukkit permission system
return sender.hasPermission(permission);
}
if (!(sender instanceof OfflinePlayer)) {
return this.permission.has(sender, permission);
}
String worldName = world != null ? world.getName() : null;
return this.permission.playerHas(worldName, (OfflinePlayer)sender, permission);
}
}

126
src/de/craftinc/gates/controllers/TeleportController.java
View File

@ -1,126 +0,0 @@
package de.craftinc.gates.controllers;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.util.ConfigurationUtil;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.player.PlayerTeleportEvent;
import java.util.Calendar;
import java.util.HashMap;
public class TeleportController {
private TeleportMessageUtil messageUtil;
private GatesManager gatesManager;
private PermissionController permissionController;
public TeleportController(Plugin plugin) {
this.gatesManager = plugin.getGatesManager();
this.messageUtil = new TeleportMessageUtil(plugin.getConfig());
this.permissionController = plugin.getPermissionController();
}
/**
* Try teleporting a player at given location.
*/
public void teleport(final Player player, Location toLocation) {
final Gate gateAtLocation = gatesManager.getGateAtLocation(toLocation);
if ((gateAtLocation == null) || !gateAtLocation.isOpen()) {
return;
}
if (!permissionController.hasPermission(player, gateAtLocation, PermissionController.permissionUse)) {
messageUtil.sendNoPermissionMessage(player);
return;
}
this.teleportPlayer(player, gateAtLocation);
}
private void teleportPlayer(final Player player, final Gate gate) {
final Entity vehicle = player.getVehicle();
if (vehicle != null && !gate.getAllowsVehicles()) {
messageUtil.sendVehicleForbiddenMessage(player);
Plugin.log("no vehicle transport");
return;
}
final Location destination = calculateDestination(player, gate);
player.teleport(destination);
if (vehicle != null) {
vehicle.teleport(destination, PlayerTeleportEvent.TeleportCause.PLUGIN);
vehicle.setPassenger(player);
}
messageUtil.sendTeleportMessage(player);
}
private Location calculateDestination(Player player, Gate gate) {
final Location exit = gate.getExit();
final Location pLocation = player.getLocation();
final Float newYaw = exit.getYaw() - gate.getLocation().getYaw() + pLocation.getYaw();
return new Location(exit.getWorld(),
exit.getX(),
exit.getY(),
exit.getZ(),
newYaw,
pLocation.getPitch()
);
}
}
class TeleportMessageUtil {
private HashMap<String, Long> lastNoPermissionMessages = new HashMap<>();
private FileConfiguration config;
TeleportMessageUtil(FileConfiguration config) {
this.config = config;
}
void sendVehicleForbiddenMessage(Player player) {
if (!config.getBoolean(ConfigurationUtil.confShowTeleportNoPermissionMessageKey)) {
return;
}
final String notAllowedMessage = config.getString(ConfigurationUtil.confGateTeleportVehicleNotAllowedMessageKey);
player.sendMessage(ChatColor.DARK_AQUA + notAllowedMessage);
}
void sendNoPermissionMessage(Player player) {
if (!config.getBoolean(ConfigurationUtil.confShowTeleportNoPermissionMessageKey)) {
return;
}
final String playerName = player.getPlayer().getName();
if (playerName == null) {
return;
}
final Long now = Calendar.getInstance().getTimeInMillis();
// do not display messages more often than once per second
if (!this.lastNoPermissionMessages.containsKey(playerName)
|| this.lastNoPermissionMessages.get(playerName) < now - 10000L) {
final String noPermissionString = config.getString(ConfigurationUtil.confGateTeleportNoPermissionMessageKey);
player.sendMessage(ChatColor.RED + noPermissionString);
this.lastNoPermissionMessages.put(playerName, now);
}
}
void sendTeleportMessage(Player player) {
if (!config.getBoolean(ConfigurationUtil.confShowTeleportMessageKey)) {
return;
}
final String teleportMessage = config.getString(ConfigurationUtil.confGateTeleportMessageKey);
player.sendMessage(ChatColor.DARK_AQUA + teleportMessage);
}
}

97
src/de/craftinc/gates/listeners/BaseLocationListener.java Normal file
View File

@ -0,0 +1,97 @@
package de.craftinc.gates.listeners;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.event.player.PlayerMoveEvent;
import de.craftinc.gates.Gate;
public abstract class BaseLocationListener
{
protected Gate getValidGateAtPlayerLocation(PlayerMoveEvent e) {
Gate gate = null;
Location playerLocation = e.getPlayer().getLocation();
World playerWorld = playerLocation.getWorld();
Block blockTo = e.getFrom().getBlock();
Block blockToUp = blockTo.getRelative(BlockFace.UP);
for (Gate g : Gate.getAll()) {
// Check if the gate is open and useable
World gateWorld = g.getLocation().getWorld();
if (g.isOpen() == false || !gateWorld.equals(playerWorld)) {
continue;
}
// Check if the location matches
for (Location l: g.getGateBlockLocations()) {
if (locationsAreAtSamePositions(l, blockTo.getLocation()) || locationsAreAtSamePositions(l, blockToUp.getLocation())) {
// Check if the gate is still valid
try {
g.validate();
gate = g;
break;
}
catch (Exception e2) {
// do nothing - gate is closed
}
}
}
}
return gate;
}
protected Gate getGateAtPlayerLocation(PlayerMoveEvent e) {
Gate gate = null;
Block blockTo = e.getFrom().getBlock();
Block blockToUp = blockTo.getRelative(BlockFace.UP);
System.out.println(blockTo.getLocation().getWorld().getName());
for (Gate g : Gate.getAll()) {
// Check if the location matches
for (Location l: g.getGateBlockLocations()) {
if (locationsAreAtSamePositions(l, blockTo.getLocation()) || locationsAreAtSamePositions(l, blockToUp.getLocation())) {
gate = g;
}
}
}
return gate;
}
/**
* Does the same as the equal method of Location but ignores pitch and yaw.
*/
protected boolean locationsAreAtSamePositions(final Location l1, final Location l2)
{
if (l1.getWorld() != l2.getWorld() && (l1.getWorld() == null || !l1.getWorld().equals(l2.getWorld()))) {
return false;
}
if (Double.doubleToLongBits(l1.getX()) != Double.doubleToLongBits(l2.getX())) {
return false;
}
if (Double.doubleToLongBits(l1.getY()) != Double.doubleToLongBits(l2.getY())) {
return false;
}
if (Double.doubleToLongBits(l1.getZ()) != Double.doubleToLongBits(l2.getZ())) {
return false;
}
return true;
}
}

46
src/de/craftinc/gates/listeners/BlockBreakListener.java
View File

@ -1,46 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.Material;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
public class BlockBreakListener implements Listener {
@EventHandler(priority = EventPriority.MONITOR)
public void onBlockBreak(BlockBreakEvent event) {
if (event.isCancelled()) {
return;
}
Gate gate = Plugin.getPlugin().getGatesManager().getGateAtFrameLocation(event.getBlock().getLocation());
if (gate != null && gate.getMaterial().getMaterial() != Material.AIR) {
try {
gate.setOpen(false);
} catch (Exception ignored) {}
GateBlockChangeSender.updateGateBlocks(gate);
}
}
}

33
src/de/craftinc/gates/listeners/PlayerChangedWorldListener.java
View File

@ -1,33 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.util.GateBlockChangeSender;
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.PlayerChangedWorldEvent;
public class PlayerChangedWorldListener implements Listener {
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerChangeWorld(PlayerChangedWorldEvent event) {
Player p = event.getPlayer();
GateBlockChangeSender.updateGateBlocks(p, p.getLocation());
}
}

33
src/de/craftinc/gates/listeners/PlayerJoinListener.java
View File

@ -1,33 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.util.GateBlockChangeSender;
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.PlayerJoinEvent;
public class PlayerJoinListener implements Listener {
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerJoin(PlayerJoinEvent event) {
Player p = event.getPlayer();
GateBlockChangeSender.updateGateBlocks(p, p.getLocation());
}
}

46
src/de/craftinc/gates/listeners/PlayerMoveListener.java
View File

@ -1,46 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.controllers.TeleportController;
import de.craftinc.gates.util.GateBlockChangeSender;
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 TeleportController teleportController;
public PlayerMoveListener(Plugin plugin) {
this.teleportController = new TeleportController(plugin);
}
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerMove(PlayerMoveEvent event) {
if (event.isCancelled()) {
return;
}
if (event.getFrom().getChunk() != event.getTo().getChunk()) {
GateBlockChangeSender.updateGateBlocks(event.getPlayer(), event.getTo());
}
teleportController.teleport(event.getPlayer(), event.getTo());
}
}

30
src/de/craftinc/gates/listeners/PlayerRespawnListener.java
View File

@ -1,30 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerRespawnEvent;
public class PlayerRespawnListener implements Listener {
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerRespawn(PlayerRespawnEvent event) {
GateBlockChangeSender.updateGateBlocks(event.getPlayer(), event.getRespawnLocation(), true);
}
}

35
src/de/craftinc/gates/listeners/PlayerTeleportListener.java
View File

@ -1,35 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.listeners;
import de.craftinc.gates.util.GateBlockChangeSender;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerTeleportEvent;
public class PlayerTeleportListener implements Listener {
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerTeleport(PlayerTeleportEvent event) {
if (event.isCancelled()) {
return;
}
GateBlockChangeSender.updateGateBlocks(event.getPlayer(), event.getTo(), true);
}
}

51
src/de/craftinc/gates/listeners/PluginBlockListener.java Normal file
View File

@ -0,0 +1,51 @@
package de.craftinc.gates.listeners;
import org.bukkit.Material;
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.block.BlockPhysicsEvent;
public class PluginBlockListener implements Listener
{
@EventHandler(priority = EventPriority.NORMAL)
public void onBlockPhysics(BlockPhysicsEvent event)
{
if (event.isCancelled())
return;
if (event.getBlock().getType() != Material.PORTAL) {
return;
}
if (isBlockInPortal(event.getBlock())) {
event.setCancelled(true);
}
}
public boolean isBlockInPortal(Block block)
{
if (block.getRelative(BlockFace.UP).getType() == Material.AIR) {
return false;
}
if (block.getRelative(BlockFace.DOWN).getType() == Material.AIR) {
return false;
}
if ( block.getRelative(BlockFace.NORTH).getType() != Material.AIR && block.getRelative(BlockFace.SOUTH).getType() != Material.AIR ) {
return true;
}
if ( block.getRelative(BlockFace.WEST).getType() != Material.AIR && block.getRelative(BlockFace.EAST).getType() != Material.AIR ) {
return true;
}
return false;
}
}

77
src/de/craftinc/gates/listeners/PluginPlayerListener.java Normal file
View File

@ -0,0 +1,77 @@
package de.craftinc.gates.listeners;
import java.util.logging.Level;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.Block;
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.PlayerMoveEvent;
import de.craftinc.gates.Gate;
import de.craftinc.gates.Plugin;
public class PluginPlayerListener extends BaseLocationListener implements Listener
{
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerMove(PlayerMoveEvent event)
{
if (event.isCancelled()) {
return;
}
// Check for permission
if (!hasPermission(event.getPlayer())) {
return;
}
// Find the gate at the current location.
Gate gateAtLocation = getValidGateAtPlayerLocation(event);
if (gateAtLocation == null) {
return;
}
// Teleport the player
checkChunkLoad(gateAtLocation.getLocation().getBlock());
Location gateExit = gateAtLocation.getExit();
Location playerLocation = event.getPlayer().getLocation();
Float newYaw = gateExit.getYaw() - gateExit.getYaw() + playerLocation.getYaw();
Location teleportToLocation = new Location( gateExit.getWorld(),
gateExit.getX(),
gateExit.getY(),
gateExit.getZ(),
newYaw,
playerLocation.getPitch() );
event.getPlayer().teleport(teleportToLocation);
event.setTo(teleportToLocation);
}
private void checkChunkLoad(Block b)
{
World w = b.getWorld();
Chunk c = b.getChunk();
if ( ! w.isChunkLoaded(c) )
{
Plugin.log(Level.FINE, "Loading chunk: " + c.toString() + " on: " + w.toString());
w.loadChunk(c);
}
}
protected boolean hasPermission(Player player) {
return player.hasPermission(Plugin.permissionUse) || player.hasPermission(Plugin.permissionAll);
}
}

27
src/de/craftinc/gates/listeners/PluginPortalListener.java Normal file
View File

@ -0,0 +1,27 @@
package de.craftinc.gates.listeners;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerPortalEvent;
import de.craftinc.gates.Gate;
public class PluginPortalListener extends BaseLocationListener implements Listener
{
@EventHandler(priority = EventPriority.NORMAL)
public void onPlayerPortal(PlayerPortalEvent event)
{
if (event.isCancelled()) {
return;
}
// Find the gate at the current location.
Gate gateAtLocation = getGateAtPlayerLocation(event);
if (gateAtLocation != null) {
event.setCancelled(true);
}
}
}

27
src/de/craftinc/gates/listeners/VehicleMoveListener.java
View File

@ -1,27 +0,0 @@
package de.craftinc.gates.listeners;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.controllers.TeleportController;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.vehicle.VehicleMoveEvent;
public class VehicleMoveListener implements Listener {
private TeleportController teleportController;
public VehicleMoveListener(Plugin plugin) {
this.teleportController = new TeleportController(plugin);
}
@EventHandler(priority = EventPriority.NORMAL)
public void onVehicleMove(VehicleMoveEvent event) {
Entity passenger = event.getVehicle().getPassenger();
if (passenger instanceof Player) {
teleportController.teleport((Player)passenger, event.getTo());
}
}
}

298
src/de/craftinc/gates/models/Gate.java
View File

@ -1,298 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.models;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.util.ConfigurationUtil;
import de.craftinc.gates.util.FloodUtil;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.configuration.serialization.ConfigurationSerializable;
import java.util.*;
public class Gate implements ConfigurationSerializable {
private Location location; /* saving both location and gateBlockLocations is redundant but makes it easy to allow players to reshape gates */
private Set<Location> gateBlockLocations = new HashSet<>(); /* Locations of the blocks inside the gate */
private Set<Block> gateFrameBlocks = new HashSet<>();
private Location exit;
private boolean isOpen = false;
private boolean allowsVehicles = true;
private String id;
private GateMaterial material = new GateMaterial(Material.PORTAL);
/**
* You should never create two gates with the same 'id'. Also see 'setId(String id)'.
*
* @param id This parameter must not be 'null'. An exception will be thrown otherwise!
*/
public Gate(final String id) {
setId(id);
}
public String toString() {
return super.toString() + " " + this.getId();
}
public GateDirection getDirection() {
if (gateBlockLocations.isEmpty()) {
return null;
} else {
Block some = ((Location)gateBlockLocations.toArray()[0]).getBlock();
boolean east = gateBlockLocations.contains(some.getRelative(BlockFace.EAST).getLocation());
boolean west = gateBlockLocations.contains(some.getRelative(BlockFace.WEST).getLocation());
return east || west ? GateDirection.EastWest : GateDirection.NorthSouth;
}
}
public GateMaterial getMaterial() {
return material;
}
public void setMaterial(GateMaterial material) throws Exception {
this.material = material;
validate();
}
/**
* @return This method might return a 'null' data.
*/
public Location getLocation() {
return location;
}
/**
* @param location Supplying 'null' is permitted.
* @throws Exception Will throw an exception if the gate is open and an invalid (no gate frame) location is
* supplied. Note that the supplied 'location' will be set even if an exception is thrown. Note that this
* gate will be closed if an exception is thrown.
*/
public void setLocation(final Location location) throws Exception {
this.location = location;
if (isOpen) {
findPortalBlocks();
validate();
} else {
this.gateBlockLocations = new HashSet<>();
this.gateFrameBlocks = new HashSet<>();
}
}
/**
* @return This method might return a 'null' value.
*/
public Location getExit() {
return exit;
}
/**
* @param exit Supplying 'null' is permitted.
* @throws Exception An exception will be thrown if 'null' data is supplied and this gate is open. Note that the
* supplied 'exit' will be set even if an exception is thrown. Note that this gate will be closed if an
* exception is thrown.
*/
public void setExit(final Location exit) throws Exception {
this.exit = exit;
validate();
}
/**
* @return This method will never return 'null'.
*/
public String getId() {
return id;
}
/**
* Every gate should have an unique 'id'. You should therefore check if another gate with the same 'id' exists.
* Note that this method will not check if another gate with the same 'id' exists!
*
* @param id This parameter must not be 'null'. An exception will be thrown otherwise!
*/
public void setId(final String id) {
if (id == null) {
throw new IllegalArgumentException("gate 'id' cannot be 'null'");
}
this.id = id.toLowerCase();
}
public boolean isOpen() {
return isOpen;
}
public void setOpen(boolean isOpen) throws Exception {
if (isOpen && !this.isOpen) {
findPortalBlocks();
}
this.isOpen = isOpen;
validate();
}
public void setAllowsVehicles(boolean allowsVehicles) {
this.allowsVehicles = allowsVehicles;
}
public boolean getAllowsVehicles() {
return this.allowsVehicles;
}
/**
* @return Will never return 'null' but might return an empty Set.
*/
public Set<Location> getGateBlockLocations() {
return gateBlockLocations;
}
/**
* @return Will never return 'null' but might return an empty Set.
*/
public Set<Block> getGateFrameBlocks() {
return gateFrameBlocks;
}
private void findPortalBlocks() {
gateBlockLocations = new HashSet<>();
Set<Block> gateBlocks = FloodUtil.getGatePortalBlocks(location.getBlock());
if (gateBlocks != null) {
for (Block b : gateBlocks) {
gateBlockLocations.add(b.getLocation());
}
}
gateFrameBlocks = FloodUtil.getFrame(gateBlocks);
}
/**
* Checks if values attributes do add up; will close gate on wrong values.
*/
public void validate() throws Exception {
if (!isOpen) {
return;
}
if (location == null) {
isOpen = false;
this.gateBlockLocations = new HashSet<>();
this.gateFrameBlocks = new HashSet<>();
throw new Exception("Gate got closed. It has no location.");
}
if (exit == null) {
isOpen = false;
this.gateBlockLocations = new HashSet<>();
this.gateFrameBlocks = new HashSet<>();
throw new Exception("Gate got closed. It has no exit.");
}
if (gateBlockLocations.size() == 0) {
isOpen = false;
this.gateBlockLocations = new HashSet<>();
this.gateFrameBlocks = new HashSet<>();
throw new Exception("Gate got closed. The frame is missing or broken. (no gate blocks)");
}
validateFrame();
}
private void validateFrame() throws Exception {
boolean isAir = material.getMaterial() == Material.AIR;
boolean ignore = !Plugin.getPlugin().getConfig().getBoolean(ConfigurationUtil.confCheckForBrokenGateFramesKey);
if (isAir || ignore) {
return;
}
for (Block b : gateFrameBlocks) {
if (b.getType() == Material.AIR) {
isOpen = false;
this.gateBlockLocations = new HashSet<>();
this.gateFrameBlocks = new HashSet<>();
throw new Exception("Gate got closed. The frame is missing or broken. (missing frame block(s))");
}
}
}
/*
* INTERFACE: ConfigurationSerializable
*/
static private String idKey = "id";
static private String locationKey = "location";
static private String gateBlocksKey = "gateBlocks";
static private String exitKey = "exit";
static private String materialKey = "material";
static private String isOpenKey = "open";
static private String allowsVehiclesKey = "allowsVehiclesKey";
@SuppressWarnings("unchecked")
public Gate(Map<String, Object> map) {
try {
id = map.get(idKey).toString().toLowerCase();
location = (Location) map.get(locationKey);
exit = (Location) map.get(exitKey);
material = new GateMaterial((String)map.get(materialKey));
isOpen = (Boolean) map.get(isOpenKey);
allowsVehicles = (Boolean) map.get(allowsVehiclesKey);
gateBlockLocations = (Set<Location>) map.get(gateBlocksKey);
gateFrameBlocks = FloodUtil.getFrameWithLocations(gateBlockLocations);
} catch (Exception e) {
Plugin.log("ERROR: Failed to load gate '" + id + "'! (" + e.getMessage() + ")");
Plugin.log("NOTE: This gate will be removed from 'gates.yml' and added to 'invalid_gates.yml'!");
Plugin.getPlugin().getGatesManager().storeInvalidGate(map);
}
try {
validate(); // make sure to not write invalid stuff to disk
} catch (Exception e) {
Plugin.log("The loaded gate " + this.getId() + " seems to be not valid: " + e.getMessage());
}
}
public Map<String, Object> serialize() {
Map<String, Object> retVal = new HashMap<>();
retVal.put(idKey, id);
retVal.put(isOpenKey, isOpen);
retVal.put(allowsVehiclesKey, allowsVehicles);
retVal.put(gateBlocksKey, gateBlockLocations);
retVal.put(materialKey, material.toString());
if (exit != null) {
retVal.put(exitKey, exit);
}
if (location != null) {
retVal.put(locationKey, location);
}
return retVal;
}
}

6
src/de/craftinc/gates/models/GateDirection.java
View File

@ -1,6 +0,0 @@
package de.craftinc.gates.models;
public enum GateDirection {
EastWest,
NorthSouth
}

162
src/de/craftinc/gates/models/GateMaterial.java
View File

@ -1,162 +0,0 @@
package de.craftinc.gates.models;
import org.bukkit.Material;
import java.security.InvalidParameterException;
public class GateMaterial {
private Material material;
GateMaterial(Material material) {
this.material = material;
}
public GateMaterial(String materialString) throws InvalidParameterException {
Material material;
switch (materialString) {
case "air":
material = Material.AIR;
break;
case "sapling":
material = Material.SAPLING;
break;
case "water":
material = Material.STATIONARY_WATER;
break;
case "lava":
material = Material.STATIONARY_LAVA;
break;
case "cobweb":
material = Material.WEB;
break;
case "grass":
material = Material.LONG_GRASS;
break;
case "dead bush":
material = Material.DEAD_BUSH;
break;
case "dandelion":
material = Material.YELLOW_FLOWER;
break;
case "poppy":
material = Material.RED_ROSE;
break;
case "brown mushroom":
material = Material.BROWN_MUSHROOM;
break;
case "red mushroom":
material = Material.RED_MUSHROOM;
break;
case "torch":
material = Material.TORCH;
break;
case "redstone torch (off)":
material = Material.REDSTONE_TORCH_OFF;
break;
case "redstone torch (on)":
material = Material.REDSTONE_TORCH_ON;
break;
case "fence":
material = Material.FENCE;
break;
case "nether portal":
material = Material.PORTAL;
break;
case "iron bars":
material = Material.IRON_FENCE;
break;
case "glass pane":
material = Material.THIN_GLASS;
break;
case "fence gate":
material = Material.FENCE_GATE;
break;
case "nether brick fence":
material = Material.NETHER_FENCE;
break;
case "nether wart":
material = Material.NETHER_WARTS;
break;
case "end portal":
material = Material.ENDER_PORTAL;
break;
case "cobblestone wall":
material = Material.COBBLE_WALL;
break;
default:
throw new InvalidParameterException();
}
this.material = material;
}
@Override
public String toString() {
switch (material) {
case AIR:
return "air";
case SAPLING:
return "sapling";
case STATIONARY_WATER:
return "water";
case STATIONARY_LAVA:
return "lava";
case WEB:
return "cobweb";
case LONG_GRASS:
return "grass";
case DEAD_BUSH:
return "dead bush";
case YELLOW_FLOWER:
return "dandelion";
case RED_ROSE:
return "poppy";
case BROWN_MUSHROOM:
return "brown mushroom";
case RED_MUSHROOM:
return "red mushroom";
case TORCH:
return "torch";
case REDSTONE_TORCH_OFF:
return "redstone torch (off)";
case REDSTONE_TORCH_ON:
return "redstone torch (on)";
case FENCE:
return "fence";
case PORTAL:
return "nether portal";
case IRON_FENCE:
return "iron bars";
case THIN_GLASS:
return "glass pane";
case FENCE_GATE:
return "fence gate";
case NETHER_FENCE:
return "nether brick fence";
case NETHER_WARTS:
return "nether wart";
case ENDER_PORTAL:
return "end portal";
case COBBLE_WALL:
return "cobblestone wall";
default:
return "nether portal";
}
}
public Material getMaterial() {
return material;
}
public byte getData(GateDirection direction) {
switch (material) {
case PORTAL:
return direction == GateDirection.EastWest ? (byte)0b0 : (byte)0b10;
case GRASS:
return 1;
default:
return 0;
}
}
}

73
src/de/craftinc/gates/models/SimpleChunk.java
View File

@ -1,73 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.models;
import org.bukkit.Chunk;
import org.bukkit.World;
public class SimpleChunk {
private int x;
private int z;
private String world;
public SimpleChunk(Chunk c) {
this.x = c.getX();
this.z = c.getZ();
this.world = c.getWorld().getName();
}
public SimpleChunk(int x, int z, World w) {
this.x = x;
this.z = z;
this.world = w.getName();
}
@Override
public boolean equals(Object o) {
if (o instanceof SimpleChunk) {
SimpleChunk otherLocation = (SimpleChunk) o;
if (otherLocation.x == this.x
&& otherLocation.z == this.z
&& otherLocation.world.equals(this.world)) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
int hash = 11;
hash = 29 * hash + x;
hash = 37 * hash + z;
hash = 29 * hash + world.hashCode();
return hash;
}
@Override
public String toString() {
return this.getClass().toString() + " (x=" + this.x + " z=" + this.z + " world='" + this.world + "')";
}
}

83
src/de/craftinc/gates/models/SimpleLocation.java
View File

@ -1,83 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.models;
import org.bukkit.Location;
public class SimpleLocation {
private String world;
private int x;
private int y;
private int z;
public SimpleLocation(Location l) {
this.world = l.getWorld().getName();
// Using Block coordinates makes it possible to compare block locations with player locations.
// There might be an offset of 1 otherwise.
this.x = l.getBlockX();
this.y = l.getBlockY();
this.z = l.getBlockZ();
}
public SimpleLocation(Location l, boolean isHeadPosition) {
this.world = l.getWorld().getName();
// Using Block coordinates makes it possible to compare block locations with player locations.
// There might be an offset of 1 otherwise.
this.x = l.getBlockX();
this.y = l.getBlockY();
this.z = l.getBlockZ();
if (isHeadPosition) {
this.y--;
}
}
@Override
public String toString() {
return super.toString() + " x: " + x + " y: " + y + " z: " + z + " world: " + world;
}
@Override
public boolean equals(final Object o) {
if (o instanceof SimpleLocation) {
SimpleLocation otherLocation = (SimpleLocation) o;
if (otherLocation.x == this.x
&& otherLocation.y == this.y
&& otherLocation.z == this.z
&& otherLocation.world.equals(this.world)) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
int hash = 13;
hash = 37 * hash + x;
hash = 31 * hash + y;
hash = 37 * hash + z;
hash = 31 * hash + world.hashCode();
return hash;
}
}

40
src/de/craftinc/gates/persistence/MigrationUtil.java
View File

@ -1,40 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.persistence;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.Plugin;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import java.util.List;
import java.util.logging.Level;
public class MigrationUtil {
public static boolean performMigration(int storageVersion, int currentVersion, List<Gate> gates) {
if (storageVersion != currentVersion) {
Plugin.log(Level.SEVERE, "Supplied storage version is currently not supported!" +
"Make sure you have the latest version of Craft Inc. Gates installed. Plugin will be disabled!");
return false;
}
return true;
}
}

30
src/de/craftinc/gates/util/ConfigurationUtil.java
View File

@ -1,30 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.util;
public class ConfigurationUtil {
public static final String confMaxGateBlocksKey = "maxGateBlocks";
public static final String confPlayerGateBlockUpdateRadiusKey = "playerGateBlockUpdateRadius";
public static final String confCheckForBrokenGateFramesKey = "checkForBrokenGateFrames";
public static final String confGateTeleportMessageKey = "gateTeleportMessage";
public static final String confGateTeleportVehicleNotAllowedMessageKey = "gateTeleportVehicleNotAllowedMessage";
public static final String confShowTeleportMessageKey = "showTeleportMessage";
public static final String confGateTeleportNoPermissionMessageKey = "gateTeleportNoPermissionMessage";
public static final String confShowTeleportNoPermissionMessageKey = "showTeleportNoPermissionMessage";
public static final String confSaveOnChangesKey = "saveOnChanges";
public static final String confHighlightDurationKey = "highlightDuration";
}

152
src/de/craftinc/gates/util/FloodUtil.java
View File

@ -1,26 +1,9 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.util;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
@ -28,11 +11,15 @@ import org.bukkit.block.BlockFace;
import de.craftinc.gates.Plugin;
public class FloodUtil {
private static final Set<BlockFace> exp1 = new HashSet<>();
private static final Set<BlockFace> exp2 = new HashSet<>();
public class FloodUtil
{
private final static int frameBlockSearchLimit = 20;
static {
private static final Set<BlockFace> exp1 = new HashSet<BlockFace>();
private static final Set<BlockFace> exp2 = new HashSet<BlockFace>();
static
{
exp1.add(BlockFace.UP);
exp1.add(BlockFace.DOWN);
exp1.add(BlockFace.EAST);
@ -44,105 +31,10 @@ public class FloodUtil {
exp2.add(BlockFace.SOUTH);
}
/**
* Returns the all frame blocks of an gate.
*
* @param blocks All blocks inside the gate.
* @return A Set containing all frame block. Will never return 'null'.
*/
public static Set<Block> getFrame(final Set<Block> blocks) {
if (blocks == null || blocks.isEmpty()) {
return new HashSet<>();
}
// try to find gate's direction (north-south or east-west)
Set<BlockFace> gateFrameSearchFaces = null;
for (Block b : blocks) {
if (blocks.contains(b.getRelative(BlockFace.EAST)) ||
blocks.contains(b.getRelative(BlockFace.WEST))) {
gateFrameSearchFaces = exp1;
break;
}
if (blocks.contains(b.getRelative(BlockFace.NORTH)) ||
blocks.contains(b.getRelative(BlockFace.SOUTH))) {
gateFrameSearchFaces = exp2;
break;
}
}
if (gateFrameSearchFaces != null) {
return _getFrame(blocks, gateFrameSearchFaces);
} else { // no direction found (the gate might only consist of blocks one over another)
// Try one direction and check if the found blocks are not air.
// If air is found (frame broken or wrong direction) return the other direction
Set<Block> frameBlocks = _getFrame(blocks, exp1);
for (Block b : frameBlocks) {
if (b.getType() == Material.AIR) {
return _getFrame(blocks, exp2);
}
}
return frameBlocks;
}
}
private static Set<Block> _getFrame(final Set<Block> blocks, final Set<BlockFace> searchDirections) {
Set<Block> frameBlocks = new HashSet<>();
for (Block b : blocks) {
for (BlockFace bf : searchDirections) {
Block bb = b.getRelative(bf);
if (!blocks.contains(bb)) {
frameBlocks.add(bb);
}
}
}
return frameBlocks;
}
/**
* Returns the all frame blocks of an gate.
*
* @param locations All locations inside the gate.
* @return A Set containing all frame block. Will never return 'null'.
*/
public static Set<Block> getFrameWithLocations(final Set<Location> locations) {
if (locations == null) {
throw new IllegalArgumentException("'locations' must not be 'null'");
}
Set<Block> blocks = new HashSet<>();
for (Location l : locations) {
blocks.add(l.getBlock());
}
return getFrame(blocks);
}
// For the same frame and location this set of blocks is deterministic
public static Set<Block> getGatePortalBlocks(final Block block) {
if (block == null) {
throw new IllegalArgumentException("'block' must not be 'null'");
}
int frameBlockSearchLimit = Plugin.getPlugin().getConfig().getInt(ConfigurationUtil.confMaxGateBlocksKey);
public static Set<Block> getGateFrameBlocks(Block block)
{
Set<Block> blocks1 = getAirFloodBlocks(block, new HashSet<Block>(), exp1, frameBlockSearchLimit);
Set<Block> blocks2 = getAirFloodBlocks(block, new HashSet<Block>(), exp2, frameBlockSearchLimit);
@ -166,27 +58,28 @@ public class FloodUtil {
}
private static Set<Block> getAirFloodBlocks(final Block startBlock,
Set<Block> foundBlocks,
final Set<BlockFace> expandFaces,
int limit) {
if (foundBlocks == null) {
public static Set<Block> getAirFloodBlocks(Block startBlock, Set<Block> foundBlocks, Set<BlockFace> expandFaces, int limit)
{
if (foundBlocks == null)
return null;
}
if (foundBlocks.size() > limit) {
if (foundBlocks.size() > limit)
{
Plugin.log(Level.ALL, "exceeding gate size limit.");
return null;
}
if (foundBlocks.contains(startBlock)) {
if (foundBlocks.contains(startBlock))
return foundBlocks;
}
if (startBlock.getType() == Material.AIR) {
if (startBlock.getType() == Material.AIR || startBlock.getType() == Material.PORTAL)
{
// ... We found a block :D ...
foundBlocks.add(startBlock);
for (BlockFace face : expandFaces) {
// ... And flood away !
for (BlockFace face : expandFaces)
{
Block potentialBlock = startBlock.getRelative(face);
foundBlocks = getAirFloodBlocks(potentialBlock, foundBlocks, expandFaces, limit);
}
@ -194,4 +87,5 @@ public class FloodUtil {
return foundBlocks;
}
}

174
src/de/craftinc/gates/util/GateBlockChangeSender.java
View File

@ -1,174 +0,0 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.util;
import de.craftinc.gates.Plugin;
import de.craftinc.gates.models.Gate;
import de.craftinc.gates.models.GateMaterial;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Set;
import static de.craftinc.gates.util.ConfigurationUtil.*;
public class GateBlockChangeSender {
/**
* Replaces gate frame blocks with glowstone for a short period of time.
* Uses the data stored in 'highlightDuration' inside the config file
* for determining when to de-highlight the frames.
*
* @param player The player for whom the frame should be highlighted.
* Must not be null!
*
* @param gates The gates to highlighting
*/
public static void temporaryHighlightGatesFrames(final Player player, final Set<Gate> gates) {
assert(player != null);
assert(gates != null);
for (Gate g : gates) {
Set<Block> frameBlocks = g.getGateFrameBlocks();
for (Block b : frameBlocks) {
player.sendBlockChange(b.getLocation(), Material.GLOWSTONE, (byte) 0);
}
}
scheduleDelighting(player, gates);
}
/**
* Sends gate blocks to player at a given location. Will send the updates either immediately or
* immediately and after a short delay.
*
* @param player A player to send block changes to. Must not be null!
* @param location The location to look for gates nearby. Must not be null!
* @param sendDelayed Set to 'true' if the block changes shall be send a second time after a one
* second delay.
*/
public static void updateGateBlocks(final Player player, final Location location, boolean sendDelayed) {
assert(player != null);
assert(location != null);
Set<Gate> gatesNearby = Plugin.getPlugin().getGatesManager().getNearbyGates(location.getChunk());
if (gatesNearby == null) {
return; // no gates nearby
}
for (Gate g : gatesNearby) {
if (!g.isOpen()) {
continue;
}
sendGateBlockChanges(g, true, player);
}
if (sendDelayed) {
Bukkit.getScheduler().scheduleSyncDelayedTask(Plugin.getPlugin(), new Runnable() {
@Override
public void run() {
updateGateBlocks(player, location, false);
}
}, 20L);
}
}
public static void updateGateBlocks(final Player player, final Location location) {
updateGateBlocks(player, location, false);
}
public static void updateGateBlocks(final Gate gate) {
updateGateBlocks(gate, false);
}
/**
* Sends block changes to players near a given gate.
*
* @param gate Must not be 'null'!
* @param remove Set to true if all visible gate blocks shall be removed.
*/
public static void updateGateBlocks(final Gate gate, boolean remove) {
assert(gate != null);
Location gateLocation = gate.getLocation();
if (gate.getGateBlockLocations().isEmpty()) {
return;
}
ArrayList<Player> playersNearby = new ArrayList<>();
int searchRadius = Plugin.getPlugin().getConfig().getInt(confPlayerGateBlockUpdateRadiusKey);
for (Player p : Plugin.getPlugin().getServer().getOnlinePlayers()) {
if (p.getWorld() == gateLocation.getWorld() && p.getLocation().distance(gateLocation) < searchRadius) {
playersNearby.add(p);
}
}
boolean isVisible = gate.isOpen() && !remove;
for (Player p : playersNearby) {
sendGateBlockChanges(gate, isVisible, p);
}
}
private static void scheduleDelighting(final Player player, final Set<Gate> gates) {
Plugin plugin = Plugin.getPlugin();
long highlightDuration = 20 * plugin.getConfig().getLong(confHighlightDurationKey);
Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
@Override
public void run() {
dehighlightGatesFrames(player, gates);
}
}, highlightDuration);
}
private static void dehighlightGatesFrames(final Player player, final Set<Gate> gates) {
for (Gate g : gates) {
Set<Block> frameBlocks = g.getGateFrameBlocks();
for (Block b : frameBlocks) {
player.sendBlockChange(b.getLocation(), b.getType(), (byte) 0);
}
}
}
private static void sendGateBlockChanges(final Gate gate, boolean isVisible, final Player p) {
byte data;
Material material;
if (isVisible) {
GateMaterial gm = gate.getMaterial();
data = gm.getData(gate.getDirection());
material = gm.getMaterial();
} else {
data = 0b0;
material = Material.AIR;
}
for (Location l : gate.getGateBlockLocations()) {
if (l.getBlock().getType() == Material.AIR) {
p.sendBlockChange(l, material, data);
}
}
}
}

15
src/de/craftinc/gates/util/GeometryUtil.java Normal file
View File

@ -0,0 +1,15 @@
package de.craftinc.gates.util;
import org.bukkit.Location;
public class GeometryUtil {
// How long between two locations?
public static double distanceBetweenLocations(Location location1, Location location2) {
double X = location1.getX() - location2.getX();
double Y = location1.getY() - location2.getY();
double Z = location1.getZ() - location2.getZ();
return Math.sqrt(X*X+Y*Y+Z*Z);
}
}

86
src/de/craftinc/gates/util/LocationSerializer.java Normal file
View File

@ -0,0 +1,86 @@
package de.craftinc.gates.util;
import java.util.HashMap;
import java.util.Map;
import org.bukkit.Location;
import org.bukkit.World;
import de.craftinc.gates.Plugin;
/**
* NOTE: We do not care about yaw and pitch for gate locations. So we won't serialize them.
*/
public class LocationSerializer
{
protected static String worldKey = "world";
protected static String xKey = "x";
protected static String yKey = "y";
protected static String zKey = "z";
protected static World getWorld(String name) throws Exception
{
World world = Plugin.instance.getServer().getWorld(name);
if (world == null) {
throw new Exception("World '" + name + "' does not exists anymore! Cannot get instance!");
}
return world;
}
public static Map<String, Object> serializeLocation(Location l)
{
if (l == null) {
return null;
}
Map<String, Object> serializedLocation = new HashMap<String, Object>();
serializedLocation.put(worldKey, l.getWorld().getName());
serializedLocation.put(xKey, l.getX());
serializedLocation.put(yKey, l.getY());
serializedLocation.put(zKey, l.getZ());
return serializedLocation;
}
public static Location deserializeLocation(Map<String, Object> map) throws Exception
{
if (map == null) {
return null;
}
World w = getWorld((String)map.get(worldKey));
// 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,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, y, z);
}
}

67
src/de/craftinc/gates/util/TextUtil.java
View File

@ -1,65 +1,68 @@
/* Craft Inc. Gates
Copyright (C) 2011-2013 Craft Inc. Gates Team (see AUTHORS.txt)
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
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 Lesser General Public License for more details.
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.gates.util;
import org.bukkit.ChatColor;
import java.util.List;
public class TextUtil {
import org.bukkit.ChatColor;
import org.bukkit.Material;
public static String titleSize(String str) {
String center = ".[ " + ChatColor.YELLOW + str + ChatColor.GOLD + " ].";
if (center.length() >= 60) {
return ChatColor.GOLD + center;
} else {
public class TextUtil
{
public static String titleize(String str)
{
String line = ChatColor.GOLD + repeat("_", 60);
String center = ".[ " + ChatColor.YELLOW + str + ChatColor.GOLD + " ].";
int pivot = line.length() / 2;
int eatLeft = center.length() / 2;
int eatRight = center.length() - eatLeft;
return line.substring(0, pivot - eatLeft) + center + line.substring(pivot + eatRight);
}
}
private static String repeat(String s, int times) {
public static String repeat(String s, int times)
{
if (times <= 0)
return "";
return s + repeat(s, times - 1);
return s + repeat(s, times-1);
}
/**
* Joins all elements of list into a single string, separating the original strings with glue.
* Joins all emements of list into a single string, sperating the original strings with glue.
*/
public static String implode(List<String> list, String glue) {
public static String implode(List<String> list, String glue)
{
if (list.size() == 0) {
return "";
}
String ret = list.get(0);
for (int i = 1; i < list.size(); i++) {
for (int i=1; i<list.size(); i++) {
ret += glue + list.get(i);
}
return ret;
}
/**
* Joins all emements of list into a single string.
*/
public static String implode(List<String> list) {
return implode(list, "");
}
public static String getMaterialName(Material material)
{
String ret = material.toString();
ret = ret.replace('_', ' ');
ret = ret.toLowerCase();
return ret.substring(0, 1).toUpperCase() + ret.substring(1);
}
}