Compare commits

..
448 Commits
Author SHA1 Message Date
Andrew Wong 8ec6a43dc8 Update the fawe hook 2020-11-04 17:38:24 +01:00
Andrew Wong 2d81614f5f Update the fawe hook 2020-11-04 17:34:43 +01:00
Andrew Wong 8fb035015d Cache rent and buy regions in a seperate map in FileManager 2020-11-04 17:19:14 +01:00
Andrew Wong 77088a3a72 Performance improvements 2020-11-04 16:38:13 +01:00
Andrew Wong 2c2f40b0ea Fix merge conflict 2020-09-25 16:55:13 +02:00
Andrew Wong 07406c3987 Improve the performance of TeleportFeature#teleportPlayer
Split chunk loading accross multiple ticks, delay 3 ticks before executing teleport logic
2020-09-25 13:01:09 +02:00
Andrew Wong 82a90b350d Minor bug fixes 2020-08-22 01:37:33 +02:00
Andrew Wong 151fbe8000 Move away from using BukkitDo; Add TaskChain as a dependency 2020-08-17 21:47:44 +02:00
Andrew Wong f2a4dd71e3 Update README.md 2020-08-16 23:44:06 +02:00
Andrew Wong d4cc70f954 Rename version 2020-08-16 23:41:56 +02:00
Andrew Wong 8001047480 Add in the spigot repo 2020-08-16 23:31:29 +02:00
Andrew Wong af1486a6fa Create maven.yml 2020-08-16 23:27:40 +02:00
Andrew Wong 36a2d054d6 Bump maven plugin versions 2020-08-16 23:24:37 +02:00
Andrew Wong 7429b0a206 Remove system dependencies. Utilise PaperLib when teleporting. Remove support for pre-1.13. Added support for 1.16.1 2020-08-16 23:17:08 +02:00
dependabot[bot] 557d11dfb4 Bump checkstyle from 8.21 to 8.29
Bumps [checkstyle](https://github.com/checkstyle/checkstyle) from 8.21 to 8.29.
- [Release notes](https://github.com/checkstyle/checkstyle/releases)
- [Commits](https://github.com/checkstyle/checkstyle/compare/checkstyle-8.21...checkstyle-8.29)

Signed-off-by: dependabot[bot] <support@github.com>
2020-02-26 11:02:43 +01:00
Thijs Wiefferink b9547e2c67 Remove github action experiment 2019-08-16 18:22:19 +02:00
Thijs Wiefferink 221785ae55 Add test workflow maven build 2019-08-16 17:42:22 +02:00
Thijs Wiefferink 0d04676bce Fix including bukkit into the AreaShop jar 2019-06-23 22:27:35 +02:00
Thijs Wiefferink c8cd68c17b Fixup javadoc build 2019-06-23 22:07:34 +02:00
Thijs Wiefferink 539887449c pom.xml: build with craftbukkit 1.13 2019-06-23 21:59:04 +02:00
Thijs Wiefferink 4cda8a9292 Fix sign handling for 1.14
- Setup modules to load different classes for different Bukkit/Spigot versions
- Create BukkitHandler to get/set the sign facing and get the block it is attached to
- Fix `/as addsign` to use new sign methods
- Fix sign updates to use new sign methods
- Implement full forwards and backwards compatibility of the saved sign material type
    - On Bukkit 1.12 and lower all special wood types are translated to the standard sign
    - On Bukkit 1.13 the internal sign name is translated (and special wood types to the standard one)
    - On Bukkit 1.14 the signs of 1.13- are translated to the OAK variants
- Cleanup the .gitignore files inside of the module folders
2019-06-23 21:53:48 +02:00
Thijs Wiefferink fe131dc157 BuyRegion/RentRegion: fix %player% placeholders for selling/unrenting confirmation messages 2019-06-16 21:40:58 +02:00
Thijs Wiefferink 41ced9ee6c Update checkstyle from 7.6 to 8.21 2019-06-01 17:08:30 +02:00
Thijs Wiefferink 03de0ff252 default.yml: fix spelling mistake 2019-06-01 16:24:15 +02:00
Thijs Wiefferink b057271394 Fix permission check of /as rent, fix 'already bought' check of /as buy 2019-02-20 19:33:37 +01:00
Thijs Wiefferink d7cdff0b22 /as setteleport: fix check that hides it from /as help 2019-02-08 22:29:57 +01:00
Thijs Wiefferink 1035b6b41b Move event commands to a feature class, add two events
- Move eventCommandProfile code to a separate class
- Add AddingRegionEvent
- Add DeletingRegionEvent
- Cleanup a couple of duplicate code paths (merge RentRegion/BuyRegion branches)
2019-01-28 23:37:43 +01:00
Thijs Wiefferink e0bad7397c Refactoring based on SonarLint and Intellij IDEA inspections 2019-01-26 21:23:49 +01:00
Thijs Wiefferink b7124e8cdd Remove mcstats.org metrics class, I don't believe they will be online again 2019-01-26 20:11:26 +01:00
Thijs Wiefferink f0952c32c9 Update issue templates
Add 'NEW' label to issues created using the template
2019-01-13 22:26:54 +01:00
Thijs Wiefferink d3dfa86a65 Set version to 2.6.0 2019-01-13 17:34:50 +01:00
Thijs Wiefferink 8f73b8af3c documentation/release.md: add instructions for releasing a new version 2019-01-13 17:34:37 +01:00
Thijs Wiefferink 51b24c74b4 langHeader.yml: add the template used to generate the language file headers to the repository 2019-01-13 17:33:54 +01:00
Thijs Wiefferink 9beb1eb61b Move the changelog from the wiki to the repository 2019-01-13 17:33:09 +01:00
Thijs Wiefferink de5fdafca0 Pull translations from Transifex 2019-01-08 21:18:19 +01:00
Thijs Wiefferink 0aea914d20 Add FastAsyncWorldEdit support on Spigot 1.13
- FastAsyncWorldEdit now supported on Spigot 1.13
- Improved support for the beta-01 versions of WorldGuard and WorldEdit
- Resolves #436
2019-01-08 00:19:48 +01:00
Thijs Wiefferink b4efe7d5bf Add default labels to issue templates 2019-01-05 16:27:05 +01:00
Thijs Wiefferink ec7983e126 Fix handling of sign updates at places where they will pop off immediately
1. When placing back a missing sign it could be placed in the middle of the air
2. BlockPhysicsEvent would fire immediately (synchronously) breaking the sign
3. Sign update would break because the sign has not actually been placed
2019-01-01 19:32:34 +01:00
Thijs Wiefferink e45c353030 Fix detecting region by location when using WorldEdit 7 beta-2 or later
- The WorldEdit 7 beta-2 handler was inheriting a function from the handler of older version that uses the old Vector class
- Fixes #466
- Fixes #467
2019-01-01 19:30:16 +01:00
Thijs Wiefferink 44b1cb0fc8 /as add: fix setting player as landlord when he is an owner of the region
- Fixes #427
- Adds a debug message to check the behavior easily in the future
2018-12-28 17:11:48 +01:00
Thijs Wiefferink c7299fa56c Update Discord image to a widget image 2018-12-27 23:14:56 +01:00
pmme 12bf467714 Simplify WorldEdit 7 flushQueue vs. flushSession 2018-12-27 22:47:14 +01:00
Thijs Wiefferink 5b327db316 signs: instead of cancelling indirect break, remove the sign to prevent lagg 2018-12-27 19:44:30 +01:00
Thijs Wiefferink b4f33589a1 Cleanup old directory 2018-12-27 17:45:19 +01:00
Thijs Wiefferink 530c74ccd2 Add support for the WorldEdit vector refactor update
- Add WorldEdit and WorldGuard module that supports the new vector system
- WorldGuard/WordEdit dependencies are in the repository itself to make builds more reliable
- Change code that uses WorldEdit vectors to use Spigot vectors
- Rename all modules to areashop-[worldguard|worldedit]-<version>
- Change maven versions of internal modules to 'latest' to be less confusing
2018-12-27 17:42:24 +01:00
Thijs Wiefferink fa4857cbce Simplify code in the handler for WorldEdit 7 2018-12-27 15:00:53 +01:00
Thijs Wiefferink 93fd4e96cb Fix restoring schematics for the latest WorldEdit dev builds
- Fixes #447
- Thanks pmme and x1p for reporting the issue!
2018-10-28 17:58:09 +01:00
Thijs Wiefferink a6863ae782 Also put the Vault dependency into /dependencies
- Now it should be easy again to built AreaShop yourself, only need to run BuildTools for 1.13.0 and it should work
2018-10-28 01:15:12 +02:00
Thijs Wiefferink e5e2c4ca08 Fixup dependencies, use Bukkit/CraftBukkit 1.7.9 instead of 1.8
- 1.7.9 is the lowest supported version, so it is good to use that as base
2018-10-28 00:53:30 +02:00
Thijs Wiefferink b0341e2a3e Fix compatibility with 1.13 Material class
- Fixes sign handling to properly detect and store signs, fixes #440
- Fixes safe teleporting (also improves block detection, making it even safer)
2018-10-28 00:12:24 +02:00
Thijs Wiefferink c8e1ebb068 Change WorldGuard/WorldEdit/Bukkit dependencies to file links
- Fixes the issue that olders WorldEdit and Bukkit versions are not available on Maven anymore
- This speeds up the build a lot
2018-10-28 00:00:41 +02:00
Thijs Wiefferink 39c8eb5f73 Fix tab complete types for /as setduration 2018-10-22 23:44:31 +02:00
Thijs Wiefferink 2483cf1614 Try to add compatibility with the FAWE schematic format 2018-10-21 21:59:45 +02:00
Thijs Wiefferink 769f8ee4ca Set version to 2.5.0, ready for release! 2018-10-20 21:58:14 +02:00
Thijs Wiefferink 2c04b87a9f Add the latest Transifex translations for DE, ES and FR 2018-10-20 21:57:05 +02:00
Thijs Wiefferink 8ce1ed0264 Fix showing /as del and /as add in /help for landlords 2018-10-20 18:36:51 +02:00
Thijs Wiefferink 035f8e1932 Possibly fix default value for areashop.limits.default (documentation is inconsistent for not op) 2018-10-20 18:36:51 +02:00
Thijs Wiefferink 4d3482994f Smaller discord image 2018-10-20 15:53:14 +02:00
Thijs Wiefferink 45f1c510e5 Add link to the AreaShop Discord 2018-10-20 15:49:36 +02:00
Thijs Wiefferink 5c13223b9e Fix for 1.13.1, depend on WorldGuard and WorldEdit 7 beta-01 2018-10-20 14:54:52 +02:00
Thijs Wiefferink 8c47ae9b3c Add README.md files in a couple of packages, closes #128 2018-08-12 16:41:03 +02:00
Thijs Wiefferink 28d03a6a3a Small fixes suggested by Intellij IDEA 2018-08-12 16:23:43 +02:00
Thijs Wiefferink aa585e9b11 Deal with empty date/time settings (handle as 'unlimited'/'disabled')
- Fixes #412
2018-08-12 16:17:02 +02:00
Thijs Wiefferink 36d2ce60b9 Disable copying entities (WorldEdit 7), and enable removing entities (WorldEdit 6)
- Fixes security problem of #273:
    - Throw item into a region
    - Rent/buy the region -> it gets saved as schematic
    - Pick up items
    - Unrent/sell the region -> items appear again
    - Pick up second set of items, they got duplicated
2018-08-11 22:31:15 +02:00
Thijs Wiefferink bdea9448a4 Update WorldEdit 7 to build 3817, update WorldGuard 7 to build 1735 2018-08-11 22:19:25 +02:00
Thijs Wiefferink bd2f40f5c8 Use new schematic format when using WorldEdit 7 2018-08-11 22:18:48 +02:00
Thijs Wiefferink 9e908cee73 Fix getting region by location for WorldGuard 7 2018-08-11 22:17:13 +02:00
Thijs Wiefferink 0d326d973d Fix saving/restoring schematics with WorldEdit 7 2018-08-05 12:23:32 +02:00
Thijs Wiefferink 27eaa27765 Add WorldGuard 7 and WorldEdit 7 support, now 1.13 works
- Closes #411
2018-08-05 00:34:50 +02:00
Thijs Wiefferink fb35153eb2 Pull translations from Transifex 2018-07-22 17:52:25 +02:00
Thijs Wiefferink aec6295516 Remove dependency on javafx 2018-06-17 17:14:23 +02:00
Thijs Wiefferink 38cd77e487 Fix compilation error in the import command 2018-06-01 19:54:02 +02:00
Thijs Wiefferink 6b9866a4c4 Ignore hidden files in the /regions directory (like .DS_Store) 2018-05-29 22:58:15 +02:00
Thijs Wiefferink 5aceb81cfd Import: setup permanent region settings when not rentable and buyable 2018-05-29 22:21:43 +02:00
Thijs Wiefferink 50f6bce64e Fix region limits, thanks @ZachryWilsn for reporting! 2018-05-29 21:59:55 +02:00
Thijs Wiefferink f713edc5b5 Disable moneyback message in /as info if sellDisabled is true 2018-05-26 01:33:23 +02:00
Thijs Wiefferink 012920a51c Cleanups because of Intellij IDEA inspections 2018-05-23 23:46:57 +02:00
Thijs Wiefferink 6154454f96 Indicate if a region has already been added with another world
- Closes #287
2018-05-23 22:53:07 +02:00
Thijs Wiefferink e34daeb5ff Update readme to use issue template selection link 2018-05-23 22:38:12 +02:00
Thijs Wiefferink 0a2dc22c59 Setup issue templates 2018-05-23 22:29:29 +02:00
Thijs Wiefferink 2482bd88c2 Add option to ignore regions for limit calculation
Set `countForLimit` to `false` in default.yml, a group or the region file to ignore it for limits
2018-05-23 22:13:42 +02:00
Thijs Wiefferink e86281ab28 Safer sign update, don't assume location/world still exists 2018-05-12 14:41:45 +02:00
Thijs Wiefferink 5a9ca74b75 Add option to disable selling and reselling your own regions 2018-05-10 20:07:10 +02:00
Thijs Wiefferink d301be2304 Add licence, issues and CI to the root pom file 2018-04-03 22:44:16 +02:00
Thijs Wiefferink a23c6fa66f Hide progress messages of region update, speed up region updates 2018-04-02 20:05:38 +02:00
Thijs Wiefferink cd63517041 Fix list of region names for error indicating missing worlds 2018-04-02 20:00:22 +02:00
Thijs Wiefferink e3043c476b Fix available languages link 2018-04-02 12:10:34 +02:00
Thijs Wiefferink 3be7573863 Parse currency prefix and suffix with InteractiveMessenger
- Allows proper colors and escaping
2018-03-09 11:50:08 +01:00
Thijs Wiefferink 51161fffee Remove unused chunkunload event 2018-03-09 11:08:15 +01:00
Thijs Wiefferink c82067ad0b Add back Paypal donate button 2018-02-17 19:04:18 +01:00
Thijs Wiefferink 46dbb8d22c More customizable metric suffixes, better currency formatting
- 'metricSymbols' section in 'config.yml' to customize the used suffixes for large numbers
- Remove trailing zeros from numbers with metric suffix
- Properly handle rounding of 1.235 to 1.24 (different double to BigDecimal conversion)
- Closes #373
2018-02-12 14:44:48 +01:00
Thijs Wiefferink cace086466 Add UTF8 awareness flag in plugin.yml
- I think it only does something if you use JavaPlugin#getConfig(), but it does not harm either
2018-02-12 12:49:04 +01:00
Thijs Wiefferink 06a716b1fd Make %uuid% available to schematics when selling a region
- Schematic save/restore would happen after removing the owner, which means %uuid% would be null
- Unrenting already does the save/restore before removing the renter, so now it is more consistent
- Thanks to Behoston on Github for reporting the issue
- Closes #383
2018-02-01 13:59:48 +01:00
Thijs Wiefferink 4530717045 Command confirmation for /as import
- Can also be used for all WordEdit based add/delete actions in the future
2018-01-26 16:16:11 +01:00
Thijs Wiefferink 741bbd879f Fix hashCode() of RegionSign 2018-01-26 14:33:27 +01:00
Thijs Wiefferink 8474edd29d Save region name as given to /as add and /as stack
- Previously the WorldGuard region id was used, converting the name to lowercase
2018-01-26 13:55:41 +01:00
Thijs Wiefferink d4df691166 FIx usage of > in javadocs 2018-01-26 12:15:10 +01:00
Thijs Wiefferink 3e247e6cb1 Move sign listeners into SignsFeature
- Fix removing signs not removing it from the signsByChunk map
2018-01-26 12:08:22 +01:00
Thijs Wiefferink f3527134e8 Prevent chunk loading by sign updates
- When sign needs update, only do it if the chunk is already loaded
- If a chunk gets loaded (by a player or something else), update any signs in that chunk
- Improve some javadocs, let checkstyle require @param, @throws and @returns
2018-01-22 18:12:15 +01:00
Thijs Wiefferink 0e14b121b8 InfoCommand: fix showing list of signs (was only showing the first one) 2018-01-22 18:08:16 +01:00
Thijs Wiefferink 8cc632fc05 Pull latest translations from Transifex (automated script) 2018-01-22 16:31:03 +01:00
Thijs Wiefferink 77c1b3f288 Fix error in help message of the import command 2018-01-22 16:10:02 +01:00
Thijs Wiefferink 21339cbf7c Fix incorrect message reference for /as message 2018-01-22 16:07:52 +01:00
Thijs Wiefferink 0351188671 Update live support link 2018-01-21 22:10:02 +01:00
Thijs Wiefferink 47e1d80821 Add live support chat link to 99messages 2018-01-18 16:16:40 +01:00
Thijs Wiefferink 1d0472b052 Improve feedback when placing [as] sign for region that is not added 2017-12-22 12:25:30 +01:00
Thijs Wiefferink 22dcfc76af Fix confirmation messages of /as del (failed refactor)
Thanks Noudux for reporting it!
2017-12-21 18:09:55 +01:00
Thijs Wiefferink 6b59176048 Fix startup error: call init method of the scheduling library 2017-11-27 10:02:51 +01:00
Thijs Wiefferink 5dc4d11408 Fix missing spaces in /as message messages 2017-11-26 23:49:42 +01:00
Thijs Wiefferink 00bd305381 Use Map#putIfAbsent where applicable 2017-11-26 16:01:05 +01:00
Thijs Wiefferink 9daa50b23b Use BukkitDo scheduling library
- Much cleaner code for scheduling tasks,
- Makes proper use of Java 8 functionality
2017-11-26 15:47:51 +01:00
Thijs Wiefferink 33b73a0369 Remove Paypal donate button 2017-11-25 17:07:54 +01:00
Thijs Wiefferink 591540af30 Partially fix problem with importing regions from RegionForSale
- When checking the type of a region AreaShop would only look at the settings of the region, not the settings of the world, parent regions and config.yml
- Checking parent regions for these settings should still be added (requires bigger changes)
2017-11-23 22:54:55 +01:00
Thijs Wiefferink 4e1e50e993 Fix /as linksigns <profile> for configs without signProfiles
The `signProfiles` section is not in the default config.yml file anymore, so getting that section can return null
2017-11-20 09:19:35 +01:00
Thijs Wiefferink 9a52ca3d9b Add missing @return Javadoc for RegionGroup#getAutoRegions() 2017-11-10 00:04:39 +01:00
Thijs Wiefferink 858b019806 Add option to teleport X blocks away from the sign
- Implements #364
- Option `general.teleportSignDistance` to `default.yml` to set the number of blocks to teleport away from the sign
- Changes the pitch/yaw of the player so that he faces the sign
- Handles wall and floor signs in any direction
- Improve SignsFeature code structure
2017-11-09 23:56:18 +01:00
Thijs Wiefferink b1dfe93088 Add RegionForSale import, rental auto-extend and other things
- `/as import RegionForSale`, as requested in #98:
    - Imports all regions from RegionForSale
    - Converts almost all settings to their AreaShop equivalent
    - Handles parent regions
- Add `rent.autoExtend` for use with rental regions to automatically extend the rent when the time is out, start of #29, still need the command
    - Vault compatible permissions plugin is required to let this work while the player is offline
    - All permissions, limits and the player balance are checked as during a normal rent
- Add option to region groups to automatically add all regions of a certain world
- BREAKING: Region events now use OfflinePlayer instead of Player
- Automatically import existing region owners/members when adding a region to AreaShop

There are still a couple of things missing in the import and it needs to be tested a lot.
2017-10-20 13:41:30 +02:00
Thijs Wiefferink 0bf2314f2a Add licence (as already listed on BukkitDev) 2017-10-16 11:56:04 +02:00
Thijs Wiefferink 33ddb8ae88 Fix %volume% for polygon regions
- WorldGuard does not implement volume() for Polygon regions, always returns 0
- Volume result is cached, calculating it for polygon regions could be slow
2017-10-05 16:53:42 +02:00
Thijs Wiefferink 234e4b6261 Prevent indirectly breaking signs with non-solid blocks
- Fixes #358
2017-10-05 13:43:27 +02:00
Thijs Wiefferink ed2ffaeaa3 Move base command to EN.yml for /as info paging 2017-10-05 13:15:51 +02:00
Thijs Wiefferink e073438862 Add %volume% variable to get the number of blocks in a region
- Works properly for polygon regions
2017-10-05 12:20:03 +02:00
Thijs Wiefferink 07194f07da Add region masking to schematic restore
- When restoring a schematic the paste is masked to the region blocks, so that only blocks that are actually inside the region are pasted (necessary for polygon regions)
- Closes #20
2017-10-01 19:49:05 +02:00
Thijs Wiefferink dfa3e0be66 Checkstyle fix 2017-09-04 17:09:31 +02:00
Thijs Wiefferink 8eef029400 Fix %month% variable using 0-11 instead of 1-12
- Fixes #354, thanks skippyaut
2017-09-04 16:58:39 +02:00
Thijs Wiefferink c8d869ce15 Fix usage of teleport location set by '/as settp'
- It was accidentally trying to get the teleport location from the plugin config file instead of the region config file.
- Also added the possibility to set the teleport location in groups and default.yml
2017-08-05 20:25:06 +02:00
Thijs Wiefferink 053d75181d Update to InteractiveMessenger 1.1-SNAPSHOT
- Ensures AreaShop is rebuild when InteractiveMessenger updates
- Fixes crash bug that was in InteractiveMessenger
- Fixes #334
2017-07-30 17:25:49 +02:00
Thijs Wiefferink f0128c221b Update README.md 2017-06-23 14:59:16 +02:00
Thijs Wiefferink ce6c01c5d0 Add Transifex translation stats image 2017-06-23 14:54:19 +02:00
Thijs Wiefferink b835c4dded Only reset WorldGuard flag/groupFlag if not already empty 2017-06-12 22:05:09 +02:00
Thijs Wiefferink 07e6782714 Fix /as setowner for regions that are not rented yet
Add a rental period to the time when setting owner of a rental region that is not rented yet, otherwise it would get expired immediately
2017-06-12 21:58:42 +02:00
Thijs Wiefferink 4002956aeb Fix javadoc comments 2017-06-12 20:42:36 +02:00
Thijs Wiefferink 0b96b9cb42 Github update checker, Java 8
- Add Github update checker, closes #201, it is implemented to allow reuse by other plugins, it will probably move to a separate repository later
- Switch to Java 8, if people did not update already they probably never will
- Add used Bukkit version as property, use that in all pom files
- Add Task class with methods to easily use BukkitRunnable (not all code is migrated to this pattern yet)
2017-06-12 20:39:28 +02:00
Thijs Wiefferink 0c192c2444 Cleanup setOwners/setMembers, only edit WorldGuard region if different
- Improve code layout for changing owners and members of WorldGuard regions
- Only edit flags and other WorldGuard region settings if they are different than the current option, this prevents useless saves in WorldGuard (which shows a message in console)
2017-06-12 20:39:28 +02:00
Thijs Wiefferink 2381aaeacc Remove link to Shop plugin because it is not fixed yet 2017-04-30 14:15:35 +02:00
Thijs Wiefferink 906b331758 Fix line endings in config.yml 2017-04-20 23:35:49 +02:00
Thijs Wiefferink f0f2e09be0 Always add English time indicators
- Internal timers specified using settings in hiddenConfig.yml use the English words, so if you remove the English words from config.yml timers do not run (regions not expiring, no notifications, no file saving)
- Warn in console when an unknown time specifier is found, might get spammy but at least gets the point across
2017-04-20 23:23:57 +02:00
Thijs Wiefferink 395cc6de07 Fix usage of 'resale' in 'default.yml' for 'flagProfile' section
- 'resale' was used instead of 'resell' (as defined in GeneralRegion#RegionState) in the 'flagProfile' section, causing the flags not getting applied when the region is in reselling state.
- Added fallback to 'resale' section if 'resell' section is not present (to properly read old config.yml/default.yml files)
- Fixed usage of '%resaleprice%' in the resale greeting, should be '%resellprice%'
- Fixes #303, thanks electro2560 for the great bug report!
2017-04-20 15:26:26 +02:00
Thijs Wiefferink 3b9d6187ca Fix checkstyle fail 2017-04-17 21:34:32 +02:00
Thijs Wiefferink 9d1585f513 Fix groups file getting cleared on server start
- Fixes #299
- Because of an earlier change the groups file is loaded before regions are loaded on server start, and region groups remove themselves if there are no valid regions in them anymore.
- Keep groups even though they are empty (so that configuration done in the group is not lost)
2017-04-17 21:32:15 +02:00
Thijs Wiefferink 9d6955039a Fix '/as groupdel' with non-existing group creating an empty one 2017-04-17 21:26:24 +02:00
Thijs Wiefferink 747b47057b Allow # in region name for /as stack to determine counter position 2017-04-11 21:22:35 +02:00
Thijs Wiefferink a973e254e6 Fix '/as addfriend' not allowing you to add players that are playing for the first time
- Fixes #297
2017-04-02 22:34:02 +02:00
Thijs Wiefferink a5105af3ad Add 'use' flag to default.yml again since people mess it up 2017-03-29 20:18:14 +02:00
Thijs Wiefferink 0bb0a05b76 Cleanup checkstyle from pom.xml in AreaShop module 2017-03-29 20:17:42 +02:00
Thijs Wiefferink dad502ec0c Add checkstyle to enforce formatting, change all formatting to comply 2017-03-29 20:15:44 +02:00
Thijs Wiefferink f471b9bbf0 Don't show 'in advance renting:' in '/as info' if maxExtends is zero
- Thanks to R0bstar for noticing this weird weird message combination
2017-03-09 16:14:30 +01:00
Thijs Wiefferink f69d1c41e6 Code cleanup and stricter visibility of methods/variables 2017-03-09 16:01:36 +01:00
Thijs Wiefferink 4ea6f59c49 Remove GeneralRegion#is{Rent|Buy}Region()
- It served no purpose and prevents IDEs from detecting type safety
2017-03-09 15:29:01 +01:00
Thijs Wiefferink 0b7158290f Add some more bStats statistics 2017-03-09 15:09:05 +01:00
Thijs Wiefferink e6757d23de Add bStats analytics
- Add bStats analytics because MCStats is down constantly
- Add custom graphs:
  - Language pie chart
  - Number of registered regions
  - Number of rental regions
  - Number of buy regions
- Closes #287
- In the future MCStats can be removed, for now I would like to keep complete data there for the times it does work
- Could add more graphs in the future for number of friends and things like that
2017-03-02 18:14:07 +01:00
Thijs Wiefferink 7cda35f4da Remove duplicate link in the readme 2017-02-12 20:04:35 +01:00
Thijs Wiefferink ee293d14b9 Fix link to CI in the readme 2017-02-12 20:03:46 +01:00
Thijs Wiefferink 2e0fce4955 Update repository url 2017-02-09 14:59:53 +01:00
Thijs Wiefferink 7afdefc9ed Add missing javadoc to loadFiles methods 2017-02-02 23:03:55 +01:00
Thijs Wiefferink 11f80e7ed1 Start using InteractiveMessenger
- Messaging functionality has been split into the InteractiveMessenger project: https://github.com/NLthijs48/InteractiveMessenger
- Jenkins build server has been changed to publish a Maven repository: http://jenkins.wiefferink.me/plugin/repository/everything
2017-02-02 22:59:00 +01:00
Thijs Wiefferink 40d45c7786 Fix using landlordName setting without using landlord (uuid) setting 2017-02-02 17:20:26 +01:00
Thijs Wiefferink 6b8e161e43 Ensure buy/rent/resell price is never below zero
This prevents problems with negative payment or withdrawal in Vault if input validation of a command is not good enough or if a price has manually been set below zero.
2017-02-02 17:18:26 +01:00
Thijs Wiefferink e1b2f7391c Improve message when you cannot rent/buy a region
The message did not specify which region cannot be rented/bought, which has now been added.
2017-02-02 16:45:15 +01:00
leNic 89ae8b9b4a Fixed reselling with negative prices (#280)
Prevents setting a negative resell price,. Some economy plugins accept a withdraw with a negative number, which has bad consequences (for example EssentialsEco does not accept it).
2017-01-28 20:25:24 +01:00
Thijs Wiefferink fab415bf19 Speed up expiration and expireWarning tasks
The expire task was triggering more often than the expireWarning task, causing lost warnings when warnings with a low time are specified
2017-01-23 14:26:25 +01:00
Thijs Wiefferink c7aa92be81 Indicate in default.yml that expressions can be used for region prices 2017-01-13 19:25:31 +01:00
Thijs Wiefferink 705c8d6891 Update README.md 2017-01-13 18:42:04 +01:00
Thijs Wiefferink 429d87c9ff Improve feature list 2017-01-13 18:41:16 +01:00
Thijs Wiefferink 1fdd8b32cc Add prices depending on a formula
- Price can be specified with an expression (JavaScript syntax)
- You can also use a block of JavaScript code, the value of the last line is used as result (for more complex logic)
- Supported settings: rent.price, buy.price, rent.moneyBack, buy.moneyBack (need more? ask me)
- Before evaluating the expression all region variables as defined in the config.yml file will be replaced (allows you to use %width% etc)
- Added %timesExtended% variable for use in expressions (to know how long the user is renting for)
- '/as setprice' and signs still only allow number input to prevent security problems (this means actual config access is required to do anything of harm with JavaScript)
- Closes #23
2017-01-13 16:56:02 +01:00
Thijs Wiefferink 7900f78a8c Change default WorldGuard flags to include block-place and block-break
Way too many people set the block-break and block-place flags on bigger or even the global region to deny (which is unnecessary and wrong relatively, for global use 'passthrough: deny' instead) so this patches up those mistakes by setting them at the AreaShop region
2017-01-13 16:06:18 +01:00
Thijs Wiefferink 3a65a88849 Fix replacing variables into language variables
- Previously it would insert it as a message, causing the language variable to be split up into multiple parts (which prevents recognizing it later)
- If a Message is marked as inline with Message#inline() it will be inserted without breaking up the message
2016-12-27 16:17:04 +01:00
Thijs Wiefferink 7b491d0389 Lazily instantiate feature classes to improve performance 2016-12-27 16:15:17 +01:00
Thijs Wiefferink fd02c51492 Add setting to prevent cross-world teleportation with '/as find'
- If a region is in another world and 'findCrossWorld' is off, it will be filtered from the results
- 'teleportCrossWorld' will not be checked anymore if the teleport is called from '/as find'
- Resolves  #234
2016-12-26 23:29:40 +01:00
Thijs Wiefferink bb1f592807 Add setting to prevent cross-world teleportation with '/as tp'
Related to #234
2016-12-26 23:20:12 +01:00
Thijs Wiefferink 16c7a044ea Add and make use of escaping in messages
- Add escaping support to FancyMessageFormat: put a backslash before a tag and it will not be interpreted, also works for color codes (&2 and §2) and variables
- Make use of escaping in the Message class to properly handle user input as plaintext (previously user input that got printed back also got interpreted, like colors apply to it)
- All replacements given to Message are escaped, unless you wrap them in a Message before it.
- Replacement limits and infinite replacing detection have changed slightly
2016-12-26 22:56:35 +01:00
Thijs Wiefferink 152f183670 Fix region update after /as reload, cleanup unused code 2016-12-25 23:02:23 +01:00
Thijs Wiefferink 09b6e4c584 Fix string setting as profile in default.yml
- This has been broken in b525c5902c
- Fixes #267
2016-12-25 22:40:11 +01:00
Thijs Wiefferink aeb70196a3 Fix shutdown exception in SignsFeature 2016-12-24 19:59:04 +01:00
Thijs Wiefferink 62148ea577 Move teleportation code to a feature class 2016-12-23 23:25:41 +01:00
Thijs Wiefferink fcc9fb0945 Refactor to introduce Manager and RegionFeature
- Manager to serve as abstract class for managers (like FileManager), implements a lifecycle to allow for shutdown operations (like save all files)
- RegionFeature to server as abstract class for region features
- Improve instantiation and lifecycle of features (global features and region specific ones)
- This is preparation for moving more region functionality into feature specific classes (which makes GeneralRegion smaller and easier to maintain)
2016-12-23 16:03:22 +01:00
Thijs Wiefferink b525c5902c Fix default settings leaking when getting configuration sections
- Default settings and custom settings are in separate YamlConfiguration instances now to prevent leaking
- When getting a configuration section you now know that either it is from the current default.yml file or the default.yml file in the jar (querying settings from the section will always have the same source)
- Fixed a startup null pointer
- Fixed #266
2016-12-23 14:07:26 +01:00
Thijs Wiefferink b18a7cc6d5 Fix [break] in hover lines
Hover lines are still a bit broken when trying to insert complex messages into them, this is hard to do in a proper way though.
2016-12-10 15:19:34 +01:00
Thijs Wiefferink 54b6e84558 File loading improvements to be more robust 2016-12-04 21:14:31 +01:00
Thijs Wiefferink bae3c0a199 Ask for config files in the issue template 2016-12-04 17:56:37 +01:00
Very Evil Olaf 508270a280 Update ISSUE_TEMPLATE.md (#258)
Note that 'latest' is not a correct version
2016-12-04 17:48:36 +01:00
Thijs Wiefferink 87b2cb9ecd Prevent exceptions if a schematicProfile does not exist 2016-12-04 17:31:22 +01:00
Thijs Wiefferink 271b17b6be Set version to 2.4.0 and update language files 2016-12-02 14:37:27 +01:00
Desjardins Jérôme 1dfedea50c Create a permission for teleporting to available regions (#241)
* Update GeneralRegion.java
Add Available abstract function
Check Permission modification

Update BuyRegion.java
Add Available function for selled

Update RentRegion.java
Add Available function for rented

Update TeleportCommand.java
Check new permission

Finish feature teleport available region

* Fix translation
2016-11-19 17:15:23 +01:00
Thijs Wiefferink d9abe2e347 FIx problem with null regionFlags sections 2016-11-14 18:02:59 +01:00
Thijs Wiefferink 1ba2e21ae9 Make profile based settings easier to understand
- Remove 'signProfiles', 'flagProfiles', 'eventCommandProfiles', 'schematicProfiles' and 'expirationWarningProfiles' from the config.yml file
- Add the removed profile contents directly to the setting without the trailing 's' in the default.yml file (this prevents the need to understand the creation of profiles, and then assigning them, taking out a step in the thought process of users)
- Added method in GeneralRegion to get a ConfigurationSection from the region file, group files or default file while also taking into account the translation from a string to a profile that is defined in the config.yml file. This ensures backwards compatibility with current config files (the old style will not be promoted anymore though).
- The 'expirationWarningProfiles' does not have the subkeys 'warnPlayer' and 'commands' anymore, it is just a list of commands now, using the '/areashop message' command to warn a player.
- Add a workaround for the empty sign problem after unrent/sell of a region while having restore enabled, an AsyncWorldEdit plugin installed and signs inside the region (sign will be updated again half a second after unrent/sell).
2016-11-13 00:44:35 +01:00
Thijs Wiefferink fcdfdc6094 Update language files
- Swedish is added
- German, French and Russian are improved
2016-11-07 14:13:03 +01:00
Thijs Wiefferink 8a7e2ba5c2 Indicate limits when a MaxChangedBlocksException is thrown by WorldEdit 2016-11-07 13:52:54 +01:00
Thijs Wiefferink 0950452692 Fix a couple of problems caused by vertical /as stack addition 2016-10-31 21:07:08 +01:00
Thijs Wiefferink 293978f068 Decouple Message class from replacement providers
- Instead of applying replacements by testing for a replacement that has the GeneralRegion type, it now checks for a ReplacementProvider instances (one step closer to making Message independent of AreaShop).
- Replacements are handled one by one with a switch-case instead of getting them from a map, helps performance a lot.
2016-10-25 20:57:58 +02:00
Thijs Wiefferink 5efe14b8e9 Add up and down direction for '/as stack'
Prevents creating regions above and below the world limits, still needs
testing.
Progress for #105
2016-10-24 15:02:49 +02:00
Thijs Wiefferink 839d510151 Switch from Bukkit to Spigot Maven repo since it is down
Also switched from Bukkit 1.7.9 to Bukkit 1.8.0 because that is the lowest version available on the Spigot repo
2016-10-17 23:45:08 +02:00
Thijs Wiefferink 9180d9b8ee Fix small language file issue
When you only have a formatting code before a language variable, the hover/click effects will accidentally be applied to one text part earlier
2016-10-16 18:29:26 +02:00
Thijs Wiefferink 7aa786f4ce Fix default config trying to execute /as message as player
Fixes #221
2016-09-04 22:43:03 +02:00
Thijs Wiefferink 10ea8540e7 Add tab completion for '/as me [player]'
Closes #220
2016-09-04 00:59:04 +02:00
Thijs Wiefferink dba00769f6 Fix problem with line breaks 2016-09-03 20:58:45 +02:00
Thijs Wiefferink 44c70c6a33 Cleanup messages about region that does not exist in WorldGuard 2016-09-03 19:46:05 +02:00
Thijs Wiefferink 570f7b4055 Don't extend rent when using '/as setowner' to set a different owner
Also remove new owner from the friends list.
Fixes #219
2016-09-03 19:19:40 +02:00
Thijs Wiefferink feafa012dd Fix issue with \n on 1.7.x servers
- Each line of a message will now be sent separately instead of using '\n' in the text
- Drastically reduced the number of StringBuilders that are instantiated during message construction
- Fixes #222
2016-09-03 17:22:40 +02:00
Thijs Wiefferink 82b340ce1a Messages: also parse section signs into color tags properly
Fixes line-wrapping removing color in some cases
2016-09-02 21:43:58 +02:00
Thijs Wiefferink 93809f27fc Rename events to be consistent with commands
- AddFriendEvent -> AddedFriendEvent
- DeleteFriendEvent -> DeletedFriendEvent
- RemovedRegionEvent -> DeletedRegionEvent
2016-08-28 22:45:20 +02:00
Thijs Wiefferink f8ed3654fd Fix compilation error 2016-08-28 22:31:06 +02:00
Thijs Wiefferink 58a1afccf3 Invert inheritance of RegionEvent and CancellabelRegionEvent/NotifyRegionEvent 2016-08-28 22:29:45 +02:00
Thijs Wiefferink d9c3573225 Change RegionUpdateEvent to UpdateRegionEvent
This breaks plugins using the event
2016-08-28 22:21:33 +02:00
Thijs Wiefferink 1577443203 Generalize events better
Adds generic classes for events with a region (BuyRegion, RentRegion or GeneralRegion)
2016-08-28 22:11:17 +02:00
Thijs Wiefferink ab7a92c57d Update README.md 2016-08-26 19:49:21 +02:00
Thijs Wiefferink 2e09b0f60f Update README.md 2016-08-26 19:48:59 +02:00
Thijs Wiefferink 6e5c35f95b Add extension plugins section 2016-08-26 19:45:37 +02:00
Thijs Wiefferink 066ceedafd Add 'build' flag by default to prevent inheriting from parent regions. 2016-08-21 22:20:25 +02:00
Thijs Wiefferink c8ebe24bd3 Put break in '/as info' help message in the right spot 2016-08-19 20:52:07 +02:00
Thijs Wiefferink ad7db5ee23 Attempt to fix unable to add new players with '/as addfriend' 2016-08-16 22:43:09 +02:00
Thijs Wiefferink f80a8178ff Fix formatting not clearing on new lines 2016-08-13 22:28:15 +02:00
Thijs Wiefferink 05c8e1a7e4 Make loggin methods more generic 2016-08-10 16:07:39 +02:00
Thijs Wiefferink 9904805310 Improve version detection of WorldGuard
- First detect version 5
- Then detect lower than 6.1.3
- Else check build number:
  - Build number exists and lower than 1672: 6
  - Build number exists and Is 1672: broken
  - Else: 6_1_3
2016-08-09 22:56:21 +02:00
Thijs Wiefferink 0df2f429c0 Only print build number warning if we found it 2016-08-09 22:38:33 +02:00
Thijs Wiefferink b3408a2648 Fix compilation error and WorldGuard version detection 2016-08-09 21:52:53 +02:00
Thijs Wiefferink e1f89e7904 Cleanup some leftover logging in an old style 2016-08-08 22:06:31 +02:00
Thijs Wiefferink 064b129205 Change version to 2.3.2 and update languages
- Russian has been added
- Spelling errors in French have been corrected
2016-08-07 22:21:57 +02:00
Thijs Wiefferink 8111387f32 Improve friend line of /as me, add click hint
Change blue color of hover popup to gold, which will be used as action color
2016-08-07 22:06:09 +02:00
Thijs Wiefferink a4b23bebba Improve line of rented regions in info command 2016-08-07 21:49:44 +02:00
Thijs Wiefferink 7421e685fa Improve robustness of variable replacing in messages
- Once the limit is reached the argument replacer would still continue sometimes (if a the replacement itself triggers the limit and the inserted message increases the size of the message we are building and adds a parameter tag again, like %0%)
- The language tag replacer also stops earlier now, it did not have the above problem though
- Fixed FancyMessageFormat.insertMessage() not checking its parameters
- Message.get() with a limit will now return an empty message if the limit is reached to prevent problems like above.
- Closes #205
2016-08-07 00:09:30 +02:00
Christoph Krüger @Androkai 374b68d8fa Update VaultAPI-repo (#206)
The url of the Vault Maven repository has changed.
2016-08-06 22:36:26 +02:00
Thijs Wiefferink ca7a9664f3 Fix error in info command of rental region 2016-08-02 22:27:55 +02:00
Thijs Wiefferink e957b4fc73 Remove all reflection for sending fancy messages
- Reflection removed
- JSON is now fully escaped instead of lenient escaping
- Sending is now done with /tellraw
2016-08-01 21:31:14 +02:00
Thijs Wiefferink 6493bc4f78 Add empty lines if a page does not fill the screen
Relevant for commands like `/as info all` that can have pages
2016-08-01 21:28:11 +02:00
Thijs Wiefferink 2db1b6a243 Prevent updater throwing errors sometimes when BukkitDev is offline 2016-08-01 20:46:40 +02:00
Thijs Wiefferink 864662a3c4 Add javadocs to limitgroup inner class and setting methods 2016-08-01 20:23:49 +02:00
Thijs Wiefferink 59b960b87c Update languages, set version number to 2.3.1
- Added German translation
- Added French translation
- Added Norwegian translation
2016-08-01 19:36:50 +02:00
Thijs Wiefferink 2de653d73f Add automatic conversion of language files downloaded from Transifex 2016-08-01 18:03:09 +02:00
Thijs Wiefferink 4feee59834 Cleanup info and warning messages. 2016-08-01 16:18:05 +02:00
Thijs Wiefferink 816d136a62 Change version number to 2.3.0, update languages
- Only English and Dutch are available yet
2016-07-24 21:48:39 +02:00
Thijs Wiefferink 121de7dc7e Add build number option to Maven
- Build number option can be used by Jenkins to add the build number
- Build number of soruce on Github will be #CUSTOM to mark custom builds
- Release versions will not contain a build number
- Closes #185
2016-07-24 20:59:25 +02:00
Thijs Wiefferink f7c86881cc Fix the default flagProfiles settings, fix migration issues. 2016-07-24 20:25:58 +02:00
Thijs Wiefferink 351d51b664 Correct message for reselling region entries. 2016-07-23 19:31:45 +02:00
Thijs Wiefferink 5a28476cf0 Add better limits for messages
- Recursive replacements are handled by catching stackoverflow exceptions
- Messages are limited 30000 in length for the produced JSON string since the client cannot handle more
- Error message print out the message key and start of the message
2016-07-23 17:21:08 +02:00
Thijs Wiefferink 8143bdae27 Add pages to the /as info command to prevent crashes
- Output displayed in pages of 18 (+ header and footer it fills the max of 20 you can see without scrolling)
- Footer shows current and max page, and has buttons to go to next/previous
- Commands accept [group] [page] both as optional arguments, works because page is a number (number as group would be weird)
- Entries show basic info about regions (owner/price/duration), and of course can be clicked to show all info
- Made debug command more generic
- Closes #172
2016-07-23 02:57:31 +02:00
Thijs Wiefferink b62744fe10 Add warnings for missing settings in limit groups.
Closes #164
2016-07-21 23:00:19 +02:00
Thijs Wiefferink fe0b63c760 Remove incorrect check 2016-07-17 23:51:24 +02:00
Thijs Wiefferink def774c7a1 Link javadoc of external classes properly
Classes of Bukkit, WorldGuard and WorldEdit that appear in the javadoc now link to the javadoc of them.
2016-06-27 23:38:44 +02:00
Thijs Wiefferink 7c5cb5f5aa Add javadoc to getApplicableRegions methods 2016-06-27 23:16:21 +02:00
Thijs Wiefferink 8af6e1d6f1 Fix small Maven warning 2016-06-25 22:20:21 +02:00
Thijs Wiefferink e0e6c39dae Fix WorldGuard version detection for later stable releases 2016-06-21 22:42:56 +02:00
Thijs Wiefferink dabe46bd47 Move all sign related methods into SignsFeature
- Each GeneralRegion now has a SignsFeature
- Each SignsFeature contains RegionSign instances representing the actual signs
 - The RegionSign class contains methods to update them etc
 - There is one SignsFeature that is not linked to a region, but registered as listener to update the signs at events
2016-06-20 20:16:13 +02:00
Thijs Wiefferink ec478a05d1 Move region friends code to separate Feature class 2016-06-20 18:22:35 +02:00
Thijs Wiefferink e21c0aafde Add events for adding/removing friends
- Cancellable event for adding friends: AddFriendEvent (region, friend and who is trying to add it available)
- Cancellable event for removing friends: DeleteFriendEvent (region, friend and who is trying to delete it available)
- Closes #54
2016-06-20 17:03:12 +02:00
Thijs Wiefferink 52bf88f4a5 Prevent RemovedRegionEvent triggering twice
Add debug logging for RemovedRegionEvent and AddedRegionEvent
2016-06-20 16:32:10 +02:00
Thijs Wiefferink e4de560a65 Prevent Maven warning
It was trying to include the WorldGuard6 handler class twice in the jar file
2016-06-20 16:28:23 +02:00
Thijs Wiefferink 6481da29e4 Add compatibility for WorldGuard build 1674 and up.
- Added a module for WorldGuard 6.1.3 to adapt to changes in flag related methods.
- No compatibility with build 1672, since there is no dependency in the Maven repo of WorldGuard to target this (this is a dev build though so I don't expect people using it long-term)
- Move properties for setting Java version to the parent pom file (other modules inherit them)
- Move repositories to the parent pom file (other modules inherit them)
- Fix AreaShop module not declaring its parent
- Fixes #170
2016-06-18 23:23:22 +02:00
Thijs Wiefferink f287cc91a6 Remove leftover logging 2016-06-13 21:11:00 +02:00
Thijs Wiefferink 95b7b50346 Add development builds and javadocs links 2016-06-13 20:59:08 +02:00
Thijs Wiefferink 21db2ff440 Improve Maven setup for javadoc and source
- Generate a .jar file with the sources if -Dsources is provided
- Generate javadocs if -Djavadoc=/path/to/destination is provided
- Copy final .jar file to directory if -DcopyResult=/path/to/server is provided
- Adding missing javadoc comments
2016-06-13 20:36:17 +02:00
Thijs Wiefferink 36dd978a92 Cleanup the config file and settings
- Moved scheduled task settings to hiddenConfig.yml (settings that are not visible, but still usable)
- Remove 'postCommandErrors' setting
- Also execute commands defined in 'expirationWarningProfiles' when player is not online
- Move around settings in config.yml and improve explanations
- Closes #168
2016-06-13 17:03:20 +02:00
Thijs Wiefferink 6cc3f2a52f Combine all messages about region not registered
And replace mentions of 'this region' with the actual region name.
2016-06-13 14:47:10 +02:00
Thijs Wiefferink 852731b1ad Add action confirmations when using signs
- Confirmations by default for selling/unrenting by signs, not for renting/buying
- Fixed a bug with message composing which would duplicate hover/click parts.
- Added `/as message <player> <message...>` for internal/console use (not shown in help).
- Closes #50
2016-06-12 21:39:12 +02:00
Thijs Wiefferink 30faa77da9 Fix small error in multiple regions found message 2016-06-12 19:38:05 +02:00
Thijs Wiefferink ec57b922b8 Messages: Version fixes, fallback to plain.
- Properly parse NMS version number to support 1.10
- Fallback to plain messages if sending a fancy message breaks (we try again after restart/reload)
2016-06-12 16:48:47 +02:00
Thijs Wiefferink c2bcc6008b Add hover/click to some forgotten mentions of regions 2016-06-12 13:25:55 +02:00
Thijs Wiefferink 72a05bedce Merge personal/all help messages. 2016-06-11 22:40:09 +02:00
Thijs Wiefferink bc73a8b20d Cleanup links to issues 2016-06-11 17:35:00 +02:00
Thijs Wiefferink 832e8218b6 Add issue template for bugs/feature requests 2016-06-11 17:29:47 +02:00
Thijs Wiefferink 6fcb629133 Move to the me.wiefferink package
The nl.evolutioncoding domain is soon not mine anymore, and this new one I do intend on keeping.
2016-06-07 22:39:45 +02:00
Thijs Wiefferink 7d6a1f35c1 Messages: Add hover/click items to region info
- The hover/click parts only appear if you have permission to use the command linked to it
- Red crosses added next to the friends in the friend list to remove them
2016-06-05 17:04:38 +02:00
Thijs Wiefferink 60257d45c2 Messages: Add a bunch of click/hover actions to '/as info region <region>'
- rent/unrent/buy/sell/extend
- teleport, set teleport location
2016-06-04 22:46:10 +02:00
Thijs Wiefferink 2300227d87 Messages: Fix problem with message insertion sometimes missing leftover part 2016-06-04 20:57:14 +02:00
Thijs Wiefferink b1852b10bb Improve /as me, remove /as info player
And change underline to bold for clickable things (underline leaks through in the next line, giving annoying layout issues)
2016-06-02 22:39:30 +02:00
Thijs Wiefferink 88fdb0c3fc Add 'ALL' flagProfiles state that is always applied
And add block-break and block-place by default.
2016-05-31 22:36:18 +02:00
Christoph Krüger 491e55fc77 Change Vault dependency to Maven repo instead of .jar
Use the Maven repository of Vault instead of including a jar file in the repository.
2016-05-28 23:19:23 +02:00
Thijs Wiefferink c7b0a2c663 Let /as help respect the areashop.help permission
Closes #155
2016-05-28 17:04:06 +02:00
Thijs Wiefferink 868f4d6b58 Events: Add refunded money to UnrentedRegionEvent and SoldRegionEvent
Closes #147
2016-05-28 17:00:52 +02:00
Thijs Wiefferink 0d4b034181 Messages: Detect and stop replacement loops. 2016-05-28 16:51:32 +02:00
Thijs Wiefferink 5f20689ba3 Improve language variable argument detection 2016-05-27 21:01:14 +02:00
Thijs Wiefferink 38b658fccf Message changes: click on regions/players
- Click on region name for region details
- Click on player name for regions of the player
- Click on landlord name for regions of the landlord
- Change color codes to things like [blue] instead of &9 (both are supported though)
2016-05-24 23:18:25 +02:00
Thijs Wiefferink 28ed20c0b5 Message system fixes and improved robustness
Hover/click message for '/as info'
2016-05-23 12:16:19 +02:00
Thijs Wiefferink aaff36b2eb Add hover/click support for messages #18
- Language files support a way to add hover tooltips, click commands and click insert commands (using FancyMessageFormat created together with PhoenixIV)
- Language variables support arguments
- Help listing (/as help) uses the new hover/click things, more to come
- See #18 for the TODO list
2016-05-22 21:36:58 +02:00
Spidev46 49b536cab0 There is a mistake with the messages (#153)
Confirmation message of reselling a region does not go to the old owner.
2016-05-22 21:19:10 +02:00
Thijs Wiefferink 9a9969dea3 Fix problems with detecting most important region when placing a sign.
WorldGuard filters child regions from the ApplicableRegionSet for some reason, so setting parent/child relations on regions messes up the detection because the children can never be found.
2016-03-07 12:21:33 +01:00
Thijs Wiefferink 84e4b49bfd Update language files
English, Dutch and German are complete, others are only partially complete.
2016-03-06 00:07:31 +01:00
Thijs Wiefferink 6daaf6997d 1.9 compatibility fixes (getOnlinePlayers() method) 2016-03-05 22:15:21 +01:00
Thijs Wiefferink c445a62334 Add variable support to all messages where a region is known (mostly messages of commands were not using it yet). 2016-02-08 19:39:33 +01:00
Thijs Wiefferink 0d205b0d9e Change general.teleportLocationY to also accept a number. 2016-02-08 14:43:24 +01:00
Thijs Wiefferink 8c33826c2c Add build flag to default flagprofiles, users are often having trouble with this 2016-01-26 22:35:01 +01:00
Thijs Wiefferink 51e1dbafb7 Fix running sign commands going wrong.
Player commands are run first, which normally rents/buys a region, so when the console commands are ran after that, then it will run the commands of the wrong state (since the state just changed). Also fixed a minor WorldGuard version dependency issue.
2016-01-26 22:20:45 +01:00
Thijs Wiefferink 6edad3faff Add priority and interact flag to config.yml by default
50% of the issues are having more regions at the same place, and therefore requiring a higher priority for the AreaShop region and having chests accessible by anyone instead of only the region owner/member. This should fix these problems.
2016-01-12 21:43:04 +01:00
Thijs Wiefferink f89e0f861b Add a link to a preview server 2016-01-08 20:18:47 +01:00
Thijs Wiefferink 770b1d98df Refactoring:
- Move a bunch of utility methods from the AreaShop class to Utils
- Comments styling cleanup
- Display warning in console when region file does not load correctly (is empty)
2016-01-05 22:31:55 +01:00
Thijs Wiefferink 8e5baa47af Fix variables of sell messages 2015-12-26 20:08:01 +01:00
Thijs Wiefferink 367466735e Fix the 'n:<name>' option for member/owner region flags
Before it would keep the 'n:' part when adding the name to the region, therefore adding an incorrect name.
2015-12-26 00:45:05 +01:00
Thijs Wiefferink ade6bc3971 Add AddedRegionEvent+RemovedRegionEvent, moved sign/flags updating
- Sign updating now uses the event system
- WorldGuard region flag updating now uses the event system
- After changes made by commands/other user input it will now use update() on the region instead of the sign and region flag commands.
2015-12-13 19:55:47 +01:00
Thijs Wiefferink 05fd8c0156 Implement event system
- 'ask' type events that can be cancelled, broadcasted before the action happens
- 'notify' type events that cannot be cancelled, but only let you know that it has happened
- Events for renting (with extending flag), unrenting, buying, selling, reselling
- General 'RegionUpdateEvent' to listen to as display service (update signs, update regions flags, etc)

All messages in the GeneralRegion, RentRegion and BuyRegion classes can now use all region variables (in the future all other messages will also be worked through)

Closes #84
Closes #86
2015-12-11 20:54:12 +01:00
Thijs Wiefferink 5403472476 Cleanup/update config.yml and default.yml comments
- Add links to the wiki.
- Make things more consistent.
2015-12-10 23:16:19 +01:00
Thijs Wiefferink c4ee7bc7aa Add 'areashop.linksigns' to the 'areashop.*' permission group 2015-11-24 20:59:58 +01:00
Thijs Wiefferink 940f1969b6 Add link to dev builds on Jenkins 2015-11-24 20:43:44 +01:00
Thijs Wiefferink 07eb5477b8 Update Metrics 2015-11-17 21:21:27 +01:00
Thijs Wiefferink a4112092b5 Fix inclusion of the version specific classes of WorldGuard/WorldEdit in the final jar 2015-11-15 23:47:23 +01:00
Thijs Wiefferink 872d81b0a9 Cleanup code, fix some small bugs
Most of these things have been found with help of Intellij IDEA, preferring it over Eclipse already
2015-11-15 23:35:48 +01:00
Thijs Wiefferink b04871c553 Add rental to max when rental would go above maxRentTime otherwise
- Setting `extendToFullWhenAboveMaxRentTime` to set if AreaShop should
automatically extend to max when the player cannot rent a full duration
because of `maxRentTime`.

Fixes #94
2015-11-11 11:56:16 +01:00
Thijs Wiefferink fd1b8fba4c Fix inactiveSetting debug messages
The messages still assumed the inactiveSettings was in minutes instead
of in milliseconds.
2015-11-02 22:39:40 +01:00
Thijs Wiefferink 991e7b1961 Fix lastActive sometimes not updating correctly
- Update the lastActive time at rent/buy to ensure it is non-zero
- Ignore lastActive time of zero, give back current time
- Update lastActive time at server shutdown for players that are still
online, quit events are not fired at shutdown
2015-11-02 22:32:51 +01:00
Thijs Wiefferink aac963325a CI run :) 2015-11-01 23:03:41 +01:00
Thijs Wiefferink 3e7c7ce76b Fix message variables for '/as info player <player>' feedback 2015-10-31 23:15:11 +01:00
Thijs Wiefferink c858d30481 Add .gitignore to the repository 2015-10-19 19:07:31 +02:00
Thijs Wiefferink b090fd5577 Remove MCStats image, site is more offline than online 2015-10-17 22:10:38 +02:00
Thijs Wiefferink 8d132c66c4 Prepare for the v2.2.1 release
- Update version number
- Update language files from Transifex
2015-10-17 21:03:30 +02:00
Thijs Wiefferink 50e3e59543 Fix indentation and error message of WorldEdit 6 integration handler 2015-10-15 12:13:15 +02:00
Thijs Wiefferink eb21b9567e Change signtags from [arent] and [abuy] to [asrent] and [asbuy]
Changes #45
2015-10-08 22:49:41 +02:00
Thijs Wiefferink 4dba305f6d Change the default sign tags to something more specific
Note: Change documentation pages to include this.

Fixes #45
2015-10-06 22:41:59 +02:00
Thijs Wiefferink 7481d8287f Retrieve money from landlords when unrenting/selling a region.
Prevents exploits by giving money to landlords, and then
unrenting/selling to get money back from 'the server' (nobody). Now it
will get the money back from the landlord, or if that is not possible
then not give anything back.

Fixes #75
2015-10-06 22:15:09 +02:00
Thijs Wiefferink 4d41decbe5 Config part of week indicators 2015-10-03 21:14:24 +02:00
Thijs Wiefferink 7fc5a5af81 Add weeks time indicators, clean other indicators
The old Dutch time indicators have been removed from the lists, this
might cause problems for people if they regenerate their config but
don't add these tags again.

Added console warnings at startup to indicate incorrect duration
strings.

Fixes #32
2015-10-03 21:12:38 +02:00
Thijs Wiefferink d26fa99b95 Fix using the seconds modifier with /as setduration
AreaShop could correctly read and use all seconds modifiers that are
defined in the config, but the `/as setduration` command would not
accept it as input.

Fixes #82
2015-10-03 20:38:38 +02:00
Thijs Wiefferink 39d755d2db Make removing regions from AreaShop less destructible for region flags
First AreaShop would reset all flags, now it will only reset the
greeting and farewell flags. This is to make sure players do not get
confused about the region, if the greeting is still there then players
might think it is still connected to AreaShop.

Fixes #72
2015-10-03 20:27:19 +02:00
Thijs Wiefferink 48ab46ecf7 Fix indirect breaking of signs causing it to disconnect
If you would break a block behind/below a sign AreaShop would disconnect
it from the region, which is most of the times not the wanted behaviour.
This commit changes it to simply leave a floating sign there, so that it
is still visible and not disconnected from the region.

Fixes #15
2015-10-03 20:10:44 +02:00
Thijs Wiefferink b3fa31e1cc Remove debug message 2015-10-02 20:44:25 +02:00
Thijs Wiefferink 783085fbf7 Cache region variable replacements 2015-10-02 20:41:00 +02:00
Thijs Wiefferink aa093b0c8a Fix sign clicking still executing while event is cancelled. 2015-09-26 01:06:22 +02:00
Thijs Wiefferink 9c357fe929 Remove lastActive from region file when unrented/sold
No problems if it is there, but just keeping the region file clean.
2015-09-11 22:44:12 +02:00
Thijs Wiefferink 4d70571a23 Improve failed file loading
- Detects incorrectly loaded config.yml and default.yml
(YamlConfiguration prints errors to console and continues silently,
returning an empty configuration if something is wrong normally)
- Will go into error state when loading fails
- Improved some error handling to make sure that no extra errors are
thrown because of trying to close non-existing streams.
2015-09-10 21:58:57 +02:00
Thijs Wiefferink 29a4105ece Add Vault to the repo to make it easier to compile 2015-09-06 17:05:38 +02:00
Thijs Wiefferink edc7136063 Fix '/as info' always showing landlord line
It would always show the landlord line, if there was no actual landlord
it would show '<UNKNOWN>' as name, which is very confusing.

Fixes #46
2015-09-06 16:42:16 +02:00
Thijs Wiefferink 6fabc75be4 Fix '/as info' trying to filter by group too much
'/as info region' would also try to filter by group using the region
name, which would almost always cause an error message (group not found)
2015-09-06 16:38:23 +02:00
Thijs Wiefferink 085507bf8b Add required dependencies section 2015-08-30 00:10:12 +02:00
Thijs Wiefferink 73ed3366ae Update README.md 2015-08-29 22:27:14 +02:00
Thijs Wiefferink 9ca029176d Fix '/as find' not getting your balance correctly
- If you search with your balance (and do not give a maxprice) it would
always use 0.0 as your balance, therefore not finding any regions.
- Also fixes the incorrect feedback, it would say it searched with a
maxprice instead of your balance and the other way around if no regions
are found.
- Fixed maxprice and balance display to use correct currency symbols and
layouts (decimals, metric prefixes, separator).

Fixes #59
2015-08-29 20:06:16 +02:00
Thijs Wiefferink bf181d69d7 Update README.md 2015-08-29 19:46:05 +02:00
Thijs Wiefferink 68c57515da Update README.md 2015-08-29 19:44:54 +02:00
Thijs Wiefferink 903d6c309f Update README.md 2015-08-29 19:44:39 +02:00
Thijs Wiefferink 0a02eb3254 Update README.md 2015-08-29 19:42:57 +02:00
Thijs Wiefferink bf04589fab Merge links to issues with the top menu 2015-08-29 19:42:11 +02:00
Thijs Wiefferink 14dd094803 Update README.md 2015-08-27 22:51:49 +02:00
Thijs Wiefferink 02df35304c Update README.md 2015-08-27 22:48:11 +02:00
Thijs Wiefferink 4321667ec5 Merge branch 'master' of https://github.com/NLthijs48/AreaShop 2015-08-26 20:05:03 +02:00
Thijs Wiefferink 5cf5df78c8 Add permissions to prevent buying resell regions
- Permission 'areashop.buynormal' can be negated to only allow buying
regions that are in resell mode
- Permission 'areashop.buyresell' can be negated to only allow buying
regions that are not in resell mode

This change does not affect existing permissions setups (above
permissions are true by default)
2015-08-26 20:04:50 +02:00
Thijs Wiefferink 8608d6ce1d Update README.md 2015-08-25 17:40:08 +02:00
Thijs Wiefferink 614336862e Update README.md 2015-08-25 17:38:02 +02:00
Thijs Wiefferink a4ea175f1b Update README.md 2015-08-25 17:33:52 +02:00
Thijs Wiefferink c96043aa38 Update README.md 2015-08-25 17:30:11 +02:00
Thijs Wiefferink d5a29f6c32 Update README.MD: WIP frontpage
Frontpage like the BukkitDev and Spigot Resources section.
2015-08-25 17:29:21 +02:00
Thijs Wiefferink 5176a1c2c5 Update README.md 2015-08-21 21:45:42 +02:00
Thijs Wiefferink 89569ea182 Update README.md 2015-08-17 23:11:46 +02:00
Thijs Wiefferink f349657a59 Fix bug with teleporting to signs
Fixes #47
2015-08-13 22:04:22 +02:00
Thijs Wiefferink 40d3d4d8af Add group filtering to /as info <rented|forrent|sold|forsale>
- Filter regions by group for the mentioned subcommands of /as info
- Clean/refactor code
- Sort the output
- Add Comparable, equals() and toString() to GeneralRegion

Closes #44
2015-08-11 22:41:30 +02:00
Thijs Wiefferink 0d5db8fa4e Add option to deny extending when over rent/total limits
Turned on by default, added config setting
'allowRegionExtendsWhenAboveLimits' to disable this change. Normally
this is expected behaviour, which pushes users to let the region run out
if they should not be able to rent it anymore (was impossible to do
before).

Closes #41
2015-08-10 21:43:29 +02:00
Thijs Wiefferink 25c56e8ecb Add permissions for landlords to remove regions
Closes #33
2015-07-31 22:56:12 +02:00
Thijs Wiefferink 9f436a7eb4 Fix landlord UUID/name handling
Also changes handling of buyer/renter UUIDs and names, if the playerdata
of a player is not available anymore AreaShop will still be able to
display his name. Also unrenting/selling will still properly pay back
the player through Vault (by name instead of UUID).

Fixes #35
2015-07-30 22:55:49 +02:00
Thijs Wiefferink f76c1b8a9f Save last online time self instead of using the Bukkit API
The Bukkit API returns an incorrect last online time when the player.dat
file is not present (for example when a server saves inventories etc.
somewhere else, or when it is cleaned).

Improves landlord handling when there is no UUID present in the config
files.

Closes #34
2015-07-28 23:02:52 +02:00
Thijs Wiefferink d466658f36 Allow only providing landlord name, instead of UUID 2015-07-28 21:50:28 +02:00
Thijs Wiefferink 04e02c4ce4 Adds a way to change number length for stack region names
Adds dots after all config explaination lines, fixes a couple things
with groups.yml file saving (would save unnecessary sometimes).

Fixes #26
2015-07-26 20:56:44 +02:00
Thijs Wiefferink 3bf493109c Add date/time variables for commands/schematics
Fixes #21
2015-07-26 20:15:45 +02:00
Thijs Wiefferink 2f9b6d3987 Update language files to the latest available versions on Transifex 2015-07-25 16:57:24 +02:00
Thijs Wiefferink 93d5612513 Fix a bug with depositing to players that never joined
Paying to players that never visited before will now fallback to using a
name instead of UUID towards Vault, which prevents problems (for players
that never visited, such as server accounts, you cannot get the name
from the UUID via Bukkit).
2015-07-25 16:56:41 +02:00
Thijs Wiefferink 937db4620d Fix problem with default value 'unlimited' for maxRentTime 2015-06-21 19:29:54 +02:00
Thijs Wiefferink a0239b8837 Fix loading when there is no regions folder 2015-06-21 17:08:11 +02:00
Thijs Wiefferink 401f52e687 Change additional places where the contains is used 2015-06-13 22:56:27 +02:00
Thijs Wiefferink 2f6874a16e Fix contains check for WorldGuard regions not version dependend 2015-06-13 22:50:06 +02:00
Thijs Wiefferink c95f4e1c6c Fix problem with '/as addfriend' denying first-joined players
Before it checked if the player had played before on the server in order
to check if the friend will get accepted, but this fails when the player
is playing for the first time. This has been repaired.
2015-06-13 22:06:34 +02:00
Thijs Wiefferink 1a2d755727 Fix message using incorrect time unit 2015-06-11 15:42:39 +02:00
Thijs Wiefferink c489e6eba4 Commit changes in language file 2015-06-11 15:32:29 +02:00
Thijs Wiefferink b1a56b5230 Fix maxRentTime, inactiveTimeUntilUnrent/-Sell settings
Made a misake while converting these settings to accept human-readable
durations strings instead of only minutes.
2015-06-11 14:11:41 +02:00
Thijs Wiefferink dfbc7805b5 Fix a couple of bugs 2015-06-11 00:51:44 +02:00
Thijs Wiefferink 8f2c95f5c4 Merge branch 'master' of https://github.com/NLthijs48/AreaShop 2015-05-22 19:01:40 +02:00
Thijs Wiefferink 0b9bffe68f Fix bug with changed time settings not loading old values 2015-05-22 19:01:30 +02:00
Thijs Wiefferink 7ac6e34c89 Update README.md 2015-05-12 10:25:07 +02:00
Thijs Wiefferink 5231f6e86e Change all time period settings to readable format
Changed all settings that took minutes or seconds as unit before to use
the format also used on signs (things like '50 seconds', '1 day', '3
months' etc).
Fixed a bug with display of currency numbers being unrounded when not
displayed with SI prefix.
2015-05-03 22:51:19 +02:00
Thijs Wiefferink 791b696aff Add support for Metric prefixes to display large numbers
Indications are used as defined on:
http://en.wikipedia.org/wiki/Metric_prefix, implemented from 'k' to 'Y'.
Added setting 'metricSuffixesAbove' to config.yml to specify from which
number these characters should be used.
Added setting 'decimalMark' to change the character(s) used as decimal
separation (is a comma instead of a dot in certain countries).
2015-05-03 00:15:05 +02:00
Thijs Wiefferink c92bc716dc Change module names to fit project setup
Forgot to rename the folders that contain the interface classes. Cleaned
pom.
2015-05-02 00:33:34 +02:00
Thijs Wiefferink 463b34e952 Merge pull request #13 from Androkai/patch-1
fix typo "targer" --> "target"
2015-05-01 11:02:53 +02:00
Androkai ff6e69196d fix typo "targer" --> "target" 2015-04-30 22:50:43 +02:00
Thijs Wiefferink 76ad952bb6 Remove unnecessary marking as 'to be saved'
Marking as 'to be saved' is already done when a setting change is
written to the YAML file, so it does not have to be called from the
places where settings are changed.
2015-04-28 20:38:44 +02:00
Thijs Wiefferink 0cdff5e143 Move README.md to the correct place. 2015-04-28 18:56:13 +02:00
Thijs Wiefferink 9dc3013215 Update README.md 2015-04-28 18:54:30 +02:00
Thijs Wiefferink 796b95c9f9 Change to a Maven project
Changed project layout to Maven, all dependencies except Vault (does not
have a maven repo) are now included in the pom.xml and will be
automatically downloaded by Maven when building. The project setup uses
modules to support both WorldGuard and WorldEdit version with 1 jar file
instead of having 2 files as the last versions of AreaShop had.

Small bug with boolean settings in the config files has been fixed.
Problem with '/as stack' stacking in the Y direction instead of Z has
been fixed. Plus some refactoring and small changes.
2015-04-28 18:53:42 +02:00
Thijs Wiefferink 2785a72457 Update README.md 2015-04-10 18:50:42 +02:00
Thijs Wiefferink c2df0cd912 Package and classes explanation 2015-04-10 18:47:20 +02:00
Thijs Wiefferink 4cd32a0792 Update README.md 2015-04-10 17:57:45 +02:00
Thijs Wiefferink 354e70af57 Add basic instructions for compiling AreaShop
Intructions to compile AreaShop from the source files provided here at GitHub.
2015-04-10 17:57:00 +02:00
Thijs Wiefferink fde60e2a27 Add permissions for landlords to add regions
Added things:
- "areashop.createrent.owner", "areashop.createrent.member",
"areashop.createbuy.owner" and "areashop.createbuy.member" to let
players add regions to AreaShop when they are member/owner of the
WorldGuard region (because they made the region for example).
- "areashop.setprice.landlord" to give landlords access to setting the
price for their regions
- "areashop.setduration.landlord" to give landlords access to setting
the duration for their regions
- When "default" or "reset" is given as price then the price will be
removed and therefore inherited from a group or default.yml
- When "default" or "reset" is given as duration then the duration will
be removed and therefore inherited from a group or default.yml
2015-03-17 21:22:57 +01:00
Thijs Wiefferink d1a3027e0b Update language files to the current status
Polish is back and 88% translated, Finnish is new and fully translated.
2015-03-13 21:16:44 +01:00
Thijs Wiefferink 4e57f03fc0 Added a command to set the landlord of a region.
The landlord receives all money from rents/buys of the region. Reselling
with '/as resell' does not transfer money to the landlord.
Unrenting/selling will not substract money from the account of the
landlord, so set the 'moneyBack' to 0 to prevent cheating. The
'landlord' setting is also present in the general section of
default.yml, so this means you can also add this setting to a region
group to easily make a group of regions give money to 1 player.
2015-03-13 21:07:59 +01:00
Thijs Wiefferink 83d4efc3a8 Remove redundant setting from the config to enable schematics
The 'enableSchematics' boolean setting from the config.yml file is not
usefull, 'enableRestore' in default.yml already handles the same thing,
and is more flexible (per region or region group instead of general)
2015-03-13 18:25:24 +01:00
Thijs Wiefferink 1395afffe9 Fix a bug with teleporting
Added messages when teleporting automatically changes to teleporting to
a sign instead of to the region or other way around.
2015-03-13 14:41:54 +01:00
Thijs Wiefferink 5094d39a96 Get worlds for WorldEdit the proper way (needs wrapped world) 2015-02-28 19:40:43 +01:00
Thijs Wiefferink e664c1efd9 Load regions at startup, check them at the first tick 2015-02-24 11:48:58 +01:00
Thijs Wiefferink 871eeed29c Change the loading of regions to all at once again
Otherwise it would cause problems with plugins that hook into AreaShop
and try to get regions.
2015-02-23 22:32:54 +01:00
Thijs Wiefferink 0d56762bfc Change to Vault integration to allow custom economies
AreaShop would not use an economy if it would be loaded after it.
2015-02-23 22:21:52 +01:00
Thijs Wiefferink c08763883f Fix a bug with '/as setowner' not saving the region file
Changed the way position the regions are marked as 'to be saved' to
prevent this problem in the future.
2015-02-23 21:48:57 +01:00
Thijs Wiefferink efb534f131 Fix the schematic saving 2015-02-23 19:26:20 +01:00
Thijs Wiefferink d9405a9f49 Make the updatechecker check async
If the updatechecker cannot reach BukkitDev it would slow down the
startup of the server up to 30 seconds (and also if you use /reload),
this will not happen anymore.
2015-02-23 18:11:51 +01:00
Thijs Wiefferink 684add89cd Change the way regions are loaded
Region loading is now started at the first server tick, and will do a
certain number of regions per tick ('loading.regionsPerTick' config
setting). This prevents problems with plugins that load worlds after
AreaShop is loaded. If AreaShop detects that a region does not have a
correct WorldGuard region assigned anymore or the world of the region is
not loaded it will be printed to the console, but it will not delete the
region anymore (which would lead to data loss).
2015-02-23 17:58:10 +01:00
Thijs Wiefferink d1848c0728 Delete .project 2015-02-23 13:32:04 +01:00
Thijs Wiefferink 9fd16290c0 Fix some unclear and wrong messages in the language file
Thanks to qlick for suggesting these language changes. Also fixes a bug
with the '/as info player' command, would cause an error if a region has
an incorrect UUID as owner or an UUID without name.
2015-02-22 23:16:37 +01:00
Thijs Wiefferink 3bbca11cc9 Added the '/as stack' command to easily create and register regions
/as stack <amount> <gap> <name> <rent|buy> [group]
    <amount> Number of regions that will be created
    <gap> Blocks distance between the regions
    <name> Name of the regions (number will be behind it)
    <rent|buy> The type of the region
    [group] A group to add the created regions to
    The regions will be created in the direction you are facing
2015-02-22 17:08:32 +01:00
Thijs Wiefferink b1be87014f Change schematic functions to new WorldGuard 6 classes 2015-02-19 17:22:06 +01:00
Thijs Wiefferink badcd77cfe Changing version number to get ready for a release.
Linksigns feature will be released next version together with other
setup tools.
2015-02-11 11:55:46 +01:00
Thijs Wiefferink 779d340bbb Fix translation of color codes for greeting/farewell messages
Ticket:
http://dev.bukkit.org/bukkit-plugins/regionbuyandrent/tickets/26-color-issue/
Thread at WorldGuard explaining the problem:
http://forum.enginehub.org/threads/color-codes-for-greeting-farewell-flags.15958/
2015-02-11 11:34:15 +01:00
Thijs Wiefferink 4e5061ba54 Added updating regions at plugin startup
Removed the '/as updaterents' and '/as updatebuys' commands, '/as
reload' also updates regions now.
2015-02-10 22:57:09 +01:00
Thijs Wiefferink b0f3bdc560 Fix the English language file
It got cleared by a faulty update script, I have some programs to get
the translated files from Transifix, and that also updates the header of
the English file but that went wrong and therefore it got cleared.
2015-02-10 12:31:21 +01:00
Thijs Wiefferink 5c9fdb6cc9 Added name change detection, updates regions when name is changed.
When a player logs in it will loop through regions owned by this players
and check if the saved playername is still the same as the current
playername and update the regionflags and -signs if necessary. Also
fixed some spelling mistakes in the English language file and updated to
the latest Transifex translations.
2015-02-09 23:46:32 +01:00
Thijs Wiefferink 23ea679cd9 Fixed a small bug with the permissions for the teleport command
The teleport command would refuse to teleport you if you only have
'areashop.teleportfriend' and/or 'areashop.teleportfriendsign'
permissions, while you should actually have access to those.
2015-02-03 22:55:31 +01:00
Thijs Wiefferink 58680c8cc4 Add a bulk sign linking mode for easier setup
When using '/as linksigns' you will get in sign linking mode. With
leftclick you can select a sign (max 100 blocks away) and with
rightclick you can select an AreaShop region (max 100 blocks away). If
you selected both then the sign will be linked to the region and then
you can select both again. This way you can easily link a lot of signs
to regions. Advice: Use WorldEdit or similar to get signs in front of
all regions (//stack), then use sign linking mode to link them all.
2015-01-30 12:12:00 +01:00
Thijs Wiefferink 75b752a235 Adds an option to '/as info' to list regions without group 2015-01-26 13:33:57 +01:00
Thijs Wiefferink fb51da84ae Fix a bug with teleporting to signs
If no signs are connected to the region it will now correctly teleport
to the location set by '/as settp' instead of always using the default
location.
2015-01-26 12:31:50 +01:00
Thijs Wiefferink 22d214e59d Add an option to set where '/as find' should teleport you to
Adds the 'findTeleportToSign' option in the general section of
default.yml, you can let it teleport to a sign or to the '/as settp'
location (if no location is set the default location is used)
2015-01-26 12:27:43 +01:00
Thijs Wiefferink 175b531eb5 Fix an unclear message when trying to create a sign for a region that is
already added to AreaShop.
2015-01-21 13:28:23 +01:00
Thijs Wiefferink 52591d3b6e Adds a blacklist of region that cannot be added
The blacklist consists of a list of regular expressions, by default the
'__global__' region is blocked because it is highly unlikely you want to
add that to AreaShop. The blacklist can for example be used to exclude
the spawn region while adding shops at spawn with the WorldEdit
selection of the '/as add' command.
2015-01-21 13:20:32 +01:00
Thijs Wiefferink 825074479c Cleanup 2015-01-18 16:58:33 +01:00
Thijs Wiefferink cc8cf1e560 Add proper punctuation to all languages (dots at the end) + more
Some preparations are made to later enable proper tab completion for
anyone instead of only OPs. Addfriend command only allows you to add
players that have played on the server before now.
2015-01-18 16:03:21 +01:00
Thijs Wiefferink a4169d127e Adds dots to all language strings and adds Chinese (Taiwan)
(All language files changed because I made a program to download them
all from Transifex and transform them to the format I want. Only
languages that are translated for 70% or more will be added to AreaShop)
2015-01-17 15:39:08 +01:00
Thijs Wiefferink 21340af89f Change the '/as find' command to randomly pick a region that suits
First searches all matching regions (rent/buy, maxprice and group), then
randomly picks one.
2015-01-12 21:55:01 +01:00
Thijs Wiefferink db06eae6c9 Add a message to show resell price when using '/as info region' 2015-01-12 21:42:54 +01:00
Thijs Wiefferink 5bae5ecf67 Fix a bug with buying a region while it is in resell mode 2015-01-12 17:11:08 +01:00
Thijs Wiefferink 679ffe2145 Releasing 1 version for WorldGuard 5.9 and one for 6.0+ now
The code represents the state of the WorldGuard 6.0+ version, the
uploaded version for 5.9 has some minor changes.
2015-01-07 12:01:04 +01:00
Thijs Wiefferink e6c5653073 Changes config version number, adds a file check for schematics 2015-01-06 22:35:08 +01:00
Thijs Wiefferink ea31dfdd65 Update languages (pulled from Transifex) and change version number 2015-01-06 22:03:23 +01:00
Thijs Wiefferink 9da31fed1f Restored compatibility with WorldGuard 5.9
AreaShop will detect if you use a 5.x version or something else, with
5.x it will add players to the regions by name, and otherwise by UUID.
AreaShop will always save UUID's itself, so future upgrading to higher
WorldGuard versions will be no problem.
2015-01-06 16:02:00 +01:00
Thijs Wiefferink 9baf0b7eec Adds an update checker and fixes some possible bugs
The update checker checks for updates at BukkitDev, if an update is
found it will print a message in the console and notifies OPs when
joining the server. It will never download files itself. The update
check can be switched off in the config. Also tried to fix a bug with
the /as me command, which could break when the friends lists is broken.
2015-01-06 11:46:02 +01:00
Thijs Wiefferink a14dc4e541 Fix a bug with the periodic updating of signs
If there is no sign connected to the region it would spam an error to
the console when the periodic update task runs.
2014-12-29 16:39:54 +01:00
Thijs Wiefferink 00d3256716 Fix a bug with inactive player unrent/sell settings
If the 'inactiveTimeUntilUnrent' or 'inactiveTimeUntilSell' settings
would be set to a value above 35000 it would cause an integer overflow,
resulting in a 50% chance that all regions will be unrentend/sold (and
if that does not happen it will still sell/unrent them too early). This
is caused by an integer overflow, switching to long fixed this problem.
2014-12-18 16:21:07 +01:00
Thijs Wiefferink 40338b66df Fix a bug with the '/as settp' command not accepting arguments
The command would always try to detect regions at the location you are
standing and would not consider the region argument.
2014-12-16 20:21:33 +01:00
Thijs Wiefferink 715bbfd9e3 Fix a bug where regions would not update after added to a group
Also applicable for removing regions from a group.
2014-12-10 16:08:52 +01:00
Thijs Wiefferink b679c49405 Update the French language file to the latest version
Adds a little more documentationto all language files, just a minor
note. Now '/as reload' will also load the a new language correctly if
you changed that in the config or language files.
2014-12-10 14:57:34 +01:00
Thijs Wiefferink dd0930bcea Removes excess debug statemements added in previous commit 2014-12-10 13:15:38 +01:00
Thijs Wiefferink 5b961564e1 Fix a bug with settings in groups.yml and region files
Now if a value has been set for a certain setting it will use it for
sure, now if you use getDoubleSetting() the following happends: 15.0 ->
15.0, 7 -> 7.0, '8.0' -> 8.0, 'bs' -> 0.0. While before only 15.0 would
see it as double, and for the others it would continue searching at the
next place (individual files > groups > default.yml).
2014-12-10 13:14:30 +01:00
Thijs Wiefferink c12314fa98 Fixes a bug with setting the owner flag
Now correctly splits the content of the owner flag at ', ' instead of
just a space (members flag already does this).
2014-12-08 18:07:04 +01:00
Thijs Wiefferink e23ad74744 Stops the unnecessary saving of the groups file.
It would mark the groups file as changed every time the groups get
loaded from the file. That would cause a unnecessary save after '/as
reload' and after restart/reload of the server.
2014-12-07 00:04:46 +01:00
Thijs Wiefferink 9957e02e65 Fix a bug with detection of files to convert
Previously it would keep sending 2 messages to console at startup saying
that is is converting files to a new format.
2014-12-06 21:43:07 +01:00
Thijs Wiefferink 07ea919aba Updates the language files to the latest version from Transifex 2014-12-05 16:20:00 +01:00
Thijs Wiefferink 2c1771cc52 Added 'friend regions' to the '/as me' command
And added teleporting to regions you are added as friend (permissions
areashop.teleportfriend and areashop.teleportfriendsign)
2014-12-05 13:48:41 +01:00
Thijs Wiefferink 83778ff803 Changes owners/members handling to WorldGuard to UUID's
Now adding uuid's to the owners/members flag in the flagProfiles section
is default, adding names is possible with 'n:<name>', groups is still
'g:<group>'. Now warnings will be displayed in the console if the size
of a schematic does not match the region size.
2014-12-04 22:56:18 +01:00
Thijs Wiefferink 0c79525144 Prevent actions on regions when it is already deleted from AreaShop
When a region is deleted with '/as del' it wil set a flag in
GeneralRegion to indicate it is deleted (isDeleted() can get it). If
this flag is set then no sign updates, saves to disk etc are being
processed by the tasks anymore. This prevents the following case: #1
task starts saving regions (makes copy of region list). #2 User 
executes '/as del' for a region, removes region file. #3 Task arrives at
the region the user just deleted and saves it to disk again #4 The
region will get loaded again next time the server starts.
2014-12-04 11:50:40 +01:00
Thijs Wiefferink e719930364 Reworks '/as info region' command for buy regions and fixes a bug
'/as info region' for buy regions now also supports more info, like the
same way as it does for rent regions. Fixed a bug with signs, now they
will correctly keep their orientation when placed again after removal
(by for example schematics).
2014-12-03 23:43:24 +01:00
Thijs Wiefferink 5568ee240b Changes the '/as info' command for rent regions to show more info
Some lines will not show up when based on config options (extending, in
advance renting, restoring), some don't show up if empty (friends,
signs) and some don't show up based on permissions (groups, teleport
location, restoring). Also adds a couple of tags to be used in language
files and the config.
2014-12-03 00:38:55 +01:00
Thijs Wiefferink 46abc8f83d Save WorldGuard regions periodically instead of directly
Now uses the saveChanges() method on RegionManager of WorldGuard, that
will only save regions that are actually changed.
2014-12-01 21:26:06 +01:00
Thijs Wiefferink cf3139f373 Changes handling WorldGuard flags, it now actually adds friends
Reworked applying flag settings configured in AreaShop to the WorldGuard
region. Now supports adding the friends to the regions, adding groups to
a region (g:groupname, would allow someone 'unlocking' functionality of
a region for a whole group of players) and adding group restrictions to
other flags (for example: 'entry: deny g:non_owners').
2014-12-01 21:00:27 +01:00
Thijs Wiefferink 59627e1b97 Add the '/as delfriend' command and minor changes the addfriend command 2014-11-29 17:08:54 +01:00
Thijs Wiefferink a25b5a5752 Fix the inactive players options, add the '/as addfriend' command
The unrent/selling of regions for inactive players now correctly checks
the option for rent regions when it is about a rent region, rent regions
also correctly check for OP now.
2014-11-29 16:37:24 +01:00
Thijs Wiefferink aceb6945fd Cleanup for code of commands, preparations for adding friends to regions
Code to dectect regions when a name of a region is not specified as
argument for commands has been cleaned and made the same for all
commands (language file cleanup is still necessary). Some functions to
manage friends for regions have been added to GeneralRegion (commands
and applying friends to regions still has to be done)
2014-11-27 23:59:44 +01:00
Thijs Wiefferink cbeffe9316 Add the stopresell command, fix a bug with reselling
If you put your region into resell mode and then sold it to the server
with /as sell, the next player buying the region would get an error or
his region would be in reselling mode directly. Now this is fixed
2014-11-27 20:38:48 +01:00
Thijs Wiefferink 9ea97fdb5d Cleans old code for replacing %clicker% tag 2014-11-25 16:48:11 +01:00
Thijs Wiefferink ed1f73fdd7 Fixes a problem with the %clicker% tag for use with sign commands
With the previous implementation it would only get replaced for commands
executed as the player, but executing as player is not wanted because
then the player should have permission for that (example: /tellraw). Now
it will properly get replaced for console and player commands attached
to a state of the sign.
2014-11-25 16:47:10 +01:00
Thijs Wiefferink 09af826f88 Add the '/as resell' command to let players sell their region to others
After executing the command the player is still owner and can do
everything like normal. The sign changes to the 'resell' section of the
chosen sign profile. The region flags change to the 'resale' section of
the flag profile (other greeting). When a player buys the region it
transfers the money to the previous owner. New schematic event and
commandevents are available for this action. Previous owner will get a
message if he is online.
A command to stop reselling your region is on the TODO list.
2014-11-24 19:16:55 +01:00
Thijs Wiefferink 1fd24d864d Adds a tag for the player name that clicks the sign
Can be used in the commands that get executed when someone clicks an
AreaShop sign. Tag is %clicker%
2014-11-24 12:58:31 +01:00
Thijs Wiefferink 4125364a96 Add highly configurable rent expire warnings for online players and some
minor changes

Rent expire warnings have profiles in config.yml, the profile can be set
in default.yml. Warning can contain a message to the player if he is
online and also have the possibility to execute certain commands.
Renamed the '/as rentduration' command to '/as setduration'.
2014-11-16 22:41:41 +01:00
Thijs Wiefferink a6f5a2eb5e Expire warning on login for players that rent regions + bugfixes
An option has been added to show a warning to players when their rent
almost runs out on login (so when they login they get a message for each
region that almost runs out, that means lower timeleft than the
'warningOnLoginTime' setting). Also a bug with schematic restoring has
been fixed and some other minor changes done.
2014-11-15 21:57:26 +01:00
Thijs Wiefferink 5eae75fef1 Add current language files again
(They got lost when changing the project setup)
2014-11-14 20:13:47 +01:00
Thijs Wiefferink 7982531e63 Merge branch 'master' of https://github.com/NLthijs48/AreaShop 2014-11-13 23:39:20 +01:00
Thijs Wiefferink 6ce15b27b7 Change the directory layout 2014-11-13 23:38:31 +01:00
Thijs Wiefferink b1809fb265 Update README.md 2014-11-13 23:17:45 +01:00
Thijs Wiefferink 0344391588 Add all changes from after the v2.0.2 release
Committing all changes made since the v2.0.2 release for now, starting
now committing will happen regularly instead of only when a version of
AreaShop is released to the public. This commit includes a large amount
of things that changed, the changelog for the upcoming version will list
them all.
2014-11-13 23:06:00 +01:00
164 changed files with 24359 additions and 9245 deletions

No files matched your search

+39
View File
@@ -0,0 +1,39 @@
---
name: Bug report
about: Report a problem in the plugin
title: ''
labels: 'NEW, Type: Bug'
assignees: ''
---
**Current behavior**
<!--- Tell what happens currently and/or show the stacktrace if an error occured -->
**Expected behavior**
<!--- Tell what you expected to happen instead -->
**Steps to reproduce**
<!--- Exactly show how this bug can be triggered -->
1.
2.
3.
4.
**Your environment**
<!--- Indicate which versions you use -->
<!--- Attention: "LATEST" or "NEWEST" are invalid answers! -->
<!--- Use '/version' for the Platform version and '/version <plugin>' for plugin versions -->
* Server platform (Bukkit, Spigot, etc.):
* Server version:
* AreaShop version:
* WorldEdit version:
* WorldGuard version:
* Vault version:
**Your config files**
<!--- Attach a '.zip' file of the '/plugins/AreaShop' and '/plugins/WorldGuard' directories to show your configuration setup -->
+15
View File
@@ -0,0 +1,15 @@
---
name: Feature request
about: Suggest an idea
title: ''
labels: 'NEW, Type: Feature'
assignees: ''
---
**Describe the problem you are trying to solve with this feature request**
<!-- When I know the problem you are trying to solve I can help you to think about the best solution -->
**Describe the solution you'd like**
<!-- Describe the config settings, commands and other features that should be added -->
@@ -0,0 +1,31 @@
---
name: Support question
about: Ask help with the setup or usage of the plugin
title: ''
labels: 'NEW, Type: Support'
assignees: ''
---
**Current behavior**
<!--- Tell what happens currently -->
**Desired behavior**
<!--- Tell what you want to happen instead -->
**Your environment**
<!--- Indicate which versions you use -->
<!--- Attention: "LATEST" or "NEWEST" are invalid answers! -->
<!--- Use '/version' for the Platform version and '/version <plugin>' for plugin versions -->
* Server platform (Bukkit, Spigot, etc.):
* Server version:
* AreaShop version:
* WorldEdit version:
* WorldGuard version:
* Vault version:
**Your config files**
<!--- Attach a '.zip' file of the '/plugins/AreaShop' and '/plugins/WorldGuard' directories to show your configuration setup -->
+32
View File
@@ -0,0 +1,32 @@
# This workflow will build a Java project with Maven
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
name: Java CI with Maven
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up JDK 1.8
uses: actions/setup-java@v1
with:
java-version: 1.8
- name: Cache local Maven repository
uses: actions/cache@v2
with:
path: ~/.m2/repository
key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }}
restore-keys: |
${{ runner.os }}-maven-
- name: Build with Maven
run: mvn -B package --file pom.xml
+25
View File
@@ -0,0 +1,25 @@
# Maven stuff
target
.project
.metadata
bin/
tmp/
*.tmp
*.bak
*.swp
*~.nib
local.properties
.classpath
.settings/
.loadpath
# Locally stored "Eclipse launch configurations"
*.launch
# IntelliJ IDEA
*.iml
.idea
dependency-reduced-pom.xml
desktop.ini
-194
View File
@@ -1,194 +0,0 @@
##############################################
# config.yml of the AreaShop plugin #
# This plugin has been created by NLThijs48 #
# Check the server minecraft.go-craft.com #
# and then the Survival server for a demo #
##############################################
########## GENERAL ##########
## Chatprefix used for all messages in the chat. Also check the 'greeting' lines in the 'flagProfiles' section,
## these also contain the prefix and you may want to change those to
chatPrefix: '&2[AreaShop]&r '
## The characters used for the prices of regions, will appear before the number, for the euro character use '%euro%'
moneyCharacter: '$'
## The characters used after a currency number, '%euro%' will become the euro character
moneyCharacterAfter: ''
## Enables / disables debug messages in the console, no need to change
debug: false
## The .yml language file that should be used, provided by this plugin: EN, NL
language: EN
## Enable Schematic saving and restoring in general
enableSchematics: true
## Maximum number of blocks to save to or restore from a .schemetic
maximumBlocks: 1000000
## Maximum number of locations the teleport function should check to find a safe spot
maximumTries: 50000
## Enable sending stats to http://mcstats.org/ (Metrics plugin)
sendStats: true
## Use colors when sending messages to console and log files
useColorsInConsole: false
## Post error messages in the console when a command run from the config fails (from the 'runCommands' section for example)
postCommandErrors: true
## Version of the config, do not change!
version: 2.0.0
## The different tags you can write on the sign to trigger the plugin
signTags:
## Tag for adding a rent region
rent: '[rent]'
## Tag for adding a buy region
buy: '[buy]'
## Tag for adding a sign to an existing region
add: '[as]'
## Configure the max total regions, max rent regions and max buy regions with different groups (-1 is unlimited)
## Assign a group to players by giving them the permission 'areashop.limits.<group>'
## Every player already has the group 'default' and ops have the unlimited group
## If a player has multiple groups the highest numbers are used
limitGroups:
default:
total: 1
rents: 1
buys: 1
unlimited:
total: -1
rents: -1
buys: -1
## Below are profiles for the signs, you can assign profiles to regions
## by setting 'general.signProfile' in default.yml, groups or individual regions
signProfiles:
default:
## Below is the format for each sign state, the following tags can be used for signs and commands:
## %region%, %player%, %uuid%, %price%, %duration%, %world%, %type%, %until%, %untilshort%
## The following sections can be added for performing certain commands when the sign is clicked:
## rightClickPlayer, rightClickConsole, shiftRightClickPlayer, shiftRightClickConsole,
## leftClickPlayer, leftClickConsole, shiftLeftClickPlayer, shiftLeftClickConsole
## Sections with 'Player' at the end will be run by the clicking player and 'Console' ones from the console
forrent:
line1: '&2&l[For Rent]'
line2: '%region%'
line3: '%duration%'
line4: '%price%'
rightClickPlayer:
- 'as rent %region%'
leftClickPlayer:
- 'as info region %region%'
rented:
line1: '&4&l[Rented]'
line2: '%region%'
line3: '%player%'
line4: '%untilshort%'
rightClickPlayer:
- 'as rent %region%'
leftClickPlayer:
- 'as info region %region%'
shiftRightClickPlayer:
- 'as unrent %region%'
forsale:
line1: '&2&l[For Sale]'
line2: '%region%'
line3: '%price%'
line4:
rightClickPlayer:
- 'as buy %region%'
leftClickPlayer:
- 'as info region %region%'
sold:
line1: '&4&l[Sold]'
line2: '%region%'
line3: '%player%'
line4:
rightClickPlayer:
- 'as buy %region%'
leftClickPlayer:
- 'as info region %region%'
shiftRightClickPlayer:
- 'as sell %region%'
## Option to run certain commands when one of these events happen
## Commands at a 'before' section will execute before the region details are changed in the AreaShop system
## and before any other actions occurred (changing signs, saving/loading schematics, etc.),
## the 'after' commands will be run when all changes are done.
## After 'before' or 'after' you can create a list of commands (see example at the created event)
eventCommandProfiles:
default:
created:
before:
after:
## - "say An AreaShop region has been created: %region%"
deleted:
before:
after:
rented:
before:
after:
extended:
before:
after:
unrented:
before:
after:
bought:
before:
after:
sold:
before:
after:
## For the following events you can specify if you want to restore or save the region to a schematic
## After 'save:' or 'restore:' you enter the name of the file, %region% will be replaced by the region name (.schematic will be added automatically)
## %type% represents the type of the region, could be 'rent' or 'buy'
## If your regions are all the same size you could use just 1 file as the restore file, just enter a name without %region%
## Be carefull with these options, it could crash your server or destroy (parts of) your world if used wrong!
schematicProfiles:
default:
created:
save: '%type%-%region%'
restore: ''
deleted:
save: ''
restore: '%type%-%region%'
rented:
save: ''
restore: ''
unrented:
save: ''
restore: '%type%-%region%'
bought:
save: ''
restore: ''
sold:
save: ''
restore: '%type%-%region%'
## Flag profiles to specify what flags should be set on the WorldGuard regions
## All region flags can be used + members, owners, priority and parent.
flagProfiles:
default:
forrent:
members: -%player%
greeting: '&2[AreaShop]&f %region% can be rented for %price% per %duration%'
rented:
members: +%player%
greeting: '&2[AreaShop]&f %region% is rented by %player% until %until%'
forsale:
members: -%player%
greeting: '&2[AreaShop]&f %region% can be bought for %price%'
sold:
members: +%player%
greeting: '&2[AreaShop]&f %region% is bought by %player%'
########## RENTING ##########
## How much seconds between checking if renting has expired (don't put this to low)
checkDelay: 60
## Timeformat to use on the signs, default is like '30-06 14:52', US format: 'MM-dd KK:mm a'
## Search for 'java SimpleDateFormat' for more options and documentation
timeFormatSign: 'dd-MM HH:mm'
## Timeformat used in the chat, default is like '30 june 2014 14:52', US format: 'MMMMMMMMMMMMMMMMM dd yyyy KK:mm a'
## Search for 'java SimpleDateFormat' for more options and documentation
timeFormatChat: 'dd MMMMMMMMMMMMMMMMM yyyy HH:mm'
## Time indicators, used for specifing rent duration on the signs
## Be careful with deleting words, will break signs using those, adding is no problem
minutes: [m, min, mins, minute, minutes, minuten, minuut]
hours: [h, hour, hours, uur, uren]
days: [d, day, days, dag, dagen]
months: [M, month, months, maanden, maand]
years: [y, year, years, jaar, jaren]
-40
View File
@@ -1,40 +0,0 @@
### All settings below are default settings and can be overridden
### by group settings or region settings (copy a section to a region or group and change them there)
########## GENERAL ##########
general:
## Set this to true to enable saving/restoring for regions as specified in the profile below, which is specified in the config
enableRestore: false
## The schematic profile as specified in the config
schematicProfile: 'default'
## The event commands profile as specified in the config
eventCommandProfile: 'default'
## The profile for the format of the sign as specified in the config
signProfile: 'default'
## The profile for the WorldGuard flags as specified in the config
flagProfile: 'default'
## The y location within the region to start searching for safe teleport spots (x and z will be in the middle of the region)
## Possible values: bottom, middle, top
teleportLocationY: bottom
## If true the teleportation algorithm only allows telportation to inside the region, otherwise it will expand algorithm
## a cube from the starting point to check for safe spots (then it could end outside the region)
## If you set a teleport location outside of the region with /as settp then setting this to true breaks that teleport (players cannot use it)
teleportIntoRegion: true
########## RENTING ##########
rent:
## The default price of a renting region
price: 1000
## The default duration of a renting region
duration: '1 day'
## The percentage of the renting price you get back if you unrent the region (price of time left will be multiplied by this/100)
moneyBack: 100
## Maximum number of extends a player can do (-1 for infinite, 0 for no extending)
maxExtends: -1
########## BUYING ##########
buy:
## The default price of a buying region
price: 1000
## The percentage of the buying price you get back if you sell the region
moneyBack: 100
-275
View File
@@ -1,275 +0,0 @@
###################################################
# English language file for the AreaShop plugin #
# Latest update: V2.0.2 #
###################################################
# Copy this file and change the strings to your #
# favor. Then change the 'language' setting in #
# the config to the filename (excluding .yml) #
###################################################
########## General strings
total-maximum: "You can't rent and buy more than %0% region(s) in total"
cmd-notValid: "That command is not valid, use '/as help' for info"
cmd-onlyByPlayer: "This command can only be run by a player"
cmd-weOnlyByPlayer: "Using a WorldEdit selection is only possible as a player, specify the region name as extra argument"
cmd-noSelection: "You don't have a WorldEdit selection"
cmd-noRegionsFound: "No regions registered in AreaShop are found in your selection"
cmd-noWERegionsFound: "No WorldEdit regions intersecting your selection are found"
########## Help command strings
help-header: "Help page, commands that you can execute"
help-alias: "Command aliases: /areashop, /as"
help-help: "&6/as help &7-&r Shows this help page"
help-info: "&6/as info &7-&r Get info about current regions"
help-rent: "&6/as rent &7-&r Rent a region or extend your current rent"
help-buy: "&6/as buy &7-&r Buy a region"
help-unrent: "&6/as unrent &7-&r Unrent a region"
help-unrentOwn: "&6/as unrent &7-&r Unrent your own region"
help-sell: "&6/as sell &7-&r Sell a region"
help-sellOwn: "&6/as sell &7-&r Sell your own region"
help-updaterents: "&6/as updaterents &7-&r Update all rent signs and regions"
help-updatebuys: "&6/as updatebuys &7-&r Update all buy signs and regions"
help-reload: "&6/as reload &7-&r Reload the config and languages"
help-setrestore: "&6/as setrestore &7-&r Set the profile for restoring and on/off "
help-setprice: "&6/as setprice &7-&r Change the price of a rent region"
help-rentduration: "&6/as rentduration &7-&r Change the duration of a rent region"
help-teleport: "&6/as tp &7-&r Teleport to your bought/rented regions"
help-teleportAll: "&6/as tp &7-&r Teleport to a rent/buy region"
help-setteleport: "&6/as settp &7-&r Set teleport position for bought/rented regions"
help-setteleportAll: "&6/as settp &7-&r Set teleport position for a region"
help-find: "&6/as find &7-&r Find an empty buy or rent"
help-groupadd: "&6/as groupadd &7-&r Add a region to a group"
help-groupdel: "&6/as groupdel &7-&r Delete a region from a group"
help-grouplist: "&6/as grouplist &7-&r Display all groups currently registered"
help-groupinfo: "&6/as groupinfo &7-&r Display information about a group"
help-schemevent: "&6/as schemevent &7-&r Trigger a schematic event for a region"
help-add: "&6/as add &7-&r Register a region as rent or buy"
help-del: "&6/as del &7-&r Delete a registered region from AreaShop"
help-addsign: "&6/as addsign &7-&r Add a sign to an existing region"
help-delsign: "&6/as delsign &7-&r Delete the sign you are looking at"
############ Other command strings
rent-help: "/as rent [regionname], the region you stand in will be used if not specified"
rent-noPermission: "You don't have permission to rent a region"
rent-maximum: "You can't rent more than %0% region(s)"
rent-payError: "Something went wrong with paying, try again later"
rent-rented: "You rented %0% until %1%"
rent-extended: "You extended your rent of %0% until %1%"
rent-extend: "You can extend your rent by rightclicking the sign again or using /as rent"
rent-lowMoneyExtend: "You don't have enough money to extend the rent (you have %0% and you need %1%)"
rent-lowMoneyRent: "You don't have enough money to rent this region (you have %0% and you need %1%)"
rent-someoneElse: "Someone else already rented this region"
rent-notRentable: "That region is not available for renting"
rent-maxExtends: "You cannot extend this rent anymore (the maximum is %0% times), however after the rent is over you can rent this region again"
buy-help: "/as buy [regionname], the region you stand in will be used if not specified"
buy-noPermission: "You don't have permission to buy a region"
buy-notBuyable: "That region is not available for buying"
buy-maximum: "You can't buy more than %0% region(s)"
buy-payError: "Something went wrong with paying, try again later"
buy-succes: "You succesfully bought %0%"
buy-lowMoney: "You don't have enough money to buy this region (you have %0% and you need %1%)"
buy-yours: "You already own this region"
buy-someoneElse: "Someone else already bought this region"
unrent-help: "/as unrent [regionname], the region you stand in will be used if not specified"
unrent-noPermission: "You don't have permission to unrent a region"
unrent-noPermissionOther: "You don't have permission to unrent another region"
unrent-notRegistered: "The region can't be unrent because it is not registered for renting"
unrent-notRented: "The region can't be unrent because it is not rented"
unrent-unrented: "Your region has been unrented"
unrent-other: "The region has been unrented for player %0%"
unrent-expired: "Your rent of %0% has expired"
sell-help: "/as sell [regionname], the region you stand in will be used if not specified"
sell-notRegistered: "The region can't be selled because it is not registered for buying"
sell-notBought: "The region can't be selled because it is not someone's property"
sell-sold: "The region has been sold for player %0%"
sell-soldYours: "Your region has been sold"
sell-noPermission: "You don't have permission to sell a region"
sell-noPermissionOther: "You don't have permission to sell another region"
rents-updated: "All signs and regions for renting have been updated"
rents-notUpdated: "Not all signs have been updated, maybe reload fixes it"
rents-noPermission: "You don't have permission to update all rent signs and regions"
buys-updated: "All signs and regions for selling have been updated"
buys-notUpdated: "Not all signs have been updated, maybe reload fixes it"
buys-noPermission: "You don't have permission to update all buy signs and regions"
reload-reloaded: "The config has been reloaded successfully"
reload-noPermission: "You don't have permission to reload the config"
info-help: "/as info <all|rented|forrent|sold|forsale|player|region>"
info-all-rents: "Regions registered for renting: &7%0%"
info-all-noRents: "There are no regions registered for renting"
info-all-buys: "Regions registered for buying: &7%0%"
info-all-noBuys: "There are no regions registered for buying"
info-rented: "Rented regions: &7%0%"
info-noRented: "No regions are rented"
info-unrented: "Unrented regions: &7%0%"
info-noUnrented: "All regions are rented"
info-sold: "Sold regions: &7%0%"
info-noSold: "No regions are sold"
info-forsale: "Regions for sale: &7%0%"
info-noForsale: "All regions are sold"
info-playerHelp: "/as info player <name>"
info-playerRents: "Regions rented by %0%: &7%1%"
info-playerNoRents: "%0% has not rented a region"
info-playerBuys: "Regions bought by %0%: &7%1%"
info-playerNoBuys: "%0% has not bought a region"
info-regionHelp: "/as info region [name], the region you stand in will be used if not specified"
info-regionNoRenting: "%0% is not registered for renting"
info-regionRenting: "&6Renting details for %0%:"
info-regionRentedBy: "Rented by: &7%0% until %1%"
info-regionNotRented: "Currently not rented"
info-regionBuying: "&6Buying details for %0%:"
info-regionNoBuying: "%0% is not registered for buying"
info-regionNotBought: "Currently not sold"
info-regionBoughtBy: "Bought by: &7%0%"
info-regionSign: "Sign location(s): %0%"
info-regionSignLocation: "&7(%0%, %1%, %2%, %3%)&r"
info-regionNoSign: "There is no sign registered for this region"
info-regionPriceDuration: "Price: &7%0% for each %1%"
info-regionPrice: "Price: &7%0%"
info-regionRestore: "Restoring enabled: &7%0%"
info-regionRestoreProfile: "Restoring profile: &7%0%"
info-regionTPLocation: "Teleport location: &7World=%0%, X=%1%, Y=%2%, Z=%3%, Pitch=%4%, Yaw=%5%"
info-regionNoTP: "No teleport location set"
info-regionNotExisting: "Region %0% is not registered"
setrestore-help: "/as setrestore <region> <true|false|general> [profile]"
setrestore-noPermission: "You don't have permission to change the restore settings"
setrestore-notRegistered: "%0% is not registered"
setrestore-invalidSetting: "'%0%' is not a valid state, should be true, false or general"
setrestore-success: "Succesfully set the restore setting of %0% to '%1%'"
setrestore-successProfile: "Succesfully set the restore setting of %0% to '%1%' and the profile to '%2%'"
setprice-noPermission: "You don't have permission to change the price of a region"
setprice-help: "/as setprice <price> [region], the region you stand in will be used if not specified"
setprice-notRegistered: "%0% is not registered in AreaShop"
setprice-wrongPrice: "'%0%' is not a valid price"
setprice-successRent: "Price of region %0% changed to %1% per %2%"
setprice-successBuy: "Price of region %0% changed to %1%"
rentduration-noPermission: "You don't have permission to change the duration of a rent"
rentduration-help: "/as rentduration <amount> <identifier> [region], the region you stand in will be used if not specified"
rentduration-notRegistered: "%0% is not registered as a rent"
rentduration-wrongAmount: "'%0%' is not a valid amount, use a whole number"
rentduration-wrongFormat: "'%0%' is not a proper timeformat, check the documentation on Bukkit"
rentduration-success: "Duration of region %0% changed to '%1%'"
setup-noRegion: "You did not specify a region on the second line"
setup-wrongRegion: "The region you specified does not exist"
setup-alreadyRentSign: "The region you specified already has a sign for renting"
setup-alreadyBuySign: "The region you specified already has a sign for buying"
setup-noDuration: "You did not specify how long the region can be rented, do this on the third line"
setup-wrongDuration: "The time specified is not in the correct format, example: 1 day"
setup-noPrice: "You did not specify the price on the fourth line"
setup-wrongPrice: "You did not specify the price correctly, use a number only"
setup-rentSuccess: "Renting of region %0% is setup correctly"
setup-buySuccess: "Buying of region %0% is setup correctly"
setup-noPermissionRent: "You don't have permission for setting up renting of regions"
setup-noPermissionBuy: "You don't have permission for setting up buying of regions"
setup-couldNotDetect: "Found multiple regions with the same priority and/or parent/child relation, specify one on the second line (2 of the regions that were found: %0% and %1%)"
destroy-noPermissionRent: "You don't have permission for destroying a sign for renting a region"
destroy-noPermissionBuy: "You don't have permission for destroying a sign for buying a region"
destroy-successRent: "Renting of %0% successfully removed"
destroy-successBuy: "Buying of %0% successfully removed"
teleport-help: "/as tp <region> [sign]"
teleport-noRentOrBuy: "Region '%0%' is not registered as rent or buy"
teleport-noPermission: "You don't have permission to teleport to a region"
teleport-noPermissionOther: "You don't have permission to teleport to region you do not own"
teleport-success: "You teleported to %0%"
teleport-noSafe: "No safe position found in region %0%, no spots in region left or maximum tries exceeded (%1%/%2%)"
setteleport-help: "/as settp [region] [reset], the region you stand in will be used if not specified"
setteleport-noPermission: "You don't have permission to set the teleport location"
setteleport-noPermissionAll: "You don't have permission to set the teleport location for a region you do not own"
setteleport-noRentOrBuy: "Region '%0%' is not registered as rent or buy"
setteleport-success: "Teleport location of %0% set"
setteleport-notInside: "The location has to be inside the region"
setteleport-reset: "Teleport location of %0% has been reset"
find-help: "/as find <buy|rent> [maxprice]"
find-noPermission: "You don't have permission to teleport to signs, so you can't use find"
find-success: "Found a %0% region: %1%, while searching with a max price of your balance: %2%"
find-successMax: "Found a %0% region: %1%, while searching with a max price of %2%"
find-wrongMaxPrice: "The specified maximum price is not a correct number: %0%"
find-noneFound: "No %0% region found while searching with a max price of your balance: %1%"
find-noneFoundMax: "No %0% region found while searching with a max price of %1%"
groupadd-help: "/as groupadd <group> [region], if no region specified all regions from your WorldEdit selection are used"
groupadd-noPermission: "You don't have permission to add regions to groups"
groupadd-noRegion: "The specified region is not registered: %0%"
groupadd-success: "Region %0% has been added to group '%1%', this group now has %2% member(s)"
groupadd-failed: "Region %0% is already a member of group '%1%'"
groupadd-weSuccess: "Added to group %0%: &7%1%"
groupadd-weFailed: "Were already in group %0%: &7%1%"
groupdel-help: "/as groupdel <group> [region], if no region specified all regions from your WorldEdit selection are used"
groupdel-noPermission: "You don't have permission to remove regions from groups"
groupdel-noRegion: "The specified region is not registered: %0%"
groupdel-success: "Region %0% has been removed from group '%1%', this group now has %2% member(s)"
groupdel-failed: "Region %0% is not a member of group '%1%'"
groupdel-weSuccess: "Removed from group %0%: &7%1%"
groupdel-weFailed: "Were not in group %0% anyway: &7%1%"
grouplist-noPermission: "You don't have permission to display the registered groups"
grouplist-noGroups: "There are currently no groups registered"
grouplist-success: "The following groups are registered: &7%0%"
groupinfo-help: "/as groupinfo <group>"
groupinfo-noPermission: "You don't have permission to display information about a group"
groupinfo-noGroup: "There is no group registered with the name '%0%', use /as grouplist to check groups"
groupinfo-members: "The following regions are member of group %0%: &7%1%"
groupinfo-noMembers: "Group %0% does not have any members"
schemevent-help: "/as schemevent <region> <created|deleted|rented|unrented|bought|sold>"
schemevent-noRegion: "The specified region is not registered: %0%"
schemevent-wrongEvent: "The specified event '%0%' does not exist, use one of the following: &7%1%"
schemevent-success: "Event '%0%' has succesfully been triggered for region %1%"
schemevent-noPermission: "You don't have permission to trigger schematic events"
add-help: "/as add <rent|buy> [region] [world]"
add-noPermission: "You don't have permission to add a region to AreaShop"
add-success: "Added as %0%: &7%1%"
add-failed: "Already registered: &7%0%"
add-specifyWorld: "Specify the world of the region when using from console"
add-incorrectWorld: "World '%0%' not found, try again (case-sensitive)"
add-noRegion: "Region '%0%' does not exist in this world"
del-noRegion: "Region '%0%' is not registered in AreaShop"
del-noPermission: "You don't have permission to remove regions"
del-success: "Removed regions: &7%0%"
del-failed: "No permission to remove or not registered: &7%0%"
addsign-help: "/as addsign [region] [profile]"
addsign-noSign: "You are not looking at a sign"
addsign-noRegion: "Region '%0%' cannot be found"
addsign-noRegions: "No region found around the sign position"
addsign-couldNotDetect: "Found multiple regions around the sign, specify region as extra argument (2 of the regions that were found: %0% and %1%)"
addsign-couldNotDetectSign: "Found multiple regions around the sign, specify region on the second line (2 of the regions that were found: %0% and %1%)"
addsign-wrongProfile: "The specified profile does not exist, use one of the following (check config): &7%0%"
addsign-success: "The sign has been added to %0%"
addsign-successProfile: "The sign has been added to %0% with profile %1%"
addsign-alreadyRegistered: "That sign is already registered for region %0%"
addsign-noPermission: "You don't have permission to add a sign"
delsign-noSign: "You are not looking at a sign"
delsign-noPermission: "You don't have permission to delete a sign"
delsign-noRegion: "That sign does not belong to an AreaShop region"
delsign-success: "The sign has been removed from region %0%"
-265
View File
@@ -1,265 +0,0 @@
###################################################
# French language file for the AreaShop plugin #
# Latest update: V2.0.2 #
###################################################
# Copy this file and change the strings to your #
# favor. Then change the 'language' setting in #
# the config to the filename (excluding .yml) #
###################################################
########## General strings
total-maximum: "Vous ne pouvez pas acheter ou louer plus de %0% region(s) au total"
cmd-notValid: "Cette commande est incorrecte, utilisez '/as help' pour plus de détails"
cmd-onlyByPlayer: "Cette commande ne peut être utilisé que par un joueur"
cmd-weOnlyByPlayer: "Utiliser une séléction WorldEdit n'est possible qu'en tant que joueur. Spécifiez le nom de la région en argument supplémentaire."
cmd-noSelection: "Vous n'avez pas de séléction WorldEdit"
cmd-noRegionsFound: "Aucune région enregistré dans AreaShop n'a été trouvé dans votre séléction"
cmd-noWERegionsFound: "Aucun région WorldEdit croisant votre séléction n'a été trouvé"
########## Help command strings
help-header: "Pade d'aide, Commande que vous pouvez éxécuter"
help-alias: "Alias des commandes: /areashop, /as"
help-help: "&6/as help &7-&r Affiche la page d'aide"
help-info: "&6/as info &7-&r Obtenir les infos sur les régions actuelles"
help-rent: "&6/as rent &7-&r Louer une région, ou prolonger la location actuelle"
help-buy: "&6/as buy &7-&r Acheter une région"
help-unrent: "&6/as unrent &7-&r Dé-louer une région"
help-unrentOwn: "&6/as unrent &7-&r Dé-louer votre propre région"
help-sell: "&6/as sell &7-&r Vendre une région"
help-sellOwn: "&6/as sell &7-&r Vendre votree propre région"
help-updaterents: "&6/as updaterents &7-&r Mettre à jours toutes les pancartes et les régions louées."
help-updatebuys: "&6/as updatebuys &7-&r Mettre à jours toutes les pancartes et les régions achetées"
help-reload: "&6/as reload &7-&r Recharge les configs et langages"
help-setrestore: "&6/as setrestore &7-&r Mettre le profil pour réstaurer à on/off"
help-setprice: "&6/as setprice &7-&r Fixerle prix d'une région louée."
help-rentduration: "&6/as rentduration &7-&r Changer la durée d'une région louée"
help-teleport: "&6/as tp &7-&r Téléportation vers votre région acheté / louée"
help-teleportAll: "&6/as tp &7-&r Téléportation vers une région louée / acheté"
help-setteleport: "&6/as settp &7-&r Définie la position de téléportation pour la région louée / acheté"
help-setteleportAll: "&6/as settp &7-&r Défini la position de téléportation pour une région"
help-find: "&6/as find &7-&r trouve un achat ou une location vide"
help-groupadd: "&6/as groupadd &7-&r Ajoute une région à un groupe"
help-groupdel: "&6/as groupdel &7-&r Supprime une région d'un groupe"
help-grouplist: "&6/as grouplist &7-&r Affiche tout les groupes enregistrés"
help-groupinfo: "&6/as groupinfo &7-&r Affiche les informations d'un groupe"
help-schemevent: "&6/as schemevent &7-&r Déclanche un évenement schématique d'une région"
help-add: "&6/as add &7-&r Enregistre une région comme louée ou acheté"
help-del: "&6/as del &7-&r Supprime une région enregistré dans AreaShop"
help-addsign: "&6/as addsign &7-&r Ajoute une pancarte à une région existante"
help-delsign: "&6/as delsign &7-&r Supprime la pancarte que vous regardez"
############ Other command strings
rent-help: "/as rent [regionname], Si non spécifié, cible la région dans laquelle vous vous trouvez"
rent-noPermission: "Vous n'avez pas la permission de louer une région"
rent-maximum: "Vous ne pouvez pas louer plus de %0% région(s)"
rent-payError: "Une erreur durant le paiement s'est produite. Essayez de nouveau plus tard"
rent-rented: "Vous avez loué de %0% jusqu'à %1%"
rent-extended: "Vous avez prolongé la location de %0% jusqu'à %1%"
rent-extend: "Vous pouvez prolonger votre location avec un clic droit sur la pancarte, ou en utilisant /as rent"
rent-lowMoneyExtend: "Vous n'avez pas assez d'argent pour prolonger la location. (Vous possédez %0% et devez payer %1%)"
rent-lowMoneyRent: "Vous n'avez pas assez d'argent pour louer cette région. (Vous possédez %0% et devez payer %1%)"
rent-someoneElse: "Quelqu'un d'autre a déjà louer cette région"
rent-notRentable: "cette région n'est pas disponible à la location"
rent-maxExtends: "Vous ne pouvez plus prolonger cette location. (Le maximum est de %0% fois). Mais lorsque la location sera terminé, vous pourrez louer de nouveau cette région"
buy-help: "/as buy [regionname], Si non spécifié, cible la région dans laquelle vous vous trouvez"
buy-noPermission: "Vous n'avez pas la permission d'acheter une région"
buy-notBuyable: "cette région n'est pas disponible à l'achat"
buy-maximum: "Vous ne pouvez pas acheter plus de %0% région(s)"
buy-payError: "Une erreur durant le paiement s'est produite. Essayez de nouveau plus tard"
buy-succes: "Vous avez bien acheté %0%"
buy-lowMoney: "Vous n'avez pas assez d'argent pour acheter cette région. (Vous possédez %0% et devez payer %1%)"
buy-yours: "Vous avez déjà acheter cette région"
buy-someoneElse: "Quelqu'un a déjà acheté cette région"
unrent-help: "/as unrent [regionname], Si non spécifié, cible la région dans laquelle vous vous trouvez"
unrent-noPermission: "Vous n'avez pas la permission de dé-louer une région"
unrent-noPermissionOther: "Vous n'avez pas la permission de délouer une autre région"
unrent-notRegistered: "La région ne peut pas être dé-louée car elle n'est pas enregistré à la location"
unrent-notRented: "La région ne peut pas être dé-louée car elle n'est pas loué"
unrent-unrented: "Votre région a été dé-louée."
unrent-other: "La région du joueur %0% a été dé-louée"
unrent-expired: "Votre location de %0% a expiré"
sell-help: "/as sell [regionname], Si non spécifié, cible la région dans laquelle vous vous trouvez"
sell-notRegistered: "la région ne peut pas être vendue car elle n'est pas enregistré comme acheté"
sell-notBought: "La région ne peut pas être vendue car elle n'est pas la propriété de quelqu'un"
sell-sold: "Cette région a été vendu au joueur %0%"
sell-soldYours: "Votre région a été vendue"
sell-noPermission: "Vous n'avez pas la permission de vendre une région"
sell-noPermissionOther: "Vous n'avez pas la permission de vendre une autre région"
rents-updated: "Tout les panneaux et régions en location ont été mis à jour"
rents-notUpdated: "Tout les panneaux n'ont pas été mis à jour. Recharger peut corriger le problème"
rents-noPermission: "Vous n'avez pas la permission de mettre à jour les panneaux et régions en location"
buys-updated: "Tout les panneaux et régions en vente ont été mis à jour"
buys-notUpdated: "Tout les panneaux n'ont pas été mis à jour. Recharger peut corriger le problème"
buys-noPermission: "Vous n'avez pas la permission de mettre à jour les panneaux et régions en vente"
reload-reloaded: "La configuration a bien été rechargée"
reload-noPermission: "Vous n'avez pas la permission de recharger la configuration"
info-help: "/as info <all|rented|forrent|sold|forsale|player|region>"
info-all-rents: "Régions enregistrées en location: &7%0%"
info-all-noRents: "Il n'y a pas de régions enregistrées en location"
info-all-buys: "Régions enregistrées en vente: &7%0%"
info-all-noBuys: "Il n'y a pas de régions enregistrées en achat"
info-rented: "Régions louées: &7%0%"
info-noRented: "Aucune régions louée"
info-unrented: "régions non louées: &7%0%"
info-noUnrented: "Toutes les régions sont louées"
info-sold: "Régions vendues: &7%0%"
info-noSold: "Aucune région n'est vendue"
info-forsale: "Région en vente: &7%0%"
info-noForsale: "Toutes les régions sont vendues"
info-playerHelp: "/as info player <name>"
info-playerRents: "Regions louées par %0%: &7%1%"
info-playerNoRents: "%0% n'a de région louée"
info-playerBuys: "Régions achetés par %0%: &7%1%"
info-playerNoBuys: "%0% n'a pas acheté de région"
info-regionHelp: "/as info region [name], Si non spécifié, cible la région dans laquelle vous vous trouvez"
info-regionNoRenting: "%0% n'est pas enregistré pour la location"
info-regionRenting: "&6Détails de location pour %0%:"
info-regionRentedBy: "Louée par: &7%0% jusqu'au %1%"
info-regionNotRented: "Actuellement non louée"
info-regionBuying: "&6Détails d'achat pour %0%:"
info-regionNoBuying: "%0% n'est pas enregistré à la vente"
info-regionNotBought: "Actuellement non vendue"
info-regionBoughtBy: "Acheté par: &7%0%"
info-regionSign: "Panneau(x) de location(s): %0%"
info-regionSignLocation: "&7(%0%, %1%, %2%, %3%)&r"
info-regionNoSign: "Il n'y a pas de panneaux enregistré pour cette région"
info-regionPriceDuration: "Prix: &7%0% pour chaque %1%"
info-regionPrice: "Prix: &7%0%"
info-regionRestore: "Réstauration activé: &7%0%"
info-regionRestoreProfile: "profil de restauration: &7%0%"
info-regionTPLocation: "lieu de téléportation: &7World=%0%, X=%1%, Y=%2%, Z=%3%, Pitch=%4%, Yaw=%5%"
info-regionNoTP: "Aucun lieu de téléportation défini"
info-regionNotExisting: "La région %0% n'est pas enregistrée"
setrestore-help: "/as setrestore <region> <true|false|general> [profile]"
setrestore-noPermission: "Vous n'avez pas la permission de restaurer les paramètres"
setrestore-notRegistered: "%0% n'est pas enregistré"
setrestore-invalidSetting: "'%0%' est invalide. Doit être true, false ou general"
setrestore-success: "Les paramètres ont bien été restauré de %0% à '%1%'"
setrestore-successProfile: "Les paramètres ont bien été restauré de %0% à '%1%' et la profil à '%2%'"
setprice-noPermission: "Vous n'avez pas la permission de changer le prix d'une région"
setprice-help: "/as setprice <price> [region], Si non spécifié, cible la région dans laquelle vous vous trouvez"
setprice-notRegistered: "%0% n'est pas enregistré dans AreaShop"
setprice-wrongPrice: "'%0%' n'est pas un rpix valide"
setprice-successRent: "Prix de la région %0% changé de %1% à %2%"
setprice-successBuy: "Pprix de la région %0% changé à %1%"
rentduration-noPermission: "Vous n'avez pas la permission de changer la durée d'une location"
rentduration-help: "/as rentduration <amount> <identifier> [region], Si non spécifié, cible la région dans laquelle vous vous trouvez"
rentduration-notRegistered: "%0% n'est pas enregistré comme location"
rentduration-wrongAmount: "'%0%' n'est pas un montant valide, utilisez un nombre entier"
rentduration-wrongFormat: "'%0%' n'est pas un format date correcte, regardez la documentation bukkit"
rentduration-success: "Durée de la région %0% changé à '%1%'"
setup-noRegion: "Vous n'avez pas spécifié une région à la seconde ligne"
setup-wrongRegion: "la région que vous avez spécifié n'existe pas"
setup-alreadyRentSign: "La région que vous avez spécifiée possède déjà un panneau de location"
setup-alreadyBuySign: "La région que vous avez spécifiée possède déjà un panneau de vente"
setup-noDuration: "A la troisième ligne, vous n'avez pas spécifié la durée de location de la région"
setup-wrongDuration: "Le temps spécifié n'est pas au bon format. Exemple: 1 day"
setup-noPrice: "A la quatrième ligne, vous n'avez pas spécifié le prix"
setup-wrongPrice: "Vous n'avez pas indiqué un prix correcte, utilisez un nombre entier"
setup-rentSuccess: "La location de la région %0% est correctement configurée"
setup-buySuccess: "L'achat de la région %0% est correctement configuré"
setup-noPermissionRent: "Vous n'avez pas la permission de mettre en place la location de régions"
setup-noPermissionBuy: "Vous n'avez pas la permission de mettre en place l'achat de régions"
setup-couldNotDetect: "Multiples régions trouvées avec la même priorité et/ou parent/enfant relation. Spécifiez en un sur la deuxième ligne. (2 des régions trouvées: %0% et %1%)"
destroy-noPermissionRent: "Vous n'avez pas la permission de détruire le panneau de location d'une région"
destroy-noPermissionBuy: "Vous n'avez pas la permission de détruire le panneau de vente d'une région"
destroy-successRent: "Location de %0% supprimé"
destroy-successBuy: "Achat de %0% supprimé"
teleport-help: "/as tp <region> [sign]"
teleport-noRentOrBuy: "La région '%0%' n'est pas enregistré comme location ou achat"
teleport-noPermission: "Vous n'avez pas la permission de vous téléporter dans une région"
teleport-noPermissionOther: "Vous n'avez pas la permission de vous téléporter à une région qui ne vous appartient pas"
teleport-success: "Vous avez été téléporté à %0%"
teleport-noSafe: "Aucune position sécurisé trouvé dans la région %0%. Pas de point restant, ou tentatives maximales dépassées. (%1%/%2%)"
setteleport-help: "/as settp [region] [reset], Si non spécifié, cible la région dans laquelle vous vous trouvez"
setteleport-noPermission: "Vous n'avez pas la permission de définir un point de téléportation"
setteleport-noPermissionAll: "Vous n'avez pas la permission de définir un point de téléportation sur une région qui ne vous appartient pas"
setteleport-noRentOrBuy: "La région '%0%' n'est pas enregistré comme location ou achat"
setteleport-success: "Lieu de téléportation de %0% défini"
setteleport-notInside: "Le lieu doit se trouver dans votre région"
setteleport-reset: "le lieu de téléportation de %0% a été reset"
find-help: "/as find <buy|rent> [maxprice]"
find-noPermission: "Vous n'avez pas la permission de vous téléporter à des panneaux. Vous ne pouvez donc pas utiliser find"
find-success: "Trouvé %0% région: %1%, en recherchant avec le prix maximum de votre solde: %2%"
find-successMax: "trouvé %0% région: %1%, en cherchant un prix maximum de %2%"
find-wrongMaxPrice: "le prix maximum n'est pas un nombre valide: %0%"
find-noneFound: "Aucune %0% région trouvée, en cherchant le prix maximum de votre solde: %1%"
find-noneFoundMax: "Aucune %0% région trouvée en cherchant un prix maximum de %1%"
groupadd-help: "/as groupadd <group> [region], Si non spécifié, cible la région dans laquelle vous vous trouvez"
groupadd-noPermission: "Vous n'avez pas la permission d'ajouter des régions aux groupes"
groupadd-noRegion: "la région spécifiée n'est pas enregistré: %0%"
groupadd-success: "La région %0% a été ajouté au groupe '%1%'. ce groupe a maintenant %2% membre(s)"
groupadd-failed: "La région %0% est déjà membre du groupe '%1%'"
groupadd-weSuccess: "Ajouté au groupe %0%: &7%1%"
groupadd-weFailed: "Nous étions déjà dans le groupe %0%: &7%1%"
groupdel-help: "/as groupdel <group> [region], Si non spécifié, cible la région dans laquelle vous vous trouvez"
groupdel-noPermission: "Vous n'avez pas la permission de supprimer des régions depuis les groupes"
groupdel-noRegion: "La région spécifiée n'est pas enregistré: %0%"
groupdel-success: "La région %0% a été supprimé du groupe '%1%', ce groupe a maintenant %2% membre(s)"
groupdel-failed: "La région %0% n'est pas membre du groupe '%1%'"
groupdel-weSuccess: "Supprimé du groupe %0%: &7%1%"
groupdel-weFailed: "Nous ne sommes pas dans le groupe %0% de toute façon: &7%1%"
grouplist-noPermission: "Vous n'avez pas l'autorisation d'afficher les groupes enregistrés"
grouplist-noGroups: "Il n'y a actuellement aucun groupe enregistré"
grouplist-success: "les groupes suivants sont enregistrés: &7%0%"
groupinfo-help: "/as groupinfo <group>"
groupinfo-noPermission: "Vous n'avez pas la permission d'afficher des informations sur un groupe"
groupinfo-noGroup: "Il n'y a pas de groupe enregistré sous le nom '%0%', utilisez /as grouplist pour vérifier les groupes"
groupinfo-members: "Les régions suivantes sont membres du groupe %0%: &7%1%"
groupinfo-noMembers: "Le groupe %0% ne possède aucun membre"
schemevent-help: "/as schemevent <region> <created|deleted|rented|unrented|bought|sold>"
schemevent-noRegion: "La région spécifiée n'est pas enregistré: %0%"
schemevent-wrongEvent: "L'évent spécifié '%0%' n'existe pas, utilisez un des suivants: &7%1%"
schemevent-success: "L'évent '%0%' a été déclenché pour la région %1%"
schemevent-noPermission: "Vous n'avez pas la permission de déclencher des événements schématiques"
add-help: "/as add <rent|buy> [region] [world]"
add-noPermission: "Vous n'avez pas la permission d'ajouter une région à AreaShop"
add-success: "Ajouté comme %0%: &7%1%"
add-failed: "Déjà enregistré: &7%0%"
add-specifyWorld: "Spécifiez le monde de la région lors de l'utilisation de la console"
add-incorrectWorld: "Le monde '%0%' est introuvable, essayez de nouveau (Attention à la casse)"
add-noRegion: "La région '%0%' n'existe pas dans ce monde"
del-noRegion: "Le région '%0%' n'est pas enregistré à AreaShop"
del-noPermission: "Vous n'avez pas la permission de supprimer des régions"
del-success: "Régions supprimées: &7%0%"
del-failed: "Pas de permission pour supprimer, ou pas enregistré: &7%0%"
addsign-help: "/as addsign [region] [profile]"
addsign-noSign: "Vous ne regardez pas de panneau"
addsign-noRegion: "La région '%0%' n'a pas été trouvé"
addsign-noRegions: "Aucune région trouvé autour du panneau"
addsign-couldNotDetect: "Plusieurs régions ont été trouvées à promixité du panneau. Spécifiez la région en argument supplémentaire. (2 des régions trouvées: %0% et %1%)"
addsign-couldNotDetectSign: "Plusieurs régions ont été trouvées à proximité du panneau. Spécifiez la région à la deuxième ligne. (2 des régions trouvées: %0% et %1%)"
addsign-wrongProfile: "le profil spécifié n'existe pas. utilisez un des suivants (vérifier la configuration): &7%0%"
addsign-success: "Le panneau a été ajouté à %0%"
addsign-successProfile: "Le panneau a été ajouté à %0% avec le profil %1%"
addsign-alreadyRegistered: "Ce panneau a déjà été enregistré pour la région %0%"
addsign-noPermission: "Vous n'avez pas la permission d'ajouter un panneau"
delsign-noSign: "Vous ne regardez pas un panneau"
delsign-noPermission: "Vous n'avez pas la permission de supprimer un panneau"
delsign-noRegion: "Ce signe n'appartient pas à une région AreaShop"
delsign-success: "Ce panneau a été supprimé de la région %0%"
-173
View File
@@ -1,173 +0,0 @@
###################################################
# Dutch language file for the AreaShop plugin #
# Latest update: V1.2.1 #
###################################################
# Copy this file and change the strings to your #
# favor. Then change the 'language' setting in #
# the config to the filename (excluding .yml) #
###################################################
########## Command strings
total-maximum: "Je kunt niet meer dan %0% gebied(en) in totaal huren en kopen"
cmd-onlyByPlayer: "Dit commando kan alleen door een speler uitgevoert worden"
cmd-notValid: "Dat commando is niet geldig , gebruik '/as help' voor informatie"
rent-regionNotRentable: "Dat gebied is niet beschikbaar om te huren"
rent-help: "/as rent <gebiednaam>"
rent-noPermission: "Je hebt geen toestemming om een gebied te huren"
rent-maximum: "Je kunt niet meer dan %0% gebied(en) huren"
rent-payError: "Er is iets mis gegaan met betalen, probeer het later opnieuw"
rent-rented: "Je hebt %0% tot %1% gehuurd"
rent-extended: "Je hebt je huur van %0% verlengt tot %1%"
rent-extend: "Je kunt je huur verlengen door opnieuw op het bordje te klikken of gebruik te maken van /as rent"
rent-lowMoneyExtend: "Je hebt niet genoeg geld om de huur te verlengen (je hebt %0% van de %1%)"
rent-lowMoneyRent: "Je hebt niet genoeg geld om het gebied te huren (je hebt %0% van de %1%)"
rent-someoneElse: "Iemand anders heeft dit gebied al gehuurd"
rent-notRentable: "Dat gebied is niet beschikbaar om te huren"
buy-help: "/as buy <gebiednaam>"
buy-noPermission: "Je hebt geen toestemming om een gebied te kopen"
buy-notBuyable: "Dat gebied is niet beschikbaar om te kopen"
buy-maximum: "Je kunt niet meer dan %0% gebied(en) kopen"
buy-payError: "Er is iets mis gegaan met betalen, probeer het later opnieuw"
buy-succes: "Je hebt %0% succesvol gekocht"
buy-lowMoney: "Je hebt niet genoeg geld om het gebied te kopen (je hebt %0% van de %1%)"
buy-yours: "Je hebt dit gebied al gekocht"
buy-someoneElse: "Iemand anders heeft dit gebied al gekocht"
unrent-help: "/as unrent <gebiednaam>"
unrent-noPermission: "Je hebt geen toestemming om te stoppen met huren"
unrent-noPermissionOther: "Je hebt geen toestemming om iemand anders huur te stoppen"
unrent-notRegistered: "De huur kan niet gestopt worden want het gebied is niet geregistreerd om te huren"
unrent-notRented: "De huur kan niet gestopt worden want het gebied is niet gehuurd"
unrent-unrented: "De huur van je gebied is gestopt"
unrent-other: "De huur voor het gebied is gestopt voor speler %0%"
unrent-expired: "De huur van je gebied %0% is gestopt"
sell-help: "/as sell <gebiednaam>"
sell-notRegistered: "Het gebied kan niet verkocht worden want het staat niet geregistreerd om te kopen"
sell-notBought: "Het gebied kan niet verkocht worden want het is niet gekocht"
sell-sold: "Het gebied is verkocht voor speler %0%"
sell-soldYours: "Je gebied is verkocht"
sell-noPermission: "Je hebt geen toestemming om een gebied te verkopen"
sell-noPermissionOther: "Je hebt geen toestemming om een gebied van iemand anders te verkopen"
rents-updated: "Alle borden en gebieden voor de verhuur zijn geupdate"
rents-notUpdated: "Niet alle borden zijn geupdate, een reload zou het op kunnen lossen"
rents-noPermission: "Je hebt geen toestemming om alle verhuur borden en gebieden te updaten"
buys-updated: "Alle borden en gebieden voor de verkoop zijn geupdate"
buys-notUpdated: "Niet alle borden zijn geupdate, een reload zou het op kunnen lossen"
buys-noPermission: "Je hebt geen toestemming om alle verkoop borden en gebieden te updaten"
reload-reloaded: "De config is succesvol opnieuw ingeladen"
reload-noPermission: "Je hebt geen toestemming om de config opnieuw in te laden"
info-help: "/as info <all|rented|forrent|sold|forsale|player|region>"
info-all-rents: "Gebieden geregistreerd voor de verhuur: %0%"
info-all-noRents: "Er zijn geen gebieden geregistreerd voor de verhuur"
info-all-buys: "Gebieden geregistreerd voor de verkoop: %0%"
info-all-noBuys: "Er zijn geen gebieden geregistreerd voor de verkoop"
info-rented: "Verhuurde gebieden: %0%"
info-noRented: "Er zijn geen verhuurde gebieden"
info-unrented: "Gebieden te huur: %0%"
info-noUnrented: "Alle gebieden zijn verhuurd"
info-sold: "Verkochte gebieden: %0%"
info-noSold: "Alle gebieden zijn verkocht"
info-forsale: "Gebieden te koop: %0%"
info-noForsale: "Alle gebieden zijn verkocht"
info-playerHelp: "/as info player <naam>"
info-playerRents: "Gebieden gehuurd door %0%: %1%"
info-playerNoRents: "%0% heeft geen gebied gehuurd"
info-playerBuys: "Gebieden gekocht door %0%: %1%"
info-playerNoBuys: "%0% heeft geen gebieden gekocht"
info-regionHelp: "/as info region <naam>"
info-regionNoRenting: "%0% is niet geregistreerd voor verhuur"
info-regionRenting: "&6Huur informatie voor %0%"
info-regionRentedBy: "Gehuurd door: %0% tot %1%"
info-regionNotRented: "Nu niet verhuurd"
info-regionBuying: "&6Verkoop informatie voor %0%"
info-regionNoBuying: "%0% is niet geregistreerd voor verkoop"
info-regionNotBought: "Nu niet verkocht"
info-regionBoughtBy: "Gekocht door: %0%"
info-regionSign: "Plek van het bordje: wereld=%0%, X=%1%, Y=%2%, Z=%3%"
info-regionPriceDuration: "Prijs: %0% voor elke %1%"
info-regionPrice: "Prijs: %0%"
info-regionRestore: "Herstellen ingeschakeld: %0%"
info-regionRestoreProfile: "Herstel profiel: %0%"
help-header: "Help pagina, commando's die jij kunt uitvoeren"
help-alias: "Commando aliassen: /areashop, /as"
help-help: "&6/as help &7-&r Laat deze help pagina zien"
help-info: "&6/as info &7-&r Vraag informatie over gebieden op"
help-rent: "&6/as rent &7-&r Huur een gebied of verleng de huur"
help-buy: "&6/as buy &7-&r Koop een gebied"
help-unrent: "&6/as unrent &7-&r Stop de huur van een gebied"
help-unrentOwn: "&6/as unrent &7-&r Stop de huur van een eigen gebied"
help-sell: "&6/as sell &7-&r Verkoop een gebied"
help-sellOwn: "&6/as sell &7-&r Verkoop een eigen gebied"
help-updaterents: "&6/as updaterents &7-&r Update alle huur borden en gebieden"
help-updatebuys: "&6/as updatebuys &7-&r Update alle koop borden en gebieden"
help-reload: "&6/as reload &7-&r Herlaad de config en de taalbestanden"
help-rentrestore: "&6/as rentrestore &7-&r Laat dit huur gebied herstellen of niet"
help-buyrestore: "&6/as buyrestore &7-&r Laat dit koop gebied herstellen of niet"
help-rentprice: "&6/as rentprice &7-&r Verander de prijs van een huur gebied"
help-buyprice: "&6/as buyprice &7-&r Verander de prijs van een koop gebied"
help-rentduration: "&6/as rentduration &7-&r Verander de looptijd van een huur gebied"
help-teleport: "&6/as tp &7-&r Teleporteer naar je gekochte/gehuurde gebieden"
help-teleportAll: "&6/as tp &7-&r Teleporteer naar koop/huur gebieden"
rentrestore-help: "/as rentrestore <gebied> <true|false|general> [profiel]"
rentrestore-noPermission: "Je hebt geen toestemming om herstel instellingen te veranderen bij een huur gebied"
rentrestore-notRegistered: "%0% is niet geregistreerd als een huur gebied"
rentrestore-invalidSetting: "'%0%' is geen goede optie, gebruik true, false of general"
rentrestore-success: "Succesvol de herstel optie gezet van %0% naar '%1%'"
rentrestore-successProfile: "Succesvol de herstel optie gezet van %0% naar '%1%' en het profiel naar '%2%'"
buyrestore-help: "/as buyrestore <gebied> <true|false|general> [profiel]"
buyrestore-noPermission: "Je hebt geen toestemming om herstel instellingen te veranderen bij geen koop gebied"
buyrestore-notRegistered: "%0% is niet geregistreerd als een koop gebied"
buyrestore-invalidSetting: "'%0%' is geen goede optie, gebruik true, false of general"
buyrestore-success: "Succesvol de herstel optie gezet van %0% naar '%1%'"
buyrestore-successProfile: "Succesvol de herstel optie gezet van %0% naar '%1%' en het profiel naar '%2%'"
rentprice-noPermission: "Je hebt geen toestemming om de prijs van een huur gebied te veranderen"
rentprice-help: "/as rentprice <gebied> <prijs>"
rentprice-notRegistered: "%0% is niet geregistreerd als een huur gebied"
rentprice-wrongPrice: "'%0%' is geen goede prijs"
rentprice-success: "Prijs van gebied %0% is veranderd naar %1% per %2%"
buyprice-noPermission: "Je hebt geen toestemming om de prijs van een koop gebied te veranderen"
buyprice-help: "/as buyprice <gebied> <prijs>"
buyprice-notRegistered: "%0% is niet geregistreerd als koop gebied"
buyprice-wrongPrice: "'%0%' is geen goede prijs"
buyprice-success: "Prijs van gebied %0% is veranderd naar %1%"
rentduration-noPermission: "Je hebt geen toestemming om de looptijd van een huur gebied te veranderen"
rentduration-help: "/as rentduration <gebied> <aantal> <soort>"
rentduration-notRegistered: "%0% is niet geregistreerd als een huur gebied"
rentduration-wrongPrice: "'%0%' is geen goede prijs, gebruik een geheel getal"
rentduration-wrongFormat: "'%0%' is geen goed tijdformaat, bekijk de documentatie op Bukkit"
rentduration-success: "Looptijd van gebeid %0% veranderd naar '%1%'"
setup-noRegion: "Je hebt geen gebied aangegeven op de tweede regel"
setup-wrongRegion: "Het aangegeven gebied bestaat niet"
setup-alreadyRentSign: "Het aangegeven gebied heeft al een bord voor huren"
setup-alreadyBuySign: "Het aangegeven gebied heeft al een bord voor kopen"
setup-noDuration: "Je hebt geen tijdsduur voor het huren aangegeven, zet dit op de derde regel"
setup-wrongDuration: "De aangegeven tijdsduur is niet in het correcte formaat, voorbeeld: 1 dag"
setup-noPrice: "Je hebt geen prijs aangegeven op de vierde regel"
setup-wrongPrice: "Je hebt de prijs niet goed aangegeven, gebruik een nummer"
setup-rentSuccess: "Huren van gebied %0% is goed opgezet"
setup-buySuccess: "Kopen van gebied %0% is goed opgezet"
setup-noPermissionRent: "Je hebt geen toestemming om huur gebieden op te zetten"
setup-noPermissionBuy: "Je hebt geen toestemming om koop gebieden op te zetten"
setup-couldNotDetect: "Meerdere gebieden gevonden met dezelfde prioriteit en/of parent/child relatie, geeft een specifieke aan op de tweede regel (2 van de gebieden die gevonden zijn: %0% en %1%)"
teleport-help: "/as tp <gebied> <aantal> <soort>"
teleport-noRentOrBuy: "Gebied '%0%' is niet geregistreerd als koop of huur gebied"
teleport-noPermission: "Je hebt geen toestemming om te teleporteren naar een gebied"
teleport-noPermissionOther: "Je hebt geen toestemming om te teleporteren naar een gebied dat niet van jou is"
teleport-success: "Je bent naar %0% geteleporteerd"
teleport-noSafe: "Geen veilige plek gevonden in gebied %0%, verander het gebied of stel de teleporteer positie in"
-153
View File
@@ -1,153 +0,0 @@
name: AreaShop
main: nl.evolutioncoding.AreaShop.AreaShop
version: 2.0.2
depend: [Vault, WorldGuard, WorldEdit]
softdepend: [Multiverse-Core]
commands:
AreaShop:
description: For all commands use /as help
usage: /AreaShop or /AS
permission: areashop.help
permission-message: You don't have <permission>
aliases: [as]
permissions:
areashop.*:
description: Give access to all commands of AreaShop
children:
areashop.help: true
areashop.createrent: true
areashop.createbuy: true
areashop.destroyrent: true
areashop.destroybuy: true
areashop.rent: true
areashop.buy: true
areashop.unrent: true
areashop.info: true
areashop.updaterents: true
areashop.updatebuys: true
areashop.reload: true
areashop.setrestore: true
areashop.setprice: true
areashop.rentduration: true
areashop.teleportall: true
areashop.setteleportall: true
areashop.teleportsign: true
areashop.tabcomplete: true
areashop.setteleportoutsideregion: true
areashop.find: true
areashop.groupadd: true
areashop.groupdel: true
areashop.grouplist: true
areashop.groupinfo: true
areashop.limits.unlimited: true
areashop.schematicevents: true
areashop.addsign: true
areashop.delsign: true
areashop.help:
description: Allows you to see the help pages
default: true
areashop.rent:
description: Allows you to rent a region
default: true
areashop.buy:
description: Allows you to buy a region
default: true
areashop.unrent:
description: Allows you to unrent a specific region
default: op
areashop.unrentown:
description: Allows you to unrent your own region
default: true
areashop.sell:
description: Allows you to sell a specific region
default: op
areashop.sellown:
description: Allows you to sell your own region
default: true
areashop.createrent:
description: Allows you to set up signs for renting regions
default: op
areashop.createbuy:
description: Allows you to set up signs for buying regions
default: op
areashop.destroyrent:
description: Allows you to break signs used for renting regions
default: op
areashop.destroybuy:
description: Allows you to break signs used for renting regions
default: op
areashop.info:
description: Allows you check the status of regions and players
default: true
areashop.updaterents:
description: Allows you to update all rent signs and regions
default: op
areashop.updatebuys:
description: Allows you to update all buy signs and regions
default: op
areashop.reload:
description: Allows you to reload the config
default: op
areashop.setrestore:
description: Allows you to change the restore settings
default: op
areashop.setprice:
description: Allows you to change the price
default: op
areashop.rentduration:
description: Allows you to change the duration of a rent
default: op
areashop.teleport:
description: Teleport to your region
default: true
areashop.teleportall:
description: Teleport to all regions
default: true
areashop.teleportsign:
description: Teleport to signs of regions
default: true
areashop.setteleport:
description: Set the teleport spot for your region
default: true
areashop.setteleportall:
description: Set the teleport for other regions
default: op
areashop.setteleportoutsideregion:
description: Set the teleport location outside the WorldGuard region
default: op
areashop.tabcomplete:
description: Allows you to tabcomplete all commands (also where you dont have permission)
default: op
areashop.find:
description: Allows you to teleport to a free region (/as find)
default: true
areashop.groupadd:
description: Allows you to add regions to groups
default: op
areashop.groupdel:
description: Allows you to delete regions from groups
default: op
areashop.grouplist:
description: Allows you to list all the groups currently created
default: op
areashop.groupinfo:
description: Allows you to display information about a group (all members)
default: op
areashop.rentextendbypass:
description: Bypass the extend limit on rents
default: op
areashop.limits.default:
description: Assign limits as set in the 'default' group in the 'limitGroups' section of the config
default: not op
areashop.limits.unlimited:
description: Assign limits as set in the 'unlimited' group in the 'limitGroups' section of the config
default: op
areashop.schematicevents:
description: Allows you to trigger schematic events for regions
default: op
areashop.addsign:
description: Allows you to add signs to existing regions
default: op
areashop.delsign:
description: Allows you to delete signs from existing regions
default: op
+285
View File
@@ -0,0 +1,285 @@
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>me.wiefferink</groupId>
<artifactId>areashop-parent</artifactId>
<version>1.0</version>
</parent>
<artifactId>areashop</artifactId>
<packaging>jar</packaging>
<name>AreaShop</name>
<version>2.6.2</version> <!-- Main plugin version -->
<repositories>
<repository>
<id>papermc</id>
<url>https://papermc.io/repo/repository/maven-public/</url>
</repository>
<repository>
<id>aikar</id>
<url>https://repo.aikar.co/content/groups/aikar/</url>
</repository>
</repositories>
<dependencies>
<!-- Bukkit, AreaShop aims to support 1.13.2+ -->
<dependency>
<groupId>org.spigotmc</groupId>
<artifactId>spigot-api</artifactId>
<version>1.13.2-R0.1-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<!-- InteractiveMessenger library -->
<dependency>
<groupId>me.wiefferink</groupId>
<artifactId>interactivemessenger</artifactId>
<version>1.1-SNAPSHOT</version>
</dependency>
<!-- TaskChain library -->
<dependency>
<groupId>co.aikar</groupId>
<artifactId>taskchain-bukkit</artifactId>
<version>3.7.2</version>
</dependency>
<dependency>
<groupId>io.papermc</groupId>
<artifactId>paperlib</artifactId>
<version>1.0.4</version>
</dependency>
<!-- WorldEdit/WorldGuard -->
<dependency>
<groupId>com.sk89q.worldedit</groupId>
<artifactId>worldedit-bukkit</artifactId>
<version>7.1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>com.sk89q.worldguard</groupId>
<artifactId>worldguard-bukkit</artifactId>
<version>7.0.3</version>
<scope>provided</scope>
</dependency>
<!-- Interfaces that specific WorldGuard and WorldEdit versions are built against -->
<dependency>
<groupId>me.wiefferink</groupId>
<artifactId>areashop-interface</artifactId>
<version>latest</version>
<scope>compile</scope>
</dependency>
<!-- WorldGuard implementations -->
<dependency>
<groupId>me.wiefferink</groupId>
<artifactId>areashop-worldguard-7</artifactId>
<version>latest</version>
<scope>compile</scope>
</dependency>
<!-- WorldEdit implementations -->
<dependency>
<groupId>me.wiefferink</groupId>
<artifactId>areashop-worldedit-7</artifactId>
<version>latest</version>
<scope>compile</scope>
</dependency>
<!-- FAWE compat -->
<dependency>
<groupId>me.wiefferink</groupId>
<artifactId>areashop-fawe-1-15</artifactId>
<version>latest</version>
<type>jar</type>
<scope>compile</scope>
</dependency>
<!-- Vault -->
<dependency>
<groupId>net.milkbowl.vault</groupId>
<artifactId>VaultAPI</artifactId>
<version>1.7</version>
<scope>provided</scope>
</dependency>
<!-- bStats -->
<dependency>
<groupId>org.bstats</groupId>
<artifactId>bstats-bukkit</artifactId>
<version>1.1</version>
<scope>compile</scope>
</dependency>
</dependencies>
<profiles>
<!-- Copy the jar file to a test server, activate by using -DcopyResult="/path/to/test/server" -->
<profile>
<id>test-locally</id>
<activation>
<property>
<name>copyResult</name>
</property>
</activation>
<build>
<plugins>
<plugin>
<artifactId>maven-antrun-plugin</artifactId>
<version>1.8</version>
<configuration>
<target>
<copy file="./target/${project.build.finalName}.jar"
tofile="${copyResult}\${project.build.finalName}.jar"/>
</target>
</configuration>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<!-- Package the source files in a jar, activate by using -Dsources -->
<profile>
<id>package-sources</id>
<activation>
<property>
<name>sources</name>
</property>
</activation>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-source-plugin</artifactId>
<version>3.2.1</version>
<executions>
<execution>
<phase>package</phase>
<id>attach-sources</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<!-- Produce javadoc files, activate by using -Djavadoc -->
<profile>
<id>generate-javadoc</id>
<activation>
<property>
<name>javadoc</name>
</property>
</activation>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-javadoc-plugin</artifactId>
<version>3.2.0</version>
<executions>
<execution>
<phase>package</phase>
<id>attach-javadocs</id>
<goals>
<goal>jar</goal>
</goals>
</execution>
</executions>
<configuration>
<excludePackageNames>me.wiefferink.areashop.lib</excludePackageNames>
<destDir>${javadoc}</destDir>
<links>
<link>https://hub.spigotmc.org/javadocs/bukkit/</link>
<link>http://docs.sk89q.com/worldedit/apidocs/</link>
<link>http://docs.sk89q.com/worldguard/apidocs/</link>
</links>
</configuration>
</plugin>
</plugins>
</build>
</profile>
</profiles>
<build>
<directory>target</directory>
<finalName>AreaShop</finalName>
<resources>
<resource>
<targetPath>.</targetPath>
<filtering>true</filtering>
<directory>src/main/resources</directory>
<includes>
<include>plugin.yml</include>
<include>config.yml</include>
<include>hiddenConfig.yml</include>
<include>default.yml</include>
<include>README.md</include>
<include>lang/*.yml</include>
</includes>
</resource>
</resources>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-shade-plugin</artifactId>
<version>3.2.3</version>
<executions>
<execution>
<phase>package</phase>
<goals>
<goal>shade</goal>
</goals>
<configuration>
<relocations>
<!-- Relocate TaskChain -->
<relocation>
<pattern>co.aikar.taskchain</pattern>
<shadedPattern>me.wiefferink.areashop.shaded.taskchain</shadedPattern>
</relocation>
<!-- Relocate messaging framework -->
<relocation>
<pattern>me.wiefferink.interactivemessenger</pattern>
<shadedPattern>me.wiefferink.areashop.shaded.interactivemessenger</shadedPattern>
</relocation>
<!-- Relocate bstats -->
<relocation>
<pattern>org.bstats</pattern>
<shadedPattern>me.wiefferink.areashop.shaded.bstats</shadedPattern>
</relocation>
<relocation>
<pattern>io.papermc</pattern>
<shadedPattern>me.wiefferink.areashop.shaded.paperlib</shadedPattern>
</relocation>
</relocations>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
@@ -0,0 +1,802 @@
package me.wiefferink.areashop;
import co.aikar.taskchain.BukkitTaskChainFactory;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
import com.sk89q.worldguard.protection.managers.RegionManager;
import me.wiefferink.areashop.interfaces.AreaShopInterface;
import me.wiefferink.areashop.interfaces.WorldEditInterface;
import me.wiefferink.areashop.interfaces.WorldGuardInterface;
import me.wiefferink.areashop.listeners.PlayerLoginLogoutListener;
import me.wiefferink.areashop.managers.*;
import me.wiefferink.areashop.tools.Analytics;
import me.wiefferink.areashop.tools.GithubUpdateCheck;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import me.wiefferink.interactivemessenger.source.LanguageManager;
import net.milkbowl.vault.economy.Economy;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.permissions.Permission;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.plugin.java.JavaPlugin;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Main class for the AreaShop plugin.
* Contains methods to get parts of the plugins functionality and definitions for constants.
*/
public final class AreaShop extends JavaPlugin implements AreaShopInterface {
// Folders and file names
public static final String languageFolder = "lang";
public static final String schematicFolder = "schem";
public static final String regionsFolder = "regions";
public static final String groupsFile = "groups.yml";
public static final String defaultFile = "default.yml";
public static final String configFile = "config.yml";
public static final String configFileHidden = "hiddenConfig.yml";
public static final String versionFile = "versions";
// Euro tag for in the config
public static final String currencyEuro = "%euro%";
// Constants for handling file versions
public static final String versionFiles = "files";
public static final int versionFilesCurrent = 3;
// Keys for replacing parts of flags, commands, strings
public static final String tagPlayerName = "player";
public static final String tagPlayerUUID = "uuid";
public static final String tagWorldName = "world";
public static final String tagRegionName = "region";
public static final String tagRegionType = "type";
public static final String tagPrice = "price";
public static final String tagRawPrice = "rawprice";
public static final String tagDuration = "duration";
public static final String tagRentedUntil = "until";
public static final String tagRentedUntilShort = "untilshort";
public static final String tagWidth = "width"; // x-axis
public static final String tagHeight = "height"; // y-axis
public static final String tagDepth = "depth"; // z-axis
public static final String tagVolume = "volume";
// Number of blocks in the region (accounting for polygon regions)
public static final String tagTimeLeft = "timeleft";
public static final String tagClicker = "clicker";
public static final String tagResellPrice = "resellprice";
public static final String tagRawResellPrice = "rawresellprice";
public static final String tagFriends = "friends";
public static final String tagFriendsUUID = "friendsuuid";
public static final String tagMoneyBackPercentage = "moneybackpercent";
public static final String tagMoneyBackAmount = "moneyback";
public static final String tagRawMoneyBackAmount = "rawmoneyback";
public static final String tagTimesExtended = "timesExtended";
public static final String tagMaxExtends = "maxextends";
public static final String tagExtendsLeft = "extendsleft";
public static final String tagMaxRentTime = "maxrenttime";
public static final String tagMaxInactiveTime = "inactivetime";
public static final String tagLandlord = "landlord";
public static final String tagLandlordUUID = "landlorduuid";
public static final String tagDateTime = "datetime";
public static final String tagDateTimeShort = "datetimeshort";
public static final String tagYear = "year";
public static final String tagMonth = "month";
public static final String tagDay = "day";
public static final String tagHour = "hour";
public static final String tagMinute = "minute";
public static final String tagSecond = "second";
public static final String tagMillisecond = "millisecond";
public static final String tagEpoch = "epoch";
public static final String tagTeleportX = "tpx";
public static final String tagTeleportY = "tpy";
public static final String tagTeleportZ = "tpz";
public static final String tagTeleportBlockX = "tpblockx";
public static final String tagTeleportBlockY = "tpblocky";
public static final String tagTeleportBlockZ = "tpblockz";
public static final String tagTeleportPitch = "tppitch";
public static final String tagTeleportYaw = "tpyaw";
public static final String tagTeleportPitchRound = "tppitchround";
public static final String tagTeleportYawRound = "tpyawround";
public static final String tagTeleportWorld = "tpworld";
// REGEX Matcher for Versions which follow a x.x.x format.
private static final Pattern VERSION_MATCHER_3 = Pattern.compile("([0-9]+)\\.([0-9]+)\\.([0-9]+)");
private static final Pattern VERSION_MATCHER_2 = Pattern.compile("([0-9]+)\\.([0-9]+)\\.([0-9]+)");
// Statically available instance
private static AreaShop instance = null;
// General variables
private WorldGuardPlugin worldGuard = null;
private WorldGuardInterface worldGuardInterface = null;
private WorldEditPlugin worldEdit = null;
private WorldEditInterface worldEditInterface = null;
private FileManager fileManager = null;
private LanguageManager languageManager = null;
private CommandManager commandManager = null;
private SignLinkerManager signLinkerManager = null;
private FeatureManager featureManager = null;
private Set<Manager> managers = null;
private boolean debug = false;
private List<String> chatprefix = null;
private boolean ready = false;
private GithubUpdateCheck githubUpdateCheck = null;
public static AreaShop getInstance() {
return AreaShop.instance;
}
/**
* Sends an debug message to the console.
*
* @param message The message that should be printed to the console
*/
public static void debug(Object... message) {
if (AreaShop.getInstance().debug) {
info("Debug: " + StringUtils.join(message, " "));
}
}
/**
* Print an information message to the console.
*
* @param message The message to print
*/
public static void info(Object... message) {
AreaShop.getInstance().getLogger().info(StringUtils.join(message, " "));
}
/**
* Print a warning to the console.
*
* @param message The message to print
*/
public static void warn(Object... message) {
AreaShop.getInstance().getLogger().warning(StringUtils.join(message, " "));
}
/**
* Print an error to the console.
*
* @param message The message to print
*/
public static void error(Object... message) {
AreaShop.getInstance().getLogger().severe(StringUtils.join(message, " "));
}
/**
* Print debug message for periodic task.
*
* @param message The message to print
*/
public static void debugTask(Object... message) {
if (AreaShop.getInstance().getConfig().getBoolean("debugTask")) {
AreaShop.debug(StringUtils.join(message, " "));
}
}
/**
* Notify a player about an update if he wants notifications about it and an update is available.
*
* @param sender CommandSender to notify
*/
public void notifyUpdate(CommandSender sender) {
if (githubUpdateCheck != null && githubUpdateCheck.hasUpdate() && sender
.hasPermission("areashop.notifyupdate")) {
AreaShop.getInstance().message(sender, "update-playerNotify",
cleanVersion(githubUpdateCheck.getCurrentVersion()),
cleanVersion(githubUpdateCheck.getLatestVersion()));
}
}
/**
* Cleanup a version number.
*
* @param version Version to clean
* @return Cleaned up version (removed prefixes and suffixes)
*/
private String cleanVersion(String version) {
version = version.toLowerCase();
// Strip 'v' as used on Github tags
if (version.startsWith("v")) {
version = version.substring(1);
}
// Strip build number as used by Jenkins
if (version.contains("#")) {
version = version.substring(0, version.indexOf("#"));
}
return version;
}
/**
* Indicates if the plugin is ready to be used.
*
* @return true if the plugin is ready, false otherwise
*/
public boolean isReady() {
return ready;
}
/**
* Set if the plugin is ready to be used or not (not to be used from another plugin!).
*
* @param ready Indicate if the plugin is ready to be used
*/
public void setReady(boolean ready) {
this.ready = ready;
}
/**
* Set if the plugin should output debug messages (loaded from config normally).
*
* @param debug Indicates if the plugin should output debug messages or not
*/
public void setDebug(boolean debug) {
this.debug = debug;
}
/**
* Setup a new LanguageManager.
*/
private void setupLanguageManager() {
languageManager =
new LanguageManager(this, languageFolder, getConfig().getString("language"), "EN",
chatprefix);
}
/**
* Set the chatprefix to use in the chat (loaded from config normally).
*
* @param chatprefix The string to use in front of chat messages (supports formatting codes)
*/
public void setChatprefix(List<String> chatprefix) {
this.chatprefix = chatprefix;
}
/**
* Function to get WorldGuardInterface for version dependent things.
*
* @return WorldGuardInterface
*/
public WorldGuardInterface getWorldGuardHandler() {
return this.worldGuardInterface;
}
/**
* Get the RegionManager.
*
* @param world World to get the RegionManager for
* @return RegionManager for the given world, if there is one, otherwise null
*/
public RegionManager getRegionManager(World world) {
return this.worldGuardInterface.getRegionManager(world);
}
/**
* Function to get WorldGuardInterface for version dependent things.
*
* @return WorldGuardInterface
*/
public WorldEditInterface getWorldEditHandler() {
return this.worldEditInterface;
}
/**
* Function to get the LanguageManager.
*
* @return the LanguageManager
*/
public LanguageManager getLanguageManager() {
return languageManager;
}
/**
* Function to get the CommandManager.
*
* @return the CommandManager
*/
public CommandManager getCommandManager() {
return commandManager;
}
/**
* Get the SignLinkerManager.
* Handles sign linking mode.
*
* @return The SignLinkerManager
*/
public SignLinkerManager getSignlinkerManager() {
return signLinkerManager;
}
/**
* Get the FeatureManager.
* Manages region specific features.
*
* @return The FeatureManager
*/
public FeatureManager getFeatureManager() {
return featureManager;
}
/**
* Function to get the Vault plugin.
*
* @return Economy
*/
public Economy getEconomy() {
RegisteredServiceProvider<Economy> economy = getServer().getServicesManager()
.getRegistration(net.milkbowl.vault.economy.Economy.class);
if (economy == null || economy.getProvider() == null) {
error(
"There is no economy provider to support Vault, make sure you installed an economy plugin");
return null;
}
return economy.getProvider();
}
/**
* Get the Vault permissions provider.
*
* @return Vault permissions provider
*/
public net.milkbowl.vault.permission.Permission getPermissionProvider() {
RegisteredServiceProvider<net.milkbowl.vault.permission.Permission> permissionProvider =
getServer().getServicesManager()
.getRegistration(net.milkbowl.vault.permission.Permission.class);
return permissionProvider == null ? null : permissionProvider.getProvider();
}
/**
* Check for a permission of a (possibly offline) player.
*
* @param offlinePlayer OfflinePlayer to check
* @param permission Permission to check
* @return true if the player has the permission, false if the player does not have permission or, is offline and there is not Vault-compatible permission plugin
*/
public boolean hasPermission(OfflinePlayer offlinePlayer, String permission) {
// Online, return through Bukkit
if (offlinePlayer.getPlayer() != null) {
return offlinePlayer.getPlayer().hasPermission(permission);
}
// Resolve while offline if possible
net.milkbowl.vault.permission.Permission permissionProvider = getPermissionProvider();
if (permissionProvider != null) {
// TODO: Should we provide a world here?
return permissionProvider.playerHas(null, offlinePlayer, permission);
}
// Player offline and no offline permission provider available, safely say that there is no permission
return false;
}
/**
* Method to get the FileManager (loads/save regions and can be used to get regions).
*
* @return The fileManager
*/
public FileManager getFileManager() {
return fileManager;
}
/**
* Register dynamic permissions controlled by config settings.
*/
private void registerDynamicPermissions() {
// Register limit groups of amount of regions a player can have
ConfigurationSection section = getConfig().getConfigurationSection("limitGroups");
if (section == null) {
return;
}
for (String group : section.getKeys(false)) {
if (!"default".equals(group)) {
Permission perm = new Permission("areashop.limits." + group);
try {
Bukkit.getPluginManager().addPermission(perm);
} catch (IllegalArgumentException e) {
warn("Could not add the following permission to be used as limit: " + perm
.getName());
}
}
}
Bukkit.getPluginManager().recalculatePermissionDefaults(
Bukkit.getPluginManager().getPermission("playerwarps.limits"));
}
/**
* Register all required tasks.
*/
private void setupTasks() {
// Rent expiration timer
long expirationCheck =
Utils.millisToTicks(Utils.getDurationFromSecondsOrString("expiration.delay"));
final AreaShop finalPlugin = this;
if (expirationCheck > 0) {
Bukkit.getScheduler().runTaskTimer(this, () -> {
if (isReady()) {
finalPlugin.getFileManager().checkRents();
AreaShop.debugTask("Checking rent expirations...");
} else {
AreaShop.debugTask("Skipped checking rent expirations, plugin not ready");
}
}, 1, expirationCheck);
}
// Inactive unrenting/selling timer
long inactiveCheck =
Utils.millisToTicks(Utils.getDurationFromMinutesOrString("inactive.delay"));
if (inactiveCheck > 0) {
Bukkit.getScheduler().runTaskTimer(this, () -> {
if (isReady()) {
finalPlugin.getFileManager().checkForInactiveRegions();
AreaShop.debugTask(
"Checking for regions with players that are inactive too long...");
} else {
AreaShop.debugTask(
"Skipped checking for regions of inactive players, plugin not ready");
}
}, 1, inactiveCheck);
}
// Periodic updating of signs for timeleft tags
long periodicUpdate =
Utils.millisToTicks(Utils.getDurationFromSecondsOrString("signs.delay"));
if (periodicUpdate > 0) {
Bukkit.getScheduler().runTaskTimer(this, () -> {
if (isReady()) {
finalPlugin.getFileManager().performPeriodicSignUpdate();
AreaShop.debugTask("Performing periodic sign update...");
} else {
AreaShop.debugTask("Skipped performing periodic sign update, plugin not ready");
}
},1, periodicUpdate);
}
// Saving regions and group settings
long saveFiles = Utils.millisToTicks(Utils.getDurationFromMinutesOrString("saving.delay"));
if (saveFiles > 0) {
Bukkit.getScheduler().runTaskTimer(this, () -> {
if (isReady()) {
finalPlugin.getFileManager().saveRequiredFiles();
AreaShop.debugTask("Saving required files...");
} else {
AreaShop.debugTask("Skipped saving required files, plugin not ready");
}
}, saveFiles, saveFiles);
}
// Sending warnings about rent regions to online players
long expireWarning =
Utils.millisToTicks(Utils.getDurationFromMinutesOrString("expireWarning.delay"));
if (expireWarning > 0) {
Bukkit.getScheduler().runTaskLater(finalPlugin, () -> {
if (isReady()) {
finalPlugin.getFileManager().sendRentExpireWarnings();
AreaShop.debugTask("Sending rent expire warnings...");
} else {
AreaShop.debugTask("Skipped sending rent expire warnings, plugin not ready");
}
}, expireWarning);
}
// Update all regions on startup
if (getConfig().getBoolean("updateRegionsOnStartup")) {
Bukkit.getScheduler().runTaskLater(this, () -> {
finalPlugin.getFileManager().updateAllRegions();
AreaShop.debugTask("Updating all regions at startup...");
}, 20);
}
}
/**
* Send a message to a target without a prefix.
*
* @param target The target to send the message to
* @param key The key of the language string
* @param replacements The replacements to insert in the message
*/
public void messageNoPrefix(Object target, String key, Object... replacements) {
Message.fromKey(key).replacements(replacements).send(target);
}
/**
* Send a message to a target, prefixed by the default chat prefix.
*
* @param target The target to send the message to
* @param key The key of the language string
* @param replacements The replacements to insert in the message
*/
public void message(Object target, String key, Object... replacements) {
Message.fromKey(key).prefix().replacements(replacements).send(target);
}
/**
* Return the config.
*/
@Override
public YamlConfiguration getConfig() {
return fileManager.getConfig();
}
/**
* Called on shutdown or reload of the server.
*/
@Override
public void onDisable() {
Bukkit.getServer().getScheduler().cancelTasks(this);
// Cleanup managers
for (Manager manager : managers) {
manager.shutdown();
}
managers = null;
fileManager = null;
languageManager = null;
commandManager = null;
signLinkerManager = null;
featureManager = null;
// Cleanup plugins
worldGuard = null;
worldGuardInterface = null;
worldEdit = null;
worldEditInterface = null;
// Cleanup other stuff
chatprefix = null;
debug = false;
ready = false;
HandlerList.unregisterAll(this);
}
/**
* Called on start or reload of the server.
*/
@Override
public void onEnable() {
AreaShop.instance = this;
Utils.factory = BukkitTaskChainFactory.create(this);
managers = new HashSet<>();
boolean error = !loadHooks();
// Check if Vault is present
if (getServer().getPluginManager().getPlugin("Vault") == null) {
error("Vault plugin is not present or has not loaded correctly");
error = true;
}
// Load all data from files and check versions
fileManager = new FileManager();
managers.add(fileManager);
boolean loadFilesResult = fileManager.loadFiles(false);
error = error || !loadFilesResult;
setupLanguageManager();
if (error) {
error("The plugin has not started, fix the errors listed above");
} else {
featureManager = new FeatureManager();
managers.add(featureManager);
// Register the event listeners
getServer().getPluginManager()
.registerEvents(new PlayerLoginLogoutListener(this), this);
setupTasks();
// Startup the CommandManager (registers itself for the command)
commandManager = new CommandManager();
managers.add(commandManager);
// Create a signLinkerManager
signLinkerManager = new SignLinkerManager();
managers.add(signLinkerManager);
// Enable Metrics if config allows it
if (getConfig().getBoolean("sendStats")) {
Analytics.start();
}
// Register dynamic permission (things declared in config)
registerDynamicPermissions();
// Don't initialize the updatechecker if disabled in the config
if (getConfig().getBoolean("checkForUpdates")) {
final GithubUpdateCheck.VersionComparator comparator = (latestVersion, currentVersion) -> {
Matcher matcher0 = VERSION_MATCHER_3.matcher(latestVersion);
boolean dual0 = false;
if (!matcher0.find()) {
matcher0 = VERSION_MATCHER_3.matcher(latestVersion);
if (!matcher0.find()) {
throw new IllegalArgumentException("Invalid Versions Detected!");
}
dual0 = true;
}
Matcher matcher1 = VERSION_MATCHER_3.matcher(currentVersion);
boolean dual1 = false;
if (!matcher1.find()) {
matcher1 = VERSION_MATCHER_2.matcher(currentVersion);
if (!matcher1.find()) {
throw new IllegalArgumentException("Invalid Versions Detected!");
}
dual1 = true;
}
int major0 = Integer.parseInt(matcher0.group(1));
int centre0 = Integer.parseInt(matcher0.group(2));
int minor0 = dual0 ? 0 : Integer.parseInt(matcher0.group(3));
int major1 = Integer.parseInt(matcher1.group(1));
int centre1 = Integer.parseInt(matcher1.group(2));
int minor1 = dual1 ? 0 : Integer.parseInt(matcher1.group(3));
return major0 > major1 && centre0 > centre1 && minor0 > minor1;
};
githubUpdateCheck =
new GithubUpdateCheck(AreaShop.getInstance(), "NLThijs48", "AreaShop")
.withVersionComparator(comparator).checkUpdate(result -> {
AreaShop.debug("Update check result:", result);
if (!result.hasUpdate()) {
return;
}
AreaShop.info(
"Update from AreaShop V" + cleanVersion(result.getCurrentVersion())
+ " to AreaShop V" + cleanVersion(result.getLatestVersion())
+ " available, get the latest version at https://www.spigotmc.org/resources/areashop.2991/");
for (Player player : Utils.getOnlinePlayers()) {
notifyUpdate(player);
}
});
}
}
}
public boolean loadHooks() {
final Plugin worldEdit = getServer().getPluginManager().getPlugin("WorldEdit");
if (!(worldEdit instanceof WorldEditPlugin) || !worldEdit.isEnabled()) {
error("WorldEdit plugin is not present or has not loaded correctly");
return true;
}
final Plugin worldGuard = getServer().getPluginManager().getPlugin("WorldGuard");
if (!(worldGuard instanceof WorldGuardPlugin) || !worldEdit.isEnabled()) {
error("WorldGuard plugin is not present or has not loaded correctly");
return true;
}
final String packageName = "me.wiefferink.areashop.handlers.";
if (this.worldEditInterface == null) {
final String version = worldEdit.getDescription().getVersion();
Matcher matcher = VERSION_MATCHER_3.matcher(version);
if (!matcher.find()) {
error("Failed to parse the WE version!");
return false;
}
String major = matcher.group(1);
if (Integer.parseInt(major) < 7) {
error("Unsupported WorldEdit Version: " + version + "! Only WorldEdit version(s) 7.x.x or newer are supported!");
return false;
}
try {
this.worldEditInterface = (WorldEditInterface) Class.forName(packageName + "worldedit.v" + major + ".WorldEditHandler")
.getDeclaredConstructor(AreaShopInterface.class).newInstance(this);
} catch (final ReflectiveOperationException ex) {
ex.printStackTrace();
error("Failed to hook into WorldEdit!");
return false;
}
}
this.worldEdit = (WorldEditPlugin) worldEdit;
final Plugin fawe = getServer().getPluginManager().getPlugin("FastAsyncWorldEdit");
if (fawe != null && fawe.isEnabled()) {
final String version = fawe.getDescription().getVersion();
if (version.startsWith("1.15") || version.startsWith("1.16")) {
try {
this.worldEditInterface = (WorldEditInterface) Class.forName(packageName + "fawe.v1_15.FastAsyncWorldEditHandler")
.getDeclaredConstructor(AreaShopInterface.class).newInstance(this);
} catch (ReflectiveOperationException ex) {
getLogger().log(Level.SEVERE, "Failed to hook into FAWE!");
ex.printStackTrace();
}
}
if (this.worldEditInterface == null) {
info("FAWE Version: " + version + " detected, no compatible handler found. Using the WorldEdit handler instead.");
}
}
final String wgVersion = worldGuard.getDescription().getVersion();
Matcher matcher = VERSION_MATCHER_3.matcher(wgVersion);
if (!matcher.find()) {
error("Failed to parse the WG version!");
return false;
}
String major = matcher.group(1);
if (Integer.parseInt(major) < 7) {
error("Unsupported WorldGuard Version: " + wgVersion + "! Only WorldGuard version(s) 7.x.x or newer are supported!");
return false;
}
try {
this.worldGuard = (WorldGuardPlugin) worldGuard;
this.worldGuardInterface = (WorldGuardInterface) Class.forName(packageName + "worldguard.v" + major + ".WorldGuardHandler")
.getDeclaredConstructor(AreaShopInterface.class).newInstance(this);
} catch (ReflectiveOperationException ex) {
ex.printStackTrace();
error("Failed to hook into WorldGuard!");
return false;
}
return true;
}
/**
* Non-static debug to use as implementation of the interface.
*
* @param message Object parts of the message that should be logged, toString() will be used
*/
@Override
public void debugI(Object... message) {
AreaShop.debug(StringUtils.join(message, " "));
}
/**
* Function to get the WorldGuard plugin.
*
* @return WorldGuardPlugin
*/
@Override
public WorldGuardPlugin getWorldGuard() {
return worldGuard;
}
/**
* Function to get the WorldEdit plugin.
*
* @return WorldEditPlugin
*/
@Override
public WorldEditPlugin getWorldEdit() {
return worldEdit;
}
/**
* Reload all files of the plugin and update all regions.
*
* @param confirmationReceiver The CommandSender which should be notified when complete, null for nobody
*/
public void reload(final CommandSender confirmationReceiver) {
setReady(false);
fileManager.saveRequiredFilesAtOnce();
fileManager.loadFiles(true);
setupLanguageManager();
message(confirmationReceiver, "reload-reloading");
fileManager.checkRents();
fileManager.updateAllRegions(confirmationReceiver);
}
/**
* Reload all files of the plugin and update all regions.
*/
public void reload() {
reload(null);
}
}
@@ -0,0 +1,319 @@
package me.wiefferink.areashop.commands;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.AddingRegionEvent;
import me.wiefferink.areashop.events.ask.BuyingRegionEvent;
import me.wiefferink.areashop.events.ask.RentingRegionEvent;
import me.wiefferink.areashop.events.notify.BoughtRegionEvent;
import me.wiefferink.areashop.events.notify.RentedRegionEvent;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.managers.FileManager;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.*;
import java.util.stream.Collectors;
public class AddCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop add";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.createrent")
|| target.hasPermission("areashop.createrent.member")
|| target.hasPermission("areashop.createrent.owner")
|| target.hasPermission("areashop.createbuy")
|| target.hasPermission("areashop.createbuy.member")
|| target.hasPermission("areashop.createbuy.owner")) {
return "help-add";
}
return null;
}
@Override
public void execute(final CommandSender sender, final String[] args) {
if(!sender.hasPermission("areashop.createrent")
&& !sender.hasPermission("areashop.createrent.member")
&& !sender.hasPermission("areashop.createrent.owner")
&& !sender.hasPermission("areashop.createbuy")
&& !sender.hasPermission("areashop.createbuy.member")
&& !sender.hasPermission("areashop.createbuy.owner")) {
plugin.message(sender, "add-noPermission");
return;
}
if(args.length < 2 || args[1] == null || (!"rent".equalsIgnoreCase(args[1]) && !"buy".equalsIgnoreCase(args[1]))) {
plugin.message(sender, "add-help");
return;
}
Map<String, ProtectedRegion> regions = new HashMap<>();
World world;
Player player = null;
if(sender instanceof Player) {
player = (Player)sender;
}
if(args.length == 2) {
if(player == null) {
plugin.message(sender, "cmd-weOnlyByPlayer");
return;
}
WorldEditSelection selection = plugin.getWorldEditHandler().getPlayerSelection(player);
if(selection == null) {
plugin.message(player, "cmd-noSelection");
return;
}
world = selection.getWorld();
regions = Utils.getWorldEditRegionsInSelection(selection).stream().collect(Collectors.toMap(ProtectedRegion::getId, region -> region));
if(regions.isEmpty()) {
plugin.message(player, "cmd-noWERegionsFound");
return;
}
} else {
if(player != null) {
if(args.length == 4) {
world = Bukkit.getWorld(args[3]);
if(world == null) {
plugin.message(sender, "add-incorrectWorld", args[3]);
return;
}
} else {
world = ((Player)sender).getWorld();
}
} else {
if(args.length < 4) {
plugin.message(sender, "add-specifyWorld");
return;
} else {
world = Bukkit.getWorld(args[3]);
if(world == null) {
plugin.message(sender, "add-incorrectWorld", args[3]);
return;
}
}
}
ProtectedRegion region = plugin.getRegionManager(world).getRegion(args[2]);
if(region == null) {
plugin.message(sender, "cmd-noRegion", args[2]);
return;
}
regions.put(args[2], region);
}
final boolean isRent = "rent".equalsIgnoreCase(args[1]);
final Player finalPlayer = player;
AreaShop.debug("Starting add task with " + regions.size() + " regions");
TreeSet<GeneralRegion> regionsSuccess = new TreeSet<>();
TreeSet<GeneralRegion> regionsAlready = new TreeSet<>();
TreeSet<GeneralRegion> regionsAlreadyOtherWorld = new TreeSet<>();
TreeSet<GeneralRegion> regionsRentCancelled = new TreeSet<>(); // Denied by an event listener
TreeSet<GeneralRegion> regionsBuyCancelled = new TreeSet<>(); // Denied by an event listener
TreeSet<String> namesBlacklisted = new TreeSet<>();
TreeSet<String> namesNoPermission = new TreeSet<>();
TreeSet<String> namesAddCancelled = new TreeSet<>(); // Denied by an event listener
Utils.runAsBatches(regions.entrySet(),
Math.min(plugin.getConfig().getInt("adding.regionsPerTick"), 1),
(regionEntry) -> {
String regionName = regionEntry.getKey();
ProtectedRegion region = regionEntry.getValue();
// Determine if the player is an owner or member of the region
boolean isMember = finalPlayer != null && plugin.getWorldGuardHandler().containsMember(region, finalPlayer.getUniqueId());
boolean isOwner = finalPlayer != null && plugin.getWorldGuardHandler().containsOwner(region, finalPlayer.getUniqueId());
String type;
if(isRent) {
type = "rent";
} else {
type = "buy";
}
FileManager.AddResult result = plugin.getFileManager().checkRegionAdd(sender, region, world, isRent ? GeneralRegion.RegionType.RENT : GeneralRegion.RegionType.BUY);
if(result == FileManager.AddResult.ALREADYADDED) {
regionsAlready.add(plugin.getFileManager().getRegion(regionName));
} else if(result == FileManager.AddResult.ALREADYADDEDOTHERWORLD) {
regionsAlreadyOtherWorld.add(plugin.getFileManager().getRegion(regionName));
} else if(result == FileManager.AddResult.BLACKLISTED) {
namesBlacklisted.add(regionName);
} else if(result == FileManager.AddResult.NOPERMISSION) {
namesNoPermission.add(regionName);
} else {
// Check if the player should be landlord
boolean landlord = (!sender.hasPermission("areashop.create" + type)
&& ((sender.hasPermission("areashop.create" + type + ".owner") && isOwner)
|| (sender.hasPermission("areashop.create" + type + ".member") && isMember)));
List<UUID> existing = new ArrayList<>();
existing.addAll(plugin.getWorldGuardHandler().getOwners(region).asUniqueIdList());
existing.addAll(plugin.getWorldGuardHandler().getMembers(region).asUniqueIdList());
AreaShop.debug("regionAddLandlordStatus:", regionName,
"landlord:", landlord,
"existing:", existing,
"isMember:", isMember,
"isOwner:", isOwner,
"createPermission:", sender.hasPermission("areashop.create" + type),
"ownerPermission:", sender.hasPermission("areashop.create" + type + ".owner"),
"memberPermission:", sender.hasPermission("areashop.create" + type + ".member"));
if(isRent) {
RentRegion rent = new RentRegion(regionName, world);
// Set landlord
if(landlord) {
rent.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
}
AddingRegionEvent event = plugin.getFileManager().addRegion(rent);
if (event.isCancelled()) {
namesAddCancelled.add(rent.getName());
return;
}
rent.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);
rent.update();
// Add existing owners/members if any
if(!landlord && !existing.isEmpty()) {
UUID rentBy = existing.remove(0);
OfflinePlayer rentByPlayer = Bukkit.getOfflinePlayer(rentBy);
RentingRegionEvent rentingRegionEvent = new RentingRegionEvent(rent, rentByPlayer, false);
Bukkit.getPluginManager().callEvent(rentingRegionEvent);
if(rentingRegionEvent.isCancelled()) {
regionsRentCancelled.add(rent);
} else {
// Add values to the rent and send it to FileManager
rent.setRentedUntil(Calendar.getInstance().getTimeInMillis() + rent.getDuration());
rent.setRenter(rentBy);
rent.updateLastActiveTime();
// Fire schematic event and updated times extended
rent.handleSchematicEvent(GeneralRegion.RegionEvent.RENTED);
// Add others as friends
for(UUID friend : existing) {
rent.getFriendsFeature().addFriend(friend, null);
}
rent.notifyAndUpdate(new RentedRegionEvent(rent, false));
}
}
regionsSuccess.add(rent);
} else {
BuyRegion buy = new BuyRegion(regionName, world);
// Set landlord
if(landlord) {
buy.setLandlord(finalPlayer.getUniqueId(), finalPlayer.getName());
}
AddingRegionEvent event = plugin.getFileManager().addRegion(buy);
if (event.isCancelled()) {
namesAddCancelled.add(buy.getName());
return;
}
buy.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);
buy.update();
// Add existing owners/members if any
if(!landlord && !existing.isEmpty()) {
UUID buyBy = existing.remove(0);
OfflinePlayer buyByPlayer = Bukkit.getOfflinePlayer(buyBy);
BuyingRegionEvent buyingRegionEvent = new BuyingRegionEvent(buy, buyByPlayer);
Bukkit.getPluginManager().callEvent(buyingRegionEvent);
if(buyingRegionEvent.isCancelled()) {
regionsBuyCancelled.add(buy);
} else {
// Set the owner
buy.setBuyer(buyBy);
buy.updateLastActiveTime();
// Update everything
buy.handleSchematicEvent(GeneralRegion.RegionEvent.BOUGHT);
// Add others as friends
for (UUID friend : existing) {
buy.getFriendsFeature().addFriend(friend, null);
}
buy.notifyAndUpdate(new BoughtRegionEvent(buy));
}
}
regionsSuccess.add(buy);
}
}
}, false).thenAccept(
(success) -> {
if(!regionsSuccess.isEmpty()) {
plugin.message(sender, "add-success", args[1], Utils.combinedMessage(regionsSuccess, "region"));
}
if(!regionsAlready.isEmpty()) {
plugin.message(sender, "add-failed", Utils.combinedMessage(regionsAlready, "region"));
}
if(!regionsAlreadyOtherWorld.isEmpty()) {
plugin.message(sender, "add-failedOtherWorld", Utils.combinedMessage(regionsAlreadyOtherWorld, "region"));
}
if(!regionsRentCancelled.isEmpty()) {
plugin.message(sender, "add-rentCancelled", Utils.combinedMessage(regionsRentCancelled, "region"));
}
if(!regionsBuyCancelled.isEmpty()) {
plugin.message(sender, "add-buyCancelled", Utils.combinedMessage(regionsBuyCancelled, "region"));
}
if(!namesBlacklisted.isEmpty()) {
plugin.message(sender, "add-blacklisted", Utils.createCommaSeparatedList(namesBlacklisted));
}
if(!namesNoPermission.isEmpty()) {
plugin.message(sender, "add-noPermissionRegions", Utils.createCommaSeparatedList(namesNoPermission));
plugin.message(sender, "add-noPermissionOwnerMember");
}
if(!namesAddCancelled.isEmpty()) {
plugin.message(sender, "add-rentCancelled", Utils.createCommaSeparatedList(namesAddCancelled));
}
});
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new LinkedList<>();
if(toComplete == 2) {
if(sender.hasPermission("areashop.createrent")) {
result.add("rent");
}
if(sender.hasPermission("areashop.createbuy")) {
result.add("buy");
}
} else if(toComplete == 3) {
if(sender instanceof Player) {
Player player = (Player)sender;
if(sender.hasPermission("areashop.createrent") || sender.hasPermission("areashop.createbuy")) {
for(ProtectedRegion region : plugin.getRegionManager(player.getWorld()).getRegions().values()) {
result.add(region.getId());
}
}
}
}
return result;
}
}
@@ -0,0 +1,141 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class AddfriendCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop addfriend";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.addfriendall") || target.hasPermission("areashop.addfriend")) {
return "help-addFriend";
}
return null;
}
@SuppressWarnings("deprecation")
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.addfriend") && !sender.hasPermission("areashop.addfriendall")) {
plugin.message(sender, "addfriend-noPermission");
return;
}
if(args.length < 2) {
plugin.message(sender, "addfriend-help");
return;
}
GeneralRegion region;
if(args.length <= 2) {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
region = plugin.getFileManager().getRegion(args[2]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[2]);
return;
}
}
if(sender.hasPermission("areashop.addfriendall")) {
if((region instanceof RentRegion && !((RentRegion)region).isRented())
|| (region instanceof BuyRegion && !((BuyRegion)region).isSold())) {
plugin.message(sender, "addfriend-noOwner", region);
return;
}
OfflinePlayer friend = Bukkit.getOfflinePlayer(args[1]);
if(friend.getLastPlayed() == 0 && !friend.isOnline() && !plugin.getConfig().getBoolean("addFriendNotExistingPlayers")) {
plugin.message(sender, "addfriend-notVisited", args[1], region);
return;
}
if(region.getFriendsFeature().getFriends().contains(friend.getUniqueId())) {
plugin.message(sender, "addfriend-alreadyAdded", friend.getName(), region);
return;
}
if(region.isOwner(friend.getUniqueId())) {
plugin.message(sender, "addfriend-self", friend.getName(), region);
return;
}
if(region.getFriendsFeature().addFriend(friend.getUniqueId(), sender)) {
region.update();
plugin.message(sender, "addfriend-successOther", friend.getName(), region);
}
} else {
if(sender.hasPermission("areashop.addfriend") && sender instanceof Player) {
if(region.isOwner((Player)sender)) {
OfflinePlayer friend = Bukkit.getOfflinePlayer(args[1]);
if(friend.getLastPlayed() == 0 && !friend.isOnline() && !plugin.getConfig().getBoolean("addFriendNotExistingPlayers")) {
plugin.message(sender, "addfriend-notVisited", args[1], region);
return;
}
if(region.getFriendsFeature().getFriends().contains(friend.getUniqueId())) {
plugin.message(sender, "addfriend-alreadyAdded", friend.getName(), region);
return;
}
if(region.isOwner(friend.getUniqueId())) {
plugin.message(sender, "addfriend-self", friend.getName(), region);
return;
}
if(region.getFriendsFeature().addFriend(friend.getUniqueId(), sender)) {
region.update();
plugin.message(sender, "addfriend-success", friend.getName(), region);
}
} else {
plugin.message(sender, "addfriend-noPermissionOther", region);
}
} else {
plugin.message(sender, "addfriend-noPermission", region);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
} else if(toComplete == 3) {
result.addAll(plugin.getFileManager().getRegionNames());
}
return result;
}
}
@@ -0,0 +1,137 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.features.signs.RegionSign;
import me.wiefferink.areashop.features.signs.SignsFeature;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Materials;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.type.Sign;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.util.BlockIterator;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class AddsignCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop addsign";
}
@Override
public String getHelp(CommandSender target) {
if (target.hasPermission("areashop.addsign")) {
return "help-addsign";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if (!sender.hasPermission("areashop.addsign")) {
plugin.message(sender, "addsign-noPermission");
return;
}
if (!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player) sender;
// Get the sign
Block block = null;
BlockIterator blockIterator = new BlockIterator(player, 100);
while (blockIterator.hasNext() && block == null) {
Block next = blockIterator.next();
if (next.getType() != Material.AIR) {
block = next;
}
}
if (block == null || !Materials.isSign(block.getType())) {
plugin.message(sender, "addsign-noSign");
return;
}
GeneralRegion region;
if (args.length > 1) {
// Get region by argument
region = plugin.getFileManager().getRegion(args[1]);
if (region == null) {
plugin.message(sender, "cmd-notRegistered", args[1]);
return;
}
} else {
// Get region by sign position
List<GeneralRegion> regions = Utils.getImportantRegions(block.getLocation());
if (regions.isEmpty()) {
plugin.message(sender, "addsign-noRegions");
return;
} else if (regions.size() > 1) {
plugin.message(sender, "addsign-couldNotDetect", regions.get(0).getName(), regions.get(1).getName());
return;
}
region = regions.get(0);
}
String profile = null;
if (args.length > 2) {
profile = args[2];
Set<String> profiles = plugin.getConfig().getConfigurationSection("signProfiles").getKeys(false);
if (!profiles.contains(profile)) {
plugin.message(sender, "addsign-wrongProfile", Utils.createCommaSeparatedList(profiles), region);
return;
}
}
RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
if (regionSign != null) {
plugin.message(sender, "addsign-alreadyRegistered", regionSign.getRegion());
return;
}
final BlockData data = block.getBlockData();
final BlockFace rotation;
if (data instanceof Sign) {
rotation = ((Sign) data).getRotation();
} else if (data instanceof WallSign) {
rotation = ((WallSign) data).getFacing();
} else {
rotation = null;
}
region.getSignsFeature().addSign(block.getLocation(), block.getType(), rotation, profile);
if (profile == null) {
plugin.message(sender, "addsign-success", region);
} else {
plugin.message(sender, "addsign-successProfile", profile, region);
}
region.update();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if (toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if (toComplete == 3) {
result.addAll(plugin.getConfig().getStringList("signProfiles"));
}
return result;
}
}
@@ -1,74 +1,69 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.regions.BuyRegion;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
public class BuyCommand extends CommandAreaShop {
public BuyCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop buy";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.buy")) {
return plugin.getLanguageManager().getLang("help-buy");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if (!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
if(args.length > 1 && args[1] != null) {
BuyRegion region = plugin.getFileManager().getBuy(args[1]);
if(region == null) {
plugin.message(player, "buy-notBuyable");
} else {
region.buy(player);
}
} else {
// get the region by location
List<GeneralRegion> regions = plugin.getFileManager().getApplicalbeASRegions(player.getLocation());
if(regions.size() != 1) {
plugin.message(sender, "buy-help");
} else {
if(!regions.get(0).isBuyRegion()) {
plugin.message(sender, "buy-notBuyable");
} else {
((BuyRegion)regions.get(0)).buy(player);
}
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
ArrayList<String> result = new ArrayList<String>();
if(toComplete == 2) {
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(!region.isSold()) {
result.add(region.getName());
}
}
}
return result;
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class BuyCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop buy";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.buy")) {
return "help-buy";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.buy")) {
plugin.message(sender, "buy-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
if(args.length > 1 && args[1] != null) {
BuyRegion region = plugin.getFileManager().getBuy(args[1]);
if(region == null) {
plugin.message(player, "buy-notBuyable", args[1]);
} else {
region.buy(player);
}
} else {
// get the region by location
List<BuyRegion> regions = Utils.getImportantBuyRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
} else {
regions.get(0).buy(player);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(!region.isSold()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -0,0 +1,102 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.interactivemessenger.processing.Message;
import org.apache.commons.lang.StringUtils;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Abstract class for generalising command classes.
*/
public abstract class CommandAreaShop {
final AreaShop plugin = AreaShop.getInstance();
private final Map<String, CommandTime> lastUsed;
public CommandAreaShop() {
lastUsed = new HashMap<>();
}
/**
* Check if this Command instance can execute the given command and arguments.
* @param command The command to check for execution
* @param args The arguments to check
* @return true if it can execute the command, false otherwise
*/
public boolean canExecute(Command command, String[] args) {
String commandString = command.getName() + " " + StringUtils.join(args, " ");
if(commandString.length() > getCommandStart().length()) {
return commandString.toLowerCase().startsWith(getCommandStart().toLowerCase() + " ");
}
return commandString.toLowerCase().startsWith(getCommandStart().toLowerCase());
}
/**
* Get a list of string to complete a command with (raw list, not matching ones not filtered out).
* @param toComplete The number of the argument that has to be completed
* @param start The already given start of the command
* @param sender The CommandSender that wants to tab complete
* @return A collection with all the possibilities for argument to complete
*/
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
return new ArrayList<>();
}
/**
* Get the argument that comes after the base command that this command reacts to.
* @return The string that should be in front of the command for this class to act
*/
public abstract String getCommandStart();
/**
* Returns the correct help string key to be used on the help page.
* @param target The CommandSender that the help message is for
* @return The help message key according to the permissions of the reciever
*/
public abstract String getHelp(CommandSender target);
/**
* Execute a (sub)command if the conditions are met.
* @param sender The commandSender that executed the command
* @param args The arguments that are given
*/
public abstract void execute(CommandSender sender, String[] args);
/**
* Confirm a command.
* @param sender To confirm it for, or send a message to confirm
* @param args Command args
* @param message Message to send when confirmation is required
* @return true if confirmed, false if confirmation is required
*/
public boolean confirm(CommandSender sender, String[] args, Message message) {
String command = "/" + getCommandStart() + " " + StringUtils.join(args, " ", 1, args.length);
long now = System.currentTimeMillis();
CommandTime last = lastUsed.get(sender.getName());
if(last != null && last.command.equalsIgnoreCase(command) && last.time > (now - 1000 * 60)) {
return true;
}
message.prefix().append(Message.fromKey("confirm-yes").replacements(command)).send(sender);
lastUsed.put(sender.getName(), new CommandTime(command, now));
return false;
}
private class CommandTime {
public final String command;
public final long time;
CommandTime(String command, long time) {
this.command = command;
this.time = time;
}
}
}
@@ -0,0 +1,148 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.events.ask.DeletingRegionEvent;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
public class DelCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop del";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.destroyrent") || target.hasPermission("areashop.destroybuy") || target.hasPermission("areashop.destroyrent.landlord") || target.hasPermission("areashop.destroybuy.landlord")) {
return "help-del";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.destroybuy")
&& !sender.hasPermission("areashop.destroybuy.landlord")
&& !sender.hasPermission("areashop.destroyrent")
&& !sender.hasPermission("areashop.destroyrent.landlord")) {
plugin.message(sender, "del-noPermission");
return;
}
if(args.length < 2) {
// Only players can have a selection
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-weOnlyByPlayer");
return;
}
Player player = (Player)sender;
WorldEditSelection selection = plugin.getWorldEditHandler().getPlayerSelection(player);
if(selection == null) {
plugin.message(player, "cmd-noSelection");
return;
}
List<GeneralRegion> regions = Utils.getRegionsInSelection(selection);
if(regions.isEmpty()) {
plugin.message(player, "cmd-noRegionsFound");
return;
}
// Start removing the regions that he has permission for
ArrayList<String> namesSuccess = new ArrayList<>();
TreeSet<GeneralRegion> regionsFailed = new TreeSet<>();
TreeSet<GeneralRegion> regionsCancelled = new TreeSet<>();
for(GeneralRegion region : regions) {
boolean isLandlord = region.isLandlord(((Player)sender).getUniqueId());
if(region instanceof RentRegion) {
if(!sender.hasPermission("areashop.destroyrent") && !(isLandlord && sender.hasPermission("areashop.destroyrent.landlord"))) {
regionsFailed.add(region);
continue;
}
} else if(region instanceof BuyRegion) {
if(!sender.hasPermission("areashop.destroybuy") && !(isLandlord && sender.hasPermission("areashop.destroybuy.landlord"))) {
regionsFailed.add(region);
continue;
}
}
DeletingRegionEvent event = plugin.getFileManager().deleteRegion(region, true);
if (event.isCancelled()) {
regionsCancelled.add(region);
} else {
namesSuccess.add(region.getName());
}
}
// Send messages
if(!namesSuccess.isEmpty()) {
plugin.message(sender, "del-success", Utils.createCommaSeparatedList(namesSuccess));
}
if(!regionsFailed.isEmpty()) {
plugin.message(sender, "del-failed", Utils.combinedMessage(regionsFailed, "region"));
}
if(!regionsCancelled.isEmpty()) {
plugin.message(sender, "del-cancelled", Utils.combinedMessage(regionsCancelled, "region"));
}
} else {
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[1]);
return;
}
boolean isLandlord = sender instanceof Player && region.isLandlord(((Player)sender).getUniqueId());
if(region instanceof RentRegion) {
// Remove the rent if the player has permission
if(sender.hasPermission("areashop.destroyrent") || (isLandlord && sender.hasPermission("areashop.destroyrent.landlord"))) {
DeletingRegionEvent event = plugin.getFileManager().deleteRegion(region, true);
if (event.isCancelled()) {
plugin.message(sender, "general-cancelled", event.getReason());
} else {
plugin.message(sender, "destroy-successRent", region);
}
} else {
plugin.message(sender, "destroy-noPermissionRent", region);
}
} else if(region instanceof BuyRegion) {
// Remove the buy if the player has permission
if(sender.hasPermission("areashop.destroybuy") || (isLandlord && sender.hasPermission("areashop.destroybuy.landlord"))) {
DeletingRegionEvent event = plugin.getFileManager().deleteRegion(region, true);
if (event.isCancelled()) {
plugin.message(sender, "general-cancelled", event.getReason());
} else {
plugin.message(sender, "destroy-successBuy", region);
}
} else {
plugin.message(sender, "destroy-noPermissionBuy", region);
}
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result = plugin.getFileManager().getRegionNames();
}
return result;
}
}
@@ -0,0 +1,139 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class DelfriendCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop delfriend";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.delfriendall") || target.hasPermission("areashop.delfriend")) {
return "help-delFriend";
}
return null;
}
/**
* Check if a person can remove friends.
* @param person The person to check
* @param region The region to check for
* @return true if the person can remove friends, otherwise false
*/
public static boolean canUse(CommandSender person, GeneralRegion region) {
if(person.hasPermission("areashop.delfriendall")) {
return true;
}
if(person instanceof Player) {
Player player = (Player)person;
return region.isOwner(player) && player.hasPermission("areashop.delfriend");
}
return false;
}
@SuppressWarnings("deprecation")
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.delfriend") && !sender.hasPermission("areashop.delfriendall")) {
plugin.message(sender, "delfriend-noPermission");
return;
}
if(args.length < 2) {
plugin.message(sender, "delfriend-help");
return;
}
GeneralRegion region;
if(args.length <= 2) {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
region = plugin.getFileManager().getRegion(args[2]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[2]);
return;
}
}
if(sender.hasPermission("areashop.delfriendall")) {
if((region instanceof RentRegion && !((RentRegion)region).isRented())
|| (region instanceof BuyRegion && !((BuyRegion)region).isSold())) {
plugin.message(sender, "delfriend-noOwner", region);
return;
}
OfflinePlayer friend = Bukkit.getOfflinePlayer(args[1]);
if(!region.getFriendsFeature().getFriends().contains(friend.getUniqueId())) {
plugin.message(sender, "delfriend-notAdded", friend.getName(), region);
return;
}
if(region.getFriendsFeature().deleteFriend(friend.getUniqueId(), sender)) {
region.update();
plugin.message(sender, "delfriend-successOther", friend.getName(), region);
}
} else {
if(sender.hasPermission("areashop.delfriend") && sender instanceof Player) {
if(region.isOwner((Player)sender)) {
OfflinePlayer friend = Bukkit.getOfflinePlayer(args[1]);
if(!region.getFriendsFeature().getFriends().contains(friend.getUniqueId())) {
plugin.message(sender, "delfriend-notAdded", friend.getName(), region);
return;
}
if(region.getFriendsFeature().deleteFriend(friend.getUniqueId(), sender)) {
region.update();
plugin.message(sender, "delfriend-success", friend.getName(), region);
}
} else {
plugin.message(sender, "delfriend-noPermissionOther", region);
}
} else {
plugin.message(sender, "delfriend-noPermission", region);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
} else if(toComplete == 3) {
result.addAll(plugin.getFileManager().getRegionNames());
}
return result;
}
}
@@ -1,85 +1,79 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.util.BlockIterator;
public class DelsignCommand extends CommandAreaShop {
public DelsignCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop delsign";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.delsign")) {
return plugin.getLanguageManager().getLang("help-delsign");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if (!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
if(!player.hasPermission("areashop.delsign")) {
plugin.message(sender, "delsign-noPermission");
return;
}
// Get the sign
Block block = null;
BlockIterator blockIterator = new BlockIterator(player, 100);
while(blockIterator.hasNext() && block == null) {
Block next = blockIterator.next();
if(next.getType() != Material.AIR) {
block = next;
}
}
if(block == null || !(block.getType() == Material.WALL_SIGN || block.getType() == Material.SIGN_POST)) {
plugin.message(sender, "delsign-noSign");
return;
}
GeneralRegion region = plugin.getFileManager().getRegionBySignLocation(block.getLocation());
if(region == null) {
plugin.message(sender, "delsign-noRegion");
return;
}
plugin.message(sender, "delsign-success", region.getName());
region.removeSign(block.getLocation());
region.updateSigns();
region.save();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
return new ArrayList<String>();
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.features.signs.RegionSign;
import me.wiefferink.areashop.features.signs.SignsFeature;
import me.wiefferink.areashop.tools.Materials;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.util.BlockIterator;
import java.util.ArrayList;
import java.util.List;
public class DelsignCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop delsign";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.delsign")) {
return "help-delsign";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.delsign")) {
plugin.message(sender, "delsign-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
// Get the sign
Block block = null;
BlockIterator blockIterator = new BlockIterator(player, 100);
while(blockIterator.hasNext() && block == null) {
Block next = blockIterator.next();
if(next.getType() != Material.AIR) {
block = next;
}
}
if(block == null || !Materials.isSign(block.getType())) {
plugin.message(sender, "delsign-noSign");
return;
}
RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
if(regionSign == null) {
plugin.message(sender, "delsign-noRegion");
return;
}
plugin.message(sender, "delsign-success", regionSign.getRegion());
regionSign.remove();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
return new ArrayList<>();
}
}
@@ -0,0 +1,191 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
public class FindCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop find";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.find")) {
return "help-find";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.find")) {
plugin.message(sender, "find-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
if(args.length <= 1 || args[1] == null || (!args[1].equalsIgnoreCase("buy") && !args[1].equalsIgnoreCase("rent"))) {
plugin.message(sender, "find-help");
return;
}
Player player = (Player)sender;
double balance = 0.0;
if(plugin.getEconomy() != null) {
balance = plugin.getEconomy().getBalance(player);
}
double maxPrice = 0;
boolean maxPriceSet = false;
RegionGroup group = null;
// Parse optional price argument
if(args.length >= 3) {
try {
maxPrice = Double.parseDouble(args[2]);
maxPriceSet = true;
} catch(NumberFormatException e) {
plugin.message(sender, "find-wrongMaxPrice", args[2]);
return;
}
}
// Parse optional group argument
if(args.length >= 4) {
group = plugin.getFileManager().getGroup(args[3]);
if(group == null) {
plugin.message(sender, "find-wrongGroup", args[3]);
return;
}
}
// Find buy regions
if(args[1].equalsIgnoreCase("buy")) {
List<BuyRegion> regions = plugin.getFileManager().getBuys();
List<BuyRegion> results = new ArrayList<>();
for(BuyRegion region : regions) {
if(!region.isSold()
&& ((region.getPrice() <= balance && !maxPriceSet) || (region.getPrice() <= maxPrice && maxPriceSet))
&& (group == null || group.isMember(region))
&& (region.getBooleanSetting("general.findCrossWorld") || player.getWorld().equals(region.getWorld()))) {
results.add(region);
}
}
if(!results.isEmpty()) {
// Draw a random one
BuyRegion region = results.get(ThreadLocalRandom.current().nextInt(results.size()));
Message onlyInGroup = Message.empty();
if(group != null) {
onlyInGroup = Message.fromKey("find-onlyInGroup").replacements(args[3]);
}
// Teleport
if(maxPriceSet) {
plugin.message(player, "find-successMax", "buy", Utils.formatCurrency(maxPrice), onlyInGroup, region);
} else {
plugin.message(player, "find-success", "buy", Utils.formatCurrency(balance), onlyInGroup, region);
}
region.getTeleportFeature().teleportPlayer(player, region.getBooleanSetting("general.findTeleportToSign"), false);
} else {
Message onlyInGroup = Message.empty();
if(group != null) {
onlyInGroup = Message.fromKey("find-onlyInGroup").replacements(args[3]);
}
if(maxPriceSet) {
plugin.message(player, "find-noneFoundMax", "buy", Utils.formatCurrency(maxPrice), onlyInGroup);
} else {
plugin.message(player, "find-noneFound", "buy", Utils.formatCurrency(balance), onlyInGroup);
}
}
}
// Find rental regions
else {
List<RentRegion> regions = plugin.getFileManager().getRents();
List<RentRegion> results = new ArrayList<>();
for(RentRegion region : regions) {
if(!region.isRented()
&& ((region.getPrice() <= balance && !maxPriceSet) || (region.getPrice() <= maxPrice && maxPriceSet))
&& (group == null || group.isMember(region))
&& (region.getBooleanSetting("general.findCrossWorld") || player.getWorld().equals(region.getWorld()))) {
results.add(region);
}
}
if(!results.isEmpty()) {
// Draw a random one
RentRegion region = results.get(ThreadLocalRandom.current().nextInt(results.size()));
Message onlyInGroup = Message.empty();
if(group != null) {
onlyInGroup = Message.fromKey("find-onlyInGroup").replacements(args[3]);
}
// Teleport
if(maxPriceSet) {
plugin.message(player, "find-successMax", "rent", Utils.formatCurrency(maxPrice), onlyInGroup, region);
} else {
plugin.message(player, "find-success", "rent", Utils.formatCurrency(balance), onlyInGroup, region);
}
region.getTeleportFeature().teleportPlayer(player, region.getBooleanSetting("general.findTeleportToSign"), false);
} else {
Message onlyInGroup = Message.empty();
if(group != null) {
onlyInGroup = Message.fromKey("find-onlyInGroup").replacements(args[3]);
}
if(maxPriceSet) {
plugin.message(player, "find-noneFoundMax", "rent", Utils.formatCurrency(maxPrice), onlyInGroup);
} else {
plugin.message(player, "find-noneFound", "rent", Utils.formatCurrency(balance), onlyInGroup);
}
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
result.add("buy");
result.add("rent");
}
return result;
}
}
@@ -1,117 +1,113 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.Utils;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion;
import nl.evolutioncoding.AreaShop.regions.RegionGroup;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import com.sk89q.worldedit.bukkit.selections.Selection;
public class GroupaddCommand extends CommandAreaShop {
public GroupaddCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop groupadd";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.groupadd")) {
return plugin.getLanguageManager().getLang("help-groupadd");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if(!sender.hasPermission("areashop.groupadd")) {
plugin.message(sender, "groupadd-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "groupadd-help");
return;
}
RegionGroup group = plugin.getFileManager().getGroup(args[1]);
if(group == null) {
group = new RegionGroup(plugin, args[1]);
plugin.getFileManager().addGroup(group);
}
if(args.length == 2) {
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-weOnlyByPlayer");
return;
}
Player player = (Player)sender;
Selection selection = plugin.getWorldEdit().getSelection(player);
if(selection == null) {
plugin.message(player, "cmd-noSelection");
return;
}
List<GeneralRegion> regions = plugin.getFileManager().getASRegionsInSelection(selection);
if(regions.size() == 0) {
plugin.message(player, "cmd-noRegionsFound");
return;
}
ArrayList<String> namesSuccess = new ArrayList<String>();
ArrayList<String> namesFailed = new ArrayList<String>();
for(GeneralRegion region : regions) {
if(group.addMember(region)) {
namesSuccess.add(region.getName());
} else {
namesFailed.add(region.getName());
}
}
if(namesSuccess.size() != 0) {
plugin.message(player, "groupadd-weSuccess", group.getName(), Utils.createCommaSeparatedList(namesSuccess));
}
if(namesFailed.size() != 0) {
plugin.message(player, "groupadd-weFailed", group.getName(), Utils.createCommaSeparatedList(namesFailed));
}
} else {
GeneralRegion region = plugin.getFileManager().getRegion(args[2]);
if(region == null) {
plugin.message(sender, "groupadd-noRegion", args[2]);
return;
}
if(group.addMember(region)) {
plugin.message(sender, "groupadd-success", region.getName(), group.getName(), group.getMembers().size());
} else {
plugin.message(sender, "groupadd-failed", region.getName(), group.getName());
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
List<String> result = new ArrayList<String>();
if(toComplete == 2) {
result = plugin.getFileManager().getGroupNames();
} else if(toComplete == 3) {
result = plugin.getFileManager().getRegionNames();
}
return result;
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
public class GroupaddCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop groupadd";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.groupadd")) {
return "help-groupadd";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.groupadd")) {
plugin.message(sender, "groupadd-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "groupadd-help");
return;
}
RegionGroup group = plugin.getFileManager().getGroup(args[1]);
if(group == null) {
group = new RegionGroup(plugin, args[1]);
plugin.getFileManager().addGroup(group);
}
if(args.length == 2) {
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-weOnlyByPlayer");
return;
}
Player player = (Player)sender;
WorldEditSelection selection = plugin.getWorldEditHandler().getPlayerSelection(player);
if(selection == null) {
plugin.message(player, "cmd-noSelection");
return;
}
List<GeneralRegion> regions = Utils.getRegionsInSelection(selection);
if(regions.isEmpty()) {
plugin.message(player, "cmd-noRegionsFound");
return;
}
TreeSet<GeneralRegion> regionsSuccess = new TreeSet<>();
TreeSet<GeneralRegion> regionsFailed = new TreeSet<>();
for(GeneralRegion region : regions) {
if(group.addMember(region)) {
regionsSuccess.add(region);
} else {
regionsFailed.add(region);
}
}
if(!regionsSuccess.isEmpty()) {
plugin.message(player, "groupadd-weSuccess", group.getName(), Utils.combinedMessage(regionsSuccess, "region"));
}
if(!regionsFailed.isEmpty()) {
plugin.message(player, "groupadd-weFailed", group.getName(), Utils.combinedMessage(regionsFailed, "region"));
}
// Update all regions, this does it in a task, updating them without lag
plugin.getFileManager().updateRegions(new ArrayList<>(regionsSuccess), player);
} else {
GeneralRegion region = plugin.getFileManager().getRegion(args[2]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[2]);
return;
}
if(group.addMember(region)) {
region.update();
plugin.message(sender, "groupadd-success", group.getName(), group.getMembers().size(), region);
} else {
plugin.message(sender, "groupadd-failed", group.getName(), region);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result = plugin.getFileManager().getGroupNames();
} else if(toComplete == 3) {
result = plugin.getFileManager().getRegionNames();
}
return result;
}
}
@@ -0,0 +1,115 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.TreeSet;
public class GroupdelCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop groupdel";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.groupdel")) {
return "help-groupdel";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.groupdel")) {
plugin.message(sender, "groupdel-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "groupdel-help");
return;
}
RegionGroup group = plugin.getFileManager().getGroup(args[1]);
if(group == null) {
plugin.message(sender, "groupdel-wrongGroup", args[1]);
return;
}
if(args.length == 2) {
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-weOnlyByPlayer");
return;
}
Player player = (Player)sender;
WorldEditSelection selection = plugin.getWorldEditHandler().getPlayerSelection(player);
if(selection == null) {
plugin.message(player, "cmd-noSelection");
return;
}
List<GeneralRegion> regions = Utils.getRegionsInSelection(selection);
if(regions.isEmpty()) {
plugin.message(player, "cmd-noRegionsFound");
return;
}
TreeSet<GeneralRegion> regionsSuccess = new TreeSet<>();
TreeSet<GeneralRegion> regionsFailed = new TreeSet<>();
for(GeneralRegion region : regions) {
if(group.removeMember(region)) {
regionsSuccess.add(region);
} else {
regionsFailed.add(region);
}
}
if(!regionsSuccess.isEmpty()) {
plugin.message(player, "groupdel-weSuccess", group.getName(), Utils.combinedMessage(regionsSuccess, "region"));
}
if(!regionsFailed.isEmpty()) {
plugin.message(player, "groupdel-weFailed", group.getName(), Utils.combinedMessage(regionsFailed, "region"));
}
// Update all regions, this does it in a task, updating them without lag
plugin.getFileManager().updateRegions(new ArrayList<>(regionsSuccess), player);
group.saveRequired();
} else {
GeneralRegion region = plugin.getFileManager().getRegion(args[2]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[2]);
return;
}
if(group.removeMember(region)) {
region.update();
plugin.message(sender, "groupdel-success", group.getName(), group.getMembers().size(), region);
} else {
plugin.message(sender, "groupdel-failed", group.getName(), region);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result = plugin.getFileManager().getGroupNames();
} else if(toComplete == 3) {
result = plugin.getFileManager().getRegionNames();
}
return result;
}
}
@@ -1,75 +1,69 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.Utils;
import nl.evolutioncoding.AreaShop.regions.RegionGroup;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
public class GroupinfoCommand extends CommandAreaShop {
public GroupinfoCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop groupinfo";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.groupinfo")) {
return plugin.getLanguageManager().getLang("help-groupinfo");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if(!sender.hasPermission("areashop.groupinfo")) {
plugin.message(sender, "groupinfo-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "groupinfo-help");
return;
}
RegionGroup group = plugin.getFileManager().getGroup(args[1]);
if(group == null) {
plugin.message(sender, "groupinfo-noGroup", args[1]);
return;
}
List<String> members = group.getMembers();
if(members.size() == 0) {
plugin.message(sender, "groupinfo-noMembers", group.getName());
} else {
plugin.message(sender, "groupinfo-members", group.getName(), Utils.createCommaSeparatedList(members));
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
List<String> result = new ArrayList<String>();
if(toComplete == 2) {
result = plugin.getFileManager().getGroupNames();
}
return result;
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class GroupinfoCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop groupinfo";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.groupinfo")) {
return "help-groupinfo";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.groupinfo")) {
plugin.message(sender, "groupinfo-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "groupinfo-help");
return;
}
RegionGroup group = plugin.getFileManager().getGroup(args[1]);
if(group == null) {
plugin.message(sender, "groupinfo-noGroup", args[1]);
return;
}
Set<String> members = group.getMembers();
if(members.isEmpty()) {
plugin.message(sender, "groupinfo-noMembers", group.getName());
} else {
plugin.message(sender, "groupinfo-members", group.getName(), Utils.createCommaSeparatedList(members));
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result = plugin.getFileManager().getGroupNames();
}
return result;
}
}
@@ -1,60 +1,53 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.Utils;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
public class GrouplistCommand extends CommandAreaShop {
public GrouplistCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop grouplist";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.grouplist")) {
return plugin.getLanguageManager().getLang("help-grouplist");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if(!sender.hasPermission("areashop.grouplist")) {
plugin.message(sender, "grouplist-noPermission");
return;
}
List<String> groups = plugin.getFileManager().getGroupNames();
if(groups.size() == 0) {
plugin.message(sender, "grouplist-noGroups");
} else {
plugin.message(sender, "grouplist-success", Utils.createCommaSeparatedList(groups));
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
return new ArrayList<String>();
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.List;
public class GrouplistCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop grouplist";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.grouplist")) {
return "help-grouplist";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.grouplist")) {
plugin.message(sender, "grouplist-noPermission");
return;
}
List<String> groups = plugin.getFileManager().getGroupNames();
if(groups.isEmpty()) {
plugin.message(sender, "grouplist-noGroups");
} else {
plugin.message(sender, "grouplist-success", Utils.createCommaSeparatedList(groups));
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
return new ArrayList<>();
}
}
@@ -0,0 +1,24 @@
package me.wiefferink.areashop.commands;
import org.bukkit.command.CommandSender;
public class HelpCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop help";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.help")) {
return "help-help";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
plugin.getCommandManager().showHelp(sender);
}
}
@@ -0,0 +1,79 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.List;
public class ImportCommand extends CommandAreaShop {
/* RegionGroup priority usage:
0: Settings from /config.yml
1: Settings from /worlds/<world>/config.yml
2: Settings from /worlds/<world>/parent-regions.yml (if their priority is set it is added to this value)
*/
@Override
public String getCommandStart() {
return "areashop import";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.import")) {
return "help-import";
}
return null;
}
// TODO:
// - Landlord?
// - Friends
// - Region flags?
// - Settings from the 'permissions' section in RegionForSale/config.yml?
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.import")) {
plugin.message(sender, "import-noPermission");
return;
}
if(args.length < 2) {
plugin.message(sender, "import-help");
return;
}
if(!"RegionForSale".equalsIgnoreCase(args[1])) {
plugin.message(sender, "import-wrongSource");
return;
}
if(!confirm(sender, args, Message.fromKey("import-confirm"))) {
return;
}
new ImportJob(sender);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result.add("RegionForSale");
}
return result;
}
}
@@ -0,0 +1,481 @@
package me.wiefferink.areashop.commands;
import com.google.common.base.Charsets;
import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.AddingRegionEvent;
import me.wiefferink.areashop.features.signs.RegionSign;
import me.wiefferink.areashop.features.signs.SignsFeature;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.regions.RentRegion;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.command.ConsoleCommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
public class ImportJob {
private final AreaShop plugin;
private final CommandSender sender;
/**
* Create and execute the import.
* @param sender CommandSender that should receive progress updates
*/
public ImportJob(CommandSender sender) {
this.sender = sender;
this.plugin = AreaShop.getInstance();
execute();
}
/**
* Execute the job.
*/
private void execute() {
// Check for RegionForSale data
File regionForSaleFolder = new File(plugin.getDataFolder().getParentFile().getAbsolutePath(), "RegionForSale");
if(!regionForSaleFolder.exists()) {
message("import-noPluginFolder", regionForSaleFolder.getName());
return;
}
File worldsFolder = new File(regionForSaleFolder.getAbsolutePath(), "worlds");
if(!worldsFolder.exists()) {
message("import-noWorldsFolder");
return;
}
File[] worldFolders = worldsFolder.listFiles();
if(worldFolders == null) {
message("import-noWorldsFolder");
return;
}
// Import data for each world
message("import-start");
// Group with settings for all imported regions
RegionGroup regionForSaleGroup = new RegionGroup(plugin, "RegionForSale");
plugin.getFileManager().addGroup(regionForSaleGroup);
// Import /RegionForSale/config.yml settings
File regionForSaleConfigFile = new File(regionForSaleFolder.getAbsolutePath(), "config.yml");
YamlConfiguration regionForSaleConfig = loadConfiguration(regionForSaleConfigFile);
if(regionForSaleConfig == null) {
messageNoPrefix("import-loadConfigFailed", regionForSaleConfigFile.getAbsolutePath());
regionForSaleConfig = new YamlConfiguration();
} else {
importRegionSettings(regionForSaleConfig, regionForSaleGroup.getSettings(), null, false);
regionForSaleGroup.setSetting("priority", 0);
}
// Import /RegionForSale/general.yml settings
File regionForSaleGeneralFile = new File(regionForSaleFolder.getAbsolutePath(), "config.yml");
YamlConfiguration regionForSaleGeneral = loadConfiguration(regionForSaleConfigFile);
if(regionForSaleGeneral == null) {
messageNoPrefix("import-loadConfigFailed", regionForSaleGeneralFile.getAbsolutePath());
} else {
// Collection interval of RegionForSale maps to rent duration
String duration = "1 day";
if(regionForSaleGeneral.isLong("interval.collect_money")) {
duration = minutesToString(regionForSaleGeneral.getLong("interval.collect_money"));
}
regionForSaleGroup.setSetting("rent.duration", duration);
// Global economy account has an effect close to landlord in AreaShop
if(regionForSaleGeneral.isString("global_econ_account")) {
regionForSaleGroup.setSetting("general.landlordName", regionForSaleGeneral.getString("global_econ_account"));
}
}
regionForSaleGroup.saveRequired();
////////// Handle defaults of RegionForSale
// Set autoExtend, to keep the same behavior as RegionForSale had
regionForSaleGroup.setSetting("rent.autoExtend", true);
// Import regions from each world
for(File worldFolder : worldFolders) {
// Skip files
if(!worldFolder.isDirectory() || worldFolder.isHidden()) {
continue;
}
messageNoPrefix("import-doWorld", worldFolder.getName());
// Get the Bukkit world
World world = Bukkit.getWorld(worldFolder.getName());
if(world == null) {
messageNoPrefix("import-noBukkitWorld");
continue;
}
// Get the WorldGuard RegionManager
RegionManager regionManager = plugin.getRegionManager(world);
if(regionManager == null) {
messageNoPrefix("import-noRegionManger");
continue;
}
// Load the /worlds/<world>/regions.yml file
File regionsFile = new File(worldFolder.getAbsolutePath(), "regions.yml");
YamlConfiguration regions = loadConfiguration(regionsFile);
if(regions == null) {
messageNoPrefix("import-loadRegionsFailed", regionsFile.getAbsolutePath());
continue;
}
// Load /worlds/<world>/config.yml file
File worldConfigFile = new File(worldFolder.getAbsolutePath(), "config.yml");
YamlConfiguration worldConfig = loadConfiguration(worldConfigFile);
if(worldConfig == null) {
messageNoPrefix("import-loadWorldConfigFailed", worldConfigFile.getAbsolutePath());
// Simply skip importing the settings, since this is not really fatal
worldConfig = new YamlConfiguration();
} else {
// RegionGroup with all world settings
RegionGroup worldGroup = new RegionGroup(plugin, "RegionForSale-" + worldFolder.getName());
importRegionSettings(worldConfig, worldGroup.getSettings(), null, false);
worldGroup.setSetting("priority", 1);
worldGroup.addWorld(worldFolder.getName());
plugin.getFileManager().addGroup(regionForSaleGroup);
worldGroup.saveRequired();
}
// Create groups to hold settings of /worlds/<world>/parent-regions.yml
File parentRegionsFile = new File(worldFolder.getAbsolutePath(), "parent-regions.yml");
YamlConfiguration parentRegions = loadConfiguration(parentRegionsFile);
if(parentRegions == null) {
messageNoPrefix("import-loadParentRegionsFailed", parentRegionsFile.getAbsolutePath());
// Non-fatal, so just continue
} else {
for(String parentRegionName : parentRegions.getKeys(false)) {
// Get WorldGuard region
ProtectedRegion worldGuardRegion = regionManager.getRegion(parentRegionName);
if(worldGuardRegion == null) {
messageNoPrefix("import-noWorldGuardRegionParent", parentRegionName);
continue;
}
// Get settings section
ConfigurationSection parentRegionSection = parentRegions.getConfigurationSection(parentRegionName);
if(parentRegionSection == null) {
messageNoPrefix("import-improperParentRegion", parentRegionName);
continue;
}
// Skip if it does not have any settings
if(parentRegionSection.getKeys(false).isEmpty()) {
continue;
}
// Import parent region settings into a RegionGroup
RegionGroup parentRegionGroup = new RegionGroup(plugin, "RegionForSale-" + worldFolder.getName() + "-" + parentRegionName);
importRegionSettings(parentRegionSection, parentRegionGroup.getSettings(), null, false);
parentRegionGroup.setSetting("priority", 2 + parentRegionSection.getLong("info.priority", 0));
parentRegionGroup.saveRequired();
// TODO add all regions that are contained in this parent region
// Utils.getWorldEditRegionsInSelection()
}
}
// Read and import regions
for(String regionKey : regions.getKeys(false)) {
GeneralRegion existingRegion = plugin.getFileManager().getRegion(regionKey);
if(existingRegion != null) {
if(world.getName().equalsIgnoreCase(existingRegion.getWorldName())) {
messageNoPrefix("import-alreadyAdded", regionKey);
} else {
messageNoPrefix("import-alreadyAddedOtherWorld", regionKey, existingRegion.getWorldName(), world.getName());
}
continue;
}
ConfigurationSection regionSection = regions.getConfigurationSection(regionKey);
if(regionSection == null) {
messageNoPrefix("import-invalidRegionSection", regionKey);
continue;
}
// Get WorldGuard region
ProtectedRegion worldGuardRegion = regionManager.getRegion(regionKey);
if(worldGuardRegion == null) {
messageNoPrefix("import-noWorldGuardRegion", regionKey);
continue;
}
String owner = regionSection.getString("info.owner", null);
boolean isBought = regionSection.getBoolean("info.is-bought");
// TODO: should also take into config settings of parent regions
boolean rentable = regionSection.getBoolean("economic-settings.rentable", worldConfig.getBoolean("economic-settings.rentable", regionForSaleConfig.getBoolean("economic-settings.rentable")));
boolean buyable = regionSection.getBoolean("economic-settings.buyable", worldConfig.getBoolean("economic-settings.buyable", regionForSaleConfig.getBoolean("economic-settings.buyable")));
// Can be bought and rented, import as buy
if(buyable && rentable) {
messageNoPrefix("import-buyAndRent", regionKey);
}
// Cannot be bought or rented, skip
if(!buyable && !rentable && owner == null) {
messageNoPrefix("import-noBuyAndNoRent", regionKey);
continue;
}
// Create region
GeneralRegion region;
if(rentable || (owner != null && !isBought)) {
region = new RentRegion(regionKey, world);
} else {
region = new BuyRegion(regionKey, world);
}
AddingRegionEvent event = plugin.getFileManager().addRegion(region);
if (event.isCancelled()) {
messageNoPrefix("general-cancelled", event.getReason());
continue;
}
// Import settings
importRegionSettings(regionSection, region.getConfig(), region, !buyable && !rentable);
region.getConfig().set("general.importedFrom", "RegionForSale");
// Get existing owners and members
List<UUID> existing = new ArrayList<>();
if(owner != null) {
@SuppressWarnings("deprecation")
OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(owner);
if(offlinePlayer != null) {
existing.add(offlinePlayer.getUniqueId());
}
}
for(UUID uuid : plugin.getWorldGuardHandler().getOwners(worldGuardRegion).asUniqueIdList()) {
if(!existing.contains(uuid)) {
existing.add(uuid);
}
}
for(UUID uuid : plugin.getWorldGuardHandler().getMembers(worldGuardRegion).asUniqueIdList()) {
if(!existing.contains(uuid)) {
existing.add(uuid);
}
}
// First owner (or if none, the first member) will be the renter/buyer
if(!existing.isEmpty()) {
region.setOwner(existing.remove(0));
}
// Add others as friends
for(UUID friend : existing) {
region.getFriendsFeature().addFriend(friend, null);
}
region.saveRequired();
messageNoPrefix("import-imported", regionKey);
}
}
// Update all regions
plugin.getFileManager().updateAllRegions(sender);
// Write all imported regions and settings to disk
plugin.getFileManager().saveRequiredFiles();
}
/**
* Load a YamlConfiguration from disk using UTF-8 encoding.
* @param from File to read the configuration from
* @return YamlConfiguration if the file exists and got read wihout problems, otherwise null
*/
private YamlConfiguration loadConfiguration(File from) {
try(
InputStreamReader reader = new InputStreamReader(new FileInputStream(from), Charsets.UTF_8)
) {
return YamlConfiguration.loadConfiguration(reader);
} catch(IOException e) {
return null;
}
}
/**
* Import region specific settings from a RegionForSale source to an AreaShop target ConfigurationSection.
* @param from RegionForSale config section that specifies region settings
* @param to AreaShop config section that specifies region settings
* @param region GeneralRegion to copy settings to, or null if doing generic settings
* @param permanent Region cannot be rented or bought, disables some features
*/
private void importRegionSettings(ConfigurationSection from, ConfigurationSection to, GeneralRegion region, boolean permanent) {
// Maximum rental time, TODO check if this is actually the same
if(from.isLong("permissions.max-rent-time")) {
to.set("rent.maxRentTime", minutesToString(from.getLong("permissions.max-rent-time")));
}
// Region rebuild
if(from.getBoolean("region-rebuilding.auto-rebuild")) {
to.set("general.enableRestore", true);
}
// Get price settings
String unit = from.getString("economic-settings.unit-type");
String rentPrice = from.getString("economic-settings.cost-per-unit.rent");
String buyPrice = from.getString("economic-settings.cost-per-unit.buy");
String sellPrice = from.getString("economic-settings.cost-per-unit.selling-price");
// TODO: There is no easy way to import this, setup eventCommandsProfile?
// String taxes = from.getString("economic-settings.cost-per-unit.taxes");
// Determine unit and add that to the price
String unitSuffix = "";
if("region".equalsIgnoreCase(unit)) {
// add nothing
} else if("m3".equalsIgnoreCase(unit)) {
unitSuffix = "*%volume%";
} else { // m2 or nothing (in case not set, we should actually look in parent files to correctly set this...)
unitSuffix = "*(%volume%/%height%)"; // This is better than width*depth because of polygon regions
}
// Apply settings
if(rentPrice != null) {
to.set("rent.price", rentPrice + unitSuffix);
}
if(buyPrice != null) {
to.set("buy.price", buyPrice + unitSuffix);
if(sellPrice != null) {
try {
double buyPriceAmount = Double.parseDouble(buyPrice);
double sellPriceAmount = Double.parseDouble(sellPrice);
to.set("buy.moneyBack", sellPriceAmount / buyPriceAmount * 100);
} catch(NumberFormatException e) {
// There is not always a region here for the message, should probably indicate something though
message("import-moneyBackFailed", buyPrice, sellPrice);
}
}
}
// Apply permanent region settings
if(permanent) {
to.set("buy.resellDisabled", true);
to.set("buy.sellDisabled", true);
to.set("general.countForLimits", false);
}
// Set rented until
if(from.isLong("info.last-withdrawal")
&& region instanceof RentRegion) {
RentRegion rentRegion = (RentRegion)region;
long lastWithdrawal = from.getLong("info.last-withdrawal");
// Because the rental duration is already imported into the region and its parents this should be correct
rentRegion.setRentedUntil(lastWithdrawal + rentRegion.getDuration());
}
// Import signs (list of strings like "297, 71, -22")
if(from.isList("info.signs") && region != null) {
for(String signLocation : from.getStringList("info.signs")) {
String[] locationParts = signLocation.split(", ");
if(locationParts.length != 3) {
message("import-invalidSignLocation", region.getName(), signLocation);
continue;
}
// Parse the location
Location location;
try {
location = new Location(region.getWorld(), Double.parseDouble(locationParts[0]), Double.parseDouble(locationParts[1]), Double.parseDouble(locationParts[2]));
} catch(NumberFormatException e) {
message("import-invalidSignLocation", region.getName(), signLocation);
continue;
}
// Check if this location is already added to a region
RegionSign regionSign = SignsFeature.getSignByLocation(location);
if(regionSign != null) {
if(!regionSign.getRegion().equals(region)) {
message("import-signAlreadyAdded", region.getName(), signLocation, regionSign.getRegion().getName());
}
continue;
}
// SignType and Facing will be written when the sign is updated later
region.getSignsFeature().addSign(location, null, null, null);
}
}
}
private static class TimeUnit {
public final long minutes;
public final String identifier;
TimeUnit(long minutes, String identifier) {
this.minutes = minutes;
this.identifier = identifier;
}
}
private static final List<TimeUnit> timeUnitLookup = new ArrayList<TimeUnit>() {
{
add(new TimeUnit(60 * 24 * 30 * 12, "year"));
add(new TimeUnit(60 * 24 * 30, "month"));
add(new TimeUnit(60 * 24, "day"));
add(new TimeUnit(60, "hour"));
}
};
/**
* Convert minutes to a human-readable string.
* @param minutes Value to convert
* @return String that represents the same length of time in a readable format, like "1 day", "5 minutes", "3 months"
*/
private String minutesToString(long minutes) {
// If the specified number of minutes can map nicely to a higher unit, use that one
String resultUnit = "minute";
long resultValue = minutes;
for(TimeUnit unit : timeUnitLookup) {
long result = minutes / unit.minutes;
if(resultValue * unit.minutes == minutes) {
resultUnit = unit.identifier;
resultValue = result;
break;
}
}
return resultValue + " " + resultUnit + (resultValue == 1 ? "" : "s");
}
/**
* Send a message to a target without a prefix.
* @param key The key of the language string
* @param replacements The replacements to insert in the message
*/
public void messageNoPrefix(String key, Object... replacements) {
plugin.messageNoPrefix(sender, key, replacements);
if(!(sender instanceof ConsoleCommandSender)) {
plugin.messageNoPrefix(Bukkit.getConsoleSender(), key, replacements);
}
}
/**
* Send a message to a target, prefixed by the default chat prefix.
* @param key The key of the language string
* @param replacements The replacements to insert in the message
*/
public void message(String key, Object... replacements) {
plugin.message(sender, key, replacements);
if(!(sender instanceof ConsoleCommandSender)) {
plugin.message(Bukkit.getConsoleSender(), key, replacements);
}
}
}
@@ -0,0 +1,484 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.Location;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
// TODO fix '/as info' help message hitting replacement limit (improve depth tracking?)
// TODO add info about autoExtend
public class InfoCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop info";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.info")) {
return "help-info";
}
return null;
}
/**
* Display a page of a list of regions.
* @param sender The CommandSender to send the messages to
* @param regions The regions to display
* @param filterGroup The group to filter the regions by
* @param keyHeader The header to print above the page
* @param pageInput The page number, if any
* @param baseCommand The command to execute for next/previous page (/areashop will be added)
*/
private void showSortedPagedList(CommandSender sender, List<? extends GeneralRegion> regions, RegionGroup filterGroup, String keyHeader, String pageInput, String baseCommand) {
int maximumItems = 20;
int itemsPerPage = maximumItems - 2;
int page = 1;
if(pageInput != null && Utils.isNumeric(pageInput)) {
try {
page = Integer.parseInt(pageInput);
} catch(NumberFormatException e) {
plugin.message(sender, "info-wrongPage", pageInput);
return;
}
}
if(filterGroup != null) {
regions.removeIf(generalRegion -> !filterGroup.isMember(generalRegion));
}
if(regions.isEmpty()) {
plugin.message(sender, "info-noRegions");
} else {
// First sort by type, then by name
regions.sort((one, two) -> {
int typeCompare = getTypeOrder(two).compareTo(getTypeOrder(one));
if(typeCompare != 0) {
return typeCompare;
} else {
return one.getName().compareTo(two.getName());
}
});
// Header
Message limitedToGroup = Message.empty();
if(filterGroup != null) {
limitedToGroup = Message.fromKey("info-limitedToGroup").replacements(filterGroup.getName());
}
plugin.message(sender, keyHeader, limitedToGroup);
// Page entries
int totalPages = (int)Math.ceil(regions.size() / (double)itemsPerPage); // Clip page to correct boundaries, not much need to tell the user
if(regions.size() == itemsPerPage + 1) { // 19 total items is mapped to 1 page of 19
itemsPerPage++;
totalPages = 1;
}
page = Math.max(1, Math.min(totalPages, page));
int linesPrinted = 1; // header
for(int i = (page - 1) * itemsPerPage; i < page * itemsPerPage && i < regions.size(); i++) {
String state;
GeneralRegion region = regions.get(i);
if(region.getType() == GeneralRegion.RegionType.RENT) {
if(region.getOwner() == null) {
state = "Forrent";
} else {
state = "Rented";
}
} else {
if(region.getOwner() == null) {
state = "Forsale";
} else if(!((BuyRegion)region).isInResellingMode()) {
state = "Sold";
} else {
state = "Reselling";
}
}
plugin.messageNoPrefix(sender, "info-entry" + state, region);
linesPrinted++;
}
Message footer = Message.empty();
// Previous button
if(page > 1) {
footer.append(Message.fromKey("info-pagePrevious").replacements(baseCommand + " " + (page - 1)));
} else {
footer.append(Message.fromKey("info-pageNoPrevious"));
}
// Page status
if(totalPages > 1) {
StringBuilder pageString = new StringBuilder("" + page);
for(int i = pageString.length(); i < (totalPages + "").length(); i++) {
pageString.insert(0, "0");
}
footer.append(Message.fromKey("info-pageStatus").replacements(page, totalPages));
if(page < totalPages) {
footer.append(Message.fromKey("info-pageNext").replacements(baseCommand + " " + (page + 1)));
} else {
footer.append(Message.fromKey("info-pageNoNext"));
}
// Fill up space if the page is not full (aligns header nicely)
for(int i = linesPrinted; i < maximumItems - 1; i++) {
sender.sendMessage(" ");
}
footer.send(sender);
}
}
}
/**
* Get an integer to order by type, usable for Comparators.
* @param region The region to get the order for
* @return An integer for sorting by type
*/
private Integer getTypeOrder(GeneralRegion region) {
if(region.getType() == GeneralRegion.RegionType.RENT) {
if(region.getOwner() == null) {
return 1;
} else {
return 2;
}
} else {
if(region.getOwner() == null) {
return 3;
} else if(!((BuyRegion)region).isInResellingMode()) {
return 4;
} else {
return 5;
}
}
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.info")) {
plugin.message(sender, "info-noPermission");
return;
}
if(args.length > 1 && args[1] != null) {
// Get filter group (only used by some commands)
RegionGroup filterGroup = null;
Set<String> groupFilters = new HashSet<>(Arrays.asList("all", "rented", "forrent", "sold", "forsale", "reselling"));
if(groupFilters.contains(args[1].toLowerCase()) && args.length > 2) {
if(!Utils.isNumeric(args[2])) {
filterGroup = plugin.getFileManager().getGroup(args[2]);
if(filterGroup == null) {
plugin.message(sender, "info-noFiltergroup", args[2]);
return;
}
// Pass page number to args[2] if available
if(args.length > 3) {
args[2] = args[3];
}
}
}
// All regions
if(args[1].equalsIgnoreCase("all")) {
showSortedPagedList(sender, plugin.getFileManager().getRegions(), filterGroup, "info-allHeader", (args.length > 2 ? args[2] : null), "info all");
}
// Rented regions
else if(args[1].equalsIgnoreCase("rented")) {
List<RentRegion> regions = plugin.getFileManager().getRents();
regions.removeIf(RentRegion::isAvailable);
showSortedPagedList(sender, regions, filterGroup, "info-rentedHeader", (args.length > 2 ? args[2] : null), "info rented");
}
// Forrent regions
else if(args[1].equalsIgnoreCase("forrent")) {
List<RentRegion> regions = plugin.getFileManager().getRents();
regions.removeIf(RentRegion::isRented);
showSortedPagedList(sender, regions, filterGroup, "info-forrentHeader", (args.length > 2 ? args[2] : null), "info forrent");
}
// Sold regions
else if(args[1].equalsIgnoreCase("sold")) {
List<BuyRegion> regions = plugin.getFileManager().getBuys();
regions.removeIf(BuyRegion::isAvailable);
showSortedPagedList(sender, regions, filterGroup, "info-soldHeader", (args.length > 2 ? args[2] : null), "info sold");
}
// Forsale regions
else if(args[1].equalsIgnoreCase("forsale")) {
List<BuyRegion> regions = plugin.getFileManager().getBuys();
regions.removeIf(BuyRegion::isSold);
showSortedPagedList(sender, regions, filterGroup, "info-forsaleHeader", (args.length > 2 ? args[2] : null), "info forsale");
}
// Reselling regions
else if(args[1].equalsIgnoreCase("reselling")) {
List<BuyRegion> regions = plugin.getFileManager().getBuys();
regions.removeIf(region -> !region.isInResellingMode());
showSortedPagedList(sender, regions, filterGroup, "info-resellingHeader", (args.length > 2 ? args[2] : null), "info reselling");
}
// List of regions without a group
else if(args[1].equalsIgnoreCase("nogroup")) {
List<GeneralRegion> regions = plugin.getFileManager().getRegions();
for(RegionGroup group : plugin.getFileManager().getGroups()) {
regions.removeAll(group.getMemberRegions());
}
if(regions.isEmpty()) {
plugin.message(sender, "info-nogroupNone");
} else {
showSortedPagedList(sender, regions, filterGroup, "info-nogroupHeader", (args.length > 2 ? args[2] : null), "info nogroup");
}
}
// Region info
else if(args[1].equalsIgnoreCase("region")) {
if(args.length > 1) {
RentRegion rent = null;
BuyRegion buy = null;
if(args.length > 2) {
rent = plugin.getFileManager().getRent(args[2]);
buy = plugin.getFileManager().getBuy(args[2]);
} else {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
if(regions.get(0) instanceof RentRegion) {
rent = (RentRegion)regions.get(0);
} else if(regions.get(0) instanceof BuyRegion) {
buy = (BuyRegion)regions.get(0);
}
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
}
if(rent == null && buy == null) {
plugin.message(sender, "info-regionNotExisting", args[2]);
return;
}
if(rent != null) {
plugin.message(sender, "info-regionHeaderRent", rent);
if(rent.isRented()) {
plugin.messageNoPrefix(sender, "info-regionRented", rent);
plugin.messageNoPrefix(sender, "info-regionExtending", rent);
// Money back
if(UnrentCommand.canUse(sender, rent)) {
plugin.messageNoPrefix(sender, "info-regionMoneyBackRentClick", rent);
} else {
plugin.messageNoPrefix(sender, "info-regionMoneyBackRent", rent);
}
// Friends
if(!rent.getFriendsFeature().getFriendNames().isEmpty()) {
String messagePart = "info-friend";
if(DelfriendCommand.canUse(sender, rent)) {
messagePart = "info-friendRemove";
}
plugin.messageNoPrefix(sender, "info-regionFriends", rent, Utils.combinedMessage(rent.getFriendsFeature().getFriendNames(), messagePart));
}
} else {
plugin.messageNoPrefix(sender, "info-regionCanBeRented", rent);
}
if(rent.getLandlordName() != null) {
plugin.messageNoPrefix(sender, "info-regionLandlord", rent);
}
// Maximum extends
if(rent.getMaxExtends() != -1) {
if(rent.getMaxExtends() == 0) {
plugin.messageNoPrefix(sender, "info-regionNoExtending", rent);
} else if(rent.isRented()) {
plugin.messageNoPrefix(sender, "info-regionExtendsLeft", rent);
} else {
plugin.messageNoPrefix(sender, "info-regionMaxExtends", rent);
}
}
// If maxExtends is zero it does not make sense to show this message
if(rent.getMaxRentTime() != -1 && rent.getMaxExtends() != 0) {
plugin.messageNoPrefix(sender, "info-regionMaxRentTime", rent);
}
if(rent.getInactiveTimeUntilUnrent() != -1) {
plugin.messageNoPrefix(sender, "info-regionInactiveUnrent", rent);
}
// Teleport
Message tp = Message.fromKey("info-prefix");
boolean foundSomething = false;
if(TeleportCommand.canUse(sender, rent)) {
foundSomething = true;
tp.append(Message.fromKey("info-regionTeleport").replacements(rent));
}
if(SetteleportCommand.canUse(sender, rent)) {
if(foundSomething) {
tp.append(", ");
}
foundSomething = true;
tp.append(Message.fromKey("info-setRegionTeleport").replacements(rent));
}
if(foundSomething) {
tp.append(".");
tp.send(sender);
}
// Signs
List<String> signLocations = new ArrayList<>();
for(Location location : rent.getSignsFeature().getSignLocations()) {
signLocations.add(Message.fromKey("info-regionSignLocation").replacements(location.getWorld().getName(), location.getBlockX(), location.getBlockY(), location.getBlockZ()).getPlain());
}
if(!signLocations.isEmpty()) {
plugin.messageNoPrefix(sender, "info-regionSigns", Utils.createCommaSeparatedList(signLocations));
}
// Groups
if(sender.hasPermission("areashop.groupinfo") && !rent.getGroupNames().isEmpty()) {
plugin.messageNoPrefix(sender, "info-regionGroups", Utils.createCommaSeparatedList(rent.getGroupNames()));
}
// Restoring
if(rent.isRestoreEnabled()) {
plugin.messageNoPrefix(sender, "info-regionRestoringRent", rent);
}
// Restrictions
if(!rent.isRented()) {
if(rent.restrictedToRegion()) {
plugin.messageNoPrefix(sender, "info-regionRestrictedRegionRent", rent);
} else if(rent.restrictedToWorld()) {
plugin.messageNoPrefix(sender, "info-regionRestrictedWorldRent", rent);
}
}
plugin.messageNoPrefix(sender, "info-regionFooterRent", rent);
} else if(buy != null) {
plugin.message(sender, "info-regionHeaderBuy", buy);
if(buy.isSold()) {
if(buy.isInResellingMode()) {
plugin.messageNoPrefix(sender, "info-regionReselling", buy);
plugin.messageNoPrefix(sender, "info-regionReselPrice", buy);
} else {
plugin.messageNoPrefix(sender, "info-regionBought", buy);
}
// Money back
if(!buy.getBooleanSetting("buy.sellDisabled")) {
if (SellCommand.canUse(sender, buy)) {
plugin.messageNoPrefix(sender, "info-regionMoneyBackBuyClick", buy);
} else {
plugin.messageNoPrefix(sender, "info-regionMoneyBackBuy", buy);
}
}
// Friends
if(!buy.getFriendsFeature().getFriendNames().isEmpty()) {
String messagePart = "info-friend";
if(DelfriendCommand.canUse(sender, buy)) {
messagePart = "info-friendRemove";
}
plugin.messageNoPrefix(sender, "info-regionFriends", buy, Utils.combinedMessage(buy.getFriendsFeature().getFriendNames(), messagePart));
}
} else {
plugin.messageNoPrefix(sender, "info-regionCanBeBought", buy);
}
if(buy.getLandlord() != null) {
plugin.messageNoPrefix(sender, "info-regionLandlord", buy);
}
if(buy.getInactiveTimeUntilSell() != -1) {
plugin.messageNoPrefix(sender, "info-regionInactiveSell", buy);
}
// Teleport
Message tp = Message.fromKey("info-prefix");
boolean foundSomething = false;
if(TeleportCommand.canUse(sender, buy)) {
foundSomething = true;
tp.append(Message.fromKey("info-regionTeleport").replacements(buy));
}
if(SetteleportCommand.canUse(sender, buy)) {
if(foundSomething) {
tp.append(", ");
}
foundSomething = true;
tp.append(Message.fromKey("info-setRegionTeleport").replacements(buy));
}
if(foundSomething) {
tp.append(".");
tp.send(sender);
}
// Signs
List<String> signLocations = new ArrayList<>();
for(Location location : buy.getSignsFeature().getSignLocations()) {
signLocations.add(Message.fromKey("info-regionSignLocation").replacements(location.getWorld().getName(), location.getBlockX(), location.getBlockY(), location.getBlockZ()).getPlain());
}
if(!signLocations.isEmpty()) {
plugin.messageNoPrefix(sender, "info-regionSigns", Utils.createCommaSeparatedList(signLocations));
}
// Groups
if(sender.hasPermission("areashop.groupinfo") && !buy.getGroupNames().isEmpty()) {
plugin.messageNoPrefix(sender, "info-regionGroups", Utils.createCommaSeparatedList(buy.getGroupNames()));
}
// Restoring
if(buy.isRestoreEnabled()) {
plugin.messageNoPrefix(sender, "info-regionRestoringBuy", buy);
}
// Restrictions
if(!buy.isSold()) {
if(buy.restrictedToRegion()) {
plugin.messageNoPrefix(sender, "info-regionRestrictedRegionBuy", buy);
} else if(buy.restrictedToWorld()) {
plugin.messageNoPrefix(sender, "info-regionRestrictedWorldBuy", buy);
}
}
plugin.messageNoPrefix(sender, "info-regionFooterBuy", buy);
}
} else {
plugin.message(sender, "info-regionHelp");
}
} else {
plugin.message(sender, "info-help");
}
} else {
plugin.message(sender, "info-help");
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result.addAll(Arrays.asList("all", "rented", "forrent", "sold", "forsale", "player", "region", "nogroup", "reselling"));
} else if(toComplete == 3) {
if(start[2].equalsIgnoreCase("player")) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
} else if(start[2].equalsIgnoreCase("region")) {
result.addAll(plugin.getFileManager().getBuyNames());
result.addAll(plugin.getFileManager().getRentNames());
}
}
return result;
}
}
@@ -0,0 +1,87 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
public class LinksignsCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop linksigns";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.linksigns")) {
return "help-linksigns";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.linksigns")) {
plugin.message(sender, "linksigns-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
if(plugin.getSignlinkerManager().isInSignLinkMode(player)) {
plugin.getSignlinkerManager().exitSignLinkMode(player);
} else {
// Get the profile
String profile = null;
if(args.length > 1) {
profile = args[1];
ConfigurationSection signProfilesSection = plugin.getConfig().getConfigurationSection("signProfiles");
if(signProfilesSection != null) {
Set<String> profiles = signProfilesSection.getKeys(false);
if(!profiles.contains(profile)) {
ArrayList<String> message = new ArrayList<>();
for(String p : profiles) {
if(!message.isEmpty()) {
message.add(", ");
}
message.addAll(Message.fromKey("addsign-profile").replacements(p).get());
}
plugin.message(sender, "addsign-wrongProfile", Message.fromList(message));
return;
}
}
}
plugin.getSignlinkerManager().enterSignLinkMode(player, profile);
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if(toComplete == 3) {
result.addAll(plugin.getConfig().getStringList("signProfiles"));
}
return result;
}
}
@@ -0,0 +1,143 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class MeCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop me";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.me")) {
return "help-me";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.me")) {
plugin.message(sender, "me-noPermission");
return;
}
OfflinePlayer player = null;
if(!(sender instanceof Player)) {
if(args.length <= 1) {
plugin.message(sender, "me-notAPlayer");
return;
}
} else {
player = (OfflinePlayer)sender;
}
if(args.length > 1) {
player = Bukkit.getOfflinePlayer(args[1]);
if(player == null) {
plugin.message(sender, "me-noPlayer", args[1]);
return;
}
}
if(player == null) {
return;
}
// Get the regions owned by the player
Set<RentRegion> rentRegions = new HashSet<>();
for(RentRegion region : plugin.getFileManager().getRents()) {
if(region.isOwner(player)) {
rentRegions.add(region);
}
}
Set<BuyRegion> buyRegions = new HashSet<>();
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(region.isOwner(player)) {
buyRegions.add(region);
}
}
// Get the regions the player is added as friend
Set<GeneralRegion> friendRegions = new HashSet<>();
for(GeneralRegion region : plugin.getFileManager().getRegions()) {
if(region.getFriendsFeature().getFriends().contains(player.getUniqueId())) {
friendRegions.add(region);
}
}
// Send messages
boolean foundSome = !rentRegions.isEmpty() || !buyRegions.isEmpty() || !friendRegions.isEmpty();
if(foundSome) {
plugin.message(sender, "me-header", player.getName());
}
if(!rentRegions.isEmpty()) {
for(RentRegion region : rentRegions) {
plugin.messageNoPrefix(sender, "me-rentLine", region);
}
}
if(!buyRegions.isEmpty()) {
for(BuyRegion region : buyRegions) {
plugin.messageNoPrefix(sender, "me-buyLine", region);
}
}
if(!friendRegions.isEmpty()) {
for(GeneralRegion region : friendRegions) {
plugin.messageNoPrefix(sender, "me-friendLine", region);
}
}
if(!foundSome) {
plugin.message(sender, "me-nothing", player.getName());
} else {
plugin.messageNoPrefix(sender, "me-clickHint");
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
}
return result;
}
}
@@ -0,0 +1,72 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import org.apache.commons.lang.StringUtils;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class MessageCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop message";
}
@Override
public String getHelp(CommandSender target) {
// Internal command, no need to show in the help list
return null;
}
@Override
public void execute(final CommandSender sender, final String[] args) {
if(!sender.hasPermission("areashop.message")) {
plugin.message(sender, "message-noPermission");
return;
}
if(args.length < 3) {
plugin.message(sender, "message-help");
return;
}
Player player = Bukkit.getPlayer(args[1]);
if(player == null) {
plugin.message(sender, "message-notOnline", args[1]);
return;
}
String[] messageArgs = new String[args.length - 2];
System.arraycopy(args, 2, messageArgs, 0, args.length - 2);
String message = StringUtils.join(messageArgs, " ");
Message.fromString(message).send(player);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
}
return result;
}
}
@@ -0,0 +1,7 @@
# Commands
This module contains all AreaShop commands.
* `CommandAreaShop` is extended by all other classes, and implements some general functionality and defines which methods should be implemented.
* Other classes implement specific sub-commands, supply their help messages and tab completion.
* `CommandManager` class in the `managers` package handles incoming commands and dispatches them to the classes in this package.
@@ -0,0 +1,29 @@
package me.wiefferink.areashop.commands;
import org.bukkit.command.CommandSender;
public class ReloadCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop reload";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.reload")) {
return "help-reload";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(sender.hasPermission("areashop.reload")) {
// Reload the configuration files and update all region flags/signs
plugin.reload(sender);
} else {
plugin.message(sender, "reload-noPermission");
}
}
}
@@ -0,0 +1,69 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class RentCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop rent";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.rent")) {
return "help-rent";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.rent")) {
plugin.message(sender, "rent-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
Player player = (Player)sender;
if(args.length > 1 && args[1] != null) {
RentRegion rent = plugin.getFileManager().getRent(args[1]);
if(rent == null) {
plugin.message(sender, "rent-notRentable", args[1]);
} else {
rent.rent(player);
}
} else {
// get the region by location
List<RentRegion> regions = Utils.getImportantRentRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
} else {
regions.get(0).rent(player);
}
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(RentRegion region : plugin.getFileManager().getRents()) {
if(!region.isRented()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -0,0 +1,134 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class ResellCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop resell";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.resellall") || target.hasPermission("areashop.resell")) {
return "help-resell";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.resell") && !sender.hasPermission("areashop.resellall")) {
plugin.message(sender, "resell-noPermissionOther");
return;
}
if(args.length <= 1) {
plugin.message(sender, "resell-help");
return;
}
double price;
try {
price = Double.parseDouble(args[1]);
} catch(NumberFormatException e) {
plugin.message(sender, "resell-wrongPrice", args[1]);
return;
}
if(price < 0) {
plugin.message(sender, "resell-wrongPrice", args[1]);
return;
}
BuyRegion buy;
if(args.length <= 2) {
if(sender instanceof Player) {
// get the region by location
List<BuyRegion> regions = Utils.getImportantBuyRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
buy = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
buy = plugin.getFileManager().getBuy(args[2]);
if(buy == null) {
plugin.message(sender, "resell-notRegistered", args[2]);
return;
}
}
if(buy == null) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
}
if(!buy.isSold()) {
plugin.message(sender, "resell-notBought", buy);
return;
}
if(sender.hasPermission("areashop.resellall")) {
buy.enableReselling(price);
buy.update();
plugin.message(sender, "resell-success", buy);
} else if(sender.hasPermission("areashop.resell") && sender instanceof Player) {
if(!buy.isOwner((Player)sender)) {
plugin.message(sender, "resell-noPermissionOther", buy);
return;
}
if(buy.getBooleanSetting("buy.resellDisabled")) {
plugin.message(sender, "resell-disabled", buy);
return;
}
buy.enableReselling(price);
buy.update();
plugin.message(sender, "resell-success", buy);
} else {
plugin.message(sender, "resell-noPermission", buy);
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 3) {
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(region.isSold() && !region.isInResellingMode()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -1,88 +1,86 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.Utils;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion.RegionEvent;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
public class SchematiceventCommand extends CommandAreaShop {
public SchematiceventCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop schemevent";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.schematicevents")) {
return plugin.getLanguageManager().getLang("help-schemevent");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if(!sender.hasPermission("areashop.schematicevents")) {
plugin.message(sender, "schemevent-noPermission");
return;
}
if(args.length < 3 || args[1] == null || args[2] == null) {
plugin.message(sender, "schemevent-help");
return;
}
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(sender, "schemevent-noRegion", args[1]);
return;
}
RegionEvent event = null;
boolean exception = false;
try {
event = RegionEvent.valueOf(args[2].toUpperCase());
} catch(IllegalArgumentException e) {
exception = true;
}
// Check for a totally wrong event or a non matching event
if(exception) {
ArrayList<String> values = new ArrayList<String>();
for(RegionEvent value : RegionEvent.values()) {
values.add(value.getValue().toLowerCase());
}
plugin.message(sender, "schemevent-wrongEvent", args[2], Utils.createCommaSeparatedList(values));
return;
}
region.handleSchematicEvent(event);
plugin.message(sender, "schemevent-success", args[2], region.getName());
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
ArrayList<String> result = new ArrayList<String>();
if(toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if(toComplete == 3) {
GeneralRegion region = plugin.getFileManager().getRegion(start[2]);
if(region != null) {
if(region.isRentRegion()) {
result.addAll(Arrays.asList("created", "deleted", "rented", "unrented"));
} else if(region.isBuyRegion()) {
result.addAll(Arrays.asList("created", "deleted", "bought", "sold"));
}
}
}
return result;
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class SchematiceventCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop schemevent";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.schematicevents")) {
return "help-schemevent";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.schematicevents")) {
plugin.message(sender, "schemevent-noPermission");
return;
}
if(args.length < 3 || args[1] == null || args[2] == null) {
plugin.message(sender, "schemevent-help");
return;
}
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[1]);
return;
}
if(region.getRegion() == null) {
plugin.message(sender, "general-noRegion", region);
return;
}
GeneralRegion.RegionEvent event = null;
boolean exception = false;
try {
event = GeneralRegion.RegionEvent.valueOf(args[2].toUpperCase());
} catch(IllegalArgumentException e) {
exception = true;
}
// Check for a totally wrong event or a non matching event
if(exception) {
ArrayList<String> values = new ArrayList<>();
for(GeneralRegion.RegionEvent value : GeneralRegion.RegionEvent.values()) {
values.add(value.getValue().toLowerCase());
}
plugin.message(sender, "schemevent-wrongEvent", args[2], Utils.createCommaSeparatedList(values), region);
return;
}
region.handleSchematicEvent(event);
region.update();
plugin.message(sender, "schemevent-success", args[2], region);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if(toComplete == 3) {
GeneralRegion region = plugin.getFileManager().getRegion(start[2]);
if(region != null) {
if(region instanceof RentRegion) {
result.addAll(Arrays.asList("created", "deleted", "rented", "unrented"));
} else if(region instanceof BuyRegion) {
result.addAll(Arrays.asList("created", "deleted", "bought", "sold"));
}
}
}
return result;
}
}
@@ -0,0 +1,110 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class SellCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop sell";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.sell") || target.hasPermission("areashop.sellown")) {
return "help-sell";
}
return null;
}
/**
* Check if a person can sell the region.
* @param person The person to check
* @param region The region to check for
* @return true if the person can sell it, otherwise false
*/
public static boolean canUse(CommandSender person, GeneralRegion region) {
if(person.hasPermission("areashop.sell")) {
return true;
}
if(person instanceof Player) {
Player player = (Player)person;
return region.isOwner(player) && person.hasPermission("areashop.sellown");
}
return false;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.sell") && !sender.hasPermission("areashop.sellown")) {
plugin.message(sender, "sell-noPermission");
return;
}
BuyRegion buy;
if(args.length <= 1) {
if(sender instanceof Player) {
// get the region by location
List<BuyRegion> regions = Utils.getImportantBuyRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
buy = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
buy = plugin.getFileManager().getBuy(args[1]);
}
if(buy == null) {
plugin.message(sender, "sell-notRegistered");
return;
}
if(!buy.isSold()) {
plugin.message(sender, "sell-notBought", buy);
return;
}
buy.sell(true, sender);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(region.isSold()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -0,0 +1,105 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class SetdurationCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop setduration";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setduration")) {
return "help-setduration";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setduration") && (!sender.hasPermission("areashop.setduration.landlord") && sender instanceof Player)) {
plugin.message(sender, "setduration-noPermission");
return;
}
if(args.length < 3 || args[1] == null || args[2] == null) {
plugin.message(sender, "setduration-help");
return;
}
int regionArgument = 3;
if(args.length >= 2 && ("default".equalsIgnoreCase(args[1]) || "reset".equalsIgnoreCase(args[1]))) {
regionArgument = 2;
}
RentRegion rent;
if(args.length <= regionArgument) {
if(sender instanceof Player) {
// get the region by location
List<RentRegion> regions = Utils.getImportantRentRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
rent = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
rent = plugin.getFileManager().getRent(args[regionArgument]);
}
if(rent == null) {
plugin.message(sender, "setduration-notRegistered", args[regionArgument]);
return;
}
if(!sender.hasPermission("areashop.setduration") && !(sender instanceof Player && rent.isLandlord(((Player)sender).getUniqueId()))) {
plugin.message(sender, "setduration-noLandlord", rent);
return;
}
if("default".equalsIgnoreCase(args[1]) || "reset".equalsIgnoreCase(args[1])) {
rent.setDuration(null);
rent.update();
plugin.message(sender, "setduration-successRemoved", rent);
return;
}
try {
Integer.parseInt(args[1]);
} catch(NumberFormatException e) {
plugin.message(sender, "setduration-wrongAmount", args[1], rent);
return;
}
if(!Utils.checkTimeFormat(args[1] + " " + args[2])) {
plugin.message(sender, "setduration-wrongFormat", args[1] + " " + args[2], rent);
return;
}
rent.setDuration(args[1] + " " + args[2]);
rent.update();
plugin.message(sender, "setduration-success", rent);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 3) {
result.addAll(plugin.getConfig().getStringList("minutes"));
result.addAll(plugin.getConfig().getStringList("hours"));
result.addAll(plugin.getConfig().getStringList("days"));
result.addAll(plugin.getConfig().getStringList("months"));
result.addAll(plugin.getConfig().getStringList("years"));
} else if(toComplete == 4) {
result = plugin.getFileManager().getRentNames();
}
return result;
}
}
@@ -0,0 +1,87 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class SetlandlordCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop setlandlord";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setlandlord")) {
return "help-setlandlord";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setlandlord")) {
plugin.message(sender, "setlandlord-noPermission");
return;
}
if(args.length < 2) {
plugin.message(sender, "setlandlord-help");
return;
}
@SuppressWarnings("deprecation")
OfflinePlayer player = Bukkit.getOfflinePlayer(args[1]);
GeneralRegion region;
if(args.length < 3) {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
region = plugin.getFileManager().getRegion(args[2]);
}
if(region == null) {
plugin.message(sender, "cmd-notRegistered", args[2]);
return;
}
String playerName = player.getName();
if(playerName == null || playerName.isEmpty()) {
playerName = args[1];
}
region.setLandlord(player.getUniqueId(), playerName);
region.update();
plugin.message(sender, "setlandlord-success", playerName, region);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
} else if(toComplete == 3) {
result.addAll(plugin.getFileManager().getRegionNames());
}
return result;
}
}
@@ -0,0 +1,134 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.UUID;
public class SetownerCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop setowner";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setownerrent") || target.hasPermission("areashop.setownerbuy")) {
return "help-setowner";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setownerrent") && !sender.hasPermission("areashop.setownerbuy")) {
plugin.message(sender, "setowner-noPermission");
return;
}
GeneralRegion region;
if(args.length < 2) {
plugin.message(sender, "setowner-help");
return;
}
if(args.length == 2) {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
region = plugin.getFileManager().getRegion(args[2]);
}
if(region == null) {
plugin.message(sender, "setowner-notRegistered");
return;
}
if(region instanceof RentRegion && !sender.hasPermission("areashop.setownerrent")) {
plugin.message(sender, "setowner-noPermissionRent", region);
return;
}
if(region instanceof BuyRegion && !sender.hasPermission("areashop.setownerbuy")) {
plugin.message(sender, "setowner-noPermissionBuy", region);
return;
}
UUID uuid = null;
@SuppressWarnings("deprecation")
OfflinePlayer player = Bukkit.getOfflinePlayer(args[1]);
if(player != null) {
uuid = player.getUniqueId();
}
if(uuid == null) {
plugin.message(sender, "setowner-noPlayer", args[1], region);
return;
}
if(region instanceof RentRegion) {
RentRegion rent = (RentRegion)region;
if(rent.isRenter(uuid)) {
// extend
rent.setRentedUntil(rent.getRentedUntil() + rent.getDuration());
rent.setRenter(uuid);
plugin.message(sender, "setowner-succesRentExtend", region);
} else {
// change
if(!rent.isRented()) {
rent.setRentedUntil(Calendar.getInstance().getTimeInMillis() + rent.getDuration());
}
rent.setRenter(uuid);
plugin.message(sender, "setowner-succesRent", region);
}
}
if(region instanceof BuyRegion) {
BuyRegion buy = (BuyRegion)region;
buy.setBuyer(uuid);
plugin.message(sender, "setowner-succesBuy", region);
}
region.getFriendsFeature().deleteFriend(region.getOwner(), null);
region.update();
region.saveRequired();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(Player player : Utils.getOnlinePlayers()) {
result.add(player.getName());
}
} else if(toComplete == 3) {
result.addAll(plugin.getFileManager().getRegionNames());
}
return result;
}
}
@@ -0,0 +1,103 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class SetpriceCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop setprice";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setprice")) {
return "help-setprice";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setprice") && (!sender.hasPermission("areashop.setprice.landlord") && sender instanceof Player)) {
plugin.message(sender, "setprice-noPermission");
return;
}
if(args.length < 2 || args[1] == null) {
plugin.message(sender, "setprice-help");
return;
}
GeneralRegion region;
if(args.length < 3) {
if(sender instanceof Player) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
region = plugin.getFileManager().getRegion(args[2]);
}
if(region == null) {
plugin.message(sender, "setprice-notRegistered", args[2]);
return;
}
if(!sender.hasPermission("areashop.setprice") && !(sender instanceof Player && region.isLandlord(((Player)sender).getUniqueId()))) {
plugin.message(sender, "setprice-noLandlord", region);
return;
}
if("default".equalsIgnoreCase(args[1]) || "reset".equalsIgnoreCase(args[1])) {
if(region instanceof RentRegion) {
((RentRegion)region).setPrice(null);
} else if(region instanceof BuyRegion) {
((BuyRegion)region).setPrice(null);
}
region.update();
plugin.message(sender, "setprice-successRemoved", region);
return;
}
double price;
try {
price = Double.parseDouble(args[1]);
} catch(NumberFormatException e) {
plugin.message(sender, "setprice-wrongPrice", args[1], region);
return;
}
if(region instanceof RentRegion) {
((RentRegion)region).setPrice(price);
plugin.message(sender, "setprice-successRent", region);
} else if(region instanceof BuyRegion) {
((BuyRegion)region).setPrice(price);
plugin.message(sender, "setprice-successBuy", region);
}
region.update();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 3) {
result = plugin.getFileManager().getRegionNames();
}
return result;
}
}
@@ -1,77 +1,73 @@
package nl.evolutioncoding.AreaShop.commands;
import java.util.ArrayList;
import java.util.List;
import nl.evolutioncoding.AreaShop.AreaShop;
import nl.evolutioncoding.AreaShop.regions.GeneralRegion;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
public class SetrestoreCommand extends CommandAreaShop {
public SetrestoreCommand(AreaShop plugin) {
super(plugin);
}
@Override
public String getCommandStart() {
return "areashop setrestore";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setrestore")) {
return plugin.getLanguageManager().getLang("help-setrestore");
}
return null;
}
@Override
public void execute(CommandSender sender, Command command, String[] args) {
if(!sender.hasPermission("areashop.setrestore")) {
plugin.message(sender, "setrestore-noPermission");
return;
}
if(args.length <= 2 || args[1] == null || args[2] == null) {
plugin.message(sender, "setrestore-help");
return;
}
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(sender, "setrestore-notRegistered", args[1]);
return;
}
String value = null;
if(args[2].equalsIgnoreCase("true") || args[2].equalsIgnoreCase("false") || args[2].equalsIgnoreCase("general")) {
value = args[2].toLowerCase();
} else {
plugin.message(sender, "setrestore-invalidSetting", args[2]);
return;
}
region.setRestoreSetting(value);
if(args.length > 3) {
region.setRestoreProfile(args[3]);
plugin.message(sender, "setrestore-successProfile", region.getName(), value, args[3]);
} else {
plugin.message(sender, "setrestore-success", region.getName(), value);
}
region.save();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start) {
List<String> result = new ArrayList<String>();
if(toComplete == 2) {
result = plugin.getFileManager().getRegionNames();
} else if(toComplete == 3) {
result.add("true");
result.add("false");
result.add("general");
} else if(toComplete == 4) {
result.addAll(plugin.config().getConfigurationSection("schematicProfiles").getKeys(false));
}
return result;
}
}
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.List;
public class SetrestoreCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop setrestore";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setrestore")) {
return "help-setrestore";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setrestore")) {
plugin.message(sender, "setrestore-noPermission");
return;
}
if(args.length <= 2 || args[1] == null || args[2] == null) {
plugin.message(sender, "setrestore-help");
return;
}
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(sender, "setrestore-notRegistered", args[1]);
return;
}
Boolean value = null;
if(args[2].equalsIgnoreCase("true")) {
value = true;
} else if(args[2].equalsIgnoreCase("false")) {
value = false;
}
region.setRestoreSetting(value);
String valueString = "general";
if(value != null) {
valueString = value + "";
}
if(args.length > 3) {
region.setSchematicProfile(args[3]);
plugin.message(sender, "setrestore-successProfile", valueString, args[3], region);
} else {
plugin.message(sender, "setrestore-success", valueString, region);
}
region.update();
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 2) {
result = plugin.getFileManager().getRegionNames();
} else if(toComplete == 3) {
result.add("true");
result.add("false");
result.add("general");
} else if(toComplete == 4) {
result.addAll(plugin.getConfig().getConfigurationSection("schematicProfiles").getKeys(false));
}
return result;
}
}
@@ -0,0 +1,118 @@
package me.wiefferink.areashop.commands;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class SetteleportCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop settp";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.setteleportall") || target.hasPermission("areashop.setteleport")) {
return "help-setteleport";
}
return null;
}
/**
* Check if a person can set the teleport location of the region.
* @param person The person to check
* @param region The region to check for
* @return true if the person can set the teleport location, otherwise false
*/
public static boolean canUse(CommandSender person, GeneralRegion region) {
if(!(person instanceof Player)) {
return false;
}
Player player = (Player)person;
return player.hasPermission("areashop.setteleportall")
|| region.isOwner(player) && player.hasPermission("areashop.setteleport");
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.setteleport") && !sender.hasPermission("areashop.setteleportall")) {
plugin.message(sender, "setteleport-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "onlyByPlayer");
return;
}
Player player = (Player)sender;
GeneralRegion region;
if(args.length < 2) {
// get the region by location
List<GeneralRegion> regions = Utils.getImportantRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
region = regions.get(0);
}
} else {
region = plugin.getFileManager().getRegion(args[1]);
}
boolean owner;
if(region == null) {
plugin.message(player, "setteleport-noRentOrBuy", args[1]);
return;
}
if(region instanceof RentRegion) {
owner = player.getUniqueId().equals(((RentRegion)region).getRenter());
} else {
owner = player.getUniqueId().equals(((BuyRegion)region).getBuyer());
}
if(!player.hasPermission("areashop.setteleport")) {
plugin.message(player, "setteleport-noPermission", region);
return;
} else if(!owner && !player.hasPermission("areashop.setteleportall")) {
plugin.message(player, "setteleport-noPermissionOther", region);
return;
}
ProtectedRegion wgRegion = region.getRegion();
if(args.length > 2 && args[2] != null && (args[2].equalsIgnoreCase("reset") || args[2].equalsIgnoreCase("yes") || args[2].equalsIgnoreCase("true"))) {
region.getTeleportFeature().setTeleport(null);
region.update();
plugin.message(player, "setteleport-reset", region);
return;
}
if(!player.hasPermission("areashop.setteleportoutsideregion") && (wgRegion == null || !wgRegion.contains(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()))) {
plugin.message(player, "setteleport-notInside", region);
return;
}
region.getTeleportFeature().setTeleport(player.getLocation());
region.update();
plugin.message(player, "setteleport-success", region);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if(toComplete == 3) {
result.add("reset");
}
return result;
}
}
@@ -0,0 +1,263 @@
package me.wiefferink.areashop.commands;
import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.AddingRegionEvent;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RegionGroup;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.Location;
import org.bukkit.block.BlockFace;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.Vector;
import java.util.ArrayList;
import java.util.List;
public class StackCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop stack";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.stack")) {
return "help-stack";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
// Check permission
if(!sender.hasPermission("areashop.stack")) {
plugin.message(sender, "stack-noPermission");
return;
}
// Only from ingame
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
final Player player = (Player)sender;
// Specify enough arguments
if(args.length < 5) {
plugin.message(sender, "stack-help");
return;
}
// Check amount
int tempAmount = -1;
try {
tempAmount = Integer.parseInt(args[1]);
} catch(NumberFormatException e) {
// Incorrect number
}
if(tempAmount <= 0) {
plugin.message(player, "stack-wrongAmount", args[1]);
return;
}
// Check gap
int gap;
try {
gap = Integer.parseInt(args[2]);
} catch(NumberFormatException e) {
plugin.message(player, "stack-wrongGap", args[2]);
return;
}
// Check region type
if(!"rent".equalsIgnoreCase(args[4]) && !"buy".equalsIgnoreCase(args[4])) {
plugin.message(sender, "stack-help");
return;
}
// Get WorldEdit selection
final WorldEditSelection selection = plugin.getWorldEditHandler().getPlayerSelection(player);
if(selection == null) {
plugin.message(player, "stack-noSelection");
return;
}
// Get or create group
RegionGroup group = null;
if(args.length > 5) {
group = plugin.getFileManager().getGroup(args[5]);
if(group == null) {
group = new RegionGroup(plugin, args[5]);
plugin.getFileManager().addGroup(group);
}
}
// Get facing of the player (must be clearly one of the four directions to make sure it is no mistake)
BlockFace facing = Utils.yawToFacing(player.getLocation().getYaw());
if(player.getLocation().getPitch() > 45) {
facing = BlockFace.DOWN;
} else if(player.getLocation().getPitch() < -45) {
facing = BlockFace.UP;
}
if(!(facing == BlockFace.NORTH || facing == BlockFace.EAST || facing == BlockFace.SOUTH || facing == BlockFace.WEST || facing == BlockFace.UP || facing == BlockFace.DOWN)) {
plugin.message(player, "stack-unclearDirection", facing.toString().toLowerCase().replace('_', '-'));
return;
}
Vector shift = new Vector(0, 0, 0);
if(facing == BlockFace.SOUTH) {
shift = shift.setZ(-selection.getLength() - gap);
} else if(facing == BlockFace.WEST) {
shift = shift.setX(selection.getWidth() + gap);
} else if(facing == BlockFace.NORTH) {
shift = shift.setZ(selection.getLength() + gap);
} else if(facing == BlockFace.EAST) {
shift = shift.setX(-selection.getWidth() - gap);
} else if(facing == BlockFace.DOWN) {
shift = shift.setY(-selection.getHeight() - gap);
} else if(facing == BlockFace.UP) {
shift = shift.setY(selection.getHeight() + gap);
}
AreaShop.debug(" calculated shift vector: " + shift + ", with facing=" + facing);
// Create regions and add them to AreaShop
final String nameTemplate = args[3];
final int regionsPerTick = plugin.getConfig().getInt("adding.regionsPerTick");
final boolean rentRegions = "rent".equalsIgnoreCase(args[4]);
final int amount = tempAmount;
final RegionGroup finalGroup = group;
final Vector finalShift = shift;
String type;
if(rentRegions) {
type = "rent";
} else {
type = "buy";
}
Message groupsMessage = Message.empty();
if(group != null) {
groupsMessage = Message.fromKey("stack-addToGroup").replacements(group.getName());
}
plugin.message(player, "stack-accepted", amount, type, gap, nameTemplate, groupsMessage);
plugin.message(player, "stack-addStart", amount, regionsPerTick * 20);
Location minimumLocation = selection.getMinimumLocation();
Vector minimumVector = new Vector(minimumLocation.getX(), minimumLocation.getY(), minimumLocation.getZ());
Location maximumLocation = selection.getMaximumLocation();
Vector maximumVector = new Vector(maximumLocation.getX(), maximumLocation.getY(), maximumLocation.getZ());
new BukkitRunnable() {
private int current = -1;
private final RegionManager manager = AreaShop.getInstance().getRegionManager(selection.getWorld());
private int counter = 1;
private int tooLow = 0;
private int tooHigh = 0;
@Override
public void run() {
for(int i = 0; i < regionsPerTick; i++) {
current++;
if(current < amount) {
// Create the region name
String regionName = countToName(nameTemplate, counter);
while(manager.getRegion(regionName) != null || AreaShop.getInstance().getFileManager().getRegion(regionName) != null) {
counter++;
regionName = countToName(nameTemplate, counter);
}
// Add the region to WorldGuard (at startposition shifted by the number of this region times the blocks it should shift)
Vector minimum = minimumVector.clone().add(finalShift.clone().multiply(current));
Vector maximum = maximumVector.clone().add(finalShift.clone().multiply(current));
// Check for out of bounds
if(minimum.getBlockY() < 0) {
tooLow++;
continue;
} else if(maximum.getBlockY() > 256) {
tooHigh++;
continue;
}
ProtectedCuboidRegion region = plugin.getWorldGuardHandler().createCuboidRegion(regionName, minimum,maximum);
manager.addRegion(region);
// Add the region to AreaShop
GeneralRegion newRegion;
if(rentRegions) {
newRegion = new RentRegion(regionName, selection.getWorld());
} else {
newRegion = new BuyRegion(regionName, selection.getWorld());
}
if(finalGroup != null) {
finalGroup.addMember(newRegion);
}
AddingRegionEvent event = plugin.getFileManager().addRegion(newRegion);
if (event.isCancelled()) {
plugin.message(player, "general-cancelled", event.getReason());
continue;
}
newRegion.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);
newRegion.update();
}
}
if(current >= amount) {
if(player.isOnline()) {
int added = amount - tooLow - tooHigh;
Message wrong = Message.empty();
if(tooHigh > 0) {
wrong.append(Message.fromKey("stack-tooHigh").replacements(tooHigh));
}
if(tooLow > 0) {
wrong.append(Message.fromKey("stack-tooLow").replacements(tooLow));
}
plugin.message(player, "stack-addComplete", added, wrong);
}
this.cancel();
}
}
}.runTaskTimer(plugin, 1, 1);
}
/**
* Build a name from a count, with the right length.
* @param template Template to put the name in (# to put the count there, otherwise count is appended)
* @param count Number to use
* @return name with prepended 0's
*/
private String countToName(String template, int count) {
StringBuilder counterName = new StringBuilder().append(count);
int minimumLength = plugin.getConfig().getInt("stackRegionNumberLength");
while(counterName.length() < minimumLength) {
counterName.insert(0, "0");
}
if(template.contains("#")) {
return template.replace("#", counterName);
} else {
return template + counterName;
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
List<String> result = new ArrayList<>();
if(toComplete == 5) {
result.add("rent");
result.add("buy");
} else if(toComplete == 6) {
result.addAll(plugin.getFileManager().getGroupNames());
}
return result;
}
}
@@ -0,0 +1,111 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class StopresellCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop stopresell";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.stopresellall") || target.hasPermission("areashop.stopresell")) {
return "help-stopResell";
}
return null;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.stopresell") && !sender.hasPermission("areashop.stopresellall")) {
plugin.message(sender, "stopresell-noPermissionOther");
return;
}
BuyRegion buy;
if(args.length <= 1) {
if(sender instanceof Player) {
// get the region by location
List<BuyRegion> regions = Utils.getImportantBuyRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
buy = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
buy = plugin.getFileManager().getBuy(args[1]);
if(buy == null) {
plugin.message(sender, "stopresell-notRegistered", args[1]);
return;
}
}
if(buy == null) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
}
if(!buy.isInResellingMode()) {
plugin.message(sender, "stopresell-notResell", buy);
return;
}
if(sender.hasPermission("areashop.stopresellall")) {
buy.disableReselling();
buy.update();
plugin.message(sender, "stopresell-success", buy);
} else if(sender.hasPermission("areashop.stopresell") && sender instanceof Player) {
if(buy.isOwner((Player)sender)) {
buy.disableReselling();
buy.update();
plugin.message(sender, "stopresell-success", buy);
} else {
plugin.message(sender, "stopresell-noPermissionOther", buy);
}
} else {
plugin.message(sender, "stopresell-noPermission", buy);
}
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(BuyRegion region : plugin.getFileManager().getBuys()) {
if(region.isSold() && region.isInResellingMode()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -0,0 +1,82 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class TeleportCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop tp";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.teleportall") || target.hasPermission("areashop.teleport")) {
return "help-teleport";
}
return null;
}
/**
* Check if a person can teleport to the region (assuming he is not teleporting to a sign).
* @param person The person to check
* @param region The region to check for
* @return true if the person can teleport to it, otherwise false
*/
public static boolean canUse(CommandSender person, GeneralRegion region) {
if(!(person instanceof Player)) {
return false;
}
Player player = (Player)person;
return player.hasPermission("areashop.teleportall")
|| region.isOwner(player) && player.hasPermission("areashop.teleport")
|| region.isAvailable() && player.hasPermission("areashop.teleportavailable")
|| region.getFriendsFeature().getFriends().contains(player.getUniqueId()) && player.hasPermission("areashop.teleportfriend");
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.teleport") && !sender.hasPermission("areashop.teleportall") && !sender.hasPermission("areashop.teleportavailable") && !sender.hasPermission("areashop.teleportavailablesign") && !sender.hasPermission("areashop.teleportsign") && !sender.hasPermission("areashop.teleportsignall") && !sender.hasPermission("areashop.teleportfriend") && !sender.hasPermission("teleportfriendsign")) {
plugin.message(sender, "teleport-noPermission");
return;
}
if(!(sender instanceof Player)) {
plugin.message(sender, "cmd-onlyByPlayer");
return;
}
if(args.length <= 1 || args[1] == null) {
plugin.message(sender, "teleport-help");
return;
}
Player player = (Player)sender;
GeneralRegion region = plugin.getFileManager().getRegion(args[1]);
if(region == null) {
plugin.message(player, "teleport-noRentOrBuy", args[1]);
return;
}
boolean toSign = args.length >= 3 && (
args[2].equalsIgnoreCase("sign")
|| args[2].equalsIgnoreCase("yes")
|| args[2].equalsIgnoreCase("true")
);
region.getTeleportFeature().teleportPlayer(player, toSign, true);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
result.addAll(plugin.getFileManager().getRegionNames());
} else if(toComplete == 3) {
result.add("sign");
}
return result;
}
}
@@ -0,0 +1,102 @@
package me.wiefferink.areashop.commands;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
public class UnrentCommand extends CommandAreaShop {
@Override
public String getCommandStart() {
return "areashop unrent";
}
@Override
public String getHelp(CommandSender target) {
if(target.hasPermission("areashop.unrent") || target.hasPermission("areashop.unrentown")) {
return "help-unrent";
}
return null;
}
/**
* Check if a person can unrent the region.
* @param person The person to check
* @param region The region to check for
* @return true if the person can unrent it, otherwise false
*/
public static boolean canUse(CommandSender person, GeneralRegion region) {
if(person.hasPermission("areashop.unrent")) {
return true;
}
if(person instanceof Player) {
Player player = (Player)person;
return region.isOwner(player) && person.hasPermission("areashop.unrentown");
}
return false;
}
@Override
public void execute(CommandSender sender, String[] args) {
if(!sender.hasPermission("areashop.unrent") && !sender.hasPermission("areashop.unrentown")) {
plugin.message(sender, "unrent-noPermission");
return;
}
RentRegion rent;
if(args.length <= 1) {
if(sender instanceof Player) {
// get the region by location
List<RentRegion> regions = Utils.getImportantRentRegions(((Player)sender).getLocation());
if(regions.isEmpty()) {
plugin.message(sender, "cmd-noRegionsAtLocation");
return;
} else if(regions.size() > 1) {
plugin.message(sender, "cmd-moreRegionsAtLocation");
return;
} else {
rent = regions.get(0);
}
} else {
plugin.message(sender, "cmd-automaticRegionOnlyByPlayer");
return;
}
} else {
rent = plugin.getFileManager().getRent(args[1]);
}
if(rent == null) {
plugin.message(sender, "unrent-notRegistered");
return;
}
if(!rent.isRented()) {
plugin.message(sender, "unrent-notRented", rent);
return;
}
rent.unRent(true, sender);
}
@Override
public List<String> getTabCompleteList(int toComplete, String[] start, CommandSender sender) {
ArrayList<String> result = new ArrayList<>();
if(toComplete == 2) {
for(RentRegion region : plugin.getFileManager().getRents()) {
if(region.isRented()) {
result.add(region.getName());
}
}
}
return result;
}
}
@@ -0,0 +1,45 @@
package me.wiefferink.areashop.events;
public class CancellableRegionEvent<T> extends RegionEvent<T> {
private boolean cancelled;
private String reason;
public CancellableRegionEvent(T region) {
super(region);
}
/**
* Cancel the event from happening.
* @param reason The reason of cancelling, used for display to the user, should end with a dot
*/
public void cancel(String reason) {
this.cancelled = true;
this.reason = reason;
}
/**
* Let the event continue, possible overwriting a cancel() call from another plugin.
*/
public void allow() {
this.cancelled = false;
this.reason = null;
}
/**
* Check if the event has been cancelled.
* @return true if the event has been cancelled, otherwise false
*/
public boolean isCancelled() {
return cancelled;
}
/**
* Get the reason why this event is cancelled.
* @return null if there is no reason or the event is not cancelled, otherwise a string
*/
public String getReason() {
return reason;
}
}
@@ -0,0 +1,7 @@
package me.wiefferink.areashop.events;
public class NotifyRegionEvent<T> extends RegionEvent<T> {
public NotifyRegionEvent(T region) {
super(region);
}
}
@@ -0,0 +1,7 @@
# Events
This package contains event classes that allow other plugins to listen to events about AreaShop regions.
* `RegionEvent` class represents a generic event.
* `CancellableRegionEvent` represents an event that has a region and can be cancelled.
* `NotifyRegionEvent` represents events that are to inform only, and cannot be cancelled anymore (an `CancellableRegionEvent` would be sent first).
@@ -0,0 +1,31 @@
package me.wiefferink.areashop.events;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
public class RegionEvent<T> extends Event {
protected T region;
private static final HandlerList handlers = new HandlerList();
public RegionEvent(T region) {
this.region = region;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
// Required by Bukkit/Spigot
public static HandlerList getHandlerList() {
return handlers;
}
/**
* Get the region of this event.
* @return The region the event is about
*/
public T getRegion() {
return region;
}
}
@@ -0,0 +1,19 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
/**
* Broadcasted when a region has been added to AreaShop.
*/
public class AddingRegionEvent extends CancellableRegionEvent<GeneralRegion> {
/**
* Constructor.
* @param region The region that has been added
*/
public AddingRegionEvent(GeneralRegion region) {
super(region);
}
}
@@ -0,0 +1,31 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
import org.bukkit.OfflinePlayer;
/**
* Broadcasted when a player tries to buy a region.
*/
public class BuyingRegionEvent extends CancellableRegionEvent<BuyRegion> {
private final OfflinePlayer player;
/**
* Constructor.
* @param region The region that is about to get bought
* @param player The player that tries to buy the region
*/
public BuyingRegionEvent(BuyRegion region, OfflinePlayer player) {
super(region);
this.player = player;
}
/**
* Get the player that is trying to buy the region.
* @return The player that is trying to buy the region
*/
public OfflinePlayer getPlayer() {
return player;
}
}
@@ -0,0 +1,19 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
/**
* Broadcasted when a region has been added to AreaShop.
*/
public class DeletingRegionEvent extends CancellableRegionEvent<GeneralRegion> {
/**
* Constructor.
* @param region The region that has been added
*/
public DeletingRegionEvent(GeneralRegion region) {
super(region);
}
}
@@ -0,0 +1,42 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.RentRegion;
import org.bukkit.OfflinePlayer;
/**
* Broadcasted when a player tries to rent a region.
*/
public class RentingRegionEvent extends CancellableRegionEvent<RentRegion> {
private final OfflinePlayer player;
private final boolean extending;
/**
* Constructor.
* @param region The region that is about to be rented
* @param player The player that tries to rent the region
* @param extending true if the player is extending the rental of the region, otherwise false
*/
public RentingRegionEvent(RentRegion region, OfflinePlayer player, boolean extending) {
super(region);
this.player = player;
this.extending = extending;
}
/**
* Get the player that is trying to rent the region.
* @return The player that is trying to rent the region
*/
public OfflinePlayer getPlayer() {
return player;
}
/**
* Check if the player is extending the region or renting it for the first time.
* @return true if the player tries to extend the region, false if he tries to rent it the first time
*/
public boolean isExtending() {
return extending;
}
}
@@ -0,0 +1,31 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
import org.bukkit.OfflinePlayer;
/**
* Broadcasted when a player tries to resell a region.
*/
public class ResellingRegionEvent extends CancellableRegionEvent<BuyRegion> {
private final OfflinePlayer player;
/**
* Contructor.
* @param region The region that the player is trying to resell
* @param player The player that is trying to buy this region from the current owner
*/
public ResellingRegionEvent(BuyRegion region, OfflinePlayer player) {
super(region);
this.player = player;
}
/**
* Get the player that is trying to buy the region.
* @return The player that is trying to buy the region
*/
public OfflinePlayer getBuyer() {
return player;
}
}
@@ -0,0 +1,18 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
/**
* Broadcasted when a region is about to get sold.
*/
public class SellingRegionEvent extends CancellableRegionEvent<BuyRegion> {
/**
* Constructor.
* @param region The region that is about to get sold
*/
public SellingRegionEvent(BuyRegion region) {
super(region);
}
}
@@ -0,0 +1,18 @@
package me.wiefferink.areashop.events.ask;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.RentRegion;
/**
* Broadcasted when a region is about to be unrented.
*/
public class UnrentingRegionEvent extends CancellableRegionEvent<RentRegion> {
/**
* Constructor.
* @param region The region that is about to be unrented
*/
public UnrentingRegionEvent(RentRegion region) {
super(region);
}
}
@@ -0,0 +1,43 @@
package me.wiefferink.areashop.events.askandnotify;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
/**
* Broadcasted when a friend is being added to a region.
*/
public class AddedFriendEvent extends CancellableRegionEvent<GeneralRegion> {
private final OfflinePlayer friend;
private final CommandSender by;
/**
* Constructor.
* @param region The region the friend is getting added to
* @param friend The friend that is about to be added
* @param by The CommandSender that is adding the friend, or null if none
*/
public AddedFriendEvent(GeneralRegion region, OfflinePlayer friend, CommandSender by) {
super(region);
this.friend = friend;
this.by = by;
}
/**
* Get the OfflinePlayer that is getting added as friend.
* @return The friend that is getting added
*/
public OfflinePlayer getFriend() {
return friend;
}
/**
* Get the CommandSender that is adding the friend.
* @return null if none, a CommandSender if done by someone (likely Player or ConsoleCommandSender)
*/
public CommandSender getBy() {
return by;
}
}
@@ -0,0 +1,43 @@
package me.wiefferink.areashop.events.askandnotify;
import me.wiefferink.areashop.events.CancellableRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
/**
* Broadcasted when a friend is being added to a region.
*/
public class DeletedFriendEvent extends CancellableRegionEvent<GeneralRegion> {
private final OfflinePlayer friend;
private final CommandSender by;
/**
* Constructor.
* @param region The region the friend is getting added to
* @param friend The friend that is about to be added
* @param by The CommandSender that is adding the friend, or null if none
*/
public DeletedFriendEvent(GeneralRegion region, OfflinePlayer friend, CommandSender by) {
super(region);
this.friend = friend;
this.by = by;
}
/**
* Get the OfflinePlayer that is getting added as friend.
* @return The friend that is getting added
*/
public OfflinePlayer getFriend() {
return friend;
}
/**
* Get the CommandSender that is adding the friend.
* @return null if none, a CommandSender if done by someone (likely Player or ConsoleCommandSender)
*/
public CommandSender getBy() {
return by;
}
}
@@ -0,0 +1,19 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
/**
* Broadcasted when a region has been added to AreaShop.
*/
public class AddedRegionEvent extends NotifyRegionEvent<GeneralRegion> {
/**
* Constructor.
* @param region The region that has been added
*/
public AddedRegionEvent(GeneralRegion region) {
super(region);
}
}
@@ -0,0 +1,19 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
/**
* Broadcasted when a region has been bought.
*/
public class BoughtRegionEvent extends NotifyRegionEvent<BuyRegion> {
/**
* Constructor.
* @param region The region that has been bought
*/
public BoughtRegionEvent(BuyRegion region) {
super(region);
}
}
@@ -0,0 +1,18 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
/**
* Broadcasted when a region has been removed from AreaShop.
*/
public class DeletedRegionEvent extends NotifyRegionEvent<GeneralRegion> {
/**
* Constructor.
* @param region The region that has been removed
*/
public DeletedRegionEvent(GeneralRegion region) {
super(region);
}
}
@@ -0,0 +1,31 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.RentRegion;
/**
* Broadcasted when a region has been rented.
*/
public class RentedRegionEvent extends NotifyRegionEvent<RentRegion> {
private final boolean extended;
/**
* Constructor.
* @param region The region that has been rented
* @param extended true if the region has been extended, false if this is the first time buying the region
*/
public RentedRegionEvent(RentRegion region, boolean extended) {
super(region);
this.region = region;
this.extended = extended;
}
/**
* Check if the region was extended or rented for the first time.
* @return true if the region was extended, false when rented for the first time
*/
public boolean hasExtended() {
return extended;
}
}
@@ -0,0 +1,32 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
import java.util.UUID;
/**
* Broadcasted when a region has been resold.
*/
public class ResoldRegionEvent extends NotifyRegionEvent<BuyRegion> {
private final UUID from;
/**
* Constructor.
* @param region The region that has been resold
* @param from The player from who the region has been resold to the current owner
*/
public ResoldRegionEvent(BuyRegion region, UUID from) {
super(region);
this.from = from;
}
/**
* Get the player that the region has been bought from.
* @return The UUID of the player that the region has been bought from
*/
public UUID getFromPlayer() {
return from;
}
}
@@ -0,0 +1,43 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.BuyRegion;
import java.util.UUID;
/**
* Broadcasted when a region is sold.
*/
public class SoldRegionEvent extends NotifyRegionEvent<BuyRegion> {
private final UUID oldBuyer;
private final double refundedMoney;
/**
* Constructor.
* @param region The region that has been sold
* @param oldBuyer The player for which the region has been sold
* @param refundedMoney The amount of money that has been refunded
*/
public SoldRegionEvent(BuyRegion region, UUID oldBuyer, double refundedMoney) {
super(region);
this.oldBuyer = oldBuyer;
this.refundedMoney = refundedMoney;
}
/**
* Get the player that the region is sold for.
* @return The UUID of the player that the region is sold for
*/
public UUID getOldBuyer() {
return oldBuyer;
}
/**
* Get the amount that is paid back to the player.
* @return The amount of money paid back to the player
*/
public double getRefundedMoney() {
return refundedMoney;
}
}
@@ -0,0 +1,43 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.RentRegion;
import java.util.UUID;
/**
* Broadcasted when a region has been unrented.
*/
public class UnrentedRegionEvent extends NotifyRegionEvent<RentRegion> {
private final UUID oldRenter;
private final double refundedMoney;
/**
* Constructor.
* @param region The region that has been unrented
* @param oldRenter The player that rented the region before it was unrented
* @param refundedMoney The amount of money that has been refunded
*/
public UnrentedRegionEvent(RentRegion region, UUID oldRenter, double refundedMoney) {
super(region);
this.oldRenter = oldRenter;
this.refundedMoney = refundedMoney;
}
/**
* Get the player that the region was unrented for.
* @return The UUID of the player that the region was unrented for
*/
public UUID getOldRenter() {
return oldRenter;
}
/**
* Get the amount that is paid back to the player.
* @return The amount of money paid back to the player
*/
public double getRefundedMoney() {
return refundedMoney;
}
}
@@ -0,0 +1,19 @@
package me.wiefferink.areashop.events.notify;
import me.wiefferink.areashop.events.NotifyRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
/**
* Broadcasted when the data of a region changes.
* Should be used for updating displays that use region data.
*/
public class UpdateRegionEvent extends NotifyRegionEvent<GeneralRegion> {
/**
* Contructor.
* @param region The region that has been updated
*/
public UpdateRegionEvent(GeneralRegion region) {
super(region);
}
}
@@ -0,0 +1,118 @@
package me.wiefferink.areashop.features;
import me.wiefferink.areashop.events.ask.AddingRegionEvent;
import me.wiefferink.areashop.events.ask.BuyingRegionEvent;
import me.wiefferink.areashop.events.ask.DeletingRegionEvent;
import me.wiefferink.areashop.events.ask.RentingRegionEvent;
import me.wiefferink.areashop.events.ask.ResellingRegionEvent;
import me.wiefferink.areashop.events.ask.SellingRegionEvent;
import me.wiefferink.areashop.events.ask.UnrentingRegionEvent;
import me.wiefferink.areashop.events.notify.AddedRegionEvent;
import me.wiefferink.areashop.events.notify.BoughtRegionEvent;
import me.wiefferink.areashop.events.notify.DeletedRegionEvent;
import me.wiefferink.areashop.events.notify.RentedRegionEvent;
import me.wiefferink.areashop.events.notify.ResoldRegionEvent;
import me.wiefferink.areashop.events.notify.SoldRegionEvent;
import me.wiefferink.areashop.events.notify.UnrentedRegionEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.Bukkit;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import java.util.List;
public class CommandsFeature extends RegionFeature {
/**
* Run command for a certain event.
* @param region Region to execute the events for
* @param event The event
* @param before The 'before' or 'after' commands
*/
public void runEventCommands(GeneralRegion region, GeneralRegion.RegionEvent event, boolean before) {
ConfigurationSection eventCommandProfileSection = region.getConfigurationSectionSetting("general.eventCommandProfile", "eventCommandProfiles");
if(eventCommandProfileSection == null) {
return;
}
List<String> commands = eventCommandProfileSection.getStringList(event.getValue() + "." + (before ? "before" : "after"));
if(commands == null || commands.isEmpty()) {
return;
}
region.runCommands(Bukkit.getConsoleSender(), commands);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void addingRegion(AddingRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.CREATED, true);
}
@EventHandler
public void addedRegion(AddedRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.CREATED, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void deletingRegion(DeletingRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.DELETED, true);
}
@EventHandler
public void deletedRegion(DeletedRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.DELETED, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void rentingRegion(RentingRegionEvent event) {
// Technically the rent can still be cancelled if the payment fails...
runEventCommands(event.getRegion(), event.isExtending() ? GeneralRegion.RegionEvent.EXTENDED : GeneralRegion.RegionEvent.RENTED, true);
}
@EventHandler
public void rentedRegion(RentedRegionEvent event) {
runEventCommands(event.getRegion(), event.hasExtended() ? GeneralRegion.RegionEvent.EXTENDED : GeneralRegion.RegionEvent.RENTED, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void buyingRegion(BuyingRegionEvent event) {
// Technically the buy can still be cancelled if the payment fails...
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.BOUGHT, true);
}
@EventHandler
public void boughtRegion(BoughtRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.BOUGHT, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void resellingRegion(ResellingRegionEvent event) {
// Technically the resell can still be cancelled if the payment fails...
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.RESELL, true);
}
@EventHandler
public void resoldRegion(ResoldRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.RESELL, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void sellingRegion(SellingRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.SOLD, true);
}
@EventHandler
public void soldRegion(SoldRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.SOLD, false);
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void unrentingRegion(UnrentingRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.UNRENTED, true);
}
@EventHandler
public void unrentedRegion(UnrentedRegionEvent event) {
runEventCommands(event.getRegion(), GeneralRegion.RegionEvent.UNRENTED, false);
}
}
@@ -0,0 +1,98 @@
package me.wiefferink.areashop.features;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.BuyingRegionEvent;
import me.wiefferink.areashop.events.ask.RentingRegionEvent;
import me.wiefferink.areashop.events.ask.ResellingRegionEvent;
import me.wiefferink.areashop.events.ask.SellingRegionEvent;
import me.wiefferink.areashop.events.ask.UnrentingRegionEvent;
import me.wiefferink.areashop.events.askandnotify.AddedFriendEvent;
import me.wiefferink.areashop.events.askandnotify.DeletedFriendEvent;
import me.wiefferink.areashop.events.notify.AddedRegionEvent;
import me.wiefferink.areashop.events.notify.BoughtRegionEvent;
import me.wiefferink.areashop.events.notify.DeletedRegionEvent;
import me.wiefferink.areashop.events.notify.RentedRegionEvent;
import me.wiefferink.areashop.events.notify.ResoldRegionEvent;
import me.wiefferink.areashop.events.notify.SoldRegionEvent;
import me.wiefferink.areashop.events.notify.UnrentedRegionEvent;
import me.wiefferink.areashop.events.notify.UpdateRegionEvent;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.event.EventHandler;
public class DebugFeature extends RegionFeature {
@EventHandler
public void buyingRegion(BuyingRegionEvent event) {
AreaShop.debug("BuyingRegionEvent: " + event.getPlayer().getName() + " is trying to buy " + event.getRegion().getName());
}
@EventHandler
public void boughtRegion(BoughtRegionEvent event) {
AreaShop.debug("BoughtRegionEvent: " + event.getRegion().getPlayerName() + " bought " + event.getRegion().getName());
}
@EventHandler
public void sellingRegion(SellingRegionEvent event) {
AreaShop.debug("SellingRegionEvent: " + event.getRegion().getName() + " is trying to sell " + event.getRegion().getName());
}
@EventHandler
public void soldRegion(SoldRegionEvent event) {
AreaShop.debug("SoldRegionEvent: " + Utils.toName(event.getOldBuyer()) + " sold " + event.getRegion().getName());
}
@EventHandler
public void resellingRegion(ResellingRegionEvent event) {
AreaShop.debug("ResellingRegionEvent: " + event.getRegion().getName() + " is trying to resell " + event.getRegion().getName());
}
@EventHandler
public void resoldRegion(ResoldRegionEvent event) {
AreaShop.debug("ResoldRegionEvent: " + Utils.toName(event.getFromPlayer()) + " resold " + event.getRegion().getName() + " to " + event.getRegion().getPlayerName());
}
@EventHandler
public void rentingRegion(RentingRegionEvent event) {
AreaShop.debug("RentingRegionEvent: " + event.getPlayer().getName() + " is trying to rent " + event.getRegion().getName() + ", extending=" + event.isExtending());
}
@EventHandler
public void rentedRegion(RentedRegionEvent event) {
AreaShop.debug("RentedRegionEvent: " + event.getRegion().getPlayerName() + " rented " + event.getRegion().getName() + ", extending=" + event.hasExtended());
}
@EventHandler
public void unrentingRegion(UnrentingRegionEvent event) {
AreaShop.debug("UnrentingRegionEvent: " + event.getRegion().getPlayerName() + " is trying to unrent " + event.getRegion().getName());
}
@EventHandler
public void unrentedRegion(UnrentedRegionEvent event) {
AreaShop.debug("UnrentedRegionEvent: " + Utils.toName(event.getOldRenter()) + " unrented " + event.getRegion().getName());
}
@EventHandler
public void regionUpdate(UpdateRegionEvent event) {
//AreaShop.debug("UpdateRegionEvent: " + event.getRegion().getName() + " updated");
}
@EventHandler
public void addedRegion(AddedRegionEvent event) {
AreaShop.debug("AddedRegionEvent: " + event.getRegion().getName());
}
@EventHandler
public void removedRegion(DeletedRegionEvent event) {
AreaShop.debug("DeletedRegionEvent: " + event.getRegion().getName());
}
@EventHandler
public void addedFriend(AddedFriendEvent event) {
AreaShop.debug("AddedFriendEvent: region " + event.getRegion().getName() + ", " + event.getFriend().getName() + " by " + (event.getBy() == null ? "<nobody>" : event.getBy().getName()));
}
@EventHandler
public void deleteFriend(DeletedFriendEvent event) {
AreaShop.debug("DeletedFriendEvent: region " + event.getRegion().getName() + ", " + event.getFriend().getName() + " by " + (event.getBy() == null ? "<nobody>" : event.getBy().getName()));
}
}
@@ -0,0 +1,109 @@
package me.wiefferink.areashop.features;
import me.wiefferink.areashop.events.askandnotify.AddedFriendEvent;
import me.wiefferink.areashop.events.askandnotify.DeletedFriendEvent;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.CommandSender;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.UUID;
public class FriendsFeature extends RegionFeature {
public FriendsFeature(GeneralRegion region) {
setRegion(region);
}
/**
* Add a friend to the region.
* @param player The UUID of the player to add
* @param by The CommandSender that is adding the friend, or null
* @return true if the friend has been added, false if adding a friend was cancelled by another plugin
*/
public boolean addFriend(UUID player, CommandSender by) {
// Fire and check event
AddedFriendEvent event = new AddedFriendEvent(getRegion(), Bukkit.getOfflinePlayer(player), by);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
plugin.message(by, "general-cancelled", event.getReason(), this);
return false;
}
Set<String> friends = new HashSet<>(getRegion().getConfig().getStringList("general.friends"));
friends.add(player.toString());
List<String> list = new ArrayList<>(friends);
getRegion().setSetting("general.friends", list);
return true;
}
/**
* Delete a friend from the region.
* @param player The UUID of the player to delete
* @param by The CommandSender that is adding the friend, or null
* @return true if the friend has been added, false if adding a friend was cancelled by another plugin
*/
public boolean deleteFriend(UUID player, CommandSender by) {
// Fire and check event
DeletedFriendEvent event = new DeletedFriendEvent(getRegion(), Bukkit.getOfflinePlayer(player), by);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
plugin.message(by, "general-cancelled", event.getReason(), this);
return false;
}
Set<String> friends = new HashSet<>(getRegion().getConfig().getStringList("general.friends"));
friends.remove(player.toString());
List<String> list = new ArrayList<>(friends);
if(list.isEmpty()) {
getRegion().setSetting("general.friends", null);
} else {
getRegion().setSetting("general.friends", list);
}
return true;
}
/**
* Get the list of friends added to this region.
* @return Friends added to this region
*/
public Set<UUID> getFriends() {
HashSet<UUID> result = new HashSet<>();
for(String friend : getRegion().getConfig().getStringList("general.friends")) {
try {
UUID id = UUID.fromString(friend);
result.add(id);
} catch(IllegalArgumentException e) {
// Don't add it
}
}
return result;
}
/**
* Get the list of friends added to this region.
* @return Friends added to this region
*/
public Set<String> getFriendNames() {
HashSet<String> result = new HashSet<>();
for(UUID friend : getFriends()) {
OfflinePlayer player = Bukkit.getOfflinePlayer(friend);
if(player.hasPlayedBefore() && player.getName() != null) {
result.add(player.getName());
}
}
return result;
}
/**
* Remove all friends that are added to this region.
*/
public void clearFriends() {
getRegion().setSetting("general.friends", null);
}
}
@@ -0,0 +1,6 @@
# Features
This package contains classes that represent a certain feature and implement it for all regions.
* `RegionFeature` represents a single feature, for each implementing class one instance is created without an assigned region, to listen for events etc, and an instance per region is created on-demand to handle region specific things.
* More features will be moved from `GeneralRegion` to these kind of classes, to keep all code for a feature together and cleanup `GeneralRegion`.
@@ -0,0 +1,73 @@
package me.wiefferink.areashop.features;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.regions.GeneralRegion;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
/*
Possible future feature classes:
- RestrictedToRegion feature
- rent/buy restricted to the region itself
- RestrictedToWorld feature
- rent/buy restricted to the world of the region
- CountLimitsFeature:
- Check region limits
- TimeLimitsFeatures:
- maxExtends
- maxRentTime
- SchematicFeature
- save/load schematics
- CommandsFeature
- execute commands after extend/rent/etc
- LandlordFeature
- manage landlords
- ExpirationWarningsFeature
- sending rental expiration warnings
*/
public abstract class RegionFeature implements Listener {
public static final AreaShop plugin = AreaShop.getInstance();
protected YamlConfiguration config = plugin.getConfig();
private GeneralRegion region;
/**
* Set the region for this feature.
* @param region Feature region
*/
public void setRegion(GeneralRegion region) {
this.region = region;
}
/**
* Get the region of this feature.
* @return region of this feature, or null if generic
*/
public GeneralRegion getRegion() {
return region;
}
/**
* Start listening to events.
*/
public void listen() {
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
/**
* Destroy the feature and deregister everything.
*/
public void shutdownFeature() {
HandlerList.unregisterAll(this);
shutdown();
}
/**
* Dummy method a RegionFeature implementation can override.
*/
public void shutdown() {
}
}
@@ -0,0 +1,600 @@
package me.wiefferink.areashop.features;
import co.aikar.taskchain.TaskChain;
import com.sk89q.worldedit.math.BlockVector3;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import io.papermc.lib.PaperLib;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.features.signs.RegionSign;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.areashop.tools.Value;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
public class TeleportFeature extends RegionFeature {
public TeleportFeature() {
}
public TeleportFeature(GeneralRegion region) {
setRegion(region);
}
/**
* Checks if a certain location is safe to teleport to.
*
* @param location The location to check
* @return true if it is safe, otherwise false
*/
private static boolean isSafe(Location location) {
Block feet = location.getBlock();
BlockState head = PaperLib.getBlockState(feet.getRelative(BlockFace.UP), true).getState();
BlockState below = PaperLib.getBlockState(feet.getRelative(BlockFace.DOWN), true).getState();
BlockState above = PaperLib.getBlockState(head.getBlock().getRelative(BlockFace.UP), true).getState();
// Check the block at the feet and head of the player
if ((feet.getType().isSolid() && !canSpawnIn(feet.getType())) || feet.isLiquid()) {
return false;
} else if ((head.getType().isSolid() && !canSpawnIn(head.getType())) || head.getBlock().isLiquid()) {
return false;
} else if (!below.getType().isSolid() || cannotSpawnOn(below.getType()) || below.getBlock().isLiquid()) {
return false;
} else if (above.getBlock().isLiquid() || cannotSpawnBeside(above.getType())) {
return false;
}
// Get all blocks around the player (below foot level, foot level, head level and above head level)
Set<Material> around = new HashSet<>();
for (int y = 0; y <= 3; y++) {
for (int x = -1; x <= 1; x++) {
for (int z = -1; z <= 1; z++) {
// Skip blocks in the column of the player
if (x == 0 && z == 0) {
continue;
}
around.add(PaperLib.getBlockState(below.getBlock().getRelative(x, y, z), true).getState().getType());
}
}
}
// Check the blocks around the player
for (Material material : around) {
if (cannotSpawnBeside(material)) {
return false;
}
}
return true;
}
/**
* Check if a player can spawn in here.
*
* @param material Material to check (assumed that this is at the feet or head level)
* @return true when it is safe to spawn inside, otherwise false
*/
private static boolean canSpawnIn(Material material) {
String name = material.name();
return name.contains("DOOR")
|| name.contains("SIGN")
|| name.contains("PLATE") // Redstone plates
|| name.equals("DRAGON_EGG");
}
/**
* Check if a player can spawn on here.
*
* @param material Material to check (assumed that this is below the feet)
* @return true when it is safe to spawn on top of, otherwise false
*/
private static boolean cannotSpawnOn(Material material) {
String name = material.name();
return name.equals("CACTUS")
|| name.contains("PISTON")
|| name.contains("SIGN")
|| name.contains("DOOR")
|| name.contains("PLATE")
|| name.contains("REDSTONE_LAMP")
|| name.contains("FENCE")
|| name.contains("GLASS_PANE") || name.contains("THIN_GLASS")
|| name.equals("DRAGON_EGG")
|| name.contains("MAGMA");
}
/**
* Check if a player can spawn next to it.
*
* @param material Material to check (assumed that this is somewhere around the player)
* @return true when it is safe to spawn next to, otherwise false
*/
private static boolean cannotSpawnBeside(Material material) {
String name = material.name();
return name.contains("LAVA")
|| name.contains("CACTUS")
|| name.equals("FIRE")
|| name.contains("MAGMA");
}
/**
* Get the teleportlocation set for this region.
*
* @return The teleport location, or null if not set
*/
public Location getTeleportLocation() {
return Utils.configToLocation(getRegion().getConfigurationSectionSetting("general.teleportLocation"));
}
/**
* Check if the region has a teleportLocation specified.
*
* @return true if the region has a teleportlocation, false otherwise
*/
public boolean hasTeleportLocation() {
return getRegion().getConfigurationSectionSetting("general.teleportLocation") != null;
}
/**
* Set the teleport location of this region.
*
* @param location The location to set as teleport location
*/
public void setTeleport(Location location) {
if (location == null) {
getRegion().setSetting("general.teleportLocation", null);
} else {
getRegion().setSetting("general.teleportLocation", Utils.locationToConfig(location, true));
}
}
/**
* Teleport a player to the region or sign.
*
* @param player Player that should be teleported
* @param toSign true to teleport to the first sign of the region, false for teleporting to the region itself
* @param checkRestrictions Set to true if teleport permissions should be checked, false otherwise, also toggles cross-world check
* @return true if the teleport succeeded, otherwise false
*/
public CompletableFuture<Boolean> teleportPlayer(Player player, boolean toSign, boolean checkRestrictions) {
// Check basics
if (getRegion().getWorld() == null) {
getRegion().message(player, "general-noWorld");
return CompletableFuture.completedFuture(false);
}
if (getRegion().getRegion() == null) {
getRegion().message(player, "general-noRegion");
return CompletableFuture.completedFuture(false);
}
if (checkRestrictions) {
// Check correct world
if (!getRegion().getBooleanSetting("general.teleportCrossWorld") && !player.getWorld().equals(getRegion().getWorld())) {
getRegion().message(player, "teleport-wrongWorld", player.getWorld().getName());
return CompletableFuture.completedFuture(false);
}
boolean owner = player.getUniqueId().equals(getRegion().getOwner());
boolean friend = getRegion().getFriendsFeature().getFriends().contains(player.getUniqueId());
boolean available = getRegion().isAvailable();
// Teleport to sign instead if they dont have permission for teleporting to region
if ((!toSign && owner && !player.hasPermission("areashop.teleport") && player.hasPermission("areashop.teleportsign")
|| !toSign && !owner && !friend && !player.hasPermission("areashop.teleportall") && player.hasPermission("areashop.teleportsignall")
|| !toSign && !owner && friend && !player.hasPermission("areashop.teleportfriend") && player.hasPermission("areashop.teleportfriendsign")
|| !toSign && !owner && !friend && available && !player.hasPermission("areashop.teleportavailable") && player.hasPermission("areashop.teleportavailablesign"))) {
getRegion().message(player, "teleport-changedToSign");
toSign = true;
}
// Check permissions
if (owner && !available && !player.hasPermission("areashop.teleport") && !toSign) {
getRegion().message(player, "teleport-noPermission");
return CompletableFuture.completedFuture(false);
} else if (!owner && !available && !player.hasPermission("areashop.teleportall") && !toSign && !friend) {
getRegion().message(player, "teleport-noPermissionOther");
return CompletableFuture.completedFuture(false);
} else if (!owner && !available && !player.hasPermission("areashop.teleportfriend") && !toSign && friend) {
getRegion().message(player, "teleport-noPermissionFriend");
return CompletableFuture.completedFuture(false);
} else if (available && !player.hasPermission("areashop.teleportavailable") && !toSign) {
getRegion().message(player, "teleport-noPermissionAvailable");
return CompletableFuture.completedFuture(false);
} else if (owner && !available && !player.hasPermission("areashop.teleportsign") && toSign) {
getRegion().message(player, "teleport-noPermissionSign");
return CompletableFuture.completedFuture(false);
} else if (!owner && !available && !player.hasPermission("areashop.teleportsignall") && toSign && !friend) {
getRegion().message(player, "teleport-noPermissionOtherSign");
return CompletableFuture.completedFuture(false);
} else if (!owner && !available && !player.hasPermission("areashop.teleportfriendsign") && toSign && friend) {
getRegion().message(player, "teleport-noPermissionFriendSign");
return CompletableFuture.completedFuture(false);
} else if (available && !player.hasPermission("areashop.teleportavailablesign") && toSign) {
getRegion().message(player, "teleport-noPermissionAvailableSign");
return CompletableFuture.completedFuture(false);
}
}
// Get the starting location
Value<Boolean> toSignRef = new Value<>(toSign);
Location startLocation = getStartLocation(player, toSignRef);
toSign = toSignRef.get();
boolean insideRegion;
if (toSign) {
insideRegion = getRegion().getBooleanSetting("general.teleportToSignIntoRegion");
} else {
insideRegion = getRegion().getBooleanSetting("general.teleportIntoRegion");
}
// Check locations starting from startLocation and then a cube that increases
// radius around that (until no block in the region is found at all cube sides)
ProtectedRegion worldguardRegion = getRegion().getRegion();
boolean blocksInRegion = worldguardRegion.contains(startLocation.getBlockX(), startLocation.getBlockY(), startLocation.getBlockZ());
if (!blocksInRegion && insideRegion) {
getRegion().message(player, "teleport-blocked");
return CompletableFuture.completedFuture(false);
}
// Tracking of which sides to continue the search
final World world = getRegion().getWorld();
BlockVector3 min = worldguardRegion.getMinimumPoint();
BlockVector3 max = worldguardRegion.getMaximumPoint();
final Collection<int[]> collection = new HashSet<>();
for (int x = min.getX(); x < max.getX(); x += 16) {
for (int z = min.getZ(); z < max.getZ(); z += 16) {
collection.add(new int[]{x, z});
}
}
final CompletableFuture<Boolean> future = new CompletableFuture<>();
final boolean finalToSign = toSign;
TaskChain<?> chain = Utils.newChain();
if (collection.size() < 64) {
chain = chain.future(Utils.runAsBatches(collection, 16, (arr) -> PaperLib.getChunkAtAsync(world, arr[0], arr[1]), false));
}
chain.delay(3).syncLast((unused) -> {
boolean blocksInRegionCopy = blocksInRegion;
Location safeLocation = startLocation;
// Tries limit tracking
int radius = 1;
int checked = 1;
int maxTries = plugin.getConfig().getInt("maximumTries");
// Tracking of which sides to continue the search
boolean done = isSafe(safeLocation);
boolean northDone = false, eastDone = false, southDone = false, westDone = false, topDone = false, bottomDone = false;
boolean continueThisDirection;
while ((blocksInRegionCopy || !insideRegion) && !done) {
blocksInRegionCopy = false;
// North side
continueThisDirection = false;
for (int x = -radius + 1; x <= radius && !done && !northDone; x++) {
for (int y = -radius + 1; y < radius && !done; y++) {
safeLocation = startLocation.clone().add(x, y, -radius);
if (safeLocation.getBlockY() > 256 || safeLocation.getBlockY() < 0) {
continue;
}
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
northDone = northDone || !continueThisDirection;
// East side
continueThisDirection = false;
for (int z = -radius + 1; z <= radius && !done && !eastDone; z++) {
for (int y = -radius + 1; y < radius && !done; y++) {
safeLocation = startLocation.clone().add(radius, y, z);
if (safeLocation.getBlockY() > 256 || safeLocation.getBlockY() < 0) {
continue;
}
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
eastDone = eastDone || !continueThisDirection;
// South side
continueThisDirection = false;
for (int x = radius - 1; x >= -radius && !done && !southDone; x--) {
for (int y = -radius + 1; y < radius && !done; y++) {
safeLocation = startLocation.clone().add(x, y, radius);
if (safeLocation.getBlockY() > 256 || safeLocation.getBlockY() < 0) {
continue;
}
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
southDone = southDone || !continueThisDirection;
// West side
continueThisDirection = false;
for (int z = radius - 1; z >= -radius && !done && !westDone; z--) {
for (int y = -radius + 1; y < radius && !done; y++) {
safeLocation = startLocation.clone().add(-radius, y, z);
if (safeLocation.getBlockY() > 256 || safeLocation.getBlockY() < 0) {
continue;
}
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
westDone = westDone || !continueThisDirection;
// Top side
continueThisDirection = false;
// Middle block of the top
if ((startLocation.getBlockY() + radius) > 256) {
topDone = true;
}
if (!done && !topDone) {
safeLocation = startLocation.clone().add(0, radius, 0);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
for (int r = 1; r <= radius && !done && !topDone; r++) {
// North
for (int x = -r + 1; x <= r && !done; x++) {
safeLocation = startLocation.clone().add(x, radius, -r);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// East
for (int z = -r + 1; z <= r && !done; z++) {
safeLocation = startLocation.clone().add(r, radius, z);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// South side
for (int x = r - 1; x >= -r && !done; x--) {
safeLocation = startLocation.clone().add(x, radius, r);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// West side
for (int z = r - 1; z >= -r && !done; z--) {
safeLocation = startLocation.clone().add(-r, radius, z);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
topDone = topDone || !continueThisDirection;
// Bottom side
continueThisDirection = false;
// Middle block of the bottom
if (startLocation.getBlockY() - radius < 0) {
bottomDone = true;
}
if (!done && !bottomDone) {
safeLocation = startLocation.clone().add(0, -radius, 0);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
for (int r = 1; r <= radius && !done && !bottomDone; r++) {
// North
for (int x = -r + 1; x <= r && !done; x++) {
safeLocation = startLocation.clone().add(x, -radius, -r);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// East
for (int z = -r + 1; z <= r && !done; z++) {
safeLocation = startLocation.clone().add(r, -radius, z);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// South side
for (int x = r - 1; x >= -r && !done; x--) {
safeLocation = startLocation.clone().add(x, -radius, r);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
// West side
for (int z = r - 1; z >= -r && !done; z--) {
safeLocation = startLocation.clone().add(-r, -radius, z);
if (worldguardRegion.contains(safeLocation.getBlockX(), safeLocation.getBlockY(), safeLocation.getBlockZ()) || !insideRegion) {
checked++;
done = isSafe(safeLocation) || checked > maxTries;
blocksInRegionCopy = true;
continueThisDirection = true;
}
}
}
bottomDone = bottomDone || !continueThisDirection;
// Increase cube radius
radius++;
}
if (done && isSafe(safeLocation)) {
if (finalToSign) {
getRegion().message(player, "teleport-successSign");
// Let the player look at the sign
Vector playerVector = safeLocation.toVector();
playerVector.setY(playerVector.getY() + player.getEyeHeight(true));
Vector signVector = getRegion().getSignsFeature().getSigns().get(0).getLocation().toVector().add(new Vector(0.5, 0.5, 0.5));
Vector direction = playerVector.clone().subtract(signVector).normalize();
safeLocation.setYaw(180 - (float) Math.toDegrees(Math.atan2(direction.getX(), direction.getZ())));
safeLocation.setPitch(90 - (float) Math.toDegrees(Math.acos(direction.getY())));
} else {
getRegion().message(player, "teleport-success");
}
AreaShop.debug("Found location: " + safeLocation.toString() + " Tries: " + checked);
PaperLib.teleportAsync(player, safeLocation).thenAccept(future::complete);
} else {
getRegion().message(player, "teleport-noSafe", checked, maxTries);
AreaShop.debug("No location found, checked " + checked + " spots of max " + maxTries);
future.complete(false);
}
}).execute();
return future;
}
/**
* Teleport a player to the region or sign when he has permissions for it.
*
* @param player Player that should be teleported
* @param toSign true to teleport to the first sign of the region, false for teleporting to the region itself
* @return true if the teleport succeeded, otherwise false
*/
public CompletableFuture<Boolean> teleportPlayer(Player player, boolean toSign) {
return teleportPlayer(player, toSign, true);
}
/**
* Teleport a player to the region when he has permissions for it.
*
* @param player Player that should be teleported
* @return true if the teleport succeeded, otherwise false
*/
public CompletableFuture<Boolean> teleportPlayer(Player player) {
return teleportPlayer(player, false, true);
}
/**
* Get the start location of a safe teleport search.
*
* @param player The player to get it for
* @param toSign true to try teleporting to the first sign, false for teleporting to the region
* @return The start location
*/
private Location getStartLocation(Player player, Value<Boolean> toSign) {
Location startLocation = null;
ProtectedRegion worldguardRegion = getRegion().getRegion();
// Try to get sign location
List<RegionSign> signs = getRegion().getSignsFeature().getSigns();
boolean signAvailable = !signs.isEmpty();
if (toSign.get()) {
if (signAvailable) {
// Use the location 1 below the sign to prevent weird spawing above the sign
startLocation = signs.get(0).getLocation(); //.subtract(0.0, 1.0, 0.0);
startLocation.setPitch(player.getLocation().getPitch());
startLocation.setYaw(player.getLocation().getYaw());
// Move player x blocks away from the sign
double distance = getRegion().getDoubleSetting("general.teleportSignDistance");
if (distance > 0) {
BlockFace facing = getRegion().getSignsFeature().getSigns().get(0).getFacing();
Vector facingVector = new Vector(facing.getModX(), facing.getModY(), facing.getModZ())
.normalize()
.multiply(distance);
startLocation.setX(startLocation.getBlockX() + 0.5);
startLocation.setZ(startLocation.getBlockZ() + 0.5);
startLocation.add(facingVector);
}
} else {
// No sign available
getRegion().message(player, "teleport-changedToNoSign");
toSign.set(false);
}
}
// Use teleportation location that is set for the region
if (startLocation == null && hasTeleportLocation()) {
startLocation = getTeleportLocation();
}
// Calculate a default location
if (startLocation == null) {
// Set to block in the middle, y configured in the config
Vector regionMin = AreaShop.getInstance().getWorldGuardHandler().getMinimumPoint(worldguardRegion);
Vector regionMax = AreaShop.getInstance().getWorldGuardHandler().getMaximumPoint(worldguardRegion);
Vector middle = regionMin.clone().midpoint(regionMax);
String configSetting = getRegion().getStringSetting("general.teleportLocationY");
if ("bottom".equalsIgnoreCase(configSetting)) {
middle = middle.setY(regionMin.getBlockY());
} else if ("top".equalsIgnoreCase(configSetting)) {
middle = middle.setY(regionMax.getBlockY());
} else if ("middle".equalsIgnoreCase(configSetting)) {
middle = middle.setY(middle.getBlockY());
} else {
try {
int vertical = Integer.parseInt(configSetting);
middle = middle.setY(vertical);
} catch (NumberFormatException e) {
AreaShop.warn("Could not parse general.teleportLocationY: '" + configSetting + "'");
}
}
startLocation = new Location(getRegion().getWorld(), middle.getX(), middle.getY(), middle.getZ(), player.getLocation().getYaw(), player.getLocation().getPitch());
}
// Set location in the center of the block
startLocation.setX(startLocation.getBlockX() + 0.5);
startLocation.setZ(startLocation.getBlockZ() + 0.5);
return startLocation;
}
}
@@ -0,0 +1,265 @@
package me.wiefferink.areashop.features;
import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
import com.sk89q.worldguard.protection.flags.Flag;
import com.sk89q.worldguard.protection.flags.InvalidFlagFormat;
import com.sk89q.worldguard.protection.flags.RegionGroupFlag;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.notify.UpdateRegionEvent;
import me.wiefferink.areashop.interfaces.RegionAccessSet;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.event.EventHandler;
import java.util.Objects;
import java.util.Set;
import java.util.UUID;
public class WorldGuardRegionFlagsFeature extends RegionFeature {
@EventHandler
public void regionUpdate(UpdateRegionEvent event) {
updateRegionFlags(event.getRegion());
}
/**
* Set the region flags/options to the values of a ConfigurationSection.
* @param region The region to update the flags for
* @return true if the flags have been set correctly, otherwise false
*/
private boolean updateRegionFlags(GeneralRegion region) {
boolean result = true;
// Get section defining the region flag profile
ConfigurationSection flagProfileSection = region.getConfigurationSectionSetting("general.flagProfile", "flagProfiles");
if(flagProfileSection == null) {
return false;
}
// Region flags for all states
ConfigurationSection allFlags = flagProfileSection.getConfigurationSection("ALL");
if(allFlags != null) {
result = updateRegionFlags(region, allFlags);
}
// Region flags for the current state
ConfigurationSection stateFlags = flagProfileSection.getConfigurationSection(region.getState().getValue());
// If in reselling mode, fallback to 'resale' section if 'resell' is not found (legacy configuration problem: https://github.com/NLthijs48/AreaShop/issues/303)
if(stateFlags == null && region.getState() == GeneralRegion.RegionState.RESELL) {
stateFlags = flagProfileSection.getConfigurationSection("resale");
}
if(stateFlags != null) {
result &= updateRegionFlags(region, stateFlags);
}
return result;
}
/**
* Set the region flags/options to the values of a ConfigurationSection.
* @param region The region to update the flags for
* @param flags The flags to apply
* @return true if the flags have been set correctly, otherwise false
*/
private boolean updateRegionFlags(GeneralRegion region, ConfigurationSection flags) {
boolean result = true;
Set<String> flagNames = flags.getKeys(false);
WorldGuardPlugin worldGuard = plugin.getWorldGuard();
// Get the region
ProtectedRegion worldguardRegion = region.getRegion();
if(worldguardRegion == null) {
AreaShop.debug("Region '" + region.getName() + "' does not exist, setting flags failed");
return false;
}
// Loop through all flags that are set in the config
for(String flagName : flagNames) {
String value = Message.fromString(flags.getString(flagName)).replacements(region).getPlain();
// In the config normal Bukkit color codes are used, those only need to be translated on 5.X WorldGuard versions
if(plugin.getWorldGuard().getDescription().getVersion().startsWith("5.")) {
value = translateBukkitToWorldGuardColors(value);
}
if(flagName.equalsIgnoreCase("members")) {
plugin.getWorldGuardHandler().setMembers(worldguardRegion, parseAccessSet(value));
//AreaShop.debug(" Flag " + flagName + " set: " + members.toUserFriendlyString());
} else if(flagName.equalsIgnoreCase("owners")) {
plugin.getWorldGuardHandler().setOwners(worldguardRegion, parseAccessSet(value));
//AreaShop.debug(" Flag " + flagName + " set: " + owners.toUserFriendlyString());
} else if(flagName.equalsIgnoreCase("priority")) {
try {
int priority = Integer.parseInt(value);
if(worldguardRegion.getPriority() != priority) {
worldguardRegion.setPriority(priority);
}
//AreaShop.debug(" Flag " + flagName + " set: " + value);
} catch(NumberFormatException e) {
AreaShop.warn("The value of flag " + flagName + " is not a number");
result = false;
}
} else if(flagName.equalsIgnoreCase("parent")) {
if(region.getWorld() == null || plugin.getRegionManager(region.getWorld()) == null) {
continue;
}
ProtectedRegion parentRegion = plugin.getRegionManager(region.getWorld()).getRegion(value);
if(parentRegion != null) {
if(!parentRegion.equals(worldguardRegion.getParent())) {
try {
worldguardRegion.setParent(parentRegion);
//AreaShop.debug(" Flag " + flagName + " set: " + value);
} catch(ProtectedRegion.CircularInheritanceException e) {
AreaShop.warn("The parent set in the config is not correct (circular inheritance)");
}
}
} else {
AreaShop.warn("The parent set in the config is not correct (region does not exist)");
}
} else {
// Parse all other normal flags (groups are also handled)
String flagSetting = null;
com.sk89q.worldguard.protection.flags.RegionGroup groupValue = null;
Flag<?> foundFlag = plugin.getWorldGuardHandler().fuzzyMatchFlag(flagName);
if(foundFlag == null) {
AreaShop.warn("Found wrong flag in flagProfiles section: " + flagName + ", check if that is the correct WorldGuard flag");
continue;
}
RegionGroupFlag groupFlag = foundFlag.getRegionGroupFlag();
if(value == null || value.isEmpty()) {
if(worldguardRegion.getFlag(foundFlag) != null) {
worldguardRegion.setFlag(foundFlag, null);
}
if(groupFlag != null && worldguardRegion.getFlag(groupFlag) != null) {
worldguardRegion.setFlag(groupFlag, null);
}
//AreaShop.debug(" Flag " + flagName + " reset (+ possible group of flag)");
} else {
if(groupFlag == null) {
flagSetting = value;
} else {
for(String part : value.split(" ")) {
if(part.startsWith("g:")) {
if(part.length() > 2) {
try {
groupValue = plugin.getWorldGuardHandler().parseFlagGroupInput(groupFlag, part.substring(2));
} catch(InvalidFlagFormat e) {
AreaShop.warn("Found wrong group value for flag " + flagName);
}
}
} else {
if(flagSetting == null) {
flagSetting = part;
} else {
flagSetting += " " + part;
}
}
}
}
if(flagSetting != null) {
try {
setFlag(worldguardRegion, foundFlag, flagSetting);
//AreaShop.debug(" Flag " + flagName + " set: " + flagSetting);
} catch(InvalidFlagFormat e) {
AreaShop.warn("Found wrong value for flag " + flagName);
}
}
if(groupValue != null) {
if(groupValue == groupFlag.getDefault()) {
worldguardRegion.setFlag(groupFlag, null);
//AreaShop.debug(" Group of flag " + flagName + " set to default: " + groupValue);
} else {
worldguardRegion.setFlag(groupFlag, groupValue);
//AreaShop.debug(" Group of flag " + flagName + " set: " + groupValue);
}
}
}
}
}
// Indicate that the regions needs to be saved
if(worldGuard.getDescription().getVersion().startsWith("5.")) {
plugin.getFileManager().saveIsRequiredForRegionWorld(region.getWorldName());
}
return result;
}
/**
* Build an RegionAccessSet from an input that specifies player names, player uuids and groups.
* @param input Input string defining the access set
* @return RegionAccessSet containing the entities parsed from the input
*/
public RegionAccessSet parseAccessSet(String input) {
RegionAccessSet result = new RegionAccessSet();
String[] inputParts = input.split(", ");
for(String access : inputParts) {
if(access != null && !access.isEmpty()) {
// Check for groups
if(access.startsWith("g:")) {
if(access.length() > 2) {
result.getGroupNames().add(access.substring(2));
}
} else if(access.startsWith("n:")) {
if(access.length() > 2) {
result.getPlayerNames().add(access.substring(2));
}
} else {
try {
result.getPlayerUniqueIds().add(UUID.fromString(access));
} catch(IllegalArgumentException e) {
AreaShop.warn("Tried using '" + access + "' as uuid for a region member/owner, is your flagProfiles section correct?");
}
}
}
}
return result;
}
/**
* Set a WorldGuard region flag.
* @param region The WorldGuard region to set
* @param flag The flag to set
* @param value The value to set the flag to
* @param <V> They type of flag to set
* @throws InvalidFlagFormat When the value of the flag is wrong
*/
private <V> void setFlag(ProtectedRegion region, Flag<V> flag, String value) throws InvalidFlagFormat {
V current = region.getFlag(flag);
V next = plugin.getWorldGuardHandler().parseFlagInput(flag, value);
if(!Objects.equals(current, next)) {
region.setFlag(flag, next);
}
}
/**
* Translate the color codes you put in greeting/farewell messages to the weird color codes of WorldGuard.
* @param message The message where the color codes should be translated (this message has bukkit color codes)
* @return The string with the WorldGuard color codes
*/
private String translateBukkitToWorldGuardColors(String message) {
String result = message;
result = result.replace("&c", "&r");
result = result.replace("&4", "&R");
result = result.replace("&e", "&y");
result = result.replace("&6", "&Y");
result = result.replace("&a", "&g");
result = result.replace("&2", "&G");
result = result.replace("&b", "&c");
result = result.replace("&3", "&C");
result = result.replace("&9", "&b");
result = result.replace("&1", "&B");
result = result.replace("&d", "&p");
result = result.replace("&5", "&P");
//result = result.replace("&0", "&0");
result = result.replace("&8", "&1");
result = result.replace("&7", "&2");
result = result.replace("&f", "&w");
result = result.replace("&r", "&x");
return result;
}
}
@@ -0,0 +1,287 @@
package me.wiefferink.areashop.features.signs;
import com.google.common.base.Objects;
import io.papermc.lib.PaperLib;
import io.papermc.lib.features.blockstatesnapshot.BlockStateSnapshotResult;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Materials;
import me.wiefferink.areashop.tools.Utils;
import me.wiefferink.interactivemessenger.processing.Message;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.BlockState;
import org.bukkit.block.Sign;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.List;
/**
* Sign that is connected to a region to display information and interact with the region.
*/
public class RegionSign {
private final SignsFeature signsFeature;
private final String key;
public RegionSign(SignsFeature signsFeature, String key) {
this.signsFeature = signsFeature;
this.key = key;
}
/**
* Get the location of this sign.
*
* @return The location of this sign
*/
public Location getLocation() {
return Utils.configToLocation(getRegion().getConfig().getConfigurationSection("general.signs." + key + ".location"));
}
/**
* Location string to be used as key in maps.
*
* @return Location string
*/
public String getStringLocation() {
return SignsFeature.locationToString(getLocation());
}
/**
* Chunk string to be used as key in maps.
*
* @return Chunk string
*/
public String getStringChunk() {
return SignsFeature.chunkToString(getLocation());
}
/**
* Get the region this sign is linked to.
*
* @return The region this sign is linked to
*/
public GeneralRegion getRegion() {
return signsFeature.getRegion();
}
/**
* Remove this sign from the region.
*/
public void remove() {
getLocation().getBlock().setType(Material.AIR);
signsFeature.getSignsRef().remove(getStringLocation());
SignsFeature.getAllSigns().remove(getStringLocation());
SignsFeature.getSignsByChunk().get(getStringChunk()).remove(this);
getRegion().setSetting("general.signs." + key, null);
}
/**
* Get the ConfigurationSection defining the sign layout.
*
* @return The sign layout config
*/
public ConfigurationSection getProfile() {
return getRegion().getConfigurationSectionSetting("general.signProfile", "signProfiles", getRegion().getConfig().get("general.signs." + key + ".profile"));
}
/**
* Get the facing of the sign as saved in the config.
*
* @return BlockFace the sign faces, or null if unknown
*/
public BlockFace getFacing() {
try {
return BlockFace.valueOf(getRegion().getConfig().getString("general.signs." + key + ".facing"));
} catch (NullPointerException | IllegalArgumentException e) {
return null;
}
}
/**
* Get the material of the sign as saved in the config.
*
* @return Material of the sign, usually {@link Material#WALL_SIGN}, {@link Material#SIGN}, or one of the other wood types (different result for 1.13-), Material.AIR if none.
*/
public Material getMaterial() {
String name = getRegion().getConfig().getString("general.signs." + key + ".signType");
Material result = Materials.signNameToMaterial(name);
return result == null ? Material.AIR : result;
}
/**
* Update this sign.
*
* @return true if the update was successful, otherwise false
*/
public boolean update() {
// Ignore updates of signs in chunks that are not loaded
Location signLocation = getLocation();
if (signLocation == null
|| signLocation.getWorld() == null
|| !signLocation.getWorld().isChunkLoaded(signLocation.getBlockX() >> 4, signLocation.getBlockZ() >> 4)) {
return false;
}
if (getRegion().isDeleted()) {
return false;
}
YamlConfiguration regionConfig = getRegion().getConfig();
ConfigurationSection signConfig = getProfile();
Block block = signLocation.getBlock();
if (signConfig == null || !signConfig.isSet(getRegion().getState().getValue())) {
block.setType(Material.AIR);
return true;
}
ConfigurationSection stateConfig = signConfig.getConfigurationSection(getRegion().getState().getValue());
assert stateConfig != null;
// Get the lines
String[] signLines = new String[4];
boolean signEmpty = true;
for (int i = 0; i < 4; i++) {
signLines[i] = stateConfig.getString("line" + (i + 1));
signEmpty &= (signLines[i] == null || signLines[i].isEmpty());
}
if (signEmpty) {
block.setType(Material.AIR);
return true;
}
final BlockStateSnapshotResult snapshotResult = PaperLib.getBlockState(block, true);
final BlockState blockState = snapshotResult.getState();
// Place the sign back (with proper rotation and type) after it has been hidden or (indirectly) destroyed
if (!Materials.isSign(block.getType())) {
Material signType = getMaterial();
if (signType.name().contains("SIGN")) {
final BlockData data = blockState.getBlockData();
// Don't do physics here, we first need to update the direction
blockState.setType(signType);
if (data instanceof WallSign) {
((WallSign) data).setFacing(getFacing());
} else if (data instanceof Sign) {
((org.bukkit.block.data.type.Sign) data).setRotation(getFacing());
}
blockState.setBlockData(data);
blockState.update(false, false);
// Check if the sign has popped
if (!Materials.isSign(block.getType())) {
AreaShop.warn("Setting sign", key, "of region", getRegion().getName(), "failed, could not set sign block back");
return false;
}
} else {
AreaShop.warn("Setting sign", key, "of region", getRegion().getName(), "failed, RegionSign material was: " + signType.name());
}
}
// Save current rotation and type
if (!regionConfig.isString("general.signs." + key + ".signType")) {
getRegion().setSetting("general.signs." + key + ".signType", block.getType().name());
}
if (!regionConfig.isString("general.signs." + key + ".facing")) {
final BlockFace rotation;
if (Materials.isSign(block.getType())) {
BlockData data = blockState.getBlockData();
if (data instanceof org.bukkit.block.data.type.Sign) {
rotation = ((org.bukkit.block.data.type.Sign) block.getBlockData()).getRotation();
} else if (data instanceof WallSign) {
rotation = ((WallSign) data).getFacing();
} else {
rotation = null;
}
} else {
rotation = null;
}
getRegion().setSetting("general.signs." + key + ".facing", rotation == null ? null : rotation.toString());
}
// Apply replacements and color and then set it on the sign
Sign signState = (Sign) blockState;
for (int i = 0; i < signLines.length; i++) {
if (signLines[i] == null) {
signState.setLine(i, "");
continue;
}
signLines[i] = Message.fromString(signLines[i]).replacements(getRegion()).getSingle();
signLines[i] = Utils.applyColors(signLines[i]);
signState.setLine(i, signLines[i]);
}
return signState.update(false, false);
}
/**
* Check if the sign needs to update periodically.
*
* @return true if it needs periodic updates, otherwise false
*/
public boolean needsPeriodicUpdate() {
ConfigurationSection signConfig = getProfile();
if (signConfig == null || !signConfig.isSet(getRegion().getState().getValue().toLowerCase())) {
return false;
}
ConfigurationSection stateConfig = signConfig.getConfigurationSection(getRegion().getState().getValue().toLowerCase());
if (stateConfig == null) {
return false;
}
// Check the lines for the timeleft tag
for (int i = 1; i <= 4; i++) {
String line = stateConfig.getString("line" + i);
if (line != null && !line.isEmpty() && line.contains(Message.VARIABLE_START + AreaShop.tagTimeLeft + Message.VARIABLE_END)) {
return true;
}
}
return false;
}
/**
* Run commands when a player clicks a sign.
*
* @param clicker The player that clicked the sign
* @param clickType The type of clicking
* @return true if the commands ran successfully, false if any of them failed
*/
public boolean runSignCommands(Player clicker, GeneralRegion.ClickType clickType) {
ConfigurationSection signConfig = getProfile();
if (signConfig == null) {
return false;
}
ConfigurationSection stateConfig = signConfig.getConfigurationSection(getRegion().getState().getValue().toLowerCase());
// Run player commands if specified
List<String> playerCommands = new ArrayList<>();
for (String command : stateConfig.getStringList(clickType.getValue() + "Player")) {
// TODO move variable checking code to InteractiveMessenger?
playerCommands.add(command.replace(Message.VARIABLE_START + AreaShop.tagClicker + Message.VARIABLE_END, clicker.getName()));
}
getRegion().runCommands(clicker, playerCommands);
// Run console commands if specified
List<String> consoleCommands = new ArrayList<>();
for (String command : stateConfig.getStringList(clickType.getValue() + "Console")) {
consoleCommands.add(command.replace(Message.VARIABLE_START + AreaShop.tagClicker + Message.VARIABLE_END, clicker.getName()));
}
getRegion().runCommands(Bukkit.getConsoleSender(), consoleCommands);
return !playerCommands.isEmpty() || !consoleCommands.isEmpty();
}
@Override
public boolean equals(Object object) {
return object instanceof RegionSign && ((RegionSign) object).getRegion().equals(this.getRegion()) && ((RegionSign) object).key.equals(this.key);
}
@Override
public int hashCode() {
return Objects.hashCode(key, getRegion().getName());
}
}
@@ -0,0 +1,637 @@
package me.wiefferink.areashop.features.signs;
import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.AddingRegionEvent;
import me.wiefferink.areashop.events.notify.UpdateRegionEvent;
import me.wiefferink.areashop.features.RegionFeature;
import me.wiefferink.areashop.managers.FileManager;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Materials;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.type.Sign;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockPhysicsEvent;
import org.bukkit.event.block.SignChangeEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.world.ChunkLoadEvent;
import java.util.*;
public class SignsFeature extends RegionFeature {
private static final Map<String, RegionSign> allSigns = Collections.synchronizedMap(new HashMap<>());
private static final Map<String, List<RegionSign>> signsByChunk = Collections.synchronizedMap(new HashMap<>());
private Map<String, RegionSign> signs;
public SignsFeature() {
}
/**
* Constructor.
*
* @param region The region to bind to
*/
public SignsFeature(GeneralRegion region) {
setRegion(region);
signs = new HashMap<>();
// Setup current signs
ConfigurationSection signSection = region.getConfig().getConfigurationSection("general.signs");
if (signSection != null) {
for (String signKey : signSection.getKeys(false)) {
RegionSign sign = new RegionSign(this, signKey);
Location location = sign.getLocation();
if (location == null) {
AreaShop.warn("Sign with key " + signKey + " of region " + region.getName() + " does not have a proper location");
continue;
}
signs.put(sign.getStringLocation(), sign);
signsByChunk.computeIfAbsent(sign.getStringChunk(), key -> new ArrayList<>())
.add(sign);
}
allSigns.putAll(signs);
}
}
/**
* Convert a location to a string to use as map key.
*
* @param location The location to get the key for
* @return A string to use in a map for a location
*/
public static String locationToString(Location location) {
return location.getWorld().getName() + ";" + location.getBlockX() + ";" + location.getBlockY() + ";" + location.getBlockZ();
}
/**
* Convert a chunk to a string to use as map key.
*
* @param location The location to get the key for
* @return A string to use in a map for a chunk
*/
public static String chunkToString(Location location) {
return location.getWorld().getName() + ";" + (location.getBlockX() >> 4) + ";" + (location.getBlockZ() >> 4);
}
/**
* Convert a chunk to a string to use as map key.
* Use a Location argument to prevent chunk loading!
*
* @param chunk The location to get the key for
* @return A string to use in a map for a chunk
*/
public static String chunkToString(Chunk chunk) {
return chunk.getWorld().getName() + ";" + chunk.getX() + ";" + chunk.getZ();
}
/**
* Get a sign by a location.
*
* @param location The location to get the sign for
* @return The RegionSign that is at the location, or null if none
*/
public static RegionSign getSignByLocation(Location location) {
return allSigns.get(locationToString(location));
}
/**
* Get the map with all signs.
*
* @return Map with all signs: locationString -&gt; RegionSign
*/
public static Map<String, RegionSign> getAllSigns() {
return allSigns;
}
/**
* Get the map with signs by chunk.
*
* @return Map with signs by chunk: chunkString -&gt; List&lt;RegionSign&gt;
*/
public static Map<String, List<RegionSign>> getSignsByChunk() {
return signsByChunk;
}
@Override
public void shutdown() {
// Deregister signs from the registry
if (signs != null) {
for (Map.Entry<String, RegionSign> entry : signs.entrySet()) {
allSigns.remove(entry.getKey());
signsByChunk.get(entry.getValue().getStringChunk()).remove(entry.getValue());
}
}
}
@EventHandler(priority = EventPriority.HIGH)
public void onSignBreak(BlockBreakEvent event) {
if (event.isCancelled()) {
return;
}
Block block = event.getBlock();
// Check if it is a sign
if (Materials.isSign(block.getType())) {
// Check if the rent sign is really the same as a saved rent
RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
if (regionSign == null) {
return;
}
// Remove the sign of the rental region if the player has permission
if (event.getPlayer().hasPermission("areashop.delsign")) {
regionSign.remove();
plugin.message(event.getPlayer(), "delsign-success", regionSign.getRegion());
} else { // Cancel the breaking of the sign
event.setCancelled(true);
plugin.message(event.getPlayer(), "delsign-noPermission", regionSign.getRegion());
}
}
}
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onIndirectSignBreak(BlockPhysicsEvent event) {
// Check if the block is a sign
if (!Materials.isSign(event.getBlock().getType())) {
return;
}
final Block block = event.getBlock();
final BlockData blockData = block.getBlockData();
final Block attachedBlock;
if (blockData instanceof WallSign) {
attachedBlock = block.getRelative(((WallSign) blockData).getFacing().getOppositeFace());
} else if (blockData instanceof Sign) {
attachedBlock = block.getRelative(BlockFace.DOWN);
} else {
attachedBlock = null;
}
// Check if still attached to a block
// TODO: signs cannot be placed on all blocks, improve this check to isSolid()?
if (attachedBlock == null || attachedBlock.getType() != Material.AIR) {
return;
}
// Check if the sign is really the same as a saved rent
RegionSign regionSign = SignsFeature.getSignByLocation(event.getBlock().getLocation());
if (regionSign == null) {
return;
}
// Remove the sign so that it does not fall on the floor as an item (next region update will place it back when possible)
AreaShop.debug("onIndirectSignBreak: Removed block of sign for", regionSign.getRegion().getName(), "at", regionSign.getStringLocation());
event.getBlock().setType(Material.AIR);
event.setCancelled(true);
}
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void onSignClick(PlayerInteractEvent event) {
Block block = event.getClickedBlock();
if (block == null) {
return;
}
// Only listen to left and right clicks on blocks
if (!(event.getAction() == Action.RIGHT_CLICK_BLOCK || event.getAction() == Action.LEFT_CLICK_BLOCK)) {
return;
}
// Only care about clicking blocks
if (!Materials.isSign(block.getType())) {
return;
}
// Check if this sign belongs to a region
RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
if (regionSign == null) {
return;
}
// Ignore players that are in sign link mode (which will handle the event itself)
Player player = event.getPlayer();
if (plugin.getSignlinkerManager().isInSignLinkMode(player)) {
return;
}
// Get the clicktype
GeneralRegion.ClickType clickType = null;
if (player.isSneaking() && event.getAction() == Action.LEFT_CLICK_BLOCK) {
clickType = GeneralRegion.ClickType.SHIFTLEFTCLICK;
} else if (!player.isSneaking() && event.getAction() == Action.LEFT_CLICK_BLOCK) {
clickType = GeneralRegion.ClickType.LEFTCLICK;
} else if (player.isSneaking() && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
clickType = GeneralRegion.ClickType.SHIFTRIGHTCLICK;
} else if (!player.isSneaking() && event.getAction() == Action.RIGHT_CLICK_BLOCK) {
clickType = GeneralRegion.ClickType.RIGHTCLICK;
}
boolean ran = regionSign.runSignCommands(player, clickType);
// Only cancel event if at least one command has been executed
event.setCancelled(ran);
}
@EventHandler(priority = EventPriority.MONITOR)
public void onSignChange(SignChangeEvent event) {
if (event.isCancelled()) {
return;
}
Player player = event.getPlayer();
if (!plugin.isReady()) {
plugin.message(player, "general-notReady");
return;
}
final BlockFace rotation;
final BlockData data = event.getBlock().getBlockData();
if (data instanceof Sign) {
rotation = ((Sign) data).getRotation();
} else if (data instanceof WallSign) {
rotation = ((WallSign) data).getFacing();
} else {
rotation = null;
}
final String line0 = event.getLine(0) == null ? "" : event.getLine(0);
// Check if the sign is meant for this plugin
if (line0.contains(plugin.getConfig().getString("signTags.rent"))) {
if (!player.hasPermission("areashop.createrent") && !player.hasPermission("areashop.createrent.member") && !player.hasPermission("areashop.createrent.owner")) {
plugin.message(player, "setup-noPermissionRent");
return;
}
// Get the other lines
String secondLine = event.getLine(1);
String thirdLine = event.getLine(2);
String fourthLine = event.getLine(3);
// Get the regionManager for accessing regions
RegionManager regionManager = plugin.getRegionManager(event.getPlayer().getWorld());
// If the secondLine does not contain a name try to find the region by location
if (secondLine == null || secondLine.isEmpty()) {
Set<ProtectedRegion> regions = plugin.getWorldGuardHandler().getApplicableRegionsSet(event.getBlock().getLocation());
if (regions != null) {
boolean first = true;
ProtectedRegion candidate = null;
for (ProtectedRegion pr : regions) {
if (first) {
candidate = pr;
first = false;
} else {
if (pr.getPriority() > candidate.getPriority()) {
candidate = pr;
} else if (pr.getParent() != null && pr.getParent().equals(candidate)) {
candidate = pr;
} else {
plugin.message(player, "setup-couldNotDetect", candidate.getId(), pr.getId());
return;
}
}
}
if (candidate != null) {
secondLine = candidate.getId();
}
}
}
boolean priceSet = fourthLine != null && !fourthLine.isEmpty();
boolean durationSet = thirdLine != null && !thirdLine.isEmpty();
// check if all the lines are correct
if (secondLine == null || secondLine.isEmpty()) {
plugin.message(player, "setup-noRegion");
return;
}
ProtectedRegion region = regionManager.getRegion(secondLine);
if (region == null) {
plugin.message(player, "cmd-noRegion", secondLine);
return;
}
FileManager.AddResult addResult = plugin.getFileManager().checkRegionAdd(player, regionManager.getRegion(secondLine), event.getPlayer().getWorld(), GeneralRegion.RegionType.RENT);
switch (addResult) {
case BLACKLISTED:
plugin.message(player, "setup-blacklisted", secondLine);
break;
case ALREADYADDED:
plugin.message(player, "setup-alreadyRentSign");
break;
case ALREADYADDEDOTHERWORLD:
plugin.message(player, "setup-alreadyOtherWorld");
break;
case NOPERMISSION:
plugin.message(player, "setup-noPermission", secondLine);
break;
default:
if (thirdLine != null && !thirdLine.isEmpty() && !Utils.checkTimeFormat(thirdLine)) {
plugin.message(player, "setup-wrongDuration");
break;
}
double price = 0.0;
if (priceSet) {
// Check the fourth line
try {
price = Double.parseDouble(fourthLine);
} catch (NumberFormatException e) {
plugin.message(player, "setup-wrongPrice");
return;
}
}
// Add rent to the FileManager
final RentRegion rent = new RentRegion(secondLine, event.getPlayer().getWorld());
boolean isMember = plugin.getWorldGuardHandler().containsMember(rent.getRegion(), player.getUniqueId());
boolean isOwner = plugin.getWorldGuardHandler().containsOwner(rent.getRegion(), player.getUniqueId());
boolean landlord = (!player.hasPermission("areashop.createrent")
&& ((player.hasPermission("areashop.createrent.owner") && isOwner)
|| (player.hasPermission("areashop.createrent.member") && isMember)));
if (landlord) {
rent.setLandlord(player.getUniqueId(), player.getName());
}
if (priceSet) {
rent.setPrice(price);
}
if (durationSet) {
rent.setDuration(thirdLine);
}
rent.getSignsFeature().addSign(event.getBlock().getLocation(), event.getBlock().getType(), rotation, null);
AddingRegionEvent addingRegionEvent = plugin.getFileManager().addRegion(rent);
if (addingRegionEvent.isCancelled()) {
plugin.message(player, "general-cancelled", addingRegionEvent.getReason());
return;
}
rent.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);
plugin.message(player, "setup-rentSuccess", rent);
// Update the region after the event has written its lines
Bukkit.getScheduler().runTask(plugin, rent::update);
}
} else if (line0.contains(plugin.getConfig().getString("signTags.buy"))) {
// Check for permission
if (!player.hasPermission("areashop.createbuy") && !player.hasPermission("areashop.createbuy.member") && !player.hasPermission("areashop.createbuy.owner")) {
plugin.message(player, "setup-noPermissionBuy");
return;
}
// Get the other lines
String secondLine = event.getLine(1);
String thirdLine = event.getLine(2);
// Get the regionManager for accessing regions
RegionManager regionManager = plugin.getRegionManager(event.getPlayer().getWorld());
// If the secondLine does not contain a name try to find the region by location
if (secondLine == null || secondLine.isEmpty()) {
Set<ProtectedRegion> regions = plugin.getWorldGuardHandler().getApplicableRegionsSet(event.getBlock().getLocation());
if (regions != null) {
boolean first = true;
ProtectedRegion candidate = null;
for (ProtectedRegion pr : regions) {
if (first) {
candidate = pr;
first = false;
} else {
if (pr.getPriority() > candidate.getPriority()) {
candidate = pr;
} else if (pr.getParent() != null && pr.getParent().equals(candidate)) {
candidate = pr;
} else {
plugin.message(player, "setup-couldNotDetect", candidate.getId(), pr.getId());
return;
}
}
}
if (candidate != null) {
secondLine = candidate.getId();
}
}
}
boolean priceSet = thirdLine != null && !thirdLine.isEmpty();
// Check if all the lines are correct
if (secondLine == null || secondLine.isEmpty()) {
plugin.message(player, "setup-noRegion");
return;
}
ProtectedRegion region = regionManager.getRegion(secondLine);
if (region == null) {
plugin.message(player, "cmd-noRegion", secondLine);
return;
}
FileManager.AddResult addResult = plugin.getFileManager().checkRegionAdd(player, region, event.getPlayer().getWorld(), GeneralRegion.RegionType.BUY);
if (addResult == FileManager.AddResult.BLACKLISTED) {
plugin.message(player, "setup-blacklisted", secondLine);
} else if (addResult == FileManager.AddResult.ALREADYADDED) {
plugin.message(player, "setup-alreadyRentSign");
} else if (addResult == FileManager.AddResult.ALREADYADDEDOTHERWORLD) {
plugin.message(player, "setup-alreadyOtherWorld");
} else if (addResult == FileManager.AddResult.NOPERMISSION) {
plugin.message(player, "setup-noPermission", secondLine);
} else {
double price = 0.0;
if (priceSet) {
// Check the fourth line
try {
price = Double.parseDouble(thirdLine);
} catch (NumberFormatException e) {
plugin.message(player, "setup-wrongPrice");
return;
}
}
// Add buy to the FileManager
final BuyRegion buy = new BuyRegion(secondLine, event.getPlayer().getWorld());
boolean isMember = plugin.getWorldGuardHandler().containsMember(buy.getRegion(), player.getUniqueId());
boolean isOwner = plugin.getWorldGuardHandler().containsOwner(buy.getRegion(), player.getUniqueId());
boolean landlord = (!player.hasPermission("areashop.createbuy")
&& ((player.hasPermission("areashop.createbuy.owner") && isOwner)
|| (player.hasPermission("areashop.createbuy.member") && isMember)));
if (landlord) {
buy.setLandlord(player.getUniqueId(), player.getName());
}
if (priceSet) {
buy.setPrice(price);
}
buy.getSignsFeature().addSign(event.getBlock().getLocation(), event.getBlock().getType(), rotation, null);
AddingRegionEvent addingRegionEvent = plugin.getFileManager().addRegion(buy);
if (addingRegionEvent.isCancelled()) {
plugin.message(player, "general-cancelled", addingRegionEvent.getReason());
return;
}
buy.handleSchematicEvent(GeneralRegion.RegionEvent.CREATED);
plugin.message(player, "setup-buySuccess", buy);
// Update the region after the event has written its lines
Bukkit.getScheduler().runTask(plugin, buy::update);
}
} else if (event.getLine(0).contains(plugin.getConfig().getString("signTags.add"))) {
// Check for permission
if (!player.hasPermission("areashop.addsign")) {
plugin.message(player, "addsign-noPermission");
return;
}
// Get the other lines
String secondLine = event.getLine(1);
String thirdLine = event.getLine(2);
GeneralRegion region;
if (secondLine != null && !secondLine.isEmpty()) {
// Get region by secondLine of the sign
region = plugin.getFileManager().getRegion(secondLine);
if (region == null) {
plugin.message(player, "addSign-notRegistered", secondLine);
return;
}
} else {
// Get region by sign position
List<GeneralRegion> regions = Utils.getImportantRegions(event.getBlock().getLocation());
if (regions.isEmpty()) {
plugin.message(player, "addsign-noRegions");
return;
} else if (regions.size() > 1) {
plugin.message(player, "addsign-couldNotDetectSign", regions.get(0).getName(), regions.get(1).getName());
return;
}
region = regions.get(0);
}
String profile = thirdLine == null || thirdLine.isEmpty() ? null : thirdLine;
region.getSignsFeature().addSign(event.getBlock().getLocation(), event.getBlock().getType(), rotation, profile);
if (profile == null) {
plugin.message(player, "addsign-success", region);
} else {
plugin.message(player, "addsign-successProfile", thirdLine, region);
}
// Update the region later because this event will do it first
Bukkit.getScheduler().runTask(plugin, region::update);
}
}
@EventHandler
public void regionUpdate(UpdateRegionEvent event) {
event.getRegion().getSignsFeature().update();
}
@EventHandler(priority = EventPriority.MONITOR)
public void onChunkLoad(ChunkLoadEvent event) {
List<RegionSign> chunkSigns = signsByChunk.get(chunkToString(event.getChunk()));
if (chunkSigns == null) {
return;
}
int batchSize = Math.max(chunkSigns.size() / 10, 10);
Utils.runAsBatches(chunkSigns, batchSize, RegionSign::update, false);
}
/**
* Update all signs connected to this region.
*
* @return true if all signs are updated correctly, false if one or more updates failed
*/
public boolean update() {
boolean result = true;
for (RegionSign sign : signs.values()) {
result &= sign.update();
}
return result;
}
/**
* Check if any of the signs need periodic updating.
*
* @return true if one or more of the signs need periodic updating, otherwise false
*/
public boolean needsPeriodicUpdate() {
for (RegionSign sign : signs.values()) {
if (sign.needsPeriodicUpdate()) {
return true;
}
}
return false;
}
/**
* Get the signs of this region.
*
* @return List of signs
*/
public List<RegionSign> getSigns() {
return new ArrayList<>(signs.values());
}
/**
* Get the signs of this region.
*
* @return Map with signs: locationString -&gt; RegionSign
*/
Map<String, RegionSign> getSignsRef() {
return signs;
}
/**
* Get a list with all sign locations.
*
* @return A List with all sign locations
*/
public List<Location> getSignLocations() {
List<Location> result = new ArrayList<>(signs.size());
for (RegionSign sign : signs.values()) {
result.add(sign.getLocation());
}
return result;
}
/**
* Add a sign to this region.
*
* @param location The location of the sign
* @param signType The type of the sign (WALL_SIGN or SIGN_POST)
* @param facing The orientation of the sign
* @param profile The profile to use with this sign (null for default)
*/
public void addSign(Location location, Material signType, BlockFace facing, String profile) {
int i = 0;
final YamlConfiguration configuration = getRegion().getConfig();
while (configuration.isSet("general.signs." + i)) {
i++;
}
String signPath = "general.signs." + i + ".";
getRegion().setSetting(signPath + "location", Utils.locationToConfig(location));
getRegion().setSetting(signPath + "facing", facing != null ? facing.name() : null);
getRegion().setSetting(signPath + "signType", signType != null ? signType.name() : null);
if (profile != null && !profile.isEmpty()) {
getRegion().setSetting(signPath + "profile", profile);
}
// Add to the map
RegionSign sign = new RegionSign(this, i + "");
signs.put(sign.getStringLocation(), sign);
allSigns.put(sign.getStringLocation(), sign);
signsByChunk.computeIfAbsent(sign.getStringChunk(), key -> new ArrayList<>())
.add(sign);
}
}
@@ -0,0 +1,159 @@
package me.wiefferink.areashop.listeners;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.areashop.tools.Utils;
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.PlayerKickEvent;
import org.bukkit.event.player.PlayerLoginEvent;
import org.bukkit.event.player.PlayerLoginEvent.Result;
import org.bukkit.event.player.PlayerQuitEvent;
import java.util.ArrayList;
import java.util.List;
/**
* Notify region expiry and track activity time.
*/
public final class PlayerLoginLogoutListener implements Listener {
private final AreaShop plugin;
/**
* Constructor.
*
* @param plugin The AreaShop plugin
*/
public PlayerLoginLogoutListener(AreaShop plugin) {
this.plugin = plugin;
}
/**
* Called when a sign is changed.
*
* @param event The event
*/
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogin(PlayerLoginEvent event) {
if (event.getResult() != Result.ALLOWED) {
return;
}
final Player player = event.getPlayer();
// Schedule task to check for notifications, prevents a lag spike at login
Utils.runCancellingTaskTimer(() -> {
// Delay until all regions are loaded
if (!plugin.isReady()) {
return true;
}
if (!player.isOnline()) {
return false;
}
// Notify for rents that almost run out
for (RentRegion region : plugin.getFileManager().getRents()) {
if (region.isRenter(player)) {
String warningSetting = region.getStringSetting("rent.warningOnLoginTime");
if (warningSetting == null || warningSetting.isEmpty()) {
continue;
}
long warningTime = Utils.durationStringToLong(warningSetting);
if (region.getTimeLeft() < warningTime) {
// Send the warning message later to let it appear after general MOTD messages
AreaShop.getInstance().message(player, "rent-expireWarning", region);
}
}
}
// Notify admins for plugin updates
AreaShop.getInstance().notifyUpdate(player);
return false;
}, 25, 25, false);
// Check if the player has regions that use an old name of him and update them
Utils.runCancellingTaskTimer(() -> {
if (!plugin.isReady()) {
return true;
}
List<GeneralRegion> regions = new ArrayList<>();
for (GeneralRegion region : plugin.getFileManager().getRegions()) {
if (region.isOwner(player)) {
regions.add(region);
}
}
final String name = player.getName();
Utils.runAsBatches(regions,
plugin.getConfig().getInt("nameupdate.regionsPerTick"),
(region) -> {
if (region instanceof BuyRegion || region instanceof RentRegion) {
String key = region instanceof BuyRegion ? "buy.buyerName" : "rent.renterName";
if (!name.equals(region.getStringSetting("buy.buyerName"))) {
region.setSetting(key, player.getName());
region.update();
}
}
}, false);
return false;
}, 22, 10, false);
}
// Active time updates
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLogout(PlayerQuitEvent event) {
updateLastActive(event.getPlayer());
}
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerKick(PlayerKickEvent event) {
updateLastActive(event.getPlayer());
}
/**
* Update the last active time for all regions the player is owner off.
*
* @param player The player to update the active times for
*/
private void updateLastActive(Player player) {
for (GeneralRegion region : plugin.getFileManager().getRegions()) {
if (region.isOwner(player)) {
region.updateLastActiveTime();
}
}
}
}
@@ -0,0 +1,221 @@
package me.wiefferink.areashop.managers;
import me.wiefferink.areashop.commands.AddCommand;
import me.wiefferink.areashop.commands.AddfriendCommand;
import me.wiefferink.areashop.commands.AddsignCommand;
import me.wiefferink.areashop.commands.BuyCommand;
import me.wiefferink.areashop.commands.CommandAreaShop;
import me.wiefferink.areashop.commands.DelCommand;
import me.wiefferink.areashop.commands.DelfriendCommand;
import me.wiefferink.areashop.commands.DelsignCommand;
import me.wiefferink.areashop.commands.FindCommand;
import me.wiefferink.areashop.commands.GroupaddCommand;
import me.wiefferink.areashop.commands.GroupdelCommand;
import me.wiefferink.areashop.commands.GroupinfoCommand;
import me.wiefferink.areashop.commands.GrouplistCommand;
import me.wiefferink.areashop.commands.HelpCommand;
import me.wiefferink.areashop.commands.ImportCommand;
import me.wiefferink.areashop.commands.InfoCommand;
import me.wiefferink.areashop.commands.LinksignsCommand;
import me.wiefferink.areashop.commands.MeCommand;
import me.wiefferink.areashop.commands.MessageCommand;
import me.wiefferink.areashop.commands.ReloadCommand;
import me.wiefferink.areashop.commands.RentCommand;
import me.wiefferink.areashop.commands.ResellCommand;
import me.wiefferink.areashop.commands.SchematiceventCommand;
import me.wiefferink.areashop.commands.SellCommand;
import me.wiefferink.areashop.commands.SetdurationCommand;
import me.wiefferink.areashop.commands.SetlandlordCommand;
import me.wiefferink.areashop.commands.SetownerCommand;
import me.wiefferink.areashop.commands.SetpriceCommand;
import me.wiefferink.areashop.commands.SetrestoreCommand;
import me.wiefferink.areashop.commands.SetteleportCommand;
import me.wiefferink.areashop.commands.StackCommand;
import me.wiefferink.areashop.commands.StopresellCommand;
import me.wiefferink.areashop.commands.TeleportCommand;
import me.wiefferink.areashop.commands.UnrentCommand;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import java.util.ArrayList;
import java.util.List;
import java.util.SortedSet;
import java.util.TreeSet;
public class CommandManager extends Manager implements CommandExecutor, TabCompleter {
private final ArrayList<CommandAreaShop> commands;
/**
* Constructor.
*/
public CommandManager() {
commands = new ArrayList<>();
commands.add(new HelpCommand());
commands.add(new RentCommand());
commands.add(new UnrentCommand());
commands.add(new BuyCommand());
commands.add(new SellCommand());
commands.add(new MeCommand());
commands.add(new InfoCommand());
commands.add(new TeleportCommand());
commands.add(new SetteleportCommand());
commands.add(new AddfriendCommand());
commands.add(new DelfriendCommand());
commands.add(new FindCommand());
commands.add(new ResellCommand());
commands.add(new StopresellCommand());
commands.add(new SetrestoreCommand());
commands.add(new SetpriceCommand());
commands.add(new SetownerCommand());
commands.add(new SetdurationCommand());
commands.add(new ReloadCommand());
commands.add(new GroupaddCommand());
commands.add(new GroupdelCommand());
commands.add(new GrouplistCommand());
commands.add(new GroupinfoCommand());
commands.add(new SchematiceventCommand());
commands.add(new AddCommand());
commands.add(new DelCommand());
commands.add(new AddsignCommand());
commands.add(new DelsignCommand());
commands.add(new LinksignsCommand());
commands.add(new StackCommand());
commands.add(new SetlandlordCommand());
commands.add(new MessageCommand());
commands.add(new ImportCommand());
// Register commands in bukkit
plugin.getCommand("AreaShop").setExecutor(this);
plugin.getCommand("AreaShop").setTabCompleter(this);
}
/**
* Get the list with AreaShop commands.
* @return The list with AreaShop commands
*/
public List<CommandAreaShop> getCommands() {
return commands;
}
/**
* Shows the help page for the CommandSender.
* @param target The CommandSender to show the help to
*/
public void showHelp(CommandSender target) {
if(!target.hasPermission("areashop.help")) {
plugin.message(target, "help-noPermission");
return;
}
// Add all messages to a list
ArrayList<String> messages = new ArrayList<>();
plugin.message(target, "help-header");
plugin.message(target, "help-alias");
for(CommandAreaShop command : commands) {
String help = command.getHelp(target);
if(help != null && !help.isEmpty()) {
messages.add(help);
}
}
// Send the messages to the target
for(String message : messages) {
plugin.messageNoPrefix(target, message);
}
}
@Override
public boolean onCommand(CommandSender sender, Command command, String alias, String[] args) {
if(!plugin.isReady()) {
plugin.message(sender, "general-notReady");
return true;
}
// Redirect `/as info player <player>` to `/as me <player>`
if(args.length == 3 && "info".equals(args[0]) && "player".equals(args[1])) {
args[0] = "me";
args[1] = args[2];
}
// Execute command
boolean executed = false;
for(int i = 0; i < commands.size() && !executed; i++) {
if(commands.get(i).canExecute(command, args)) {
commands.get(i).execute(sender, args);
executed = true;
}
}
// Show help
if (!executed) {
if (args.length == 0) {
this.showHelp(sender);
} else {
// Indicate that the '/as updaterents' and '/as updatebuys' commands are removed
if("updaterents".equalsIgnoreCase(args[0]) || "updatebuys".equalsIgnoreCase(args[0])) {
plugin.message(sender, "reload-updateCommandChanged");
} else {
plugin.message(sender, "cmd-notValid");
}
}
}
return true;
}
@Override
public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
List<String> result = new ArrayList<>();
if(!sender.hasPermission("areashop.tabcomplete")) {
return result;
}
int toCompleteNumber = args.length;
String toCompletePrefix = args[args.length - 1].toLowerCase();
//AreaShop.debug("toCompleteNumber=" + toCompleteNumber + ", toCompletePrefix=" + toCompletePrefix + ", length=" + toCompletePrefix.length());
if(toCompleteNumber == 1) {
for(CommandAreaShop c : commands) {
String begin = c.getCommandStart();
result.add(begin.substring(begin.indexOf(' ') + 1));
}
} else {
String[] start = new String[args.length];
start[0] = command.getName();
System.arraycopy(args, 0, start, 1, args.length - 1);
for(CommandAreaShop c : commands) {
if(c.canExecute(command, args)) {
result = c.getTabCompleteList(toCompleteNumber, start, sender);
}
}
}
// Filter and sort the results
if(!result.isEmpty()) {
SortedSet<String> set = new TreeSet<>();
for(String suggestion : result) {
if(suggestion.toLowerCase().startsWith(toCompletePrefix)) {
set.add(suggestion);
}
}
result.clear();
result.addAll(set);
}
//AreaShop.debug("Tabcomplete #" + toCompleteNumber + ", prefix="+ toCompletePrefix + ", result=" + result.toString());
return result;
}
}
@@ -0,0 +1,88 @@
package me.wiefferink.areashop.managers;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.features.CommandsFeature;
import me.wiefferink.areashop.features.DebugFeature;
import me.wiefferink.areashop.features.FriendsFeature;
import me.wiefferink.areashop.features.RegionFeature;
import me.wiefferink.areashop.features.TeleportFeature;
import me.wiefferink.areashop.features.WorldGuardRegionFlagsFeature;
import me.wiefferink.areashop.features.signs.SignsFeature;
import me.wiefferink.areashop.regions.GeneralRegion;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class FeatureManager extends Manager {
// List of defined features
private static final Set<Class<? extends RegionFeature>> featureClasses = new HashSet<>(Arrays.asList(
DebugFeature.class,
SignsFeature.class,
FriendsFeature.class,
WorldGuardRegionFlagsFeature.class,
TeleportFeature.class,
CommandsFeature.class
));
// One instance of each feature, registered for event handling
private final Set<RegionFeature> globalFeatures;
private final Map<Class<? extends RegionFeature>, Constructor<? extends RegionFeature>> regionFeatureConstructors;
/**
* Constructor.
*/
public FeatureManager() {
// Instantiate and register global features (one per type, for event handling)
globalFeatures = new HashSet<>();
for(Class<? extends RegionFeature> clazz : featureClasses) {
try {
Constructor<? extends RegionFeature> constructor = clazz.getConstructor();
RegionFeature feature = constructor.newInstance();
feature.listen();
globalFeatures.add(feature);
} catch(InstantiationException | IllegalAccessException | InvocationTargetException | IllegalArgumentException e) {
AreaShop.error("Failed to instantiate global feature:", clazz, e);
} catch(NoSuchMethodException e) {
// Feature does not have a global part
}
}
// Setup constructors for region specific features
regionFeatureConstructors = new HashMap<>();
for(Class<? extends RegionFeature> clazz : featureClasses) {
try {
regionFeatureConstructors.put(clazz, clazz.getConstructor(GeneralRegion.class));
} catch(NoSuchMethodException | IllegalArgumentException e) {
// The feature does not have a region specific part
}
}
}
@Override
public void shutdown() {
for(RegionFeature feature : globalFeatures) {
feature.shutdown();
}
}
/**
* Instanciate a feature for a certain region.
* @param region The region to create a feature for
* @param featureClazz The class of the feature to create
* @return The feature class
*/
public RegionFeature getRegionFeature(GeneralRegion region, Class<? extends RegionFeature> featureClazz) {
try {
return regionFeatureConstructors.get(featureClazz).newInstance(region);
} catch(InstantiationException | InvocationTargetException | IllegalAccessException | IllegalArgumentException e) {
AreaShop.error("Failed to instantiate feature", featureClazz, "for region", region, e, e.getCause());
}
return null;
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,16 @@
package me.wiefferink.areashop.managers;
import me.wiefferink.areashop.AreaShop;
public abstract class Manager {
final AreaShop plugin = AreaShop.getInstance();
/**
* Called at shutdown of the plugin.
*/
public void shutdown() {
// To override by extending classes
}
}
@@ -0,0 +1,242 @@
package me.wiefferink.areashop.managers;
import me.wiefferink.areashop.features.signs.RegionSign;
import me.wiefferink.areashop.features.signs.SignsFeature;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.tools.Materials;
import me.wiefferink.areashop.tools.Utils;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.type.Sign;
import org.bukkit.block.data.type.WallSign;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.util.BlockIterator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
public class SignLinkerManager extends Manager implements Listener {
private final Map<UUID, SignLinker> signLinkers;
private boolean eventsRegistered;
public SignLinkerManager() {
signLinkers = new HashMap<>();
eventsRegistered = false;
}
@Override
public void shutdown() {
for(UUID uuid : signLinkers.keySet()) {
exitSignLinkMode(Bukkit.getPlayer(uuid));
}
}
/**
* Let a player enter sign linking mode.
* @param player The player that has to enter sign linking mode
* @param profile The profile to use for the signs (null for default)
*/
public void enterSignLinkMode(Player player, String profile) {
signLinkers.put(player.getUniqueId(), new SignLinker(player, profile));
plugin.message(player, "linksigns-first");
plugin.message(player, "linksigns-next");
if(!eventsRegistered) {
eventsRegistered = true;
plugin.getServer().getPluginManager().registerEvents(this, plugin);
}
}
/**
* Let a player exit sign linking mode.
* @param player The player that has to exit sign linking mode
*/
public void exitSignLinkMode(Player player) {
signLinkers.remove(player.getUniqueId());
if(eventsRegistered && signLinkers.isEmpty()) {
eventsRegistered = false;
HandlerList.unregisterAll(this);
}
plugin.message(player, "linksigns-stopped");
}
/**
* Check if the player is in sign linking mode.
* @param player The player to check
* @return true if the player is in sign linking mode, otherwise false
*/
public boolean isInSignLinkMode(Player player) {
return signLinkers.containsKey(player.getUniqueId());
}
/**
* On player interactions.
* @param event The PlayerInteractEvent
*/
@EventHandler(priority = EventPriority.HIGH)
public void onPlayerInteract(PlayerInteractEvent event) {
if(isInSignLinkMode(event.getPlayer())) {
event.setCancelled(true);
Player player = event.getPlayer();
SignLinker linker = signLinkers.get(event.getPlayer().getUniqueId());
if(event.getAction() == Action.RIGHT_CLICK_AIR || event.getAction() == Action.RIGHT_CLICK_BLOCK) {
// Get the region
BlockIterator blockIterator = new BlockIterator(player, 100);
while(blockIterator.hasNext()) {
Block next = blockIterator.next();
List<GeneralRegion> regions = Utils.getRegions(next.getLocation());
if(regions.size() == 1) {
linker.setRegion(regions.get(0));
return;
} else if(regions.size() > 1) {
Set<String> names = new HashSet<>();
for(GeneralRegion region : regions) {
names.add(region.getName());
}
plugin.message(player, "linksigns-multipleRegions", Utils.createCommaSeparatedList(names));
plugin.message(player, "linksigns-multipleRegionsAdvice");
return;
}
}
// No regions found within the maximum range
plugin.message(player, "linksigns-noRegions");
} else if(event.getAction() == Action.LEFT_CLICK_AIR || event.getAction() == Action.LEFT_CLICK_BLOCK) {
Block block = null;
BlockIterator blockIterator = new BlockIterator(player, 100);
while(blockIterator.hasNext() && block == null) {
Block next = blockIterator.next();
if(next.getType() != Material.AIR) {
block = next;
}
}
if(block == null || !Materials.isSign(block.getType())) {
plugin.message(player, "linksigns-noSign");
return;
}
RegionSign regionSign = SignsFeature.getSignByLocation(block.getLocation());
if(regionSign != null) {
plugin.message(player, "linksigns-alreadyRegistered", regionSign.getRegion());
return;
}
final BlockData blockData = block.getBlockData();
final BlockFace rotation;
if (blockData instanceof Sign) {
rotation = ((Sign) blockData).getRotation();
} else if (blockData instanceof WallSign) {
rotation = ((WallSign) blockData).getFacing();
} else {
rotation = null;
}
linker.setSign(block.getLocation(), block.getType(), rotation);
}
}
}
/**
* Handle disconnection players.
* @param event The PlayerQuitEvent
*/
@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerLeave(PlayerQuitEvent event) {
exitSignLinkMode(event.getPlayer());
}
/**
* Class to keep track of the signlinking data.
*/
private class SignLinker {
private boolean hasSign = false;
private boolean hasRegion = false;
public final Player linker;
public final String profile;
public GeneralRegion region = null;
public Location location = null;
public Material type = null;
public BlockFace facing = null;
public SignLinker(Player linker, String profile) {
this.linker = linker;
this.profile = profile;
}
public void setRegion(GeneralRegion region) {
this.region = region;
hasRegion = true;
if(!isComplete()) {
plugin.message(linker, "linksigns-regionFound", region);
}
finish();
}
public void setSign(Location location, Material type, BlockFace facing) {
this.location = location;
this.type = type;
this.facing = facing;
hasSign = true;
if(!isComplete()) {
plugin.message(linker, "linksigns-signFound", location.getBlockX(), location.getBlockY(), location.getBlockZ());
}
finish();
}
public void finish() {
if(isComplete()) {
region.getSignsFeature().addSign(location, type, facing, profile);
if(profile == null) {
plugin.message(linker, "addsign-success", region);
} else {
plugin.message(linker, "addsign-successProfile", region, profile);
}
region.update();
reset();
plugin.message(linker, "linksigns-next");
}
}
public void reset() {
hasSign = false;
hasRegion = false;
}
public boolean isComplete() {
return hasSign && hasRegion;
}
}
}
@@ -0,0 +1,588 @@
package me.wiefferink.areashop.regions;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.BuyingRegionEvent;
import me.wiefferink.areashop.events.ask.ResellingRegionEvent;
import me.wiefferink.areashop.events.ask.SellingRegionEvent;
import me.wiefferink.areashop.events.notify.BoughtRegionEvent;
import me.wiefferink.areashop.events.notify.ResoldRegionEvent;
import me.wiefferink.areashop.events.notify.SoldRegionEvent;
import me.wiefferink.areashop.tools.Utils;
import net.milkbowl.vault.economy.EconomyResponse;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import java.util.Calendar;
import java.util.UUID;
public class BuyRegion extends GeneralRegion {
public BuyRegion(YamlConfiguration config) {
super(config);
}
public BuyRegion(String name, World world) {
super(name, world);
}
@Override
public RegionType getType() {
return RegionType.BUY;
}
@Override
public RegionState getState() {
if(isSold() && isInResellingMode()) {
return RegionState.RESELL;
} else if(isSold() && !isInResellingMode()) {
return RegionState.SOLD;
} else {
return RegionState.FORSALE;
}
}
@Override
public boolean isAvailable() {
return !isSold();
}
/**
* Get the UUID of the owner of this region.
* @return The UUID of the owner of this region
*/
public UUID getBuyer() {
String buyer = config.getString("buy.buyer");
if(buyer != null) {
try {
return UUID.fromString(buyer);
} catch(IllegalArgumentException e) {
// Incorrect UUID
}
}
return null;
}
/**
* Check if a player is the buyer of this region.
* @param player Player to check
* @return true if this player owns this region, otherwise false
*/
public boolean isBuyer(OfflinePlayer player) {
return player != null && isBuyer(player.getUniqueId());
}
public boolean isBuyer(UUID player) {
UUID buyer = getBuyer();
return !(buyer == null || player == null) && buyer.equals(player);
}
/**
* Set the buyer of this region.
* @param buyer The UUID of the player that should be set as buyer
*/
public void setBuyer(UUID buyer) {
if(buyer == null) {
setSetting("buy.buyer", null);
setSetting("buy.buyerName", null);
} else {
setSetting("buy.buyer", buyer.toString());
setSetting("buy.buyerName", Utils.toName(buyer));
}
}
/**
* Get the name of the player that owns this region.
* @return The name of the player that owns this region, if unavailable by UUID it will return the old cached name, if that is unavailable it will return &lt;UNKNOWN&gt;
*/
public String getPlayerName() {
String result = Utils.toName(getBuyer());
if(result == null || result.isEmpty()) {
result = getStringSetting("buy.buyerName");
if(result == null || result.isEmpty()) {
result = "<UNKNOWN>";
}
}
return result;
}
/**
* Check if the region is sold.
* @return true if the region is sold, otherwise false
*/
public boolean isSold() {
return getBuyer() != null;
}
/**
* Check if the region is being resold.
* @return true if the region is available for reselling, otherwise false
*/
public boolean isInResellingMode() {
return config.getBoolean("buy.resellMode");
}
/**
* Get the price of the region.
* @return The price of the region
*/
public double getPrice() {
return Math.max(0, Utils.evaluateToDouble(getStringSetting("buy.price"), this));
}
/**
* Get the resell price of this region.
* @return The resell price if isInResellingMode(), otherwise 0.0
*/
public double getResellPrice() {
return Math.max(0, config.getDouble("buy.resellPrice"));
}
/**
* Get the formatted string of the price (includes prefix and suffix).
* @return The formatted string of the price
*/
public String getFormattedPrice() {
return Utils.formatCurrency(getPrice());
}
/**
* Get the formatted string of the resellprice (includes prefix and suffix).
* @return The formatted string of the resellprice
*/
public String getFormattedResellPrice() {
return Utils.formatCurrency(getResellPrice());
}
/**
* Change the price of the region.
* @param price The price to set this region to
*/
public void setPrice(Double price) {
setSetting("buy.price", price);
}
/**
* Set the region into resell mode with the given price.
* @param price The price this region should be put up for sale
*/
public void enableReselling(double price) {
setSetting("buy.resellMode", true);
setSetting("buy.resellPrice", price);
}
/**
* Stop this region from being in resell mode.
*/
public void disableReselling() {
setSetting("buy.resellMode", null);
setSetting("buy.resellPrice", null);
}
/**
* Get the moneyBack percentage.
* @return The % of money the player will get back when selling
*/
public double getMoneyBackPercentage() {
return Utils.evaluateToDouble(getStringSetting("buy.moneyBack"), this);
}
/**
* Get the amount of money that should be paid to the player when selling the region.
* @return The amount of money the player should get back
*/
public double getMoneyBackAmount() {
return getPrice() * (getMoneyBackPercentage() / 100.0);
}
/**
* Get the formatted string of the amount of the moneyBack amount.
* @return String with currency symbols and proper fractional part
*/
public String getFormattedMoneyBackAmount() {
return Utils.formatCurrency(getMoneyBackAmount());
}
@Override
public Object provideReplacement(String variable) {
switch(variable) {
case AreaShop.tagPrice:
return getFormattedPrice();
case AreaShop.tagRawPrice:
return getPrice();
case AreaShop.tagPlayerName:
return getPlayerName();
case AreaShop.tagPlayerUUID:
return getBuyer();
case AreaShop.tagResellPrice:
return getFormattedResellPrice();
case AreaShop.tagRawResellPrice:
return getResellPrice();
case AreaShop.tagMoneyBackAmount:
return getFormattedMoneyBackAmount();
case AreaShop.tagRawMoneyBackAmount:
return getMoneyBackAmount();
case AreaShop.tagMoneyBackPercentage:
return getMoneyBackPercentage() % 1.0 == 0.0 ? (int)getMoneyBackPercentage() : getMoneyBackPercentage();
case AreaShop.tagMaxInactiveTime:
return this.getFormattedInactiveTimeUntilSell();
default:
return super.provideReplacement(variable);
}
}
/**
* Minutes until automatic unrent when player is offline.
* @return The number of milliseconds until the region is unrented while player is offline
*/
public long getInactiveTimeUntilSell() {
return Utils.getDurationFromMinutesOrStringInput(getStringSetting("buy.inactiveTimeUntilSell"));
}
/**
* Get a human readable string indicating how long the player can be offline until automatic unrent.
* @return String indicating the inactive time until unrent
*/
public String getFormattedInactiveTimeUntilSell() {
return Utils.millisToHumanFormat(getInactiveTimeUntilSell());
}
/**
* Buy a region.
* @param offlinePlayer The player that wants to buy the region
* @return true if it succeeded and false if not
*/
@SuppressWarnings("deprecation")
public boolean buy(OfflinePlayer offlinePlayer) {
// Check if the player has permission
if(!plugin.hasPermission(offlinePlayer, "areashop.buy")) {
message(offlinePlayer, "buy-noPermission");
return false;
}
if(plugin.getEconomy() == null) {
message(offlinePlayer, "general-noEconomy");
return false;
}
if(isInResellingMode()) {
if(!plugin.hasPermission(offlinePlayer, "areashop.buyresell")) {
message(offlinePlayer, "buy-noPermissionResell");
return false;
}
} else {
if(!plugin.hasPermission(offlinePlayer, "areashop.buynormal")) {
message(offlinePlayer, "buy-noPermissionNoResell");
return false;
}
}
if(getWorld() == null) {
message(offlinePlayer, "general-noWorld");
return false;
}
if(getRegion() == null) {
message(offlinePlayer, "general-noRegion");
return false;
}
if (isSold() && !(isInResellingMode() && !isBuyer(offlinePlayer))) {
if(isBuyer(offlinePlayer)) {
message(offlinePlayer, "buy-yours");
} else {
message(offlinePlayer, "buy-someoneElse");
}
return false;
}
boolean isResell = isInResellingMode();
// Only relevant if the player is online
Player player = offlinePlayer.getPlayer();
if(player != null) {
// Check if the players needs to be in the region for buying
if(restrictedToRegion() && (!player.getWorld().getName().equals(getWorldName())
|| !getRegion().contains(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()))) {
message(offlinePlayer, "buy-restrictedToRegion");
return false;
}
// Check if the players needs to be in the world for buying
if(restrictedToWorld() && !player.getWorld().getName().equals(getWorldName())) {
message(offlinePlayer, "buy-restrictedToWorld", player.getWorld().getName());
return false;
}
}
// Check region limits
LimitResult limitResult = this.limitsAllow(RegionType.BUY, offlinePlayer);
AreaShop.debug("LimitResult: " + limitResult.toString());
if(!limitResult.actionAllowed()) {
if(limitResult.getLimitingFactor() == LimitType.TOTAL) {
message(offlinePlayer, "total-maximum", limitResult.getMaximum(), limitResult.getCurrent(), limitResult.getLimitingGroup());
return false;
}
if(limitResult.getLimitingFactor() == LimitType.BUYS) {
message(offlinePlayer, "buy-maximum", limitResult.getMaximum(), limitResult.getCurrent(), limitResult.getLimitingGroup());
return false;
}
// Should not be reached, but is safe like this
return false;
}
// Check if the player has enough money
if (isResell && !plugin.getEconomy().has(offlinePlayer, getWorldName(), getResellPrice())) {
message(offlinePlayer, "buy-lowMoneyResell", Utils.formatCurrency(plugin.getEconomy().getBalance(offlinePlayer, getWorldName())));
return false;
}
if (!isResell && !plugin.getEconomy().has(offlinePlayer, getWorldName(), getPrice())) {
message(offlinePlayer, "buy-lowMoney", Utils.formatCurrency(plugin.getEconomy().getBalance(offlinePlayer, getWorldName())));
return false;
}
UUID oldOwner = getBuyer();
if(isResell && oldOwner != null) {
// Broadcast and check event
ResellingRegionEvent event = new ResellingRegionEvent(this, offlinePlayer);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
message(offlinePlayer, "general-cancelled", event.getReason());
return false;
}
getFriendsFeature().clearFriends();
double resellPrice = getResellPrice();
// Transfer the money to the previous owner
EconomyResponse r = plugin.getEconomy().withdrawPlayer(offlinePlayer, getWorldName(), getResellPrice());
if(!r.transactionSuccess()) {
message(offlinePlayer, "buy-payError");
AreaShop.debug("Something went wrong with getting money from " + offlinePlayer.getName() + " while buying " + getName() + ": " + r.errorMessage);
return false;
}
r = null;
OfflinePlayer oldOwnerPlayer = Bukkit.getOfflinePlayer(oldOwner);
String oldOwnerName = getPlayerName();
if(oldOwnerPlayer != null && oldOwnerPlayer.getName() != null) {
r = plugin.getEconomy().depositPlayer(oldOwnerPlayer, getWorldName(), getResellPrice());
oldOwnerName = oldOwnerPlayer.getName();
} else if(oldOwnerName != null) {
r = plugin.getEconomy().depositPlayer(oldOwnerName, getWorldName(), getResellPrice());
}
if(r == null || !r.transactionSuccess()) {
AreaShop.warn("Something went wrong with paying '" + oldOwnerName + "' " + getFormattedPrice() + " for his resell of region " + getName() + " to " + offlinePlayer.getName());
}
// Resell is done, disable that now
disableReselling();
// Set the owner
setBuyer(offlinePlayer.getUniqueId());
updateLastActiveTime();
// Update everything
handleSchematicEvent(RegionEvent.RESELL);
// Notify about updates
this.notifyAndUpdate(new ResoldRegionEvent(this, oldOwner));
// Send message to the player
message(offlinePlayer, "buy-successResale", oldOwnerName);
Player seller = Bukkit.getPlayer(oldOwner);
if(seller != null) {
message(seller, "buy-successSeller", resellPrice);
}
} else {
// Broadcast and check event
BuyingRegionEvent event = new BuyingRegionEvent(this, offlinePlayer);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
message(offlinePlayer, "general-cancelled", event.getReason());
return false;
}
// Substract the money from the players balance
EconomyResponse r = plugin.getEconomy().withdrawPlayer(offlinePlayer, getWorldName(), getPrice());
if(!r.transactionSuccess()) {
message(offlinePlayer, "buy-payError");
return false;
}
// Optionally give money to the landlord
OfflinePlayer landlordPlayer = null;
if(getLandlord() != null) {
landlordPlayer = Bukkit.getOfflinePlayer(getLandlord());
}
String landlordName = getLandlordName();
if(landlordName != null) {
if(landlordPlayer != null && landlordPlayer.getName() != null) {
r = plugin.getEconomy().depositPlayer(landlordPlayer, getWorldName(), getPrice());
} else {
r = plugin.getEconomy().depositPlayer(landlordName, getWorldName(), getPrice());
}
if(r != null && !r.transactionSuccess()) {
AreaShop.warn("Something went wrong with paying '" + landlordName + "' " + getFormattedPrice() + " for his sell of region " + getName() + " to " + offlinePlayer.getName());
}
}
// Set the owner
setBuyer(offlinePlayer.getUniqueId());
updateLastActiveTime();
// Send message to the player
message(offlinePlayer, "buy-succes");
// Update everything
handleSchematicEvent(RegionEvent.BOUGHT);
// Notify about updates
this.notifyAndUpdate(new BoughtRegionEvent(this));
}
return true;
}
/**
* Sell a buyed region, get part of the money back.
* @param giveMoneyBack true if the player should be given money back, otherwise false
* @param executor CommandSender to receive a message when the sell fails, or null
* @return true if the region has been sold, otherwise false
*/
@SuppressWarnings("deprecation")
public boolean sell(boolean giveMoneyBack, CommandSender executor) {
boolean own = executor instanceof Player && this.isBuyer((Player)executor);
if(executor != null) {
if(!executor.hasPermission("areashop.sell") && !own) {
message(executor, "sell-noPermissionOther");
return false;
}
if(!executor.hasPermission("areashop.sell") && !executor.hasPermission("areashop.sellown") && own) {
message(executor, "sell-noPermission");
return false;
}
if(!executor.hasPermission("areashop.sell")
&& executor.hasPermission("areashop.sellown")
&& own
&& getBooleanSetting("buy.sellDisabled")) {
message(executor, "sell-disabled");
return false;
}
}
if(plugin.getEconomy() == null) {
return false;
}
// Broadcast and check event
SellingRegionEvent event = new SellingRegionEvent(this);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
message(executor, "general-cancelled", event.getReason());
return false;
}
disableReselling();
// Give part of the buying price back
double moneyBack = getMoneyBackAmount();
if(moneyBack > 0 && giveMoneyBack) {
boolean noPayBack = false;
OfflinePlayer landlordPlayer = null;
if(getLandlord() != null) {
landlordPlayer = Bukkit.getOfflinePlayer(getLandlord());
}
String landlordName = getLandlordName();
EconomyResponse r;
if(landlordName != null) {
if(landlordPlayer != null && landlordPlayer.getName() != null) {
r = plugin.getEconomy().withdrawPlayer(landlordPlayer, getWorldName(), moneyBack);
} else {
r = plugin.getEconomy().withdrawPlayer(landlordName, getWorldName(), moneyBack);
}
if(r == null || !r.transactionSuccess()) {
noPayBack = true;
}
}
// Give back the money
OfflinePlayer player = Bukkit.getOfflinePlayer(getBuyer());
if(player != null && !noPayBack) {
EconomyResponse response = null;
boolean error = false;
try {
if(player.getName() != null) {
response = plugin.getEconomy().depositPlayer(player, getWorldName(), moneyBack);
} else if(getPlayerName() != null) {
response = plugin.getEconomy().depositPlayer(getPlayerName(), getWorldName(), moneyBack);
}
} catch(Exception e) {
error = true;
}
if(error || response == null || !response.transactionSuccess()) {
AreaShop.warn("Something went wrong with paying back money to " + getPlayerName() + " while selling region " + getName());
}
}
}
// Handle schematic save/restore (while %uuid% is still available)
handleSchematicEvent(RegionEvent.SOLD);
// Send message: before actual removal of the buyer so that it is still available for variables
message(executor, "sell-sold");
// Remove friends and the owner
getFriendsFeature().clearFriends();
UUID oldBuyer = getBuyer();
setBuyer(null);
removeLastActiveTime();
// Notify about updates
this.notifyAndUpdate(new SoldRegionEvent(this, oldBuyer, Math.max(moneyBack, 0)));
return true;
}
@Override
public boolean checkInactive() {
if(isDeleted() || !isSold()) {
return false;
}
long inactiveSetting = getInactiveTimeUntilSell();
OfflinePlayer player = Bukkit.getOfflinePlayer(getBuyer());
if(inactiveSetting <= 0 || player.isOp()) {
return false;
}
long lastPlayed = getLastActiveTime();
//AreaShop.debug("currentTime=" + Calendar.getInstance().getTimeInMillis() + ", getLastPlayed()=" + lastPlayed + ", timeInactive=" + (Calendar.getInstance().getTimeInMillis()-player.getLastPlayed()) + ", inactiveSetting=" + inactiveSetting);
if(Calendar.getInstance().getTimeInMillis() > (lastPlayed + inactiveSetting)) {
AreaShop.info("Region " + getName() + " unrented because of inactivity for player " + getPlayerName());
AreaShop.debug("currentTime=" + Calendar.getInstance().getTimeInMillis() + ", getLastPlayed()=" + lastPlayed + ", timeInactive=" + (Calendar.getInstance().getTimeInMillis() - player.getLastPlayed()) + ", inactiveSetting=" + inactiveSetting);
return this.sell(true, null);
}
return false;
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,7 @@
# Regions
This package contains the `GeneralRegion` class which represents a region in AreaShop. Such a region is linked to a WorldGuard region and has its own configuration file at `/plugins/AreaShop/regions/<name>.yml`.
The `BuyRegion` and `RentRegion` classes represent buy and rental regions (mutually exclusive) and inherit from `GeneralRegion`.
To group regions there is `RegionGroup`, which allows configuring settings for a lot of regions at once.
@@ -0,0 +1,225 @@
package me.wiefferink.areashop.regions;
import me.wiefferink.areashop.AreaShop;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Set;
// TODO consider switching to saving lowercase regions
public class RegionGroup {
private final AreaShop plugin;
private final String name;
private final Set<String> regions;
private Set<String> autoRegions;
private boolean autoDirty;
private final Set<String> worlds;
/**
* Constructor, used when creating new groups or restoring them from groups.yml at server boot.
* @param plugin The AreaShop plugin
* @param name Name of the group, has to be unique
*/
public RegionGroup(AreaShop plugin, String name) {
this.plugin = plugin;
this.name = name;
this.autoDirty = true;
setSetting("name", name);
// Load regions and worlds
regions = new HashSet<>(getSettings().getStringList("regions"));
worlds = new HashSet<>(getSettings().getStringList("worlds"));
}
/**
* Get automatically added regions.
* @return Set of regions automatically added by the configuration
*/
public Set<String> getAutoRegions() {
if(autoDirty) {
autoRegions = new HashSet<>();
for(GeneralRegion region : plugin.getFileManager().getRegions()) {
if(worlds.contains(region.getWorldName())) {
autoRegions.add(region.getName());
}
}
autoDirty = false;
}
return autoRegions;
}
/**
* Mark that automatically added regions should be regenerated.
*/
public void autoDirty() {
autoDirty = true;
}
/**
* Adds a world from which all regions should be added to the group.
* @param world World from which all regions should be added
* @return true if the region was not already added, otherwise false
*/
public boolean addWorld(String world) {
if(worlds.add(world)) {
setSetting("regionsFromWorlds", new ArrayList<>(worlds));
saveRequired();
autoDirty();
return true;
}
return false;
}
/**
* Remove a member from the group.
* @param world World to remove
* @return true if the region was in the group before, otherwise false
*/
public boolean removeWorld(String world) {
if(worlds.remove(world)) {
setSetting("regionsFromWorlds", new ArrayList<>(worlds));
saveRequired();
autoDirty();
return true;
}
return false;
}
/**
* Get all worlds from which regions are added automatically.
* @return A list with the names of all worlds (immutable)
*/
public Set<String> getWorlds() {
return new HashSet<>(worlds);
}
/**
* Adds a member to a group.
* @param region The region to add to the group (GeneralRegion or a subclass of it)
* @return true if the region was not already added, otherwise false
*/
public boolean addMember(GeneralRegion region) {
if(regions.add(region.getName())) {
setSetting("regions", new ArrayList<>(regions));
saveRequired();
return true;
}
return false;
}
/**
* Remove a member from the group.
* @param region The region to remove
* @return true if the region was in the group before, otherwise false
*/
public boolean removeMember(GeneralRegion region) {
if(regions.remove(region.getName())) {
setSetting("regions", new ArrayList<>(regions));
saveRequired();
return true;
}
return false;
}
/**
* Get all members of the group.
* @return A list with the names of all members of the group (immutable)
*/
public Set<String> getMembers() {
HashSet<String> result = new HashSet<>(regions);
result.addAll(getAutoRegions());
return result;
}
/**
* Get all manually added members of the group.
* @return A list with the names of all members of the group (immutable)
*/
public Set<String> getManualMembers() {
return new HashSet<>(regions);
}
/**
* Get all members of the group as GeneralRegions.
* @return A Set with all group members
*/
public Set<GeneralRegion> getMemberRegions() {
Set<GeneralRegion> result = new HashSet<>();
for(String playerName : getMembers()) {
result.add(plugin.getFileManager().getRegion(playerName));
}
return result;
}
/**
* Get the name of the group.
* @return The name of the group
*/
public String getName() {
return name;
}
/**
* Get the lowercase name of the group (used for getting the config etc).
* @return The name of the group in lowercase
*/
public String getLowerCaseName() {
return getName().toLowerCase();
}
/**
* Check if a region is member of the group.
* @param region Region to check
* @return true if the region is in the group, otherwise false
*/
public boolean isMember(GeneralRegion region) {
return getMembers().contains(region.getName());
}
/**
* Get the priority of the group (higher overwrites).
* @return The priority of the group
*/
public int getPriority() {
return getSettings().getInt("priority");
}
/**
* Get the configurationsection with the settings of this group.
* @return The ConfigurationSection with the settings of the group
*/
public ConfigurationSection getSettings() {
ConfigurationSection result = plugin.getFileManager().getGroupSettings(name);
if(result != null) {
return result;
} else {
return new YamlConfiguration();
}
}
/**
* Set a setting of this group.
* @param path The path to set
* @param setting The value to set
*/
public void setSetting(String path, Object setting) {
plugin.getFileManager().setGroupSetting(this, path, setting);
}
/**
* Indicates this file needs to be saved, will actually get saved later by a task.
*/
public void saveRequired() {
plugin.getFileManager().saveGroupsIsRequired();
}
/**
* Save the groups to disk now, normally saveRequired() is preferred because of performance.
*/
public void saveNow() {
plugin.getFileManager().saveGroupsNow();
}
}
@@ -0,0 +1,746 @@
package me.wiefferink.areashop.regions;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.events.ask.RentingRegionEvent;
import me.wiefferink.areashop.events.ask.UnrentingRegionEvent;
import me.wiefferink.areashop.events.notify.RentedRegionEvent;
import me.wiefferink.areashop.events.notify.UnrentedRegionEvent;
import me.wiefferink.areashop.tools.Utils;
import net.milkbowl.vault.economy.EconomyResponse;
import org.bukkit.Bukkit;
import org.bukkit.OfflinePlayer;
import org.bukkit.World;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.UUID;
import static me.wiefferink.areashop.tools.Utils.millisToHumanFormat;
public class RentRegion extends GeneralRegion {
private long warningsDoneUntil = Calendar.getInstance().getTimeInMillis();
/**
* Constructor.
* @param config All settings of this region
*/
public RentRegion(YamlConfiguration config) {
super(config);
}
/**
* Create a new RentRegion.
* @param name The name of the region (correct casing)
* @param world The world of the WorldGuard region
*/
public RentRegion(String name, World world) {
super(name, world);
}
@Override
public RegionType getType() {
return RegionType.RENT;
}
@Override
public RegionState getState() {
if(isRented()) {
return RegionState.RENTED;
} else {
return RegionState.FORRENT;
}
}
@Override
public boolean isAvailable() {
return !isRented();
}
/**
* Get the UUID of the player renting the region.
* @return The UUID of the renter
*/
public UUID getRenter() {
String renter = config.getString("rent.renter");
if(renter != null) {
try {
return UUID.fromString(renter);
} catch(IllegalArgumentException e) {
// Incorrect UUID
}
}
return null;
}
/**
* Check if a player is the renter of this region.
* @param player Player to check
* @return true if this player rents this region, otherwise false
*/
public boolean isRenter(Player player) {
return player != null && isRenter(player.getUniqueId());
}
public boolean isRenter(UUID player) {
UUID renter = getRenter();
return !(player == null || renter == null) && renter.equals(player);
}
/**
* Set the renter of this region.
* @param renter The UUID of the player that should be set as the renter
*/
public void setRenter(UUID renter) {
if(renter == null) {
setSetting("rent.renter", null);
setSetting("rent.renterName", null);
} else {
setSetting("rent.renter", renter.toString());
setSetting("rent.renterName", Utils.toName(renter));
}
}
/**
* Get the max number of extends of this region.
* @return -1 if infinite otherwise the maximum number
*/
public int getMaxExtends() {
return getIntegerSetting("rent.maxExtends");
}
/**
* Get how many times the rent has already been extended.
* @return The number of times extended
*/
public int getTimesExtended() {
return config.getInt("rent.timesExtended");
}
/**
* Set the number of times the region has been extended.
* @param times The number of times the region has been extended
*/
public void setTimesExtended(int times) {
if(times < 0) {
setSetting("rent.timesExtended", null);
} else {
setSetting("rent.timesExtended", times);
}
}
@Override
public Object provideReplacement(String variable) {
switch(variable) {
case AreaShop.tagPrice:
return getFormattedPrice();
case AreaShop.tagRawPrice:
return getPrice();
case AreaShop.tagDuration:
return getDurationString();
case AreaShop.tagPlayerName:
return getPlayerName();
case AreaShop.tagPlayerUUID:
return getRenter();
case AreaShop.tagRentedUntil:
return new SimpleDateFormat(plugin.getConfig().getString("timeFormatChat")).format(new Date(getRentedUntil()));
case AreaShop.tagRentedUntilShort:
return new SimpleDateFormat(plugin.getConfig().getString("timeFormatSign")).format(new Date(getRentedUntil()));
case AreaShop.tagTimeLeft:
return getTimeLeftString();
case AreaShop.tagMoneyBackAmount:
return getFormattedMoneyBackAmount();
case AreaShop.tagRawMoneyBackAmount:
return getMoneyBackAmount();
case AreaShop.tagMoneyBackPercentage:
return (getMoneyBackPercentage() % 1.0) == 0.0 ? (int)getMoneyBackPercentage() : getMoneyBackPercentage();
case AreaShop.tagTimesExtended:
return this.getTimesExtended();
case AreaShop.tagMaxExtends:
return this.getMaxExtends();
case AreaShop.tagExtendsLeft:
return getMaxExtends() - getTimesExtended();
case AreaShop.tagMaxRentTime:
return millisToHumanFormat(getMaxRentTime());
case AreaShop.tagMaxInactiveTime:
return this.getFormattedInactiveTimeUntilUnrent();
default:
return super.provideReplacement(variable);
}
}
/**
* Check if the region is rented.
* @return true if the region is rented, otherwise false
*/
public boolean isRented() {
return getRenter() != null;
}
/**
* Get the name of the player renting this region.
* @return Name of the player renting this region, if unavailable by UUID it will return the old cached name, if that is unavailable it will return &lt;UNKNOWN&gt;
*/
public String getPlayerName() {
String result = Utils.toName(getRenter());
if(result == null || result.isEmpty()) {
result = config.getString("rent.renterName");
if(result == null || result.isEmpty()) {
result = "<UNKNOWN>";
}
}
return result;
}
/**
* Get the time until this region is rented (time from 1970 epoch).
* @return The epoch time until which this region is rented
*/
public long getRentedUntil() {
return getLongSetting("rent.rentedUntil");
}
/**
* Set the time until the region is rented (milliseconds from 1970, system time).
* @param rentedUntil The time until the region is rented
*/
public void setRentedUntil(Long rentedUntil) {
if(rentedUntil == null) {
setSetting("rent.rentedUntil", null);
} else {
setSetting("rent.rentedUntil", rentedUntil);
}
}
/**
* Get the price of the region.
* @return The price of the region
*/
public double getPrice() {
return Math.max(0, Utils.evaluateToDouble(getStringSetting("rent.price"), this));
}
/**
* Get the formatted string of the price (includes prefix and suffix).
* @return The formatted string of the price
*/
public String getFormattedPrice() {
return Utils.formatCurrency(getPrice());
}
/**
* Get the duration of 1 rent period.
* @return The duration in milliseconds of 1 rent period
*/
public long getDuration() {
return Utils.durationStringToLong(getDurationString());
}
/**
* Get the duration string, includes 'number indentifier'.
* @return The duration string
*/
public String getDurationString() {
return getStringSetting("rent.duration");
}
/**
* Get the time that is left on the region.
* @return The time left on the region
*/
public long getTimeLeft() {
if(isRented()) {
return this.getRentedUntil() - Calendar.getInstance().getTimeInMillis();
} else {
return 0;
}
}
/**
* Get a formatted string indicating the rent time that is left.
* @return Time left on the rent, for example '29 days', '3 months', '1 second'
*/
public String getTimeLeftString() {
return Utils.millisToHumanFormat(getTimeLeft());
}
/**
* Minutes until automatic unrent when player is offline.
* @return The number of milliseconds until the region is unrented while player is offline
*/
public long getInactiveTimeUntilUnrent() {
return Utils.getDurationFromMinutesOrStringInput(getStringSetting("rent.inactiveTimeUntilUnrent"));
}
/**
* Get a human readable string indicating how long the player can be offline until automatic unrent.
* @return String indicating the inactive time until unrent
*/
public String getFormattedInactiveTimeUntilUnrent() {
return Utils.millisToHumanFormat(getInactiveTimeUntilUnrent());
}
/**
* Change the price of the region.
* @param price The price of the region
*/
public void setPrice(Double price) {
setSetting("rent.price", price);
}
/**
* Set the duration of the rent.
* @param duration The duration of the rent (as specified on the documentation pages)
*/
public void setDuration(String duration) {
setSetting("rent.duration", duration);
}
/**
* Get the moneyBack percentage.
* @return The % of money the player will get back when unrenting
*/
public double getMoneyBackPercentage() {
return Utils.evaluateToDouble(getStringSetting("rent.moneyBack"), this);
}
/**
* Get the amount of money that should be paid to the player when unrenting the region.
* @return The amount of money the player should get back
*/
public double getMoneyBackAmount() {
Long currentTime = Calendar.getInstance().getTimeInMillis();
Double timeLeft = (double)(getRentedUntil() - currentTime);
double percentage = (getMoneyBackPercentage()) / 100.0;
Double timePeriod = (double)(getDuration());
double periods = timeLeft / timePeriod;
return Math.max(0, periods * getPrice() * percentage);
}
/**
* Get the formatted string of the amount of the moneyBack amount.
* @return String with currency symbols and proper fractional part
*/
public String getFormattedMoneyBackAmount() {
return Utils.formatCurrency(getMoneyBackAmount());
}
/**
* Get the maximum time the player can rent the region in advance (milliseconds).
* @return The maximum rent time in milliseconds
*/
public long getMaxRentTime() {
return Utils.getDurationFromMinutesOrStringInput(getStringSetting("rent.maxRentTime"));
}
/**
* Check if the rent should expire.
* @return true if the rent has expired and has been unrented, false otherwise
*/
public boolean checkExpiration() {
long now = Calendar.getInstance().getTimeInMillis();
if(!isDeleted() && isRented() && now > getRentedUntil()) {
// Extend rent if configured for that
if(getBooleanSetting("rent.autoExtend") && extend()) {
return false;
}
// Send message to the player if online
Player player = Bukkit.getPlayer(getRenter());
if(unRent(false, null)) {
if(player != null) {
message(player, "unrent-expired");
}
return true;
}
}
return false;
}
/**
* Send the expiration warnings from the selected profile which is specified in the config.
* Sends all warnings since previous call until (now + normal delay), delay can be found in the config as well.
*/
public void sendExpirationWarnings() {
// Send from warningsDoneUntil to current+delay
if(isDeleted() || !isRented()) {
return;
}
ConfigurationSection profileSection = getConfigurationSectionSetting("rent.expirationWarningProfile", "expirationWarningProfiles");
if(profileSection == null) {
return;
}
// Check if a warning needs to be send for each defined point in time
Player player = Bukkit.getPlayer(getRenter());
long sendUntil = Calendar.getInstance().getTimeInMillis() + (plugin.getConfig().getInt("expireWarning.delay") * 60 * 1000);
for(String timeBefore : profileSection.getKeys(false)) {
long timeBeforeParsed = Utils.durationStringToLong(timeBefore);
if(timeBeforeParsed <= 0) {
return;
}
long checkTime = getRentedUntil() - timeBeforeParsed;
if(checkTime > warningsDoneUntil && checkTime <= sendUntil) {
List<String> commands;
if(profileSection.isConfigurationSection(timeBefore)) {
/* Legacy config layout:
* "1 minute":
* warnPlayer: true
* commands: ["say hi"]
*/
commands = profileSection.getStringList(timeBefore + ".commands");
// Warn player
if(profileSection.getBoolean(timeBefore + ".warnPlayer") && player != null) {
message(player, "rent-expireWarning");
}
} else {
commands = profileSection.getStringList(timeBefore);
}
this.runCommands(Bukkit.getConsoleSender(), commands);
}
}
warningsDoneUntil = sendUntil;
}
/**
* Try to extend the rent for the current owner, respecting all restrictions.
* @return true if successful, otherwise false
*/
public boolean extend() {
if(!isRented()) {
return false;
}
OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(getRenter());
return offlinePlayer != null && rent(offlinePlayer);
}
/**
* Rent a region.
* @param offlinePlayer The player that wants to rent the region
* @return true if it succeeded and false if not
*/
public boolean rent(OfflinePlayer offlinePlayer) {
if(plugin.getEconomy() == null) {
message(offlinePlayer, "general-noEconomy");
return false;
}
// Check if the player has permission
if(!plugin.hasPermission(offlinePlayer, "areashop.rent")) {
message(offlinePlayer, "rent-noPermission");
return false;
}
// Check location restrictions
if(getWorld() == null) {
message(offlinePlayer, "general-noWorld");
return false;
}
if(getRegion() == null) {
message(offlinePlayer, "general-noRegion");
return false;
}
boolean extend = false;
if(getRenter() != null && offlinePlayer.getUniqueId().equals(getRenter())) {
extend = true;
}
// Check if available or extending
if (isRented() && !extend) {
message(offlinePlayer, "rent-someoneElse");
return false;
}
// These checks are only relevant for online players doing the renting/buying themselves
Player player = offlinePlayer.getPlayer();
if(player != null) {
// Check if the players needs to be in the region for renting
if(restrictedToRegion() && (!player.getWorld().getName().equals(getWorldName())
|| !getRegion().contains(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ()))) {
message(offlinePlayer, "rent-restrictedToRegion");
return false;
}
// Check if the players needs to be in the world for renting
if(restrictedToWorld() && !player.getWorld().getName().equals(getWorldName())) {
message(offlinePlayer, "rent-restrictedToWorld", player.getWorld().getName());
return false;
}
}
// Check region limits if this is not extending
if(!(extend && config.getBoolean("allowRegionExtendsWhenAboveLimits"))) {
LimitResult limitResult;
if(extend) {
limitResult = this.limitsAllow(RegionType.RENT, offlinePlayer, true);
} else {
limitResult = this.limitsAllow(RegionType.RENT, offlinePlayer);
}
AreaShop.debug("LimitResult: " + limitResult.toString());
if(!limitResult.actionAllowed()) {
if(limitResult.getLimitingFactor() == LimitType.TOTAL) {
message(offlinePlayer, "total-maximum", limitResult.getMaximum(), limitResult.getCurrent(), limitResult.getLimitingGroup());
return false;
}
if(limitResult.getLimitingFactor() == LimitType.RENTS) {
message(offlinePlayer, "rent-maximum", limitResult.getMaximum(), limitResult.getCurrent(), limitResult.getLimitingGroup());
return false;
}
if(limitResult.getLimitingFactor() == LimitType.EXTEND) {
message(offlinePlayer, "rent-maximumExtend", limitResult.getMaximum(), limitResult.getCurrent() + 1, limitResult.getLimitingGroup());
return false;
}
return false;
}
}
// Check if the player can still extend this rent
if(extend && !plugin.hasPermission(offlinePlayer, "areashop.rentextendbypass")) {
if(getMaxExtends() >= 0 && getTimesExtended() >= getMaxExtends()) {
message(offlinePlayer, "rent-maxExtends");
return false;
}
}
// Check if there is enough time left before hitting maxRentTime
boolean extendToMax = false;
double price = getPrice();
long timeNow = Calendar.getInstance().getTimeInMillis();
long timeRented = 0;
long maxRentTime = getMaxRentTime();
if(isRented()) {
timeRented = getRentedUntil() - timeNow;
}
if((timeRented + getDuration()) > (maxRentTime)
&& !plugin.hasPermission(offlinePlayer, "areashop.renttimebypass")
&& maxRentTime != -1) {
// Extend to the maximum instead of adding a full period
if(getBooleanSetting("rent.extendToFullWhenAboveMaxRentTime")) {
if(timeRented >= maxRentTime) {
message(offlinePlayer, "rent-alreadyAtFull");
return false;
} else {
long toRentPart = maxRentTime - timeRented;
extendToMax = true;
price = ((double)toRentPart) / getDuration() * price;
}
} else {
message(offlinePlayer, "rent-maxRentTime");
return false;
}
}
// Check if the player has enough money
if(!plugin.getEconomy().has(offlinePlayer, getWorldName(), price)) {
if(extend) {
message(offlinePlayer, "rent-lowMoneyExtend", Utils.formatCurrency(plugin.getEconomy().getBalance(offlinePlayer, getWorldName())));
} else {
message(offlinePlayer, "rent-lowMoneyRent", Utils.formatCurrency(plugin.getEconomy().getBalance(offlinePlayer, getWorldName())));
}
return false;
}
// Broadcast and check event
RentingRegionEvent event = new RentingRegionEvent(this, offlinePlayer, extend);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
message(offlinePlayer, "general-cancelled", event.getReason());
return false;
}
// Substract the money from the players balance
EconomyResponse r = plugin.getEconomy().withdrawPlayer(offlinePlayer, getWorldName(), price);
if(!r.transactionSuccess()) {
message(offlinePlayer, "rent-payError");
AreaShop.debug("Something went wrong with getting money from " + offlinePlayer.getName() + " while renting " + getName() + ": " + r.errorMessage);
return false;
}
// Optionally give money to the landlord
OfflinePlayer landlordPlayer = null;
if(getLandlord() != null) {
landlordPlayer = Bukkit.getOfflinePlayer(getLandlord());
}
String landlordName = getLandlordName();
if(landlordName != null) {
if(landlordPlayer != null && landlordPlayer.getName() != null) {
r = plugin.getEconomy().depositPlayer(landlordPlayer, getWorldName(), price);
} else {
r = plugin.getEconomy().depositPlayer(landlordName, getWorldName(), price);
}
if(r == null || !r.transactionSuccess()) {
AreaShop.warn("Something went wrong with paying '" + landlordName + "' " + Utils.formatCurrency(price) + " for his rent of region " + getName() + " to " + offlinePlayer.getName());
}
}
// Get the time until the region will be rented
Calendar calendar = Calendar.getInstance();
if(extendToMax) {
calendar.setTimeInMillis(calendar.getTimeInMillis() + getMaxRentTime());
} else if(extend) {
calendar.setTimeInMillis(getRentedUntil() + getDuration());
} else {
calendar.setTimeInMillis(calendar.getTimeInMillis() + getDuration());
}
// Add values to the rent and send it to FileManager
setRentedUntil(calendar.getTimeInMillis());
setRenter(offlinePlayer.getUniqueId());
updateLastActiveTime();
// Fire schematic event and updated times extended
if(!extend) {
this.handleSchematicEvent(RegionEvent.RENTED);
setTimesExtended(0);
} else {
setTimesExtended(getTimesExtended() + 1);
}
// Send message to the player
if(extendToMax) {
message(offlinePlayer, "rent-extendedToMax");
} else if(extend) {
message(offlinePlayer, "rent-extended");
} else {
message(offlinePlayer, "rent-rented");
}
// Notify about updates
this.notifyAndUpdate(new RentedRegionEvent(this, extend));
return true;
}
/**
* Unrent a region, reset to unrented.
* @param giveMoneyBack true if money should be given back to the player, false otherwise
* @param executor The CommandSender that should get the cancelled message if there is any, or null
* @return true if unrenting succeeded, othwerwise false
*/
@SuppressWarnings("deprecation")
public boolean unRent(boolean giveMoneyBack, CommandSender executor) {
boolean own = executor instanceof Player && this.isRenter((Player) executor);
if(executor != null) {
if(!executor.hasPermission("areashop.unrent") && !own) {
message(executor, "unrent-noPermissionOther");
return false;
}
if(!executor.hasPermission("areashop.unrent") && !executor.hasPermission("areashop.unrentown") && own) {
message(executor, "unrent-noPermission");
return false;
}
}
if(plugin.getEconomy() == null) {
return false;
}
// Broadcast and check event
UnrentingRegionEvent event = new UnrentingRegionEvent(this);
Bukkit.getPluginManager().callEvent(event);
if(event.isCancelled()) {
message(executor, "general-cancelled", event.getReason());
return false;
}
// Do a payback
double moneyBack = getMoneyBackAmount();
if(moneyBack > 0 && giveMoneyBack) {
boolean noPayBack = false;
OfflinePlayer landlordPlayer = null;
if(getLandlord() != null) {
landlordPlayer = Bukkit.getOfflinePlayer(getLandlord());
}
String landlordName = getLandlordName();
EconomyResponse r;
if(landlordName != null) {
if(landlordPlayer != null && landlordPlayer.getName() != null) {
r = plugin.getEconomy().withdrawPlayer(landlordPlayer, getWorldName(), moneyBack);
} else {
r = plugin.getEconomy().withdrawPlayer(landlordName, getWorldName(), moneyBack);
}
if(r == null || !r.transactionSuccess()) {
noPayBack = true;
}
}
// Give back the money
OfflinePlayer player = Bukkit.getOfflinePlayer(getRenter());
if(player != null && !noPayBack) {
r = null;
boolean error = false;
try {
if(player.getName() != null) {
r = plugin.getEconomy().depositPlayer(player, getWorldName(), moneyBack);
} else if(getPlayerName() != null) {
r = plugin.getEconomy().depositPlayer(getPlayerName(), getWorldName(), moneyBack);
}
} catch(Exception e) {
error = true;
}
if(error || r == null || !r.transactionSuccess()) {
AreaShop.warn("Something went wrong with paying back to " + getPlayerName() + " money while unrenting region " + getName());
}
}
}
// Handle schematic save/restore (while %uuid% is still available)
handleSchematicEvent(RegionEvent.UNRENTED);
// Send message: before actual removal of the renter so that it is still available for variables
message(executor, "unrent-unrented");
// Remove friends, the owner and renteduntil values
getFriendsFeature().clearFriends();
UUID oldRenter = getRenter();
setRenter(null);
setRentedUntil(null);
setTimesExtended(-1);
removeLastActiveTime();
// Notify about updates
this.notifyAndUpdate(new UnrentedRegionEvent(this, oldRenter, Math.max(0, moneyBack)));
return true;
}
@Override
public boolean checkInactive() {
if(isDeleted() || !isRented()) {
return false;
}
long inactiveSetting = getInactiveTimeUntilUnrent();
OfflinePlayer player = Bukkit.getOfflinePlayer(getRenter());
if(inactiveSetting <= 0 || player.isOp()) {
return false;
}
long lastPlayed = getLastActiveTime();
//AreaShop.debug("currentTime=" + Calendar.getInstance().getTimeInMillis() + ", getLastPlayed()=" + lastPlayed + ", timeInactive=" + (Calendar.getInstance().getTimeInMillis()-player.getLastPlayed()) + ", inactiveSetting=" + inactiveSetting);
if(Calendar.getInstance().getTimeInMillis() > (lastPlayed + inactiveSetting)) {
AreaShop.info("Region " + getName() + " unrented because of inactivity for player " + getPlayerName());
AreaShop.debug("currentTime=" + Calendar.getInstance().getTimeInMillis() + ", getLastPlayed()=" + lastPlayed + ", timeInactive=" + (Calendar.getInstance().getTimeInMillis() - player.getLastPlayed()) + ", inactiveSetting=" + inactiveSetting);
return this.unRent(true, null);
}
return false;
}
}
@@ -0,0 +1,143 @@
package me.wiefferink.areashop.tools;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import org.bstats.Metrics;
import java.util.HashMap;
public class Analytics {
private Analytics() {
}
/**
* Start analytics tracking.
*/
public static void start() {
// bStats statistics
try {
Metrics metrics = new Metrics(AreaShop.getInstance());
// Number of regions
metrics.addCustomChart(new Metrics.SingleLineChart("region_count") {
@Override
public int getValue() {
return AreaShop.getInstance().getFileManager().getRegions().size();
}
});
// Number of rental regions
metrics.addCustomChart(new Metrics.SingleLineChart("rental_region_count") {
@Override
public int getValue() {
return AreaShop.getInstance().getFileManager().getRents().size();
}
});
// Number of buy regions
metrics.addCustomChart(new Metrics.SingleLineChart("buy_region_count") {
@Override
public int getValue() {
return AreaShop.getInstance().getFileManager().getBuys().size();
}
});
// Language
metrics.addCustomChart(new Metrics.SimplePie("language") {
@Override
public String getValue() {
return AreaShop.getInstance().getConfig().getString("language");
}
});
// Pie with region states
metrics.addCustomChart(new Metrics.AdvancedPie("region_state") {
@Override
public HashMap<String, Integer> getValues(HashMap<String, Integer> result) {
RegionStateStats stats = getStateStats();
result.put("For Rent", stats.forrent);
result.put("Rented", stats.rented);
result.put("For Sale", stats.forsale);
result.put("Sold", stats.sold);
result.put("Reselling", stats.reselling);
return result;
}
});
// Time series of each region state
metrics.addCustomChart(new Metrics.SingleLineChart("forrent_region_count") {
@Override
public int getValue() {
return getStateStats().forrent;
}
});
metrics.addCustomChart(new Metrics.SingleLineChart("rented_region_count") {
@Override
public int getValue() {
return getStateStats().rented;
}
});
metrics.addCustomChart(new Metrics.SingleLineChart("forsale_region_count") {
@Override
public int getValue() {
return getStateStats().forsale;
}
});
metrics.addCustomChart(new Metrics.SingleLineChart("sold_region_count") {
@Override
public int getValue() {
return getStateStats().sold;
}
});
metrics.addCustomChart(new Metrics.SingleLineChart("reselling_region_count") {
@Override
public int getValue() {
return getStateStats().reselling;
}
});
// TODO track rent/buy/unrent/sell/resell actions (so that it can be reported per collection interval)
AreaShop.debug("Started bstats.org statistics service");
} catch(Exception e) {
AreaShop.debug("Could not start bstats.org statistics service");
}
}
private static class RegionStateStats {
int forrent = 0;
int forsale = 0;
int rented = 0;
int sold = 0;
int reselling = 0;
}
private static RegionStateStats getStateStats() {
RegionStateStats result = new RegionStateStats();
for(GeneralRegion region : AreaShop.getInstance().getFileManager().getRegions()) {
if(region instanceof RentRegion) {
RentRegion rent = (RentRegion)region;
if(rent.isAvailable()) {
result.forrent++;
} else {
result.rented++;
}
} else if(region instanceof BuyRegion) {
BuyRegion buy = (BuyRegion)region;
if(buy.isAvailable()) {
result.forsale++;
} else if(buy.isInResellingMode()) {
result.reselling++;
} else {
result.sold++;
}
}
}
return result;
}
}
@@ -0,0 +1,251 @@
package me.wiefferink.areashop.tools;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.Arrays;
import java.util.logging.Logger;
public class GithubUpdateCheck {
public static final String API_HOST = "https://api.github.com/repos";
public static final String API_LATEST_RELEASE = "releases/latest";
public static final String USER_AGENT = "GithubUpdateCheck by NLThijs48";
public static final boolean DEBUG = false;
private final String author;
private final String repository;
private final Plugin plugin;
private final Logger logger;
private URL url;
private VersionComparator versionComparator;
// Status
private boolean checking;
private boolean error;
private boolean hasUpdate;
private String latestVersion;
private final String currentVersion;
/**
* Create a new GithubUpdateCheck with the required information.
* @param plugin The plugin to create it for (used for logging and checking version)
* @param author The author of the plugin as used on Github
* @param repository The repository name of the plugin on Github
*/
public GithubUpdateCheck(Plugin plugin, String author, String repository) {
this.plugin = plugin;
this.logger = plugin.getLogger();
this.author = author;
this.repository = repository;
this.currentVersion = plugin.getDescription().getVersion();
this.versionComparator = (latest, current) ->
!latest.equalsIgnoreCase(current);
this.checking = false;
this.error = false;
this.hasUpdate = false;
}
/**
* Change the version comparator.
* @param versionComparator VersionComparator to use for checking if one version is newer than the other
* @return this
*/
public GithubUpdateCheck withVersionComparator(VersionComparator versionComparator) {
this.versionComparator = versionComparator;
return this;
}
/**
* Check if an update is available.
*/
public void checkUpdate() {
checkUpdate(null);
}
/**
* Check if an update is available.
* @param callback Callback to execute when the update check is done
* @return GithubUpdateCheck containing the status of the check
*/
public GithubUpdateCheck checkUpdate(UpdateCallback callback) {
checking = true;
final GithubUpdateCheck self = this;
// Check for update on asyn thread
new BukkitRunnable() {
@Override
public void run() {
try {
try {
String rawUrl = API_HOST + "/" + author + "/" + repository + "/" + API_LATEST_RELEASE;
url = new URL(rawUrl);
} catch(MalformedURLException e) {
logger.severe("Invalid url: '" + url + "', are the author '" + author + "' and repository '" + repository + "' correct?");
error = true;
return;
}
try {
URLConnection conn = url.openConnection();
// Give up after 15 seconds
conn.setConnectTimeout(15000);
// Identify ourselves
conn.addRequestProperty("User-Agent", USER_AGENT);
// Make sure we access the correct api version
conn.addRequestProperty("Accept", "application/vnd.github.v3+json");
// We want to read the result
conn.setDoOutput(true);
// Open connection
try(BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()))) {
String response = reader.readLine();
debug("Response:", response);
JSONObject latestRelease = (JSONObject)JSONValue.parse(response);
if(latestRelease.isEmpty()) {
logger.warning("Failed to get api response from " + url);
error = true;
return;
}
debug("json: " + latestRelease.toJSONString());
// Latest version
latestVersion = (String)latestRelease.get("tag_name");
debug("Tag name:", latestVersion);
// Current version
debug("Plugin version:", currentVersion);
// Compare version
hasUpdate = versionComparator.isNewer(latestVersion, currentVersion);
}
} catch(IOException e) {
logger.severe("Failed to get latest release:" + ExceptionUtils.getStackTrace(e));
error = true;
} catch(ClassCastException e) {
logger.info("Unexpected structure of the result, failed to parse it");
error = true;
}
} finally {
checking = false;
debug("result:", self);
if(callback != null) {
// Switch back to main thread and call the callback
new BukkitRunnable() {
@Override
public void run() {
callback.run(self);
}
}.runTask(plugin);
}
}
}
}.runTaskAsynchronously(plugin);
return this;
}
/**
* Check if an update check is running.
* @return true if an update check is running
*/
public boolean isChecking() {
return checking;
}
/**
* Check if the update check failed.
* @return true if the update check failed (an error message has been logged)
*/
public boolean hasFailed() {
return error;
}
/**
* Check if an update has been found.
* @return true if an update has been found
*/
public boolean hasUpdate() {
return hasUpdate;
}
/**
* Get the repository that this update checker is checking.
* @return Used repository
*/
public String getRepository() {
return repository;
}
/**
* Get the author that this update checker is checking.
* @return Used author
*/
public String getAuthor() {
return author;
}
/**
* Get the current version.
* @return Current version of the plugin
*/
public String getCurrentVersion() {
return currentVersion;
}
/**
* Get the latest version.
* @return Latest version of the plugin (if checking is complete)
*/
public String getLatestVersion() {
return latestVersion;
}
public interface VersionComparator {
/**
* Check if a version should be considered 'newer' than another.
* @param latestVersion Version that is available on Github
* @param currentVersion Version of the current plugin
* @return true if the latestVersion is newer than the localVersion, otherwise false
*/
boolean isNewer(String latestVersion, String currentVersion);
}
public interface UpdateCallback {
void run(GithubUpdateCheck result);
}
/**
* Print a debug message if DEBUG is enabled.
* @param message Message to print
*/
private void debug(Object... message) {
if(DEBUG) {
logger.info("[" + this.getClass().getSimpleName() + "] [DEBUG] " + StringUtils.join(message, " "));
}
}
@Override
public String toString() {
return "GithubUpdateCheck(" + StringUtils.join(Arrays.asList(
"author=" + author,
"repository=" + repository,
"plugin=" + plugin.getName(),
"checking=" + checking,
"hasUpdate=" + hasUpdate,
"error=" + error,
"currentVersion=" + currentVersion,
"latestVersion=" + latestVersion
), ", ") + ")";
}
}
@@ -0,0 +1,132 @@
package me.wiefferink.areashop.tools;
import me.wiefferink.areashop.AreaShop;
import org.bukkit.Bukkit;
import org.bukkit.Material;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
public class Materials {
private Materials() {
}
private static final HashSet<String> WALL_SIGN_TYPES = new HashSet<>(Arrays.asList(
// 1.14+ types
"ACACIA_WALL_SIGN",
"BIRCH_WALL_SIGN",
"DARK_OAK_WALL_SIGN",
"JUNGLE_WALL_SIGN",
"OAK_WALL_SIGN",
"SPRUCE_WALL_SIGN",
// Legacy types
"LEGACY_WALL_SIGN",
"WALL_SIGN"
));
private static final HashSet<String> FLOOR_SIGN_TYPES = new HashSet<>(Arrays.asList(
// 1.14+ types
"ACACIA_SIGN",
"BIRCH_SIGN",
"DARK_OAK_SIGN",
"JUNGLE_SIGN",
"OAK_SIGN",
"SPRUCE_SIGN",
// Legacy types
"LEGACY_SIGN",
"LEGACY_SIGN_POST",
"SIGN",
"SIGN_POST"
));
private static boolean legacyMaterials = false;
static {
List<String> legacyMaterialVersions = Arrays.asList("1.7", "1.8", "1.9", "1.10", "1.11", "1.12");
for(String legacyMaterialVersion : legacyMaterialVersions) {
String version = Bukkit.getBukkitVersion();
// Detects '1.8', '1.8.3', '1.8-pre1' style versions
if(version.equals(legacyMaterialVersion)
|| version.startsWith(legacyMaterialVersion + ".")
|| version.startsWith(legacyMaterialVersion + "-")) {
legacyMaterials = true;
break;
}
}
}
/**
* Get material based on a sign material name.
* @param name Name of the sign material
* @return null if not a sign, otherwise the material matching the name (when the material is not available on the current minecraft version, it returns the base type)
*/
public static Material signNameToMaterial(String name) {
// Expected null case
if (!isSign(name)) {
return null;
}
Material result = null;
if (legacyMaterials) {
// 1.12 and lower just know SIGN_POST, WALL_SIGN and SIGN
if (FLOOR_SIGN_TYPES.contains(name)) {
result = Material.getMaterial("SIGN_POST");
} else if (WALL_SIGN_TYPES.contains(name)) {
result = Material.getMaterial("WALL_SIGN");
if (result == null) {
result = Material.getMaterial("SIGN");
}
}
} else {
// Try saved name (works for wood types on 1.14, regular types for below)
result = Material.getMaterial(name);
if (result == null) {
// Cases for 1.13, which don't know wood types, but need new materials
if (FLOOR_SIGN_TYPES.contains(name)) {
// SIGN -> OAK_SIGN for 1.14
result = Material.getMaterial("OAK_SIGN");
// Fallback for 1.13
if (result == null) {
result = Material.getMaterial("SIGN");
}
} else if (WALL_SIGN_TYPES.contains(name)) {
// WALL_SIGN -> OAK_WALL_SIGN for 1.14
result = Material.getMaterial("OAK_WALL_SIGN");
// Fallback for 1.13
if (result == null) {
result = Material.getMaterial("WALL_SIGN");
}
}
}
}
if (result == null) {
AreaShop.debug("Materials.get() null result:", name, "legacyMaterials:", legacyMaterials);
}
return result;
}
/**
* Check if a Material is a sign (of either the wall or floor type).
* @param material Material to check
* @return true if the given material is a sign
*/
public static boolean isSign(Material material) {
return isSign(material.name());
}
/**
* Check if a Material is a sign (of either the wall or floor type).
* @param name String to check
* @return true if the given material is a sign
*/
public static boolean isSign(String name) {
return name != null && (FLOOR_SIGN_TYPES.contains(name) || WALL_SIGN_TYPES.contains(name));
}
}
@@ -0,0 +1,924 @@
package me.wiefferink.areashop.tools;
import co.aikar.taskchain.TaskChain;
import co.aikar.taskchain.TaskChainFactory;
import com.sk89q.worldguard.protection.managers.RegionManager;
import com.sk89q.worldguard.protection.regions.ProtectedRegion;
import me.wiefferink.areashop.AreaShop;
import me.wiefferink.areashop.interfaces.WorldEditSelection;
import me.wiefferink.areashop.regions.BuyRegion;
import me.wiefferink.areashop.regions.GeneralRegion;
import me.wiefferink.areashop.regions.RentRegion;
import me.wiefferink.interactivemessenger.Log;
import me.wiefferink.interactivemessenger.processing.Message;
import org.apache.commons.lang.exception.ExceptionUtils;
import org.bukkit.*;
import org.bukkit.block.BlockFace;
import org.bukkit.configuration.Configuration;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
import org.bukkit.util.Vector;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Supplier;
public class Utils {
private static final BlockFace[] facings = {BlockFace.NORTH, BlockFace.NORTH_EAST, BlockFace.EAST, BlockFace.SOUTH_EAST, BlockFace.SOUTH, BlockFace.SOUTH_WEST, BlockFace.WEST, BlockFace.NORTH_WEST};
public static TaskChainFactory factory;
private static YamlConfiguration config;
private static Set<String> identifiers;
private static Set<String> seconds;
private static Set<String> minutes;
private static Set<String> hours;
private static Set<String> days;
private static Set<String> weeks;
private static Set<String> months;
private static Set<String> years;
private static ScriptEngine scriptEngine;
private static Map<Double, String> suffixes;
// Not used
private Utils() {
}
/**
* Initialize the utilities class with constants.
*
* @param pluginConfig The config of the plugin
*/
public static void initialize(YamlConfiguration pluginConfig) {
config = pluginConfig;
// Setup individual identifiers
seconds = getSetAndDefaults("seconds");
minutes = getSetAndDefaults("minutes");
hours = getSetAndDefaults("hours");
days = getSetAndDefaults("days");
weeks = getSetAndDefaults("weeks");
months = getSetAndDefaults("months");
years = getSetAndDefaults("years");
// Setup all time identifiers
identifiers = new HashSet<>();
identifiers.addAll(seconds);
identifiers.addAll(minutes);
identifiers.addAll(hours);
identifiers.addAll(days);
identifiers.addAll(weeks);
identifiers.addAll(months);
identifiers.addAll(years);
suffixes = new HashMap<>();
// This stuff should not be necessary, but it is, getConfigurationSection() does not do proper fallback to defaults!
// TODO: Create a custom configuration that fixes this behavior
ConfigurationSection suffixesSection = null;
if (config.isSet("metricSymbols")) {
suffixesSection = config.getConfigurationSection("metricSymbols");
} else {
Configuration defaults = config.getDefaults();
if (defaults != null) {
suffixesSection = defaults.getConfigurationSection("metricSymbols");
}
}
if (suffixesSection != null) {
for (String key : suffixesSection.getKeys(false)) {
try {
suffixes.put(Double.parseDouble(key), suffixesSection.getString(key));
} catch (NumberFormatException e) {
Log.warn("Key '" + key + "' in the metricSymbols section of config.yml is not a number!");
}
}
}
}
/**
* Get a string list from the config, combined with the entries specified in the default config.
*
* @param path The path to read the lists from
* @return List with all values defined in the config and the default config combined
*/
private static Set<String> getSetAndDefaults(String path) {
Set<String> result = new HashSet<>(config.getStringList(path));
ConfigurationSection defaults = config.getDefaults();
if (defaults != null) {
result.addAll(defaults.getStringList(path));
}
return result;
}
/**
* Create a message with a list of parts.
*
* @param replacements The parts to use
* @param messagePart The message to use for the parts
* @return A Message object containing the parts combined into one message
*/
public static Message combinedMessage(Collection<?> replacements, String messagePart) {
return combinedMessage(replacements, messagePart, ", ");
}
/**
* Create a message with a list of parts.
*
* @param replacements The parts to use
* @param messagePart The message to use for the parts
* @param combiner The string to use as combiner
* @return A Message object containing the parts combined into one message
*/
public static Message combinedMessage(Collection<?> replacements, String messagePart, String combiner) {
Message result = Message.empty();
boolean first = true;
for (Object part : replacements) {
if (first) {
first = false;
} else {
result.append(combiner);
}
result.append(Message.fromKey(messagePart).replacements(part));
}
return result;
}
/**
* Gets the online players.
* Provides backwards compatibility for 1.7- where it returns an array
*
* @return Online players
*/
@SuppressWarnings("unchecked")
public static Collection<? extends Player> getOnlinePlayers() {
try {
Method onlinePlayerMethod = Server.class.getMethod("getOnlinePlayers");
if (onlinePlayerMethod.getReturnType().equals(Collection.class)) {
return ((Collection<? extends Player>) onlinePlayerMethod.invoke(Bukkit.getServer()));
} else {
return Arrays.asList((Player[]) onlinePlayerMethod.invoke(Bukkit.getServer()));
}
} catch (Exception ex) {
AreaShop.debug("getOnlinePlayers error: " + ex.getMessage());
}
return new HashSet<>();
}
/**
* Create a map from a location, to save it in the config.
*
* @param location The location to transform
* @param setPitchYaw true to save the pitch and yaw, otherwise false
* @return The map with the location values
*/
public static ConfigurationSection locationToConfig(Location location, boolean setPitchYaw) {
if (location == null) {
return null;
}
ConfigurationSection result = new YamlConfiguration();
result.set("world", location.getWorld().getName());
result.set("x", location.getX());
result.set("y", location.getY());
result.set("z", location.getZ());
if (setPitchYaw) {
result.set("yaw", Float.toString(location.getYaw()));
result.set("pitch", Float.toString(location.getPitch()));
}
return result;
}
/**
* Create a map from a location, to save it in the config (without pitch and yaw).
*
* @param location The location to transform
* @return The map with the location values
*/
public static ConfigurationSection locationToConfig(Location location) {
return locationToConfig(location, false);
}
/**
* Create a location from a map, reconstruction from the config values.
*
* @param config The config section to reconstruct from
* @return The location
*/
public static Location configToLocation(ConfigurationSection config) {
if (config == null
|| !config.isString("world")
|| !config.isDouble("x")
|| !config.isDouble("y")
|| !config.isDouble("z")
|| Bukkit.getWorld(config.getString("world")) == null) {
return null;
}
Location result = new Location(
Bukkit.getWorld(config.getString("world")),
config.getDouble("x"),
config.getDouble("y"),
config.getDouble("z"));
if (config.isString("yaw") && config.isString("pitch")) {
result.setPitch(Float.parseFloat(config.getString("pitch")));
result.setYaw(Float.parseFloat(config.getString("yaw")));
}
return result;
}
/**
* Create a comma-separated list.
*
* @param input Collection of object which should be concatenated with comma's in between (skipping null values)
* @return Innput object concatenated with comma's in between
*/
public static String createCommaSeparatedList(Collection<?> input) {
StringBuilder result = new StringBuilder();
boolean first = true;
for (Object object : input) {
if (object != null) {
if (first) {
first = false;
result.append(object.toString());
} else {
result.append(", ").append(object.toString());
}
}
}
return result.toString();
}
/**
* Convert milliseconds to ticks.
*
* @param milliseconds Milliseconds to convert
* @return milliseconds divided by 50 (20 ticks per second)
*/
public static long millisToTicks(long milliseconds) {
return milliseconds / 50;
}
/**
* Convert milliseconds to a human readable format.
*
* @param milliseconds The amount of milliseconds to convert
* @return A formatted string based on the language file
*/
public static String millisToHumanFormat(long milliseconds) {
long timeLeft = milliseconds + 500;
// To seconds
timeLeft /= 1000;
if (timeLeft <= 0) {
return Message.fromKey("timeleft-ended").getPlain();
} else if (timeLeft == 1) {
return Message.fromKey("timeleft-second").replacements(timeLeft).getPlain();
} else if (timeLeft <= 120) {
return Message.fromKey("timeleft-seconds").replacements(timeLeft).getPlain();
}
// To minutes
timeLeft /= 60;
if (timeLeft <= 120) {
return Message.fromKey("timeleft-minutes").replacements(timeLeft).getPlain();
}
// To hours
timeLeft /= 60;
if (timeLeft <= 48) {
return Message.fromKey("timeleft-hours").replacements(timeLeft).getPlain();
}
// To days
timeLeft /= 24;
if (timeLeft <= 60) {
return Message.fromKey("timeleft-days").replacements(timeLeft).getPlain();
}
// To months
timeLeft /= 30;
if (timeLeft <= 24) {
return Message.fromKey("timeleft-months").replacements(timeLeft).getPlain();
}
// To years
timeLeft /= 12;
return Message.fromKey("timeleft-years").replacements(timeLeft).getPlain();
}
// ======================================================================
// Methods to get WorldGuard or AreaShop regions by location or selection
// ======================================================================
/**
* Get the facing direction based on the yaw.
*
* @param yaw The horizontal angle that for example the player is looking
* @return The Block Face of the angle
*/
public static BlockFace yawToFacing(float yaw) {
return facings[Math.round(yaw / 45f) & 0x7];
}
/**
* Get all AreaShop regions intersecting with a WorldEdit selection.
*
* @param selection The selection to check
* @return A list with all the AreaShop regions intersecting with the selection
*/
public static List<GeneralRegion> getRegionsInSelection(WorldEditSelection selection) {
ArrayList<GeneralRegion> result = new ArrayList<>();
for (ProtectedRegion region : getWorldEditRegionsInSelection(selection)) {
GeneralRegion asRegion = AreaShop.getInstance().getFileManager().getRegion(region.getId());
if (asRegion != null) {
result.add(asRegion);
}
}
return result;
}
/**
* Get all AreaShop regions containing a location.
*
* @param location The location to check
* @return A list with all the AreaShop regions that contain the location
*/
public static List<GeneralRegion> getRegions(Location location) {
return getRegionsInSelection(new WorldEditSelection(location.getWorld(), location, location));
}
/**
* Get all WorldGuard regions intersecting with a WorldEdit selection.
*
* @param selection The selection to check
* @return A list with all the WorldGuard regions intersecting with the selection
*/
public static List<ProtectedRegion> getWorldEditRegionsInSelection(WorldEditSelection selection) {
// Get all regions inside or intersecting with the WorldEdit selection of the player
World world = selection.getWorld();
RegionManager regionManager = AreaShop.getInstance().getRegionManager(world);
ArrayList<ProtectedRegion> result = new ArrayList<>();
Location selectionMin = selection.getMinimumLocation();
Location selectionMax = selection.getMaximumLocation();
for (ProtectedRegion region : regionManager.getRegions().values()) {
Vector regionMin = AreaShop.getInstance().getWorldGuardHandler().getMinimumPoint(region);
Vector regionMax = AreaShop.getInstance().getWorldGuardHandler().getMaximumPoint(region);
if (
( // x part, resolves to true if the selection and region overlap anywhere on the x-axis
(regionMin.getBlockX() <= selectionMax.getBlockX() && regionMin.getBlockX() >= selectionMin.getBlockX())
|| (regionMax.getBlockX() <= selectionMax.getBlockX() && regionMax.getBlockX() >= selectionMin.getBlockX())
|| (selectionMin.getBlockX() >= regionMin.getBlockX() && selectionMin.getBlockX() <= regionMax.getBlockX())
|| (selectionMax.getBlockX() >= regionMin.getBlockX() && selectionMax.getBlockX() <= regionMax.getBlockX())
) && ( // Y part, resolves to true if the selection and region overlap anywhere on the y-axis
(regionMin.getBlockY() <= selectionMax.getBlockY() && regionMin.getBlockY() >= selectionMin.getBlockY())
|| (regionMax.getBlockY() <= selectionMax.getBlockY() && regionMax.getBlockY() >= selectionMin.getBlockY())
|| (selectionMin.getBlockY() >= regionMin.getBlockY() && selectionMin.getBlockY() <= regionMax.getBlockY())
|| (selectionMax.getBlockY() >= regionMin.getBlockY() && selectionMax.getBlockY() <= regionMax.getBlockY())
) && ( // Z part, resolves to true if the selection and region overlap anywhere on the z-axis
(regionMin.getBlockZ() <= selectionMax.getBlockZ() && regionMin.getBlockZ() >= selectionMin.getBlockZ())
|| (regionMax.getBlockZ() <= selectionMax.getBlockZ() && regionMax.getBlockZ() >= selectionMin.getBlockZ())
|| (selectionMin.getBlockZ() >= regionMin.getBlockZ() && selectionMin.getBlockZ() <= regionMax.getBlockZ())
|| (selectionMax.getBlockZ() >= regionMin.getBlockZ() && selectionMax.getBlockZ() <= regionMax.getBlockZ())
)
) {
result.add(region);
}
}
return result;
}
/**
* Get a list of regions around a location.
* - Returns highest priority, child instead of parent regions
*
* @param location The location to check for regions
* @return empty list if no regions found, 1 member if 1 region is a priority, more if regions with the same priority
*/
public static List<ProtectedRegion> getImportantWorldEditRegions(Location location) {
List<ProtectedRegion> result = new ArrayList<>();
Set<ProtectedRegion> regions = AreaShop.getInstance().getWorldGuardHandler().getApplicableRegionsSet(location);
if (regions != null) {
boolean first = true;
for (ProtectedRegion pr : regions) {
if (first) {
result.add(pr);
first = false;
} else {
if (pr.getPriority() > result.get(0).getPriority()) {
result.clear();
result.add(pr);
} else if (pr.getParent() != null && pr.getParent().equals(result.get(0))) {
result.clear();
result.add(pr);
} else {
result.add(pr);
}
}
}
}
return result;
}
/**
* Get the most important rental AreaShop regions.
* - Returns highest priority, child instead of parent regions.
*
* @param location The location to check for regions
* @return empty list if no regions found, 1 member if 1 region is a priority, more if regions with the same priority
*/
public static List<RentRegion> getImportantRentRegions(Location location) {
List<RentRegion> result = new ArrayList<>();
for (GeneralRegion region : getImportantRegions(location, GeneralRegion.RegionType.RENT)) {
result.add((RentRegion) region);
}
return result;
}
/**
* Get the most important buy AreaShop regions.
* - Returns highest priority, child instead of parent regions.
*
* @param location The location to check for regions
* @return empty list if no regions found, 1 member if 1 region is a priority, more if regions with the same priority
*/
public static List<BuyRegion> getImportantBuyRegions(Location location) {
List<BuyRegion> result = new ArrayList<>();
for (GeneralRegion region : getImportantRegions(location, GeneralRegion.RegionType.BUY)) {
result.add((BuyRegion) region);
}
return result;
}
/**
* Get the most important AreaShop regions.
* - Returns highest priority, child instead of parent regions.
*
* @param location The location to check for regions
* @return empty list if no regions found, 1 member if 1 region is a priority, more if regions with the same priority
*/
public static List<GeneralRegion> getImportantRegions(Location location) {
return getImportantRegions(location, null);
}
/**
* Get the most important AreaShop regions.
* - Returns highest priority, child instead of parent regions.
*
* @param location The location to check for regions
* @param type The type of regions to look for, null for all
* @return empty list if no regions found, 1 member if 1 region is a priority, more if regions with the same priority
*/
public static List<GeneralRegion> getImportantRegions(Location location, GeneralRegion.RegionType type) {
List<GeneralRegion> result = new ArrayList<>();
Set<ProtectedRegion> regions = AreaShop.getInstance().getWorldGuardHandler().getApplicableRegionsSet(location);
if (regions != null) {
List<GeneralRegion> candidates = new ArrayList<>();
for (ProtectedRegion pr : regions) {
GeneralRegion region = AreaShop.getInstance().getFileManager().getRegion(pr.getId());
if (region != null && (
(type == GeneralRegion.RegionType.RENT && region instanceof RentRegion)
|| (type == GeneralRegion.RegionType.BUY && region instanceof BuyRegion)
|| type == null)) {
candidates.add(region);
}
}
boolean first = true;
for (GeneralRegion region : candidates) {
if (region == null) {
AreaShop.debug("skipped null region");
continue;
}
if (first) {
result.add(region);
first = false;
} else {
if (region.getRegion().getPriority() > result.get(0).getRegion().getPriority()) {
result.clear();
result.add(region);
} else if (region.getRegion().getParent() != null && region.getRegion().getParent().equals(result.get(0).getRegion())) {
result.clear();
result.add(region);
} else {
result.add(region);
}
}
}
}
return new ArrayList<>(result);
}
/**
* Convert color and formatting codes to bukkit values.
*
* @param input Start string with color and formatting codes in it
* @return String with the color and formatting codes in the bukkit format
*/
public static String applyColors(String input) {
String result = null;
if (input != null) {
result = ChatColor.translateAlternateColorCodes('&', input);
}
return result;
}
/**
* Format the currency amount with the characters before and after.
*
* @param amount Amount of money to format
* @return Currency character format string
*/
public static String formatCurrency(double amount) {
String before = config.getString("moneyCharacter");
before = before.replace(AreaShop.currencyEuro, "€");
String after = config.getString("moneyCharacterAfter");
after = after.replace(AreaShop.currencyEuro, "€");
String result;
// Check for infinite and NaN
if (Double.isInfinite(amount)) {
result = "\u221E"; // Infinite symbol
} else if (Double.isNaN(amount)) {
result = "NaN";
} else {
BigDecimal bigDecimal = BigDecimal.valueOf(amount);
boolean stripTrailingZeros = false;
int fractionalNumber = config.getInt("fractionalNumbers");
// Add metric suffix if necessary
if (config.getDouble("metricSuffixesAbove") != -1) {
String suffix = null;
double divider = 1;
for (Double number : suffixes.keySet()) {
if (amount >= number && number > divider) {
divider = number;
suffix = suffixes.get(number);
}
}
if (suffix != null) {
bigDecimal = BigDecimal.valueOf(amount / divider);
after = suffix + after;
fractionalNumber = config.getInt("fractionalNumbersShort");
stripTrailingZeros = true;
}
}
// Round if necessary
if (fractionalNumber >= 0) {
bigDecimal = bigDecimal.setScale(fractionalNumber, RoundingMode.HALF_UP);
}
result = bigDecimal.toString();
if (config.getBoolean("hideEmptyFractionalPart")) {
// Strip zero fractional: 12.00 -> 12
if (bigDecimal.remainder(BigDecimal.ONE).compareTo(BigDecimal.ZERO) == 0 && result.contains(".")) {
result = result.substring(0, result.indexOf('.'));
}
// Strip zeros from suffixed numbers: 1.20M -> 1.2M
if (stripTrailingZeros && result.contains(".")) {
result = result.replaceAll("0+$", "");
}
}
}
result = result.replace(".", config.getString("decimalMark"));
Message resultMessage = Message.fromString(result);
resultMessage.prepend(before);
resultMessage.append(after);
return resultMessage.getSingle();
}
/**
* Checks if the string is a correct time period.
*
* @param time String that has to be checked
* @return true if format is correct, false if not
*/
public static boolean checkTimeFormat(String time) {
// Check if the string is not empty and check the length
if (time == null || time.length() <= 1 || time.indexOf(' ') == -1 || time.indexOf(' ') >= (time.length() - 1)) {
return false;
}
// Check if the suffix is one of these values
String suffix = time.substring(time.indexOf(' ') + 1);
if (!identifiers.contains(suffix)) {
return false;
}
// check if the part before the space is a number
String prefix = time.substring(0, (time.indexOf(' ')));
return prefix.matches("\\d+");
}
// LEGACY TIME INPUT CONVERSION
/**
* Methode to tranlate a duration string to a millisecond value.
*
* @param duration The duration string
* @return The duration in milliseconds translated from the durationstring, or if it is invalid then 0
*/
public static long durationStringToLong(String duration) {
if (duration == null) {
return 0;
} else if (duration.equalsIgnoreCase("disabled") || duration.equalsIgnoreCase("unlimited") || duration.isEmpty()) {
return -1;
} else if (duration.indexOf(' ') == -1) {
return 0;
}
Calendar calendar = Calendar.getInstance();
calendar.setTimeInMillis(0);
String durationString = duration.substring(duration.indexOf(' ') + 1);
int durationInt = 0;
try {
durationInt = Integer.parseInt(duration.substring(0, duration.indexOf(' ')));
} catch (NumberFormatException exception) {
// No Number found, add zero
}
if (seconds.contains(durationString)) {
calendar.add(Calendar.SECOND, durationInt);
} else if (minutes.contains(durationString)) {
calendar.add(Calendar.MINUTE, durationInt);
} else if (hours.contains(durationString)) {
calendar.add(Calendar.HOUR, durationInt);
} else if (days.contains(durationString)) {
calendar.add(Calendar.DAY_OF_MONTH, durationInt);
} else if (weeks.contains(durationString)) {
calendar.add(Calendar.DAY_OF_MONTH, durationInt * 7);
} else if (months.contains(durationString)) {
calendar.add(Calendar.MONTH, durationInt);
} else if (years.contains(durationString)) {
calendar.add(Calendar.YEAR, durationInt);
} else {
AreaShop.warn("Unknown duration indicator:", durationString, "check if config.yml has the correct time indicators");
}
return calendar.getTimeInMillis();
}
/**
* Get setting from config that could be only a number indicating seconds.
* or a string indicating a duration string
*
* @param path Path of the setting to read
* @return milliseconds that the setting indicates
*/
public static long getDurationFromSecondsOrString(String path) {
if (config.isLong(path) || config.isInt(path)) {
long setting = config.getLong(path);
if (setting != -1) {
setting *= 1000;
}
return setting;
} else {
return durationStringToLong(config.getString(path));
}
}
/**
* Get setting from config that could be only a number indicating minutes.
* or a string indicating a duration string.
*
* @param path Path of the setting to read
* @return milliseconds that the setting indicates
*/
public static long getDurationFromMinutesOrString(String path) {
if (config.isLong(path) || config.isInt(path)) {
long setting = config.getLong(path);
if (setting != -1) {
setting *= 60 * 1000;
}
return setting;
} else {
return durationStringToLong(config.getString(path));
}
}
/**
* Parse a time setting that could be minutes or a duration string.
*
* @param input The string to parse
* @return milliseconds that the string indicates
*/
public static long getDurationFromMinutesOrStringInput(String input) {
long number;
try {
number = Long.parseLong(input);
if (number != -1) {
number *= 60 * 1000;
}
return number;
} catch (NumberFormatException e) {
return durationStringToLong(input);
}
}
/**
* Parse a time setting that could be seconds or a duration string.
*
* @param input The string to parse
* @return seconds that the string indicates
*/
public static long getDurationFromSecondsOrStringInput(String input) {
long number;
try {
number = Long.parseLong(input);
if (number != -1) {
number *= 1000;
}
return number;
} catch (NumberFormatException e) {
return durationStringToLong(input);
}
}
/**
* Check if an input is numeric.
*
* @param input The input to check
* @return true if the input is numeric, otherwise false
*/
@SuppressWarnings("ResultOfMethodCallIgnored")
public static boolean isNumeric(String input) {
try {
Integer.parseInt(input);
return true;
} catch (NumberFormatException ignored) {
return false;
}
}
/**
* Check if a string is a double.
*
* @param input The input
* @return true if the input is a double, otherwise false
*/
@SuppressWarnings("ResultOfMethodCallIgnored")
public static boolean isDouble(String input) {
try {
Double.parseDouble(input);
return true;
} catch (NumberFormatException e) {
return false;
}
}
// NAME <-> UUID CONVERSION
/**
* Evaluate string input to a number.
* Uses JavaScript for expressions.
*
* @param input The input string
* @param region The region to apply replacements for and use for logging
* @return double evaluated from the input or a very high default in case of a script exception
*/
public static double evaluateToDouble(String input, GeneralRegion region) {
// Replace variables
input = Message.fromString(input).replacements(region).getSingle();
// Check for simple number
if (isDouble(input)) {
return Double.parseDouble(input);
}
// Lazy init scriptEngine
if (scriptEngine == null) {
scriptEngine = new ScriptEngineManager().getEngineByName("JavaScript");
}
// Evaluate expression
Object result;
try {
result = scriptEngine.eval(input);
} catch (ScriptException e) {
AreaShop.warn("Price of region", region.getName(), "is set with an invalid expression: '" + input + "', exception:", ExceptionUtils.getStackTrace(e));
return 99999999999.0; // High fallback for safety
}
// Handle the result
if (Utils.isDouble(result.toString())) {
return Double.parseDouble(result.toString());
} else {
AreaShop.warn("Price of region", region.getName(), "is set with the expression '" + input + "' that returns a result that is not a number:", result);
return 99999999999.0; // High fallback for safety
}
}
/**
* Conversion to name by uuid.
*
* @param uuid The uuid in string format
* @return the name of the player
*/
public static String toName(String uuid) {
String result = "";
if (uuid != null) {
try {
UUID parsed = UUID.fromString(uuid);
result = toName(parsed);
} catch (IllegalArgumentException e) {
// Incorrect UUID
}
}
return result;
}
/**
* Conversion to name by uuid object.
*
* @param uuid The uuid in string format
* @return the name of the player
*/
public static String toName(UUID uuid) {
if (uuid == null) {
return "";
} else {
String name = Bukkit.getOfflinePlayer(uuid).getName();
if (name != null) {
return name;
}
return "";
}
}
/**
* Conversion from name to uuid.
*
* @param name The name of the player
* @return The uuid of the player
*/
@SuppressWarnings("deprecation") // Fake deprecation by Bukkit to inform developers, method will stay
public static String toUniqueId(String name) {
if (name == null) {
return null;
} else {
return Bukkit.getOfflinePlayer(name).getUniqueId().toString();
}
}
public static <T> TaskChain<T> newChain() {
return factory.newChain();
}
public static <T> TaskChain<T> newSharedChain(String name) {
return factory.newSharedChain(name);
}
public static <E> CompletableFuture<?> runAsBatches(final Collection<E> objects, final int batchSize, final Consumer<E> task, final boolean async) {
if (batchSize < 1) {
throw new IllegalArgumentException("Invalid batch size!");
}
final Queue<E> cloned = new LinkedList<>(objects);
final CompletableFuture<Object> future = new CompletableFuture<>();
BukkitRunnable runnable = new BukkitRunnable() {
@Override
public void run() {
if (cloned.isEmpty()) {
future.complete(true);
cancel();
}
for (int i = 0; i < batchSize && !cloned.isEmpty(); i++) {
task.accept(cloned.remove());
}
}
};
if (async) {
runnable.runTaskTimerAsynchronously(AreaShop.getInstance(), 1, 1);
} else {
runnable.runTaskTimer(AreaShop.getInstance(), 1, 1);
}
return future;
}
public static BukkitTask runCancellingTaskTimer(final Supplier<Boolean> task, final long delay, final long period, boolean async) {
BukkitRunnable runnable = new BukkitRunnable() {
@Override
public void run() {
if (!task.get()) {
cancel();
}
}
};
if(async) {
return runnable.runTaskTimerAsynchronously(AreaShop.getInstance(), delay, period);
} else {
return runnable.runTaskTimer(AreaShop.getInstance(), delay, period);
}
}
}
@@ -0,0 +1,30 @@
package me.wiefferink.areashop.tools;
public class Value<T> {
private T content;
/**
* Create a container with a default content.
* @param content The content to set
*/
public Value(T content) {
this.content = content;
}
/**
* Get the stored content.
* @return The stored content
*/
public T get() {
return content;
}
/**
* Set the content.
* @param value The new content
*/
public void set(T value) {
this.content = value;
}
}
+181
View File
@@ -0,0 +1,181 @@
# ╔════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
# ║ config.yml file of the AreaShop plugin created by NLThijs48, Github can be found at https://github.com/NLthijs48/AreaShop. ║
# ║ This file contains options to change the working of the plugin, the profiles defined here can be used in default.yml. ║
# ║ More information and tutorials can be found on the wiki: https://github.com/NLthijs48/AreaShop/wiki ║
# ╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ GENERAL: Options that influence the global state of the plugin │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Chat prefix used for all messages in the chat, also changes the greeting messages.
chatPrefix:
- '[darkgreen][AreaShop][reset]'
- ' hover: AreaShop region management plugin'
- ' hover: %lang:action|Click to check the available commands|%'
- ' command: /areashop help'
- ' '
# The language file that should be used, check the 'lang' folder for build-in languages (use the filename without .yml here).
# More information can be found here: https://github.com/NLthijs48/AreaShop/wiki/Language-support.
language: EN
# The tags that need to be written on the first line of a sign to add it to AreaShop.
signTags:
# Add a rental region.
rent: '[asrent]'
# Add a buy region.
buy: '[asbuy]'
# Add a sign to an existing region.
add: '[as]'
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ ECONOMY: Options to change the display of prices. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# The characters displayed before a price.
moneyCharacter: '$'
# The characters displayed after a price.
moneyCharacterAfter: ''
# The character(s) to use as decimal mark.
decimalMark: '.'
# How many numbers behind the dot should be shown (2 will make numbers like '8.55', '9.01', '5.20').
fractionalNumbers: 2
# How many numbers behind the dot should be shown when using a metric symbol suffix.
fractionalNumbersShort: 3
# Set this to true if you want to hide '.0' for a number like '15.0' ('4.50' will still stay '4.50').
hideEmptyFractionalPart: true
# Use a suffix if the price is above a certain number (use 1.00M instead of 1000000.00 etc.)
metricSymbols:
#1000: "k"
1000000: "M"
1000000000: "G"
1000000000000: "T"
1000000000000000: "P"
1000000000000000000: "E"
1000000000000000000000: "Z"
1000000000000000000000000: "Y"
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ RENTING: Options that apply to all rent regions. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Timeformat to use on the signs, default is like '30-06 14:52', US format: 'MM-dd KK:mm a'.
# Search for 'java SimpleDateFormat' for more options and documentation.
timeFormatSign: 'dd-MM HH:mm'
# Timeformat used in the chat, default is like '30 june 2014 14:52', US format: 'MMMMMMMMMMMMMMMMM dd yyyy KK:mm a'.
# Search for 'java SimpleDateFormat' for more options and documentation.
timeFormatChat: 'dd MMMMMMMMMMMMMMMMM yyyy HH:mm'
# Time indicators, used for specifing time periods (for example rent duration).
seconds: [s, sec, secs, second, seconds]
minutes: [m, min, mins, minute, minutes]
hours: [h, hour, hours]
days: [d, day, days]
weeks: [w, week, weeks]
months: [M, month, months]
years: [y, year, years]
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ PERMISSION GROUPS: Assigned by giving players certain permissions. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Configure the max total regions, max rent regions and max buy regions with different groups (-1 is unlimited).
# Assign a group to players by giving them the permission 'areashop.limits.<group>'.
# Every player already has the group 'default', OPs bypass the limits because of the 'areashop.limitbypass' permission.
# All the groups applied to the player will be checked and only if they all allow an extra region it will be allowed.
# More information like limits for regions of a certain group or in a certain word can be found here:
# https://github.com/NLthijs48/AreaShop/wiki/Limitgroups-information-and-examples.
limitGroups:
default:
total: 1
rents: 1
buys: 1
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ ADVANCED AND DEBUG: Specific options to tweak the plugin precisely and check if it functions correctly. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Blacklist of region names that cannot be added to AreaShop for renting or buying. Regular expressions can be used, search
# for 'java regex pattern' to find documentation about how to use it.
# Example: Blocking all regions that have a name like 'house_1', 'house_2', etc. would be done with 'house_\d+'.
# The '\d' represents the numerical digits 0-9, the + symbol represents 1 or more times repeated.
# This means it would also block 'house_123' and 'house_000456'. It will not block 'ahouse_1' or 'house_'.
blacklist:
- '__global__'
# Minimum length of the numbers that are suffixed for region names generated by the '/as stack' command.
# When having this at 3 it will generate names like this: 'region-001', 'region-014', 'region-4567'.
stackRegionNumberLength: 3
# Allow/disallow adding players that did not visit the server yet as friend of a region.
addFriendNotExistingPlayers: false
# Enable sending stats to http://mcstats.org/ (Metrics plugin).
# This information will give me an indication about how much the plugin is used and encourages me to continue development.
sendStats: true
# If enabled it will check for updates when loading the plugin, it will never download files, it will only notify about it.
checkForUpdates: true
# Use colors when sending messages to console and log files.
useColorsInConsole: false
# Use tellraw style messages, which can be interacted with by players
useFancyMessages: true
# Update all region flags and signs after starting the plugin.
# This ensures that changes to the config are directly visible after restarting the server.
updateRegionsOnStartup: true
# Enables / disables debug messages in the console, could be useful to figure out where errors come from.
debug: false
# Version of the config, do not change!
version: ${project.version}
# Maximum number of blocks to save to or restore from a .schemetic file.
maximumBlocks: 1000000
# Maximum number of locations the teleport function should check to find a safe spot.
maximumTries: 50000
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ VARIABLES: Variables that can be used in messages and settings where a region is available. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# If a tag has no value (for example %player% when the region is not rented/bought) then the tag will not get replaced.
# %region% The region name (with correct capitalization).
# %player% The name of the player that rents/buys the region (with correct capitalization).
# %uuid% The UUID of the player that rents/buys the region.
# %friends% The names of friends added to this region separated by ', '.
# %friendsuuid% The UUID's of friends added to this region separated by ', '.
# %landlord% The name of the landlord.
# %landlorduuid% The UUID of the landlord.
# %price% The price of the region formatted with the configured characters before and after the number.
# %rawprice% The price without formatting, like '10.0' or '7.77'.
# %duration% The duration of a rent region, for example '1 d', '4 minutes' or '2 years'.
# %world% The name of the world that the region is in.
# %type% The type of the region, 'rent' or 'buy'.
# %until% The end time of a rent formatted as configured with 'timeFormatChat'.
# %untilshort% The end time of a rent formatted as configured with 'timeFormatSign'.
# %width% The width of the region (number of blocks on the x-axis).
# %depth% The depth of the region (number of blocks on the z-axis).
# %volume% The number of blocks in a region (accounting for polygon shaped regions).
# %height% The height of the region (number of blocks on the y-axis).
# %timeleft% The time left on the rent (uses the unit of time that fits best, minutes used from 121 seconds till 120 minutes).
# %clicker% The name of the player that clicked the sign (only to be used in the signProfiles section).
# %resellprice% The price of a region when it is in resell mode.
# %rawresellprice% The resellprice without formatting.
# %moneyback% The amount of money the player will get back when unrenting/selling the region (formatted with currency layout).
# %rawmoneyback% The moneyback without formatting.
# %moneybackpercent% The percentage of the price the player will get back when unrenting the region.
# %timesExtended% The number of times the region has been extended (zero when first rented)
# %maxextends% The maximum number of extends a player can do on the region.
# %extendsleft% The number of extends that are left (maxextends - timesextended).
# %maxrenttime% The maximum time you can rent a region in advance (human readable).
# %inactivetime% The maximum time a player may be inactive before unrent/sell (human readable).
# %year% The current year.
# %month% The current month in the year.
# %day% The current day in the month.
# %hour% The current hour in the day (0-23).
# %minute% The current minute of the hour.
# %second% The current second of the minute.
# %millisecond% The current millisecond of the second.
# %epoch% The number of milliseconds since January 1, 1970 (Unix Epoch).
# %tpx% The exact x coordinate of the location that the teleport is set to
# %tpy% The exact y coordinate of the location that the teleport is set to
# %tpz% The exact z coordinate of the location that the teleport is set to
# %tpblockx% The rounded x coordinate of the location that the teleport is set to
# %tpblocky% The rounded y coordinate of the location that the teleport is set to
# %tpblockz% The rounded z coordinate of the location that the teleport is set to
# %tppitch% The exact pitch of the teleport location
# %tppitchround% The rounded pitch of the teleport location
# %tpyaw% The exact yaw of the teleport location
# %tpyawround% The rounded yaw of the teleport location
# %tpworld% The world name of the teleport location
# %lang:<languageKey>|Optional arguments|% Insert a message from EN.yml, for example: '%lang:timeleft-ended%' or '%lang:timeleft-years|15|%'
+249
View File
@@ -0,0 +1,249 @@
# ╔════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
# ║ default.yml file of the AreaShop plugin created by NLThijs48, Github can be found at https://github.com/NLthijs48/AreaShop.║
# ║ All settings below are default settings and can be overridden by group settings or individual region settings. ║
# ║ More information and tutorials can be found on the wiki: https://github.com/NLthijs48/AreaShop/wiki ║
# ╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ GENERAL: Settings that apply to all regions. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
general:
# The y location within the region to start searching for safe teleport locations (x and z are in the middle of the region).
# Possible values: 'bottom', 'middle', 'top' or a number indicating an exact y coordinate.
teleportLocationY: bottom
# If true the teleportation algorithm only allows teleportation to inside the region, otherwise it will expand
# a cube from the starting point to check for safe spots (then it could end outside of the region).
teleportIntoRegion: true
# Same as above, but then for when you teleport to the sign of a region instead of the region itself.
teleportToSignIntoRegion: false
# Allow teleporting to the region from another world with `/as tp`
teleportCrossWorld: true
# When teleporting to a sign, the number of blocks the player should get teleported away from the sign
teleportSignDistance: 1
# Should '/as find' find this region while the player is in another world? (prevents cross-world teleport if turned off)
findCrossWorld: true
# Set where the '/as find' command should teleport the player to, set to true for the first sign of the region and set to
# false to teleport to the location set by '/as settp' or the default location (if not set).
findTeleportToSign: true
# Restricts buying and renting of regions to the world of the region.
restrictedToWorld: false
# Restricts buying and renting of regions to the region itself (player needs to be inside the region).
restrictedToRegion: false
# The UUID of the landlord, this player will receive all money from rents/buys (but not reselling with '/as resell').
landlord: ''
# Name of the landlord, if the landlord UUID setting is not provided then the name will be used instead.
landlordName: ''
# Disable to prevent counting this region towards limits set by 'limitGroups' in config.yml.
countForLimits: true
##### Set the layout and functions of the signs.
# The following sections can be added for performing certain commands when the sign is clicked:
# rightClickPlayer, rightClickConsole, shiftRightClickPlayer, shiftRightClickConsole,
# leftClickPlayer, leftClickConsole, shiftLeftClickPlayer, shiftLeftClickConsole.
# Sections with 'Player' at the end will be run by the player that clicks the sign and 'Console' ones from the console.
signProfile:
forrent:
line1: '&2&l[For Rent]'
line2: '%region%'
line3: '%duration%'
line4: '%price%'
rightClickPlayer:
- 'areashop rent %region%'
rightClickConsole:
# - 'areashop message %clicker% %lang:confirm-rent|%region%|%' # Alternative to first ask for confirmation (remove rightClickPlayer section)
leftClickPlayer:
- 'areashop info region %region%'
rented:
line1: '&4&l[Rented]'
line2: '%region%'
line3: '%player%'
line4: '%untilshort%'
rightClickPlayer:
- 'areashop rent %region%'
rightClickConsole:
# - 'areashop message %clicker% %lang:confirm-extend|%region%|%' # Alternative to first ask for confirmation (remove rightClickPlayer section)
leftClickPlayer:
- 'areashop info region %region%'
shiftRightClickConsole:
- 'areashop message %clicker% %lang:confirm-unrent|%region%|%'
forsale:
line1: '&2&l[For Sale]'
line2: '%region%'
line3: '%price%'
line4:
rightClickPlayer:
- 'areashop buy %region%'
rightClickConsole:
# - 'areashop message %clicker% %lang:confirm-buy|%region%|%' # Alternative to first ask for confirmation (remove rightClickPlayer section)
leftClickPlayer:
- 'areashop info region %region%'
resell:
line1: '&9&l[Resale]'
line2: '%region%'
line3: '%resellprice%'
line4: '&8%player%'
rightClickPlayer:
- 'areashop buy %region%'
rightClickConsole:
# - 'areashop message %clicker% %lang:confirm-buy|%region%|%' # Alternative to first ask for confirmation (remove rightClickPlayer section)
leftClickPlayer:
- 'areashop info region %region%'
shiftRightClickPlayer:
- 'areashop stopresell %region%'
sold:
line1: '&4&l[Sold]'
line2: '%region%'
line3: '%player%'
line4:
rightClickPlayer:
- 'areashop buy %region%'
leftClickPlayer:
- 'areashop info region %region%'
shiftRightClickConsole:
- 'areashop message %clicker% %lang:confirm-sell|%region%|%'
##### Set WorldGuard regions flags depending on the region state.
# All normal region flags as present in WorldGuard can be used, in addition to 'members', 'owners', 'priority' and 'parent'.
# The members and owners flag normally take a list of UUID's separated by a comma, adding by name is possible with 'n:<name>'.
# You can add groups by using 'g:<groupname>', so an example woul be: '%uuid%, %friendsuuid%, g:vip, n:coolGuy'.
# For allow/deny flags like 'entry' and 'exit' you can set the group setting by using 'g:<scope>', <scope> is one of the following:
# members, non_members, owners, non_owners, all. Example, only members can enter the region:
# entry: 'deny g:non_members'
# '' will remove the flag from the region.
flagProfile:
ALL: # Flags that should always be applied
priority: 10
owners: ''
members: ''
interact: 'deny g:non_members' # Only allow region members/owners to use things in the region (chests, furnace, animals, etc.)
use: 'deny g:non_members'
build: 'deny g:non_members'
block-break: 'deny g:non_members'
block-place: 'deny g:non_members'
forrent:
greeting: '%lang:prefix%%lang:greeting-forrent%'
rented:
members: '%uuid%, %friendsuuid%'
greeting: '%lang:prefix%%lang:greeting-rented%'
forsale:
greeting: '%lang:prefix%%lang:greeting-forsale%'
sold:
members: '%uuid%, %friendsuuid%'
greeting: '%lang:prefix%%lang:greeting-bought%'
resell:
members: '%uuid%, %friendsuuid%'
greeting: '%lang:prefix%%lang:greeting-resale%'
##### Save and restore schematics to clean up regions.
# After 'save:' or 'restore:' you enter the name of the file to restore from/to (.schematic is added automatically).
# Set to true to enable saving/restoring for regions as specified in the profile below, which is specified in the config.
enableRestore: false
schematicProfile:
created:
save: '%type%-%region%'
restore: ''
deleted:
save: ''
restore: '%type%-%region%'
rented:
save: '%type%-%region%'
restore: ''
unrented:
save: ''
restore: '%type%-%region%'
bought:
save: '%type%-%region%'
restore: ''
sold:
save: ''
restore: '%type%-%region%'
resell:
save: ''
restore: ''
##### Run commands when an event happens.
# Commands at a 'before' section will execute before the region details are changed in the AreaShop system
# and before any other actions occurred (setting the owner, saving/loading schematics, etc.),
# the 'after' commands will be run when all changes are done.
# You can add a list of commands to 'before' and 'after'.
eventCommandProfile:
created:
before:
after:
# - "say An AreaShop region has been created: %region%"
deleted:
before:
after:
rented:
before:
after:
extended:
before:
after:
unrented:
before:
after:
bought:
before:
after:
sold:
before:
after:
resell:
before:
after:
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ RENT: Settings that apply to rent regions. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
rent:
# The default price of a rental region (variables, mathematical expressions and JavaScript can be used).
price: 1000
# The default duration of a rental region, you can find all time indicators in config.yml below the RENTING header.
duration: '1 day'
# Automatically extend the rental when it is running out (if the player meets the criteria)
autoExtend: false
# The percentage of the rent price you get back if you unrent the region (only the time that is unused is given back).
# (variables, mathematical expressions and JavaScript can be used)
moneyBack: 100
# Maximum number of extends a player can do (-1 for infinite, 0 for no extending), if they are at this number then
# they are force to let their rent run out (and can rent it again at that point).
maxExtends: -1
# The Maximum time they can have the region rented in advance (use times like '1 day' etc, or 'unlimited' for no limit).
# This can prevent players from renting their region for a year, and to ensure they periodically have to extend their rent.
maxRentTime: 'unlimited'
# Automatically unrent the region after the specified time between the last login time of the renter and the current time.
# Use times like '1 day' etc, or 'disabled' for never.
inactiveTimeUntilUnrent: 'disabled'
# If a region of a player has less then this time left when he joins the server he will get a notice about his region.
# Use '' to disable.
warningOnLoginTime: '1 day'
# If renting the region would go above 'maxRentTIme', then extend to the maximum instead of cancelling the rent.
extendToFullWhenAboveMaxRentTime: true
##### Run commands a certain time before expiration of a region.
# Time identifiers specify how much time before the rent is over the commands should be executed.
# These commands are executed in a 'best effort' manner, if your server is offline when it should trigger then it won't run.
expirationWarningProfile:
'1 day':
- "areashop message %player% %lang:prefix%%lang:rent-expiringSoon|%region%|%timeleft%|%"
'1 hour':
- "areashop message %player% %lang:prefix%%lang:rent-expiringSoon|%region%|%timeleft%|%"
'5 minutes':
- "areashop message %player% %lang:prefix%%lang:rent-expiringSoon|%region%|%timeleft%|%"
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ BUY: Settings that apply to buy regions. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
buy:
# The default price of a buy region (variables, mathematical expressions and JavaScript can be used).
price: 1000
# The percentage of the price you get back if you sell the region (variables, mathematical expressions and JavaScript can be used)
moneyBack: 100
# Automatically sell the region after the specified number of minutes between the last login time of the buyer and the current time
# Use times like '1 day' etc, or 'disabled' for never.
inactiveTimeUntilSell: 'disabled'
# Selling is disabled for the region owner (players with areashop.sellown without areashop.sell)
sellDisabled: false
# Reselling is disabled for the region owner (players with areashop.resell without areashop.resellall)
resellDisabled: false
@@ -0,0 +1,58 @@
# ╔════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
# ║ hiddenConfig.yml file of the AreaShop plugin created by NLThijs48. ║
# ║ Options in this file are available in config.yml, but are not shown by default there. ║
# ║ The options in these file are either very advanced, or not useful for the majority of users. ║
# ╚════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ TIMERS: Settings to define how often scheduled tasks run. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Setting the 'delay' setting to 0 or lower will prevent the taks from runnning.
# The 'delay' settings are specified using a number followed by one of the identifiers as defined in config.yml.
# The 'regionsPerTick' settings are to configure how fast something goes, lower value is less lag, but slower updates.
# There are 20 ticks in 1 second, so if you set 'regionPerTick' to 5, then 5*20=100 regions per second will be updated.
# Timings for saving files that need saving.
saving:
delay: '11 minutes'
regionsPerTick: 1
# Timings for rent expiration checking.
expiration:
delay: '14 seconds'
regionsPerTick: 5
# Timings for expiration warning to online players.
expireWarning:
delay: '11 seconds'
regionsPerTick: 5
# Timings for updating signs and region flags ('/as reload' or after '/as groupadd' or '/as groupdel').
update:
regionsPerTick: 10
# Time between checking if any regions need to be unrented because the player was not online for the specified time period.
inactive:
delay: '17 minutes'
regionsPerTick: 5
# Timings for the periodic updating of signs (for timeleft tags etc).
signs:
delay: '1 minute'
regionsPerTick: 3
# Number of regions per tick to check when a player joins to see if his name changed for regions he owned (updates the regions when changed).
nameupdate:
regionsPerTick: 10
# Timings for adding regions to AreaShop ('/as stack').
adding:
regionsPerTick: 2
# ┌────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐
# │ OTHER: All other settings. │
# └────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘
# Allow or disallow extending a rental region when the player is above his limits enforced by the 'limitGroups' section below.
# false will ensure a player will eventually lose his region when he has no access anymore.
allowRegionExtendsWhenAboveLimits: false
# Flag profiles that can be used by the 'general.flagProfile' setting in default.yml
flagProfiles:
# Event command profiles that can be used by the 'general.eventCommandProfile' setting in default.yml
eventCommandProfiles:
# Sign profiles that can be used by the 'general.signProfile' setting in default.yml
signProfiles:
# Schematic profiles that can be used by the 'general.schematicProfile' setting in default.yml
schematicProfiles:
+521
View File
@@ -0,0 +1,521 @@
# ╔═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
# ║ Language file of the AreaShop plugin created by NLThijs48, Github can be found at https://github.com/NLthijs48/AreaShop
# ║ German language file, plugin version 2.5.0, 396/428 messages are translated (93%)
# ║
# ║ This file will be overwritten at each startup/reload of the plugin, if you want to change anything then do the following:
# ║ 1: Make a copy of this file
# ║ 2: Rename it to `servername.yml`
# ║ 3: Change the `language` setting in config.yml to `servername`, do not include `.yml`
# ║ 4: Change the messages in the new file to your liking
# ║ 5: Use `/as reload`or reload/restart your server to see the changes
# ╚═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
"action": "[gold][bold]<%0%>[/bold]"
"button": "[bold]<%0%>[/bold]"
"command":
- "[bold]%0%[/bold]"
- " hover: %lang:action|Benutze %1%|%"
- " command: %1%"
"helpCommand":
- "[gold]%0% [gray]-[reset]"
- " hover: %lang:action|Benutze %0%|%"
- " command: %0%"
"region": "%lang:tRegion|%region%|%"
"tRegion":
- "[bold]%0%[/bold]"
- " hover: Region %0%"
- " hover: %lang:action|Region information|%"
- " command: /areashop info region %0%"
"player": "%lang:tPlayer|%player%|%"
"tPlayer":
- "[bold]%0%[/bold]"
- " hover: Spieler %0%"
- " hover: %lang:action|Regionen von %0%|%"
- " command: /areashop info player %0%"
"landlord":
- "[bold]%landlord%[/bold]"
- " hover: Vermieter %landlord%"
- " hover: %lang:action|Regionen von %landlord%|%"
- " command: /areashop info player %landlord%"
"total-maximum": "Du kannst nicht mehr als %0% Region(en) mieten/kaufen (Du hast bereits %1% in Gruppe '%2%')."
"confirm-yes": " [gray]Klicken um %lang:command|den Command zu bestätigen|1%0%|%[gray] oder zu wiederholen."
"general-notReady": "AreaShop ist noch nicht vollständig geladen, bitte warten."
"general-noWorld": "Du kannst das nicht machen, die Welt von %lang:region% ist derzeit nicht verfügbar (Welt '%world%')."
"general-noRegion": "Du kannst das nicht machen, die WorldGuard Region ist derzeit nicht verfügbar (region %lang:region%)."
"general-noEconomy": "AreaShop kann kein (korrekt) installiertes Economy-Plugin finden, bitte informiere den Serverinhaber darüber."
"general-cancelled": "%0%"
"cmd-notValid": "Der Befehl ist ungültig, nutze '/as help' für weitere Informationen."
"cmd-onlyByPlayer": "Dieser Befehl kann nur von einem Spieler benutzt werden."
"cmd-weOnlyByPlayer": "Eine WorldEdit-Selektion kann nur von einem Spieler gewählt werden, gib die Region als extra Argument an."
"cmd-noSelection": "Du hast mit WorldEdit nichts markiert."
"cmd-noRegionsFound": "In deiner Selektion wurden keine in AreaShop registrierten Regionen gefunden."
"cmd-noWERegionsFound": "Es wurden keine WorldEdit-Regionen gefunden, die sich mit deiner Selektion überschneiden."
"cmd-notRegistered": "Die Region '%0%' ist in AreaShop nicht verfügbar."
"cmd-noRegion": "'%0%' ist keine gültige WorldGuard Region."
"cmd-noRegionsAtLocation": "Keine Regionen an deiner Position gefunden, gib die Region als Argument an."
"cmd-moreRegionsAtLocation": "Mehr als eine Region wurde an deiner Position gefunden, gib die Region als Argument an."
"cmd-automaticRegionOnlyByPlayer": "Die Automatische Auswahl einer Region ist nur für Spieler möglich, gib die Region als Argument an."
"help-header": "Hilfeseite mit Befehlen, die du ausführen kannst."
"help-noPermission": "Du hast keine Permissions, um diese Hilfeseite anzuzeigen."
"help-alias": "Befehlsaliase: /areashop, /as."
"help-help": "%lang:helpCommand|/as help|% Zeigt diese Hilfeseite."
"help-info": "%lang:helpCommand|/as info|% Zeigt Infos über aktuelle Regionen."
"help-rent": "%lang:helpCommand|/as rent|% Miete eine Region oder verlängere deine derzeitige Miete."
"help-buy": "%lang:helpCommand|/as buy|% Kaufe eine Region."
"help-unrent": "%lang:helpCommand|/as unrent|% Breche eine Miete für eine Region ab."
"help-sell": "%lang:helpCommand|/as sell|% Verkaufe eine Region."
"help-reload": "%lang:helpCommand|/as reload|% Lade alle Dateien sowie Regionen neu."
"help-setrestore": "%lang:helpCommand|/as setrestore|% Aktiviere das Zurücksetzen und wähle ein Profil."
"help-setprice": "%lang:helpCommand|/as setprice|% Ändere den Preis einer Region."
"help-setduration": "%lang:helpCommand|/as setduration|% Ändere die Dauer einer gemieteten Region."
"help-teleport": "%lang:helpCommand|/as tp|% Teleportiere dich zu einer kauf- oder mietbaren Region."
"help-setteleport": "%lang:helpCommand|/as settp|% Setze die Teleport Position von einer Region."
"help-find": "%lang:helpCommand|/as find|% Finde eine kauf- oder mietbare Region."
"help-groupadd": "%lang:helpCommand|/as groupadd|% Füge eine Region zu einer Gruppe hinzu."
"help-groupdel": "%lang:helpCommand|/as groupdel|% Lösche eine Region von einer Gruppe."
"help-grouplist": "%lang:helpCommand|/as grouplist|% Liste alle Gruppen auf, welche derzeit Registriert sind."
"help-groupinfo": "%lang:helpCommand|/as groupinfo|% Zeigt Informationen über eine Gruppe an."
"help-schemevent": "%lang:helpCommand|/as schemevent|% Löst ein Schematic Event für eine Region aus."
"help-add": "%lang:helpCommand|/as add|% Registriere eine Region zum mieten oder kaufen."
"help-del": "%lang:helpCommand|/as del|% Lösche eine registrierte Region von AreaShop"
"help-addsign": "%lang:helpCommand|/as addsign|% Füge ein Schild zu einer existierenden Region hinzu."
"help-delsign": "%lang:helpCommand|/as delsign|% Lösche das Schild auf das du Schaust."
"help-me": "%lang:helpCommand|/as me|% Liste alle Regionen, welche zu besitzt auf, sowie deren Ablaufdatum."
"help-setowner": "%lang:helpCommand|/as setowner|% Setze den Besitzer einer Region oder verlängere die Miete."
"help-resell": "%lang:helpCommand|/as resell|% Setzt eine Region in den Wiederverkaufs-Modus."
"help-stopResell": "%lang:helpCommand|/as stopresell|% Setzt eine Region zurück in den Verkauft Modus."
"help-addFriend": "%lang:helpCommand|/as addfriend|% Fügt einen Freund zu einer Region hinzu."
"help-delFriend": "%lang:helpCommand|/as delfriend|% Löscht einen Freund von einer Region."
"help-linksigns": "%lang:helpCommand|/as linksigns|% Benutze Massenschild Verlinkungs Modus."
"help-stack": "%lang:helpCommand|/as stack|% Erstelle mehrere Regionen und füge sie hinzu."
"help-setlandlord": "%lang:helpCommand|/as setlandlord|% Setzt den Vermieter einer Region."
"rent-help": "/as rent [Region], Die Region in der du stehst wird Gemietet, wenn du keine Region angegeben hast."
"rent-noPermission": "Du bist nicht berechtigt, diese Region zu mieten."
"rent-maximum": "Du kannst nicht mehr als %0% Region(en) mieten (Du hast bereits %1% in Gruppe '%2%')."
"rent-maximumExtend": "Du kannst diese Miete nicht verlängern weil du mehr als %0% Region(en) hast. (Du hast bereits %1% in Gruppe '%2%')."
"rent-payError": "Die Bezahlung hat nicht funktioniert. Bitte versuche es später noch einmal."
"rent-rented": "Du hast die Region %lang:region% bis zum %until% gemietet. Du kannst deine Miete verlängern, in dem du erneut auf das Schild klickst, oder /as rent eingibst."
"rent-extended": "Du hast Deine Miete von %lang:region% bis zum %until% verlängert."
"rent-extendedToMax": "Du hast Deine Miete von %lang:region% bis zum %until% verlängert. (Das ist die maximal zulässige Mietdauer von %maxrenttime%)."
"rent-lowMoneyExtend": "Du hast nicht genug Geld um die Miete zu verlängern. (Du hast %0% und benötigst %price%)."
"rent-lowMoneyRent": "Du hast nicht genug Geld um die Region %lang:region% zu mieten. (Du hast %0% und benötigst %price%)."
"rent-someoneElse": "Die Region %lang:region% ist bereits vermietet."
"rent-notRentable": "Region '%0%' ist nicht vorhanden (Nicht registiert in Areashop oder nur zu verkaufen)."
"rent-maxExtends": "Du kannst diese Miete nicht weiter verlängern. (Zulässig sind %maxextends% Verlängerungen). Nachdem die Miete abgelaufen ist, kannst du die Region %lang:region% erneut mieten."
"rent-maxRentTime": "Du kannst die Region%lang:region% nicht noch mehr im Voraus mieten. Die maximale Zeit beträgt %maxrenttime% und du hast diese Region für %timeleft% gemietet."
"rent-restrictedToWorld": "Du musst dich in der Welt '%world%' befinden, um die Region %lang:region% mieten zu können (Du befindest Dich in der Welt '%0%')."
"rent-restrictedToRegion": "Du musst innerhalb der Region %lang:region% sein, um diese mieten zu können."
"rent-expireWarning": "Deine Region %lang:region% hat %timeleft% übrig. Beachte, dass du sie rechtzeitig verlängerst, wenn du sie behalten willst."
"rent-expiringSoon": "Deine Region %lang:tRegion|%0%|% hat noch %1% übrig. Verlängere sie, wenn du sie behalten möchtest."
"rent-alreadyAtFull": "Die Region %lang:region% ist bereits auf oder über der maximalen Mietzeit, Du kannst diese noch nicht verlängern."
"buy-help": "/as buy [Regionname], Die Region in der du stehst wird gekauft wenn keine Region angegeben wurde."
"buy-noPermission": "Du bist nicht berechtigt, eine Region zu kaufen."
"buy-noPermissionResell": "Du hast keine Berechtigung eine Region im Weiterverkaufs-Modus zu kaufen."
"buy-noPermissionNoResell": "Du hast keine Berechtigung um eine Region zu kaufen, die nicht im Weiterverkaufs-Modus ist."
"buy-notBuyable": "Region '1%0%' ist nicht zum Kauf verfügbar (nicht registriert in AreaShop oder es ist eine mietbare Region)"
"buy-maximum": "Du kannst nicht mehr als %0% Region(en) erwerben (Du hast bereits %1% in Gruppe '%2%')."
"buy-payError": "Die Bezahlung hat nicht funktioniert. Bitte versuche es später noch einmal."
"buy-succes": "Du hast %lang:region% erfolgreich gekauft."
"buy-successResale": "Du hast %lang:region% erfolgreich von %lang:tPlayer|%0%|% gekauft."
"buy-successSeller": "Deine Region %lang:region% wurde an %lang:player% für %0% verkauft."
"buy-lowMoney": "Du hast nicht genug Geld um die Region %lang:region% zu kaufen. (Du hast %0% und benötigst %price%)."
"buy-lowMoneyResell": "Du hast nicht genug Geld um die Region %lang:region% zu kaufen. (Du hast %0% und benötigst %resellprice%)."
"buy-yours": "Du besitzt die Region %lang:region% bereits."
"buy-someoneElse": "Jemand anderes hat die Region %lang:region% bereits gekauft."
"buy-restrictedToWorld": "Du musst Dich in der Welt '%world%' befinden, um die Region %lang:region% kaufen zu können. (Du befindest Dich in der Welt '%0%')."
"buy-restrictedToRegion": "Du musst innerhalb der Region %lang:region% sein, um diese kaufen zu können."
"unrent-help": "/as unrent [Region], Die Region in der du stehst wird entmietet, wenn keine Region angegeben wird."
"unrent-noPermission": "Du bist nicht berechtigt, den Mietvertrag zu kündigen."
"unrent-noPermissionOther": "Du bist nicht berechtigt, den Mietvertrag einer anderen Region zu kündigen."
"unrent-notRegistered": "Die Region kann nicht entmietet werden, weil sie nicht für Vermietungen registriert ist."
"unrent-notRented": "Die Region kann nicht entmietet werden, weil sie nicht gemietet ist."
"unrent-unrented": "Die Region %lang:region% ist nun nicht mehr an %lang:player% vermietet."
"unrent-expired": "Deine Miete von %lang:region% ist abgelaufen."
"sell-help": "/as sell [Region], Die Region in der du stehst wird verkauft wenn keine Region angegeben wurde."
"sell-notRegistered": "Die Region kann nicht verkauft werden, da sie nicht für den Verkauf registriert ist."
"sell-notBought": "Die Region kann nicht verkauft werden, da sie keinen Eigentümer hat."
"sell-sold": "Die Region %lang:region% von %lang:player% wurde verkauft."
"sell-noPermission": "Du bist nicht berechtigt, diese Region zu verkaufen."
"sell-noPermissionOther": "Du bist nicht berechtigt, eine Region zu verkaufen."
"sell-disabled": "Das verkaufen dieser Region wurde deaktiviert."
"reload-reloading": "Alle Konfigurationsdateien und Region-Dateien wurden neu geladen."
"reload-noPermission": "Du hast keine Berechtigungen um die Konfigurationsdateien neu zu laden."
"reload-updateCommandChanged": "'/as updaterents' und '/as updatebuys' wurden entfernt, bitte benutze '/as reload' um die Regionen neu zu laden."
"info-help":
- "/as info[break]"
- " %lang:command|all|/as info all|%[break]"
- " %lang:command|rented|/as info rented|% [Gruppe] [Seite][break]"
- " %lang:command|forrent|/as info forrent|% [Gruppe] [Seite][break]"
- " %lang:command|sold|/as info sold|% [Gruppe] [Seite][break]"
- " %lang:command|forsale|/as info forsale|% [Gruppe] [Seite][break]"
- " %lang:command|reselling|/as info reselling|% [Gruppe] [Seite][break]"
- " %lang:command|nogroup|/as info nogroup [Seite]|%[break]"
- " %lang:command|region|/as info region|% [Region]"
"info-noPermission": "Du hast keine Berechtigung, Informationen über Regionen zu erhalten."
"info-allHeader": "Alle Regionen%0%:"
"info-rentedHeader": "Gemietete Regionen%0%:"
"info-forrentHeader": "Mietbare Regionen%0%:"
"info-forsaleHeader": "Kaufbare Regionen%0%:"
"info-soldHeader": "Verkaufte Regionen%0%:"
"info-resellingHeader": "Weiterverkaufbare Regionen%0%:"
"info-nogroupHeader": "Regionen ohne Gruppe%0%:"
"info-limitedToGroup": " (begrenzt auf Gruppe %0%)"
"info-nogroupNone": "Es gibt keine Regionen ohne Gruppe."
"info-noFiltergroup": "Gruppe '%0%' existiert nicht und kann deshalb nicht genutzt werden um die Ergebnisse zu limitieren."
"info-noRegions": "Es wurden keine Regionen gefunden."
"info-wrongPage": "%0% ist keine korrekte Seitenzahl."
"info-entryForrent": "[darkgreen][bold]►[reset] %lang:region%: [gray]Zur Vermietung für %price% je %duration%."
"info-entryRented": "[darkgreen][bold]►[reset] %lang:region%: [gray]Vermietet an %lang:player%."
"info-entryForsale": "[darkgreen][bold]►[reset] %lang:region%: [gray]Zum Verkauf für %price%."
"info-entrySold": "[darkgreen][bold]►[reset] %lang:region%: [gray]Verkauft an %lang:player%."
"info-entryReselling": "[darkgreen][bold]►[reset] %lang:region%: [gray]Verkauft an %lang:player% (Weiterverkauf)."
"info-pageStatus": "[gold]Seite %0%/%1%"
"info-pageNoPrevious":
- " [darkgray][bold]◄Vorherige[/bold] "
- " hover: Das ist bereits die erste Seite."
"info-pageNoNext":
- " [darkgray][bold]Nächste►[/bold]"
- " hover: Das ist bereits die letzte Seite."
"info-playerHelp": "/as info player <Spielername>."
"info-playerRents": "Gemietete Regionen von %lang:tPlayer|%0%|%: [gray]%1%"
"info-playerNoRents": "%lang:tPlayer|%0%|% hat bisher keine Region(en) gemietet."
"info-playerBuys": "Gekaufte Regionen von %lang:tPlayer|%0%|%: [gray]%1%."
"info-playerNoBuys": "%lang:tPlayer|%0%|% hat bisher keine Region(en) gekauft."
"info-regionHelp": "/as info region [Region], Wenn kein Regionsname angegeben wird, wird die Region genutzt, in der du dich gerade befindest."
"info-regionHeaderRent": "[darkgreen]Informationen über %lang:region%:"
"info-regionHeaderBuy": "[darkgreen]Informationen über %lang:region%:"
"info-regionRented": "[darkgreen][bold]►[reset] Gemietet von %lang:player% bis: [gray]%until%."
"info-regionBought": "[darkgreen][bold]►[reset] Gekauft von %lang:player%."
"info-regionReselling": "[darkgreen][bold]►[reset] Gekauft von %lang:player%, derzeit Weiterverkauf."
"info-regionExtending":
- "[darkgreen][bold]►[reset] "
- "[bold]Verlängern für[/bold]"
- " hover: Miete verlängern für %region%"
- " hover: mit %duration% für %price%"
- " hover: %lang:action|Mieter Verlängern für %region%|%"
- " command: /areashop rent %region%"
- ": [gray]%price% für %duration%."
"info-regionCanBeRented":
- "[darkgreen][bold]►[reset] "
- "[bold]Mieten für[/bold]"
- " hover: Miete %region% für %price% für %duration%"
- " hover: %lang:action|Miete %region%|%"
- " command: /areashop rent %region%"
- ": [gray]%price% für %duration%."
"info-regionCanBeBought":
- "[darkgreen][bold]►[reset] "
- "[bold]Kaufen für[/bold]"
- " hover: Kaufe %region% für %price%"
- " hover: %lang:action|Kaufe %region%|%"
- " command: /areashop buy %region%"
- ": [gray]%price%."
"info-regionReselPrice": "[darkgreen][bold]►[reset] Weiterverkaufspreis: [gray]%resellprice% (Du kannst es von %lang:player% kaufen)."
"info-regionFriends": "[darkgreen][bold]►[reset] Hinzugefügte Freunde: [gray]%0%."
"info-friend": "%lang:tPlayer|%0%|%"
"info-friendRemove":
- "%lang:info-friend|%0%|%"
- "[red]✕[gray]"
- " hover: Region %region%"
- " hover: %lang:action|Lösche %0% als Freund|%"
- " command: /areashop delfriend %0% %region%"
"info-regionMoneyBackBuy": "[darkgreen][bold]►[reset] Verkaufpreis: [gray]%moneyback% (%moneybackpercent%% des Kaufpreises)."
"info-regionMoneyBackBuyClick":
- "[darkgreen][bold]►[reset] "
- "[bold]Verkaufsrückzahlung[/bold]"
- " hover: Verkaufe %region% und bekomme %moneyback% zurück"
- " hover: %lang:action|Verkaufe %region%|%"
- " command: /areashop sell %region%"
- ": [gray]%moneyback% (%moneybackpercent%% des Kaufpreises)."
"info-regionMoneyBackRent": "[darkgreen][bold]►[reset] Rückzahlung bei Mietkündigung: [gray]%moneyback% (%moneybackpercent%% der verbleibenden Zeit)."
"info-regionMoneyBackRentClick":
- "[darkgreen][bold]►[reset] "
- "[bold]Mietrückzahlung[/bold]"
- " hover: Entmiete %region% und bekomme %moneyback% zurück"
- " hover: %lang:action|Unrent %region%|%"
- " command: /areashop unrent %region%"
- ": [gray]%moneyback% (%moneybackpercent%% der verbleibenden Zeit)."
"info-regionMaxExtends": "[darkgreen][bold]►[reset] Maximale Anzahl an Verlängerungen: [gray]%maxextends% ."
"info-regionNoExtending": "[darkgreen][bold]►[reset] Miete kann nicht verlängert werden."
"info-regionExtendsLeft": "[darkgreen][bold]►[reset] Verbleibende Mietverlängerungen: [gray]%extendsleft% von %maxextends% ."
"info-regionMaxRentTime": "[darkgreen][bold]►[reset] Miete im Voraus: [gray]Maximal %maxrenttime%."
"info-prefix": "[darkgreen][bold]►[reset] "
"info-regionTeleport":
- "[bold]Gehe zu der Region[/bold]"
- " hover: %lang:action|Teleport to %region%|%"
- " command: /areashop tp %region%"
"info-setRegionTeleport":
- "[bold]Setze den Teleport Punkt[/bold]"
- " hover: %region%"
- " hover: %lang:action|Set teleport location|%"
- " command: /areashop settp %region%"
"info-regionSigns": "[darkgreen][bold]►[reset] Verbundene Schilder: [gray]%0%."
"info-regionSignLocation": "[gray](%0%, %1%, %2%, %3%)[reset]"
"info-regionGroups": "[darkgreen][bold]►[reset] Zugewiesene Gruppen: [gray]%0%."
"info-regionInactiveUnrent": "[darkgreen][bold]►[reset] Automatische Mietkündigung nach: [gray]%inactivetime% Inaktivität des Spielers."
"info-regionInactiveSell": "[darkgreen][bold]►[reset] Automatischer Verkauf nach: [gray]%inactivetime% Inaktivität des Spielers."
"info-regionRestrictedRegionRent": "[darkgreen][bold]►[reset] Du musst dich in der Region %lang:region% befinden, um sie mieten zu können."
"info-regionRestrictedWorldRent": "[darkgreen][bold]►[reset] Du musst in der Welt '%world%' sein, um die Region %lang:region% mieten zu können."
"info-regionRestrictedRegionBuy": "[darkgreen][bold]►[reset] Du musst dich in der Region %lang:region% befinden, um sie kaufen zu können."
"info-regionRestrictedWorldBuy": "[darkgreen][bold]►[reset] Du musst in der Welt '%world%' sein, um die Region %lang:region% kaufen zu können."
"info-regionRestoringRent": "[darkgreen][bold]►[reset] Wiederherstellung ist aktiviert [gray](Region wird bei Mietkündigung zurückgesetzt)."
"info-regionRestoringBuy": "[darkgreen][bold]►[reset] Wiederherstellung ist aktiviert. [gray](Region wird beim Verkauf zurückgesetzt)."
"info-regionLandlord": "[darkgreen][bold]►[reset] Vermieter: [gray]%lang:landlord% (Erhält das Geld)."
"info-regionNotExisting": "Die angegebene Region ist nicht registriert: %0%."
"setrestore-help": "/as setrestore <Region> <true|false|general> [Profil]."
"setrestore-noPermission": "Du bist nicht berechtigt, die Wiederherstellungs-Einstellungen zu verändern."
"setrestore-notRegistered": "Die angegebene Region ist nicht registriert: %0%."
"setrestore-invalidSetting": "'%0%' ist keine gültige Angabe, benutze true, false oder general."
"setrestore-success": "Wiederherstellungs-Einstellungen von %lang:region% erfolgreich zu '%0%' geändert."
"setrestore-successProfile": "Wiederherstellungs-Einstellungen von %lang:region% erfolgreich zu '%0%' geändert und das Profil zu '%1%'."
"setprice-noPermission": "Du bist nicht berechtigt, den Preis einer Region zu ändern."
"setprice-help": "/as setprice <Preis> [Region], Andert den Preis der Region in der du stehst wenn keine Region angegeben wird."
"setprice-notRegistered": "Die angegebene Region ist nicht registriert: %0%."
"setprice-wrongPrice": "'%0%' ist kein gültiger Preis."
"setprice-successRent": "Der Preis der Region %lang:region% änderte sich zu %price% per %duration%."
"setprice-successBuy": "Der Preis der Region %lang:region% wurde zu %price% geändert."
"setprice-successRemoved": "Der Preis der Region %lang:region% wurde entfernt, ab jetzt wird der Preis einer Gruppe oder der default.yml-Datei benutzt. Neuer Preis: %price%."
"setprice-noLandlord": "Du hast keine Rechte um den Preis zu ändern, da du nicht der Vermieter der Region %lang:region% bist."
"setduration-noPermission": "Du hast keine Berechtigung, die Mietdauer zu verändern."
"setduration-help": "/as setduration <Anzahl> <Zeiteinheit> [Region], ändert die Zeit der Region in der du dich befindest wenn keine Region angegeben wurde."
"setduration-notRegistered": "%0% ist nicht als mietbar registriert."
"setduration-wrongAmount": "'%0%' ist keine gültige Anzahl, gib eine ganze Zahl an."
"setduration-wrongFormat": "'%0%' ist kein gültiges Zeitformat, schau in der Doku auf Bukkit nach."
"setduration-success": "Dauer von Region %lang:region% zu '%duration%' geändert."
"setduration-noLandlord": "Du hast keine Rechte um die Dauer der Miete zu ändern, da du nicht der Vermieter der Region %lang:region% bist."
"setduration-successRemoved": "Die Mietdauer der Region %lang:region% wurde entfernt, es wird nun die Dauer von einer Gruppe oder der default.yml Datei benutzt. Neue Mietdauer: %duration%."
"setup-noRegion": "Du hast in der zweiten Zeile keine Region angegeben."
"setup-alreadyRentSign": "Die angegebene Region ist bereits in AreaShop als eine Miet-Region eingefügt, du kannst Schilder zu der Region mit [as] in der ersten Zeile hinzufügen, oder '/as addsign' verwenden."
"setup-alreadyOtherWorld": "Die Region, die angegeben wurde, wurde bereits in einer anderen Welt hinzugefügt, Regionen aus verschiedenen Welten benötigen dennoch andere Namen."
"setup-alreadyBuySign": "Die angegebene Region ist bereits in AreaShop als eine Kauf-Region eingefügt, du kannst Schilder zu der Region mit [as] in der ersten Zeile hinzufügen, oder '/as addsign' verwenden."
"setup-noDuration": "Du hast nicht angegeben, wie lange eine Region mietbar ist. Bitte trage dies in die dritte Zeile ein."
"setup-wrongDuration": "Die angegebene Zeit liegt nicht in einem korrekten Format vor. Beispiel: 1 Tag."
"setup-noPrice": "Du hast in der vierten Zeile noch keinen Preis angegeben."
"setup-wrongPrice": "Du hast den Preis nicht korrekt angegeben, bitte nutze dafür ausschließlich Zahlen."
"setup-rentSuccess": "Die Vermietung der Region %lang:region% ist erfolgreich erstellt worden."
"setup-buySuccess": "Das Kaufen der Region %lang:region% ist erfolgreich erstellt worden."
"setup-noPermissionRent": "Du hast keine Berechtigungen um mietbare Regionen zu erstellen."
"setup-noPermissionBuy": "Du hast keine Berechtigungen um kaufbare Regionen zu erstellen."
"setup-couldNotDetect": "Mehrere Regionen mit der selben Priorität und/oder Eltern/Kind-Verhältnis gefunden, bitte gib die gewünschte Region in der zweiten Zeile an (zwei der gefundenen Regionen: %lang:tRegion|%0%|% und %lang:tRegion|%1%|%)."
"setup-blacklisted": "%0% ist auf der Blacklist und kann nicht in AreaShop eingefügt werden."
"setup-noPermission": "Du kannst die Region '%0%' nicht hinzufügen, da du weder Besitzer noch Mitglied der Region bist oder keine Rechte dazu hast."
"destroy-noPermissionRent": "Du hast keine Berechtigungen um eine mietbare Region abzumelden. "
"destroy-noPermissionBuy": "Du hast keine Berechtigungen um eine kaufbare Region abzumelden. "
"destroy-successRent": "%lang:region% erfolgreich als mietbare Region abgemeldet."
"destroy-successBuy": "%lang:region% erfolgreich als kaufbare Region abgemeldet."
"teleport-help": "/as tp <Region> [Schild]."
"teleport-noRentOrBuy": "Die angegebene Region ist nicht registriert: %0%."
"teleport-noPermission": "Du hast keine Rechte um dich zu dieser Region zu teleportieren."
"teleport-noPermissionOther": "Du bist nicht berechtigt, dich zu einer Region zu teleportieren, welche du nicht besitzt."
"teleport-noPermissionSign": "Du hast keine Rechte um dich zu diesem Schild in deiner Region zu teleportieren."
"teleport-noPermissionOtherSign": "Du hast keine Berechtigung, dich zu Schildern von Regionen, die du nicht besitzt, zu teleportieren."
"teleport-noPermissionFriend": "Du hast keine Berechtigungen, dich zu Regionen zu teleporten, in denen du als Freund hinzugefügt worden bist."
"teleport-noPermissionFriendSign": "Du hast keine Berechtigungen, dich zu dem Schild einer Region zu teleportieren, in denen du als Freund hinzugefügt worden bist."
"teleport-noPermissionAvailable": "Du hast keine Rechte um dich zu verfügbaren Regionen zu teleportieren."
"teleport-noPermissionAvailableSign": "Du hast keine Rechte um dich zum Schild von verfügbaren Regionen zu teleportieren."
"teleport-success": "Du wurdest zu %lang:region% teleportiert."
"teleport-successSign": "Du wurdest zum Schild von %lang:region% teleportiert."
"teleport-noSafe": "Keine sichere Position in %lang:region% gefunden, kein Boden vorhanden oder maximale Anzahl an Versuchen erreicht (%0%/%1%)."
"teleport-blocked": "Du kannst dich nicht teleportieren, weil sich die Position außerhalb der Region befindet und du dich nur in die Region teleportieren kannst."
"teleport-changedToSign": "Du hast nur Rechte um zum Schild der Region zu teleportieren und nicht um in die Region zu teleportieren. Teleportiere zum Schild."
"teleport-changedToNoSign": "Es ist kein Schild zum teleportieren verfügbar, versuche stattdessen in die Region zu teleportieren."
"setteleport-help": "/as settp [Region] [reset], Wenn kein Regionsname angegeben wird, wird die Region genutzt, in der du dich gerade befindest."
"setteleport-noPermission": "Du bist nicht berechtigt, einen Teleport-Punkt zu setzen."
"setteleport-noPermissionOther": "Dir fehlt die Berechtigung die Teleportposition für eine Region, du du nicht besitzt, festzulegen."
"setteleport-noRentOrBuy": "Die angegebene Region ist nicht registriert: %0%."
"setteleport-success": "Teleport-Punkt von %lang:region% erfolgreich gesetzt."
"setteleport-notInside": "Der Teleportpunkt muss sich innerhalb einer Region befinden."
"setteleport-reset": "Teleport-Punkt von %lang:region% erfolgreich zurückgesetzt."
"find-help": "/as find <buy|rent> [maximaler Preis] [Gruppe]."
"find-noPermission": "Du hast keine Berechtigungen nach Regionen zu suchen und zu ihnen zu teleporten."
"find-success": "%0% Region gefunden: %lang:region%, bei Suche nach max. Preis in Höhe deines Guthabens: %1%%2%."
"find-successMax": "%0% Region gefunden: %lang:region%,, bei Suche nach max. Preis in Höhe von %1%%2%."
"find-wrongMaxPrice": "Der angegebene Maximal-Preis ist kein korrekter Betrag: %0%."
"find-wrongGroup": "Die angegebene Gruppe existiert nicht: %0%."
"find-noneFound": "Keine %0% Region gefunden bei Suche nach max. Preis in Höhe deines Guthabens: %1%%2%."
"find-noneFoundMax": "Keine %0% Region gefunden bei Suche nach max. Preis in Höhe von %1%%2%."
"find-onlyInGroup": ", nur nach Regionen in der Gruppe %0% suchen."
"groupadd-help": "/as groupadd <Gruppe> [Region], Wenn kein Regionsname angegeben wird, werden alle Regionen deiner WorldEdit-Markierung einbezogen."
"groupadd-noPermission": "Du bist nicht berechtigt Regionen zu Gruppen hinzuzufügen."
"groupadd-success": "Region %lang:region% wurde zur Gruppe '%0%' hinzugefügt. Diese Gruppe hat nun %1% Mitglied(er)."
"groupadd-failed": "Region %lang:region% ist bereits Mitglied der Gruppe '%0%';."
"groupadd-weSuccess": "Zu Gruppe %0% hinzugefügt: [gray]%1%."
"groupadd-weFailed": "Ist bereits in Gruppe %0%: [gray]%1%."
"groupdel-help": "/as groupdel <Gruppe> [Region], Wenn kein Regionsname angegeben wird, werden alle Regionen deiner WorldEdit-Markierung einbezogen."
"groupdel-noPermission": "Du bist nicht berechtigt, Regionen aus Gruppen zu entfernen."
"groupdel-success": "Region %lang:region% ist aus Gruppe '%0%' entfernt worden. Diese Gruppe hat nun %1% Mitglied(er)."
"groupdel-failed": "Region %lang:region% gehört nicht zur Gruppe '%0%'."
"groupdel-weSuccess": "Entfernt aus Gruppe %0%: [gray]%1%."
"groupdel-weFailed": "Ist nicht länger in Gruppe %0%: [gray]%1%."
"grouplist-noPermission": "Du bist nicht berechtigt, die eingetragenen Gruppen abzurufen."
"grouplist-noGroups": "Momentan sind keine Gruppen vorhanden."
"grouplist-success": "Folgende Gruppen sind vorhanden: [gray]%0%."
"groupinfo-help": "/as groupinfo <Gruppe>."
"groupinfo-noPermission": "Du bist nicht berechtigt, Informationen über eine Gruppe abzurufen."
"groupinfo-noGroup": "Es ist keine Gruppe mit dem Namen '%0%' vorhanden, bitte benutze zum Anzeigen der verfügbaren Gruppen /as grouplist."
"groupinfo-members": "Die folgenden Regionen gehören zur Gruppe %0%: [gray]%1%."
"groupinfo-noMembers": "Gruppe %0% hat keine Mitglieder."
"schemevent-help": "/as schemevent <Region> <created|deleted|rented|unrented|bought|sold>."
"schemevent-wrongEvent": "Das angegebene Event '%0%' existiert nicht, bitte benutze eines der folgenden: [gray]%1%."
"schemevent-success": "'%0%'-Event wurde erfolgreich für Region %lang:region% ausgelöst."
"schemevent-noPermission": "Du bist nicht berechtigt, Schematic-Events auszuführen."
"add-help": "/as add <rent|buy> [Region] [Welt]."
"add-noPermission": "Du bist nicht berechtigt, eine Region in AreaShop hinzuzufügen."
"add-success": "Hinzugefügt als %0%: [gray]%1%."
"add-failed": "Bereits eingetragen: [gray]%0%."
"add-blacklisted": "Auf der Blacklist: [gray]%0%."
"add-specifyWorld": "Bei Verwendung der Konsole bitte Welt der Region eintragen."
"add-incorrectWorld": "Welt '%0%' nicht gefunden, versuche es bitte noch einmal (Groß- und Kleinschreibung beachten)."
"add-noPermissionRegions": "Keine Rechte zum hinzufügen: [gray]%0%."
"add-noPermissionOwnerMember": "[gray]Entweder bist du weder Mitglied noch Besitzer der Region oder hast keine Rechte um deine Regionen hinzuzufügen."
"del-noPermission": "Du bist nicht berechtigt, Regionen zu entfernen."
"del-success": "Entfernte Region(en): [gray]%0%."
"del-failed": "Keine Berechtigung zum Entfernen oder nicht eingetragen: [gray]%0%."
"addsign-help": "/as addsign [Region] [Profil]."
"addsign-noSign": "Du schaust gerade nicht auf ein Schild."
"addsign-noRegions": "Keine Region(en) um das Schild herum gefunden."
"addsign-couldNotDetect": "Mehrere Regionen um das Schild herum gefunden, bitte gewünschte Region als Argument angeben (zwei der gefundenen Regionen: %lang:tRegion|%0%|% und %lang:tRegion|%1%|%)."
"addsign-couldNotDetectSign": "Mehrere Regionen um das Schild herum gefunden, bitte gewünschte Region in die zweite Zeile eintragen (zwei der gefundenen Regionen: %lang:tRegion|%0%|% und %lang:tRegion|%1%|%)."
"addsign-wrongProfile": "Das eingetragene Profil existiert nicht. Bitte benutze eines der folgenden (überprüfe config): [gray]%0%."
"addsign-profile":
- "[bold]%0%[/bold]"
- " hover: Schildprofil %0%"
- " hover: %lang:action|Use this profile|%"
- " command: /areashop linksigns %0%"
"addsign-success": "Das Schild wurde hinzugefügt zu %lang:region%."
"addsign-successProfile": "Das Schild wurde zu %lang:region% mit dem Profil %0% hinzugefügt."
"addsign-alreadyRegistered": "Dieses Schild ist bereits für die Region %lang:region% registriert."
"addsign-noPermission": "Du bist nicht berechtigt, ein Schild hinzuzufügen."
"delsign-noSign": "Du schaust gerade nicht auf ein Schild."
"delsign-noPermission": "Du bist nicht berechtigt, ein Schild zu entfernen."
"delsign-noRegion": "Dieses Schild gehört zu keiner in AreaShop eingetragenen Region."
"delsign-success": "Das Schild wurde von der Region %lang:region% entfernt."
"me-noPermission": "Dir fehlt die Berechtigung einzusehen, welche Regionen du besitzt."
"me-header": "Regionen von %lang:tPlayer|%0%|%:"
"me-notAPlayer": "Du bist kein Spieler, darum können dir keine Regionen gehören."
"me-rentLine":
- "[darkgreen][bold]►[reset] %lang:region% [gray]("
- "%timeleft% übrig"
- " hover: bis %until%"
- ")."
"me-buyLine": "[darkgreen][bold]►[reset] %lang:region%."
"me-friendLine":
- "[darkgreen][bold]►[reset] %lang:region% [gray]("
- "Im Besitz von %lang:player%"
- " hover: Du wurdest als Freund hinzugefügt"
- ")."
"me-nothing": "%lang:tPlayer|%0%|% hat keine gemieteten oder gekaufen Regionen und wurde nicht als Freund zu einem hinzugefügt."
"me-noPlayer": "%0% konnte nicht gefunden werden, möglicherweise war er nie auf diesem Server."
"me-clickHint": "[gray][italic]Klicke auf eine Region, um weitere Details zu erhalten."
"setowner-help": "/as setowner <Spieler> [Region], wenn kein Regionsname angegeben wird, wird die Region genutzt, in der du dich gerade befindest."
"setowner-noPermission": "Dir fehlt die Berechtigung den Besitzer einer Region festzulegen."
"setowner-noPermissionRent": "Dir fehlt die Berechtigung den Mieter einer Region festzulegen."
"setowner-noPermissionBuy": "Dir fehlt die Berechtigung den Eigentümer einer Region festzulegen."
"setowner-notRegistered": "Die angegebene Region ist nicht registriert, Besitzer kann nicht festgelegt werden."
"setowner-noPlayer": "Die UUID des Spielers %0% konnte nicht gefunden werden."
"setowner-succesRent": "Besitzer von %lang:region% erfolgreich geändert zu %lang:player%, gemietet bis %until% (%timeleft% verbleibend)."
"setowner-succesRentExtend": "%lang:player% ist bereits Besitzer, Miete verlängert um '%duration%', nun gemietet bis %until% (%timeleft% verbleibend)."
"setowner-succesBuy": "Besitzer von %lang:region% erfolgreich geändert zu %lang:player%."
"resell-help": "/as resell <Preis> [Region], wählt automatisch die Region, in der du dich befindest, wenn nicht angegeben."
"resell-wrongPrice": "'%0%' ist keine gültige Preisangabe."
"resell-notRegistered": "Die angegebene Region ist nicht registriert: %0%."
"resell-notBought": "Du kannst %lang:region% nicht weiterverkaufen, weil sie noch nicht erworben wurde."
"resell-success": "Weiterverkauf für %lang:region% erfolgreich aktiviert. Preis: %resellprice%."
"resell-noPermission": "Du hast keine Berechtigung, deine Region weiterzuverkaufen."
"resell-noPermissionOther": "Du hast keine Berechtigung, den Weiterverkauf von Regionen zu aktivieren."
"resell-disabled": "Der Weiterverkauf wurde für diese Region deaktiviert."
"stopresell-help": "/as stopresell [Region], wählt automatisch die Region, in der du dich befindest, wenn nicht angegeben."
"stopresell-notRegistered": "Die angegebene Region ist nicht registriert: %0%."
"stopresell-notResell": "Du kannst den Weiterverkauf von %lang:region% nicht stoppen, weil sie bisher nicht weiterverkauft werden soll."
"stopresell-success": "Weiterverkauf von %lang:region% wurde erfolgreich gestoppt."
"stopresell-noPermission": "Du hast keine Berechtigung, den Weiterverkauf deiner Region zu stoppen."
"stopresell-noPermissionOther": "Du hast keine Berechtigung, den Weiterverkauf einer Region zu stoppen."
"addfriend-help": "/as addfriend <Spieler> [Region], wählt automatisch die Region, in der du dich befindest, wenn nicht angegeben."
"addfriend-noPermissionOther": "Du hast keine Berechtigung, Freunde zu einer Region hinzufügen, welche dir nicht gehört."
"addfriend-noPermission": "Du hast keine Berechtigung, Spieler zu deiner Region hinzuzufügen."
"addfriend-successOther": "%lang:tPlayer|%0%|% wurde als Freund zur Region %lang:region% hinzugefügt."
"addfriend-success": "%lang:tPlayer|%0%|% wurde als Freund zu deiner Region %lang:region% hinzugefügt."
"addfriend-alreadyAdded": "%lang:tPlayer|%0%|% wurde bereits als Freund zu der Region %lang:region% hinzugefügt."
"addfriend-self": "Den Besitzer der Region als Freund hinzuzufügen wäre sinnlos."
"addfriend-noOwner": "Du kannst keine Freunde zu einer Region ohne Besitzer hinzufügen."
"addfriend-notVisited": "Du kannst %0% nicht hinzufügen, weil dieser Spieler noch nie auf dem Server war."
"delfriend-help": "/as delfriend <Spieler> [Region], wählt automatisch die Region, in der du dich befindest, wenn nicht angegeben."
"delfriend-noPermissionOther": "Du hast keine Berechtigung, Freunde von Regionen zu entfernen, die dir nicht gehören."
"delfriend-noPermission": "Du hast keine Berechtigung, Freunde von deinen Regionen zu entfernen."
"delfriend-successOther": "%lang:tPlayer|%0%|% wurde als Freund der Region %lang:region% entfernt."
"delfriend-success": "%lang:tPlayer|%0%|% wurde als Freund Deiner Region %lang:region% entfernt."
"delfriend-notAdded": "%lang:tPlayer|%0%|% wurde nicht als Freund zur Region %lang:region% hinzugefügt."
"delfriend-noOwner": "Du kannst keine Freunde von einer Region ohne Besitzer entfernen."
"linksigns-multipleRegions": "Mehrere Regionen gefunden: [gray]%0%."
"linksigns-multipleRegionsAdvice": "Bitte klicke nochmal oder benutze '/as linksigns', um aufzuhören."
"linksigns-noRegions": "Keine AreaShop Regionen in Cursorrichtung gefunden, bitte stell sicher, dass die Region in AreaShop registriert ist. [gray](Maximale Reichweite 100 Blöcke)"
"linksigns-regionFound": "Region %lang:region% wurde gefunden, verbinde sie jetzt mit einem Linksklick auf ein Schild."
"linksigns-signFound": "Schild gefunden bei (%0%, %1%, %2%), mach einen Rechtsklick auf eine Region um das Schild zu verbinden."
"linksigns-noSign": "Kein Schild in Cursorrichtung gefunden, bitte stell sicher, dass du eine direkte Sicht auf ein Schild hast und klicke erneut [gray](Maximale Reichweite 100 Blöcke)."
"linksigns-alreadyRegistered": "Dieses Schild ist bereits auf die Region %lang:region% registriert, klicke erneut um ein anderes Schild zu wählen."
"linksigns-first": "Du bist nun im Schilderverbindungsmodus."
"linksigns-next": "[gray]Linksklicke um ein Schild zu wählen, Rechtsklicke um eine Region zu wählen. Benutze /as linksigns um aufzuhören."
"linksigns-noPermission": "Du hast keine Berechtigungen um den Schilder-Massenverbindungsmodus zu benutzen."
"linksigns-stopped": "Schilder-Verbindungsmodus verlassen."
"stack-help":
- "/as stack <Menge> <Abstand> <Name> <rent|buy> [Gruppe]."
- "[gray]<Menge> Nummer der Regionen, die erstellt werden."
- "[gray]<Abstand> Block-Abstand zwischen den Regionen."
- "[gray]<Name> Namen der Regionen (Nummer wird dahinter sein)."
- "[gray]<rent|buy> Macht die Regionen zu kauf- oder Mietregionen"
- "[gray][Gruppe] Eine Gruppe, die zu den erstellten Regionen hinzugefügt wird."
- "Die Regionen werden in deiner Blickrichtung erstellt."
"stack-accepted": "Erstelle %0% %1% Regionen mit %2% Blöcken Abstand, Namen beginnend mit %3% und einer Zahl dahinter. %4%"
"stack-addToGroup": "Gruppe '%0%' wird zu den erstellten Regionen hinzugefügt."
"stack-noPermission": "Du hast keine Berechtigungen um Regionen massenweise in AreaShop zu erstellen und hinzuzufügen."
"stack-wrongAmount": "'%0%' ist keine korrekte Anzahl von Regionen."
"stack-wrongGap": "'%0%' ist keine korrekte Nummer von Blöcken für den Abstand, der zwischen den Regionen sein soll."
"stack-noSelection": "Du hast keine Auswahl, die angibt, wo die erste Region erstellt werden soll."
"stack-addStart": "[gray]Füge %0% Regionen mit %1% Regionen pro Sekunde hinzu."
"stack-addComplete": "[gray]%0% Regionen%1% hinzugefügt."
"stack-tooHigh": ", %0% Regionen übersprungen, da sie sich über Y=256 befinden."
"stack-tooLow": ", %0% Regionen übersprungen, da sie sich unter Y=0 befinden."
"stack-unclearDirection": "Bitte gucke ganz klar nach Norden, Osten, Süden, Westen, nach oben oder unten. Du guckst im Moment nach %0%."
"setlandlord-help": "/as setlandlord <Spieler> [Region], die Region in der du stehst wird verwendet, wenn keine angegeben wird."
"setlandlord-noPermission": "Du hast keine Rechte um den Vermieter einer Region zu setzen."
"setlandlord-success": "%lang:landlord% wurde erfolgreich als Vermieter der Region %lang:region% gesetzt."
"message-help": "/as message <Spieler> <Nachricht...>"
"message-noPermission": "Du hast keine Berechtigung AreaShop Nachrichten zu senden."
"message-notOnline": "%0% ist nicht online."
"confirm-rent":
- "%lang:prefix%Bist du sicher, dass du %lang:tRegion|%0%|% mieten willst?"
- "[darkgreen][bold]►[reset] %lang:button|Klick zum Mieten %0%|%"
- "hover: %lang:action|Rent %0%|%"
- "command: /areashop rent %0%"
"confirm-extend":
- "%lang:prefix%Bist du sicher, dass du %lang:tRegion|%0%|% verlängern willst?"
- "[darkgreen][bold]►[reset] %lang:button|Klick zum Verlängern %0%|%"
- "hover: %lang:action|Verlängern %0%|%"
- "command: /areashop rent %0%"
"confirm-unrent":
- "%lang:prefix%Bist du sicher, dass du %lang:tRegion|%0%|% nicht länger mieten möchtest?"
- "[darkgreen][bold]►[reset] %lang:button|Klick zum Auflösen %0%|%"
- "hover: %lang:action|Mietvertrag auslösen %0%|%"
- "command: /areashop unrent %0%"
"confirm-buy":
- "%lang:prefix% Bist du sicher das du %lang:tRegion|%0%|% kaufen möchtest?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to buy %0%|%"
- " hover: %lang:action|Buy %0%|%"
- " command: /areashop buy %0% "
"confirm-sell":
- "%lang:prefix% Bist du sicher, dass du %lang:tRegion|%0%|% verkaufen willst?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Klick zum Verkaufen von %0%|%"
- " hover: %lang:action|Verkaufe %0%|%"
- " command: /areashop sell %0% "
"timeleft-years": "%0% Jahre"
"timeleft-months": "%0% Monate"
"timeleft-days": "%0% Tage"
"timeleft-hours": "%0% Stunden"
"timeleft-minutes": "%0% Minuten"
"timeleft-second": "%0% Sekunde"
"timeleft-seconds": "%0% Sekunden"
"timeleft-ended": "abgelaufen"
"greeting-forrent": "%region% kann gemietet werden für %price% je %duration%."
"greeting-rented": "%region% ist vermietet an %player% bis %until%."
"greeting-forsale": "%region% kann gekauft werden für %price%."
"greeting-bought": "%region% ist Eigentum von %player%."
"greeting-resale": "%region% kann für %resellprice% von 1%player% gekauft werden."
+625
View File
@@ -0,0 +1,625 @@
# ╔═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
# ║ Language file of the AreaShop plugin created by NLThijs48, Github can be found at https://github.com/NLthijs48/AreaShop
# ║ English language file, plugin version 2.5.0
# ║
# ║ This file will be overwritten at each startup/reload of the plugin, if you want to change anything then do the following:
# ║ 1: Make a copy of this file
# ║ 2: Rename it to `servername.yml`
# ║ 3: Change the `language` setting in config.yml to `servername`, do not include `.yml`
# ║ 4: Change the messages in the new file to your liking
# ║ 5: Use `/as reload`or reload/restart your server to see the changes
# ╚═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════
action: "[gold][bold]<%0%>[/bold]"
button: "[bold]<%0%>[/bold]"
command:
- "[bold]%0%[/bold]"
- " hover: %lang:action|Use %1%|%"
- " command: %1%"
helpCommand:
- "[gold]%0% [gray]-[reset]"
- " hover: %lang:action|Use %0%|%"
- " command: %0%"
region: "%lang:tRegion|%region%|%"
tRegion:
- "[bold]%0%[/bold]"
- " hover: Region %0%"
- " hover: %lang:action|Region information|%"
- " command: /areashop info region %0%"
player: "%lang:tPlayer|%player%|%"
tPlayer:
- "[bold]%0%[/bold]"
- " hover: Player %0%"
- " hover: %lang:action|Regions of %0%|%"
- " command: /areashop info player %0%"
landlord:
- "[bold]%landlord%[/bold]"
- " hover: Landlord %landlord%"
- " hover: %lang:action|Regions of %landlord%|%"
- " command: /areashop info player %landlord%"
total-maximum: "You can't rent and buy more than %0% region(s) in total (you already have %1% in group '%2%')."
confirm-yes: " [gray]Click to %lang:command|Confirm|%0%|%[gray], or repeat the command."
general-notReady: "AreaShop has not fully loaded yet, please wait."
general-noWorld: "You cannot do that, the world of %lang:region% is currently unavailable (world '%world%')."
general-noRegion: "You cannot do that, the WorldGuard region is currently unavailable (region %lang:region%)."
general-noEconomy: "There is no Economy plugin installed or it is not setup correctly, notify the server owner about this."
general-cancelled: "%0%"
cmd-notValid: "That command is not valid, use '/as help' for info."
cmd-onlyByPlayer: "This command can only be run by a player."
cmd-weOnlyByPlayer: "Using a WorldEdit selection is only possible as a player, specify the region name as extra argument."
cmd-noSelection: "You don't have a WorldEdit selection."
cmd-noRegionsFound: "No regions registered in AreaShop are found in your selection."
cmd-noWERegionsFound: "No WorldEdit regions intersecting your selection are found."
cmd-notRegistered: "Region '%0%' is not available in AreaShop."
cmd-noRegion: "'%0%' is not a valid WorldGuard region."
cmd-noRegionsAtLocation: "No regions found at your location, specify the region as argument."
cmd-moreRegionsAtLocation: "More than one region has been found at your location, specify the region as argument."
cmd-automaticRegionOnlyByPlayer: "Automatically determining the region is only possible for players, specify the region as argument."
help-header: "Help page, commands that you can execute."
help-noPermission: "You do not have permission to view the help page."
help-alias: "Command aliases: /areashop, /as."
help-help: "%lang:helpCommand|/as help|% Shows this help page."
help-info: "%lang:helpCommand|/as info|% Get info about current regions."
help-rent: "%lang:helpCommand|/as rent|% Rent a region or extend your current rent."
help-buy: "%lang:helpCommand|/as buy|% Buy a region."
help-unrent: "%lang:helpCommand|/as unrent|% Unrent a region."
help-sell: "%lang:helpCommand|/as sell|% Sell a region."
help-reload: "%lang:helpCommand|/as reload|% Reload all files and update the regions."
help-setrestore: "%lang:helpCommand|/as setrestore|% Set restoring on/off and choose profile."
help-setprice: "%lang:helpCommand|/as setprice|% Change the price of a region."
help-setduration: "%lang:helpCommand|/as setduration|% Change the duration of a rent region."
help-teleport: "%lang:helpCommand|/as tp|% Teleport to a rent/buy region."
help-setteleport: "%lang:helpCommand|/as settp|% Set teleport position for a region."
help-find: "%lang:helpCommand|/as find|% Find an empty buy or rent."
help-groupadd: "%lang:helpCommand|/as groupadd|% Add a region to a group."
help-groupdel: "%lang:helpCommand|/as groupdel|% Delete a region from a group."
help-grouplist: "%lang:helpCommand|/as grouplist|% Display all groups currently registered."
help-groupinfo: "%lang:helpCommand|/as groupinfo|% Display information about a group."
help-schemevent: "%lang:helpCommand|/as schemevent|% Trigger a schematic event for a region."
help-add: "%lang:helpCommand|/as add|% Register a region as rent or buy."
help-del: "%lang:helpCommand|/as del|% Delete a registered region from AreaShop."
help-addsign: "%lang:helpCommand|/as addsign|% Add a sign to an existing region."
help-delsign: "%lang:helpCommand|/as delsign|% Delete the sign you are looking at."
help-me: "%lang:helpCommand|/as me|% Check which regions you have (+expiration)."
help-setowner: "%lang:helpCommand|/as setowner|% Set region owner or extend the rent."
help-resell: "%lang:helpCommand|/as resell|% Put a region into resell mode."
help-stopResell: "%lang:helpCommand|/as stopresell|% Put a region back into sold mode."
help-addFriend: "%lang:helpCommand|/as addfriend|% Add a friend to a region."
help-delFriend: "%lang:helpCommand|/as delfriend|% Delete a friend from a region."
help-linksigns: "%lang:helpCommand|/as linksigns|% Use bulk sign linking mode."
help-stack: "%lang:helpCommand|/as stack|% Create multiple regions and add them."
help-setlandlord: "%lang:helpCommand|/as setlandlord|% Set the landlord of a region."
help-import: "%lang:helpCommand|/as import|% Import region from RegionForSale."
rent-help: "/as rent [region], the region you stand in will be used if not specified."
rent-noPermission: "You don't have permission to rent a region."
rent-maximum: "You can't rent more than %0% region(s) (you already have %1% in group '%2%')."
rent-maximumExtend: "You can't extend this rent because you have more than %0% region(s) (you already have %1% in group '%2%')."
rent-payError: "Something went wrong with paying, try again later."
rent-rented: "You rented %lang:region% until %until%, you can extend your rent by rightclicking the sign again or using /as rent."
rent-extended: "You extended your rent of %lang:region% until %until%."
rent-extendedToMax: "You extended your rent of %lang:region% until %until% (which is the maximum rental time of %maxrenttime%)."
rent-lowMoneyExtend: "You don't have enough money to extend the rent (you have %0% and you need %price%)."
rent-lowMoneyRent: "You don't have enough money to rent %lang:region% (you have %0% and you need %price%)."
rent-someoneElse: "Someone else already rented %lang:region%."
rent-notRentable: "Region '%0%' is not available for renting (not registered in AreaShop or it is a buy region)."
rent-maxExtends: "You cannot extend this rent anymore (the maximum is %maxextends% times), however after the rent is over you can rent %lang:region% again."
rent-maxRentTime: "You cannot rent %lang:region% more time in advance, the maximum time is %maxrenttime% and you have currently rented it for %timeleft%."
rent-restrictedToWorld: "You need to be in the '%world%' world to rent %lang:region% (you are in '%0%')."
rent-restrictedToRegion: "You need to be inside %lang:region% to rent it."
rent-expireWarning: "Your region %lang:region% has %timeleft% left, be sure to extend it if you want to keep it."
rent-expiringSoon: "Your region %lang:tRegion|%0%|% has %1% left, be sure to extend it if you want to keep it."
rent-alreadyAtFull: "%lang:region% is already at or above the maximum rental time, you cannot extend it yet."
buy-help: "/as buy [region], the region you stand in will be used if not specified."
buy-noPermission: "You don't have permission to buy a region."
buy-noPermissionResell: "You don't have permission to buy a region in resell mode."
buy-noPermissionNoResell: "You don't have permission to buy a region that is not in resell mode."
buy-notBuyable: "Region '%0%' is not available for buying (not registered in AreaShop or it is a rental region)."
buy-maximum: "You can't buy more than %0% region(s) (you already have %1% in group '%2%')."
buy-payError: "Something went wrong with paying, try again later."
buy-succes: "You successfully bought %lang:region%."
buy-successResale: "You successfully bought %lang:region% from %lang:tPlayer|%0%|%."
buy-successSeller: "Your region %lang:region% has been sold to %lang:player% for %0%."
buy-lowMoney: "You don't have enough money to buy %lang:region% (you have %0% and you need %price%)."
buy-lowMoneyResell: "You don't have enough money to buy %lang:region% (you have %0% and you need %resellprice%)."
buy-yours: "You already own %lang:region%."
buy-someoneElse: "Someone else already bought %lang:region%."
buy-restrictedToWorld: "You need to be in the '%world%' world to buy %lang:region% (you are in '%0%')."
buy-restrictedToRegion: "You need to be inside %lang:region% to buy it."
unrent-help: "/as unrent [region], the region you stand in will be used if not specified."
unrent-noPermission: "You don't have permission to unrent a region."
unrent-noPermissionOther: "You don't have permission to unrent another region."
unrent-notRegistered: "The region can't be unrented because it is not registered for renting."
unrent-notRented: "The region can't be unrented because it is not rented."
unrent-unrented: "%lang:region% of %lang:player% has been unrented."
unrent-expired: "Your rent of %lang:region% has expired."
sell-help: "/as sell [region], the region you stand in will be used if not specified."
sell-notRegistered: "The region can't be sold because it is not registered for buying."
sell-notBought: "The region can't be sold because it is not someone's property."
sell-sold: "%lang:region% of %lang:player% has been sold."
sell-noPermission: "You don't have permission to sell a region."
sell-noPermissionOther: "You don't have permission to sell another region."
sell-disabled: "Selling has been disabled for this region."
reload-reloading: "Reloaded all configuration and region files."
reload-updateStart: ""
reload-updateComplete: ""
reload-noPermission: "You don't have permission to reload the config files."
reload-updateCommandChanged: "'/as updaterents' and '/as updatebuys' have been removed, '/as reload' will also update the regions now so use that command instead."
info-help:
- "/as info[break]"
- " %lang:command|all|/as info all|%[break]"
- " %lang:command|rented|/as info rented|% [group] [page][break]"
- " %lang:command|forrent|/as info forrent|% [group] [page][break]"
- " %lang:command|sold|/as info sold|% [group] [page][break]"
- " %lang:command|forsale|/as info forsale|% [group] [page][break]"
- " %lang:command|reselling|/as info reselling|% [group] [page][break]"
- " %lang:command|nogroup|/as info nogroup [page]|%[break]"
- " %lang:command|region|/as info region|% [region]"
info-noPermission: "You don't have permission to get information about regions."
info-allHeader: "All regions%0%:"
info-rentedHeader: "Rented regions%0%:"
info-forrentHeader: "For rent regions%0%:"
info-forsaleHeader: "For sale regions%0%:"
info-soldHeader: "Sold regions%0%:"
info-resellingHeader: "Reselling regions%0%:"
info-nogroupHeader: "Regions without group%0%:"
info-limitedToGroup: " (limited to group %0%)"
info-nogroupNone: "There are no regions without a group."
info-noFiltergroup: "Group '%0%' does not exist and therefore cannot be used to limit the results."
info-noRegions: "No regions have been found."
info-wrongPage: "%0% is not a correct page number."
info-entryForrent: "[darkgreen][bold]►[reset] %lang:region%: [gray]For rent for %price% per %duration%."
info-entryRented: "[darkgreen][bold]►[reset] %lang:region%: [gray]Rented to %lang:player%."
info-entryForsale: "[darkgreen][bold]►[reset] %lang:region%: [gray]For sale for %price%."
info-entrySold: "[darkgreen][bold]►[reset] %lang:region%: [gray]Sold to %lang:player%."
info-entryReselling: "[darkgreen][bold]►[reset] %lang:region%: [gray]Sold to %lang:player% (reselling)."
info-pageStatus:
- "[gold]Page %0%/%1%"
info-pagePrevious:
- " [gold][bold]◄Previous[/bold] "
- " hover: %lang:action|Show previous page|%"
- " command: /areashop %0%"
info-pageNoPrevious:
- " [darkgray][bold]◄Previous[/bold] "
- " hover: This is already the first page"
info-pageNext:
- " [gold][bold]Next►[/bold]"
- " hover: %lang:action|Show next page|%"
- " command: /areashop %0%"
info-pageNoNext:
- " [darkgray][bold]Next►[/bold]"
- " hover: This is already the last page"
info-playerHelp: "/as info player <name>."
info-playerRents: "Regions rented by %lang:tPlayer|%0%|%: [gray]%1%"
info-playerNoRents: "%lang:tPlayer|%0%|% has not rented a region."
info-playerBuys: "Regions bought by %lang:tPlayer|%0%|%: [gray]%1%."
info-playerNoBuys: "%lang:tPlayer|%0%|% has not bought a region."
info-regionHelp: "/as info region [name], the region you stand in will be used if not specified."
info-regionHeaderRent: "[darkgreen]Information about %lang:region%:"
info-regionHeaderBuy: "[darkgreen]Information about %lang:region%:"
info-regionFooterRent: ""
info-regionFooterBuy: ""
info-regionRented: "[darkgreen][bold]►[reset] Rented by %lang:player% until: [gray]%until%."
info-regionBought: "[darkgreen][bold]►[reset] Bought by %lang:player%."
info-regionReselling: "[darkgreen][bold]►[reset] Bought by %lang:player%, currently reselling."
info-regionExtending:
- "[darkgreen][bold]►[reset] "
- "[bold]Extend for[/bold]"
- " hover: Extend rent of %region%"
- " hover: with %duration% for %price%"
- " hover: %lang:action|Extend rent of %region%|%"
- " command: /areashop rent %region%"
- ": [gray]%price% per %duration%."
info-regionCanBeRented:
- "[darkgreen][bold]►[reset] "
- "[bold]Rent for[/bold]"
- " hover: Rent %region% for %price% per %duration%"
- " hover: %lang:action|Rent %region%|%"
- " command: /areashop rent %region%"
- ": [gray]%price% per %duration%."
info-regionCanBeBought:
- "[darkgreen][bold]►[reset] "
- "[bold]Buy for[/bold]"
- " hover: Buy %region% for %price%"
- " hover: %lang:action|Buy %region%|%"
- " command: /areashop buy %region%"
- ": [gray]%price%."
info-regionReselPrice: "[darkgreen][bold]►[reset] Resell price: [gray]%resellprice% (you can buy it from %lang:player%)."
info-regionFriends: "[darkgreen][bold]►[reset] Added friends: [gray]%0%."
info-friend: "%lang:tPlayer|%0%|%"
info-friendRemove:
- "%lang:info-friend|%0%|%"
- "[red]✕[gray]"
- " hover: Region %region%"
- " hover: %lang:action|Remove %0% as friend|%"
- " command: /areashop delfriend %0% %region%"
info-regionMoneyBackBuy:
- "[darkgreen][bold]►[reset] Selling payback: [gray]%moneyback% (%moneybackpercent%% of the price)."
info-regionMoneyBackBuyClick:
- "[darkgreen][bold]►[reset] "
- "[bold]Selling payback[/bold]"
- " hover: Sell %region% and get back %moneyback%"
- " hover: %lang:action|Sell %region%|%"
- " command: /areashop sell %region%"
- ": [gray]%moneyback% (%moneybackpercent%% of the price)."
info-regionMoneyBackRent:
- "[darkgreen][bold]►[reset] Unrenting payback: [gray]%moneyback% (%moneybackpercent%% of the remaining time)."
info-regionMoneyBackRentClick:
- "[darkgreen][bold]►[reset] "
- "[bold]Unrenting payback[/bold]"
- " hover: Unrent %region% and get back %moneyback%"
- " hover: %lang:action|Unrent %region%|%"
- " command: /areashop unrent %region%"
- ": [gray]%moneyback% (%moneybackpercent%% of the remaining time)."
info-regionMaxExtends: "[darkgreen][bold]►[reset] Maximum number of extensions: [gray]%maxextends% time(s)."
info-regionNoExtending: "[darkgreen][bold]►[reset] Rent cannot be extended."
info-regionExtendsLeft: "[darkgreen][bold]►[reset] Extensions left: [gray]%extendsleft% time(s) out of %maxextends%."
info-regionMaxRentTime: "[darkgreen][bold]►[reset] In advance renting: [gray]%maxrenttime% at maximum."
info-prefix: "[darkgreen][bold]►[reset] "
info-regionTeleport:
- "[bold]Go to the region[/bold]"
- " hover: %lang:action|Teleport to %region%|%"
- " command: /areashop tp %region%"
info-setRegionTeleport:
- "[bold]set teleport location[/bold]"
- " hover: %region%"
- " hover: %lang:action|Set teleport location|%"
- " command: /areashop settp %region%"
info-regionSigns: "[darkgreen][bold]►[reset] Connected signs: [gray]%0%."
info-regionSignLocation: "[gray](%0%, %1%, %2%, %3%)[reset]"
info-regionGroups: "[darkgreen][bold]►[reset] Assigned groups: [gray]%0%."
info-regionInactiveUnrent: "[darkgreen][bold]►[reset] Auto unrent after: [gray]%inactivetime% of inactivity by the player."
info-regionInactiveSell: "[darkgreen][bold]►[reset] Auto sell after: [gray]%inactivetime% of inactivity by the player."
info-regionRestrictedRegionRent: "[darkgreen][bold]►[reset] You must be inside %lang:region% to rent it."
info-regionRestrictedWorldRent: "[darkgreen][bold]►[reset] You need to be inside world '%world%' to rent %lang:region%."
info-regionRestrictedRegionBuy: "[darkgreen][bold]►[reset] You must be inside %lang:region% to buy it."
info-regionRestrictedWorldBuy: "[darkgreen][bold]►[reset] You need to be inside world '%world%' to buy %lang:region%."
info-regionRestoringRent: "[darkgreen][bold]►[reset] Restoring is enabled [gray](region will reset at unrent)."
info-regionRestoringBuy: "[darkgreen][bold]►[reset] Restoring is enabled [gray](region will reset at sell)."
info-regionLandlord: "[darkgreen][bold]►[reset] Landlord: [gray]%lang:landlord% (receives the money)."
info-regionNotExisting: "The specified region is not registered: %0%."
setrestore-help: "/as setrestore <region> <true|false|general> [profile]."
setrestore-noPermission: "You don't have permission to change the restore settings."
setrestore-notRegistered: "The specified region is not registered: %0%."
setrestore-invalidSetting: "'%0%' is not a valid state, should be true, false or general."
setrestore-success: "Successfully set the restore setting of %lang:region% to '%0%'."
setrestore-successProfile: "Successfully set the restore setting of %lang:region% to '%0%' and the profile to '%1%'."
setprice-noPermission: "You don't have permission to change the price of a region."
setprice-help: "/as setprice <price> [region], the region you stand in will be used if not specified."
setprice-notRegistered: "The specified region is not registered: %0%."
setprice-wrongPrice: "'%0%' is not a valid price."
setprice-successRent: "Price of region %lang:region% changed to %price% per %duration%."
setprice-successBuy: "Price of region %lang:region% changed to %price%."
setprice-successRemoved: "Price of %lang:region% has been removed, it will now use the price from a group or the default.yml file, new price: %price%."
setprice-noLandlord: "You don't have permission to change the price because you are not the landlord of %lang:region%."
setduration-noPermission: "You don't have permission to change the duration of a rent."
setduration-help: "/as setduration <amount> <identifier> [region], the region you stand in will be used if not specified."
setduration-notRegistered: "%0% is not registered for renting."
setduration-wrongAmount: "'%0%' is not a valid amount, use a whole number."
setduration-wrongFormat: "'%0%' is not a proper timeformat, check the documentation on Bukkit."
setduration-success: "Duration of region %lang:region% changed to '%duration%'."
setduration-noLandlord: "You don't have permission to change the duration because you are not the landlord of %lang:region%."
setduration-successRemoved: "Duration of %lang:region% has been removed, it will now use the duration from a group or the default.yml file, new duration: %duration%."
setup-noRegion: "You did not specify a region on the second line."
setup-alreadyRentSign: "The region you specified is already added to AreaShop as a rent region, add signs with [as] on the first line or '/as addsign'."
setup-alreadyOtherWorld: "The region you specified is already added to AreaShop in another world, regions from different worlds still need different names."
setup-alreadyBuySign: "The region you specified is already added to AreaShop as a buy region, add signs with [as] on the first line or '/as addsign'."
setup-noDuration: "You did not specify how long the region can be rented, do this on the third line."
setup-wrongDuration: "The time specified is not in the correct format, example: 1 day."
setup-noPrice: "You did not specify the price on the fourth line."
setup-wrongPrice: "You did not specify the price correctly, use numbers only."
setup-rentSuccess: "Renting of region %lang:region% is setup correctly."
setup-buySuccess: "Buying of region %lang:region% is setup correctly."
setup-noPermissionRent: "You don't have permission for setting up rental regions."
setup-noPermissionBuy: "You don't have permission for setting up buy regions."
setup-couldNotDetect: "Found multiple regions with the same priority and/or parent/child relation, specify one on the second line (2 of the regions that were found: %lang:tRegion|%0%|% and %lang:tRegion|%1%|%)."
setup-blacklisted: "%0% is on the blacklist and cannot be added to AreaShop."
setup-noPermission: "You cannot add the region '%0%', you are not an owner/member or don't have the permission for it."
destroy-noPermissionRent: "You don't have permission for deregistering a rental region."
destroy-noPermissionBuy: "You don't have permission for deregistering a buy region."
destroy-successRent: "%lang:region% successfully deregistered as rental region."
destroy-successBuy: "%lang:region% successfully deregistered as buy region."
teleport-help: "/as tp <region> [sign]."
teleport-noRentOrBuy: "The specified region is not registered: %0%."
teleport-noPermission: "You don't have permission to teleport to your region."
teleport-noPermissionOther: "You don't have permission to teleport to regions you do not own."
teleport-noPermissionSign: "You don't have permission to teleport to the sign of your region."
teleport-noPermissionOtherSign: "You don't have permission to teleport to signs of regions you do not own."
teleport-noPermissionFriend: "You don't have permission to teleport to regions you are added to as a friend."
teleport-noPermissionFriendSign: "You don't have permission to teleport to the sign of regions you are added to as a friend."
teleport-noPermissionAvailable: "You don't have permission to teleport to available regions."
teleport-noPermissionAvailableSign: "You don't have permission to teleport to the sign of available regions."
teleport-success: "You teleported to %lang:region%."
teleport-successSign: "You teleported to the sign of %lang:region%."
teleport-noSafe: "No safe position found in %lang:region%, no spots in the region left or maximum tries exceeded (%0%/%1%)."
teleport-blocked: "You can't teleport because the position is outside the region, and you are forced to teleport inside."
teleport-changedToSign: "You only have permission to teleport to the sign and not inside the region, teleporting to sign."
teleport-changedToNoSign: "No sign available to teleport to, trying to teleport inside the region instead."
teleport-wrongWorld: "You need to be in world '%world%' to teleport to %lang:region%, but you are in world '%0%'."
setteleport-help: "/as settp [region] [reset], the region you stand in will be used if not specified."
setteleport-noPermission: "You don't have permission to set the teleport location."
setteleport-noPermissionOther: "You don't have permission to set the teleport location for a region you do not own."
setteleport-noRentOrBuy: "The specified region is not registered: %0%."
setteleport-success: "Teleport location of %lang:region% set."
setteleport-notInside: "The location has to be inside the region."
setteleport-reset: "Teleport location of %lang:region% has been reset."
find-help: "/as find <buy|rent> [maxprice] [group]."
find-noPermission: "You don't have permission to search regions and teleport to them."
find-success: "Found a %0% region: %lang:region%, while searching with a max price of your balance: %1%%2%."
find-successMax: "Found a %0% region: %lang:region%, while searching with a max price of %1%%2%."
find-wrongMaxPrice: "The specified maximum price is not a correct number: %0%."
find-wrongGroup: "The specified group does not exist: %0%."
find-noneFound: "No %0% region found while searching with a max price of your balance: %1%%2%."
find-noneFoundMax: "No %0% region found while searching with a max price of %1%%2%."
find-onlyInGroup: ", only searched for regions in group: %0%."
groupadd-help: "/as groupadd <group> [region], if no region specified all regions from your WorldEdit selection are used."
groupadd-noPermission: "You don't have permission to add regions to groups."
groupadd-success: "Region %lang:region% has been added to group '%0%', this group now has %1% member(s)."
groupadd-failed: "Region %lang:region% is already a member of group '%0%'."
groupadd-weSuccess: "Added to group %0%: [gray]%1%."
groupadd-weFailed: "Were already in group %0%: [gray]%1%."
groupdel-help: "/as groupdel <group> [region], if no region specified all regions from your WorldEdit selection are used."
groupdel-noPermission: "You don't have permission to remove regions from groups."
groupdel-wrongGroup: "Group %0% not found, check '/as grouplist' for registered groups."
groupdel-success: "Region %lang:region% has been removed from group '%0%', this group now has %1% member(s)."
groupdel-failed: "Region %lang:region% is not a member of group '%0%'."
groupdel-weSuccess: "Removed from group %0%: [gray]%1%."
groupdel-weFailed: "Were not in group %0% anyway: [gray]%1%."
grouplist-noPermission: "You don't have permission to display the registered groups."
grouplist-noGroups: "There are currently no groups registered."
grouplist-success: "The following groups are registered: [gray]%0%."
groupinfo-help: "/as groupinfo <group>."
groupinfo-noPermission: "You don't have permission to display information about a group."
groupinfo-noGroup: "There is no group registered with the name '%0%', use /as grouplist to check groups."
groupinfo-members: "The following regions are member of group %0%: [gray]%1%."
groupinfo-noMembers: "Group %0% does not have any members."
schemevent-help: "/as schemevent <region> <created|deleted|rented|unrented|bought|sold>."
schemevent-wrongEvent: "The specified event '%0%' does not exist, use one of the following: [gray]%1%."
schemevent-success: "Event '%0%' has successfully been triggered for region %lang:region%."
schemevent-noPermission: "You don't have permission to trigger schematic events."
add-help: "/as add <rent|buy> [region] [world]."
add-noPermission: "You don't have permission to add a region to AreaShop."
add-success: "Added as %0%: [gray]%1%."
add-failed: "Already registered: [gray]%0%."
add-failedOtherWorld: "Already registered from another world: [gray]%0%."
add-blacklisted: "On the blacklist: [gray]%0%."
add-rentCancelled: "Rent cancelled: [gray]%0%."
add-buyCancelled: "Buy cancelled: [gray]%0%."
add-addCancelled: "Add cancelled: [gray]%0%."
add-specifyWorld: "Specify the world of the region when using from console."
add-incorrectWorld: "World '%0%' not found, try again (case-sensitive)."
add-noPermissionRegions: "No permission to add: [gray]%0%."
add-noPermissionOwnerMember: "[gray]You either are not a member/owner of these regions or have no permission to add your regions."
del-noPermission: "You don't have permission to remove regions."
del-success: "Removed regions: [gray]%0%."
del-failed: "No permission to remove or not registered: [gray]%0%."
del-cancelled: "Delete cancelled: [gray]%0%."
addsign-help: "/as addsign [region] [profile]."
addsign-noSign: "You are not looking at a sign."
addsign-noRegions: "No region found around the sign position."
addSign-notRegistered: "The specified region is not registered in AreaShop: %0% (it first needs to be added to AreaShop before a sign can be added)."
addsign-couldNotDetect: "Found multiple regions around the sign, specify region as extra argument (2 of the regions that were found: %lang:tRegion|%0%|% and %lang:tRegion|%1%|%)."
addsign-couldNotDetectSign: "Found multiple regions around the sign, specify region on the second line (2 of the regions that were found: %lang:tRegion|%0%|% and %lang:tRegion|%1%|%)."
addsign-wrongProfile: "The specified profile does not exist, use one of the following (check config): [gray]%0%."
addsign-profile:
- "[bold]%0%[/bold]"
- " hover: Signprofile %0%"
- " hover: %lang:action|Use this profile|%"
- " command: /areashop linksigns %0%"
addsign-success: "The sign has been added to %lang:region%."
addsign-successProfile: "The sign has been added to %lang:region% with profile %0%."
addsign-alreadyRegistered: "That sign is already registered for region %lang:region%."
addsign-noPermission: "You don't have permission to add a sign."
delsign-noSign: "You are not looking at a sign."
delsign-noPermission: "You don't have permission to delete a sign."
delsign-noRegion: "That sign does not belong to an AreaShop region."
delsign-success: "The sign has been removed from region %lang:region%."
me-noPermission: "You don't have permission to check which regions you have."
me-header: "Regions of %lang:tPlayer|%0%|%:"
me-notAPlayer: "You are not a player so you can't have any regions."
me-rentLine:
- "[darkgreen][bold]►[reset] %lang:region% [gray]("
- "%timeleft% left"
- " hover: until %until%"
- ")."
me-buyLine: "[darkgreen][bold]►[reset] %lang:region%."
me-friendLine:
- "[darkgreen][bold]►[reset] %lang:region% [gray]("
- "owned by %lang:player%"
- " hover: You are added as friend"
- ")."
me-nothing: "%lang:tPlayer|%0%|% has not rented or bought regions and is not added as friend to one."
me-noPlayer: "%0% cannot be found, probably never joined the server."
me-clickHint: "[gray][italic]Click a region name to see details."
setowner-help: "/as setowner <player> [region], the region you stand in will be used if not specified."
setowner-noPermission: "You don't have permission to set the owner of a region."
setowner-noPermissionRent: "You don't have permission to set the owner of rent regions."
setowner-noPermissionBuy: "You don't have permission to set the owner of buy regions."
setowner-notRegistered: "The specified region is not registered, owner cannot be set."
setowner-noPlayer: "Could not get the UUID of the specified player: %0%."
setowner-succesRent: "Owner of %lang:region% successfully changed to %lang:player%, rented until %until% (%timeleft% left)."
setowner-succesRentExtend: "Owner was already %lang:player%, rent extended with '%duration%', now rented until %until% (%timeleft% left)."
setowner-succesBuy: "Owner of %lang:region% successfully changed to %lang:player%."
resell-help: "/as resell <price> [region], the region you stand in will be used if not specified."
resell-wrongPrice: "'%0%' is not a valid price."
resell-notRegistered: "The specified region is not registered: %0%."
resell-notBought: "You can't resell %lang:region% because it is not sold yet."
resell-success: "%lang:region% is successfully put into reselling mode for %resellprice%."
resell-noPermission: "You don't have permission to set your region in reselling mode."
resell-noPermissionOther: "You don't have permission to set regions in reselling mode."
resell-disabled: "Reselling has been disabled for this region."
stopresell-help: "/as stopresell [region], the region you stand in will be used if not specified."
stopresell-notRegistered: "The specified region is not registered: %0%."
stopresell-notResell: "You can't stop reselling %lang:region% because it is not in resell mode."
stopresell-success: "%lang:region% is successfully put back into sold mode."
stopresell-noPermission: "You don't have permission to set your region back to sold mode."
stopresell-noPermissionOther: "You don't have permission to set regions back to sold mode."
addfriend-help: "/as addfriend <player> [region], the region you stand in will be used if not specified."
addfriend-noPermissionOther: "You don't have permission to add friends to regions that are not yours."
addfriend-noPermission: "You don't have permission to add friends to your region."
addfriend-successOther: "%lang:tPlayer|%0%|% has been added as friend to region %lang:region%."
addfriend-success: "%lang:tPlayer|%0%|% has been added as friend to your region %lang:region%."
addfriend-alreadyAdded: "%lang:tPlayer|%0%|% is already added as friend to %lang:region%."
addfriend-self: "Adding the owner of the region as friend would be pointless."
addfriend-noOwner: "You cannot add friends to a region without owner."
addfriend-notVisited: "You cannot add %0% because he did not visit the server yet."
delfriend-help: "/as delfriend <player> [region], the region you stand in will be used if not specified."
delfriend-noPermissionOther: "You don't have permission to delete friends from regions that are not yours."
delfriend-noPermission: "You don't have permission to delete friends from your region."
delfriend-successOther: "%lang:tPlayer|%0%|% has been deleted as friend from region %lang:region%."
delfriend-success: "%lang:tPlayer|%0%|% has been deleted as friend from your region %lang:region%."
delfriend-notAdded: "%lang:tPlayer|%0%|% is not added as friend to %lang:region%."
delfriend-noOwner: "You cannot remove friends from a region without owner."
linksigns-multipleRegions: "Found multiple regions: [gray]%0%."
linksigns-multipleRegionsAdvice: "Click another time to try again or use '/as linksigns' to stop."
linksigns-noRegions: "No AreaShop regions found in the direction of your cursor, make sure the region is added to AreaShop [gray](maximum range 100 blocks)."
linksigns-regionFound: "Region %lang:region% has been found, now point to a sign and leftclick to link it."
linksigns-signFound: "Found a sign at (%0%, %1%, %2%), now point towards a region and rightclick to link it"
linksigns-noSign: "No sign found in the direction of your cursor, make sure you have a direct sight to a sign and click again [gray](maximum range 100 blocks)."
linksigns-alreadyRegistered: "That sign is already registered for region %lang:region%, click again to select another sign."
linksigns-first: "You have entered sign linking mode."
linksigns-next: "[gray]Leftclick to select a sign, rightclick to select a region, use /as linksigns to stop."
linksigns-noPermission: "You don't have permission to enter bulk sign linking mode."
linksigns-stopped: "Exited sign linking mode."
stack-help:
- "/as stack <amount> <gap> <name> <rent|buy> [group].[break]"
- " [gray]<amount> Number of regions that will be created.[break]"
- " [gray]<gap> Blocks distance between the regions.[break]"
- " [gray]<name> Name of the regions (number will be behind it).[break]"
- " [gray]<rent|buy> Make then rent or buy regions.[break]"
- " [gray][group] A group to add the created regions to.[break]"
- " [gray]The regions will be created in the direction you are facing."
stack-accepted: "Starting to create %0% %1% regions with %2% blocks in between, names start with %3% and have a number behind them.%4%"
stack-addToGroup: " Created regions will be added to the group '%0%'."
stack-noPermission: "You don't have permission to create and add regions to AreaShop in bulk."
stack-wrongAmount: "'%0%' is not a correct amount of regions."
stack-wrongGap: "'%0%' is not a correct number for the number of blocks gap between regions."
stack-noSelection: "You don't have a selection that indicates where the first region should be created."
stack-addStart: "[gray]Adding %0% regions at %1% per second."
stack-addComplete: "[gray]Added %0% regions%1%."
stack-tooHigh: ", %0% regions skipped because they were above Y=256"
stack-tooLow: ", %0% regions skipped because they were below Y=0"
stack-unclearDirection: "Please look clearly in the north, east, south, west, up or down direction, currently detected %0%."
setlandlord-help: "/as setlandlord <player> [region], the region you stand in will be used if not specified."
setlandlord-noPermission: "You don't have permission to set the landlord for a region."
setlandlord-success: "%lang:landlord% has successfully been set as landlord of %lang:region%."
message-help: "/as message <player> <message...>"
message-noPermission: "You do not have permission to send AreaShop messages."
message-notOnline: "%0% is not online."
import-help: "/as import RegionForSale"
import-wrongSource: "Specify from where you want to import data, options: RegionForSale."
import-noPluginFolder: "Could not find the %0% folder, are you sure you are importing from the correct source?"
import-noWorldsFolder: "There is no 'plugins/RegionForSale/worlds' folder, therefore nothing could be imported."
import-confirm: "Are you sure you want to import all regions from RegionForSale?"
import-start: "Starting import of RegionForSale data:"
import-doWorld: "[darkgreen][bold]► World %0%:"
import-noBukkitWorld: "[red]Could not find world in Bukkit."
import-noRegionManager: "[red]Could not get RegionManager from WorldGuard, are regions enabled in this world?"
import-noRegions: "[red]No regions.yml file found."
import-loadRegionsFailed: "[red]Could not load regions.yml at: %0%"
import-invalidRegionSection: "[red]Invalid section in regions.yml: %0%."
import-noWorldGuardRegion: "[red]WorldGuard region not found: %0%."
import-noWorldGuardRegionParent: "[red]WorldGuard region for parent region not found: %0%."
import-buyAndRent: "[gold]%0% can be bought and rented, only adding as buy in AreaShop (cannot be both)."
import-noBuyAndNoRent: "[red]%0% cannot be bought and cannot be rented, skipping import."
import-imported: "[green]%lang:tRegion|%0%|% imported."
import-loadWorldConfigFailed: "[red]Loading world-specific config.yml failed: %0%."
import-improperParentRegion: "[red]Parent region %0% does not have readable settings."
import-alreadyAdded: "[red]Region '%0%' has already been added."
import-alreadyAddedOtherWorld: "[red]Region '%0%' has already been added in world %1%, regions in different worlds cannot have the same name in AreaShop."
import-invalidSignLocation: "[red]Failed to import a sign of region '%0%', invalid location: '%1%'."
import-signAlreadyAdded: "[red]Skipped adding sign at location '%1%' to region '%0%', it is already added to region '%2%'."
import-moneyBackFailed: "[red]Failed to parse buy price '%0%' and sell price '%1%' to set the money back percentage."
confirm-rent:
- "%lang:prefix%Are you sure you want to rent %lang:tRegion|%0%|%?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to rent %0%|%"
- " hover: %lang:action|Rent %0%|%"
- " command: /areashop rent %0%"
confirm-extend:
- "%lang:prefix%Are you sure you want to extend %lang:tRegion|%0%|%?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to extend %0%|%"
- " hover: %lang:action|Extend %0%|%"
- " command: /areashop rent %0%"
confirm-unrent:
- "%lang:prefix%Are you sure you want to stop renting %lang:tRegion|%0%|%?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to stop renting %0%|%"
- " hover: %lang:action|Stop renting %0%|%"
- " command: /areashop unrent %0%"
confirm-buy:
- "%lang:prefix%Are you sure you want to buy %lang:tRegion|%0%|%?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to buy %0%|%"
- " hover: %lang:action|Buy %0%|%"
- " command: /areashop buy %0%"
confirm-sell:
- "%lang:prefix%Are you sure you want to sell %lang:tRegion|%0%|%?[break]"
- "[darkgreen][bold]►[reset] %lang:button|Click to sell %0%|%"
- " hover: %lang:action|Sell %0%|%"
- " command: /areashop sell %0%"
timeleft-years: "%0% years"
timeleft-months: "%0% months"
timeleft-days: "%0% days"
timeleft-hours: "%0% hours"
timeleft-minutes: "%0% minutes"
timeleft-second: "%0% second"
timeleft-seconds: "%0% seconds"
timeleft-ended: "Expired"
greeting-forrent: "%region% can be rented for %price% per %duration%."
greeting-rented: "%region% is rented by %player% until %until%."
greeting-forsale: "%region% can be bought for %price%."
greeting-bought: "%region% is bought by %player%."
greeting-resale: "%region% can be bought for %resellprice% from %player%."
update-playerNotify:
- "[darkgreen]Update from AreaShop V%0% to AreaShop V%1% available, get the latest version at "
- "[bold]Spigot[/bold]"
- " hover: %lang:action|Go to the Spigot AreaShop page|%"
- " link: https://www.spigotmc.org/resources/areashop.2991/"
- " (and leave a review)."
Loaded 100 of 164 files, more files were not shown because too many files have changed in this diff. Show more