using newer release option for compiler plugin

# Conflicts:
#	mvnw

.gitbook.yaml

@@ -0,0 +1,5 @@
+root: ./wiki
+
+structure:
+    readme: README.md 
+    summary: SUMMARY.md

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,30 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior:
+1. Run the command '...'
+2. Click on a mob '....'
+3. See error
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Screenshots**
+If applicable, add screenshots to help explain your problem.
+
+**Software (please complete the following information):**
+ - Server: [e.g. Spigot 1.12]
+ - Plugin version [e.g. 2.12.1]
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/maven.yml

@@ -0,0 +1,37 @@
+# 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: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: true
+      max-parallel: 4
+      matrix:
+        java-version: [ 16, 17 ]
+    runs-on: ubuntu-latest
+    name: Java ${{ matrix.java-version }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      - name: "Set up JDK ${{ matrix.java-version }}"
+        uses: actions/setup-java@v3
+        with:
+          java-version: "${{ matrix.java-version }}"
+          distribution: 'adopt'
+          cache: 'maven'
+      - name: Build with Maven
+        run: ./mvnw -B -U package --file pom.xml
+      - name: Upload Build Artifact
+        if: "${{ matrix.java-version == 16 }}"
+        uses: actions/upload-artifact@v3
+        with:
+          name: SimpleClans
+          path: target/SimpleClans.jar

.github/workflows/publish_curseforge.yml

@@ -0,0 +1,31 @@
+name: Publish to CurseForge
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up JDK 16
+      uses: actions/setup-java@v3
+      with:
+        java-version: 16
+        cache: 'maven'
+        distribution: 'adopt'
+    - name: Build with Maven
+      run: ./mvnw -B package --file pom.xml
+    - name: Upload artifact
+      uses: itsmeow/curseforge-upload@v3
+      with:
+        token: ${{ secrets.CURSEFORGE_TOKEN }}
+        project_id: 380814
+        game_endpoint: minecraft
+        file_path: target/SimpleClans.jar
+        changelog: ${{ github.event.release.body }}
+        changelog_type: markdown
+        display_name: ${{ github.event.release.tag_name }}
+        game_versions: 8849,8503,7915,7667,7330,7105,6588,630,591,585,531
+        release_type: release
+        relations: vault:optionalDependency,worldguard:optionalDependency,grief-prevention:optionalDependency

.github/workflows/publish_modrinth.yml

@@ -0,0 +1,31 @@
+name: Publish to Modrinth
+on:
+  release:
+    types: [created]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up JDK 16
+      uses: actions/setup-java@v3
+      with:
+        java-version: 16
+        cache: 'maven'
+        distribution: 'adopt'
+    - name: Build with Maven
+      run: ./mvnw -B package --file pom.xml
+    - name: Upload artifact
+      uses: RubixDev/modrinth-upload@v1.0.0
+      with:
+        token: ${{ secrets.MODRINTH_TOKEN }}
+        project_id: quLDfyDl
+        file_path: target/SimpleClans.jar
+        changelog: ${{ github.event.release.body }}
+        name: ${{ github.event.release.tag_name }}
+        version: ${{ github.event.release.tag_name }}
+        game_versions: 1.19,1.18,1.17,1.16,1.15,1.14,1.13,1.12,1.11,1.10,1.9,1.8
+        release_type: release
+        loaders: spigot
+        featured: true

.github/workflows/publish_reposilite.yml

@@ -0,0 +1,29 @@
+name: Publish to Reposilite
+on:
+  push:
+    branches:
+      - master
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up JDK 16
+        uses: actions/setup-java@v3
+        with:
+          java-version: 16
+          server-id: reposilite # Value of the distributionManagement/repository/id field of the pom.xml
+          server-username: MAVEN_USERNAME
+          server-password: MAVEN_PASSWORD
+          cache: 'maven'
+          distribution: 'adopt'
+      - name: Build with Maven
+        run: ./mvnw -B package --file pom.xml
+      - name: Publish to Reposilite
+        run: ./mvnw -B deploy
+        env:
+          MAVEN_USERNAME: simpleclans
+          MAVEN_PASSWORD: ${{ secrets.REPOSILITE_TOKEN }}

.github/workflows/release_please.yml

@@ -0,0 +1,15 @@
+on:
+  push:
+    branches:
+      - master
+name: release-please
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: google-github-actions/release-please-action@v3
+        with:
+          release-type: maven
+          package-name: SimpleClans
+          token: ${{ secrets.PAT_TOKEN }}
+          fork: false

.gitignore

@@ -1,3 +1,10 @@
 /target/
 /.idea/
-SimpleClans.iml
+/bin/
+/.classpath
+/.project
+*.jar
+.settings
+.factorypath
+SimpleClans.iml
+dependency-reduced-pom.xml

.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.3/apache-maven-3.9.3-bin.zip
+wrapperUrl=https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar

.travis.yml

@@ -10,6 +10,9 @@ jdk: [openjdk8]
 # if one build failed, exit testing
 matrix:
   fast_finish: true
+  
+addons:
+  artifacts: true
 
 # Disable caching in order to get notified if there are some repo/dependency issues
 ## Cache maven dependencies

CHANGELOG.md

@@ -0,0 +1,105 @@
+# Changelog
+
+## [2.19.0](https://github.com/RoinujNosde/SimpleClans/compare/v2.18.1...v2.19.0) (2023-07-27)
+
+
+### Features
+
+* add %simpleclans_has_rank% placeholder ([#379](https://github.com/RoinujNosde/SimpleClans/issues/379)) ([f8ce0f4](https://github.com/RoinujNosde/SimpleClans/commit/f8ce0f415f17748f8b4382e028dd1f5f93cae06a))
+* add a command to set player's locale ([#378](https://github.com/RoinujNosde/SimpleClans/issues/378)) ([5cf64a6](https://github.com/RoinujNosde/SimpleClans/commit/5cf64a672d0a25a62d3abd6720082bb3b4cf056f))
+* add confirmation before reset kdr ([#371](https://github.com/RoinujNosde/SimpleClans/issues/371)) ([d4f1a74](https://github.com/RoinujNosde/SimpleClans/commit/d4f1a74dee9cdeeb458ff6975715a817bfe30fa1))
+* add PlayerResetKdrEvent ([#370](https://github.com/RoinujNosde/SimpleClans/issues/370)) ([d68ec28](https://github.com/RoinujNosde/SimpleClans/commit/d68ec28f8e14926cbe9d13c09a61735e5304a97d))
+* add subcommand /clan mod bb display ([#367](https://github.com/RoinujNosde/SimpleClans/issues/367)) ([105a8ca](https://github.com/RoinujNosde/SimpleClans/commit/105a8cad51b12bf6f487cf6c2b81eb85d966a3cc))
+* adds the possibility to rename a clan ([#360](https://github.com/RoinujNosde/SimpleClans/issues/360)) ([0f69332](https://github.com/RoinujNosde/SimpleClans/commit/0f693329cae81036bfe1423344ed41cf3d535f64))
+* bb message language key ([#358](https://github.com/RoinujNosde/SimpleClans/issues/358)) ([263d129](https://github.com/RoinujNosde/SimpleClans/commit/263d129325888fb1303dda549986ab43ca93ed13))
+* **chat:** adds permissions to use colors and formats ([#341](https://github.com/RoinujNosde/SimpleClans/issues/341)) ([2a139ab](https://github.com/RoinujNosde/SimpleClans/commit/2a139aba03be174086dfb3603007312d0c7a6c33))
+* EconomyTransactionEvent creation ([#384](https://github.com/RoinujNosde/SimpleClans/issues/384)) ([d21dc02](https://github.com/RoinujNosde/SimpleClans/commit/d21dc02dff45f4f20a40303cd26215a71de7dddb))
+* hide reset kdr in main frame if perm denied ([#385](https://github.com/RoinujNosde/SimpleClans/issues/385)) ([ad6bb7b](https://github.com/RoinujNosde/SimpleClans/commit/ad6bb7b13b347be71789fbfb4b8a82f6c5481c96))
+* validating tag by regex ([#363](https://github.com/RoinujNosde/SimpleClans/issues/363)) ([3ef3169](https://github.com/RoinujNosde/SimpleClans/commit/3ef3169942f897280af15040f1243d955df001ab))
+
+
+### Bug Fixes
+
+* added clan suggestion in staff bb commands ([#359](https://github.com/RoinujNosde/SimpleClans/issues/359)) ([442096e](https://github.com/RoinujNosde/SimpleClans/commit/442096e9da98410682c2cd09e0e930454fe0364f))
+* async permission reset & category deletion ([#347](https://github.com/RoinujNosde/SimpleClans/issues/347)) ([7eb748b](https://github.com/RoinujNosde/SimpleClans/commit/7eb748bb9a31a826f53fd7ac6b1eeac64e330467))
+* bump JDK to 16 ([e368ead](https://github.com/RoinujNosde/SimpleClans/commit/e368ead04aa2735f5525d88d5dcb63b78286f80e))
+* **bungee:** removes players from clan on delete ([0258a75](https://github.com/RoinujNosde/SimpleClans/commit/0258a75c819f12e5dbbaf383a572682717f34c59))
+* **bungee:** updates kills count immediately ([ed243f7](https://github.com/RoinujNosde/SimpleClans/commit/ed243f72ecc58a3af11d053d73b315bce9e20e94))
+* default username-regex ([bf1033a](https://github.com/RoinujNosde/SimpleClans/commit/bf1033af769bacbca9a790d2184ec77eeb519485))
+* **discord:** permission overrides reset only existing members ([#349](https://github.com/RoinujNosde/SimpleClans/issues/349)) ([8a35293](https://github.com/RoinujNosde/SimpleClans/commit/8a3529377f5b4a482b530e474e4921b311197a04))
+* display hex message on bulletin board ([#365](https://github.com/RoinujNosde/SimpleClans/issues/365)) ([0b74355](https://github.com/RoinujNosde/SimpleClans/commit/0b74355467625a4901944c72feb84d8de91a4283))
+* invalid colors being used in tags ([2850e59](https://github.com/RoinujNosde/SimpleClans/commit/2850e59d370da34c643de198de85d91744610467))
+* invalid colors being used in tags, pt. 2 ([f98868c](https://github.com/RoinujNosde/SimpleClans/commit/f98868c776a2e275dc7c1647748a0231e935f43e))
+* migrates land permissions on GP claim resize ([2f4ad00](https://github.com/RoinujNosde/SimpleClans/commit/2f4ad00f1c72ee7e3948267965c3a075ec4ef728))
+* NPE on EntityDamageByEntityEvent listener (LandProtection) ([524e407](https://github.com/RoinujNosde/SimpleClans/commit/524e40762011dd500a407286b72b51acf6c357f3))
+* players not able to break vehicles/exit horses ([86d4fac](https://github.com/RoinujNosde/SimpleClans/commit/86d4fac938e353f94c288c39b884027027972bba))
+* players not able to sleep on beds (WorldGuard) ([e9ec283](https://github.com/RoinujNosde/SimpleClans/commit/e9ec283ace55af10abdeb6f937d31d4c2dc198dc))
+* players not able to strip logs/fertilize blocks ([5021b8a](https://github.com/RoinujNosde/SimpleClans/commit/5021b8ad7b5633769bd87af96a0226a53a8b24b4))
+* players not able to use water buckets (WorldGuard) ([807d39a](https://github.com/RoinujNosde/SimpleClans/commit/807d39afeb51d99a96fb793099393b44e2c43b04))
+* players unable to interact with armor stands, paintings, etc ([61dcb3d](https://github.com/RoinujNosde/SimpleClans/commit/61dcb3d440e2eedfb717afcc69687194311a8973))
+* possibly fixes CME on SpyChatHandler ([8a05dbb](https://github.com/RoinujNosde/SimpleClans/commit/8a05dbbf00df97afa7df71a500e2626aaa46ed37))
+* prevent clan name renaming with colors ([#374](https://github.com/RoinujNosde/SimpleClans/issues/374)) ([7fcb964](https://github.com/RoinujNosde/SimpleClans/commit/7fcb964f41118e7d8746e87d5770cc329730834c))
+* remove abandoned channels before validating ([#348](https://github.com/RoinujNosde/SimpleClans/issues/348)) ([5f519c4](https://github.com/RoinujNosde/SimpleClans/commit/5f519c477af3e759596017010d51ddd06e26157e))
+* resets error message when validating a clan tag ([#383](https://github.com/RoinujNosde/SimpleClans/issues/383)) ([8269d80](https://github.com/RoinujNosde/SimpleClans/commit/8269d80831533e517ed2ebd94bec18021de7b0e3))
+* sets duplicate names to something unique ([046aa1d](https://github.com/RoinujNosde/SimpleClans/commit/046aa1d96d58e21496a3361c7d072f3943595304))
+* tnt explosion doesn't count a kill ([#381](https://github.com/RoinujNosde/SimpleClans/issues/381)) ([57b9987](https://github.com/RoinujNosde/SimpleClans/commit/57b9987e9b9dade59c52c88dbfd3b12fdf5eee94))
+* view permission applies only to cached channels ([#346](https://github.com/RoinujNosde/SimpleClans/issues/346)) ([1850701](https://github.com/RoinujNosde/SimpleClans/commit/18507016a843c28efc6d8109f2bb5a5106531f47))
+
+
+### Performance Improvements
+
+* **discord:** remove discord channels from creation ([#353](https://github.com/RoinujNosde/SimpleClans/issues/353)) ([36084db](https://github.com/RoinujNosde/SimpleClans/commit/36084dbfa3e73aedccb156e49af5062e40639927))
+
+
+### Documentation
+
+* author tag isn't available at methods ([f5d547a](https://github.com/RoinujNosde/SimpleClans/commit/f5d547ab27fac7cfe1abd9c819e4f1bb3dd7c624))
+* updated version in README ([#343](https://github.com/RoinujNosde/SimpleClans/issues/343)) ([718868b](https://github.com/RoinujNosde/SimpleClans/commit/718868b2d9eea2aeb6fcfd734e85d16a2cefaa36))
+
+## [2.18.1](https://github.com/RoinujNosde/SimpleClans/compare/v2.18.0...v2.18.1) (2022-11-29)
+
+
+### Bug Fixes
+
+* added check for clan_member on land commands ([fc81e76](https://github.com/RoinujNosde/SimpleClans/commit/fc81e765211bebe22a7a6aa5d5158754580bbdc5))
+* attempt at fixing NPE on getAllClanPlayers ([26ba9f7](https://github.com/RoinujNosde/SimpleClans/commit/26ba9f73296a772eaa698d2ede6fbc3831da850c))
+* **bungee:** error deserializing clan banners ([56c7908](https://github.com/RoinujNosde/SimpleClans/commit/56c7908c332167cec9cca6a4ea054977d0d68b9f))
+* channel auto creation setting not respected on join/link ([7f9d133](https://github.com/RoinujNosde/SimpleClans/commit/7f9d133051b9011837d0a5114abc6c3637a3f02c))
+* default ranks were getting re-added on config load ([7a37382](https://github.com/RoinujNosde/SimpleClans/commit/7a37382264ff4dd5456f6930045b5102bf491897))
+* missing getHandlerList on HomeRegroupEvent ([#338](https://github.com/RoinujNosde/SimpleClans/issues/338)) ([8fa465d](https://github.com/RoinujNosde/SimpleClans/commit/8fa465da385f36b1fb075031c375ef94df78ea52))
+* money was not given back when channel creation failed ([#336](https://github.com/RoinujNosde/SimpleClans/issues/336)) ([d8cb61b](https://github.com/RoinujNosde/SimpleClans/commit/d8cb61b0fc9584bb58f421faf98596816621053f))
+* wrong path of discord economy section ([#334](https://github.com/RoinujNosde/SimpleClans/issues/334)) ([3f1b06d](https://github.com/RoinujNosde/SimpleClans/commit/3f1b06dcf996e51a878b7fc281069e236ebcbfce))
+
+## [2.18.0](https://github.com/RoinujNosde/SimpleClans/compare/v2.17.0...v2.18.0) (2022-10-14)
+
+
+### Features
+
+* add help-size config ([25197cd](https://github.com/RoinujNosde/SimpleClans/commit/25197cdd729cea63d7e223dc1e0aaef830613327))
+* added method for registering protection providers ([2ea7444](https://github.com/RoinujNosde/SimpleClans/commit/2ea744443f502970b15859818e9d5e45ca69d453))
+* adds permission to bypass the teleport delay ([d56a0a9](https://github.com/RoinujNosde/SimpleClans/commit/d56a0a979a47a140115742518e934a2469e6f880))
+* adds PlayerHomeClearEvent ([becb88b](https://github.com/RoinujNosde/SimpleClans/commit/becb88b763380bed5a2e1dd209c32c8363a7f88b))
+* adds starter-ranks ([a440834](https://github.com/RoinujNosde/SimpleClans/commit/a4408343479d7efa6ae5a65894f8b822ecd47ebb))
+* Improves Bungee support ([#327](https://github.com/RoinujNosde/SimpleClans/issues/327)) ([2c9b0f9](https://github.com/RoinujNosde/SimpleClans/commit/2c9b0f98fe3942ea74190c1a81d61be2c8647db8))
+* **lang:** new crowdin updates ([#319](https://github.com/RoinujNosde/SimpleClans/issues/319)) ([87ece22](https://github.com/RoinujNosde/SimpleClans/commit/87ece22036fb674c8c362b6a1b86fe884543e6ad))
+
+
+### Bug Fixes
+
+* changes size of some frames for better visualization on Bedrock ([1adec0b](https://github.com/RoinujNosde/SimpleClans/commit/1adec0b89d676767cdb94dcdf91ba37a231eb4a8))
+* ConfigurationSerializableAdapter NPE ([30a501c](https://github.com/RoinujNosde/SimpleClans/commit/30a501c063aa9dbcf596df83adc2b15baf0e4bb9))
+* getPastClans() preserves the insertion order ([af07988](https://github.com/RoinujNosde/SimpleClans/commit/af079881030bd299b9bae1ebf0cc62353af7e6fc))
+* NoClassDefFoundError in WorldGuard6Provider ([a859928](https://github.com/RoinujNosde/SimpleClans/commit/a8599286225ba603ea124b8b52510245b94ffd24))
+* NPE while collecting fees ([c47289c](https://github.com/RoinujNosde/SimpleClans/commit/c47289c5bf8113a9d6a8e1ee74a5afb0358647b6))
+* NPE while purging data ([f14c425](https://github.com/RoinujNosde/SimpleClans/commit/f14c42548846feef01b484acbb5f02bcbcabd8db))
+* NPE while sending a message to spies ([#322](https://github.com/RoinujNosde/SimpleClans/issues/322)) ([e7f756f](https://github.com/RoinujNosde/SimpleClans/commit/e7f756f3063c646e21415e08eea73f123d2818a0))
+* removes duplicate /clan from help ([f7e7ec6](https://github.com/RoinujNosde/SimpleClans/commit/f7e7ec66243359e26d3c456a9740a53753951c48))
+* removes rank and join date on disband ([2a1ad5b](https://github.com/RoinujNosde/SimpleClans/commit/2a1ad5b5c8d2937a8ee6dd6f7f43d85c86f08307))
+* set useSSL to false ([f484bc1](https://github.com/RoinujNosde/SimpleClans/commit/f484bc16c6176ccd13e05aae2169400e7bcf5d62))
+* supports '.' and '*' as username prefix by default ([37f0ecf](https://github.com/RoinujNosde/SimpleClans/commit/37f0ecff506d06f3047e3598848117a14c2b7ead))
+* updates join date when joining a clan ([#326](https://github.com/RoinujNosde/SimpleClans/issues/326)) ([96a13d8](https://github.com/RoinujNosde/SimpleClans/commit/96a13d8d6cc18c91d4dee20dd632cd5d65db5213))
+
+
+### Performance Improvements
+
+* improved UUID lookup performance ([4ab53d1](https://github.com/RoinujNosde/SimpleClans/commit/4ab53d16135ecf5a4067b1a63d058da392dc5313))

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,15 +1,85 @@
+[![SimpleClans Logo](https://i.imgur.com/9vgfVdX.png)](https://www.spigotmc.org/resources/simpleclans.71242/)
+
 SimpleClans
 ==========
 
-Full featured clan system for PVP Minecraft Servers
+Full featured clan system for PVP Minecraft Servers!
 
-[![Build Status](https://travis-ci.org/marcelo-mason/SimpleClans.svg)](https://travis-ci.org/marcelo-mason/SimpleClans)
-[![Download](https://img.shields.io/badge/snapshot-download-blue.svg)](https://github.com/marcelo-mason/SimpleClans/releases)
-[![Issues](https://img.shields.io/github/issues/marcelo-mason/SimpleClans.svg)](https://github.com/marcelo-mason/SimpleClans/issues)
-[![ghit.me](https://ghit.me/badge.svg?repo=marcelo-mason/SimpleClans)](https://ghit.me/repo/marcelo-mason/SimpleClans)
+[![Build Status](https://img.shields.io/jenkins/build?jobUrl=https%3A%2F%2Fci.roinujnosde.me%2Fjob%2FSimpleClans%2F)](https://ci.roinujnosde.me/job/SimpleClans/)
+[![Spiget Downloads](https://img.shields.io/spiget/downloads/71242)](https://www.spigotmc.org/resources/simpleclans.71242/)
+[![Issues](https://img.shields.io/github/issues/RoinujNosde/SimpleClans.svg)](https://github.com/RoinujNosde/SimpleClans/issues)
+[![Crowdin](https://badges.crowdin.net/simpleclans/localized.svg)](https://crowdin.com/project/simpleclans)
+[![Discord](https://img.shields.io/discord/719557355917934613?label=discord&logo=discord)](https://discord.gg/CkNwgdE)
+[![bStats Servers](https://img.shields.io/bstats/servers/7131)](https://bstats.org/plugin/bukkit/SimpleClans/7131)
+[![bStats Players](https://img.shields.io/bstats/players/7131)](https://bstats.org/plugin/bukkit/SimpleClans/7131)
 
-## Disclaimer:
 
-Active development for this plugin has stopped.  It is in maintenance mode and will continue to be kept up to date as-is with any new Minecraft version indefinitely.
+#### Download Link
 
-Pull-requests for bug fixes or new features are welcomed and will be merged in if they do not break existing functionalities.
+* [Download from Spigot](https://www.spigotmc.org/resources/simpleclans.71242/)
+
+#### Documentation 
+
+* [Documentation](https://simpleclans.gitbook.io/simpleclans/)
+* Commands & Permissions
+  * [Permissions](https://simpleclans.gitbook.io/simpleclans/commands-and-permissions/permissions)
+  * [Commands](https://simpleclans.gitbook.io/simpleclans/commands-and-permissions/commands)
+  * [Clan Alliances and Rivalries](https://simpleclans.gitbook.io/simpleclans/commands-and-permissions/aliances-and-rivalries)
+  * [Clan Ranks with Permissions](https://simpleclans.gitbook.io/simpleclans/commands-and-permissions/ranks-with-permissions)
+* How to Setup
+  * [Configuration](https://simpleclans.gitbook.io/simpleclans/how-to-setup/configuration)
+  * [Translation](https://simpleclans.gitbook.io/simpleclans/how-to-setup/translation)
+  * [Clan Member Fee](https://simpleclans.gitbook.io/simpleclans/how-to-setup/member-fee)
+  * [Clan Upkeep](https://simpleclans.gitbook.io/simpleclans/how-to-setup/clan-upkeep)
+  * [Clan name above players head](https://simpleclans.gitbook.io/simpleclans/how-to-setup/clan-below-players-name)
+  * [Clan name on Tablist](https://simpleclans.gitbook.io/simpleclans/how-to-setup/clan-on-tablist)
+* Plugins & Development 
+  * [SimpleClans API Example](https://simpleclans.gitbook.io/simpleclans/other/simpleclans-api)
+  * [PlaceholderAPI Placeholders](https://simpleclans.gitbook.io/simpleclans/other/placeholderapi-support)
+  * [Land Protection Plugins](https://simpleclans.gitbook.io/simpleclans/other/land-claims)
+  
+#### Support & Suggestions
+
+* [Discord Support](https://discord.gg/CkNwgdE)
+* [Bugs and Suggestions](https://github.com/RoinujNosde/SimpleClans/issues)
+
+
+#### Developers
+
+Including SimpleClans with Maven:
+```xml
+<repositories>
+    <repository>
+        <id>roinujnosde-repo</id>
+        <url>https://repo.roinujnosde.me/releases/</url>
+    </repository>
+</repositories>
+```
+```xml
+<dependencies>
+    <dependency>
+        <groupId>net.sacredlabyrinth.phaed.simpleclans</groupId>
+        <artifactId>SimpleClans</artifactId>
+        <version>2.18.1</version> <!-- You can find the latest version at the bottom -->
+        <scope>provided</scope>
+    </dependency>
+</dependencies>
+```
+
+Using Gradle:
+```groovy
+repositories {
+    maven {
+        url  "https://repo.roinujnosde.me/releases/" 
+    }
+}
+dependencies {
+    compileOnly "net.sacredlabyrinth.phaed.simpleclans:SimpleClans:2.18.1"
+}
+```
+
+Feel free to learn our [Javadoc](https://ci.roinujnosde.me/job/SimpleClans/Javadoc/).
+##### Latest version:
+[![Maven metadata URL](https://img.shields.io/maven-metadata/v?metadataUrl=https%3A%2F%2Frepo.roinujnosde.me%2Freleases%2Fnet%2Fsacredlabyrinth%2Fphaed%2Fsimpleclans%2FSimpleClans%2Fmaven-metadata.xml)](https://repo.roinujnosde.me/#/releases/net/sacredlabyrinth/phaed/simpleclans/SimpleClans)
+##### API Examples
+* [Examples of how to use the API](https://simpleclans.gitbook.io/simpleclans/other/simpleclans-api)

SimpleClans.iml

@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module org.jetbrains.idea.maven.project.MavenProjectsManager.isMavenModule="true" type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" LANGUAGE_LEVEL="JDK_1_7" inherit-compiler-output="false">
-    <output url="file://$MODULE_DIR$/target/classes" />
-    <output-test url="file://$MODULE_DIR$/target/test-classes" />
-    <content url="file://$MODULE_DIR$">
-      <sourceFolder url="file://$MODULE_DIR$/src/main/java" isTestSource="false" />
-      <sourceFolder url="file://$MODULE_DIR$/src/main/resources" type="java-resource" />
-      <excludeFolder url="file://$MODULE_DIR$/target" />
-    </content>
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: org.bukkit:bukkit:1.9-R0.1-SNAPSHOT" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: commons-lang:commons-lang:2.6" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: com.googlecode.json-simple:json-simple:1.1.1" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: junit:junit:4.10" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: org.hamcrest:hamcrest-core:1.1" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: com.google.guava:guava:17.0" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: com.google.code.gson:gson:2.2.4" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: org.avaje:ebean:2.8.1" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: javax.persistence:persistence-api:1.0" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: org.yaml:snakeyaml:1.15" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: net.milkbowl.vault:VaultAPI:1.4" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: com.nijikokun.bukkit:Permissions:2.7.4" level="project" />
-    <orderEntry type="library" scope="PROVIDED" name="Maven: net.sacredlabyrinth.Phaed:PreciousStones:9.7.0" level="project" />
-    <orderEntry type="library" name="Maven: org.getspout:spoutplugin:dev-SNAPSHOT" level="project" />
-  </component>
-</module>

co/aikar/commands/annotations.xml

@@ -0,0 +1,11 @@
+<root>
+    <item name='co.aikar.commands.BukkitCommandCompletionContext org.bukkit.entity.Player getPlayer()'>
+        <annotation name='org.jetbrains.annotations.Nullable'/>
+    </item>
+    <item name='co.aikar.commands.BukkitCommandExecutionContext org.bukkit.entity.Player getPlayer()'>
+        <annotation name='org.jetbrains.annotations.Nullable'/>
+    </item>
+    <item name='co.aikar.commands.BukkitCommandIssuer org.bukkit.entity.Player getPlayer()'>
+        <annotation name='org.jetbrains.annotations.Nullable'/>
+    </item>
+</root>

crowdin.yml

@@ -0,0 +1,7 @@
+pull_request_title: "feat(lang): new crowdin updates"
+pull_request_labels: ["l10n"]
+commit_message: "feat(lang): new translations for %language%"
+append_commit_message: false
+files:
+  - source: src/main/resources/messages.properties
+    translation: /src/main/resources/%file_name%_%locale_with_underscore%.%file_extension%

mvnw

@@ -0,0 +1,308 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.2.0
+#
+# Required ENV vars:
+# ------------------
+#   JAVA_HOME - location of a JDK home dir
+#
+# Optional ENV vars
+# -----------------
+#   MAVEN_OPTS - parameters passed to the Java VM when running Maven
+#     e.g. to debug Maven itself, use
+#       set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+#   MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+# ----------------------------------------------------------------------------
+
+if [ -z "$MAVEN_SKIP_RC" ] ; then
+
+  if [ -f /usr/local/etc/mavenrc ] ; then
+    . /usr/local/etc/mavenrc
+  fi
+
+  if [ -f /etc/mavenrc ] ; then
+    . /etc/mavenrc
+  fi
+
+  if [ -f "$HOME/.mavenrc" ] ; then
+    . "$HOME/.mavenrc"
+  fi
+
+fi
+
+# OS specific support.  $var _must_ be set to either true or false.
+cygwin=false;
+darwin=false;
+mingw=false
+case "$(uname)" in
+  CYGWIN*) cygwin=true ;;
+  MINGW*) mingw=true;;
+  Darwin*) darwin=true
+    # Use /usr/libexec/java_home if available, otherwise fall back to /Library/Java/Home
+    # See https://developer.apple.com/library/mac/qa/qa1170/_index.html
+    if [ -z "$JAVA_HOME" ]; then
+      if [ -x "/usr/libexec/java_home" ]; then
+        JAVA_HOME="$(/usr/libexec/java_home)"; export JAVA_HOME
+      else
+        JAVA_HOME="/Library/Java/Home"; export JAVA_HOME
+      fi
+    fi
+    ;;
+esac
+
+if [ -z "$JAVA_HOME" ] ; then
+  if [ -r /etc/gentoo-release ] ; then
+    JAVA_HOME=$(java-config --jre-home)
+  fi
+fi
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched
+if $cygwin ; then
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=$(cygpath --unix "$JAVA_HOME")
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=$(cygpath --path --unix "$CLASSPATH")
+fi
+
+# For Mingw, ensure paths are in UNIX format before anything is touched
+if $mingw ; then
+  [ -n "$JAVA_HOME" ] && [ -d "$JAVA_HOME" ] &&
+    JAVA_HOME="$(cd "$JAVA_HOME" || (echo "cannot cd into $JAVA_HOME."; exit 1); pwd)"
+fi
+
+if [ -z "$JAVA_HOME" ]; then
+  javaExecutable="$(which javac)"
+  if [ -n "$javaExecutable" ] && ! [ "$(expr "\"$javaExecutable\"" : '\([^ ]*\)')" = "no" ]; then
+    # readlink(1) is not available as standard on Solaris 10.
+    readLink=$(which readlink)
+    if [ ! "$(expr "$readLink" : '\([^ ]*\)')" = "no" ]; then
+      if $darwin ; then
+        javaHome="$(dirname "\"$javaExecutable\"")"
+        javaExecutable="$(cd "\"$javaHome\"" && pwd -P)/javac"
+      else
+        javaExecutable="$(readlink -f "\"$javaExecutable\"")"
+      fi
+      javaHome="$(dirname "\"$javaExecutable\"")"
+      javaHome=$(expr "$javaHome" : '\(.*\)/bin')
+      JAVA_HOME="$javaHome"
+      export JAVA_HOME
+    fi
+  fi
+fi
+
+if [ -z "$JAVACMD" ] ; then
+  if [ -n "$JAVA_HOME"  ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+    fi
+  else
+    JAVACMD="$(\unset -f command 2>/dev/null; \command -v java)"
+  fi
+fi
+
+if [ ! -x "$JAVACMD" ] ; then
+  echo "Error: JAVA_HOME is not defined correctly." >&2
+  echo "  We cannot execute $JAVACMD" >&2
+  exit 1
+fi
+
+if [ -z "$JAVA_HOME" ] ; then
+  echo "Warning: JAVA_HOME environment variable is not set."
+fi
+
+# traverses directory structure from process work directory to filesystem root
+# first directory with .mvn subdirectory is considered project base directory
+find_maven_basedir() {
+  if [ -z "$1" ]
+  then
+    echo "Path not specified to find_maven_basedir"
+    return 1
+  fi
+
+  basedir="$1"
+  wdir="$1"
+  while [ "$wdir" != '/' ] ; do
+    if [ -d "$wdir"/.mvn ] ; then
+      basedir=$wdir
+      break
+    fi
+    # workaround for JBEAP-8937 (on Solaris 10/Sparc)
+    if [ -d "${wdir}" ]; then
+      wdir=$(cd "$wdir/.." || exit 1; pwd)
+    fi
+    # end of workaround
+  done
+  printf '%s' "$(cd "$basedir" || exit 1; pwd)"
+}
+
+# concatenates all lines of a file
+concat_lines() {
+  if [ -f "$1" ]; then
+    # Remove \r in case we run on Windows within Git Bash
+    # and check out the repository with auto CRLF management
+    # enabled. Otherwise, we may read lines that are delimited with
+    # \r\n and produce $'-Xarg\r' rather than -Xarg due to word
+    # splitting rules.
+    tr -s '\r\n' ' ' < "$1"
+  fi
+}
+
+log() {
+  if [ "$MVNW_VERBOSE" = true ]; then
+    printf '%s\n' "$1"
+  fi
+}
+
+BASE_DIR=$(find_maven_basedir "$(dirname "$0")")
+if [ -z "$BASE_DIR" ]; then
+  exit 1;
+fi
+
+MAVEN_PROJECTBASEDIR=${MAVEN_BASEDIR:-"$BASE_DIR"}; export MAVEN_PROJECTBASEDIR
+log "$MAVEN_PROJECTBASEDIR"
+
+##########################################################################################
+# Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+# This allows using the maven wrapper in projects that prohibit checking in binary data.
+##########################################################################################
+wrapperJarPath="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar"
+if [ -r "$wrapperJarPath" ]; then
+    log "Found $wrapperJarPath"
+else
+    log "Couldn't find $wrapperJarPath, downloading it ..."
+
+    if [ -n "$MVNW_REPOURL" ]; then
+      wrapperUrl="$MVNW_REPOURL/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+    else
+      wrapperUrl="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+    fi
+    while IFS="=" read -r key value; do
+      # Remove '\r' from value to allow usage on windows as IFS does not consider '\r' as a separator ( considers space, tab, new line ('\n'), and custom '=' )
+      safeValue=$(echo "$value" | tr -d '\r')
+      case "$key" in (wrapperUrl) wrapperUrl="$safeValue"; break ;;
+      esac
+    done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+    log "Downloading from: $wrapperUrl"
+
+    if $cygwin; then
+      wrapperJarPath=$(cygpath --path --windows "$wrapperJarPath")
+    fi
+
+    if command -v wget > /dev/null; then
+        log "Found wget ... using wget"
+        [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--quiet"
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            wget $QUIET "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        else
+            wget $QUIET --http-user="$MVNW_USERNAME" --http-password="$MVNW_PASSWORD" "$wrapperUrl" -O "$wrapperJarPath" || rm -f "$wrapperJarPath"
+        fi
+    elif command -v curl > /dev/null; then
+        log "Found curl ... using curl"
+        [ "$MVNW_VERBOSE" = true ] && QUIET="" || QUIET="--silent"
+        if [ -z "$MVNW_USERNAME" ] || [ -z "$MVNW_PASSWORD" ]; then
+            curl $QUIET -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+        else
+            curl $QUIET --user "$MVNW_USERNAME:$MVNW_PASSWORD" -o "$wrapperJarPath" "$wrapperUrl" -f -L || rm -f "$wrapperJarPath"
+        fi
+    else
+        log "Falling back to using Java to download"
+        javaSource="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.java"
+        javaClass="$MAVEN_PROJECTBASEDIR/.mvn/wrapper/MavenWrapperDownloader.class"
+        # For Cygwin, switch paths to Windows format before running javac
+        if $cygwin; then
+          javaSource=$(cygpath --path --windows "$javaSource")
+          javaClass=$(cygpath --path --windows "$javaClass")
+        fi
+        if [ -e "$javaSource" ]; then
+            if [ ! -e "$javaClass" ]; then
+                log " - Compiling MavenWrapperDownloader.java ..."
+                ("$JAVA_HOME/bin/javac" "$javaSource")
+            fi
+            if [ -e "$javaClass" ]; then
+                log " - Running MavenWrapperDownloader.java ..."
+                ("$JAVA_HOME/bin/java" -cp .mvn/wrapper MavenWrapperDownloader "$wrapperUrl" "$wrapperJarPath") || rm -f "$wrapperJarPath"
+            fi
+        fi
+    fi
+fi
+##########################################################################################
+# End of extension
+##########################################################################################
+
+# If specified, validate the SHA-256 sum of the Maven wrapper jar file
+wrapperSha256Sum=""
+while IFS="=" read -r key value; do
+  case "$key" in (wrapperSha256Sum) wrapperSha256Sum=$value; break ;;
+  esac
+done < "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.properties"
+if [ -n "$wrapperSha256Sum" ]; then
+  wrapperSha256Result=false
+  if command -v sha256sum > /dev/null; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | sha256sum -c > /dev/null 2>&1; then
+      wrapperSha256Result=true
+    fi
+  elif command -v shasum > /dev/null; then
+    if echo "$wrapperSha256Sum  $wrapperJarPath" | shasum -a 256 -c > /dev/null 2>&1; then
+      wrapperSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available."
+    echo "Please install either command, or disable validation by removing 'wrapperSha256Sum' from your maven-wrapper.properties."
+    exit 1
+  fi
+  if [ $wrapperSha256Result = false ]; then
+    echo "Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised." >&2
+    echo "Investigate or delete $wrapperJarPath to attempt a clean download." >&2
+    echo "If you updated your Maven version, you need to update the specified wrapperSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+MAVEN_OPTS="$(concat_lines "$MAVEN_PROJECTBASEDIR/.mvn/jvm.config") $MAVEN_OPTS"
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin; then
+  [ -n "$JAVA_HOME" ] &&
+    JAVA_HOME=$(cygpath --path --windows "$JAVA_HOME")
+  [ -n "$CLASSPATH" ] &&
+    CLASSPATH=$(cygpath --path --windows "$CLASSPATH")
+  [ -n "$MAVEN_PROJECTBASEDIR" ] &&
+    MAVEN_PROJECTBASEDIR=$(cygpath --path --windows "$MAVEN_PROJECTBASEDIR")
+fi
+
+# Provide a "standardized" way to retrieve the CLI args that will
+# work with both Windows and non-Windows executions.
+MAVEN_CMD_LINE_ARGS="$MAVEN_CONFIG $*"
+export MAVEN_CMD_LINE_ARGS
+
+WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+# shellcheck disable=SC2086 # safe args
+exec "$JAVACMD" \
+  $MAVEN_OPTS \
+  $MAVEN_DEBUG_OPTS \
+  -classpath "$MAVEN_PROJECTBASEDIR/.mvn/wrapper/maven-wrapper.jar" \
+  "-Dmaven.multiModuleProjectDirectory=${MAVEN_PROJECTBASEDIR}" \
+  ${WRAPPER_LAUNCHER} $MAVEN_CONFIG "$@"

mvnw.cmd

@@ -0,0 +1,205 @@
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.2.0
+@REM
+@REM Required ENV vars:
+@REM JAVA_HOME - location of a JDK home dir
+@REM
+@REM Optional ENV vars
+@REM MAVEN_BATCH_ECHO - set to 'on' to enable the echoing of the batch commands
+@REM MAVEN_BATCH_PAUSE - set to 'on' to wait for a keystroke before ending
+@REM MAVEN_OPTS - parameters passed to the Java VM when running Maven
+@REM     e.g. to debug Maven itself, use
+@REM set MAVEN_OPTS=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=8000
+@REM MAVEN_SKIP_RC - flag to disable loading of mavenrc files
+@REM ----------------------------------------------------------------------------
+
+@REM Begin all REM lines with '@' in case MAVEN_BATCH_ECHO is 'on'
+@echo off
+@REM set title of command window
+title %0
+@REM enable echoing by setting MAVEN_BATCH_ECHO to 'on'
+@if "%MAVEN_BATCH_ECHO%" == "on"  echo %MAVEN_BATCH_ECHO%
+
+@REM set %HOME% to equivalent of $HOME
+if "%HOME%" == "" (set "HOME=%HOMEDRIVE%%HOMEPATH%")
+
+@REM Execute a user defined script before this one
+if not "%MAVEN_SKIP_RC%" == "" goto skipRcPre
+@REM check for pre script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_pre.bat" call "%USERPROFILE%\mavenrc_pre.bat" %*
+if exist "%USERPROFILE%\mavenrc_pre.cmd" call "%USERPROFILE%\mavenrc_pre.cmd" %*
+:skipRcPre
+
+@setlocal
+
+set ERROR_CODE=0
+
+@REM To isolate internal variables from possible post scripts, we use another setlocal
+@setlocal
+
+@REM ==== START VALIDATION ====
+if not "%JAVA_HOME%" == "" goto OkJHome
+
+echo.
+echo Error: JAVA_HOME not found in your environment. >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+:OkJHome
+if exist "%JAVA_HOME%\bin\java.exe" goto init
+
+echo.
+echo Error: JAVA_HOME is set to an invalid directory. >&2
+echo JAVA_HOME = "%JAVA_HOME%" >&2
+echo Please set the JAVA_HOME variable in your environment to match the >&2
+echo location of your Java installation. >&2
+echo.
+goto error
+
+@REM ==== END VALIDATION ====
+
+:init
+
+@REM Find the project base dir, i.e. the directory that contains the folder ".mvn".
+@REM Fallback to current working directory if not found.
+
+set MAVEN_PROJECTBASEDIR=%MAVEN_BASEDIR%
+IF NOT "%MAVEN_PROJECTBASEDIR%"=="" goto endDetectBaseDir
+
+set EXEC_DIR=%CD%
+set WDIR=%EXEC_DIR%
+:findBaseDir
+IF EXIST "%WDIR%"\.mvn goto baseDirFound
+cd ..
+IF "%WDIR%"=="%CD%" goto baseDirNotFound
+set WDIR=%CD%
+goto findBaseDir
+
+:baseDirFound
+set MAVEN_PROJECTBASEDIR=%WDIR%
+cd "%EXEC_DIR%"
+goto endDetectBaseDir
+
+:baseDirNotFound
+set MAVEN_PROJECTBASEDIR=%EXEC_DIR%
+cd "%EXEC_DIR%"
+
+:endDetectBaseDir
+
+IF NOT EXIST "%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config" goto endReadAdditionalConfig
+
+@setlocal EnableExtensions EnableDelayedExpansion
+for /F "usebackq delims=" %%a in ("%MAVEN_PROJECTBASEDIR%\.mvn\jvm.config") do set JVM_CONFIG_MAVEN_PROPS=!JVM_CONFIG_MAVEN_PROPS! %%a
+@endlocal & set JVM_CONFIG_MAVEN_PROPS=%JVM_CONFIG_MAVEN_PROPS%
+
+:endReadAdditionalConfig
+
+SET MAVEN_JAVA_EXE="%JAVA_HOME%\bin\java.exe"
+set WRAPPER_JAR="%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.jar"
+set WRAPPER_LAUNCHER=org.apache.maven.wrapper.MavenWrapperMain
+
+set WRAPPER_URL="https://repo.maven.apache.org/maven2/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperUrl" SET WRAPPER_URL=%%B
+)
+
+@REM Extension to allow automatically downloading the maven-wrapper.jar from Maven-central
+@REM This allows using the maven wrapper in projects that prohibit checking in binary data.
+if exist %WRAPPER_JAR% (
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Found %WRAPPER_JAR%
+    )
+) else (
+    if not "%MVNW_REPOURL%" == "" (
+        SET WRAPPER_URL="%MVNW_REPOURL%/org/apache/maven/wrapper/maven-wrapper/3.2.0/maven-wrapper-3.2.0.jar"
+    )
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Couldn't find %WRAPPER_JAR%, downloading it ...
+        echo Downloading from: %WRAPPER_URL%
+    )
+
+    powershell -Command "&{"^
+		"$webclient = new-object System.Net.WebClient;"^
+		"if (-not ([string]::IsNullOrEmpty('%MVNW_USERNAME%') -and [string]::IsNullOrEmpty('%MVNW_PASSWORD%'))) {"^
+		"$webclient.Credentials = new-object System.Net.NetworkCredential('%MVNW_USERNAME%', '%MVNW_PASSWORD%');"^
+		"}"^
+		"[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12; $webclient.DownloadFile('%WRAPPER_URL%', '%WRAPPER_JAR%')"^
+		"}"
+    if "%MVNW_VERBOSE%" == "true" (
+        echo Finished downloading %WRAPPER_JAR%
+    )
+)
+@REM End of extension
+
+@REM If specified, validate the SHA-256 sum of the Maven wrapper jar file
+SET WRAPPER_SHA_256_SUM=""
+FOR /F "usebackq tokens=1,2 delims==" %%A IN ("%MAVEN_PROJECTBASEDIR%\.mvn\wrapper\maven-wrapper.properties") DO (
+    IF "%%A"=="wrapperSha256Sum" SET WRAPPER_SHA_256_SUM=%%B
+)
+IF NOT %WRAPPER_SHA_256_SUM%=="" (
+    powershell -Command "&{"^
+       "$hash = (Get-FileHash \"%WRAPPER_JAR%\" -Algorithm SHA256).Hash.ToLower();"^
+       "If('%WRAPPER_SHA_256_SUM%' -ne $hash){"^
+       "  Write-Output 'Error: Failed to validate Maven wrapper SHA-256, your Maven wrapper might be compromised.';"^
+       "  Write-Output 'Investigate or delete %WRAPPER_JAR% to attempt a clean download.';"^
+       "  Write-Output 'If you updated your Maven version, you need to update the specified wrapperSha256Sum property.';"^
+       "  exit 1;"^
+       "}"^
+       "}"
+    if ERRORLEVEL 1 goto error
+)
+
+@REM Provide a "standardized" way to retrieve the CLI args that will
+@REM work with both Windows and non-Windows executions.
+set MAVEN_CMD_LINE_ARGS=%*
+
+%MAVEN_JAVA_EXE% ^
+  %JVM_CONFIG_MAVEN_PROPS% ^
+  %MAVEN_OPTS% ^
+  %MAVEN_DEBUG_OPTS% ^
+  -classpath %WRAPPER_JAR% ^
+  "-Dmaven.multiModuleProjectDirectory=%MAVEN_PROJECTBASEDIR%" ^
+  %WRAPPER_LAUNCHER% %MAVEN_CONFIG% %*
+if ERRORLEVEL 1 goto error
+goto end
+
+:error
+set ERROR_CODE=1
+
+:end
+@endlocal & set ERROR_CODE=%ERROR_CODE%
+
+if not "%MAVEN_SKIP_RC%"=="" goto skipRcPost
+@REM check for post script, once with legacy .bat ending and once with .cmd ending
+if exist "%USERPROFILE%\mavenrc_post.bat" call "%USERPROFILE%\mavenrc_post.bat"
+if exist "%USERPROFILE%\mavenrc_post.cmd" call "%USERPROFILE%\mavenrc_post.cmd"
+:skipRcPost
+
+@REM pause the script if MAVEN_BATCH_PAUSE is set to 'on'
+if "%MAVEN_BATCH_PAUSE%"=="on" pause
+
+if "%MAVEN_TERMINATE_CMD%"=="on" exit %ERROR_CODE%
+
+cmd /C exit /B %ERROR_CODE%

org/bukkit/configuration/annotations.xml

@@ -0,0 +1,7 @@
+<root>
+    <item name='org.bukkit.configuration.MemorySection java.lang.String getString(java.lang.String, java.lang.String)'>
+        <annotation name='org.jetbrains.annotations.Contract'>
+            <val val="&quot;_, _ -&gt; !null&quot;"/>
+        </annotation>
+    </item>
+</root>

pom.xml

@@ -1,10 +1,11 @@
-<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">
+<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>
     <groupId>net.sacredlabyrinth.phaed.simpleclans</groupId>
     <artifactId>SimpleClans</artifactId>
-    <version>2.7.25</version>
+    <version>2.19.1-SNAPSHOT</version>
     <name>SimpleClans</name>
-    <url>http://dev.bukkit.org/server-mods/simpleclans/</url>
+    <url>https://www.spigotmc.org/resources/simpleclans.71242/</url>
 
     <build>
         <finalName>${project.name}</finalName>
@@ -18,9 +19,7 @@
                 <includes>
                     <include>plugin.yml</include>
                     <include>config.yml</include>
-                    <include>language.yml</include>
-                    <include>language-br.yml</include>
-                    <include>language-zh.yml</include>
+                    <include>*.properties</include>
                 </includes>
             </resource>
         </resources>
@@ -31,13 +30,14 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.1</version>
+                <version>3.11.0</version>
                 <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
+                    <release>16</release>
                     <showDeprecation>true</showDeprecation>
                     <showWarnings>true</showWarnings>
-                    <fork>true</fork>
+                    <compilerArgs>
+                        <arg>-parameters</arg>
+                    </compilerArgs>
                 </configuration>
             </plugin>
 
@@ -45,64 +45,273 @@
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-jar-plugin</artifactId>
-                <version>2.4</version>
+                <version>3.3.0</version>
             </plugin>
 
             <!-- Release plugin -->
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-release-plugin</artifactId>
-                <version>2.3.2</version>
+                <version>3.0.1</version>
+            </plugin>
+
+            <!-- Shade plugin -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.5.0</version>
+                <configuration>
+                    <relocations>
+                        <relocation>
+                            <pattern>org.bstats</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.metrics</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>io.papermc.lib</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.paperlib</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>co.aikar.commands</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.acf</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>co.aikar.locales</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.locales</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>com.cryptomorin.xseries</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.xseries</shadedPattern>
+                        </relocation>
+                        <relocation>
+                            <pattern>com.google.gson</pattern>
+                            <shadedPattern>net.sacredlabyrinth.phaed.simpleclans.gson</shadedPattern>
+                        </relocation>
+                    </relocations>
+                    <artifactSet>
+                        <excludes>
+                            <exclude>org.jetbrains:annotations</exclude>
+                        </excludes>
+                    </artifactSet>
+
+                    <transformers>
+                        <!-- Avoid overlapping MANIFEST.MF file -->
+                        <transformer implementation="org.apache.maven.plugins.shade.resource.DontIncludeResourceTransformer">
+                            <resource>MANIFEST.MF</resource>
+                        </transformer>
+                    </transformers>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <!-- Dependency plugin -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <version>3.6.0</version>
+                <executions>
+                    <execution>
+                        <id>copy-installed</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>copy</goal>
+                        </goals>
+                        <configuration>
+                            <artifactItems>
+                                <artifactItem>
+                                    <groupId>${project.groupId}</groupId>
+                                    <artifactId>${project.artifactId}</artifactId>
+                                    <version>${project.version}</version>
+                                    <type>${project.packaging}</type>
+                                </artifactItem>
+                            </artifactItems>
+                            <outputDirectory>${env.TEST_SERVER}\plugins</outputDirectory>
+                            <silent>true</silent>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+
+            <plugin>
+                <groupId>pl.project13.maven</groupId>
+                <artifactId>git-commit-id-plugin</artifactId>
+                <version>4.9.10</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>revision</goal>
+                        </goals>
+                        <phase>validate</phase>
+                    </execution>
+                </executions>
+                <configuration>
+                    <dotGitDirectory>${project.basedir}/.git</dotGitDirectory>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-javadoc-plugin</artifactId>
+                <version>3.5.0</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>javadoc</goal>
+                        </goals>
+                        <phase>package</phase>
+                    </execution>
+                </executions>
+                <configuration>
+                    <release>16</release>
+                    <doclint>all,-missing</doclint>
+                </configuration>
+            </plugin>
+
+            <plugin>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.1.2</version>
             </plugin>
         </plugins>
     </build>
     <!-- Dependencies -->
     <dependencies>
         <dependency>
-            <groupId>com.destroystokyo.paper</groupId>
-            <artifactId>paper-api</artifactId>
-            <version>1.13.2-R0.1-SNAPSHOT</version>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
+            <version>1.16.4-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>net.milkbowl.vault</groupId>
+            <groupId>com.github.MilkBowl</groupId>
             <artifactId>VaultAPI</artifactId>
             <version>1.7</version>
             <scope>provided</scope>
+            <exclusions>
+                <!-- No idea why, but it fails JUnit 5 tests -->
+                <exclusion>
+                    <groupId>com.googlecode.json-simple</groupId>
+                    <artifactId>json-simple</artifactId>
+                </exclusion>
+            </exclusions>
         </dependency>
         <dependency>
-            <groupId>com.googlecode.json-simple</groupId>
-            <artifactId>json-simple</artifactId>
-            <version>1.1.1</version>
+            <groupId>org.bstats</groupId>
+            <artifactId>bstats-bukkit</artifactId>
+            <version>2.2.1</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>me.clip</groupId>
+            <artifactId>placeholderapi</artifactId>
+            <version>2.10.9</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>22.0.0</version>
+        </dependency>
+        <dependency>
+            <groupId>io.papermc</groupId>
+            <artifactId>paperlib</artifactId>
+            <version>1.0.8-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>co.aikar</groupId>
+            <artifactId>acf-paper</artifactId>
+            <version>0.5.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.github.cryptomorin</groupId>
+            <artifactId>XSeries</artifactId>
+            <version>8.3.0</version>
+        </dependency>
+        <dependency>
+            <groupId>com.sk89q.worldguard</groupId>
+            <artifactId>worldguard-bukkit</artifactId>
+            <version>7.0.4</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.github.TechFortress</groupId>
+            <artifactId>GriefPrevention</artifactId>
+            <version>16.18.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.discordsrv</groupId>
+            <artifactId>discordsrv</artifactId>
+            <version>1.24.1-SNAPSHOT</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>biz.princeps</groupId>
+            <artifactId>landlord-latest</artifactId>
+            <version>4.351</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.9.1</version>
+        </dependency>
+
+        <!--    Test frameworks    -->
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>5.9.3</version>
+            <scope>test</scope>
         </dependency>
     </dependencies>
 
     <!-- Repositories -->
     <repositories>
         <repository>
-            <id>vault-repo</id>
-            <url>http://nexus.hc.to/content/repositories/pub_releases</url>
+            <id>spigot-repo</id>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
         </repository>
         <repository>
-            <id>paper-repo</id>
-            <url>https://repo.destroystokyo.com/repository/maven-public/</url>
+            <id>placeholderapi-repo</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
+        <repository>
+            <id>bstats-repo</id>
+            <url>https://repo.codemc.org/repository/maven-public</url>
+        </repository>
+        <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>
+        <repository>
+            <id>sk89q-repo</id>
+            <url>https://maven.enginehub.org/repo/</url>
+        </repository>
+        <repository>
+            <id>Scarsz-Nexus</id>
+            <url>https://nexus.scarsz.me/content/groups/public/</url>
+        </repository>
+        <repository>
+            <id>eldonexus</id>
+            <url>https://eldonexus.de/repository/maven-public</url>
+        </repository>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
         </repository>
     </repositories>
 
-    <!-- GitHub/Jenkins -->
-
-    <ciManagement>
-        <system>jenkins</system>
-        <url>http://104.236.246.108:8080</url>
-    </ciManagement>
-
-    <scm>
-        <connection>scm:git:git:@github.com:marcelo-mason/SimpleClans.git</connection>
-        <developerConnection>scm:git:git:@github.com:marcelo-mason/SimpleClans.git</developerConnection>
-        <url>http://github.com/marcelo-mason/SimpleClans.git/tree/master/</url>
-        <tag>SimpleClans</tag>
-    </scm>
-
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
@@ -111,14 +320,12 @@
 
     <distributionManagement>
         <repository>
-            <id>SacredCoding</id>
-            <name>SacredCoding-releases</name>
-            <url>http://104.236.246.108:8081/artifactory/plugins-release-local</url>
+            <id>reposilite</id>
+            <url>https://repo.roinujnosde.me/releases/</url>
         </repository>
         <snapshotRepository>
-            <id>SacredCoding</id>
-            <name>SacredCoding-snapshots</name>
-            <url>http://104.236.246.108:8081/artifactory/plugins-release-local</url>
+            <id>reposilite</id>
+            <url>https://repo.roinujnosde.me/snapshots/</url>
         </snapshotRepository>
     </distributionManagement>
 </project>

src/main/java/META-INF/MANIFEST.MF

@@ -1,3 +0,0 @@
-Manifest-Version: 1.0
-Main-Class: net.sacredlabyrinth.phaed.simpleclans.SimpleClans
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/ChatBlock.java

@@ -1,13 +1,17 @@
 package net.sacredlabyrinth.phaed.simpleclans;
 
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
 import org.bukkit.ChatColor;
 import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.logging.Logger;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
 
 /**
  * @author phaed
@@ -19,31 +23,30 @@ public class ChatBlock {
     private final ArrayList<String> columnAlignments = new ArrayList<>();
     private final LinkedList<String[]> rows = new LinkedList<>();
     private String color = "";
-    /**
-     *
-     */
-    public static final Logger LOG = Logger.getLogger("Minecraft");
+    private boolean cropRight = true;
+    private boolean padRight = true;
+
+    @Deprecated
+    public void setCropRight(boolean cropRight) {
+        this.cropRight = cropRight;
+    }
+
+    @Deprecated
+    public void setPadRight(boolean padRight) {
+        this.padRight = padRight;
+    }
 
-    /**
-     * @param columnAlignment
-     */
     public void setAlignment(String... columnAlignment) {
         columnAlignments.addAll(Arrays.asList(columnAlignment));
     }
 
-    /**
-     * @param columnFlex
-     */
     public void setFlexibility(boolean... columnFlex) {
         for (boolean flex : columnFlex) {
             columnFlexes.add(flex);
         }
     }
 
-    /**
-     * @param columnPercentages
-     * @param prefix
-     */
+    @Deprecated
     public void setColumnSizes(String prefix, double... columnPercentages) {
         int ll = LINE_LENGTH;
 
@@ -56,73 +59,44 @@ public class ChatBlock {
         }
     }
 
-    /**
-     * @return
-     */
+    @Deprecated
     public boolean hasContent() {
         return !rows.isEmpty();
     }
 
-    /**
-     * @param contents
-     */
     public void addRow(String... contents) {
         rows.add(contents);
     }
 
-    /**
-     * @return
-     */
+
     public int size() {
         return rows.size();
     }
 
-    /**
-     * @return
-     */
+    @Deprecated
     public boolean isEmpty() {
         return rows.isEmpty();
     }
 
-    /**
-     *
-     */
+    @Deprecated
     public void clear() {
         rows.clear();
     }
 
-    /**
-     * @param player
-     * @return
-     */
+    @Deprecated
     public boolean sendBlock(CommandSender player) {
         return sendBlock(player, null, 0);
     }
 
-    /**
-     * @param player
-     * @param prefix
-     * @return
-     */
+    @Deprecated
     public boolean sendBlock(CommandSender player, String prefix) {
         return sendBlock(player, prefix, 0);
     }
 
-    /**
-     * @param player
-     * @param amount
-     * @return
-     */
     public boolean sendBlock(CommandSender player, int amount) {
         return sendBlock(player, null, amount);
     }
 
-    /**
-     * @param player
-     * @param prefix
-     * @param amount
-     * @return
-     */
     boolean sendBlock(CommandSender player, String prefix, int amount) {
         if (player == null) {
             return false;
@@ -158,6 +132,7 @@ public class ChatBlock {
         }
 
 
+        List<String> messages = new ArrayList<>();
         // size up all sections
 
         for (int i = 0; i < amount; i++) {
@@ -182,13 +157,25 @@ public class ChatBlock {
                     }
                 } else if (align.equalsIgnoreCase("l")) {
                     if (msgLength(section) > colsize) {
-                        col = cropRightToFit(section, colsize);
+                        if (cropRight) {
+                            col = cropRightToFit(section, colsize);
+                        } else {
+                            col = section;
+                        }
                     } else if (msgLength(section) < colsize) {
-                        col = paddRightToFit(section, colsize);
+                        if (padRight) {
+                            col = paddRightToFit(section, colsize);
+                        } else {
+                            col = section;
+                        }
                     }
                 } else if (align.equalsIgnoreCase("c")) {
                     if (msgLength(section) > colsize) {
-                        col = cropRightToFit(section, colsize);
+                        if (cropRight) {
+                            col = cropRightToFit(section, colsize);
+                        } else {
+                            col = section;
+                        }
                     } else if (msgLength(section) < colsize) {
                         col = centerInLineOf(section, colsize);
                     }
@@ -253,18 +240,20 @@ public class ChatBlock {
             }
 
             // crop and print out
-
-            String msg = cropRightToFit((prefix_used ? empty_prefix : prefix + " ") + finalString, LINE_LENGTH);
-
+            String msg = (prefix_used ? empty_prefix : prefix + " ") + finalString;
+            if (cropRight) {
+                msg = cropRightToFit(msg, LINE_LENGTH);
+            }
             if (color.length() > 0) {
                 msg = color + msg;
             }
 
-            player.sendMessage(msg);
+            messages.add(msg);
 
             prefix_used = true;
         }
 
+        player.sendMessage(messages.toArray(new String[0]));
         return !rows.isEmpty();
     }
 
@@ -278,10 +267,6 @@ public class ChatBlock {
         return out;
     }
 
-    /**
-     * @param col
-     * @return
-     */
     int getMaxWidth(int col) {
         double maxWidth = 0;
 
@@ -292,19 +277,11 @@ public class ChatBlock {
         return (int) maxWidth;
     }
 
-    /**
-     * @param msg
-     * @return
-     */
+    @Deprecated
     public static String centerInLine(String msg) {
         return centerInLineOf(msg, LINE_LENGTH);
     }
 
-    /**
-     * @param msg
-     * @param lineLength
-     * @return
-     */
     private static String centerInLineOf(String msg, double lineLength) {
         double length = msgLength(msg);
         double diff = lineLength - length;
@@ -329,10 +306,6 @@ public class ChatBlock {
         return msg;
     }
 
-    /**
-     * @param str
-     * @return
-     */
     public static String makeEmpty(String str) {
         if (str == null) {
             return "";
@@ -341,11 +314,6 @@ public class ChatBlock {
         return paddLeftToFit("", msgLength(str));
     }
 
-    /**
-     * @param msg
-     * @param length
-     * @return
-     */
     private static String cropRightToFit(String msg, double length) {
         if (msg == null || msg.length() == 0 || length == 0) {
             return "";
@@ -358,11 +326,6 @@ public class ChatBlock {
         return msg;
     }
 
-    /**
-     * @param msg
-     * @param length
-     * @return
-     */
     private static String cropLeftToFit(String msg, double length) {
         if (msg == null || msg.length() == 0 || length == 0) {
             return "";
@@ -376,11 +339,11 @@ public class ChatBlock {
     }
 
     /**
-     * Padds left til the string is a certain size
+     * Pads left til the string is a certain size
      *
-     * @param msg
-     * @param length
-     * @return
+     * @param msg    the message to pad
+     * @param length the message length
+     * @return the padded message
      */
     private static String paddLeftToFit(String msg, double length) {
         if (msgLength(msg) >= length) {
@@ -395,11 +358,11 @@ public class ChatBlock {
     }
 
     /**
-     * Padds right til the string is a certain size
+     * Pads right til the string is a certain size
      *
-     * @param msg
-     * @param length
-     * @return
+     * @param msg    the message to pad
+     * @param length the message length
+     * @return the padded message
      */
     private static String paddRightToFit(String msg, double length) {
         if (msgLength(msg) >= length) {
@@ -415,9 +378,6 @@ public class ChatBlock {
 
     /**
      * Finds the length on the screen of a string. Ignores colors.
-     *
-     * @param str
-     * @return
      */
     private static double msgLength(String str) {
         double length = 0;
@@ -438,9 +398,6 @@ public class ChatBlock {
 
     /**
      * Finds the visual length of the character on the screen.
-     *
-     * @param x
-     * @return
      */
     private static int charLength(char x) {
         String normalized = StringSimplifier.simplifiedString(x + "");
@@ -466,15 +423,11 @@ public class ChatBlock {
 
     /**
      * Cuts the message apart into whole words short enough to fit on one line
-     *
-     * @param msg
-     * @return
      */
     private static String[] wordWrap(String msg) {
         // Split each word apart
 
-        ArrayList<String> split = new ArrayList<>();
-        split.addAll(Arrays.asList(msg.split(" ")));
+        ArrayList<String> split = new ArrayList<>(Arrays.asList(msg.split(" ")));
 
         // Create an array list for the output
 
@@ -514,19 +467,15 @@ public class ChatBlock {
 
             // Merge the words into a sentence (that now fits into a single chat line) and add them to the output array.
 
-            String merged = combineSplit(words.toArray(new String[words.size()]));
+            String merged = combineSplit(words.toArray(new String[0]));
             out.add(merged);
         }
 
         // Convert to an array and return
 
-        return out.toArray(new String[out.size()]);
+        return out.toArray(new String[0]);
     }
 
-    /**
-     * @param string
-     * @return
-     */
     private static String combineSplit(String[] string) {
         StringBuilder builder = new StringBuilder();
         for (String aString : string) {
@@ -540,10 +489,6 @@ public class ChatBlock {
 
     /**
      * Cuts apart a word that is too long to fit on one line
-     *
-     * @param lengthBefore
-     * @param str
-     * @return
      */
     private static String[] wordCut(int lengthBefore, String str) {
         int length = lengthBefore;
@@ -578,8 +523,8 @@ public class ChatBlock {
     /**
      * Outputs a single line out, crops overflow
      *
-     * @param receiver
-     * @param msg
+     * @param receiver the receiver
+     * @param msg      the message
      */
     public static void saySingle(CommandSender receiver, String msg) {
         if (receiver == null) {
@@ -592,34 +537,43 @@ public class ChatBlock {
     /**
      * Outputs a message to a user
      *
-     * @param receiver
-     * @param msg
+     * @param receiver the receiver
+     * @param msg      the message
      */
-    public static void sendMessage(CommandSender receiver, String msg) {
+    public static void sendMessage(@Nullable CommandSender receiver, @NotNull String msg) {
         if (receiver == null) {
             return;
         }
 
-        String[] message = colorize(wordWrap(msg));
-
-        for (String out : message) {
-            receiver.sendMessage(out);
-        }
+        receiver.sendMessage(ChatUtils.parseColors(msg));
     }
 
-    /**
-     * Send blank lie
-     *
-     * @param color
-     */
+    public static void sendMessage(@Nullable ClanPlayer receiver, @NotNull String msg) {
+        if (receiver == null) {
+            return;
+        }
+
+        SimpleClans.getInstance().getProxyManager().sendMessage(receiver.getName(), ChatUtils.parseColors(msg));
+    }
+
+    // ClanCommands#setbanner, LandCommands#Allow/BlockCommand/verify, StaffCommands#kick, etc
+    public static void sendMessageKey(@Nullable CommandSender receiver, @NotNull String key, @NotNull Object... args) {
+        sendMessage(receiver, lang(key, receiver, args));
+    }
+
+    public static void sendMessageKey(@NotNull ClanPlayer clanPlayer, @NotNull String key, @NotNull Object... args) {
+        sendMessageKey(clanPlayer.toPlayer(), key, args);
+    }
+
+    @Deprecated
     public void startColor(String color) {
         this.color = color;
     }
 
     /**
-     * Send blank lie
+     * Sends a blank line
      *
-     * @param receiver
+     * @param receiver the receiver
      */
     public static void sendBlank(CommandSender receiver) {
         if (receiver == null) {
@@ -631,22 +585,17 @@ public class ChatBlock {
 
     /**
      * Colors each line
-     *
-     * @param message
-     * @return
      */
+    @Deprecated
     public static String[] say(String message) {
         return colorize(wordWrap(message));
     }
-    
+
+    @Deprecated
     public static String[] getColorizedMessage(String msg) {
         return colorize(wordWrap(msg));
     }
 
-    /**
-     * @param message
-     * @return
-     */
     private static String[] colorize(String[] message) {
         try {
             return colorizeBase(message);
@@ -655,21 +604,12 @@ public class ChatBlock {
         }
     }
 
-    /**
-     * @param message
-     * @return
-     */
-    public static String colorize(String message) {
-        return colorizeBase(new String[]{
-                message
-        })[0];
+    @Deprecated
+    public static @Nullable String colorize(String message) {
+        return colorizeBase(new String[]{message})[0];
     }
 
-    /**
-     * @param message
-     * @return
-     */
-    private static String[] colorizeBase(String[] message) {
+    private static @Nullable String[] colorizeBase(String[] message) {
         if (message != null && message[0] != null && !message[0].isEmpty()) {
             // Go through each line
 
@@ -685,9 +625,8 @@ public class ChatBlock {
                         // advance x to the next character
                         x += 1;
 
-                        try {
-                            lastColor = ChatColor.getByChar(msg.charAt(x)) + "";
-                        } catch (Exception ignored) {
+                        if (x < msg.length()) {
+                            lastColor = ChatColor.COLOR_CHAR + "" + msg.charAt(x);
                         }
                     }
                 }
@@ -699,6 +638,7 @@ public class ChatBlock {
             }
         }
 
+        //noinspection ConstantConditions
         return message;
     }
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/ChatFormatMigration.java

@@ -1,98 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-import org.bukkit.configuration.file.FileConfiguration;
-
-/**
- *
- * @author RoinujNosde
- */
-public class ChatFormatMigration {
-
-    SimpleClans plugin = SimpleClans.getInstance();
-
-    public void migrateClanChat() {
-        SettingsManager sm = plugin.getSettingsManager();
-        FileConfiguration c = sm.getConfig();
-
-        if (c.getString("clanchat.name-color") == null) {
-            return;
-        }
-
-        StringBuilder sb = new StringBuilder();
-
-        sb.append('&');
-        sb.append(sm.getClanChatBracketColor());
-        sb.append(sm.getClanChatTagBracketLeft());
-        sb.append("%clan%");
-        sb.append("&");
-        sb.append(sm.getClanChatBracketColor());
-        sb.append(sm.getClanChatTagBracketRight());
-        sb.append(" ");
-        sb.append('&');
-        sb.append(sm.getClanChatNameColor());
-        sb.append(sm.getClanChatPlayerBracketLeft());
-        sb.append("%nick-color%");
-        sb.append("%player%");
-        sb.append('&');
-        sb.append(sm.getClanChatNameColor());
-        sb.append(sm.getClanChatPlayerBracketRight());
-        sb.append(" %rank%: ");
-        sb.append('&');
-        sb.append(sm.getClanChatMessageColor());
-        sb.append("%message%");
-
-        c.set("clanchat.format", sb.toString());
-        c.set("clanchat.rank", "&f[%rank%&f]");
-        c.set("clanchat.rank.color", null);
-        c.set("clanchat.name-color", null);
-        c.set("clanchat.player-bracket", null);
-        c.set("clanchat.message-color", null);
-        c.set("clanchat.tag-bracket", null);
-        sm.save();
-    }
-
-    public void migrateAllyChat() {
-        SettingsManager sm = SimpleClans.getInstance().getSettingsManager();
-        FileConfiguration c = sm.getConfig();
-
-        //Checks if the old format is still in use
-        if (c.getString("allychat.tag-color") == null) {
-            return;
-        }
-
-        StringBuilder sb = new StringBuilder();
-        sb.append('&');
-        sb.append(sm.getAllyChatBracketColor());
-        sb.append(sm.getAllyChatTagBracketLeft());
-        sb.append('&');
-        sb.append(sm.getAllyChatTagColor());
-        sb.append(sm.getCommandAlly());
-        sb.append('&');
-        sb.append(sm.getAllyChatBracketColor());
-        sb.append(sm.getAllyChatTagBracketRight());
-        sb.append(" ");
-        sb.append("&4<%clan%&4> ");
-        sb.append('&');
-        sb.append(sm.getAllyChatBracketColor());
-        sb.append(sm.getAllyChatPlayerBracketLeft());
-        sb.append("%nick-color%");
-        sb.append("%player%");
-        sb.append('&');
-        sb.append(sm.getAllyChatBracketColor());
-        sb.append(sm.getAllyChatPlayerBracketRight());
-        sb.append(" %rank%: ");
-        sb.append('&');
-        sb.append(sm.getAllyChatMessageColor());
-        sb.append("%message%");
-
-        c.set("allychat.format", sb.toString());
-        c.set("allychat.rank", "&f[%rank%&f]");
-        c.set("allychat.tag-color", null);
-        c.set("allychat.name-color", null);
-        c.set("allychat.player-bracket", null);
-        c.set("allychat.message-color", null);
-        c.set("allychat.tag-bracket", null);
-        sm.save();
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/ClanRequest.java

@@ -6,5 +6,5 @@ package net.sacredlabyrinth.phaed.simpleclans;
  */
 public enum ClanRequest
 {
-    DEMOTE, PROMOTE, DISBAND, INVITE, CREATE_ALLY, BREAK_RIVALRY, START_WAR, END_WAR
+    DEMOTE, PROMOTE, DISBAND, INVITE, CREATE_ALLY, BREAK_RIVALRY, START_WAR, END_WAR, RENAME
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/CommandHelper.java

@@ -1,60 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandMap;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.SimplePluginManager;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.util.Arrays;
-
-public class CommandHelper {
-
-    private CommandHelper() {
-    }
-
-    public static void registerCommand(String... aliases) {
-        if (aliases != null) {
-            PluginCommand command = getCommand(aliases[0], SimpleClans.getInstance());
-
-            if (command != null) {
-                command.setAliases(Arrays.asList(aliases));
-                getCommandMap().register(SimpleClans.getInstance().getDescription().getName(), command);
-            }
-        }
-    }
-
-    private static PluginCommand getCommand(String name, Plugin plugin) {
-        PluginCommand command = null;
-
-        try {
-            Constructor<PluginCommand> c = PluginCommand.class.getDeclaredConstructor(String.class, Plugin.class);
-            c.setAccessible(true);
-
-            command = c.newInstance(name, plugin);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        return command;
-    }
-
-    private static CommandMap getCommandMap() {
-        CommandMap commandMap = null;
-
-        try {
-            if (Bukkit.getPluginManager() instanceof SimplePluginManager) {
-                Field f = SimplePluginManager.class.getDeclaredField("commandMap");
-                f.setAccessible(true);
-
-                commandMap = (CommandMap) f.get(Bukkit.getPluginManager());
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        return commandMap;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/DamageRecord.java

@@ -1,65 +0,0 @@
-
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import java.util.Date;
-
-/**
- * @author phaed
- */
-public class DamageRecord {
-    private String victim;
-    private String attacker;
-    private Date time;
-
-    /**
-     * @param victim
-     * @param attacker
-     */
-    public DamageRecord(String victim, String attacker) {
-        this.victim = victim;
-        this.attacker = attacker;
-        this.time = new Date();
-    }
-
-    /**
-     * @return the victim
-     */
-    public String getVictim() {
-        return victim;
-    }
-
-    /**
-     * @param victim the victim to set
-     */
-    public void setVictim(String victim) {
-        this.victim = victim;
-    }
-
-    /**
-     * @return the attacker
-     */
-    public String getAttacker() {
-        return attacker;
-    }
-
-    /**
-     * @param attacker the attacker to set
-     */
-    public void setAttacker(String attacker) {
-        this.attacker = attacker;
-    }
-
-    /**
-     * @return the time
-     */
-    public Date getTime() {
-        return new Date(time.getTime());
-    }
-
-    /**
-     * @param time the time to set
-     */
-    public void setTime(Date time) {
-        this.time = new Date(time.getTime());
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Dates.java

@@ -4,6 +4,8 @@ import java.sql.Timestamp;
 import java.util.Calendar;
 import java.util.Date;
 
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+
 /**
  * @author phaed
  */
@@ -13,115 +15,51 @@ public class Dates {
     private Dates() {
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInMonths(Timestamp date1, Timestamp date2) {
         return differenceInMonths(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInYears(Timestamp date1, Timestamp date2) {
         return differenceInYears(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInDays(Timestamp date1, Timestamp date2) {
         return differenceInDays(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInHours(Timestamp date1, Timestamp date2) {
         return differenceInHours(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInMinutes(Timestamp date1, Timestamp date2) {
         return differenceInMinutes(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInSeconds(Timestamp date1, Timestamp date2) {
         return differenceInSeconds(new Date(date1.getTime()), new Date(date2.getTime()));
     }
 
-    private static double differenceInMilliseconds(Timestamp date1, Timestamp date2) {
-        return differenceInMilliseconds(new Date(date1.getTime()), new Date(date2.getTime()));
-    }
-
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInMonths(Date date1, Date date2) {
         return differenceInYears(date1, date2) * 12;
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInYears(Date date1, Date date2) {
         double days = differenceInDays(date1, date2);
         return days / 365.2425;
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInDays(Date date1, Date date2) {
         return differenceInHours(date1, date2) / 24.0;
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInHours(Date date1, Date date2) {
         return differenceInMinutes(date1, date2) / 60.0;
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInMinutes(Date date1, Date date2) {
         return differenceInSeconds(date1, date2) / 60.0;
     }
 
-    /**
-     * @param date1
-     * @param date2
-     * @return
-     */
     public static double differenceInSeconds(Date date1, Date date2) {
         return differenceInMilliseconds(date1, date2) / 1000.0;
     }
@@ -137,56 +75,55 @@ public class Dates {
     }
 
     /**
-     * Returns the string representation of the amount of time labeled as days, hours, minutes, seconds
-     * @author RoboMWM, LaxWasHere
+     * <p>
+     * authors: RoboMWM, LaxWasHere
+     * </p>
      * @param seconds the time in seconds
-     * @param depth Max amount of detail (e.g. only display days and hours if set to 1 and seconds > 1 day)
-     * @return
+     * @param depth Max amount of detail (e.g. only display days and hours if set to 1 and seconds {@literal >} 1 day)
+     * @return the string representation of the amount of time labeled as days, hours, minutes, seconds
      */
-    public static String formatTime(Long seconds, int depth)
-    {
-        SimpleClans plugin = SimpleClans.getInstance();
+    public static String formatTime(Long seconds, int depth) {
         if (seconds == null || seconds < 1) {
-            return plugin.getLang("bb.moments");
+            return lang("bb.moments");
         }
 
         if (seconds < 60) {
-            return seconds + plugin.getLang("bb.seconds");
+            return seconds + lang("bb.seconds");
         }
 
         if (seconds < 3600) {
-            Long count = (long) Math.ceil(seconds / 60);
+            long count = (long) Math.ceil(seconds / 60f);
             String res;
             if (count > 1) {
-                res = count + plugin.getLang("bb.minutes");
+                res = count + lang("bb.minutes");
             } else {
-                res = plugin.getLang("bb.one.minute");
+                res = lang("bb.one.minute");
             }
-            Long remaining = seconds % 60;
+            long remaining = seconds % 60;
             if (depth > 0 && remaining >= 5) {
                 return res + ", " + formatTime(remaining, --depth);
             }
             return res;
         }
         if (seconds < 86400) {
-            Long count = (long) Math.ceil(seconds / 3600);
+            long count = (long) Math.ceil(seconds / 3600f);
             String res;
             if (count > 1) {
-                res = count + plugin.getLang("bb.hours");
+                res = count + lang("bb.hours");
             } else {
-                res = plugin.getLang("bb.one.hour");
+                res = lang("bb.one.hour");
             }
             if (depth > 0) {
                 return res + ", " + formatTime(seconds % 3600, --depth);
             }
             return res;
         }
-        Long count = (long) Math.ceil(seconds / 86400);
+        long count = (long) Math.ceil(seconds / 86400f);
         String res;
         if (count > 1) {
-            res = count + plugin.getLang("bb.days");
+            res = count + lang("bb.days");
         } else {
-            res = plugin.getLang("bb.one.day");
+            res = lang("bb.one.day");
         }
         if (depth > 0) {
             return res + ", " + formatTime(seconds % 86400, --depth);

src/main/java/net/sacredlabyrinth/phaed/simpleclans/EconomyResponse.java

@@ -0,0 +1,5 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+public enum EconomyResponse {
+    SUCCESS, NEGATIVE_VALUE, NOT_ENOUGH_BALANCE, CANCELLED
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Flags.java

@@ -0,0 +1,87 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Flags {
+
+    private static final Gson gson = new Gson();
+    private final JsonObject flags;
+
+    public Flags(@Nullable String json) {
+        if (json != null && !json.isEmpty()) {
+            flags = gson.fromJson(json, JsonObject.class);
+        } else {
+            flags = new JsonObject();
+        }
+    }
+
+    @NotNull
+    public List<String> getStringList(@NotNull String key) {
+        JsonElement object = flags.get(key);
+        ArrayList<String> list = new ArrayList<>();
+        if (object != null && object.isJsonArray()) {
+            for (JsonElement element : object.getAsJsonArray()) {
+                list.add(element.getAsString());
+            }
+        }
+        return list;
+    }
+
+    @Nullable
+    public String getString(@NotNull String key) {
+        JsonElement element = flags.get(key);
+        if (element == null || element.isJsonNull()) {
+            return null;
+        }
+        return element.getAsString();
+    }
+
+    @NotNull
+    public String getString(@NotNull String key, @NotNull String def) {
+        String string = getString(key);
+        if (string == null) {
+            return def;
+        }
+        return string;
+    }
+
+    @NotNull
+    public Number getNumber(@NotNull String key) {
+        JsonElement element = flags.get(key);
+        if (element == null || element.isJsonNull()) {
+            return 0;
+        }
+        return element.getAsNumber();
+    }
+
+    public boolean getBoolean(@NotNull String key) {
+        return getBoolean(key, false);
+    }
+
+    public boolean getBoolean(@NotNull String key, boolean def) {
+        JsonElement element = flags.get(key);
+        if (element == null || element.isJsonNull()) {
+            return def;
+        }
+        return element.getAsBoolean();
+    }
+
+    public void put(@NotNull String key, @NotNull List<?> value) {
+        flags.add(key, gson.toJsonTree(value));
+    }
+
+    public void put(@NotNull String key, @NotNull Object object) {
+        flags.add(key, gson.toJsonTree(object));
+    }
+
+    public String toJSONString() {
+        return flags.toString();
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Helper.java

@@ -1,80 +1,204 @@
 package net.sacredlabyrinth.phaed.simpleclans;
 
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.reflect.TypeToken;
+import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
 import org.bukkit.Location;
+import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
-import org.json.simple.JSONObject;
-import org.json.simple.parser.JSONParser;
-import org.json.simple.parser.ParseException;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.IOException;
-import java.lang.reflect.Method;
-import java.net.HttpURLConnection;
-import java.net.URL;
+import java.lang.reflect.Type;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.FileSystem;
+import java.nio.file.FileSystems;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.temporal.ChronoUnit;
 import java.util.*;
 import java.util.Map.Entry;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
+import java.util.function.Predicate;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils.stripColors;
 
 /**
  * @author phaed
  */
-public class Helper {
 
+public final class Helper {
+
+    private static final Gson GSON = new Gson();
+    private static final Type RANKS_TYPE = TypeToken.getParameterized(List.class, Rank.class).getType();
+    private static final Type RESIGN_TYPE = TypeToken.getParameterized(Map.class, String.class, Long.class).getType();
     private Helper() {
     }
 
-    /**
-     * Dumps stacktrace to log
-     */
-    public static void dumpStackTrace() {
-        for (StackTraceElement el : Thread.currentThread().getStackTrace()) {
-            SimpleClans.debug(el.toString());
+    @NotNull
+    public static Locale forLanguageTag(@Nullable String languageTag) {
+        Locale defaultLanguage = SimpleClans.getInstance().getSettingsManager().getLanguage();
+        if (languageTag == null) {
+            return defaultLanguage;
         }
+        return Locale.forLanguageTag(languageTag);
     }
-    
+
+    @Contract("null -> null")
+    @Nullable
+    public static String toLanguageTag(@Nullable Locale locale) {
+        return locale != null ? locale.toLanguageTag() : null;
+    }
+
+    public static Set<Path> getPathsIn(String path, Predicate<? super Path> filter) {
+        Set<Path> files = new LinkedHashSet<>();
+        String packagePath = path.replace(".", "/");
+
+        try {
+            URI uri = SimpleClans.class.getProtectionDomain().getCodeSource().getLocation().toURI();
+            FileSystem fileSystem = FileSystems.newFileSystem(URI.create("jar:" + uri), Collections.emptyMap());
+            files = Files.walk(fileSystem.getPath(packagePath)).
+                    filter(Objects::nonNull).
+                    filter(filter).
+                    collect(Collectors.toSet());
+            fileSystem.close();
+        } catch (URISyntaxException | IOException ex) {
+            SimpleClans.getInstance().getLogger().
+                    log(Level.WARNING, "An error occurred while trying to load files: " + ex.getMessage(), ex);
+        }
+
+        return files;
+    }
+
+    public static Set<Class<?>> getClasses(String packageName) {
+        Set<Class<?>> classes = new LinkedHashSet<>();
+
+        Predicate<? super Path> filter = entry -> {
+            String path = entry.getFileName().toString();
+            return !path.contains("$") && path.endsWith(".class");
+        };
+
+        for (Path filesPath : getPathsIn(packageName, filter)) {
+            // Compatibility with different Java versions
+            String path = filesPath.toString();
+            if (path.charAt(0) == '/') {
+                path = path.substring(1);
+            }
+
+            String fileName = path.replace("/", ".").split(".class")[0];
+
+            try {
+                Class<?> clazz = Class.forName(fileName);
+                classes.add(clazz);
+            } catch (ClassNotFoundException e) {
+                e.printStackTrace();
+            }
+        }
+
+        return classes;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> Set<Class<? extends T>> getSubTypesOf(String packageName, Class<?> type) {
+        return getClasses(packageName).stream().
+                filter(type::isAssignableFrom).
+                map(aClass -> ((Class<? extends T>) aClass)).
+                collect(Collectors.toSet());
+    }
+
+    /**
+     * Parses a list of ranks from the specified Json String
+     *
+     * @param json the Json String
+     * @return a list of ranks or null if the JSON String is null/empty
+     */
+    public static @Nullable List<Rank> ranksFromJson(@Nullable String json) {
+        if (json != null && !json.isEmpty()) {
+            JsonObject object = GSON.fromJson(json, JsonObject.class);
+            JsonElement ranks = object.get("ranks");
+            return GSON.fromJson(ranks, RANKS_TYPE);
+        }
+        return null;
+    }
+
+    /**
+     * Parses the default rank from the specified Json String
+     *
+     * @param json the Json String
+     * @return the default rank or null if not found and/or it does not exist
+     */
+    public static @Nullable String defaultRankFromJson(@Nullable String json) {
+        if (json != null && !json.isEmpty()) {
+            JsonObject object = GSON.fromJson(json, JsonObject.class);
+            JsonElement defaultRank = object.get("defaultRank");
+            if (defaultRank != null && !defaultRank.isJsonNull()) {
+                return defaultRank.getAsString();
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Converts a list of ranks and the default rank to a JSON String
+     *
+     * @param ranks       the ranks
+     * @param defaultRank the default rank
+     * @return a JSON String
+     */
+    public static String ranksToJson(List<Rank> ranks, @Nullable String defaultRank) {
+        if (ranks == null)
+            ranks = new ArrayList<>();
+
+        JsonObject object = new JsonObject();
+        object.add("ranks", GSON.toJsonTree(ranks));
+        object.addProperty("defaultRank", defaultRank);
+        return object.toString();
+    }
+
     /**
      * Converts a resign times map to a JSON String
-     * 
-     * @param resignTimes
+     *
+     * @param resignTimes the resign times
      * @return a JSON String
      */
     public static String resignTimesToJson(Map<String, Long> resignTimes) {
-    	return JSONObject.toJSONString(resignTimes);
+        return GSON.toJson(resignTimes);
     }
-    
+
     /**
      * Converts a JSON String to a resign times map
-     * 
+     *
      * @param json JSON String
      * @return a map
      */
-    @SuppressWarnings("unchecked")
-	public static Map<String, Long> resignTimesFromJson(String json) {
-    	if (json != null) {
-	    	try {
-				return (Map<String, Long>) new JSONParser().parse(json);
-			} catch (ParseException e) {
-				e.printStackTrace();
-			}	
-    	}
-    	return null;
+    public static @Nullable Map<String, Long> resignTimesFromJson(String json) {
+        if (json != null && !json.isEmpty()) {
+            return GSON.fromJson(json, RESIGN_TYPE);
+        }
+        return null;
     }
-    
+
     /**
      * Returns the delay in seconds to the specified hour and minute.
-     * 
-     * @param hour hour
+     *
+     * @param hour   hour
      * @param minute minute
      * @return the delay in seconds
      */
     public static long getDelayTo(int hour, int minute) {
+        if (hour < 0 || hour > 23) hour = 1;
+        if (minute < 0 || minute > 59) minute = 0;
         LocalDateTime now = LocalDateTime.now();
-        LocalDateTime d = LocalDateTime.of(now.toLocalDate(), LocalTime.of(1, 0));
+        LocalDateTime d = LocalDateTime.of(now.toLocalDate(), LocalTime.of(hour, minute));
         long delay;
         if (now.isAfter(d)) {
             delay = now.until(d.plusDays(1), ChronoUnit.SECONDS);
@@ -94,189 +218,20 @@ public class Helper {
         List<Player> players = SimpleClans.getInstance().getServer().matchPlayer(playerName);
 
         if (players.size() == 1) {
-            return SimpleClans.getInstance().getPermissionsManager().getPrefix(players.get(0)) + players.get(0).getName() + SimpleClans.getInstance().getPermissionsManager().getSuffix(players.get(0));
+            PermissionsManager pm = SimpleClans.getInstance().getPermissionsManager();
+            return pm.getPrefix(players.get(0)) + players.get(0).getName() + pm.getSuffix(players.get(0));
         }
 
         return playerName;
     }
 
     /**
-     * Check for integer
-     *
-     * @param o
-     * @return
-     */
-    public static boolean isInteger(Object o) {
-        return o instanceof java.lang.Integer;
-    }
-
-    /**
-     * Check for byte
-     *
-     * @param input
-     * @return
-     */
-    public static boolean isByte(String input) {
-        try {
-            Byte.parseByte(input);
-            return true;
-        } catch (Exception ex) {
-            return false;
-        }
-    }
-
-    /**
-     * Check for short
-     *
-     * @param input
-     * @return
-     */
-    public static boolean isShort(String input) {
-        try {
-            Short.parseShort(input);
-            return true;
-        } catch (Exception ex) {
-            return false;
-        }
-    }
-
-    /**
-     * Check for integer
-     *
-     * @param input
-     * @return
-     */
-    public static boolean isInteger(String input) {
-        try {
-            Integer.parseInt(input);
-            return true;
-        } catch (Exception ex) {
-            return false;
-        }
-    }
-
-    /**
-     * Check for float
-     *
-     * @param input
-     * @return
-     */
-    public static boolean isFloat(String input) {
-        try {
-            Float.parseFloat(input);
-            return true;
-        } catch (Exception ex) {
-            return false;
-        }
-    }
-
-    /**
-     * Check for string
-     *
-     * @param o
-     * @return
-     */
-    public static boolean isString(Object o) {
-        return o instanceof java.lang.String;
-    }
-
-    /**
-     * Check for boolean
-     *
-     * @param o
-     * @return
-     */
-    public static boolean isBoolean(Object o) {
-        return o instanceof java.lang.Boolean;
-    }
-
-    /**
-     * Remove a character from a string
-     *
-     * @param s
-     * @param c
-     * @return
-     */
-    public static String removeChar(String s, char c) {
-        String r = "";
-
-        for (int i = 0; i < s.length(); i++) {
-            if (s.charAt(i) != c) {
-                r += s.charAt(i);
-            }
-        }
-
-        return r;
-    }
-
-    /**
-     * Remove first character from a string
-     *
-     * @param s
-     * @param c
-     * @return
-     */
-    public static String removeFirstChar(String s, char c) {
-        String r = "";
-
-        for (int i = 0; i < s.length(); i++) {
-            if (s.charAt(i) != c) {
-                r += s.charAt(i);
-                break;
-            }
-        }
-
-        return r;
-    }
-
-    /**
-     * Capitalize first word of sentence
-     *
-     * @param content
-     * @return
-     */
-    public static String capitalize(String content) {
-        if (content.length() < 2) {
-            return content;
-        }
-
-        String first = content.substring(0, 1).toUpperCase();
-        return first + content.substring(1);
-    }
-
-    /**
-     * Return plural word if count is bigger than one
-     *
-     * @param count
-     * @param word
-     * @param ending
-     * @return
-     */
-    public static String plural(int count, String word, String ending) {
-        return count == 1 ? word : word + ending;
-    }
-
-    /**
-     * Hex value to ChatColor
-     *
-     * @param hexValue
-     * @return
-     */
-    public static String toColor(String hexValue) {
-        if (hexValue == null) {
-            return "";
-        }
-
-        return ChatColor.getByChar(hexValue).toString();
-    }
-
-    /**
-     * Converts string array to ArrayList<String>, remove empty strings
+     * Converts string array to {@literal ArrayList<String>}, remove empty strings
      *
      * @param values
      * @return
      */
-    public static List<String> fromArray(String... values) {
+    public static List<String> fromArrayToList(String... values) {
         List<String> results = new ArrayList<>();
         Collections.addAll(results, values);
         results.remove("");
@@ -284,12 +239,13 @@ public class Helper {
     }
 
     /**
-     * Converts string array to HashSet<String>, remove empty strings
+     * Converts string array to {@literal HashSet<String>}, remove empty strings
      *
      * @param values
      * @return
      */
-    public static Set<String> fromArray2(String... values) {
+    @Deprecated
+    public static Set<String> fromArrayToSet(String... values) {
         HashSet<String> results = new HashSet<>();
         Collections.addAll(results, values);
         results.remove("");
@@ -297,140 +253,27 @@ public class Helper {
     }
 
     /**
-     * Converts a player array to ArrayList<Player>
-     *
-     * @param values
-     * @return
-     */
-    public static List<Player> fromPlayerArray(Player... values) {
-        List<Player> results = new ArrayList<>();
-        Collections.addAll(results, values);
-        return results;
-    }
-
-    /**
-     * Converts ArrayList<String> to string array
+     * Converts  {@literal ArrayList<String>} to string array
      *
      * @param list
      * @return
      */
     public static String[] toArray(List<String> list) {
-        return list.toArray(new String[list.size()]);
+        return list.toArray(new String[0]);
     }
 
     /**
-     * Removes first item from a string array
+     * Converts the Permission values array to a String array
      *
-     * @param args
      * @return
      */
-    public static String[] removeFirst(String[] args) {
-        List<String> out = fromArray(args);
-
-        if (!out.isEmpty()) {
-            out.remove(0);
+    public static String[] fromPermissionArray() {
+        RankPermission[] permissions = RankPermission.values();
+        String[] sa = new String[permissions.length];
+        for (int i = 0; i < permissions.length; i++) {
+            sa[i] = permissions[i].toString();
         }
-        return toArray(out);
-    }
-
-    /**
-     * Converts a string array to a space separated string
-     *
-     * @param args
-     * @return
-     */
-    public static String toMessage(String[] args) {
-        String out = "";
-
-        for (String arg : args) {
-            out += arg + " ";
-        }
-
-        return out.trim();
-    }
-
-    /**
-     * Converts a string array to a string with custom separators
-     *
-     * @param args
-     * @param sep
-     * @return
-     */
-    public static String toMessage(String[] args, String sep) {
-        String out = "";
-
-        for (String arg : args) {
-            out += arg + ", ";
-        }
-
-        return stripTrailing(out, ", ");
-    }
-
-    /**
-     * Converts a string array to a string with custom separators
-     *
-     * @param args
-     * @param sep
-     * @return
-     */
-    public static String toMessage(List<String> args, String sep) {
-        String out = "";
-
-        for (String arg : args) {
-            out += arg + sep;
-        }
-
-        return stripTrailing(out, sep);
-    }
-
-    /**
-     * Convert color hex values with ampersand to special character
-     *
-     * @param msg
-     * @return
-     */
-    public static String parseColors(String msg) {
-        return msg.replace("&", "\u00a7");
-    }
-
-    /**
-     * Removes color codes from strings
-     *
-     * @param msg
-     * @return
-     */
-    public static String stripColors(String msg) {
-        String out = msg.replaceAll("[&][0-9a-f]", "");
-        out = out.replaceAll(String.valueOf((char) 194), "");
-        return out.replaceAll("[\u00a7][0-9a-f]", "");
-    }
-
-    /*
-     * Retrieves the last color code @param msg @return
-     */
-    /**
-     * @param msg
-     * @return
-     */
-    public static String getLastColorCode(String msg) {
-        msg = msg.replaceAll(String.valueOf((char) 194), "").trim();
-
-        if (msg.length() < 2) {
-            return "";
-        }
-
-        String one = msg.substring(msg.length() - 2, msg.length() - 1);
-        String two = msg.substring(msg.length() - 1);
-
-        if (one.equals("\u00a7")) {
-            return one + two;
-        }
-
-        if (one.equals("&")) {
-            return Helper.toColor(two);
-        }
-
-        return "";
+        return sa;
     }
 
     /**
@@ -443,33 +286,6 @@ public class Helper {
         return stripColors(tag).toLowerCase();
     }
 
-    /**
-     * Removes trailing separators
-     *
-     * @param msg
-     * @param sep
-     * @return
-     */
-    public static String stripTrailing(String msg, String sep) {
-        if (msg.length() < sep.length()) {
-            return msg;
-        }
-
-        String out = msg;
-        String first = msg.substring(0, sep.length());
-        String last = msg.substring(msg.length() - sep.length(), msg.length());
-
-        if (first.equals(sep)) {
-            out = msg.substring(sep.length());
-        }
-
-        if (last.equals(sep)) {
-            out = msg.substring(0, msg.length() - sep.length());
-        }
-
-        return out;
-    }
-
     /**
      * Generates page separator line
      *
@@ -485,43 +301,6 @@ public class Helper {
         return out;
     }
 
-    /**
-     * Check whether a player is online
-     *
-     * @param playerName
-     * @return
-     */
-    @Deprecated
-    public static boolean isOnline(String playerName) {
-        Collection<Player> online = getOnlinePlayers();
-
-        for (Player o : online) {
-            if (o.getName().equalsIgnoreCase(playerName)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Check whether a player is online
-     *
-     * @param playerUniqueId
-     * @return
-     */
-    public static boolean isOnline(UUID playerUniqueId) {
-        Collection<Player> online = getOnlinePlayers();
-
-        for (Player o : online) {
-            if (o.getUniqueId().equals(playerUniqueId)) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
     /**
      * Remove offline players from a ClanPlayer array
      *
@@ -540,35 +319,13 @@ public class Helper {
         return out;
     }
 
-    /**
-     * Test if a url is valid
-     *
-     * @param strUrl
-     * @return
-     */
-    public static boolean testURL(String strUrl) {
-        try {
-            URL url = new URL(strUrl);
-            HttpURLConnection urlConn = (HttpURLConnection) url.openConnection();
-            urlConn.connect();
-
-            if (urlConn.getResponseCode() != HttpURLConnection.HTTP_OK) {
-                return false;
-            }
-        } catch (IOException e) {
-            return false;
-        }
-
-        return true;
-    }
-
     /**
      * Escapes single quotes
      *
      * @param str
      * @return
      */
-    public static String escapeQuotes(String str) {
+    public static String escapeQuotes(@Nullable String str) {
         if (str == null) {
             return "";
         }
@@ -576,7 +333,7 @@ public class Helper {
     }
 
     /**
-     * Returns a prettier coordinate, does not include world
+     * Returns a prettier coordinate
      *
      * @param loc
      * @return
@@ -586,159 +343,47 @@ public class Helper {
     }
 
     /**
-     * Whether the two locations refer to the same block
+     * Sorts a Map by value
      *
-     * @param loc
-     * @param loc2
-     * @return
+     * @param map the Map to sort
+     * @return the Map sorted
      */
-    public static boolean isSameBlock(Location loc, Location loc2) {
-        return loc.getBlockX() == loc2.getBlockX() && loc.getBlockY() == loc2.getBlockY() && loc.getBlockZ() == loc2.getBlockZ();
-    }
+    public static <K, V extends Comparable<V>> Map<K, V> sortByValue(Map<K, V> map) {
+        LinkedList<Map.Entry<K, V>> entryList = new LinkedList<>(map.entrySet());
+        entryList.sort(Entry.comparingByValue());
 
-    /**
-     * Whether the two locations refer to the same location, ignoring pitch and
-     * yaw
-     *
-     * @param loc
-     * @param loc2
-     * @return
-     */
-    public static boolean isSameLocation(Location loc, Location loc2) {
-        return loc.getX() == loc2.getX() && loc.getY() == loc2.getY() && loc.getZ() == loc2.getZ();
-    }
-
-    /**
-     * Sort hashmap by value
-     *
-     * @param map
-     * @return Map
-     */
-    public static Map sortByValue(Map map) {
-        List list = new LinkedList(map.entrySet());
-        Collections.sort(list, new Comparator() {
-
-            @Override
-            public int compare(Object o1, Object o2) {
-                return ((Comparable) ((Map.Entry) (o2)).getValue()).compareTo(((Map.Entry) (o1)).getValue());
-            }
-        });
-
-        Map result = new LinkedHashMap();
-        for (Iterator it = list.iterator(); it.hasNext();) {
-            Map.Entry entry = (Map.Entry) it.next();
+        Map<K, V> result = new LinkedHashMap<>();
+        for (Entry<K, V> entry : entryList) {
             result.put(entry.getKey(), entry.getValue());
         }
         return result;
     }
 
-    public static boolean isVanished(Player player) {
-        if (player != null && player.hasMetadata("vanished") && !player.getMetadata("vanished").isEmpty()) {
-            return player.getMetadata("vanished").get(0).asBoolean();
-        }
-        return false;
-    }
-
-    public static Collection<Player> getOnlinePlayers() {
-        try {
-            Method method = Bukkit.class.getDeclaredMethod("getOnlinePlayers");
-            Object players = method.invoke(null);
-
-            if (players instanceof Player[]) {
-                return new ArrayList<>(Arrays.asList((Player[]) players));
-            } else {
-                return (Collection<Player>) players;
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        return new ArrayList<>();
-    }
-
-    public static Player getPlayer(String playerName) {
-        if (SimpleClans.getInstance().hasUUID()) {
-            return SimpleClans.getInstance().getServer().getPlayer(UUIDMigration.getForcedPlayerUUID(playerName));
-        }
-
-        return SimpleClans.getInstance().getServer().getPlayer(playerName);
-    }
-
     /**
-     * Formats the ally chat
-     * 
-     * @param cp Sender
-     * @param msg The message
-     * @param placeholders The placeholders
-     * @return The formated message
+     * Formats max inactive days to an infinity symbol if it's negative or 0
+     *
+     * @param max inactive days
+     * @return formatted message
      */
-    public static String formatAllyChat(ClanPlayer cp, String msg, Map<String, String> placeholders) {
-        SettingsManager sm = SimpleClans.getInstance().getSettingsManager();
-
-        String leaderColor = sm.getAllyChatLeaderColor();
-        String memberColor = sm.getAllyChatMemberColor();
-        String rank = cp.getRank().isEmpty() ? null : ChatColor.translateAlternateColorCodes('&', cp.getRank());
-        String rankFormat = rank != null ? ChatColor.translateAlternateColorCodes('&', sm.getAllyChatRank()).replace("%rank%", rank) : "";
-
-        String message = replacePlaceholders(sm.getAllyChatFormat(), cp, leaderColor, memberColor, rankFormat, msg);
-        if (placeholders != null) {
-            for (Entry<String, String> e : placeholders.entrySet()) {
-                message = message.replace("%"+e.getKey()+"%", e.getValue());
-            }
-        }
-        return message;
-    }
-
-    private static String replacePlaceholders(String messageFormat, ClanPlayer cp, String leaderColor, String memberColor, String rankFormat, String msg) {
-        String message = ChatColor.translateAlternateColorCodes('&', messageFormat)
-                .replace("%clan%", cp.getClan().getColorTag())
-                .replace("%nick-color%", (cp.isLeader() ? leaderColor : memberColor))
-                .replace("%player%", cp.getName())
-                .replace("%rank%", rankFormat)
-                .replace("%message%", msg);
-        return message;
-    }
-
-    /**
-     * Formats the clan chat
-     * 
-     * @param cp Sender
-     * @param msg The message
-     * @param placeholders The placeholders
-     * @return The formated message
-     */
-    public static String formatClanChat(ClanPlayer cp, String msg, Map<String, String> placeholders) {
-        SettingsManager sm = SimpleClans.getInstance().getSettingsManager();
-
-        String leaderColor = sm.getClanChatLeaderColor();
-        String memberColor = sm.getClanChatMemberColor();
-        String rank = cp.getRank().isEmpty() ? null : ChatColor.translateAlternateColorCodes('&', cp.getRank());
-        String rankFormat = rank != null ? ChatColor.translateAlternateColorCodes('&', sm.getClanChatRank()).replace("%rank%", rank) : "";
-
-        String message = replacePlaceholders(sm.getClanChatFormat(), cp, leaderColor, memberColor, rankFormat, msg);
-        
-        if (placeholders != null) {
-            for (Entry<String, String> e : placeholders.entrySet()) {
-                message = message.replace("%"+e.getKey()+"%", e.getValue());
-            }
-        }
-        return message;
-    }
-
-    /**
-     * Formats the chat in a way that the Clan Tag is always there, so infractors can be easily identified
-     * 
-     * @param cp Sender
-     * @param msg The chat message
-     * @return The formated message
-     */
-    public static String formatSpyClanChat(ClanPlayer cp, String msg) {
-        msg = stripColors(msg);
-        
-        if (msg.contains(stripColors(cp.getClan().getColorTag()))) {
-            return ChatColor.DARK_GRAY + msg;
+    public static String formatMaxInactiveDays(int max) {
+        if (max <= 0) {
+            return "∞";
         } else {
-            return ChatColor.DARK_GRAY + "[" + cp.getTag() + "] " + msg;
+            return String.valueOf(max);
         }
     }
+
+    @NotNull
+    public static String getFormattedClanStatus(Clan clan, CommandSender sender) {
+        ArrayList<String> statuses = new ArrayList<>();
+        if (clan.isPermanent()) {
+            statuses.add(lang("permanent", sender));
+        }
+        if (clan.isVerified()) {
+            statuses.add(lang("verified", sender));
+        } else {
+            statuses.add(lang("unverified", sender));
+        }
+        return String.join(", ", statuses);
+    }
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Kill.java

@@ -0,0 +1,42 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import java.time.LocalDateTime;
+
+public class Kill {
+
+	private final ClanPlayer killer;
+	private final ClanPlayer victim;
+	private final LocalDateTime time;
+	
+	public Kill(ClanPlayer killer, ClanPlayer victim, LocalDateTime time) {
+		this.killer = killer;
+		this.victim = victim;
+		this.time = time;
+	}
+
+	public ClanPlayer getKiller() {
+		return killer;
+	}
+
+	public ClanPlayer getVictim() {
+		return victim;
+	}
+
+	public LocalDateTime getTime() {
+		return time;
+	}
+	
+	public enum Type {
+		CIVILIAN("c"), RIVAL("r"), NEUTRAL("n"), ALLY("a");
+		
+		Type(String shortName) {
+			this.shortName = shortName;
+		}
+		
+		private final String shortName;
+		
+		public String getShortname() {
+			return shortName;
+		}
+	}
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/PermissionLevel.java

@@ -0,0 +1,5 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+public enum PermissionLevel {
+	LEADER, TRUSTED
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/PlayerNameTabCompleter.java

@@ -1,54 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import org.bukkit.ChatColor;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabCompleter;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public class PlayerNameTabCompleter implements TabCompleter {
-    private SimpleClans plugin;
-
-    public PlayerNameTabCompleter() {
-        plugin = SimpleClans.getInstance();
-    }
-
-    @Override
-    public List<String> onTabComplete(CommandSender commandSender, Command command, String s, String[] strings) {
-        if (command.getName().equalsIgnoreCase(plugin.getSettingsManager().getCommandClan())) {
-            if (strings.length < 2) {
-                return null;
-            }
-
-            if (strings[0].equalsIgnoreCase(plugin.getLang("lookup.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("ban.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("unban.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("kick.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("trust.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("untrust.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("promote.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("demote.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("setrank.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("place.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("invite.command")) ||
-                    strings[0].equalsIgnoreCase(plugin.getLang("kills.command"))) {
-                List<String> list = new ArrayList<>();
-
-                for (OfflinePlayer player : plugin.getServer().getOnlinePlayers()) {
-                    if (player.getName().startsWith(strings[1])) {
-                        list.add(player.getName());
-                    }
-                }
-
-                Collections.sort(list);
-                return list;
-            }
-        }
-
-        return null;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Rank.java

@@ -0,0 +1,107 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+*
+* @author RoinujNosde
+*/
+public class Rank implements Comparable<Rank> {
+	
+	private String name;
+	private String displayName;
+	private Set<String> permissions;
+	
+	public Rank(String name) {
+		setName(name);
+		permissions = new HashSet<>();
+		setDisplayName(displayName);
+	}
+	
+	public Rank(String name, @Nullable String displayName, Set<String> permissions) {
+		setName(name);
+		setDisplayName(displayName);
+		setPermissions(permissions);
+	}
+	
+	public void setName(String name) {
+		if (name == null || name.isEmpty()) {
+			throw new IllegalArgumentException("name cannot be null or empty");
+		}
+		this.name = name;
+	}
+
+	public void setDisplayName(@Nullable String displayName) {
+		if (displayName == null || displayName.isEmpty()) {
+			displayName = name;
+		}
+		this.displayName = displayName;
+	}
+	
+	public void setPermissions(Set<String> permissions) {
+		if (permissions == null) {
+			permissions = new HashSet<>();
+		}
+		this.permissions = permissions;
+	}
+
+	@Override
+	public int hashCode() {
+		final int prime = 31;
+		int result = 1;
+		result = prime * result + ((name == null) ? 0 : name.hashCode());
+		return result;
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		if (this == obj)
+			return true;
+		if (obj == null)
+			return false;
+		if (getClass() != obj.getClass())
+			return false;
+		Rank other = (Rank) obj;
+		if (name == null) {
+			if (other.name != null)
+				return false;
+		} else if (!name.equals(other.name))
+			return false;
+		return true;
+	}
+
+	/**
+	 * Returns the rank's permissions
+	 * 
+	 * @return
+	 */
+	public Set<String> getPermissions() {
+		return permissions;
+	}
+
+	/**
+	 * Returns the rank's display name
+	 * 
+	 * @return
+	 */
+	public String getDisplayName() {
+		return displayName;
+	}
+
+	/**
+	 * Returns the rank's name
+	 * 
+	 * @return
+	 */
+	public String getName() {
+		return name;
+	}
+
+	@Override
+	public int compareTo(Rank other) {
+		return Integer.compare(permissions.size(), other.permissions.size());
+	}
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/RankPermission.java

@@ -0,0 +1,90 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * 
+ * @author RoinujNosde
+ *
+ */
+public enum RankPermission {
+
+	ALLY_ADD("simpleclans.leader.ally", PermissionLevel.LEADER),
+	ALLY_CHAT("simpleclans.member.ally", PermissionLevel.TRUSTED),
+	ALLY_REMOVE("simpleclans.leader.ally", PermissionLevel.LEADER),
+	BANK_BALANCE("simpleclans.member.bank", PermissionLevel.TRUSTED),
+	BANK_DEPOSIT("simpleclans.member.bank", PermissionLevel.LEADER),
+	BANK_WITHDRAW("simpleclans.member.bank", PermissionLevel.LEADER),
+	BB_ADD("simpleclans.member.bb-add", PermissionLevel.TRUSTED),
+	BB_CLEAR("simpleclans.leader.bb-clear", PermissionLevel.LEADER),
+	COORDS("simpleclans.member.coords", PermissionLevel.TRUSTED),
+	FEE_ENABLE("simpleclans.leader.fee", PermissionLevel.LEADER),
+	FEE_SET("simpleclans.leader.fee", PermissionLevel.LEADER),
+	FEE_BYPASS("", PermissionLevel.LEADER),
+	REGROUP_HOME("simpleclans.leader.regroup.home", PermissionLevel.LEADER),
+	REGROUP_ME("simpleclans.leader.regroup.me", PermissionLevel.LEADER),
+	HOME_SET("simpleclans.leader.home-set", PermissionLevel.LEADER),
+	HOME_TP("simpleclans.member.home", PermissionLevel.TRUSTED),
+	INVITE("simpleclans.leader.invite", PermissionLevel.LEADER),
+	KICK("simpleclans.leader.kick", PermissionLevel.LEADER),
+	MODTAG("simpleclans.leader.modtag", PermissionLevel.LEADER),
+	RANK_DISPLAYNAME("simpleclans.leader.rank.setdisplayname", PermissionLevel.LEADER),
+	RANK_LIST("simpleclans.leader.rank.list", PermissionLevel.LEADER),
+	RIVAL_ADD("simpleclans.leader.rival", PermissionLevel.LEADER),
+	RIVAL_REMOVE("simpleclans.leader.rival", PermissionLevel.LEADER),
+	WAR_END("simpleclans.leader.war", PermissionLevel.LEADER),
+	WAR_START("simpleclans.leader.war", PermissionLevel.LEADER),
+	STATS("simpleclans.member.stats", PermissionLevel.TRUSTED),
+	VITALS("simpleclans.member.vitals", PermissionLevel.TRUSTED),
+	KILLS("simpleclans.member.kills", PermissionLevel.TRUSTED),
+	DESCRIPTION("simpleclans.leader.description", PermissionLevel.LEADER),
+	MOSTKILLED("simpleclans.mod.mostkilled", PermissionLevel.TRUSTED),
+	FRIENDLYFIRE("simpleclans.leader.ff", PermissionLevel.LEADER),
+	SETBANNER("simpleclans.leader.setbanner", PermissionLevel.LEADER);
+
+	private final String bukkitPermission;
+	private final PermissionLevel permissionLevel;
+
+	RankPermission(String bukkitPermission, PermissionLevel permissionLevel) {
+		this.bukkitPermission = bukkitPermission;
+		this.permissionLevel = permissionLevel;
+	}
+
+	/**
+	 *
+	 * @return the Bukkit equivalent to this rank permission
+	 */
+	public String getBukkitPermission() {
+		return bukkitPermission;
+	}
+
+	/**
+	 * 
+	 * @return the PermissionLevel
+	 *
+	 */
+	public PermissionLevel getPermissionLevel() {
+		return permissionLevel;
+	}
+
+	@Override
+	public String toString() {
+		return super.toString().replace("_", ".").toLowerCase();
+	}
+
+	/**
+	 * 
+	 * @param permission the permission
+	 * @return true if this is a valid rank permission
+	 */
+	@Contract("null -> false")
+	public static boolean isValid(@Nullable String permission) {
+		for (RankPermission p : values()) {
+			if (p.toString().equalsIgnoreCase(permission)) {
+				return true;
+			}
+		}
+		return false;
+	}
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/Request.java

@@ -1,9 +1,13 @@
 package net.sacredlabyrinth.phaed.simpleclans;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.REQUEST_MAX;
+
 /**
  * @author phaed
  */
@@ -16,16 +20,12 @@ public final class Request {
     private ClanPlayer requester;
     private int askCount;
 
-    /**
-     * @param plugin
-     * @param type
-     * @param acceptors
-     * @param msg
-     * @param requester
-     * @param clan
-     * @param target
-     */
-    public Request(SimpleClans plugin, ClanRequest type, List<ClanPlayer> acceptors, ClanPlayer requester, String target, Clan clan, String msg) {
+    public Request(ClanRequest type,
+                   @Nullable List<ClanPlayer> acceptors,
+                   ClanPlayer requester,
+                   String target,
+                   Clan clan,
+                   String msg) {
         this.type = type;
         this.target = target;
         this.clan = clan;
@@ -108,25 +108,15 @@ public final class Request {
         this.target = target;
     }
 
-    /**
-     * Used for leader voting
-     *
-     * @param playerNAme
-     * @param vote
-     */
-    public void vote(String playerNAme, VoteResult vote) {
+    public void vote(String playerName, VoteResult vote) {
         for (ClanPlayer cp : acceptors) {
-            if (cp.getName().equalsIgnoreCase(playerNAme)) {
+            if (cp.getName().equalsIgnoreCase(playerName)) {
                 cp.setVote(vote);
             }
         }
     }
 
-    /**
-     * Check whether all leaders have voted
-     *
-     * @return
-     */
+    @SuppressWarnings("BooleanMethodIsAlwaysInverted")
     public boolean votingFinished() {
         for (ClanPlayer cp : acceptors) {
             if (cp.getVote() == null) {
@@ -137,11 +127,6 @@ public final class Request {
         return true;
     }
 
-    /**
-     * Returns the players who have denied the request
-     *
-     * @return
-     */
     public List<String> getDenies() {
         List<String> out = new ArrayList<>();
 
@@ -154,11 +139,6 @@ public final class Request {
         return out;
     }
 
-    /**
-     * Returns the players who have denied the request
-     *
-     * @return
-     */
     public List<String> getAccepts() {
         List<String> out = new ArrayList<>();
 
@@ -199,6 +179,6 @@ public final class Request {
     }
 
     public boolean reachedRequestLimit() {
-        return askCount > SimpleClans.getInstance().getSettingsManager().getMaxAsksPerRequest();
+        return askCount > SimpleClans.getInstance().getSettingsManager().getInt(REQUEST_MAX);
     }
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/SimpleClans.java

@@ -1,212 +1,361 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-
-import org.bukkit.plugin.java.JavaPlugin;
-
-import net.sacredlabyrinth.phaed.simpleclans.executors.AcceptCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.executors.AllyCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.executors.ClanCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.executors.DenyCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.executors.GlobalCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.executors.MoreCommandExecutor;
-import net.sacredlabyrinth.phaed.simpleclans.listeners.SCEntityListener;
-import net.sacredlabyrinth.phaed.simpleclans.listeners.SCPlayerListener;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.LanguageManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.RequestManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.TeleportManager;
-import net.sacredlabyrinth.phaed.simpleclans.tasks.CollectFeeTask;
-import net.sacredlabyrinth.phaed.simpleclans.tasks.CollectUpkeepTask;
-import net.sacredlabyrinth.phaed.simpleclans.tasks.UpkeepWarningTask;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-
-/**
- * @author Phaed
- */
-public class SimpleClans extends JavaPlugin {
-
-    private ArrayList<String> messages = new ArrayList<>();
-    private static SimpleClans instance;
-    private static final Logger logger = Logger.getLogger("Minecraft");
-    private ClanManager clanManager;
-    private RequestManager requestManager;
-    private StorageManager storageManager;
-    private SettingsManager settingsManager;
-    private PermissionsManager permissionsManager;
-    private TeleportManager teleportManager;
-    private LanguageManager languageManager;
-    private ChatFormatMigration chatFormatMigration;
-    private boolean hasUUID;
-
-    /**
-     * @return the logger
-     */
-    public static Logger getLog() {
-        return logger;
-    }
-
-    /**
-     * @param msg
-     */
-    public static void debug(String msg) {
-        if (getInstance().getSettingsManager().isDebugging()) {
-            logger.log(Level.INFO, msg);
-        }
-    }
-
-    /**
-     * @return the instance
-     */
-    public static SimpleClans getInstance() {
-        return instance;
-    }
-
-    public static void log(String msg, Object... arg) {
-        if (arg == null || arg.length == 0) {
-            logger.log(Level.INFO, msg);
-        } else {
-            logger.log(Level.INFO, MessageFormat.format(msg, arg));
-        }
-    }
-
-    @Override
-    public void onEnable() {
-        instance = this;
-        
-        settingsManager = new SettingsManager();
-        this.hasUUID = UUIDMigration.canReturnUUID();
-        languageManager = new LanguageManager();
-
-        permissionsManager = new PermissionsManager();
-        requestManager = new RequestManager();
-        clanManager = new ClanManager();
-        storageManager = new StorageManager();
-        teleportManager = new TeleportManager();
-        chatFormatMigration = new ChatFormatMigration();
-        
-        chatFormatMigration.migrateAllyChat();
-        chatFormatMigration.migrateClanChat();
-
-        logger.info(MessageFormat.format(getLang("version.loaded"), getDescription().getName(), getDescription().getVersion()));
-
-        getServer().getPluginManager().registerEvents(new SCEntityListener(), this);
-        getServer().getPluginManager().registerEvents(new SCPlayerListener(), this);
-
-        permissionsManager.loadPermissions();
-
-        CommandHelper.registerCommand(getSettingsManager().getCommandClan());
-        CommandHelper.registerCommand(getSettingsManager().getCommandAccept());
-        CommandHelper.registerCommand(getSettingsManager().getCommandDeny());
-        CommandHelper.registerCommand(getSettingsManager().getCommandMore());
-        CommandHelper.registerCommand(getSettingsManager().getCommandAlly());
-        CommandHelper.registerCommand(getSettingsManager().getCommandGlobal());
-
-        getCommand(getSettingsManager().getCommandClan()).setExecutor(new ClanCommandExecutor());
-        getCommand(getSettingsManager().getCommandAccept()).setExecutor(new AcceptCommandExecutor());
-        getCommand(getSettingsManager().getCommandDeny()).setExecutor(new DenyCommandExecutor());
-        getCommand(getSettingsManager().getCommandMore()).setExecutor(new MoreCommandExecutor());
-        getCommand(getSettingsManager().getCommandAlly()).setExecutor(new AllyCommandExecutor());
-        getCommand(getSettingsManager().getCommandGlobal()).setExecutor(new GlobalCommandExecutor());
-
-        getCommand(getSettingsManager().getCommandClan()).setTabCompleter(new PlayerNameTabCompleter());
-        logger.info("[SimpleClans] Online Mode: " + hasUUID); //TODO: Is this necessary?
-        logger.info("[SimpleClans] Modo Multithreading: " + SimpleClans.getInstance().getSettingsManager().getUseThreads());
-        logger.info("[SimpleClans] Modo BungeeCord: " + SimpleClans.getInstance().getSettingsManager().getUseBungeeCord());
-        
-        startTasks();
-    }
-
-    private void startTasks() {
-        if (getSettingsManager().isMemberFee()) {
-            new CollectFeeTask().start();
-        }
-        if (getSettingsManager().isClanUpkeep()) {
-            new CollectUpkeepTask().start();
-            new UpkeepWarningTask().start();
-        }
-    }
-
-    @Override
-    public void onDisable() {
-        getServer().getScheduler().cancelTasks(this);
-        getStorageManager().closeConnection();
-        getPermissionsManager().savePermissions();
-    }
-
-    /**
-     * @return the clanManager
-     */
-    public ClanManager getClanManager() {
-        return clanManager;
-    }
-
-    /**
-     * @return the requestManager
-     */
-    public RequestManager getRequestManager() {
-        return requestManager;
-    }
-
-    /**
-     * @return the storageManager
-     */
-    public StorageManager getStorageManager() {
-        return storageManager;
-    }
-
-    /**
-     * @return the settingsManager
-     */
-    public SettingsManager getSettingsManager() {
-        return settingsManager;
-    }
-
-    /**
-     * @return the permissionsManager
-     */
-    public PermissionsManager getPermissionsManager() {
-        return permissionsManager;
-    }
-
-    /**
-     * @param msg the path within the language file
-     * @return the lang
-     */
-    public String getLang(String msg) {
-        return languageManager.get(msg);
-    }
-
-    public TeleportManager getTeleportManager() {
-        return teleportManager;
-    }
-
-    public List<String> getMessages() {
-        return messages;
-    }
-
-    /**
-     * @return the hasUUID
-     */
-    public boolean hasUUID() {
-        return this.hasUUID;
-    }
-
-    /**
-     * @param trueOrFalse
-     */
-    public void setUUID(boolean trueOrFalse) {
-        this.hasUUID = trueOrFalse;
-    }
-
-    public LanguageManager getLanguageManager() {
-        return languageManager;
-    }
-}
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import co.aikar.commands.BukkitCommandIssuer;
+import net.sacredlabyrinth.phaed.simpleclans.commands.SCCommandManager;
+import net.sacredlabyrinth.phaed.simpleclans.hooks.papi.SimpleClansExpansion;
+import net.sacredlabyrinth.phaed.simpleclans.language.LanguageResource;
+import net.sacredlabyrinth.phaed.simpleclans.listeners.*;
+import net.sacredlabyrinth.phaed.simpleclans.loggers.BankLogger;
+import net.sacredlabyrinth.phaed.simpleclans.loggers.CSVBankLogger;
+import net.sacredlabyrinth.phaed.simpleclans.managers.*;
+import net.sacredlabyrinth.phaed.simpleclans.migrations.BbMigration;
+import net.sacredlabyrinth.phaed.simpleclans.migrations.ChatFormatMigration;
+import net.sacredlabyrinth.phaed.simpleclans.migrations.LanguageMigration;
+import net.sacredlabyrinth.phaed.simpleclans.proxy.BungeeManager;
+import net.sacredlabyrinth.phaed.simpleclans.proxy.ProxyManager;
+import net.sacredlabyrinth.phaed.simpleclans.tasks.*;
+import net.sacredlabyrinth.phaed.simpleclans.ui.InventoryController;
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
+import net.sacredlabyrinth.phaed.simpleclans.utils.TagValidator;
+import net.sacredlabyrinth.phaed.simpleclans.utils.UpdateChecker;
+import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
+import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
+import org.bstats.charts.SingleLineChart;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Pattern;
+
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.*;
+import static org.bukkit.Bukkit.getPluginManager;
+
+/**
+ * @author Phaed
+ */
+public class SimpleClans extends JavaPlugin {
+
+    private final ArrayList<String> messages = new ArrayList<>();
+
+    private static SimpleClans instance;
+    private static LanguageResource languageResource;
+    private static final Logger logger = Logger.getLogger("SimpleClans");
+    private SCCommandManager commandManager;
+    private ClanManager clanManager;
+    private RequestManager requestManager;
+    private StorageManager storageManager;
+    private SettingsManager settingsManager;
+    private PermissionsManager permissionsManager;
+    private TeleportManager teleportManager;
+    private ProtectionManager protectionManager;
+    private ChatManager chatManager;
+    private ProxyManager proxyManager;
+    private boolean hasUUID;
+    private static final Pattern ACF_PLACEHOLDER_PATTERN = Pattern.compile("\\{(?<key>[a-zA-Z]+?)}");
+
+    private BankLogger bankLogger;
+    private TagValidator tagValidator;
+
+    /**
+     * @return the logger
+     */
+    @Deprecated
+    public static Logger getLog() {
+        return logger;
+    }
+
+    public static void debug(String msg) {
+        if (getInstance().getSettingsManager().is(DEBUG)) {
+            logger.log(Level.INFO, msg);
+        }
+    }
+
+    /**
+     * @return the instance
+     */
+    public static SimpleClans getInstance() {
+        return instance;
+    }
+
+    @Deprecated
+    public static void log(String msg, Object... arg) {
+        if (arg == null || arg.length == 0) {
+            logger.log(Level.INFO, msg);
+        } else {
+            logger.log(Level.INFO, MessageFormat.format(msg, arg));
+        }
+    }
+
+    @Override
+    public void onEnable() {
+        instance = this;
+        new LanguageMigration(this).migrate();
+        settingsManager = new SettingsManager(this);
+        new BbMigration(settingsManager);
+        new ChatFormatMigration(settingsManager);
+        languageResource = new LanguageResource();
+        this.hasUUID = UUIDMigration.canReturnUUID();
+
+        permissionsManager = new PermissionsManager();
+        requestManager = new RequestManager();
+        clanManager = new ClanManager();
+        proxyManager = new BungeeManager(this);
+        storageManager = new StorageManager();
+        teleportManager = new TeleportManager();
+        protectionManager = new ProtectionManager();
+        protectionManager.registerListeners();
+        chatManager = new ChatManager(this);
+        registerEvents();
+        permissionsManager.loadPermissions();
+        commandManager = new SCCommandManager(this);
+        bankLogger = new CSVBankLogger(this);
+
+        tagValidator = new TagValidator(settingsManager, permissionsManager);
+
+        logStatus();
+        startTasks();
+        startMetrics();
+        hookIntoPAPI();
+        new UpdateChecker(this).check();
+    }
+
+    private void logStatus() {
+        getLogger().info("Multithreading: " + settingsManager.is(PERFORMANCE_USE_THREADS));
+        getLogger().info("BungeeCord: " + settingsManager.is(PERFORMANCE_USE_BUNGEECORD));
+        getLogger().info("HEX support: " + ChatUtils.HEX_COLOR_SUPPORT);
+        getLogger().info("Help us translate SimpleClans to your language! " +
+                "Access https://crowdin.com/project/simpleclans/");
+    }
+
+    private void registerEvents() {
+        PluginManager pm = getServer().getPluginManager();
+        pm.registerEvents(new PlayerDeath(this), this);
+        pm.registerEvents(new SCPlayerListener(this), this);
+        pm.registerEvents(new InventoryController(), this);
+        pm.registerEvents(new TamableMobsSharing(this), this);
+        pm.registerEvents(new PvPOnlyInWar(this), this);
+        pm.registerEvents(new FriendlyFire(this), this);
+    }
+
+    private void hookIntoPAPI() {
+        if (getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            getLogger().info("PlaceholderAPI found. Registering hook...");
+            new SimpleClansExpansion(this).register();
+        }
+    }
+
+    private void startMetrics() {
+        Metrics metrics = new Metrics(this, 7131);
+        SettingsManager sm = getSettingsManager();
+        ClanManager cm = getClanManager();
+        String on = "enabled";
+        String off = "disabled";
+        metrics.addCustomChart(new SingleLineChart("clans", () -> cm.getClans().size()));
+        metrics.addCustomChart(new SingleLineChart("clan_players", () -> cm.getAllClanPlayers().size()));
+        metrics.addCustomChart(new SimplePie("language", () -> sm.getLanguage().toString()));
+        metrics.addCustomChart(new SimplePie("machine_language", () -> Locale.getDefault().toString()));
+        metrics.addCustomChart(new SimplePie("language_chooser", () -> sm.is(LANGUAGE_SELECTOR) ? on : off));
+        metrics.addCustomChart(new SimplePie("database", () -> sm.is(MYSQL_ENABLE) ? "MySQL" : "SQLite"));
+        metrics.addCustomChart(new SimplePie("save_periodically", () -> sm.is(PERFORMANCE_SAVE_PERIODICALLY) ? on : off));
+        metrics.addCustomChart(new SimplePie("save_interval", () -> sm.getString(PERFORMANCE_SAVE_INTERVAL)));
+        metrics.addCustomChart(new SimplePie("upkeep", () -> sm.is(ECONOMY_UPKEEP_ENABLED) ? on : off));
+        metrics.addCustomChart(new SimplePie("member_fee", () -> sm.is(ECONOMY_MEMBER_FEE_ENABLED) ? on : off));
+        metrics.addCustomChart(new SimplePie("rejoin_cooldown", () -> sm.is(ENABLE_REJOIN_COOLDOWN) ? on : off));
+        metrics.addCustomChart(new SimplePie("clan_verification", () -> sm.is(REQUIRE_VERIFICATION) ? on : off));
+        metrics.addCustomChart(new SimplePie("money_per_kill", () -> sm.is(ECONOMY_MONEY_PER_KILL) ? on : off));
+        metrics.addCustomChart(new SimplePie("threads", () -> sm.is(PERFORMANCE_USE_THREADS) ? on : off));
+        metrics.addCustomChart(new SimplePie("bungeecord", () -> sm.is(PERFORMANCE_USE_BUNGEECORD) ? on : off));
+        metrics.addCustomChart(new SimplePie("discord_chat", () -> sm.is(DISCORDCHAT_ENABLE) ? on : off));
+    }
+
+    private void startTasks() {
+        if (getSettingsManager().is(PERFORMANCE_SAVE_PERIODICALLY)) {
+            new SaveDataTask().start();
+        }
+        if (getSettingsManager().is(ECONOMY_MEMBER_FEE_ENABLED)) {
+            new CollectFeeTask().start();
+        }
+        if (getSettingsManager().is(ECONOMY_UPKEEP_ENABLED)) {
+            new CollectUpkeepTask().start();
+            new UpkeepWarningTask().start();
+        }
+        if (getSettingsManager().is(PERFORMANCE_HEAD_CACHING)) {
+            new PlayerHeadCacheTask(this).start();
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        if (getSettingsManager().is(PERFORMANCE_SAVE_PERIODICALLY)) {
+            getStorageManager().saveModified();
+        }
+        getStorageManager().closeConnection();
+        getPermissionsManager().savePermissions();
+        getSettingsManager().loadAndSave();
+    }
+
+    /**
+     * @return the clanManager
+     */
+    public ClanManager getClanManager() {
+        return clanManager;
+    }
+
+    /**
+     * @return the requestManager
+     */
+    public RequestManager getRequestManager() {
+        return requestManager;
+    }
+
+    /**
+     * @return the storageManager
+     */
+    public StorageManager getStorageManager() {
+        return storageManager;
+    }
+
+    /**
+     * @return the settingsManager
+     */
+    public SettingsManager getSettingsManager() {
+        return settingsManager;
+    }
+
+    /**
+     * @return the permissionsManager
+     */
+    @NotNull
+    public PermissionsManager getPermissionsManager() {
+        return permissionsManager;
+    }
+
+    public SCCommandManager getCommandManager() {
+        return commandManager;
+    }
+
+    public ProtectionManager getProtectionManager() {
+        return protectionManager;
+    }
+
+    public ChatManager getChatManager() {
+        return chatManager;
+    }
+
+    public ProxyManager getProxyManager() {
+        return proxyManager;
+    }
+
+    public BankLogger getBankLogger() {
+        return bankLogger;
+    }
+
+    /**
+     * @param key the path within the language file
+     * @return the lang
+     */
+    @Deprecated
+    public String getLang(@NotNull String key) {
+        return getLang(key, null);
+    }
+
+    @Deprecated
+    public String getLang(@NotNull String key, @Nullable Player player) {
+        return lang(key, player);
+    }
+
+    @Nullable
+    public static String optionalLang(@NotNull String key, @Nullable ClanPlayer clanPlayer, Object... arguments) {
+        Locale locale = instance.getSettingsManager().getLanguage();
+        if (clanPlayer != null && clanPlayer.getLocale() != null && instance.getSettingsManager().is(LANGUAGE_SELECTOR)) {
+            locale = clanPlayer.getLocale();
+        }
+
+        String lang = languageResource.getLang(key, locale);
+        if (lang == null) {
+            return null;
+        }
+        String message = ChatUtils.parseColors(lang);
+        // contains acf placeholders like {commandprefix}
+        if (ACF_PLACEHOLDER_PATTERN.matcher(message).find()) {
+            return message;
+        }
+        return MessageFormat.format(message, arguments);
+    }
+
+    @Nullable
+    public static String optionalLang(@NotNull String key, @Nullable Player player, Object... arguments) {
+        ClanPlayer clanPlayer = null;
+        if (player != null) {
+            clanPlayer = instance.getClanManager().getAnyClanPlayer(player.getUniqueId());
+        }
+        return optionalLang(key, clanPlayer, arguments);
+    }
+
+    @NotNull
+    public static String lang(@NotNull String key, @Nullable Player player, Object... arguments) {
+        String lang = optionalLang(key, player, arguments);
+        return (lang == null) ? key : lang;
+    }
+
+    @NotNull
+    public static String lang(@NotNull String key, @Nullable ClanPlayer clanPlayer, Object... arguments) {
+        String lang = optionalLang(key, clanPlayer, arguments);
+        return (lang == null) ? key : lang;
+    }
+
+    @NotNull
+    public static String lang(@NotNull String key, @Nullable CommandSender sender, Object... arguments) {
+        if (sender instanceof Player) {
+            return lang(key, (Player) sender, arguments);
+        } else {
+            return lang(key, (Player) null, arguments);
+        }
+    }
+
+    @NotNull
+    public static String lang(@NotNull String key, @Nullable BukkitCommandIssuer issuer, Object... arguments) {
+        if (issuer != null) {
+            return lang(key, issuer.getIssuer(), arguments);
+        }
+        return lang(key, arguments);
+    }
+
+    @NotNull
+    public static String lang(@NotNull String key, Object... arguments) {
+        return lang(key, (Player) null, arguments);
+    }
+
+    public TeleportManager getTeleportManager() {
+        return teleportManager;
+    }
+
+    @Deprecated
+    public List<String> getMessages() {
+        return messages;
+    }
+
+    @Deprecated
+    public boolean hasUUID() {
+        return this.hasUUID;
+    }
+
+    @Deprecated
+    public void setUUID(boolean trueOrFalse) {
+        this.hasUUID = trueOrFalse;
+    }
+
+    public TagValidator getTagValidator() {
+        return tagValidator;
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/TeleportState.java

@@ -1,40 +1,33 @@
 package net.sacredlabyrinth.phaed.simpleclans;
 
 import org.bukkit.Location;
+import org.bukkit.OfflinePlayer;
 import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
 
-import java.util.UUID;
 
 public class TeleportState {
-    private UUID playerUniqueId;
-    private String playerName;
-    private Location playerLocation;
-    private Location destination;
+
+    private final OfflinePlayer offlinePlayer;
+    private final Location origin;
+    private final Location destination;
     private int counter;
-    private String clanName;
+    private final String clanName;
     private boolean processing;
 
-    public TeleportState(Player player, Location dest, String clanName) {
-        this.destination = dest;
-        this.playerLocation = player.getLocation();
-        this.playerName = player.getName();
+    public TeleportState(Player player, Location destination, String clanName, int counter) {
+        this.offlinePlayer = player;
+        this.destination = destination;
+        this.origin = player.getLocation();
         this.clanName = clanName;
-        this.counter = SimpleClans.getInstance().getSettingsManager().getWaitSecs();
-        this.playerUniqueId = player.getUniqueId();
+        this.counter = counter;
     }
 
-    /**
-     * @return
-     */
+
     public Location getLocation() {
-        return this.playerLocation;
+        return this.origin;
     }
 
-    /**
-     * Whether its time for teleport
-     *
-     * @return
-     */
     public boolean isTeleportTime() {
         if (this.counter > 1) {
             this.counter--;
@@ -47,20 +40,16 @@ public class TeleportState {
     /**
      * The player that is waiting for teleport
      *
-     * @return
+     * @return the player
      */
-    public Player getPlayer() {
-        if (SimpleClans.getInstance().hasUUID()) {
-            return SimpleClans.getInstance().getServer().getPlayer(this.playerUniqueId);
-        } else {
-            return SimpleClans.getInstance().getServer().getPlayer(this.playerName);
-        }
+    public @Nullable Player getPlayer() {
+    	return offlinePlayer.getPlayer();
     }
 
     /**
      * Get seconds left before teleport
      *
-     * @return
+     * @return the counter
      */
     public int getCounter() {
         return this.counter;
@@ -86,7 +75,4 @@ public class TeleportState {
         this.processing = processing;
     }
 
-    public UUID getUniqueId() {
-        return this.playerUniqueId;
-    }
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/VoteResult.java

@@ -2,12 +2,9 @@ package net.sacredlabyrinth.phaed.simpleclans;
 
 /**
  * Possible vote values
- */
-/**
  *
  * @author cc_madelg
  */
-public enum VoteResult
-{
+public enum VoteResult {
     ACCEPT, DENY
 }

src/main/java/net/sacredlabyrinth/phaed/simpleclans/War.java

@@ -0,0 +1,49 @@
+package net.sacredlabyrinth.phaed.simpleclans;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class War {
+    private final Map<Clan, Integer> clans = new HashMap<>();
+
+    public War(@NotNull Clan clan1, @NotNull Clan clan2) {
+        clans.put(clan1, 0);
+        clans.put(clan2, 0);
+    }
+
+    public List<Clan> getClans() {
+        return new ArrayList<>(clans.keySet());
+    }
+
+    public int getTotalCasualties() {
+        return clans.values().stream().mapToInt(value -> value).sum();
+    }
+
+    public int getCasualties(@NotNull Clan clan) {
+        return clans.getOrDefault(clan, 0);
+    }
+
+    public void increaseCasualties(@NotNull Clan clan) {
+        clans.computeIfPresent(clan, (c, i) -> i + 1);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) {
+            return true;
+        }
+        if (obj instanceof War) {
+            return clans.equals(((War) obj).clans);
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return clans.hashCode();
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/ChatHandler.java

@@ -0,0 +1,18 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat;
+
+import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
+import net.sacredlabyrinth.phaed.simpleclans.managers.ChatManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
+
+public interface ChatHandler {
+
+    SimpleClans plugin = SimpleClans.getInstance();
+    SettingsManager settingsManager = plugin.getSettingsManager();
+    ChatManager chatManager = plugin.getChatManager();
+    PermissionsManager permissionsManager = plugin.getPermissionsManager();
+
+    void sendMessage(SCMessage message);
+
+    boolean canHandle(SCMessage.Source source);
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/SCMessage.java

@@ -0,0 +1,90 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat;
+
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SCMessage implements Cloneable {
+
+    private final Source source;
+    private final ClanPlayer.Channel channel;
+    private final ClanPlayer sender;
+    private List<ClanPlayer> receivers;
+    private String content;
+
+    /**
+     * Creates a message with initial parameters
+     *
+     * @param source    The source of message
+     * @param channel   The channel of clan player
+     * @param sender    The clan player sender
+     * @param content   The content of message
+     * @param receivers The clan players, who will receive the content
+     */
+    public SCMessage(@NotNull Source source, @NotNull ClanPlayer.Channel channel,
+                     @NotNull ClanPlayer sender, String content, @NotNull List<ClanPlayer> receivers) {
+        this.source = source;
+        this.channel = channel;
+        this.sender = sender;
+        this.content = content;
+        this.receivers = receivers;
+    }
+
+    /**
+     * Creates a new SCMessage without receivers
+     *
+     * @see SCMessage#SCMessage(Source, ClanPlayer.Channel, ClanPlayer, String, List) instantiate with initial receievers
+     */
+    public SCMessage(@NotNull Source source, @NotNull ClanPlayer.Channel channel, @NotNull ClanPlayer sender, String content) {
+        this(source, channel, sender, content, new ArrayList<>());
+    }
+
+    public ClanPlayer.Channel getChannel() {
+        return channel;
+    }
+
+    public ClanPlayer getSender() {
+        return sender;
+    }
+
+    public String getContent() {
+        return content;
+    }
+
+    public Source getSource() {
+        return source;
+    }
+
+    public List<ClanPlayer> getReceivers() {
+        return receivers;
+    }
+
+    public void setContent(@NotNull String content) {
+        this.content = content;
+    }
+
+    public void setReceivers(@NotNull List<ClanPlayer> receivers) {
+        this.receivers = receivers;
+    }
+
+    @Override
+    public SCMessage clone() {
+        try {
+            return (SCMessage) super.clone();
+        } catch (CloneNotSupportedException e) {
+            throw new Error(); //never thrown
+        }
+    }
+
+    /**
+     * The place where the message came from.
+     * Used by ChatHandlers to know which SCMessages they can handle.
+     *
+     * @see ChatHandler initiate the handler
+     */
+    public enum Source {
+        SPIGOT, DISCORD, PROXY
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/handlers/DiscordChatHandler.java

@@ -0,0 +1,48 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat.handlers;
+
+import github.scarsz.discordsrv.dependencies.jda.api.entities.TextChannel;
+import github.scarsz.discordsrv.util.DiscordUtil;
+import net.sacredlabyrinth.phaed.simpleclans.Clan;
+import net.sacredlabyrinth.phaed.simpleclans.chat.ChatHandler;
+import net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage;
+import net.sacredlabyrinth.phaed.simpleclans.hooks.discord.DiscordHook;
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+import java.util.Optional;
+
+import static net.sacredlabyrinth.phaed.simpleclans.ClanPlayer.Channel.CLAN;
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source;
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source.SPIGOT;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.DISCORDCHAT_FORMAT_TO;
+
+/**
+ * Handles delivering messages from {@link Source#SPIGOT} to {@link Source#DISCORD}.
+ */
+public class DiscordChatHandler implements ChatHandler {
+
+    @Override
+    public void sendMessage(@NotNull SCMessage message) {
+        if (message.getChannel() != CLAN) {
+            return;
+        }
+
+        String format = settingsManager.getString(DISCORDCHAT_FORMAT_TO);
+        String formattedMessage = ChatUtils.stripColors(chatManager.parseChatFormat(format, message));
+
+        Clan clan = message.getSender().getClan();
+        if (clan == null) {
+            return;
+        }
+
+        DiscordHook discordHook = Objects.requireNonNull(chatManager.getDiscordHook(), "DiscordHook cannot be null");
+        Optional<TextChannel> channel = discordHook.getCachedChannel(clan.getTag());
+        channel.ifPresent(textChannel -> DiscordUtil.sendMessage(textChannel, formattedMessage));
+    }
+
+    @Override
+    public boolean canHandle(SCMessage.Source source) {
+        return source == SPIGOT && chatManager.isDiscordHookEnabled();
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/handlers/ProxyChatHandler.java

@@ -0,0 +1,20 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat.handlers;
+
+import net.sacredlabyrinth.phaed.simpleclans.chat.ChatHandler;
+import net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage;
+import net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source;
+
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.PERFORMANCE_USE_BUNGEECORD;
+
+public class ProxyChatHandler implements ChatHandler {
+
+    @Override
+    public void sendMessage(SCMessage message) {
+        plugin.getProxyManager().sendMessage(message);
+    }
+
+    @Override
+    public boolean canHandle(Source source) {
+        return source == Source.SPIGOT && settingsManager.is(PERFORMANCE_USE_BUNGEECORD);
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/handlers/SpigotChatHandler.java

@@ -0,0 +1,74 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat.handlers;
+
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import net.sacredlabyrinth.phaed.simpleclans.chat.ChatHandler;
+import net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage;
+import net.sacredlabyrinth.phaed.simpleclans.events.ChatEvent;
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source.*;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.PERFORMANCE_USE_BUNGEECORD;
+import static org.bukkit.Bukkit.getPluginManager;
+
+@SuppressWarnings("unused")
+public class SpigotChatHandler implements ChatHandler {
+
+    @Override
+    public void sendMessage(SCMessage message) {
+        /*
+          TODO: Make it async, change Type to Channel in 3.0
+        */
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                ChatEvent event = new ChatEvent(message.getContent(), message.getSender(), message.getReceivers(),
+                        ChatEvent.Type.valueOf(message.getChannel().name()));
+
+                getPluginManager().callEvent(event);
+                if (event.isCancelled()) {
+                    return;
+                }
+                message.setContent(stripColorsAndFormatsPerPermission(message.getSender(),event.getMessage()));
+
+                ConfigField configField = ConfigField.valueOf(String.format("%sCHAT_FORMAT",
+                        message.getSource() == DISCORD ? "DISCORD" : message.getChannel()));
+
+                String format = settingsManager.getString(configField);
+                String formattedMessage = chatManager.parseChatFormat(format, message, event.getPlaceholders());
+
+                plugin.getLogger().info(ChatUtils.stripColors(formattedMessage));
+
+                for (ClanPlayer cp : message.getReceivers()) {
+                    ChatBlock.sendMessage(cp, formattedMessage);
+                }
+            }
+        }.runTask(plugin);
+    }
+
+    private String stripColorsAndFormatsPerPermission(ClanPlayer sender, String message) {
+        if (!permissionsManager.has(sender.toPlayer(), "simpleclans.member.chat.color")) {
+            message = stripColors(message);
+        }
+        if (!permissionsManager.has(sender.toPlayer(), "simpleclans.member.chat.format")) {
+            message = stripFormats(message);
+        }
+        return message;
+    }
+
+    private String stripColors(String message) {
+        return message.replaceAll("[§&][0-9a-fA-FxX]", "");
+    }
+
+    private String stripFormats(String message) {
+        return message.replaceAll("[§&][k-orK-OR]", "");
+    }
+
+    @Override
+    public boolean canHandle(SCMessage.Source source) {
+        return source == SPIGOT || (source == PROXY && settingsManager.is(PERFORMANCE_USE_BUNGEECORD))
+                || (source == DISCORD && chatManager.isDiscordHookEnabled());
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/chat/handlers/SpyChatHandler.java

@@ -0,0 +1,55 @@
+package net.sacredlabyrinth.phaed.simpleclans.chat.handlers;
+
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import net.sacredlabyrinth.phaed.simpleclans.chat.ChatHandler;
+import net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage;
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
+import org.bukkit.Bukkit;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source;
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source.*;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.PERFORMANCE_USE_BUNGEECORD;
+
+/**
+ * Handles delivering messages from {@link Source#SPIGOT} or {@link Source#DISCORD} to internal spy chat.
+ */
+public class SpyChatHandler implements ChatHandler {
+
+    @Override
+    public void sendMessage(SCMessage message) {
+        ConfigField formatField = ConfigField.valueOf(String.format("%sCHAT_SPYFORMAT",
+                message.getSource() == DISCORD ? "DISCORD" : message.getChannel()));
+        String format = settingsManager.getString(formatField);
+        message.setContent(ChatUtils.stripColors(message.getContent()));
+        String formattedMessage = chatManager.parseChatFormat(format, message);
+
+        List<ClanPlayer> onlineSpies = getOnlineSpies();
+
+        // Don't send a duplicate message if a spy is inside the clan
+        onlineSpies.removeAll(message.getReceivers());
+        onlineSpies.forEach(receiver -> ChatBlock.sendMessage(receiver, formattedMessage));
+    }
+
+    @Override
+    public boolean canHandle(SCMessage.Source source) {
+        return source == SPIGOT || (source == PROXY && settingsManager.is(PERFORMANCE_USE_BUNGEECORD))
+                || (source == DISCORD && chatManager.isDiscordHookEnabled());
+    }
+
+    private List<ClanPlayer> getOnlineSpies() {
+        return new ArrayList<>(Bukkit.getOnlinePlayers()).stream().
+                filter(Objects::nonNull).
+                filter(player -> permissionsManager.has(player, "simpleclans.admin.all-seeing-eye")).
+                map(player -> plugin.getClanManager().getCreateClanPlayer(player.getUniqueId())).
+                filter(Objects::nonNull).
+                filter(clanPlayer -> !clanPlayer.isMuted()).
+                collect(Collectors.toList());
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/AlliancesCommand.java

@@ -1,71 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class AlliancesCommand {
-    public AlliancesCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.clan.alliances"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.anyone.alliances")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        List<Clan> clans = plugin.getClanManager().getClans();
-        plugin.getClanManager().sortClansByKDR(clans);
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("alliances") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-
-        chatBlock.setAlignment("l", "l");
-        chatBlock.addRow("  " + headColor + plugin.getLang("clan"), plugin.getLang("allies"));
-
-        for (Clan clan : clans) {
-            if (!clan.isVerified()) {
-                continue;
-            }
-
-            chatBlock.addRow("  " + ChatColor.AQUA + clan.getName(), clan.getAllyString(ChatColor.DARK_GRAY + ", "));
-        }
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/AllyCommand.java

@@ -1,100 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class AllyCommand {
-    public AllyCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.ally")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-
-        if (arg.length != 2) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.ally"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        if (clan.getSize() < plugin.getSettingsManager().getClanMinSizeToAlly()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("minimum.to.make.alliance"), plugin.getSettingsManager().getClanMinSizeToAlly()));
-            return;
-        }
-
-        String action = arg[0];
-        Clan ally = plugin.getClanManager().getClan(arg[1]);
-
-        if (ally == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-            return;
-        }
-
-        if (!ally.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("cannot.ally.with.an.unverified.clan"));
-        }
-
-        if (action.equals(plugin.getLang("add"))) {
-            if (clan.isAlly(ally.getTag())) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clans.are.already.allies"));
-                return;
-            }
-
-            List<ClanPlayer> onlineLeaders = Helper.stripOffLinePlayers(clan.getLeaders());
-
-            if (onlineLeaders.isEmpty()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("at.least.one.leader.accept.the.alliance"));
-                return;
-            }
-
-            plugin.getRequestManager().addAllyRequest(cp, ally, clan);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("leaders.have.been.asked.for.an.alliance"), Helper.capitalize(ally.getName())));
-        } else if (action.equals(plugin.getLang("remove"))) {
-            if (!clan.isAlly(ally.getTag())) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clans.are.not.allies"));
-                return;
-            }
-
-            clan.removeAlly(ally);
-            ally.addBb(cp.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.broken.the.alliance"), Helper.capitalize(clan.getName()), ally.getName()), false);
-            clan.addBb(cp.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.broken.the.alliance"), Helper.capitalize(cp.getName()), Helper.capitalize(ally.getName())));
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.ally"), plugin.getSettingsManager().getCommandClan()));
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/BanCommand.java

@@ -1,73 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.UUID;
-
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-
-/**
- * @author phaed
- */
-public class BanCommand {
-    public BanCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.ban")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, MessageFormat.format(plugin.getLang("usage.ban.unban"), ChatColor.RED, plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String banned = arg[0];
-
-        if (SimpleClans.getInstance().hasUUID()) {
-            UUID PlayerUniqueId = UUIDMigration.getForcedPlayerUUID(banned);
-            if (plugin.getSettingsManager().isBanned(PlayerUniqueId)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.already.banned"));
-                return;
-            }
-
-            Player pl = SimpleClans.getInstance().getServer().getPlayer(PlayerUniqueId);
-
-            if (pl != null) {
-                ChatBlock.sendMessage(pl, ChatColor.AQUA + plugin.getLang("you.banned"));
-            }
-
-            plugin.getClanManager().ban(banned);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("player.added.to.banned.list"));
-        } else {
-            if (plugin.getSettingsManager().isBanned(banned)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.already.banned"));
-                return;
-            }
-
-            Player pl = SimpleClans.getInstance().getServer().getPlayerExact(banned);
-
-            if (pl != null) {
-                ChatBlock.sendMessage(pl, ChatColor.AQUA + plugin.getLang("you.banned"));
-            }
-
-            plugin.getClanManager().ban(banned);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("player.added.to.banned.list"));
-        }
-
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/BankCommand.java

@@ -1,92 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class BankCommand {
-
-    public BankCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.bank")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-        double plmoney = plugin.getPermissionsManager().playerGetMoney(player);
-        double money = 0;
-        Clan clan = cp.getClan();
-
-        if (clan == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        double clanbalance = clan.getBalance();
-
-        if (clan.isMember(player)) {
-            if (!clan.isVerified()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-                return;
-            }
-            if (!cp.isTrusted()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.stats"));
-                return;
-            }
-
-            if (arg.length == 1) {
-                if (arg[0].equalsIgnoreCase("status")) {
-                      player.sendMessage(ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.balance"), clanbalance));
-                }
-            } else if (arg.length == 2) {
-                if (arg[1].matches("[0-9]+")) {
-                    money = Double.parseDouble(arg[1]);
-                }
-                if (arg[0].equalsIgnoreCase("deposit")) {
-                    if (!cp.getClan().isLeader(player) && !clan.isAllowDeposit()) {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                        return;
-                    }
-                    if (arg[1].equalsIgnoreCase("all")) {
-                        clan.deposit(plmoney, player);
-                    } else {
-                        clan.deposit(money, player);
-                    }
-                } else if (arg[0].equalsIgnoreCase("withdraw")) {
-                    if (!cp.getClan().isLeader(player) && !clan.isAllowWithdraw()) {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                        return;
-                    }
-                    if (arg[1].equalsIgnoreCase("all")) {
-                        clan.withdraw(clanbalance, player);
-                    } else {
-                        clan.withdraw(money, player);
-                    }
-                } else {
-                    ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.bank"), plugin.getSettingsManager().getCommandClan()));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.bank"), plugin.getSettingsManager().getCommandClan()));
-            }
-        }
-
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/BbCommand.java

@@ -1,75 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-/**
- * @author phaed
- */
-public class BbCommand {
-
-    public BbCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-
-        if (arg.length == 0) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.member.bb")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            clan.displayBb(player);
-            return;
-        }
-
-        if (arg.length == 1 && arg[0].equalsIgnoreCase("clear")) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.bb-clear")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            if (!cp.isTrusted() || !cp.isLeader()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                return;
-            }
-            cp.getClan().clearBb();
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("cleared.bb"));
-            return;
-        }
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.bb-add")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-
-        String msg = Helper.toMessage(arg);
-        clan.addBb(player.getName(), ChatColor.AQUA + player.getName() + ": " + ChatColor.WHITE + msg);
-        plugin.getStorageManager().updateClan(clan);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ClanInput.java

@@ -0,0 +1,32 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands;
+
+import net.sacredlabyrinth.phaed.simpleclans.Clan;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class ClanInput {
+
+    private final Clan clan;
+
+    public ClanInput(@NotNull Clan clan) {
+        this.clan = clan;
+    }
+
+    public Clan getClan() {
+        return clan;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ClanInput clanInput = (ClanInput) o;
+        return clan.equals(clanInput.clan);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(clan);
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ClanPlayerInput.java

@@ -0,0 +1,32 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands;
+
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class ClanPlayerInput {
+
+    private final ClanPlayer clanPlayer;
+
+    public ClanPlayerInput(@NotNull ClanPlayer clanPlayer) {
+        this.clanPlayer = clanPlayer;
+    }
+
+    public ClanPlayer getClanPlayer() {
+        return clanPlayer;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        ClanPlayerInput that = (ClanPlayerInput) o;
+        return clanPlayer.equals(that.clanPlayer);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(clanPlayer);
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ClanffCommand.java

@@ -1,69 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class ClanffCommand {
-    public ClanffCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.ff")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.clanff"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String action = arg[0];
-
-        if (action.equalsIgnoreCase(plugin.getLang("allow"))) {
-            clan.addBb(player.getName(), ChatColor.AQUA + plugin.getLang("clan.wide.friendly.fire.is.allowed"));
-            clan.setFriendlyFire(true);
-            plugin.getStorageManager().updateClan(clan);
-            return;
-        }
-
-        if (!action.equalsIgnoreCase(plugin.getLang("block"))) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.clanff"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + plugin.getLang("clan.wide.friendly.fire.blocked"));
-        clan.setFriendlyFire(false);
-        plugin.getStorageManager().updateClan(clan);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/CoordsCommand.java

@@ -1,112 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.TreeMap;
-
-/**
- * @author phaed
- */
-public class CoordsCommand {
-    public CoordsCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.coords")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.coords"));
-            return;
-        }
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.coords"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        chatBlock.setFlexibility(true, false, false, false);
-        chatBlock.setAlignment("l", "c", "c", "c");
-
-        chatBlock.addRow("  " + headColor + plugin.getLang("name"), plugin.getLang("distance"), plugin.getLang("coords.upper"), plugin.getLang("world"));
-
-        List<ClanPlayer> members = Helper.stripOffLinePlayers(clan.getMembers());
-
-        Map<Integer, List<String>> rows = new TreeMap<>();
-
-        for (ClanPlayer cpm : members) {
-            Player p = cpm.toPlayer();
-
-            if (p != null) {
-                String name = (cpm.isLeader() ? plugin.getSettingsManager().getPageLeaderColor() : (cpm.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() : plugin.getSettingsManager().getPageUnTrustedColor())) + cpm.getName();
-                Location loc = p.getLocation();
-                int distance = (int) Math.ceil(loc.toVector().distance(player.getLocation().toVector()));
-                String coords = loc.getBlockX() + " " + loc.getBlockY() + " " + loc.getBlockZ();
-                String world = loc.getWorld().getName();
-
-                List<String> cols = new ArrayList<>();
-                cols.add("  " + name);
-                cols.add(ChatColor.AQUA + "" + distance);
-                cols.add(ChatColor.WHITE + "" + coords);
-                cols.add(world);
-                rows.put(distance, cols);
-            }
-        }
-
-        if (rows.isEmpty()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.are.the.only.member.online"));
-            return;
-        }
-
-        for (List<String> col : rows.values()) {
-            chatBlock.addRow(col.get(0), col.get(1), col.get(2), col.get(3));
-        }
-
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(clan.getName()) + subColor + " " + plugin.getLang("coords") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/CreateCommand.java

@@ -1,112 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class CreateCommand {
-    public CreateCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.create")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        if (arg.length < 2) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.create.tag"), plugin.getSettingsManager().getCommandClan()));
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("example.clan.create"));
-            return;
-        }
-
-        String tag = arg[0];
-        String cleanTag = Helper.cleanTag(arg[0]);
-
-        String name = Helper.toMessage(Helper.removeFirst(arg));
-
-        boolean bypass = plugin.getPermissionsManager().has(player, "simpleclans.mod.bypass");
-
-        if (!bypass) {
-            if (cleanTag.length() > plugin.getSettingsManager().getTagMaxLength()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.tag.cannot.be.longer.than.characters"), plugin.getSettingsManager().getTagMaxLength()));
-                return;
-            }
-            if (cleanTag.length() <= plugin.getSettingsManager().getTagMinLength()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.tag.must.be.longer.than.characters"), plugin.getSettingsManager().getTagMinLength()));
-                return;
-            }
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.coloredtag") && tag.contains("&")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.tag.cannot.contain.color.codes"));
-                return;
-            }
-            if (plugin.getSettingsManager().hasDisallowedColor(tag)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.tag.cannot.contain.the.following.colors"), plugin.getSettingsManager().getDisallowedColorString()));
-                return;
-            }
-            if (Helper.stripColors(name).length() > plugin.getSettingsManager().getClanMaxLength()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.name.cannot.be.longer.than.characters"), plugin.getSettingsManager().getClanMaxLength()));
-                return;
-            }
-            if (Helper.stripColors(name).length() <= plugin.getSettingsManager().getClanMinLength()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.name.must.be.longer.than.characters"), plugin.getSettingsManager().getClanMinLength()));
-                return;
-            }
-            if (plugin.getSettingsManager().isDisallowedWord(cleanTag.toLowerCase())) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("that.tag.name.is.disallowed"));
-                return;
-            }
-        }
-
-        if (!cleanTag.matches("[0-9a-zA-Z]*")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clan.tag.can.only.contain.letters.numbers.and.color.codes"));
-            return;
-        }
-        if (name.contains("&")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clan.name.cannot.contain.color.codes"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp != null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("you.must.first.resign"), cp.getClan().getName()));
-            return;
-        }
-        if (plugin.getClanManager().isClan(cleanTag)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.with.this.tag.already.exists"));
-            return;
-        }
-        if (plugin.getClanManager().purchaseCreation(player)) {
-            plugin.getClanManager().createClan(player, tag, name);
-
-            Clan clan = plugin.getClanManager().getClan(tag);
-            clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.created"), name));
-            plugin.getStorageManager().updateClan(clan);
-
-            if (plugin.getSettingsManager().isRequireVerification()) {
-                boolean verified = !plugin.getSettingsManager().isRequireVerification() || plugin.getPermissionsManager().has(player, "simpleclans.mod.verify");
-
-                if (!verified) {
-                    ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("get.your.clan.verified.to.access.advanced.features"));
-                }
-            }
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/DemoteCommand.java

@@ -1,126 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.UUID;
-
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-
-/**
- * @author phaed
- */
-public class DemoteCommand {
-
-    public DemoteCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.demote.leader"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String demotedName = arg[0];
-
-        if (demotedName == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        final boolean hasUUID = SimpleClans.getInstance().hasUUID();
-        ClanPlayer toDemote;
-        if (hasUUID) {
-            UUID uuid = UUIDMigration.getForcedPlayerUUID(demotedName);
-            toDemote = plugin.getClanManager().getAnyClanPlayer(uuid);
-        } else {
-            toDemote = plugin.getClanManager().getAnyClanPlayer(demotedName);
-        }
-        
-        if (plugin.getPermissionsManager().has(player, "simpleclans.admin.demote")) {
-            if (!toDemote.isLeader()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("player.is.not.a.leader.of.any.clan"));
-                return;
-            }
-            final Clan clan = toDemote.getClan();
-
-            if (clan.getLeaders().size() == 1) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.demote.the.last.leader"));
-                return;
-            }
-
-            if (hasUUID) {
-                clan.demote(toDemote.getUniqueId());
-            } else {
-                clan.demote(demotedName);
-            }
-            clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("demoted.back.to.member"), Helper.capitalize(demotedName)));
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("player.successfully.demoted"));
-            return;
-        }
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.demote")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }        
-
-        if (!clan.enoughLeadersOnlineToDemote(toDemote)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.enough.leaders.online.to.vote.on.demotion"));
-            return;
-        }
-
-        if (hasUUID) {
-            UUID uuid = UUIDMigration.getForcedPlayerUUID(demotedName);
-            if (!clan.isLeader(uuid)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("player.is.not.a.leader.of.your.clan"));
-                return;
-            }
-            if (clan.getLeaders().size() != 1 && plugin.getSettingsManager().isConfirmationForDemote()) {
-                plugin.getRequestManager().addDemoteRequest(cp, demotedName, clan);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("demotion.vote.has.been.requested.from.all.leaders"));
-                return;
-            }
-            clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("demoted.back.to.member"), Helper.capitalize(demotedName)));
-            clan.demote(uuid);
-        } else {
-            if (!clan.isLeader(demotedName)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("player.is.not.a.leader.of.your.clan"));
-                return;
-            }
-            if (clan.getLeaders().size() != 1 && plugin.getSettingsManager().isConfirmationForDemote()) {
-                plugin.getRequestManager().addDemoteRequest(cp, demotedName, clan);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("demotion.vote.has.been.requested.from.all.leaders"));
-                return;
-            }
-            clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("demoted.back.to.member"), Helper.capitalize(demotedName)));
-            clan.demote(demotedName);
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/DescriptionCommand.java

@@ -1,68 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.MessageFormat;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-
-public class DescriptionCommand {
-
-	/**
-	 * Execute the command
-	 *
-	 * @param player
-	 * @param args
-	 */
-	public void execute(Player player, String[] args) {
-		final SimpleClans plugin = SimpleClans.getInstance();
-		final SettingsManager sm = plugin.getSettingsManager();
-
-		if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.description")) {
-			ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-			return;
-		}
-
-		ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-		if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        
-        if (args.length < 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.description"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-        
-        String description = Helper.toMessage(args);
-        if (description.length() < sm.getClanMinDescriptionLength()) {
-        	ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.description.must.be.longer.than"), sm.getClanMinDescriptionLength()));
-        	return;
-        }
-        if (description.length() > sm.getClanMaxDescriptionLength()) {
-        	ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.description.cannot.be.longer.than"), sm.getClanMaxDescriptionLength()));
-        	return;
-        }
-
-        clan.setDescription(description);
-        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("description.changed"));
-        plugin.getStorageManager().updateClanAsync(clan);
-	}
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/DisbandCommand.java

@@ -1,78 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class DisbandCommand {
-    public DisbandCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (arg.length == 0) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.disband")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-            if (cp == null) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-                return;
-            }
-
-            Clan clan = cp.getClan();
-
-            if (!clan.isLeader(player)) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                return;
-            }
-            if (clan.getLeaders().size() != 1) {
-                plugin.getRequestManager().addDisbandRequest(cp, clan);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("clan.disband.vote.has.been.requested.from.all.leaders"));
-                return;
-            }
-
-            clan.clanAnnounce(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.has.been.disbanded"), clan.getName()));
-            clan.disband();
-            return;
-        }
-
-        if (arg.length > 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.disband"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.disband")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        Clan clan = plugin.getClanManager().getClan(arg[0]);
-
-        if (clan == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-            return;
-        }
-
-        plugin.getClanManager().serverAnnounce(ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.has.been.disbanded"), clan.getName()));
-        clan.disband();
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/FeeCommand.java

@@ -1,85 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.MessageFormat;
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-/**
- *
- * @author roinujnosde
- */
-public class FeeCommand {
-
-    /**
-     * Executes the command
-     *
-     * @param player
-     * @param args
-     */
-    public void execute(Player player, String[] args) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        if (!plugin.getSettingsManager().isMemberFee()) {
-            return;
-        }
-
-        if (args.length >= 1) {
-            ClanPlayer cp = plugin.getClanManager().getAnyClanPlayer(player.getUniqueId());
-            Clan clan = cp.getClan();
-            if (!clan.isVerified()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-                return;
-            }
-
-            if (args[0].equalsIgnoreCase("check")) {
-                if (!plugin.getPermissionsManager().has(player, "simpleclans.member.fee-check")) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                    return;
-                }
-                ChatBlock.sendMessage(player, ChatColor.AQUA
-                        + MessageFormat.format(
-                                plugin.getLang("the.fee.is.0.and.its.current.value.is.1"),
-                                clan.isMemberFeeEnabled() ? plugin.getLang("fee.enabled") : plugin.getLang("fee.disabled"),
-                                clan.getMemberFee()
-                        ));
-                return;
-            }
-            if (args.length == 2 && args[0].equalsIgnoreCase("set")) {
-                if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.fee")) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                    return;
-                }
-                if (!cp.isLeader()) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                    return;
-                }
-                double newFee = 0;
-                try {
-                    newFee = Double.parseDouble(args[1]);
-                } catch (NumberFormatException ignored) {
-                    player.sendMessage(ChatColor.RED + plugin.getLang("invalid.fee"));
-                    return;
-                }
-                double maxFee = plugin.getSettingsManager().getMaxMemberFee();
-                if (newFee > maxFee) {
-                    ChatBlock.sendMessage(player, ChatColor.RED
-                            + MessageFormat.format(plugin.getLang("max.fee.allowed.is.0"), maxFee));
-                    return;
-                }
-                
-                if (plugin.getClanManager().purchaseMemberFeeSet(player)) {
-                    clan.setMemberFee(newFee);
-                    clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("bb.fee.set"), newFee));
-                    ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("fee.set"));
-                    plugin.getStorageManager().updateClanAsync(clan);                    
-                }
-                return;
-            }
-        }
-        ChatBlock.sendMessage(player, ChatColor.RED
-                + MessageFormat.format(plugin.getLang("usage.fee"), plugin.getSettingsManager().getCommandClan()));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/FfCommand.java

@@ -1,61 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class FfCommand {
-    public FfCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.ff")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.ff.allow.auto"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String action = arg[0];
-
-        if (action.equalsIgnoreCase(plugin.getLang("allow"))) {
-            cp.setFriendlyFire(true);
-            plugin.getStorageManager().updateClanPlayer(cp);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("personal.friendly.fire.is.set.to.allowed"));
-            return;
-        }
-
-        if (action.equalsIgnoreCase(plugin.getLang("auto"))) {
-            cp.setFriendlyFire(false);
-            plugin.getStorageManager().updateClanPlayer(cp);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("friendy.fire.is.now.managed.by.your.clan"));
-            return;
-        }
-
-        ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.ff.allow.auto"), plugin.getSettingsManager().getCommandClan()));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/GlobalffCommand.java

@@ -1,55 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class GlobalffCommand {
-    public GlobalffCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(CommandSender player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.ff.allow.auto"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String action = arg[0];
-
-        if (action.equalsIgnoreCase(plugin.getLang("allow"))) {
-            if (plugin.getSettingsManager().isGlobalff()) {
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("global.friendly.fire.is.already.being.allowed"));
-            } else {
-                plugin.getSettingsManager().setGlobalff(true);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("global.friendly.fire.is.set.to.allowed"));
-            }
-            return;
-        }
-
-        if (action.equalsIgnoreCase(plugin.getLang("auto"))) {
-            if (!plugin.getSettingsManager().isGlobalff()) {
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("global.friendy.fire.is.already.being.managed.by.each.clan"));
-            } else {
-                plugin.getSettingsManager().setGlobalff(false);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("global.friendy.fire.is.now.managed.by.each.clan"));
-            }
-            return;
-        }
-        ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.globalff.allow.auto"), plugin.getSettingsManager().getCommandClan()));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/HomeCommand.java

@@ -1,209 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-import java.util.Random;
-import net.sacredlabyrinth.phaed.simpleclans.events.HomeRegroupEvent;
-import net.sacredlabyrinth.phaed.simpleclans.events.PlayerHomeSetEvent;
-
-/**
- * @author phaed
- */
-public class HomeCommand {
-
-    public HomeCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (arg.length == 2) {
-            if (arg[0].equalsIgnoreCase("set") && plugin.getPermissionsManager().has(player, "simpleclans.mod.home")) {
-                if (!plugin.getClanManager().purchaseHomeTeleportSet(player)) {
-                    return;
-                }
-
-                Location loc = player.getLocation();
-                Clan clan = plugin.getClanManager().getClan(arg[1]);
-
-                if (clan == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.does.not.exist"));
-                    return;
-                }
-
-                clan.setHomeLocation(loc);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("hombase.mod.set"), clan.getName()) + " " + ChatColor.YELLOW + Helper.toLocationString(loc));
-                return;
-            }
-
-            if (arg[0].equalsIgnoreCase("tp") && plugin.getPermissionsManager().has(player, "simpleclans.mod.hometp")) {
-                Clan clan = plugin.getClanManager().getClan(arg[1]);
-
-                if (clan == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.does.not.exist"));
-                    return;
-                }
-
-                Location loc = clan.getHomeLocation();
-
-                if (loc == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("hombase.not.set"));
-                    return;
-                }
-
-                player.teleport(loc);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("now.at.homebase"), clan.getName()));
-                return;
-            }
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.vitals"));
-            return;
-        }
-
-        if (arg.length == 0) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.member.home")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-
-            Location loc = clan.getHomeLocation();
-
-            if (loc == null) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("hombase.not.set"));
-                return;
-            }
-
-            if (plugin.getClanManager().purchaseHomeTeleport(player)) {
-                plugin.getTeleportManager().addPlayer(player, clan.getHomeLocation(), clan.getName());
-            }
-            return;
-        }
-
-        if (arg[0].equalsIgnoreCase("set")) {
-            if (!cp.isLeader()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                return;
-            }
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.home-set")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            if (plugin.getSettingsManager().isHomebaseSetOnce() && clan.getHomeLocation() != null && !plugin.getPermissionsManager().has(player, "simpleclans.mod.home")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("home.base.only.once"));
-                return;
-            }
-
-            PlayerHomeSetEvent homeSetEvent = new PlayerHomeSetEvent(clan, cp, player.getLocation());
-            SimpleClans.getInstance().getServer().getPluginManager().callEvent(homeSetEvent);
-
-            if (homeSetEvent.isCancelled() || !plugin.getClanManager().purchaseHomeTeleportSet(player)) {
-                return;
-            }
-
-            clan.setHomeLocation(player.getLocation());
-            ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("hombase.set"), ChatColor.YELLOW + Helper.toLocationString(player.getLocation())));
-            return;
-        }
-
-        if (arg[0].equalsIgnoreCase("clear")) {
-            if (!cp.isLeader()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                return;
-            }
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.home-set")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            if (plugin.getSettingsManager().isHomebaseSetOnce() && clan.getHomeLocation() != null && !plugin.getPermissionsManager().has(player, "simpleclans.mod.home")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("home.base.only.once"));
-                return;
-            }
-
-            clan.setHomeLocation(null);
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("hombase.cleared"));
-            return;
-        }
-
-        if (arg[0].equalsIgnoreCase("regroup")) {
-            if (!SimpleClans.getInstance().getSettingsManager().getAllowReGroupCommand()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            Location loc;
-            if (arg.length >= 2 && arg[1].equalsIgnoreCase("me")) {
-                loc = player.getLocation();
-            } else {
-                loc = cp.getClan().getHomeLocation();
-            }
-
-            if (!cp.isLeader()) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            }
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.home-regroup")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-
-            HomeRegroupEvent homeRegroupEvent = new HomeRegroupEvent(clan, cp, clan.getOnlineMembers(), loc);
-            SimpleClans.getInstance().getServer().getPluginManager().callEvent(homeRegroupEvent);
-
-            if (homeRegroupEvent.isCancelled() || !plugin.getClanManager().purchaseHomeRegroup(player)) {
-                return;
-            }
-
-            List<ClanPlayer> members = clan.getOnlineMembers();
-            for (ClanPlayer ccp : members) {
-                Player pl = ccp.toPlayer();
-                if (pl == null) {
-                    continue;
-                }
-                int x = loc.getBlockX();
-                int z = loc.getBlockZ();
-                player.sendBlockChange(new Location(loc.getWorld(), x + 1, loc.getBlockY(), z + 1), Material.GLASS, (byte) 0);
-                player.sendBlockChange(new Location(loc.getWorld(), x - 1, loc.getBlockY(), z - 1), Material.GLASS, (byte) 0);
-                player.sendBlockChange(new Location(loc.getWorld(), x + 1, loc.getBlockY(), z - 1), Material.GLASS, (byte) 0);
-                player.sendBlockChange(new Location(loc.getWorld(), x - 1, loc.getBlockY(), z + 1), Material.GLASS, (byte) 0);
-                Random r = new Random();
-                int xx = r.nextInt(2) - 1;
-                int zz = r.nextInt(2) - 1;
-                if (xx == 0 && zz == 0) {
-                    xx = 1;
-                }
-                x = x + xx;
-                z = z + zz;
-                
-                plugin.getTeleportManager().addPlayer(player, new Location(loc.getWorld(), x + .5, loc.getBlockY(), z + .5), clan.getName());
-            }
-            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("hombase.set") + ChatColor.YELLOW + Helper.toLocationString(loc));
-            return;
-        }
-
-        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/InviteCommand.java

@@ -1,105 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.MessageFormat;
-import java.time.Instant;
-import java.time.temporal.ChronoUnit;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-
-/**
- * @author phaed
- */
-public class InviteCommand {
-    public InviteCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.invite")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.invite.player"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        Player invited = Helper.getPlayer(arg[0]);
-
-        if (invited == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        if (!plugin.getPermissionsManager().has(invited, "simpleclans.member.can-join")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.doesn.t.not.have.the.permissions.to.join.clans"));
-            return;
-        }
-        if (invited.getName().equals(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.invite.yourself"));
-            return;
-        }
-        if (plugin.getSettingsManager().isBanned(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.banned.from.using.clan.commands"));
-            return;
-        }
-
-        ClanPlayer cpInv = plugin.getClanManager().getAnyClanPlayer(invited.getUniqueId());
-
-        if (cpInv != null) {
-        	if (cpInv.getClan() != null) {
-        		ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.already.member.of.another.clan"));
-        		return;
-        	}
-        	if (plugin.getSettingsManager().isRejoinCooldown()) {
-	        	Long resign = cpInv.getResignTime(clan.getTag());
-	        	if (resign != null) {
-	        		long timePassed = Instant.ofEpochMilli(resign).until(Instant.now(), ChronoUnit.MINUTES);
-	        		int cooldown = plugin.getSettingsManager().getRejoinCooldown();
-	        		if (timePassed < cooldown) {
-	        			ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("the.player.must.wait.0.before.joining.your.clan.again"), cooldown - timePassed));
-	        			return;
-	        		}
-	        	}
-        	}
-        }
-        
-        if (!plugin.getClanManager().purchaseInvite(player)) {
-            return;
-        }
-        if (clan.getSize() >= plugin.getSettingsManager().getMaxMembers()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.members.reached.limit"));
-            return;
-        }
-        
-        plugin.getRequestManager().addInviteRequest(cp, invited.getName(), clan);
-        ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.been.asked.to.join"), Helper.capitalize(invited.getName()), clan.getName()));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/KickCommand.java

@@ -1,81 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-
-/**
- * @author phaed
- */
-public class KickCommand {
-    public KickCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.kick")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.kick.player"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String kicked = arg[0];
-
-        if (kicked == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        if (kicked.equalsIgnoreCase(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.kick.yourself"));
-            return;
-        }
-        if (!clan.isMember(kicked)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.not.a.member.of.your.clan"));
-            return;
-        }
-        if (clan.isLeader(kicked)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.kick.another.leader"));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.been.kicked.by"), Helper.capitalize(kicked), player.getName()));
-
-        if (SimpleClans.getInstance().hasUUID()) {
-            clan.removePlayerFromClan(UUIDMigration.getForcedPlayerUUID(kicked));
-        } else {
-            clan.removePlayerFromClan(kicked);
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/KillsCommand.java

@@ -1,90 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-public class KillsCommand {
-    public KillsCommand() {
-
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.kills")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.stats"));
-            return;
-        }
-
-        String polledPlayerName = player.getName();
-
-        if (arg.length == 1) {
-            polledPlayerName = arg[0];
-        }
-
-        ChatBlock chatBlock = new ChatBlock();
-        chatBlock.setFlexibility(true, false);
-        chatBlock.setAlignment("l", "c");
-        chatBlock.addRow("  " + headColor + plugin.getLang("victim"), plugin.getLang("killcount"));
-
-        Map<String, Integer> killsPerPlayerUnordered = plugin.getStorageManager().getKillsPerPlayer(polledPlayerName);
-
-        if (killsPerPlayerUnordered.isEmpty()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("nokillsfound"));
-            return;
-        }
-
-        Map<String, Integer> killsPerPlayer = Helper.sortByValue(killsPerPlayerUnordered);
-
-        for (Entry<String, Integer> playerKills : killsPerPlayer.entrySet()) {
-            int count = playerKills.getValue();
-            chatBlock.addRow("  " + playerKills.getKey(), ChatColor.AQUA + "" + count);
-        }
-
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(polledPlayerName) + subColor + " " + plugin.getLang("kills") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/LeaderboardCommand.java

@@ -1,91 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.DecimalFormat;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class LeaderboardCommand {
-    public LeaderboardCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-        NumberFormat formatter = new DecimalFormat("#.#");
-
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.leaderboard"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.anyone.leaderboard")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        List<ClanPlayer> clanPlayers = plugin.getClanManager().getAllClanPlayers();
-        plugin.getClanManager().sortClanPlayersByKDR(clanPlayers);
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("leaderboard.command") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-        ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("total.clan.players.0"), subColor + clanPlayers.size()));
-        ChatBlock.sendBlank(player);
-
-        chatBlock.setAlignment("c", "l", "c", "c", "c", "c");
-        chatBlock.addRow("  " + headColor + plugin.getLang("rank"), plugin.getLang("player"), plugin.getLang("kdr"), plugin.getLang("clan"), plugin.getLang("seen"));
-
-        int rank = 1;
-
-        for (ClanPlayer cp : clanPlayers) {
-            Player p = cp.toPlayer();
-
-            boolean isOnline = false;
-
-            if (p != null) {
-                isOnline = true;
-            }
-
-            String name = (cp.isLeader() ? plugin.getSettingsManager().getPageLeaderColor() : (cp.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() : plugin.getSettingsManager().getPageUnTrustedColor())) + cp.getName();
-            String lastSeen = isOnline ? ChatColor.GREEN + plugin.getLang("online") : ChatColor.WHITE + cp.getLastSeenDaysString();
-
-            String clanTag = ChatColor.WHITE + plugin.getLang("free.agent");
-
-            if (cp.getClan() != null) {
-                clanTag = cp.getClan().getColorTag();
-            }
-
-            chatBlock.addRow("  " + rank, name, ChatColor.YELLOW + "" + formatter.format(cp.getKDR()), ChatColor.WHITE + clanTag, lastSeen);
-            rank++;
-        }
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ListCommand.java

@@ -1,137 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.DecimalFormat;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-import java.util.List;
-
-
-/**
- * @author phaed
- */
-public class ListCommand {
-    public ListCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param args
-     */
-    public void execute(Player player, String[] args) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-        NumberFormat formatter = new DecimalFormat("#.#");
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.anyone.list")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        if (args.length > 2) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.list"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-        List<Clan> clans = plugin.getClanManager().getClans();
-
-        sort(plugin, clans, args);
-
-        if (clans.isEmpty()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clans.have.been.created"));
-            return;
-        }
-
-        ChatBlock chatBlock = new ChatBlock();
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("clans.lower") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("total.clans") + " " + subColor + clans.size());
-        ChatBlock.sendBlank(player);
-        chatBlock.setAlignment("c", "l", "c", "c");
-        chatBlock.setFlexibility(false, true, false, false);
-        chatBlock.addRow("  " + headColor + plugin.getLang("rank"), plugin.getLang("name"), plugin.getLang("kdr"), plugin.getLang("members"));
-
-        int rank = 1;
-
-        for (Clan clan : clans) {
-            if (!plugin.getSettingsManager().isShowUnverifiedOnList() && !clan.isVerified()) {
-                continue;
-            }
-
-            String tag = plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketLeft() + plugin.getSettingsManager().getTagDefaultColor() + clan.getColorTag() + plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketRight();
-            String name = (clan.isVerified() ? plugin.getSettingsManager().getPageClanNameColor() : ChatColor.GRAY) + clan.getName();
-            String fullname = tag + " " + name;
-            String size = ChatColor.WHITE + "" + clan.getSize();
-            String kdr = clan.isVerified() ? ChatColor.YELLOW + "" + formatter.format(clan.getTotalKDR()) : "";
-
-            chatBlock.addRow("  " + rank, fullname, kdr, size);
-            rank++;
-        }
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-
-	private void sort(SimpleClans plugin, List<Clan> clans, String[] args) {
-		SettingsManager sm = plugin.getSettingsManager();
-		String type = sm.getListDefault();
-        String order = null;
-        if (args.length > 0) {
-        	type = args[0];
-        }
-        String asc = sm.getListAsc();
-        String desc = sm.getListDesc();
-        if (args.length == 2) {
-        	order = args[1];
-        	if (!order.equalsIgnoreCase(asc) && !order.equalsIgnoreCase(desc)) {
-        		order = null;
-        	}
-        }
-        ClanManager cm = plugin.getClanManager();
-        //in case the default type is invalid
-        cm.sortClansByKDR(clans);
-        
-		if (type.equalsIgnoreCase(sm.getListActive())) {
-        	cm.sortClansByActive(clans, asc.equalsIgnoreCase(order));
-        }
-        if (type.equalsIgnoreCase(sm.getListFounded())) {
-        	if (order == null) {
-        		order = asc;
-        	}
-        	cm.sortClansByFounded(clans, asc.equalsIgnoreCase(order));
-        }
-        if (type.equalsIgnoreCase(sm.getListKdr())) {
-        	cm.sortClansByKDR(clans, asc.equalsIgnoreCase(order));
-        }
-        if (type.equalsIgnoreCase(sm.getListName())) {
-        	if (order == null) {
-        		order = asc;
-        	}
-        	cm.sortClansByName(clans, asc.equalsIgnoreCase(order));
-        }
-        if (type.equalsIgnoreCase(sm.getListSize())) {
-        	cm.sortClansBySize(clans, asc.equalsIgnoreCase(order));
-        }
-	}
-}
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/LookupCommand.java

@@ -1,111 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.DecimalFormat;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-
-/**
- * @author phaed
- */
-public class LookupCommand {
-    public LookupCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-        NumberFormat formatter = new DecimalFormat("#.#");
-
-        String playerName = null;
-
-        if (arg.length == 0) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.member.lookup")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            playerName = player.getName();
-        } else if (arg.length == 1) {
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.anyone.lookup")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            playerName = arg[0];
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.lookup.tag"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        ClanPlayer targetCp = plugin.getClanManager().getAnyClanPlayer(playerName);
-        ClanPlayer myCp = plugin.getClanManager().getClanPlayer(player.getName());
-        Clan myClan = myCp == null ? null : myCp.getClan();
-
-        if (targetCp != null) {
-            Clan targetClan = targetCp.getClan();
-
-            ChatBlock.sendBlank(player);
-            ChatBlock.saySingle(player, MessageFormat.format(plugin.getLang("s.player.info"), plugin.getSettingsManager().getPageClanNameColor() + targetCp.getName() + subColor) + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-            ChatBlock.sendBlank(player);
-
-            String clanName = ChatColor.WHITE + plugin.getLang("none");
-
-            if (targetClan != null) {
-                clanName = plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketLeft() + plugin.getSettingsManager().getTagDefaultColor() + targetClan.getColorTag() + plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketRight() + " " + plugin.getSettingsManager().getPageClanNameColor() + targetClan.getName();
-            }
-
-            String status = targetClan == null ? ChatColor.WHITE + plugin.getLang("free.agent") : (targetCp.isLeader() ? plugin.getSettingsManager().getPageLeaderColor() + plugin.getLang("leader") : (targetCp.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() + plugin.getLang("trusted") : plugin.getSettingsManager().getPageUnTrustedColor() + plugin.getLang("untrusted")));
-            String rank = ChatColor.WHITE + "" + Helper.parseColors(targetCp.getRank());
-            String joinDate = ChatColor.WHITE + "" + targetCp.getJoinDateString();
-            String lastSeen = ChatColor.WHITE + "" + targetCp.getLastSeenString();
-            String inactive = ChatColor.WHITE + "" + targetCp.getInactiveDays() + subColor + "/" + ChatColor.WHITE + plugin.getSettingsManager().getPurgePlayers() + " days";
-            String rival = ChatColor.WHITE + "" + targetCp.getRivalKills();
-            String neutral = ChatColor.WHITE + "" + targetCp.getNeutralKills();
-            String civilian = ChatColor.WHITE + "" + targetCp.getCivilianKills();
-            String deaths = ChatColor.WHITE + "" + targetCp.getDeaths();
-            String kdr = ChatColor.YELLOW + "" + formatter.format(targetCp.getKDR());
-            String pastClans = ChatColor.WHITE + "" + targetCp.getPastClansString(headColor + ", ");
-
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("clan.0"), clanName));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("rank.0"), rank));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("status.0"), status));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("kdr.0"), kdr));
-            ChatBlock.sendMessage(player, "  " + subColor + plugin.getLang("kill.totals") + " " + headColor + "[" + plugin.getLang("rival") + ":" + rival + " " + headColor + "" + plugin.getLang("neutral") + ":" + neutral + " " + headColor + "" + plugin.getLang("civilian") + ":" + civilian + headColor + "]");
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("deaths.0"), deaths));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("join.date.0"), joinDate));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("last.seen.0"), lastSeen));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("past.clans.0"), pastClans));
-            ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("inactive.0"), inactive));
-
-            if (arg.length == 1 && !targetCp.equals(myCp)) {
-                String killType = ChatColor.GRAY + plugin.getLang("neutral");
-
-                if (targetClan == null) {
-                    killType = ChatColor.DARK_GRAY + plugin.getLang("civilian");
-                } else if (myClan != null && myClan.isRival(targetClan.getTag())) {
-                    killType = ChatColor.WHITE + plugin.getLang("rival");
-                }
-
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("kill.type.0"), killType));
-            }
-
-            ChatBlock.sendBlank(player);
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.data.found"));
-
-            if (arg.length == 1 && myClan != null) {
-                ChatBlock.sendBlank(player);
-                ChatBlock.sendMessage(player, MessageFormat.format(plugin.getLang("kill.type.civilian"), ChatColor.DARK_GRAY));
-            }
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/MenuCommand.java

@@ -1,298 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.LinkedList;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class MenuCommand {
-    private List<String> menuItems = new LinkedList<>();
-
-    public MenuCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     */
-    public void execute(Player player) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-        Clan clan = cp == null ? null : cp.getClan();
-
-        boolean isLeader = cp != null && cp.isLeader();
-        boolean isTrusted = cp != null && cp.isTrusted();
-        boolean isVerified = clan != null && clan.isVerified();
-        boolean isNonVerified = clan != null && !clan.isVerified();
-
-        String clanCommand = plugin.getSettingsManager().getCommandClan();
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        if (clan == null && plugin.getPermissionsManager().has(player, "simpleclans.leader.create")) {
-            if (plugin.getSettingsManager().isePurchaseCreation()) {
-                chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.create.tag.name.1.purchase.a.new.clan"), clanCommand, ChatColor.WHITE));
-            } else {
-                chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.create.tag.name.1.create.a.new.clan"), clanCommand, ChatColor.WHITE));
-            }
-        }
-        if (isNonVerified && plugin.getSettingsManager().isRequireVerification() && plugin.getSettingsManager().isePurchaseVerification()) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.verify.1.purchase.verification.of.your.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.list")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.list.1.lists.all.clans"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && plugin.getPermissionsManager().has(player, "simpleclans.member.profile")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.profile.1.view.your.clan.s.profile"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.profile")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.profile.tag.1.view.a.clan.s.profile"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.member.lookup")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.lookup.1.lookup.your.info"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.lookup")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.lookup.player.1.lookup.a.player.s.info"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.leaderboard")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.leaderboard.1.view.leaderboard"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.alliances")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.alliances.1.view.all.clan.alliances"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.rivalries")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.rivalries.1.view.all.clan.rivalries"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && plugin.getPermissionsManager().has(player, "simpleclans.member.roster")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.roster.1.view.your.clan.s.member.list"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.roster")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.roster.tag.1.view.a.clan.s.member.list"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.vitals")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.vitals.1.view.your.clan.member.s.vitals"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.coords")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.coords.1.view.your.clan.member.s.coordinates"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.stats")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.stats.1.view.your.clan.member.s.stats"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.kills")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.kills"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.kills")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.killsplayer"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && plugin.getPermissionsManager().has(player, "simpleclans.member.fee-check")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.fee.check"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.fee")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.fee.set"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.ally")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.ally.add.remove.tag.1.add.remove.an.ally.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.rival")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.rival.add.remove.tag.1.add.remove.a.rival.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && plugin.getPermissionsManager().has(player, "simpleclans.member.home")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("home-menu"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.home-set")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("home-set-menu"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.home-set")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("home-clear-menu"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.home-regroup")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("home-regroup-menu"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.war")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.war"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.member.resetkdr")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.resetkdr.1.resets.your.kdr"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && plugin.getPermissionsManager().has(player, "simpleclans.member.bb")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.bb.1.display.bulletin.board"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.bb-add")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.bb.msg.1.add.a.message.to.the.bulletin.board"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.modtag")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.modtag.tag.1.modify.the.clan.s.tag"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.description")) {
-        	chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.description.description.1.modify.the.clan.s.description"), clanCommand, ChatColor.WHITE));
-        }
-
-        String toggles = "";
-
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.bb-toggle")) {
-            toggles += "bb/";
-        }
-
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.member.tag-toggle")) {
-            toggles += "tag/";
-        }
-        
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.fee")) {
-            toggles += "fee/";
-        }
-
-        if (!toggles.isEmpty()) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.toggle.command"), clanCommand, ChatColor.WHITE, Helper.stripTrailing(toggles, "/")));
-        }
-
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.invite")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.invite.player.1.invite.a.player"), clanCommand, ChatColor.WHITE));
-        }
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.kick")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.kick.player.1.kick.a.player.from.the.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.setrank")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.trust.setrank"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.settrust")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.trust.untrust.player.1.set.trust.level1"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.settrust")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.trust.untrust.player.1.set.trust.level2"), clanCommand, ChatColor.WHITE));
-        }
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.promote")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.promote.member.1.promote.a.member.to.leader"), clanCommand, ChatColor.WHITE));
-        }
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.demote")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.demote.leader.1.demote.a.leader.to.member"), clanCommand, ChatColor.WHITE));
-        }
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.ff")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.clanff.allow.block.1.toggle.clan.s.friendly.fire"), clanCommand, ChatColor.WHITE));
-        }
-        if (isLeader && plugin.getPermissionsManager().has(player, "simpleclans.leader.disband")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.disband.1.disband.your.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.member.ff")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.ff.allow.auto.1.toggle.personal.friendly.fire"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.member.resign")) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + MessageFormat.format(plugin.getLang("0.resign.1.resign.from.the.clan"), clanCommand, ChatColor.WHITE));
-        }
-
-        for (String item : menuItems) {
-            chatBlock.addRow(ChatColor.AQUA + "  " + item);
-        }
-
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.verify") && plugin.getSettingsManager().isRequireVerification()) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.verify.tag.1.verify.an.unverified.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.place")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.place"), clanCommand, ChatColor.WHITE));
-        }
-        if (isVerified && isTrusted && plugin.getPermissionsManager().has(player, "simpleclans.mod.mostkilled")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.mostkilled"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.disband")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.disband.tag.1.disband.a.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.ban")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.ban.unban.player.1.ban.unban.a.player"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.hometp")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.hometp.clan.1.tp.home.a.clan"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.mod.globalff")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.globalff.allow.auto.1.set.global.friendly.fire"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.admin.demote")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.demote.leader.1.demote.a.leader.to.member"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.admin.purge")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.purge.player.1.purge.a.player"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.admin.resetkdr")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.resetkdr.1.resets.kdr"), clanCommand, ChatColor.WHITE));
-        }
-        if (plugin.getPermissionsManager().has(player, "simpleclans.admin.reload")) {
-            chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.reload.1.reload.configuration"), clanCommand, ChatColor.WHITE));
-        }
-        if (chatBlock.isEmpty()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("clan.commands") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param sender
-     */
-    public void executeSender(CommandSender sender) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        String clanCommand = plugin.getSettingsManager().getCommandClan();
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.purge.player.1.purge.a.player"), clanCommand, ChatColor.WHITE));
-        chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.verify.tag.1.verify.an.unverified.clan"), clanCommand, ChatColor.WHITE));
-        chatBlock.addRow(ChatColor.DARK_RED + "  " + MessageFormat.format(plugin.getLang("0.reload.1.reload.configuration"), clanCommand, ChatColor.WHITE));
-
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("clan.commands") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(sender);
-        chatBlock.sendBlock(sender, plugin.getSettingsManager().getPageSize());
-        ChatBlock.sendBlank(sender);
-    }
-
-    /**
-     * Adds a menu item to the /clan menu
-     *
-     * @param syntax
-     * @param description
-     */
-    public void addMenuItem(String syntax, String description) {
-        addMenuItem(syntax, description, ChatColor.AQUA);
-    }
-
-    /**
-     * Adds a menu item to the /clan menu, specifying syntax color
-     * [color] /[syntax] - [description]
-     *
-     * @param syntax
-     * @param description
-     * @param color
-     */
-    public void addMenuItem(String syntax, String description, ChatColor color) {
-        menuItems.add(color + "/" + syntax + ChatColor.WHITE + " - " + description);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ModtagCommand.java

@@ -1,85 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class ModtagCommand {
-    public ModtagCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.modtag")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.modtag.tag"), plugin.getSettingsManager().getCommandClan()));
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("example.clan.modtag.4kfo.4l"));
-            return;
-        }
-
-        String newtag = arg[0];
-        String cleantag = Helper.cleanTag(newtag);
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.coloredtag") && newtag.contains("&")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.tag.cannot.contain.color.codes"));
-            return;
-        }
-        if (Helper.stripColors(newtag).length() > plugin.getSettingsManager().getTagMaxLength()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.clan.tag.cannot.be.longer.than.characters"), plugin.getSettingsManager().getTagMaxLength()));
-            return;
-        }
-        if (plugin.getSettingsManager().hasDisallowedColor(newtag)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("your.tag.cannot.contain.the.following.colors"), plugin.getSettingsManager().getDisallowedColorString()));
-            return;
-        }
-        if (!Helper.stripColors(newtag).matches("[0-9a-zA-Z]*")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clan.tag.can.only.contain.letters.numbers.and.color.codes"));
-            return;
-        }
-        if (!cleantag.equals(clan.getTag())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.can.only.modify.the.color.and.case.of.the.tag"));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("tag.changed.to.0"), Helper.parseColors(newtag)));
-        clan.changeClanTag(newtag);
-        plugin.getClanManager().updateDisplayName(player.getPlayer());
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/MostKilledCommand.java

@@ -1,93 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-public class MostKilledCommand {
-    public MostKilledCommand() {
-
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.mostkilled")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.stats"));
-            return;
-        }
-
-        ChatBlock chatBlock = new ChatBlock();
-        chatBlock.setFlexibility(true, false, false);
-        chatBlock.setAlignment("l", "c", "l");
-        chatBlock.addRow("  " + headColor + plugin.getLang("victim"), headColor + plugin.getLang("killcount"), headColor + plugin.getLang("attacker"));
-
-        Map<String, Integer> killsPerPlayerUnordered = plugin.getStorageManager().getMostKilled();
-
-        if (killsPerPlayerUnordered.isEmpty()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("nokillsfound"));
-            return;
-        }
-
-        Map<String, Integer> killsPerPlayer = Helper.sortByValue(killsPerPlayerUnordered);
-
-        for (Entry<String, Integer> attackerVictim : killsPerPlayer.entrySet()) {
-            String[] split = attackerVictim.getKey().split(" ");
-
-            if (split.length < 2) {
-                continue;
-            }
-
-            int count = attackerVictim.getValue();
-            String attacker = split[0];
-            String victim = split[1];
-
-            chatBlock.addRow("  " + ChatColor.WHITE + victim, ChatColor.AQUA + "" + count, ChatColor.YELLOW + attacker);
-        }
-
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("mostkilled") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/PlaceCommand.java

@@ -1,83 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-public class PlaceCommand {
-    public PlaceCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param sender
-     * @param arg
-     */
-    public void execute(CommandSender sender, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (sender instanceof Player) {
-            Player player = (Player) sender;
-
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.place")) {
-                ChatBlock.sendMessage(sender, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-        }
-
-        if (arg.length != 2) {
-            ChatBlock.sendMessage(sender, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.place"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        Player player = Helper.getPlayer(arg[0]);
-
-        if (player == null) {
-            ChatBlock.sendMessage(sender, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-
-        Clan newClan = plugin.getClanManager().getClan(arg[1]);
-
-        if (newClan == null) {
-            ChatBlock.sendMessage(sender, ChatColor.RED + plugin.getLang("the.clan.does.not.exist"));
-            return;
-        }
-
-        ClanPlayer oldCp = plugin.getClanManager().getClanPlayer(player);
-
-        if (oldCp != null) {
-            Clan oldClan = oldCp.getClan();
-
-            if (oldClan.isLeader(player) && oldClan.getLeaders().size() <= 1) {
-                oldClan.clanAnnounce(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.has.been.disbanded"), oldClan.getName()));
-                oldClan.disband();
-            } else {
-                oldClan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("0.has.resigned"), Helper.capitalize(player.getName())));
-
-                if (SimpleClans.getInstance().hasUUID()) {
-                    oldClan.removePlayerFromClan(player.getUniqueId());
-                } else {
-                    oldClan.removePlayerFromClan(player.getName());
-                }
-            }
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getCreateClanPlayerUUID(player.getName());
-
-        if (cp == null) {
-            return;
-        }
-
-        newClan.addBb(ChatColor.AQUA + MessageFormat.format(plugin.getLang("joined.the.clan"), player.getName()));
-        plugin.getClanManager().serverAnnounce(MessageFormat.format(plugin.getLang("has.joined"), player.getName(), newClan.getName()));
-        newClan.addPlayerToClan(cp);
-
-    }
-}
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ProfileCommand.java

@@ -1,106 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.DecimalFormat;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-
-/**
- * @author phaed
- */
-public class ProfileCommand {
-    public ProfileCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-        NumberFormat formatter = new DecimalFormat("#.#");
-
-        Clan clan = null;
-
-        if (arg.length == 0) {
-            if (plugin.getPermissionsManager().has(player, "simpleclans.member.profile")) {
-                ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-                if (cp == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-                } else {
-                    if (cp.getClan().isVerified()) {
-                        clan = cp.getClan();
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-                    }
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-        } else if (arg.length == 1) {
-            if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.profile")) {
-                clan = plugin.getClanManager().getClan(arg[0]);
-
-                if (clan == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.profile.tag"), plugin.getSettingsManager().getCommandClan()));
-        }
-
-        if (clan != null) {
-            if (clan.isVerified()) {
-                ChatBlock.sendBlank(player);
-                ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(clan.getName()) + subColor + " " + plugin.getLang("profile") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-                ChatBlock.sendBlank(player);
-
-                String name = plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketLeft() + plugin.getSettingsManager().getTagDefaultColor() + clan.getColorTag() + plugin.getSettingsManager().getClanChatBracketColor() + plugin.getSettingsManager().getClanChatTagBracketRight() + " " + plugin.getSettingsManager().getPageClanNameColor() + clan.getName();
-                String description = ChatColor.WHITE + (clan.getDescription() != null && !clan.getDescription().isEmpty() ? clan.getDescription() : plugin.getLang("no.description"));
-                String leaders = clan.getLeadersString(plugin.getSettingsManager().getPageLeaderColor(), subColor + ", ");
-                String onlineCount = ChatColor.WHITE + "" + Helper.stripOffLinePlayers(clan.getMembers()).size();
-                String membersOnline = onlineCount + subColor + "/" + ChatColor.WHITE + clan.getSize();
-                String inactive = ChatColor.WHITE + "" + clan.getInactiveDays() + subColor + "/" + ChatColor.WHITE + (clan.isVerified() ? plugin.getSettingsManager().getPurgeClan() : plugin.getSettingsManager().getPurgeUnverified()) + " " + plugin.getLang("days");
-                String founded = ChatColor.WHITE + "" + clan.getFoundedString();
-                String allies = ChatColor.WHITE + "" + clan.getAllyString(subColor + ", ");
-                String rivals = ChatColor.WHITE + "" + clan.getRivalString(subColor + ", ");
-                String kdr = ChatColor.YELLOW + "" + formatter.format(clan.getTotalKDR());
-                String deaths = ChatColor.WHITE + "" + clan.getTotalDeaths();
-                String rival = ChatColor.WHITE + "" + clan.getTotalRival();
-                String neutral = ChatColor.WHITE + "" + clan.getTotalNeutral();
-                String civ = ChatColor.WHITE + "" + clan.getTotalCivilian();
-                String status = ChatColor.WHITE + "" + (clan.isVerified() ? plugin.getSettingsManager().getPageTrustedColor() + plugin.getLang("verified") : plugin.getSettingsManager().getPageUnTrustedColor() + plugin.getLang("unverified"));
-                String feeEnabled = ChatColor.WHITE + (clan.isMemberFeeEnabled() ? plugin.getLang("fee.enabled") : plugin.getLang("fee.disabled"));
-                String feeValue = ChatColor.WHITE + "" + clan.getMemberFee();
-                
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("name.0"), name));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("description.0"), description));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("status.0"), status));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("leaders.0"), leaders));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("members.online.0"), membersOnline));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("kdr.0"), kdr));
-                ChatBlock.sendMessage(player, "  " + subColor + plugin.getLang("kill.totals") + " " + headColor + "[" + plugin.getLang("rival") + ":" + rival + " " + headColor + "" + plugin.getLang("neutral") + ":" + neutral + " " + headColor + "" + plugin.getLang("civilian") + ":" + civ + headColor + "]");
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("deaths.0"), deaths));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("fee.0.value.1"), feeEnabled, feeValue));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("allies.0"), allies));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("rivals.0"), rivals));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("founded.0"), founded));
-                ChatBlock.sendMessage(player, "  " + subColor + MessageFormat.format(plugin.getLang("inactive.0"), inactive));
-
-                ChatBlock.sendBlank(player);
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            }
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/PromoteCommand.java

@@ -1,80 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class PromoteCommand {
-    public PromoteCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.promote")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.promote.member"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        Player promoted = Helper.getPlayer(arg[0]);
-
-        if (promoted == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.member.to.be.promoted.must.be.online"));
-            return;
-        }
-        if (!plugin.getPermissionsManager().has(promoted, "simpleclans.leader.promotable")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.does.not.have.the.permissions.to.lead.a.clan"));
-            return;
-        }
-        if (promoted.getName().equals(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.promote.yourself"));
-            return;
-        }
-        if (!clan.isMember(promoted)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.not.a.member.of.your.clan"));
-            return;
-        }
-        if (clan.isLeader(promoted) && plugin.getSettingsManager().isConfirmationForPromote()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.already.a.leader"));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("promoted.to.leader"), Helper.capitalize(promoted.getName())));
-        if (SimpleClans.getInstance().hasUUID()) {
-            clan.promote(promoted.getUniqueId());
-        } else {
-            clan.promote(promoted.getName());
-        }
-    }
-}
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/PurgeCommand.java

@@ -1,47 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.MessageFormat;
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-/**
- *
- * @author roinujnosde
- */
-public class PurgeCommand {
-
-    /**
-     * Executes the command
-     *
-     * @param sender
-     * @param args
-     */
-    public void execute(CommandSender sender, String args[]) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        if (sender instanceof Player) {
-            if (!plugin.getPermissionsManager().has((Player) sender, "simpleclans.admin.purge")) {
-                ChatBlock.sendMessage(sender, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-        }
-
-        if (args.length == 1) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(args[0]);
-            if (cp == null) {
-                ChatBlock.sendMessage(sender, ChatColor.RED + plugin.getLang("no.player.matched"));
-                return;
-            }
-
-            plugin.getClanManager().deleteClanPlayer(cp);
-            ChatBlock.sendMessage(sender, ChatColor.AQUA + plugin.getLang("player.purged"));
-            return;
-        }
-
-        ChatBlock.sendMessage(sender, ChatColor.RED
-                + MessageFormat.format(plugin.getLang("usage.purge"), plugin.getSettingsManager().getCommandClan()));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ReloadCommand.java

@@ -1,47 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-/**
- * @author phaed
- */
-public class ReloadCommand
-{
-    public ReloadCommand()
-    {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param sender
-     * @param arg
-     */
-    public void execute(CommandSender sender, String[] arg)
-    {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (sender instanceof Player && !plugin.getPermissionsManager().has((Player)sender, "simpleclans.admin.reload"))
-        {
-        	ChatBlock.sendMessage(sender, ChatColor.RED + "Does not match a clan command");
-        	return;
-        }
-        plugin.reloadConfig();
-        plugin.getSettingsManager().load();
-        plugin.getLanguageManager().load();
-        plugin.getStorageManager().importFromDatabase();
-        SimpleClans.getInstance().getPermissionsManager().loadPermissions();
-
-        for (Clan clan : plugin.getClanManager().getClans())
-        {
-            SimpleClans.getInstance().getPermissionsManager().updateClanPermissions(clan);
-        }
-        ChatBlock.sendMessage(sender, ChatColor.AQUA + plugin.getLang("configuration.reloaded"));
-
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ResetKDRCommand.java

@@ -1,72 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.MessageFormat;
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.OfflinePlayer;
-import org.bukkit.entity.Player;
-
-/**
- * @author phaed
- */
-public class ResetKDRCommand {
-
-    public ResetKDRCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        if (arg == null || arg.length == 0) {
-            if (!plugin.getSettingsManager().isAllowResetKdr()) {
-                ChatBlock.sendMessage(player, ChatColor.RED
-                        + MessageFormat.format(plugin.getLang("usage.resetkdr"),
-                                plugin.getSettingsManager().getCommandClan()));
-                return;
-            }
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.member.resetkdr")) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                return;
-            }
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-            if (cp == null) {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-                return;
-            }
-            if (plugin.getClanManager().purchaseResetKdr(player)) {
-                plugin.getClanManager().resetKdr(cp);
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.have.reseted.your.kdr"));
-            }
-            return;
-        }
-        if (arg.length == 1 && plugin.getPermissionsManager().has(player, "simpleclans.admin.resetkdr")) {
-            if (arg[0].equalsIgnoreCase("all")) {
-                for (ClanPlayer cp : SimpleClans.getInstance().getClanManager().getAllClanPlayers()) {
-                    plugin.getClanManager().resetKdr(cp);
-                }
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.have.reseted.kdr.of.all.players"));
-            } else {                
-                OfflinePlayer toReset = Bukkit.getOfflinePlayer(arg[0]);
-                if (toReset == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-                    return;
-                }
-                ClanPlayer trcp = plugin.getClanManager().getClanPlayer(toReset);
-                if (trcp == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.data.found"));
-                    return;
-                }
-                plugin.getClanManager().resetKdr(trcp);
-                ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("you.have.reseted.0.kdr"), toReset.getName()));
-            }
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ResignCommand.java

@@ -1,45 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import net.sacredlabyrinth.phaed.simpleclans.conversation.ResignPrompt;
-import org.bukkit.conversations.ConversationFactory;
-
-/**
- * @author phaed
- */
-public class ResignCommand {
-    public ResignCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.resign")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-        
-        new ConversationFactory(plugin)
-                .withFirstPrompt(new ResignPrompt())
-                .withLocalEcho(true)
-                .withTimeout(10)
-                .buildConversation(player).begin();
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/RivalCommand.java

@@ -1,117 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class RivalCommand {
-    public RivalCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.rival")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (clan.isUnrivable()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clan.cannot.create.rivals"));
-            return;
-        }
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 2) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.rival"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        if (clan.getSize() < plugin.getSettingsManager().getClanMinSizeToRival()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("min.players.rivalries"), plugin.getSettingsManager().getClanMinSizeToRival()));
-            return;
-        }
-
-        String action = arg[0];
-        Clan rival = plugin.getClanManager().getClan(arg[1]);
-
-        if (rival == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-            return;
-        }
-        if (clan.getTag().equals(rival.getTag()))
-        {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.rival.your.own.clan"));
-            return;
-        }
-            
-        if (plugin.getSettingsManager().isUnrivable(rival.getTag())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.cannot.be.rivaled"));
-            return;
-        }
-        if (!rival.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("cannot.rival.an.unverified.clan"));
-            return;
-        }
-
-        if (action.equals(plugin.getLang("add"))) {
-            if (!clan.reachedRivalLimit()) {
-                if (!clan.isRival(rival.getTag())) {
-                    clan.addRival(rival);
-                    rival.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.initiated.a.rivalry"), Helper.capitalize(clan.getName()), rival.getName()), false);
-                    clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.initiated.a.rivalry"), Helper.capitalize(player.getName()), Helper.capitalize(rival.getName())));
-                } else {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clans.are.already.rivals"));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("rival.limit.reached"));
-            }
-            return;
-        }
-
-        if (action.equals(plugin.getLang("remove"))) {
-            if (clan.isRival(rival.getTag())) {
-                plugin.getRequestManager().addRivalryBreakRequest(cp, rival, clan);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("leaders.asked.to.end.rivalry"), Helper.capitalize(rival.getName())));
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("your.clans.are.not.rivals"));
-            }
-            return;
-        }
-
-        ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.rival"), plugin.getSettingsManager().getCommandClan()));
-    }
-}
-
-
-
-
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/RivalriesCommand.java

@@ -1,72 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class RivalriesCommand {
-    public RivalriesCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.rivalries"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.anyone.rivalries")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        List<Clan> clans = plugin.getClanManager().getClans();
-        plugin.getClanManager().sortClansByKDR(clans);
-
-        ChatBlock chatBlock = new ChatBlock();
-
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getServerName() + subColor + " " + plugin.getLang("rivalries") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("legend") + ChatColor.DARK_RED + " [" + plugin.getLang("war") + "]");
-        ChatBlock.sendBlank(player);
-
-        chatBlock.setAlignment("l", "l");
-        chatBlock.addRow(plugin.getLang("clan"), plugin.getLang("rivals"));
-
-        for (Clan clan : clans) {
-            if (!clan.isVerified()) {
-                continue;
-            }
-
-            chatBlock.addRow("  " + ChatColor.AQUA + clan.getName(), clan.getRivalString(ChatColor.DARK_GRAY + ", "));
-        }
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-}
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/RosterCommand.java

@@ -1,112 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class RosterCommand {
-
-    public RosterCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        Clan clan = null;
-
-        if (arg.length == 0) {
-            if (plugin.getPermissionsManager().has(player, "simpleclans.member.roster")) {
-                ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-                if (cp == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-                } else {
-                    clan = cp.getClan();
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-        } else if (arg.length == 1) {
-            if (plugin.getPermissionsManager().has(player, "simpleclans.anyone.roster")) {
-                clan = plugin.getClanManager().getClan(arg[0]);
-
-                if (clan == null) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.roster.tag"), plugin.getSettingsManager().getCommandClan()));
-        }
-
-        if (clan != null) {
-            if (clan.isVerified()) {
-                ChatBlock chatBlock = new ChatBlock();
-
-                ChatBlock.sendBlank(player);
-                ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(clan.getName()) + subColor + " " + plugin.getLang("roster") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-                ChatBlock.sendBlank(player);
-                ChatBlock.sendMessage(player, headColor + plugin.getLang("legend") + " " + plugin.getSettingsManager().getPageLeaderColor() + plugin.getLang("leader") + headColor + ", " + plugin.getSettingsManager().getPageTrustedColor() + plugin.getLang("trusted") + headColor + ", " + plugin.getSettingsManager().getPageUnTrustedColor() + plugin.getLang("untrusted"));
-                ChatBlock.sendBlank(player);
-
-                chatBlock.setFlexibility(false, true, false, true);
-                chatBlock.addRow("  " + headColor + plugin.getLang("player"), plugin.getLang("rank"), plugin.getLang("seen"));
-
-                List<ClanPlayer> leaders = clan.getLeaders();
-                plugin.getClanManager().sortClanPlayersByLastSeen(leaders);
-
-                List<ClanPlayer> members = clan.getNonLeaders();
-                plugin.getClanManager().sortClanPlayersByLastSeen(members);
-
-                for (ClanPlayer cp : leaders) {
-
-                    Player p = cp.toPlayer();
-
-                    String name = plugin.getSettingsManager().getPageLeaderColor() + cp.getName();
-                    String lastSeen = p != null && p.isOnline() && !Helper.isVanished(p) ? ChatColor.GREEN + plugin.getLang("online") : ChatColor.WHITE + cp.getLastSeenDaysString();
-
-                    chatBlock.addRow("  " + name, ChatColor.YELLOW + Helper.parseColors(cp.getRank()), lastSeen);
-
-                }
-
-                for (ClanPlayer cp : members) {
-                    Player p = cp.toPlayer();
-
-                    String name = (cp.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() : plugin.getSettingsManager().getPageUnTrustedColor()) + cp.getName();
-                    String lastSeen = p != null && p.isOnline() && !Helper.isVanished(p) ? ChatColor.GREEN + plugin.getLang("online") : ChatColor.WHITE + cp.getLastSeenDaysString();
-
-                    chatBlock.addRow("  " + name, ChatColor.YELLOW + Helper.parseColors(cp.getRank()), lastSeen);
-                }
-
-                boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-                if (more) {
-                    plugin.getStorageManager().addChatBlock(player, chatBlock);
-                    ChatBlock.sendBlank(player);
-                    ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-                }
-
-                ChatBlock.sendBlank(player);
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            }
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.roster.tag"), plugin.getSettingsManager().getCommandClan()));
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/SCCommandManager.java

@@ -0,0 +1,229 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.BukkitLocales;
+import co.aikar.commands.CommandIssuer;
+import co.aikar.commands.PaperCommandManager;
+import co.aikar.locales.MessageKey;
+import co.aikar.locales.MessageKeyProvider;
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import net.sacredlabyrinth.phaed.simpleclans.Helper;
+import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
+import net.sacredlabyrinth.phaed.simpleclans.commands.completions.AbstractAsyncCompletion;
+import net.sacredlabyrinth.phaed.simpleclans.commands.completions.AbstractCompletion;
+import net.sacredlabyrinth.phaed.simpleclans.commands.completions.AbstractStaticCompletion;
+import net.sacredlabyrinth.phaed.simpleclans.commands.completions.AbstractSyncCompletion;
+import net.sacredlabyrinth.phaed.simpleclans.commands.conditions.AbstractCommandCondition;
+import net.sacredlabyrinth.phaed.simpleclans.commands.conditions.AbstractCondition;
+import net.sacredlabyrinth.phaed.simpleclans.commands.conditions.AbstractParameterCondition;
+import net.sacredlabyrinth.phaed.simpleclans.commands.contexts.AbstractContextResolver;
+import net.sacredlabyrinth.phaed.simpleclans.commands.contexts.AbstractInputOnlyContextResolver;
+import net.sacredlabyrinth.phaed.simpleclans.commands.contexts.AbstractIssuerOnlyContextResolver;
+import net.sacredlabyrinth.phaed.simpleclans.managers.*;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.optionalLang;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.*;
+
+public class SCCommandManager extends PaperCommandManager {
+    private final SimpleClans plugin;
+    private static final List<String> SUBCOMMANDS;
+
+    public SCCommandManager(@NotNull SimpleClans plugin) {
+        super(plugin);
+        this.plugin = plugin;
+        configure();
+    }
+    
+    private void configure() {
+        enableUnstableAPI("help");
+        registerDependencies();
+        addCommandReplacements();
+        registerContexts();
+        registerCommands();
+        registerConditions();
+        registerCompletions();
+        defaultHelpPerPage = plugin.getSettingsManager().getInt(HELP_SIZE);
+    }
+
+    private void registerDependencies() {
+        registerDependency(ClanManager.class, plugin.getClanManager());
+        registerDependency(SettingsManager.class, plugin.getSettingsManager());
+        registerDependency(StorageManager.class, plugin.getStorageManager());
+        registerDependency(PermissionsManager.class, plugin.getPermissionsManager());
+        registerDependency(RequestManager.class, plugin.getRequestManager());
+        registerDependency(ProtectionManager.class, plugin.getProtectionManager());
+        registerDependency(ChatManager.class, plugin.getChatManager());
+    }
+
+    private void registerCompletions() {
+        Set<Class<? extends AbstractCompletion>> completions =
+                Helper.getSubTypesOf("net.sacredlabyrinth.phaed.simpleclans.commands.completions",
+                        AbstractCompletion.class);
+        plugin.getLogger().info(String.format("Registering %d command completions...", completions.size()));
+        for (Class<? extends AbstractCompletion> c : completions) {
+            if (Modifier.isAbstract(c.getModifiers())) {
+                continue;
+            }
+            try {
+                AbstractCompletion obj = c.getConstructor(SimpleClans.class).newInstance(plugin);
+                if (obj instanceof AbstractStaticCompletion) {
+                    getCommandCompletions().registerStaticCompletion(obj.getId(),
+                            ((AbstractStaticCompletion) obj).getCompletions());
+                }
+                if (obj instanceof AbstractAsyncCompletion) {
+                    getCommandCompletions().registerAsyncCompletion(obj.getId(), (AbstractAsyncCompletion) obj);
+                }
+                if (obj instanceof AbstractSyncCompletion) {
+                    getCommandCompletions().registerCompletion(obj.getId(), ((AbstractSyncCompletion) obj));
+                }
+            } catch (Exception ex) {
+                plugin.getLogger().log(Level.SEVERE, "Error registering completion", ex);
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private void registerConditions() {
+        Set<Class<? extends AbstractCondition>> conditions =
+                Helper.getSubTypesOf("net.sacredlabyrinth.phaed.simpleclans.commands.conditions",
+                        AbstractCondition.class);
+        plugin.getLogger().info(String.format("Registering %d command conditions...", conditions.size()));
+        for (Class<? extends AbstractCondition> c : conditions) {
+            if (Modifier.isAbstract(c.getModifiers())) {
+                continue;
+            }
+            try {
+                AbstractCondition obj = c.getConstructor(SimpleClans.class).newInstance(plugin);
+                if (obj instanceof AbstractParameterCondition) {
+                    @SuppressWarnings("rawtypes")
+                    AbstractParameterCondition condition = (AbstractParameterCondition) obj;
+                    getCommandConditions().addCondition(condition.getType(), condition.getId(), condition);
+                }
+                if (obj instanceof AbstractCommandCondition) {
+                    AbstractCommandCondition condition = (AbstractCommandCondition) obj;
+                    getCommandConditions().addCondition(condition.getId(), condition);
+                }
+            } catch (Exception ex) {
+                plugin.getLogger().log(Level.SEVERE, "Error registering condition", ex);
+            }
+        }
+    }
+
+    @SuppressWarnings({"rawtypes", "unchecked"})
+    private void registerContexts() {
+        Set<Class<? extends AbstractContextResolver>> resolvers =
+                Helper.getSubTypesOf("net.sacredlabyrinth.phaed.simpleclans.commands.contexts",
+                        AbstractContextResolver.class);
+        plugin.getLogger().info(String.format("Registering %d command contexts...", resolvers.size()));
+        for (Class<? extends AbstractContextResolver> cr : resolvers) {
+            if (Modifier.isAbstract(cr.getModifiers())) {
+                continue;
+            }
+            try {
+                AbstractContextResolver obj = cr.getConstructor(SimpleClans.class).newInstance(plugin);
+                if (obj instanceof AbstractIssuerOnlyContextResolver) {
+                    getCommandContexts().registerIssuerOnlyContext(obj.getType(), ((AbstractIssuerOnlyContextResolver) obj));
+                }
+                if (obj instanceof AbstractInputOnlyContextResolver) {
+                    getCommandContexts().registerContext(obj.getType(), ((AbstractInputOnlyContextResolver<?>) obj));
+                }
+            } catch (Exception ex) {
+                plugin.getLogger().log(Level.SEVERE, "Error registering context", ex);
+            }
+        }
+    }
+
+    private void registerCommands() {
+        boolean forceCommandPriority = plugin.getSettingsManager().is(COMMANDS_FORCE_PRIORITY);
+        Set<Class<? extends BaseCommand>> commands = Helper.getSubTypesOf("net.sacredlabyrinth.phaed.simpleclans.commands", BaseCommand.class);
+        plugin.getLogger().info(String.format("Registering %d base commands...", commands.size()));
+        for (Class<? extends BaseCommand> c : commands) {
+            //ACF already registers nested classes
+            if (c.isMemberClass() || Modifier.isStatic(c.getModifiers())) {
+                continue;
+            }
+            try {
+                BaseCommand baseCommand = c.getConstructor().newInstance();
+                registerCommand(baseCommand, forceCommandPriority);
+            } catch (Exception ex) {
+                plugin.getLogger().log(Level.SEVERE, "Error registering command", ex);
+            }
+        }
+    }
+
+    private void addCommandReplacements() {
+        SettingsManager sm = plugin.getSettingsManager();
+        getCommandReplacements().addReplacements(
+                "basic_conditions", "not_blacklisted|not_banned",
+                "clan", sm.getString(COMMANDS_CLAN),
+                "deny", sm.getString(COMMANDS_DENY) + "|deny",
+                "more", sm.getString(COMMANDS_MORE),
+                "ally_chat", sm.getString(COMMANDS_ALLY),
+                "accept", sm.getString(COMMANDS_ACCEPT) + "|accept",
+                "clan_chat", sm.getString(COMMANDS_CLAN_CHAT)
+        );
+
+        SUBCOMMANDS.forEach(s -> {
+            String command = optionalLang(s + ".command", (ClanPlayer) null);
+            if (command == null) {
+                command = s;
+            }
+            command = command.replace(" ", "");
+            String replacement = command.equals(s) ? s : command + "|" + s;
+            getCommandReplacements().addReplacement(s, replacement);
+        });
+    }
+    
+    @Override
+    public BukkitLocales getLocales() {
+        if (this.locales == null) {
+            this.locales = new BukkitLocales(this) {
+
+                @Nullable
+                private Player getPlayer(CommandIssuer issuer) {
+                    if (issuer != null) {
+                        return Bukkit.getPlayer(issuer.getUniqueId());
+                    }
+                    return null;
+                }
+
+                @Override
+                @Nullable
+                public String getOptionalMessage(CommandIssuer issuer, MessageKey key) {
+                    return optionalLang(key.getKey(), getPlayer(issuer));
+                }
+
+                @Override
+                @NotNull
+                public String getMessage(CommandIssuer issuer, MessageKeyProvider key) {
+                    return lang(key.getMessageKey().getKey(), getPlayer(issuer));
+                }
+            };
+            //this.locales.loadLanguages();
+        }
+        return this.locales;
+    }
+
+    static {
+        SUBCOMMANDS = Arrays.asList("setbanner", "resetkdr", "place", "rank", "home", "war", "regroup",
+                "mostkilled", "kills", "globalff", "reload", "unban", "ban", "verify", "disband", "resign", "ff",
+                "clanff", "demote", "promote", "untrust", "trust", "purge", "fee", "bank", "kick", "invite", "toggle",
+                "modtag", "bb", "display", "clear", "rival", "ally", "add", "remove", "stats", "coords", "vitals", "rivalries",
+                "alliances", "leaderboard", "allow", "block", "auto", "check", "assign", "unassign", "delete", "me",
+                "setdisplayname", "permissions", "tag", "deposit", "withdraw", "set", "status", "tp", "all", "everyone",
+                "lookup", "roster", "profile", "list", "create", "description", "start", "end", "admin", "help", "mod",
+                "setdefault", "removedefault", "land", "break", "interact", "place_block", "damage", "interact_entity",
+                "container", "permanent", "take", "give", "join", "leave", "mute", "confirm", "balance", "discord", "rename", "locale");
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/SetRankCommand.java

@@ -1,68 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-public class SetRankCommand {
-    public SetRankCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.setrank")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length < 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.setrank"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String playerName = arg[0];
-        String rank = Helper.toMessage(Helper.removeFirst(arg));
-
-        if (!clan.isMember(playerName) && !clan.isLeader(playerName)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-
-        ClanPlayer cpm = plugin.getClanManager().getClanPlayer(playerName);
-        cpm.setRank(rank);
-        plugin.getStorageManager().updateClanPlayer(cpm);
-
-        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("player.rank.changed"));
-    }
-}
-
-
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/StatsCommand.java

@@ -1,105 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import java.text.DecimalFormat;
-import java.text.MessageFormat;
-import java.text.NumberFormat;
-import java.util.List;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-/**
- * @author phaed
- */
-public class StatsCommand {
-    public StatsCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.stats")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.stats"));
-            return;
-        }
-
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.stats"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        ChatBlock chatBlock = new ChatBlock();
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(clan.getName()) + subColor + " " + plugin.getLang("stats") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("kdr") + " = " + subColor + plugin.getLang("kill.death.ratio"));
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("weights") + " = " + plugin.getLang("rival") + ": " + subColor + plugin.getSettingsManager().getKwRival() + headColor + " " + plugin.getLang("neutral") + ": " + subColor + plugin.getSettingsManager().getKwNeutral() + headColor + " " + plugin.getLang("civilian") + ": " + subColor + plugin.getSettingsManager().getKwCivilian());
-        ChatBlock.sendBlank(player);
-
-        chatBlock.setFlexibility(true, false, false, false, false, false, false);
-        chatBlock.setAlignment("l", "c", "c", "c", "c", "c", "c");
-        chatBlock.addRow("  " + headColor + plugin.getLang("name"), plugin.getLang("kdr"), plugin.getLang("rival"), plugin.getLang("neutral"), plugin.getLang("civilian.abbreviation"), plugin.getLang("deaths"));
-
-        List<ClanPlayer> leaders = clan.getLeaders();
-        plugin.getClanManager().sortClanPlayersByKDR(leaders);
-
-        List<ClanPlayer> members = clan.getNonLeaders();
-        plugin.getClanManager().sortClanPlayersByKDR(members);
-
-        addRows(leaders, chatBlock);
-        addRows(members, chatBlock);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-
-    private void addRows(List<ClanPlayer> leaders, ChatBlock chatBlock) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        NumberFormat formatter = new DecimalFormat("#.#");
-
-        for (ClanPlayer cpm : leaders) {
-            String name = (cpm.isLeader() ? plugin.getSettingsManager().getPageLeaderColor() : (cpm.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() : plugin.getSettingsManager().getPageUnTrustedColor())) + cpm.getName();
-            String rival = NumberFormat.getInstance().format(cpm.getRivalKills());
-            String neutral = NumberFormat.getInstance().format(cpm.getNeutralKills());
-            String civilian = NumberFormat.getInstance().format(cpm.getCivilianKills());
-            String deaths = NumberFormat.getInstance().format(cpm.getDeaths());
-            String kdr = formatter.format(cpm.getKDR());
-
-            chatBlock.addRow("  " + name, ChatColor.YELLOW + kdr, ChatColor.WHITE + rival, ChatColor.GRAY + neutral, ChatColor.DARK_GRAY + civilian, ChatColor.DARK_RED + deaths);
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/ToggleCommand.java

@@ -1,159 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-/**
- * @author phaed
- */
-public class ToggleCommand {
-
-    public ToggleCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (arg.length == 0) {
-            return;
-        }
-
-        String cmd = arg[0];
-
-        if (cmd.equalsIgnoreCase("cape")) {
-            if (plugin.getPermissionsManager().has(player, "simpleclans.member.cape-toggle")) {
-                ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-                if (cp != null) {
-                    Clan clan = cp.getClan();
-
-                    if (clan.isVerified()) {
-                        if (cp.isCapeEnabled()) {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("capeoff"));
-                            cp.setCapeEnabled(false);
-                        } else {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("capeon"));
-                            cp.setCapeEnabled(true);
-                        }
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-                    }
-                } else {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            }
-        }
-
-        if (cmd.equalsIgnoreCase("bb") && plugin.getPermissionsManager().has(player, "simpleclans.member.bb-toggle")) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-            if (cp != null) {
-                Clan clan = cp.getClan();
-
-                if (clan.isVerified()) {
-                    if (cp.isBbEnabled()) {
-                        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("bboff"));
-                        cp.setBbEnabled(false);
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("bbon"));
-                        cp.setBbEnabled(true);
-                    }
-                    plugin.getStorageManager().updateClanPlayer(cp);
-                }
-            }
-        }
-
-        if (cmd.equalsIgnoreCase("tag") && plugin.getPermissionsManager().has(player, "simpleclans.member.tag-toggle")) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-            if (cp != null) {
-                Clan clan = cp.getClan();
-
-                if (clan.isVerified()) {
-                    if (cp.isTagEnabled()) {
-                        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("tagoff"));
-                        cp.setTagEnabled(false);
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("tagon"));
-                        cp.setTagEnabled(true);
-                    }
-                    plugin.getStorageManager().updateClanPlayer(cp);
-                }
-            }
-        }
-
-        if (cmd.equalsIgnoreCase("deposit") && plugin.getPermissionsManager().has(player, "simpleclans.leader.deposit-toggle")) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-            if (cp != null) {
-                Clan clan = cp.getClan();
-                if (clan.isLeader(player)) {
-                    if (clan.isVerified()) {
-                        if (clan.isAllowDeposit()) {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("depositoff"));
-                            clan.setAllowDeposit(false);
-                        } else {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("depositon"));
-                            clan.setAllowDeposit(true);
-                        }
-                    }
-                } else {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                }
-            }
-        }
-
-        if (cmd.equalsIgnoreCase("fee") && plugin.getPermissionsManager().has(player, "simpleclans.leader.fee")) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-            if (cp != null) {
-                Clan clan = cp.getClan();
-                if (clan.isVerified()) {
-                    if (clan.isLeader(player)) {
-                        if (clan.isMemberFeeEnabled()) {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("feeoff"));
-                            clan.setMemberFeeEnabled(false);
-                        } else {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("feeon"));
-                            clan.setMemberFeeEnabled(true);
-                        }
-                        plugin.getStorageManager().updateClanAsync(clan);
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                    }
-                }
-            }
-        }
-
-        if (cmd.equalsIgnoreCase("withdraw") && plugin.getPermissionsManager().has(player, "simpleclans.leader.withdraw-toggle")) {
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-            if (cp != null) {
-                Clan clan = cp.getClan();
-                if (clan.isVerified()) {
-                    if (clan.isLeader(player)) {
-                        if (clan.isAllowWithdraw()) {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("withdrawoff"));
-                            clan.setAllowWithdraw(false);
-                        } else {
-                            ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("withdrawon"));
-                            clan.setAllowWithdraw(true);
-                        }
-                    } else {
-                        ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-                    }
-                }
-            }
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/TrustCommand.java

@@ -1,95 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class TrustCommand {
-    public TrustCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.settrust")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.trust.player"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String trusted = arg[0];
-
-        if (trusted == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        if (trusted.equals(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.trust.yourself"));
-            return;
-        }
-        if (!clan.isMember(trusted)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.not.a.member.of.your.clan"));
-            return;
-        }
-        if (clan.isLeader(trusted)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("leaders.are.already.trusted"));
-            return;
-        }
-
-        ClanPlayer tcp = plugin.getClanManager().getClanPlayer(trusted);
-
-        if (tcp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-
-        if (tcp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.already.trusted"));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.been.given.trusted.status.by"), Helper.capitalize(trusted), player.getName()));
-        tcp.setTrusted(true);
-        plugin.getStorageManager().updateClanPlayer(tcp);
-    }
-
-}
-
-
-
-
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/UnbanCommand.java

@@ -1,56 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class UnbanCommand {
-    public UnbanCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.ban")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.ban.unban"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String banned = arg[0];
-
-        if (!plugin.getSettingsManager().isBanned(banned)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.not.banned"));
-            return;
-        }
-
-        Player pl = Helper.getPlayer(banned);
-
-        if (pl != null) {
-            ChatBlock.sendMessage(pl, ChatColor.AQUA + plugin.getLang("you.have.been.unbanned.from.clan.commands"));
-        }
-
-        plugin.getSettingsManager().removeBanned(banned);
-        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("player.removed.from.the.banned.list"));
-    }
-}
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/UntrustCommand.java

@@ -1,93 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class UntrustCommand {
-    public UntrustCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.settrust")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 1) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.untrust.player"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String trusted = arg[0];
-
-        if (trusted == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        if (trusted.equals(player.getName())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.cannot.untrust.yourself"));
-            return;
-        }
-        if (!clan.isMember(trusted)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.player.is.not.a.member.of.your.clan"));
-            return;
-        }
-        if (clan.isLeader(trusted)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("leaders.cannot.be.untrusted"));
-            return;
-        }
-
-        ClanPlayer tcp = plugin.getClanManager().getClanPlayer(trusted);
-
-        if (tcp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.player.matched"));
-            return;
-        }
-        if (!tcp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("this.player.is.already.untrusted"));
-            return;
-        }
-
-        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("has.been.given.untrusted.status.by"), Helper.capitalize(trusted), player.getName()));
-        tcp.setTrusted(false);
-        plugin.getStorageManager().updateClanPlayer(tcp);
-    }
-}
-
-
-
-
-
-
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/VerifyCommand.java

@@ -1,85 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-
-/**
- * @author phaed
- */
-public class VerifyCommand {
-
-    public VerifyCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param sender
-     * @param arg
-     */
-    public void execute(CommandSender sender, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (sender instanceof Player) {
-            Player player = (Player) sender;
-
-            ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-            Clan clan = cp == null ? null : cp.getClan();
-
-            boolean isNonVerified = clan != null && !clan.isVerified();
-            boolean isBuyer = isNonVerified && plugin.getSettingsManager().isRequireVerification() && plugin.getSettingsManager().isePurchaseVerification();
-
-            if (!plugin.getPermissionsManager().has(player, "simpleclans.mod.verify")) {
-                //if the player does specify a tag, but does not have mod permission to verify
-                //if the player does not specify a tag, but does not have leader permission to verify
-                if (arg.length != 0 || !plugin.getPermissionsManager().has(player, "simpleclans.leader.verify")) {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-                    return;
-                }
-                if (isBuyer) {
-                    if (arg.length == 0 && plugin.getClanManager().purchaseVerification(player)) {
-                        clan.verifyClan();
-                        clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.0.has.been.verified"), clan.getName()));
-                        ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("the.clan.has.been.verified"));
-                    }
-                }
-            } else {
-                if (arg.length != 1) {
-                    ChatBlock.sendMessage(sender, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.verify.tag"), plugin.getSettingsManager().getCommandClan()));
-                    return;
-                }
-                verify(player, arg[0]);
-            }
-        } else {
-            if (arg.length != 1) {
-                ChatBlock.sendMessage(sender, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.verify.tag"), plugin.getSettingsManager().getCommandClan()));
-                return;
-            }
-            verify(sender, arg[0]);
-        }
-    }
-
-    private void verify(CommandSender player, String clanName) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        Clan clan = plugin.getClanManager().getClan(clanName);
-
-        if (clan != null) {
-            if (!clan.isVerified()) {
-                clan.verifyClan();
-                clan.addBb(player.getName(), ChatColor.AQUA + MessageFormat.format(plugin.getLang("clan.0.has.been.verified"), clan.getName()));
-                ChatBlock.sendMessage(player, ChatColor.AQUA + plugin.getLang("the.clan.has.been.verified"));
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.is.already.verified"));
-            }
-        } else {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("the.clan.does.not.exist"));
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/VitalsCommand.java

@@ -1,105 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
-/**
- * @author phaed
- */
-public class VitalsCommand {
-    public VitalsCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-        String headColor = plugin.getSettingsManager().getPageHeadingsColor();
-        String subColor = plugin.getSettingsManager().getPageSubTitleColor();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.member.vitals")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!cp.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("only.trusted.players.can.access.clan.vitals"));
-            return;
-        }
-        if (arg.length != 0) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.0.vitals"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-        ChatBlock chatBlock = new ChatBlock();
-        ChatBlock.sendBlank(player);
-        ChatBlock.saySingle(player, plugin.getSettingsManager().getPageClanNameColor() + Helper.capitalize(clan.getName()) + subColor + " " + plugin.getLang("vitals") + " " + headColor + Helper.generatePageSeparator(plugin.getSettingsManager().getPageSep()));
-        ChatBlock.sendBlank(player);
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("weapons") + ": " + MessageFormat.format(plugin.getLang("0.s.sword.1.2.b.bow.3.4.a.arrow"), ChatColor.WHITE, ChatColor.DARK_GRAY, ChatColor.WHITE, ChatColor.DARK_GRAY, ChatColor.WHITE));
-        ChatBlock.sendMessage(player, headColor + plugin.getLang("materials") + ": " + ChatColor.AQUA + plugin.getLang("diamond") + ChatColor.DARK_GRAY + ", " + ChatColor.YELLOW + plugin.getLang("gold") + ChatColor.DARK_GRAY + ", " + ChatColor.GRAY + plugin.getLang("stone") + ChatColor.DARK_GRAY + ", " + ChatColor.WHITE + plugin.getLang("iron") + ChatColor.DARK_GRAY + ", " + ChatColor.GOLD + plugin.getLang("wood"));
-
-        ChatBlock.sendBlank(player);
-
-        chatBlock.setFlexibility(true, false, false, false, false, false);
-        chatBlock.setAlignment("l", "l", "l", "c", "c", "c");
-
-        chatBlock.addRow("  " + headColor + plugin.getLang("name"), plugin.getLang("health"), plugin.getLang("hunger"), plugin.getLang("food"), plugin.getLang("armor"), plugin.getLang("weapons"));
-
-        List<ClanPlayer> members = Helper.stripOffLinePlayers(clan.getLeaders());
-        members.addAll(Helper.stripOffLinePlayers(clan.getNonLeaders()));
-
-        addRows(members, chatBlock);
-
-        chatBlock.addRow(" -- Allies -- ", "", "", "", "", "");
-
-        addRows(clan.getAllAllyMembers(), chatBlock);
-
-        boolean more = chatBlock.sendBlock(player, plugin.getSettingsManager().getPageSize());
-
-        if (more) {
-            plugin.getStorageManager().addChatBlock(player, chatBlock);
-            ChatBlock.sendBlank(player);
-            ChatBlock.sendMessage(player, headColor + MessageFormat.format(plugin.getLang("view.next.page"), plugin.getSettingsManager().getCommandMore()));
-        }
-
-        ChatBlock.sendBlank(player);
-    }
-
-    private void addRows(Collection<ClanPlayer> players, ChatBlock chatBlock){
-        SimpleClans plugin = SimpleClans.getInstance();
-        for (ClanPlayer cpm : players) {
-            Player p = cpm.toPlayer();
-
-            if (p != null) {
-                String name = (cpm.isLeader() ? plugin.getSettingsManager().getPageLeaderColor() : (cpm.isTrusted() ? plugin.getSettingsManager().getPageTrustedColor() : plugin.getSettingsManager().getPageUnTrustedColor())) + cpm.getName();
-                String health = plugin.getClanManager().getHealthString(p.getHealth());
-                String hunger = plugin.getClanManager().getHungerString(p.getFoodLevel());
-                String armor = plugin.getClanManager().getArmorString(p.getInventory());
-                String weapons = plugin.getClanManager().getWeaponString(p.getInventory());
-                String food = plugin.getClanManager().getFoodString(p.getInventory());
-
-                chatBlock.addRow("  " + name, ChatColor.RED + health, hunger, ChatColor.WHITE + food, armor, weapons);
-            }
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/WarCommand.java

@@ -1,94 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.text.MessageFormat;
-import java.util.List;
-
-/**
- * @author phaed
- */
-public class WarCommand {
-    public WarCommand() {
-    }
-
-    /**
-     * Execute the command
-     *
-     * @param player
-     * @param arg
-     */
-    public void execute(Player player, String[] arg) {
-        SimpleClans plugin = SimpleClans.getInstance();
-
-        if (!plugin.getPermissionsManager().has(player, "simpleclans.leader.war")) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("insufficient.permissions"));
-            return;
-        }
-
-        ClanPlayer cp = plugin.getClanManager().getClanPlayer(player);
-
-        if (cp == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("not.a.member.of.any.clan"));
-            return;
-        }
-
-        Clan clan = cp.getClan();
-
-        if (!clan.isVerified()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clan.is.not.verified"));
-            return;
-        }
-        if (!clan.isLeader(player)) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.leader.permissions"));
-            return;
-        }
-        if (arg.length != 2) {
-            ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.war"), plugin.getSettingsManager().getCommandClan()));
-            return;
-        }
-
-        String action = arg[0];
-        Clan war = plugin.getClanManager().getClan(arg[1]);
-
-        if (war == null) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("no.clan.matched"));
-            return;
-        }
-        if (!clan.isRival(war.getTag())) {
-            ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("you.can.only.start.war.with.rivals"));
-            return;
-        }
-
-        if (action.equals(plugin.getLang("start"))) {
-            if (!clan.isWarring(war.getTag())) {
-                List<ClanPlayer> onlineLeaders = Helper.stripOffLinePlayers(clan.getLeaders());
-
-                if (!onlineLeaders.isEmpty()) {
-                    plugin.getRequestManager().addWarStartRequest(cp, war, clan);
-                    ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("leaders.have.been.asked.to.accept.the.war.request"), Helper.capitalize(war.getName())));
-                } else {
-                    ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("at.least.one.leader.accept.the.alliance"));
-                }
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clans.already.at.war"));
-            }
-            return;
-        }
-
-        if (action.equals(plugin.getLang("end"))) {
-            if (clan.isWarring(war.getTag())) {
-                plugin.getRequestManager().addWarEndRequest(cp, war, clan);
-                ChatBlock.sendMessage(player, ChatColor.AQUA + MessageFormat.format(plugin.getLang("leaders.asked.to.end.rivalry"), Helper.capitalize(war.getName())));
-            } else {
-                ChatBlock.sendMessage(player, ChatColor.RED + plugin.getLang("clans.not.at.war"));
-            }
-            return;
-        }
-
-        ChatBlock.sendMessage(player, ChatColor.RED + MessageFormat.format(plugin.getLang("usage.war"), plugin.getSettingsManager().getCommandClan()));
-    }
-}
-

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/clan/AllyChatCommand.java

@@ -0,0 +1,68 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.*;
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import net.sacredlabyrinth.phaed.simpleclans.managers.ChatManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
+
+import static net.sacredlabyrinth.phaed.simpleclans.ClanPlayer.Channel.ALLY;
+import static net.sacredlabyrinth.phaed.simpleclans.ClanPlayer.Channel.NONE;
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source.SPIGOT;
+
+@CommandAlias("%ally_chat")
+@Description("{@@command.description.ally}")
+@CommandPermission("simpleclans.member.ally")
+@Conditions("%basic_conditions|clan_member|can_chat:type=ALLY|rank:name=ALLY_CHAT")
+public class AllyChatCommand extends BaseCommand {
+
+    @Dependency
+    private ChatManager chatManager;
+    @Dependency
+    private SettingsManager settingsManager;
+    @Dependency
+    private StorageManager storageManager;
+
+    @Default
+    @HelpSearchTags("chat")
+    public void sendMessage(ClanPlayer cp, @Name("message") String message) {
+        chatManager.processChat(SPIGOT, ALLY, cp, message);
+    }
+
+    @Subcommand("%join")
+    public void join(ClanPlayer clanPlayer) {
+        if (clanPlayer.getChannel() == ALLY) {
+            ChatBlock.sendMessage(clanPlayer, lang("already.joined.ally.chat"));
+            return;
+        }
+
+        clanPlayer.setChannel(ALLY);
+        storageManager.updateClanPlayer(clanPlayer);
+        ChatBlock.sendMessage(clanPlayer, lang("joined.ally.chat"));
+    }
+
+    @Subcommand("%leave")
+    public void leave(ClanPlayer clanPlayer) {
+        if (clanPlayer.getChannel() == ALLY) {
+            clanPlayer.setChannel(NONE);
+            storageManager.updateClanPlayer(clanPlayer);
+            ChatBlock.sendMessage(clanPlayer, lang("left.ally.chat", clanPlayer));
+        } else {
+            ChatBlock.sendMessage(clanPlayer, lang("chat.didnt.join", clanPlayer));
+        }
+    }
+
+    @Subcommand("%mute")
+    public void mute(ClanPlayer clanPlayer) {
+        if (!clanPlayer.isMutedAlly()) {
+            clanPlayer.mute(ALLY, true);
+            ChatBlock.sendMessage(clanPlayer, lang("muted.ally.chat", clanPlayer));
+        } else {
+            clanPlayer.mute(ALLY, false);
+            ChatBlock.sendMessage(clanPlayer, lang("unmuted.ally.chat", clanPlayer));
+        }
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/clan/BankCommand.java

@@ -0,0 +1,139 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.*;
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.Clan;
+import net.sacredlabyrinth.phaed.simpleclans.EconomyResponse;
+import net.sacredlabyrinth.phaed.simpleclans.events.BankDepositEvent;
+import net.sacredlabyrinth.phaed.simpleclans.events.BankWithdrawEvent;
+import net.sacredlabyrinth.phaed.simpleclans.loggers.BankLogger;
+import net.sacredlabyrinth.phaed.simpleclans.loggers.BankOperator;
+import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.events.ClanBalanceUpdateEvent.Cause.COMMAND;
+import static net.sacredlabyrinth.phaed.simpleclans.events.ClanBalanceUpdateEvent.Cause.REVERT;
+import static org.bukkit.ChatColor.AQUA;
+import static org.bukkit.ChatColor.RED;
+
+@CommandAlias("%clan")
+@Subcommand("%bank")
+@Conditions("%basic_conditions|economy|verified")
+public class BankCommand extends BaseCommand {
+    @Dependency
+    private PermissionsManager permissions;
+
+    @Subcommand("%status")
+    @CommandPermission("simpleclans.member.bank")
+    @Conditions("rank:name=BANK_BALANCE")
+    @Description("{@@command.description.bank.status}")
+    public void bankStatus(Player player, Clan clan) {
+        player.sendMessage(AQUA + lang("clan.balance", player, clan.getBalance()));
+    }
+
+    @Subcommand("%withdraw %all")
+    @CommandPermission("simpleclans.member.bank")
+    @Conditions("rank:name=BANK_WITHDRAW")
+    @Description("{@@command.description.bank.withdraw.all}")
+    public void bankWithdraw(Player player, Clan clan) {
+        processWithdraw(player, clan, clan.getBalance());
+    }
+
+    @Subcommand("%withdraw")
+    @CommandPermission("simpleclans.member.bank")
+    @Conditions("rank:name=BANK_WITHDRAW")
+    @Description("{@@command.description.bank.withdraw.amount}")
+    public void bankWithdraw(Player player, Clan clan, double amount) {
+        processWithdraw(player, clan, amount);
+    }
+
+    private void processWithdraw(Player player, Clan clan, double amount) {
+        if (!clan.isAllowWithdraw()) {
+            String message = getCurrentCommandManager().getCommandReplacements()
+                    .replace(lang("withdraw.not.allowed", player));
+            ChatBlock.sendMessage(player, RED + message);
+            return;
+        }
+        amount = Math.abs(amount);
+        /*
+            TODO: Remove at SimpleClans 3.0
+         */
+        BankWithdrawEvent event = new BankWithdrawEvent(player, clan, amount);
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return;
+        }
+        /*
+         * ——————————————————————————————————
+         */
+        BankOperator operator = new BankOperator(player, permissions.playerGetMoney(player));
+        switch (clan.withdraw(operator, COMMAND, amount)) {
+            case SUCCESS -> {
+                if (permissions.grantPlayer(player, amount)) {
+                    player.sendMessage(AQUA + lang("player.clan.withdraw", player, amount));
+                    clan.addBb(player.getName(), lang("bb.clan.withdraw", amount, player.getName()));
+                } else {
+                    clan.setBalance(operator, REVERT, BankLogger.Operation.WITHDRAW, clan.getBalance() + amount);
+                }
+            }
+            case NOT_ENOUGH_BALANCE -> player.sendMessage(lang("clan.bank.not.enough.money", player));
+        }
+    }
+
+    @Subcommand("%deposit %all")
+    @CommandPermission("simpleclans.member.bank")
+    @Conditions("rank:name=BANK_DEPOSIT")
+    @Description("{@@command.description.bank.deposit.all}")
+    public void bankDeposit(Player player, Clan clan) {
+        processDeposit(player, clan, permissions.playerGetMoney(player));
+    }
+
+    @Subcommand("%deposit")
+    @CommandPermission("simpleclans.member.bank")
+    @Conditions("rank:name=BANK_DEPOSIT")
+    @Description("{@@command.description.bank.deposit.amount}")
+    public void bankDeposit(Player player, Clan clan, double amount) {
+        processDeposit(player, clan, amount);
+    }
+
+    private void processDeposit(Player player, Clan clan, double amount) {
+        if (!clan.isAllowDeposit()) {
+            String message = getCurrentCommandManager().getCommandReplacements()
+                    .replace(lang("deposit.not.allowed", player));
+            ChatBlock.sendMessage(player, RED + message);
+            return;
+        }
+        amount = Math.abs(amount);
+
+        /*
+            TODO: Remove at SimpleClans 3.0
+         */
+        BankDepositEvent event = new BankDepositEvent(player, clan, amount);
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return;
+        }
+        /*
+        * ——————————————————————————————————
+        */
+
+        if (!permissions.playerHasMoney(player, amount)) {
+            player.sendMessage(AQUA + lang("not.sufficient.money", player, amount));
+            return;
+        }
+        BankOperator operator = new BankOperator(player, permissions.playerGetMoney(player));
+        EconomyResponse response = clan.deposit(operator, COMMAND, amount);
+        if (response == EconomyResponse.SUCCESS) {
+            if (permissions.chargePlayer(player, amount)) {
+                player.sendMessage(AQUA + lang("player.clan.deposit", player, amount));
+                clan.addBb(player.getName(), lang("bb.clan.deposit", amount, player.getName()));
+            } else {
+                //Reverts the deposit if something went wrong with Vault
+                clan.setBalance(operator, REVERT, BankLogger.Operation.DEPOSIT, clan.getBalance() - amount);
+            }
+        }
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/clan/BbCommand.java

@@ -0,0 +1,56 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.*;
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.Clan;
+import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
+import org.bukkit.entity.Player;
+
+import java.util.Objects;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static org.bukkit.ChatColor.RED;
+
+@CommandAlias("%clan")
+@Conditions("%basic_conditions|verified")
+public class BbCommand extends BaseCommand {
+
+    @Dependency
+    private ClanManager cm;
+    @Dependency
+    private StorageManager storage;
+    @Dependency
+    private SettingsManager settings;
+
+    @Subcommand("%bb")
+    @CommandPermission("simpleclans.member.bb")
+    @Description("{@@command.description.bb.display}")
+    public void display(Player sender) {
+        Clan clan = Objects.requireNonNull(cm.getClanByPlayerUniqueId(sender.getUniqueId()));
+        clan.displayBb(sender);
+    }
+
+    @Subcommand("%bb %clear")
+    @CommandPermission("simpleclans.leader.bb-clear")
+    @Conditions("rank:name=BB_CLEAR")
+    @Description("{@@command.description.bb.clear}")
+    public void clear(Player player) {
+        Clan clan = Objects.requireNonNull(cm.getClanByPlayerUniqueId(player.getUniqueId()));
+        clan.clearBb();
+        ChatBlock.sendMessage(player, RED + lang("cleared.bb", player));
+    }
+
+    @Subcommand("%bb %add")
+    @CommandPermission("simpleclans.member.bb-add")
+    @Conditions("rank:name=BB_ADD")
+    @Description("{@@command.description.bb.post}")
+    public void postMessage(Player player, @Name("message") String msg) {
+        Clan clan = Objects.requireNonNull(cm.getClanByPlayerUniqueId(player.getUniqueId()));
+        clan.addBb(lang("bulletin.board.message", player.getName(), msg));
+        clan.displayBb(player);
+        storage.updateClan(clan);
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/clan/ChatCommand.java

@@ -0,0 +1,65 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.*;
+import net.sacredlabyrinth.phaed.simpleclans.ChatBlock;
+import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
+import net.sacredlabyrinth.phaed.simpleclans.managers.ChatManager;
+import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
+
+import static net.sacredlabyrinth.phaed.simpleclans.ClanPlayer.Channel.CLAN;
+import static net.sacredlabyrinth.phaed.simpleclans.ClanPlayer.Channel.NONE;
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.chat.SCMessage.Source.SPIGOT;
+
+@CommandAlias("%clan_chat")
+@Conditions("%basic_conditions|clan_member|can_chat:type=CLAN")
+@CommandPermission("simpleclans.member.chat")
+@Description("{@@command.description.chat}")
+public class ChatCommand extends BaseCommand {
+
+    @Dependency
+    private ChatManager chatManager;
+    @Dependency
+    private StorageManager storageManager;
+
+    @Default
+    @HelpSearchTags("chat")
+    public void sendMessage(ClanPlayer cp, @Name("message") String message) {
+        chatManager.processChat(SPIGOT, CLAN, cp, message);
+    }
+
+    @Subcommand("%join")
+    public void join(ClanPlayer clanPlayer) {
+        if (clanPlayer.getChannel() == CLAN) {
+            ChatBlock.sendMessage(clanPlayer, lang("already.joined.clan.chat"));
+            return;
+        }
+
+        clanPlayer.setChannel(CLAN);
+        storageManager.updateClanPlayer(clanPlayer);
+        ChatBlock.sendMessage(clanPlayer, lang("joined.clan.chat"));
+    }
+
+    @Subcommand("%leave")
+    public void leave(ClanPlayer clanPlayer) {
+        if (clanPlayer.getChannel() == CLAN) {
+            clanPlayer.setChannel(NONE);
+            storageManager.updateClanPlayer(clanPlayer);
+            ChatBlock.sendMessage(clanPlayer, lang("left.clan.chat", clanPlayer));
+        } else {
+            ChatBlock.sendMessage(clanPlayer, lang("chat.didnt.join", clanPlayer));
+        }
+    }
+
+    @Subcommand("%mute")
+    public void mute(ClanPlayer clanPlayer) {
+        if (!clanPlayer.isMuted()) {
+            clanPlayer.mute(CLAN, true);
+            ChatBlock.sendMessage(clanPlayer, lang("muted.clan.chat", clanPlayer));
+        } else {
+            clanPlayer.mute(CLAN, false);
+            ChatBlock.sendMessage(clanPlayer, lang("unmuted.clan.chat", clanPlayer));
+        }
+    }
+}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/clan/ClanCommands.java

@@ -0,0 +1,389 @@
+package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
+
+import co.aikar.commands.BaseCommand;
+import co.aikar.commands.annotation.*;
+import net.sacredlabyrinth.phaed.simpleclans.*;
+import net.sacredlabyrinth.phaed.simpleclans.commands.ClanInput;
+import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
+import net.sacredlabyrinth.phaed.simpleclans.conversation.ResignPrompt;
+import net.sacredlabyrinth.phaed.simpleclans.conversation.SCConversation;
+import net.sacredlabyrinth.phaed.simpleclans.events.TagChangeEvent;
+import net.sacredlabyrinth.phaed.simpleclans.managers.*;
+import net.sacredlabyrinth.phaed.simpleclans.utils.ChatUtils;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+
+import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
+import static net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager.ConfigField.*;
+import static org.bukkit.ChatColor.AQUA;
+import static org.bukkit.ChatColor.RED;
+
+@CommandAlias("%clan")
+@Conditions("%basic_conditions")
+public class ClanCommands extends BaseCommand {
+    @Dependency
+    private SimpleClans plugin;
+    @Dependency
+    private SettingsManager settings;
+    @Dependency
+    private ClanManager cm;
+    @Dependency
+    private StorageManager storage;
+    @Dependency
+    private PermissionsManager permissions;
+    @Dependency
+    private RequestManager requestManager;
+    @Dependency
+    private ProtectionManager protectionManager;
+
+    @Subcommand("%war %start")
+    @CommandPermission("simpleclans.leader.war")
+    @Conditions("verified|rank:name=WAR_START")
+    @Description("{@@command.description.war.start}")
+    @CommandCompletion("@rivals")
+    public void startWar(Player player, ClanPlayer requester, Clan requestClan, @Conditions("can_war_target") @Name("clan") ClanInput targetClanInput) {
+        Clan targetClan = targetClanInput.getClan();
+
+        List<ClanPlayer> onlineLeaders = Helper.stripOffLinePlayers(requestClan.getLeaders());
+
+        if (settings.is(WAR_START_REQUEST_ENABLED)) {
+            if (!onlineLeaders.isEmpty()) {
+                requestManager.addWarStartRequest(requester, targetClan, requestClan);
+                ChatBlock.sendMessage(player, AQUA + lang("leaders.have.been.asked.to.accept.the.war.request",
+                        player, targetClan.getName()));
+            } else {
+                ChatBlock.sendMessage(player, RED + lang("at.least.one.leader.accept.the.alliance", player));
+            }
+        } else {
+            protectionManager.addWar(requester, requestClan, targetClan);
+        }
+    }
+
+    @Subcommand("%war %end")
+    @CommandPermission("simpleclans.leader.war")
+    @Conditions("verified|rank:name=WAR_END")
+    @Description("{@@command.description.war.end}")
+    @CommandCompletion("@warring_clans")
+    public void endWar(ClanPlayer cp, Clan issuerClan, @Name("clan") ClanInput other) {
+        Clan war = other.getClan();
+        if (issuerClan.isWarring(war.getTag())) {
+            requestManager.addWarEndRequest(cp, war, issuerClan);
+            ChatBlock.sendMessage(cp, AQUA + lang("leaders.asked.to.end.rivalry", cp, war.getName()));
+        } else {
+            ChatBlock.sendMessage(cp, RED + lang("clans.not.at.war", cp));
+        }
+    }
+
+    @Subcommand("%modtag")
+    @CommandPermission("simpleclans.leader.modtag")
+    @Conditions("verified|rank:name=MODTAG")
+    @Description("{@@command.description.modtag}")
+    public void modtag(Player player, Clan clan, @Single @Name("tag") String tag) {
+        TagChangeEvent event = new TagChangeEvent(player, clan, tag);
+        plugin.getServer().getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            return;
+        }
+        tag = event.getNewTag();
+        String cleanTag = Helper.cleanTag(tag);
+
+        Optional<String> validationError = plugin.getTagValidator().validate(player, tag);
+        if (validationError.isPresent()) {
+            ChatBlock.sendMessage(player, validationError.get());
+            return;
+        }
+
+        if (!cleanTag.equals(clan.getTag())) {
+            ChatBlock.sendMessage(player, RED + lang("you.can.only.modify.the.color.and.case.of.the.tag",
+                    player));
+            return;
+        }
+
+        clan.addBb(player.getName(), lang("tag.changed.to.0", ChatUtils.parseColors(tag)));
+        clan.changeClanTag(tag);
+        cm.updateDisplayName(player);
+    }
+
+    @Subcommand("%setbanner")
+    @CommandPermission("simpleclans.leader.setbanner")
+    @Conditions("verified|rank:name=SETBANNER")
+    @Description("{@@command.description.setbanner}")
+    public void setbanner(Player player, Clan clan) {
+        @SuppressWarnings("deprecation")
+        ItemStack hand = player.getItemInHand();
+        if (!hand.getType().toString().contains("BANNER")) {
+            ChatBlock.sendMessageKey(player, "you.must.hold.a.banner");
+            return;
+        }
+
+        clan.setBanner(hand);
+        storage.updateClan(clan);
+        ChatBlock.sendMessageKey(player, "you.changed.clan.banner");
+    }
+
+    @Subcommand("%invite")
+    @CommandPermission("simpleclans.leader.invite")
+    @CommandCompletion("@non_members:ignore_vanished")
+    @Conditions("rank:name=INVITE")
+    @Description("{@@command.description.invite}")
+    public void invite(Player sender, ClanPlayer cp, Clan clan,
+                       @Conditions("not_banned|not_in_clan|online:ignore_vanished") @Name("player") ClanPlayerInput invited) {
+        if (!invited.getClanPlayer().isInviteEnabled()) {
+            ChatBlock.sendMessage(sender, RED + lang("invitedplayer.invite.off", sender));
+            return;
+        }
+        Player invitedPlayer = invited.getClanPlayer().toPlayer();
+        if (invitedPlayer == null) return;
+        if (!permissions.has(invitedPlayer, "simpleclans.member.can-join")) {
+            ChatBlock.sendMessage(sender, RED +
+                    lang("the.player.doesn.t.not.have.the.permissions.to.join.clans", sender));
+            return;
+        }
+        if (invitedPlayer.getUniqueId().equals(sender.getUniqueId())) {
+            ChatBlock.sendMessage(sender, RED + lang("you.cannot.invite.yourself", sender));
+            return;
+        }
+        long minutesBeforeRejoin = cm.getMinutesBeforeRejoin(invited.getClanPlayer(), clan);
+        if (minutesBeforeRejoin != 0) {
+            ChatBlock.sendMessage(sender, RED +
+                    lang("the.player.must.wait.0.before.joining.your.clan.again", sender, minutesBeforeRejoin));
+            return;
+        }
+
+        if (clan.getSize() >= settings.getInt(CLAN_MAX_MEMBERS) && settings.getInt(CLAN_MAX_MEMBERS) > 0) {
+            ChatBlock.sendMessage(sender, RED + lang("the.clan.members.reached.limit", sender));
+            return;
+        }
+        if (!cm.purchaseInvite(sender)) {
+            return;
+        }
+
+        requestManager.addInviteRequest(cp, invitedPlayer.getName(), clan);
+        ChatBlock.sendMessage(sender, AQUA + lang("has.been.asked.to.join",
+                sender, invitedPlayer.getName(), clan.getName()));
+    }
+
+    @Subcommand("%fee %check")
+    @Conditions("member_fee_enabled|verified")
+    @CommandPermission("simpleclans.member.fee-check")
+    @Description("{@@command.description.fee.check}")
+    public void checkFee(Player player, Clan clan) {
+        ChatBlock.sendMessage(player, AQUA
+                + lang("the.fee.is.0.and.its.current.value.is.1", player, clan.isMemberFeeEnabled() ?
+                        lang("fee.enabled", player) : lang("fee.disabled", player),
+                clan.getMemberFee()
+        ));
+    }
+
+    @Subcommand("%fee %set")
+    @CommandPermission("simpleclans.leader.fee")
+    @Conditions("rank:name=FEE_SET|change_fee")
+    @Description("{@@command.description.fee.set}")
+    public void setFee(Player player, Clan clan, @Name("fee") double fee) {
+        fee = Math.abs(fee);
+        double maxFee = settings.getDouble(ECONOMY_MAX_MEMBER_FEE);
+        if (fee > maxFee) {
+            ChatBlock.sendMessage(player, RED
+                    + lang("max.fee.allowed.is.0", player, maxFee));
+            return;
+        }
+        if (cm.purchaseMemberFeeSet(player)) {
+            clan.setMemberFee(fee);
+            clan.addBb(player.getName(), lang("bb.fee.set", fee));
+            ChatBlock.sendMessage(player, AQUA + lang("fee.set", player));
+            storage.updateClan(clan);
+        }
+    }
+
+    @Subcommand("%clanff %allow")
+    @CommandPermission("simpleclans.leader.ff")
+    @Conditions("rank:name=FRIENDLYFIRE")
+    @Description("{@@command.description.clanff.allow}")
+    public void allowClanFf(Player player, Clan clan) {
+        clan.addBb(player.getName(), lang("clan.wide.friendly.fire.is.allowed"));
+        clan.setFriendlyFire(true);
+        storage.updateClan(clan);
+    }
+
+    @Subcommand("%clanff %block")
+    @CommandPermission("simpleclans.leader.ff")
+    @Description("{@@command.description.clanff.block}")
+    public void blockClanFf(Player player, Clan clan) {
+        clan.addBb(player.getName(), lang("clan.wide.friendly.fire.blocked"));
+        clan.setFriendlyFire(false);
+        storage.updateClan(clan);
+    }
+
+    @Subcommand("%description")
+    @CommandPermission("simpleclans.leader.description")
+    @Conditions("verified|rank:name=DESCRIPTION")
+    @Description("{@@command.description.description}")
+    public void setDescription(Player player, Clan clan, @Name("description") String description) {
+        if (description.length() < settings.getInt(CLAN_MIN_DESCRIPTION_LENGTH)) {
+            ChatBlock.sendMessage(player, RED + lang("your.clan.description.must.be.longer.than",
+                    player, settings.getInt(CLAN_MIN_DESCRIPTION_LENGTH)));
+            return;
+        }
+        if (description.length() > settings.getInt(CLAN_MAX_DESCRIPTION_LENGTH)) {
+            ChatBlock.sendMessage(player, RED + lang("your.clan.description.cannot.be.longer.than",
+                    player, settings.getInt(CLAN_MAX_DESCRIPTION_LENGTH)));
+            return;
+        }
+        clan.setDescription(description);
+        ChatBlock.sendMessage(player, AQUA + lang("description.changed", player));
+        storage.updateClan(clan);
+    }
+
+    @Subcommand("%rival %add")
+    @CommandPermission("simpleclans.leader.rival")
+    @Conditions("verified|rivable|minimum_to_rival|rank:name=RIVAL_ADD")
+    @CommandCompletion("@clans:hide_own")
+    @Description("{@@command.description.rival.add}")
+    public void addRival(Player player, Clan issuerClan, @Conditions("verified|different") @Name("clan") ClanInput rival) {
+        Clan rivalInput = rival.getClan();
+        if (settings.isUnrivable(rivalInput.getTag())) {
+            ChatBlock.sendMessage(player, RED + lang("the.clan.cannot.be.rivaled", player));
+            return;
+        }
+        if (!issuerClan.reachedRivalLimit()) {
+            if (!issuerClan.isRival(rivalInput.getTag())) {
+                issuerClan.addRival(rivalInput);
+                rivalInput.addBb(player.getName(), lang("has.initiated.a.rivalry", issuerClan.getName(),
+                        rivalInput.getName()), false);
+                issuerClan.addBb(player.getName(), lang("has.initiated.a.rivalry", player.getName(),
+                        rivalInput.getName()));
+            } else {
+                ChatBlock.sendMessage(player, RED + lang("your.clans.are.already.rivals", player));
+            }
+        } else {
+            ChatBlock.sendMessage(player, RED + lang("rival.limit.reached", player));
+        }
+    }
+
+    @Subcommand("%rival %remove")
+    @CommandPermission("simpleclans.leader.rival")
+    @Conditions("verified|rank:name=RIVAL_REMOVE")
+    @CommandCompletion("@rivals")
+    @Description("{@@command.description.rival.remove}")
+    public void removeRival(Player player,
+                            ClanPlayer cp,
+                            Clan issuerClan,
+                            @Conditions("different") @Name("clan") ClanInput rival) {
+        Clan rivalInput = rival.getClan();
+        if (issuerClan.isRival(rivalInput.getTag())) {
+            requestManager.addRivalryBreakRequest(cp, rivalInput, issuerClan);
+            ChatBlock.sendMessage(player, AQUA + lang("leaders.asked.to.end.rivalry", player,
+                    rivalInput.getName()));
+        } else {
+            ChatBlock.sendMessage(player, RED + lang("your.clans.are.not.rivals", player));
+        }
+    }
+
+    @Subcommand("%ally %add")
+    @CommandPermission("simpleclans.leader.ally")
+    @Conditions("verified|rank:name=ALLY_ADD|minimum_to_ally")
+    @CommandCompletion("@clans:hide_own")
+    @Description("{@@command.description.ally.add}")
+    public void addAlly(Player player,
+                        ClanPlayer cp,
+                        Clan issuerClan,
+                        @Conditions("verified|different") @Name("clan") ClanInput other) {
+        Clan input = other.getClan();
+        if (issuerClan.isAlly(input.getTag())) {
+            ChatBlock.sendMessage(player, RED + lang("your.clans.are.already.allies", player));
+            return;
+        }
+        int maxAlliances = settings.getInt(CLAN_MAX_ALLIANCES);
+        if (maxAlliances != -1) {
+            if (issuerClan.getAllies().size() >= maxAlliances) {
+                ChatBlock.sendMessage(player, lang("your.clan.reached.max.alliances", player));
+                return;
+            }
+            if (input.getAllies().size() >= maxAlliances) {
+                ChatBlock.sendMessage(player, lang("other.clan.reached.max.alliances", player));
+                return;
+            }
+        }
+
+        List<ClanPlayer> onlineLeaders = Helper.stripOffLinePlayers(issuerClan.getLeaders());
+        if (onlineLeaders.isEmpty()) {
+            ChatBlock.sendMessage(player, RED + lang("at.least.one.leader.accept.the.alliance",
+                    player));
+            return;
+        }
+
+        requestManager.addAllyRequest(cp, input, issuerClan);
+        ChatBlock.sendMessage(player, AQUA + lang("leaders.have.been.asked.for.an.alliance",
+                player, input.getName()));
+    }
+
+    @Subcommand("%ally %remove")
+    @Conditions("verified|rank:name=ALLY_REMOVE")
+    @CommandPermission("simpleclans.leader.ally")
+    @Description("{@@command.description.ally.remove}")
+    @CommandCompletion("@allied_clans")
+    public void removeAlly(Player player, Clan issuerClan, @Conditions("different|allied_clan") @Name("clan") ClanInput ally) {
+        Clan allyInput = ally.getClan();
+        issuerClan.removeAlly(allyInput);
+        allyInput.addBb(player.getName(), lang("has.broken.the.alliance", issuerClan.getName(),
+                allyInput.getName()), false);
+        issuerClan.addBb(player.getName(), lang("has.broken.the.alliance", player.getName(),
+                allyInput.getName()));
+    }
+
+    @Subcommand("%kick")
+    @CommandPermission("simpleclans.leader.kick")
+    @CommandCompletion("@clan_members:hide_own")
+    @Conditions("rank:name=KICK")
+    @Description("{@@command.description.kick}")
+    public void kick(@Conditions("clan_member") Player sender,
+                     @Conditions("same_clan") @Name("member") ClanPlayerInput other) {
+        ClanPlayer clanPlayer = other.getClanPlayer();
+        if (sender.getUniqueId().equals(clanPlayer.getUniqueId())) {
+            ChatBlock.sendMessage(sender, RED + lang("you.cannot.kick.yourself", sender));
+            return;
+        }
+
+        Clan clan = cm.getClanByPlayerUniqueId(sender.getUniqueId());
+        if (Objects.requireNonNull(clan).isLeader(clanPlayer.getUniqueId())) {
+            ChatBlock.sendMessage(sender, RED + lang("you.cannot.kick.another.leader", sender));
+            return;
+        }
+
+        clan.addBb(sender.getName(), lang("has.been.kicked.by", clanPlayer.getName(),
+                sender.getName(), sender));
+        clan.removePlayerFromClan(clanPlayer.getUniqueId());
+    }
+
+    @Subcommand("%resign %confirm")
+    @CommandPermission("simpleclans.member.resign")
+    @Description("{@@command.description.resign}")
+    @HelpSearchTags("leave")
+    public void resignConfirm(Player player, ClanPlayer cp, Clan clan) {
+        if (clan.isPermanent() || !clan.isLeader(player) || clan.getLeaders().size() > 1) {
+            clan.addBb(player.getName(), lang("0.has.resigned", player.getName()));
+            cp.addResignTime(clan.getTag());
+            clan.removePlayerFromClan(player.getUniqueId());
+
+            ChatBlock.sendMessage(cp, AQUA + lang("resign.success", player));
+        } else if (clan.isLeader(player) && clan.getLeaders().size() == 1) {
+            clan.disband(player, true, false);
+            ChatBlock.sendMessage(cp, RED + lang("clan.has.been.disbanded", player, clan.getName()));
+        } else {
+            ChatBlock.sendMessage(cp, RED +
+                    lang("last.leader.cannot.resign.you.must.appoint.another.leader.or.disband.the.clan", player));
+        }
+    }
+
+    @Subcommand("%resign")
+    @CommandPermission("simpleclans.member.resign")
+    @Description("{@@command.description.resign}")
+    @HelpSearchTags("leave")
+    public void resign(@Conditions("clan_member") Player player) {
+        new SCConversation(plugin, player, new ResignPrompt()).begin();
+    }
+}