Point submodules at canonical Gitea repositories

Reorder main GUI and add Union Banking preview

.gitattributes

@@ -0,0 +1 @@
+.gitea/CODEOWNERS linguist-detectable=false

.gitbook.yaml

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

.gitea/CODEOWNERS

@@ -0,0 +1,3 @@
+# Pull requests request review from the eligible staff team(s).
+# One approval from either an Admin or Developer satisfies branch protection.
+*   @trueog/Admins @trueog/Developers

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,30 +0,0 @@
----
-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

@@ -1,20 +0,0 @@
----
-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/bintray-publish.yml

@@ -1,29 +0,0 @@
-name: Publish to Bintray (Spigot 1.13+)
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 1.8
-      uses: actions/setup-java@v1
-      with:
-        java-version: 1.8
-        server-id: bintray-roinujnosde-bukkit-plugins # Value of the distributionManagement/repository/id field of the pom.xml
-        server-username: MAVEN_USERNAME
-        server-password: MAVEN_PASSWORD
-
-    - name: Build with Maven
-      run: mvn -B package --file pom.xml
-
-    - name: Publish to Bintray
-      run: mvn -B deploy
-      env:
-        MAVEN_USERNAME: ${{ secrets.BINTRAY_USERNAME }}
-        MAVEN_PASSWORD: ${{ secrets.BINTRAY_TOKEN }}

.github/workflows/maven.yml

@@ -1,31 +0,0 @@
-# This workflow will build a Java project with Maven
-# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-maven
-
-name: Java CI Dev Build
-
-on:
-  push:
-    branches: [ dev ]
-  pull_request:
-    branches: [ dev ]
-
-jobs:
-  build:
-
-    runs-on: ubuntu-latest
-
-    steps:
-    - uses: actions/checkout@v2
-    - name: Set up JDK 1.8
-      uses: actions/setup-java@v1
-      with:
-        java-version: 1.8
-    - name: Build with Maven
-      run: mvn -B package --file pom.xml
-    - name: Create Staging
-      run: mkdir staging && cp target/SimpleClans.jar staging
-    - name: Upload a Build Artifact
-      uses: actions/upload-artifact@v2
-      with:
-        name: SimpleClans
-        path: staging

.gitignore

@@ -1,10 +1,11 @@
-/target/
-/.idea/
-SimpleClans.iml
-/bin/
-/.classpath
-/.project
-/dependency-reduced-pom.xml
-/simpleclans-mc1.8.iml
+.idea/
+bin/
+.classpath
+.project
 *.jar
+build/
+.gradle/
 .settings
+.factorypath
+SimpleClans.iml
+/unions.txt

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "libs/Utilities-OG"]
+	path = libs/Utilities-OG
+	url = https://git.trueog.net/trueog/Utilities-OG
+[submodule "libs/DiamondBank-OG"]
+	path = libs/DiamondBank-OG
+	url = https://git.trueog.net/trueog/DiamondBank-OG

.travis.yml

@@ -1,22 +0,0 @@
-# Use https://travis-ci.org/ for automatic testing
-
-# This is a java project
-language: java
-
-script: mvn install
-
-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
-#sudo: false
-#cache:
-#  directories:
-#    - '$HOME/.m2/repository'

CHANGELOG.md

@@ -0,0 +1,126 @@
+# Unions-OG Changelog
+
+This changelog records only changes made by the Unions-OG soft fork relative
+to upstream [SimpleClans](https://github.com/RoinujNosde/SimpleClans). Changes
+inherited unchanged from SimpleClans are intentionally omitted.
+
+## [2.5.1] - 2026-08-15
+
+- Inactivity purges removed. Unions and player data are no longer deleted on startup.
+
+## [2.5] - 2026-08-13
+
+### Added
+
+- Clickable chat buttons for request responses. Accept and deny regroup requests
+  now display green `[ACCEPT]` and red `[DENY]` buttons in chat that players can
+  click instead of typing commands. Hover text explains each button's action.
+  Command-based responses still work for full backward compatibility.
+- Adventure/MiniMessage dependency for rich text rendering and interactive chat
+  components.
+- Fix union commands and help menu
+
+## [2.4] - 2026-08-10
+
+### Added
+
+- Unions decide by member vote. `disband`, `home set` and `war start` now open
+  a proposal that passes when half the members are in favour, is rejected once
+  half becomes unreachable, and expires after 7 days. Votes are stored in the
+  database, so members can vote when they next log in.
+- `/union vote` shows the open proposal and its tally; `/union vote yes|no`
+  casts a vote. A vote screen in the GUI does the same, and is shown once on
+  login to members who have not voted.
+- Disbanding a union splits its bank evenly between all members. Inert until
+  union bank accounts are enabled.
+- `/clan`, `/clans`, `/factions`, `/guilds`, `/party`, `/tribe`, `/nation`,
+  `/crew`, `/squad` and `/gang` tell the player to use `/union` instead.
+  `/f`, `/faction` and `/guild` are left to Utilities-OG.
+
+### Changed
+
+- Unions are flat. Every union command is member-level, and the three actions
+  above are the only ones needing more than one member's say-so.
+- Folded `unionsog.leader.*` into `unionsog.member.*`, which is granted by
+  default. Union ally management is `unionsog.member.ally-set` and union
+  friendly fire is `unionsog.member.union-ff`, to avoid clashing with the
+  existing ally-chat and personal-friendly-fire nodes.
+- Renamed clan to union across the API, config sections and message keys:
+  `Clan` is `Union`, `clan:` is `union:`, `clanchat:` is `unionchat:`.
+  Database identifiers and PlaceholderAPI placeholder names deliberately keep
+  their `clan` spelling.
+- Renamed `/union clanff` to `/union unionff`.
+- Chat and display formats accept `{union}`; `{clan}` still works.
+- A union now ends with its last member.
+- `/union war start` no longer asks the target union, so the member-count
+  guard always applies. Removed `war-and-protection.war-start.request-enabled`.
+- Inter-union requests are answered by the first member of the asked union
+  rather than by its leaders.
+- Set the union GUI title to "Union Management".
+
+### Removed
+
+- Ranks, promotion and demotion, with their commands, settings, events and GUI
+  screens.
+- The leader role: no leader flag, leader-only command, tag colour, Discord
+  role or `sc_leader` LuckPerms group. The `sc_players.leader` column is kept
+  and always written `0` for data compatibility.
+- The leaders-only land creation option.
+- The in-game Crowdin translation prompts.
+
+### Fixed
+
+- `/union lookup` and `/union profile` no longer print a literal
+  `%player_rank%` or `%clan_leaders%`.
+- Removed a stale `%rank%` token from the default chat formats.
+- `/union unionff block` now requires union membership, matching
+  `/union unionff allow`.
+- The legacy database importer no longer reads or writes leader relationships.
+
+## [2.3] - Initial release
+
+### Added
+
+- `/union` and `/unions` as primary command aliases, keeping `/clan` and
+  `/clans`.
+- `/u [message]` for union chat. Running `/u` alone toggles the channel.
+- `/union color <color>` with named, legacy and hex color support.
+- `simpleunions` PlaceholderAPI aliases alongside the legacy `simpleclans`
+  identifier, plus MiniPlaceholders support through Utilities-OG.
+- A Union Banking preview in the main GUI.
+- A configuration-gated legacy database migration from `unions_parties` and
+  `unions_players`. It never touches the source tables, requires empty
+  transactional destinations, is idempotent, and aborts startup on failure so
+  the server cannot run on partially migrated data.
+
+### Changed
+
+- Renamed the plugin and artifact to Unions-OG, moved the namespace to
+  `net.trueog.unionsog` and permission nodes to `unionsog.*`.
+- Replaced Vault with DiamondBank-OG and its shard-based balances. Legacy
+  Vault-denominated union balances are zeroed once. Union-bank commands are
+  disabled until DiamondBank-OG provides union-owned accounts.
+- Unions are treated as verified without the upstream verification workflow.
+- Reserved `None` as a union name or tag, and made the no-union color-tag
+  placeholder return a stable `&8None`.
+- Bulletin-board messages no longer show on login by default.
+- Reordered the main GUI around the union overview, banking preview, lists,
+  leaderboards and administrative tools.
+- Replaced the WorldGuard 6 reflection provider with the WorldEdit and
+  WorldGuard 7 APIs.
+- Updated MySQL driver loading for Connector/J 8, MariaDB and JDBC service
+  discovery.
+- Migrated the build from Maven to Gradle with a Java 17 toolchain,
+  reproducible shaded jars, and the Utilities-OG and DiamondBank-OG submodules.
+
+### Removed
+
+- The Vault dependency, along with the member-fee and upkeep tasks it backed.
+- The legacy WorldGuard 6 provider.
+- bStats telemetry.
+
+## Fork baseline
+
+The fork last merged upstream SimpleClans history through commit `0406c61b`
+on 2026-03-30. Earlier SimpleClans release history belongs to the upstream
+project.

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,48 +1,140 @@
-SimpleClans
-==========
+![Unions-OG Logo](https://i.imgur.com/9vgfVdX.png)
 
-Full featured clan system for PVP Minecraft Servers!
+# Unions-OG
 
-[![Build Status](https://travis-ci.com/RoinujNosde/SimpleClans.svg?branch=master)](https://travis-ci.com/RoinujNosde/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)
+A full-featured union system for PvP Minecraft servers.
 
-Spigot resource page: https://www.spigotmc.org/resources/simpleclans.71242/
+> [!IMPORTANT]
+> Unions-OG is an unofficial soft fork of
+> [SimpleClans](https://github.com/RoinujNosde/SimpleClans), maintained for the
+> TrueOG Network. Upstream behavior is retained where practical, while
+> branding, integrations, and selected gameplay behavior intentionally differ.
 
-Wiki page: https://github.com/RoinujNosde/SimpleClans/wiki
+Current fork version: **2.4**
 
-#### Developers
+- [Fork-only changelog](CHANGELOG.md)
+- [PlaceholderAPI and MiniPlaceholders reference](placeholder-info.txt)
+- [Upstream SimpleClans project](https://github.com/RoinujNosde/SimpleClans)
 
-Including SimpleClans with Maven:
-```xml
-<repositories>
-    <repository>
-        <id>bintray-roinujnosde-bukkit-plugins</id>
-        <url>https://dl.bintray.com/roinujnosde/bukkit-plugins</url>
-    </repository>
-</repositories>
-<dependencies>
-    <dependency>
-        <groupId>net.sacredlabyrinth.phaed.simpleclans</groupId>
-        <artifactId>SimpleClans</artifactId>
-        <version>2.12.2</version>
-        <scope>provided</scope>
-    </dependency>
-</dependencies>
+## Main fork differences
+
+### Flat unions
+
+Unions have no internal hierarchy. Ranks, promotion, demotion and the leader
+role itself were removed, so every member holds the same powers.
+
+- Every union command is member-level. There is no leader flag, no rank
+  system, and no way to grant one member authority over another.
+- A union ends with its last member: resigning, or being kicked or moved out
+  as the only member, disbands it.
+
+### Decisions by member consensus
+
+Three actions need a vote of the union's own members instead of a leader's
+say-so: **disband**, **home set**, and **war start**.
+
+- A proposal passes as soon as half the members (rounded up) vote in favour,
+  and is rejected as soon as enough vote against that half can no longer be
+  reached.
+- Votes are stored in the database, so a member who is offline when a
+  proposal opens can still vote the next time they log in. Proposals expire
+  after 7 days.
+- A union can only have one proposal open at a time.
+- Members vote with `/union vote yes|no`, or by clicking the vote buttons in
+  the union GUI. The GUI is presented once on login to members who have not
+  voted yet.
+- `/union vote` on its own shows the open proposal and the running tally.
+
+### Other differences
+
+- Uses Unions-OG branding and union terminology throughout, including config
+  sections (`union:`, `unionchat:`) and message keys.
+- Provides `/union` and `/unions`. Other group words — `/clan`, `/clans`,
+  `/factions`, `/guilds`, `/party`, `/tribe`, `/nation`, `/crew`, `/squad` and
+  `/gang` — are registered as signposts that tell the player to run the same command with
+  `/union` instead. `/f`, `/faction` and `/guild` belong to Utilities-OG,
+  which already redirects them.
+- Uses `/u` for union chat; a bare `/u` toggles the union-chat channel.
+- Adds `/union rename <name>` and `/union color <color>`, both open to any
+  member.
+- Union-wide friendly fire is `/union unionff allow|block`, aliased as
+  `/union pvp on|off`. The per-player friendly fire opt-in (`/union ff`)
+  is removed, so friendly fire is decided only by the union setting or the
+  staff-wide `globalff` override.
+- Supports both `simpleclans` and `simpleunions` placeholder identifiers in
+  PlaceholderAPI and MiniPlaceholders.
+- Uses DiamondBank-OG instead of Vault for player economy access. Union-owned
+  bank accounts remain under development, so their commands are currently
+  disabled. Once enabled, disbanding a union splits its bank evenly between
+  all members.
+- Treats unions as verified without requiring the upstream verification
+  workflow.
+- Includes a configuration-gated, transactional importer for the legacy
+  unions database.
+
+See the [changelog](CHANGELOG.md) for the complete list of changes maintained
+by this fork. Upstream SimpleClans changes are intentionally not repeated
+there.
+
+## Documentation
+
+The [Unions-OG wiki](wiki/) documents this fork, and is the reference to use.
+
+- [Commands](wiki/commands-and-permissions/commands.md)
+- [Permissions](wiki/commands-and-permissions/permissions.md)
+- [Proposals and Voting](wiki/commands-and-permissions/proposals-and-voting.md)
+- [Union Alliances and Rivalries](wiki/commands-and-permissions/alliances-and-rivalries.md)
+- [Configuration](wiki/how-to-setup/configuration.md)
+- [PlaceholderAPI Support](wiki/other/placeholderapi-support.md)
+- [API example](wiki/other/unions-og-api.md)
+
+> [!WARNING]
+> The [upstream SimpleClans documentation](https://simpleclans.gitbook.io/simpleclans/)
+> no longer describes this fork. Its pages on leaders, ranks, promotion,
+> demotion, member fees and upkeep do **not** apply, and its command,
+> permission and configuration names have all been renamed here.
+
+For the unmodified upstream plugin and its public releases, use the
+[SimpleClans Spigot page](https://www.spigotmc.org/resources/simpleclans.71242/).
+That download is not an Unions-OG build.
+
+## Building
+
+The build requires Java 17. Clone with submodules, then run:
+
+```bash
+git submodule update --init --recursive
+./gradlew build
 ```
 
-Using Gradle:
-```groovy
-repositories {
-    maven {
-        url  "https://dl.bintray.com/roinujnosde/bukkit-plugins" 
-    }
-}
-dependencies {
-    compileOnly "net.sacredlabyrinth.phaed.simpleclans:SimpleClans:2.12.2"
-}
-```
+The shaded plugin is produced under `build/libs/` with the
+`Unions-OG-2.4.jar` name.
 
-Some examples on how to use the API: https://github.com/RoinujNosde/SimpleClans/wiki/SimpleClans-API-example
+## Developer compatibility
+
+- Java and Gradle namespace: `net.trueog.unionsog`
+- Bukkit main class: `net.trueog.unionsog.UnionsOG`
+- API types use union naming: `Union`, `UnionPlayer`, `UnionManager`,
+  `Proposal`, `DisbandUnionEvent`
+- Permission prefix: `unionsog.*`. Union actions all live under
+  `unionsog.member.*`, which is granted by default; there is no
+  `unionsog.leader.*` tree
+- Command aliases: `union` and `unions`. Other group words are redirect-only
+  signposts, not aliases, and never execute a union command
+- Placeholder identifiers: `simpleunions` and the retained `simpleclans`
+  compatibility identifier. Placeholder **names** deliberately keep their
+  upstream `clan` spelling (`%simpleunions_clan_name%`) so existing setups
+  keep resolving
+- Database identifiers are unchanged for live-data compatibility: the table
+  prefix stays `sc_`, and the `clans` table and `leader` column are retained
+  even though the leader column is no longer used
+- Chat and display formats accept `{union}`; the legacy `{clan}` token still
+  works
+
+The old SimpleClans Maven coordinates and Java packages do not describe this
+fork and should not be used as Unions-OG API coordinates.
+
+## Credits and license
+
+Unions-OG is derived from SimpleClans by its original and upstream
+contributors. This fork remains licensed under the [GNU GPL v3](LICENSE).

bootstrap.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/bash
+
+# Fetch all submodule content.
+git submodule update --force --recursive --init

build.gradle.kts

@@ -0,0 +1,181 @@
+import org.gradle.kotlin.dsl.provideDelegate
+
+/* ------------------------------ Plugins ------------------------------ */
+plugins {
+    id("java") // Import Java plugin.
+    id("java-library") // Import Java Library plugin.
+    id("com.diffplug.spotless") version "8.1.0" // Import Spotless plugin.
+    id("com.gradleup.shadow") version "8.3.9" // Import Shadow plugin.
+    id("checkstyle") // Import Checkstyle plugin.
+    eclipse // Import Eclipse plugin.
+    kotlin("jvm") version "2.1.21" // Import Kotlin JVM plugin.
+}
+
+extra["kotlinAttribute"] = Attribute.of("kotlin-tag", Boolean::class.javaObjectType)
+
+val kotlinAttribute: Attribute<Boolean> by rootProject.extra
+
+/* --------------------------- JDK / Kotlin ---------------------------- */
+java {
+    sourceCompatibility = JavaVersion.VERSION_17 // Compile with JDK 17 compatibility.
+    toolchain { // Select Java toolchain.
+        languageVersion.set(JavaLanguageVersion.of(17)) // Use JDK 17.
+        vendor.set(JvmVendorSpec.GRAAL_VM) // Use GraalVM CE.
+    }
+}
+
+kotlin { jvmToolchain(17) }
+
+/* ----------------------------- Metadata ------------------------------ */
+group = "net.trueog.unionsog" // Declare bundle identifier.
+
+version = "2.5.1" // Declare plugin version (will be in .jar).
+
+val apiVersion = "1.19" // Declare minecraft server target version.
+
+/* ----------------------------- Resources ----------------------------- */
+tasks.named<ProcessResources>("processResources") {
+    val props = mapOf("version" to version, "apiVersion" to apiVersion)
+    inputs.properties(props) // Indicates to rerun if version changes.
+    filesMatching("plugin.yml") { expand(props) }
+    from("LICENSE") { into("/") } // Bundle licenses into jarfiles.
+}
+
+/* ---------------------------- Repos ---------------------------------- */
+repositories {
+    mavenCentral() // Import the Maven Central Maven Repository.
+    gradlePluginPortal() // Import the Gradle Plugin Portal Maven Repository.
+    maven { url = uri("https://repo.purpurmc.org/snapshots") } // Import the PurpurMC Maven Repository.
+    maven { url = uri("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") }
+    maven { url = uri("https://repo.extendedclip.com/content/repositories/placeholderapi/") }
+    maven { url = uri("https://repo.codemc.org/repository/maven-public") }
+    maven { url = uri("https://repo.papermc.io/repository/maven-public/") }
+    maven { url = uri("https://repo.aikar.co/content/groups/aikar/") }
+    maven { url = uri("https://maven.enginehub.org/repo/") }
+    maven { url = uri("https://nexus.scarsz.me/content/groups/public/") }
+    maven { url = uri("https://eldonexus.de/repository/maven-public") }
+    maven { url = uri("https://jitpack.io") }
+    maven { url = uri("file://${System.getProperty("user.home")}/.m2/repository") }
+    System.getProperty("SELF_MAVEN_LOCAL_REPO")?.let {
+        val dir = file(it)
+        if (dir.isDirectory) {
+            println("Using SELF_MAVEN_LOCAL_REPO at: $it")
+            maven { url = uri("file://${dir.absolutePath}") }
+        } else {
+            logger.error("TrueOG Bootstrap not found, defaulting to ~/.m2 for mavenLocal()")
+            mavenLocal()
+        }
+    } ?: logger.error("TrueOG Bootstrap not found, defaulting to ~/.m2 for mavenLocal()")
+}
+
+/* ---------------------- Java project deps ---------------------------- */
+dependencies {
+    compileOnly("org.purpurmc.purpur:purpur-api:1.19.4-R0.1-SNAPSHOT")
+    compileOnly("net.luckperms:api:5.5") // Import LuckPerms API.
+    compileOnlyApi(project(":libs:Utilities-OG")) // Import TrueOG Network Utilities-OG Java API (from source).
+    compileOnlyApi(project(":libs:DiamondBank-OG")) {
+        attributes { attribute(kotlinAttribute, true) }
+    } // Import TrueOG network DiamondBank-OG Kotlin API (from source).
+    compileOnly("me.clip:placeholderapi:2.11.3")
+    compileOnly("org.jetbrains:annotations:24.0.1")
+    implementation("io.papermc:paperlib:1.0.8-SNAPSHOT")
+    implementation("net.kyori:adventure-api:4.14.0")
+    implementation("net.kyori:adventure-text-minimessage:4.14.0")
+    implementation("net.kyori:adventure-platform-bukkit:4.3.0")
+    implementation("co.aikar:acf-paper:0.5.1-SNAPSHOT")
+    implementation("com.github.cryptomorin:XSeries:11.2.0.1")
+    compileOnly("com.sk89q.worldedit:worldedit-bukkit:7.3.0-SNAPSHOT") { isTransitive = false }
+    compileOnly("com.sk89q.worldedit:worldedit-core:7.3.0-SNAPSHOT") { isTransitive = false }
+    compileOnly("com.sk89q.worldguard:worldguard-bukkit:7.0.8") { isTransitive = false }
+    compileOnly("com.sk89q.worldguard:worldguard-core:7.0.8") { isTransitive = false }
+    compileOnly("com.github.TechFortress:GriefPrevention:17.0.0")
+    compileOnly("com.discordsrv:discordsrv:1.28.0")
+    implementation("com.google.code.gson:gson:2.10.1")
+    testImplementation("org.purpurmc.purpur:purpur-api:1.19.4-R0.1-SNAPSHOT")
+    testImplementation("org.junit.jupiter:junit-jupiter-api:5.11.3")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.11.3")
+    testImplementation("org.junit.jupiter:junit-jupiter-params:5.11.3")
+    testImplementation("org.mockito:mockito-core:5.14.2")
+    testImplementation("org.mockito:mockito-junit-jupiter:5.14.2")
+    testImplementation("com.h2database:h2:2.3.232")
+}
+
+apply(from = "eclipse.gradle.kts") // Import eclipse classpath support script.
+
+/* ---------------------- Reproducible jars ---------------------------- */
+tasks.withType<AbstractArchiveTask>().configureEach { // Ensure reproducible .jars
+    isPreserveFileTimestamps = false
+    isReproducibleFileOrder = true
+}
+
+/* ----------------------------- Shadow -------------------------------- */
+tasks.shadowJar {
+    relocate("io.papermc.lib", "net.trueog.unionsog.paperlib")
+    relocate("co.aikar.commands", "net.trueog.unionsog.acf")
+    relocate("co.aikar.locales", "net.trueog.unionsog.locales")
+    relocate("com.cryptomorin.xseries", "net.trueog.unionsog.xseries")
+    relocate("com.google.gson", "net.trueog.unionsog.gson")
+    dependencies { exclude(dependency("org.jetbrains:annotations:.*")) }
+    archiveBaseName.set("Unions-OG")
+    archiveClassifier.set("")
+}
+
+tasks.jar { archiveClassifier.set("part") } // Applies to root jarfile only.
+
+tasks.build { dependsOn(tasks.spotlessApply, tasks.shadowJar, tasks.javadoc) } // Build depends on spotless and shadow.
+
+/* --------------------------- Javac opts ------------------------------- */
+tasks.withType<JavaCompile>().configureEach {
+    options.compilerArgs.add("-parameters") // Enable reflection for java code.
+    options.isFork = true // Run javac in its own process.
+    options.compilerArgs.add("-Xlint:deprecation") // Trigger deprecation warning messages.
+    options.encoding = "UTF-8" // Use UTF-8 file encoding.
+}
+
+tasks.test { useJUnitPlatform() }
+
+/* ----------------------------- Auto Formatting ------------------------ */
+spotless {
+    java {
+        eclipse().configFile("config/formatter/eclipse-java-formatter.xml") // Eclipse java formatting.
+        leadingTabsToSpaces() // Convert leftover leading tabs to spaces.
+        removeUnusedImports() // Remove imports that aren't being called.
+    }
+    kotlinGradle {
+        ktfmt().kotlinlangStyle().configure { it.setMaxWidth(120) } // JetBrains Kotlin formatting.
+        target("build.gradle.kts", "settings.gradle.kts") // Gradle files to format.
+    }
+}
+
+checkstyle {
+    toolVersion = "10.18.1" // Declare checkstyle version to use.
+    configFile = file("config/checkstyle/checkstyle.xml") // Point checkstyle to config file.
+    isIgnoreFailures = true // Don't fail the build if checkstyle does not pass.
+    isShowViolations = true // Show the violations in any IDE with the checkstyle plugin.
+}
+
+tasks.named("compileJava") {
+    dependsOn("spotlessApply") // Run spotless before compiling with the JDK.
+}
+
+tasks.named("spotlessCheck") {
+    dependsOn("spotlessApply") // Run spotless before checking if spotless ran.
+}
+
+/* ------------------------------ Eclipse SHIM ------------------------- */
+
+// This can't be put in eclipse.gradle.kts because Gradle is weird.
+subprojects {
+    apply(plugin = "java-library")
+    apply(plugin = "eclipse")
+    eclipse.project.name = "${project.name}-${rootProject.name}"
+    tasks.withType<Jar>().configureEach { archiveBaseName.set("${project.name}-${rootProject.name}") }
+}
+
+tasks.register<Copy>("copyToTestServer") {
+    val out = System.getenv("TEST_SERVER")?.let { file("$it/plugins") }
+    onlyIf { out != null }
+    dependsOn(tasks.shadowJar)
+    from(tasks.shadowJar)
+    into(out ?: layout.buildDirectory.dir("noop").get().asFile)
+}

config/checkstyle/checkstyle.xml

@@ -0,0 +1,34 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC
+  "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+  "https://checkstyle.org/dtds/configuration_1_3.dtd">
+<module name="Checker">
+
+  <module name="FileTabCharacter">
+    <property name="eachLine" value="true"/>
+    <property name="severity" value="error"/>
+  </module>
+
+  <module name="TreeWalker">
+    <module name="FinalLocalVariable"/>
+    <module name="AvoidStarImport"/>
+    <module name="Indentation">
+      <property name="severity" value="ignore"/>
+    </module>
+  </module>
+
+  <module name="RegexpSingleline">
+    <property name="format" value="\borg\.junit\.jupiter\.api\.Assertions\.fail\s*\(\s*&quot;Not yet implemented&quot;\s*\)\s*;"/>
+    <property name="message" value="Remove placeholder fail() and implement the test."/>
+    <property name="ignoreCase" value="true"/>
+    <property name="severity" value="warning"/>
+  </module>
+
+  <module name="RegexpSingleline">
+    <property name="format" value="(?&lt;!\w)fail\s*\(\s*&quot;Not yet implemented&quot;\s*\)\s*;"/>
+    <property name="message" value="Remove placeholder fail() and implement the test."/>
+    <property name="severity" value="warning"/>
+  </module>
+
+</module>
+

config/formatter/eclipse-java-formatter.xml

@@ -0,0 +1,404 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<profiles version="23">
+    <profile kind="CodeFormatterProfile" name="TrueOG Network Formatting" version="23">
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_ellipsis" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_for_statment" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_javadoc_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indentation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_enum_constant_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_with_spaces" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_before_code_block" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_switch_case_expressions" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_package" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_root_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.enabling_tag" value="@formatter:on"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.count_line_length_from_starting_position" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_record_components" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_multiplicative_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameterized_type_references" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_logical_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_annotation_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_abstract_method" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_constant_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_variable_declarations_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_catch_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiplicative_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_anonymous_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_switch_case_expressions" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_shift_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_parameters" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_loops" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_for_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_switch_case_arrow_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_annotation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_ellipsis" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_enum_constant" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.text_block_indentation" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_type_members_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assignment" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_module_statements" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_names_descriptions" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_if_then_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_assignment_statements_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_permitted_types" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression_chain" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_header" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_annotations" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assertion_message_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_method_declaration" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_fields_grouping_blank_lines" value="2147483647"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_bitwise_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_resources_in_try" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_source_code" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_field" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_method" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_not_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_type_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_html" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_delcaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_compact_if" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_empty_lines" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_type_arguments" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_unary_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_package" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_label" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_permitted_types_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_record_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_bitwise_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.javadoc_do_not_separate_block_tags" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_tag_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_constructor" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_string_concatenation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_multiple_fields" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_array_initializer" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_shift_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_do_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_record_components" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_for_loop_header" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_additive_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_getter_setter_on_one_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_block_in_case_after_arrow" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_lambda_arrow" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_lines_in_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_import_groups" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_method_invocation" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_record_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_switch_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.disabling_tag" value="@formatter:off"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_enum_constants" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_imports" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_end_of_method_body" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_if_while_statement" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_block" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_arrow" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.align_tags_descriptions_grouped" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.line_length" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_on_off_tags" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_method_body_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_loop_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_method_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_type_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_additive_operator" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_constructor" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_relational_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_lambda_body" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.compact_else_if" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_parameter" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_relational_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_arrows_in_switch_on_columns" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_string_concatenation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_line_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.align_selector_in_method_invocation_on_expression_first_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_record_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_switch_case_with_arrow_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_expressions_in_switch_case_with_colon" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_after_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_conditional_expression" value="80"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_type" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_local_variable" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_arrow_in_switch_default" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.insert_new_line_between_different_tags" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_additive_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_wrapped_lines" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_field" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_conditional_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.join_line_comments" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_shift_operator" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_try_clause" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_code_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_record_components" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.size" value="4"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_bitwise_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer" value="2"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_record_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_assignment_operator" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_switch" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_switch_case_with_arrow" value="20"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_lambda_body_block_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_annotations_on_method" value="49"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_record_constructor_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_record_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_assertion_message" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_member_type" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_logical_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_record_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_semicolon" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_relational_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.format_block_comments" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration" value="16"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_after_last_class_body_declaration" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_statements_compare_to_body" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_simple_while_body_on_same_line" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_logical_operator" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_between_statement_group_in_switch" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.parentheses_positions_in_lambda_declaration" value="common_lines"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_comma_in_permitted_types" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.keep_enum_declaration_on_one_line" value="one_line_never"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_enum_constant" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.brace_position_for_type_declaration" value="next_line_on_wrap"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_multiplicative_operator" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.blank_lines_before_package" value="0"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional" value="insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.comment.indent_parameter_description" value="false"/>
+        <setting id="org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_code_block" value="1"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.tabulation.char" value="space"/>
+        <setting id="org.eclipse.jdt.core.formatter.wrap_before_string_concatenation" value="true"/>
+        <setting id="org.eclipse.jdt.core.formatter.lineSplit" value="120"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation" value="do not insert"/>
+        <setting id="org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch" value="insert"/>
+    </profile>
+</profiles>

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%

dependency-reduced-pom.xml

@@ -1,202 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<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/maven-v4_0_0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>net.sacredlabyrinth.phaed.simpleclans</groupId>
-  <artifactId>SimpleClans</artifactId>
-  <name>SimpleClans</name>
-  <version>2.14.0</version>
-  <url>http://dev.bukkit.org/server-mods/simpleclans/</url>
-  <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>
-    <tag>SimpleClans</tag>
-    <url>http://github.com/marcelo-mason/SimpleClans.git/tree/master/</url>
-  </scm>
-  <build>
-    <resources>
-      <resource>
-        <targetPath>.</targetPath>
-        <filtering>true</filtering>
-        <directory>${basedir}/src/main/resources</directory>
-        <includes>
-          <include>plugin.yml</include>
-          <include>config.yml</include>
-          <include>*.properties</include>
-        </includes>
-      </resource>
-    </resources>
-    <finalName>${project.name}</finalName>
-    <plugins>
-      <plugin>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>3.1</version>
-        <configuration>
-          <source>1.8</source>
-          <target>1.8</target>
-          <showDeprecation>true</showDeprecation>
-          <showWarnings>true</showWarnings>
-          <fork>true</fork>
-          <compilerArgs>
-            <arg>-parameters</arg>
-          </compilerArgs>
-        </configuration>
-      </plugin>
-      <plugin>
-        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.4</version>
-      </plugin>
-      <plugin>
-        <artifactId>maven-release-plugin</artifactId>
-        <version>2.3.2</version>
-      </plugin>
-      <plugin>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>3.1.0</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <relocations>
-            <relocation>
-              <pattern>org.bstats.bukkit</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>
-          </relocations>
-          <artifactSet>
-            <excludes>
-              <exclude>org.jetbrains:annotations</exclude>
-            </excludes>
-          </artifactSet>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-  <repositories>
-    <repository>
-      <id>spigot-repo</id>
-      <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-    </repository>
-    <repository>
-      <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>jitpack.io</id>
-      <url>https://jitpack.io</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>
-  </repositories>
-  <dependencies>
-    <dependency>
-      <groupId>org.spigotmc</groupId>
-      <artifactId>spigot-api</artifactId>
-      <version>1.13.2-R0.1-SNAPSHOT</version>
-      <scope>provided</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>commons-lang</artifactId>
-          <groupId>commons-lang</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>guava</artifactId>
-          <groupId>com.google.guava</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>gson</artifactId>
-          <groupId>com.google.code.gson</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>bungeecord-chat</artifactId>
-          <groupId>net.md-5</groupId>
-        </exclusion>
-        <exclusion>
-          <artifactId>snakeyaml</artifactId>
-          <groupId>org.yaml</groupId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>com.github.MilkBowl</groupId>
-      <artifactId>VaultAPI</artifactId>
-      <version>1.7</version>
-      <scope>provided</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>bukkit</artifactId>
-          <groupId>org.bukkit</groupId>
-        </exclusion>
-      </exclusions>
-    </dependency>
-    <dependency>
-      <groupId>com.googlecode.json-simple</groupId>
-      <artifactId>json-simple</artifactId>
-      <version>1.1.1</version>
-      <scope>provided</scope>
-      <exclusions>
-        <exclusion>
-          <artifactId>junit</artifactId>
-          <groupId>junit</groupId>
-        </exclusion>
-      </exclusions>
-    </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>16.0.2</version>
-      <scope>compile</scope>
-    </dependency>
-  </dependencies>
-  <distributionManagement>
-    <repository>
-      <id>bintray-roinujnosde-bukkit-plugins</id>
-      <name>roinujnosde-bukkit-plugins</name>
-      <url>https://api.bintray.com/maven/roinujnosde/bukkit-plugins/SimpleClans/;publish=1</url>
-    </repository>
-  </distributionManagement>
-  <properties>
-    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-  </properties>
-</project>
-

eclipse.gradle.kts

@@ -0,0 +1,151 @@
+/* This is free and unencumbered software released into the public domain */
+
+import org.gradle.plugins.ide.eclipse.model.EclipseModel
+import java.nio.file.Files
+import javax.xml.parsers.DocumentBuilderFactory
+import javax.xml.transform.OutputKeys
+import javax.xml.transform.TransformerFactory
+import javax.xml.transform.dom.DOMSource
+import javax.xml.transform.stream.StreamResult
+
+val kotlinAttribute: Attribute<Boolean> by rootProject.extra
+
+val kotlinPluginProjects = configurations
+.getByName("compileClasspath")
+.allDependencies
+    .filterIsInstance<ProjectDependency>()
+    .filter { it -> it.attributes.getAttribute(kotlinAttribute) != null }
+    .map { it.path }
+kotlinPluginProjects.forEach { evaluationDependsOn(it) }
+
+val ideLibs: Configuration by
+configurations.creating {
+    isCanBeResolved = true
+    isCanBeConsumed = false
+}
+
+configure<EclipseModel> {
+    project {
+        name = "Template-OG-Plugin"
+    }
+    classpath {
+        plusConfigurations.add(ideLibs)
+    }
+}
+
+val ideLibDir = layout.buildDirectory.dir("ide-libs")
+val hashRegex = Regex("-[0-9a-fA-F]{10}(?=\\.jar$)") // Black magic.
+
+val copyTasks = mutableListOf<TaskProvider<Copy>>()
+
+kotlinPluginProjects.forEach { path ->
+    val sub = project(path)
+    val shadowJarProv = sub.tasks.named("shadowJar")
+    val copyTask =
+        tasks.register<Copy>("ideCopy${sub.name.replaceFirstChar(Char::titlecase)}") {
+            dependsOn(shadowJarProv)
+            from(shadowJarProv)
+            into(ideLibDir)
+            rename { it.replace(hashRegex, "") } // Remove git commit hash from jarfile.
+        }
+    copyTasks += copyTask
+}
+
+/* Ensure the jars exist before .classpath is generated */
+tasks.named("eclipseClasspath").configure { dependsOn(copyTasks) }
+
+/* Supply those jars to the ideLibs configuration (after evaluation) */
+afterEvaluate { dependencies { add("ideLibs", fileTree(ideLibDir) { include("*.jar") }) } }
+
+val injectIdeLibs =
+    tasks.register("injectIdeLibs") {
+        dependsOn("eclipse") // run after all eclipse files are generated
+        doLast {
+            val cpFile = file(".classpath")
+            if (!cpFile.exists()) return@doLast
+
+            val jars = fileTree(ideLibDir.get()) { include("*.jar") }.files.sortedBy { it.name }
+            if (jars.isEmpty()) return@doLast
+
+            // Parse DOM
+            val dbf = DocumentBuilderFactory.newInstance()
+            val doc = dbf.newDocumentBuilder().parse(cpFile)
+            val root = doc.documentElement
+
+            // Helper to see if an entry already exists
+            fun exists(path: String): Boolean =
+                root.getElementsByTagName("classpathentry").let { list ->
+                    (0 until list.length).any { i ->
+                        val n = list.item(i)
+                        val kind = n.attributes?.getNamedItem("kind")?.nodeValue
+                        val p = n.attributes?.getNamedItem("path")?.nodeValue
+                        kind == "lib" && p == path
+                    }
+                }
+
+            // Remove any entry that points to ide-libs dir (folder or jars) to avoid dupes
+            val toRemove = mutableListOf<org.w3c.dom.Node>()
+            val list = root.getElementsByTagName("classpathentry")
+            val dirPath = ideLibDir.get().asFile.absolutePath
+            for (i in 0 until list.length) {
+                val n = list.item(i)
+                val kind = n.attributes?.getNamedItem("kind")?.nodeValue
+                val p = n.attributes?.getNamedItem("path")?.nodeValue ?: ""
+                if (kind == "lib" && (p == dirPath || p.startsWith("$dirPath/"))) {
+                    toRemove += n
+                }
+            }
+            toRemove.forEach { root.removeChild(it) }
+
+            // Append our jar entries LAST
+            jars.forEach { f ->
+                val abs = f.absolutePath
+                if (!exists(abs)) {
+                    val entry = doc.createElement("classpathentry")
+                    entry.setAttribute("kind", "lib")
+                    entry.setAttribute("path", abs)
+                    root.appendChild(entry)
+                }
+            }
+
+            // Write back pretty
+            val tf =
+                TransformerFactory.newInstance().newTransformer().apply {
+                    setOutputProperty(OutputKeys.INDENT, "yes")
+                    setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "1")
+                    setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no")
+                    setOutputProperty(OutputKeys.ENCODING, "UTF-8")
+                }
+            Files.newBufferedWriter(cpFile.toPath()).use { w -> tf.transform(DOMSource(doc), StreamResult(w)) }
+        }
+    }
+
+tasks.named("eclipse").configure { finalizedBy(injectIdeLibs) }
+
+val eclipseModel = extensions.getByType<EclipseModel>()
+
+fun Project.addResolvableEclipseConfigs() {
+    val jarAttr =
+        objects.named(org.gradle.api.attributes.LibraryElements::class, org.gradle.api.attributes.LibraryElements.JAR)
+    val apiAttr = objects.named(org.gradle.api.attributes.Usage::class, org.gradle.api.attributes.Usage.JAVA_API)
+
+    val compileOnlyRes =
+        configurations.create("eclipseCompileOnly") {
+            extendsFrom(configurations.getByName("compileOnly"))
+            isCanBeResolved = true
+            isCanBeConsumed = false
+            attributes.attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE, apiAttr)
+            attributes.attribute(org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, jarAttr)
+        }
+    val compileOnlyApiRes =
+        configurations.create("eclipseCompileOnlyApi") {
+            extendsFrom(configurations.getByName("compileOnlyApi"))
+            isCanBeResolved = true
+            isCanBeConsumed = false
+            attributes.attribute(org.gradle.api.attributes.Usage.USAGE_ATTRIBUTE, apiAttr)
+            attributes.attribute(org.gradle.api.attributes.LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, jarAttr)
+        }
+    eclipseModel.classpath.plusConfigurations.addAll(listOf(compileOnlyRes, compileOnlyApiRes))
+}
+
+addResolvableEclipseConfigs()

gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=1024m -Dfile.encoding=UTF-8
+

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

gradlew

@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed 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
+#
+#      https://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.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+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
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

org/bukkit/configuration/annotations.xml

@@ -1,7 +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;"/>
+            <val val="&quot;_, _ -&gt; !null&quot;"/>
         </annotation>
     </item>
 </root>

placeholder-info.txt

@@ -0,0 +1,194 @@
+Unions-OG Placeholder Reference
+===============================
+
+Unions-OG registers legacy PlaceholderAPI placeholders when PlaceholderAPI is installed.
+It also registers MiniPlaceholders through the Utilities-OG API when Utilities-OG is installed.
+
+Identifiers
+-----------
+
+All placeholders use both identifiers:
+
+- simpleclans
+- simpleunions
+
+In the syntax patterns below, replace {id} with either identifier.
+
+Legacy PlaceholderAPI syntax:
+
+- Player placeholder: %{id}_{player-placeholder}%
+- Union placeholder: %{id}_clan_{union-placeholder}%
+- Union compatibility alias: %{id}_union_{union-placeholder}%
+- Relational color placeholder: %rel_{id}_color%
+
+MiniPlaceholders syntax:
+
+- Player placeholder: <{id}_{player-placeholder}>
+- Union placeholder: <{id}_clan_{union-placeholder}>
+- Union compatibility alias: <{id}_union_{union-placeholder}>
+- Relational color placeholder: <{id}_rel_color>
+
+MiniPlaceholders are audience placeholders unless marked relational. They require a player audience.
+Relational MiniPlaceholders require a relational MiniPlaceholders context.
+
+Boolean output follows PlaceholderAPI's boolean.true and boolean.false config values when PlaceholderAPI is loaded.
+Without PlaceholderAPI, boolean placeholders return yes or no.
+
+Player Placeholders
+-------------------
+
+These resolve against the requested player:
+
+- name
+- clean_name
+- lastseendays
+- total_kills
+- rival_kills
+- civilian_kills
+- neutral_kills
+- ally_kills
+- is_friendlyfire_on
+- deaths
+- weighted_kills
+- kdr
+- topplayers_position
+- join_date
+- lastseen
+- inactive_days
+- in_clan
+- tag
+- tag_label
+- is_trusted
+- is_member
+- clanchat_player_color
+- allychat_player_color
+- is_bb_enabled
+- is_invite_enabled
+- is_tag_enabled
+- is_muted
+- is_mutedally
+
+Player compatibility aliases:
+
+- in_union maps to in_clan
+- unionchat_player_color maps to clanchat_player_color
+
+Examples:
+
+- %simpleclans_name%
+- %simpleunions_in_union%
+- <simpleclans_name>
+- <simpleunions_in_union>
+
+Union Placeholders
+------------------
+
+These resolve against the requested player's union:
+
+- name
+- balance
+- balance_formatted
+- tag
+- color
+- inactivedays
+- friendly_fire
+- allies_count
+- founded
+- color_tag
+- size
+- rivals_count
+- is_permanent
+- onlinemembers_count
+- total_kdr
+- topclans_position
+- total_deaths
+- average_wk
+- total_kills
+- total_rival
+- total_neutral
+- total_civilian
+- total_ally
+- is_anyonline
+- is_unrivable
+- allow_withdraw
+- allow_deposit
+
+Union compatibility aliases:
+
+- Use union_ instead of clan_ for any union placeholder.
+- topunions_position maps to topclans_position.
+
+Examples:
+
+- %simpleclans_clan_name%
+- %simpleclans_union_name%
+- %simpleunions_clan_color_tag%
+- %simpleunions_union_topunions_position%
+- <simpleclans_clan_name>
+- <simpleclans_union_name>
+- <simpleunions_clan_color_tag>
+- <simpleunions_union_topunions_position>
+
+Top Player Placeholders
+-----------------------
+
+Legacy PlaceholderAPI syntax:
+
+- %{id}_topplayers_{position}_{player-placeholder}%
+
+MiniPlaceholders syntax:
+
+- <{id}_topplayers_{player-placeholder}:{position}>
+
+The {position} value is 1-based. The {player-placeholder} value can be any player placeholder or player compatibility alias listed above.
+
+Examples:
+
+- %simpleclans_topplayers_1_name%
+- %simpleunions_topplayers_3_kdr%
+- <simpleclans_topplayers_name:1>
+- <simpleunions_topplayers_kdr:3>
+
+Top Union Placeholders
+----------------------
+
+Legacy PlaceholderAPI syntax:
+
+- %{id}_topclans_{position}_clan_{union-placeholder}%
+- %{id}_topunions_{position}_union_{union-placeholder}%
+
+MiniPlaceholders syntax:
+
+- <{id}_topclans_clan_{union-placeholder}:{position}>
+- <{id}_topunions_union_{union-placeholder}:{position}>
+
+The {position} value is 1-based. The {union-placeholder} value can be any union placeholder or union compatibility alias listed above.
+
+Examples:
+
+- %simpleclans_topclans_1_clan_name%
+- %simpleclans_topunions_1_union_name%
+- %simpleunions_topclans_5_clan_total_kdr%
+- <simpleclans_topclans_clan_name:1>
+- <simpleclans_topunions_union_name:1>
+- <simpleunions_topclans_clan_total_kdr:5>
+
+Relational Color Placeholder
+----------------------------
+
+The relational color placeholder returns a color code based on the relationship between two players:
+
+- same union: &a
+- ally: &b
+- rival: &c
+- unrelated: empty string
+
+Legacy PlaceholderAPI syntax:
+
+- %rel_simpleclans_color%
+- %rel_simpleunions_color%
+
+MiniPlaceholders syntax:
+
+- <simpleclans_rel_color>
+- <simpleunions_rel_color>

pom.xml

@@ -1,220 +0,0 @@
-<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.14.1</version>
-    <name>SimpleClans</name>
-    <url>http://dev.bukkit.org/server-mods/simpleclans/</url>
-
-    <build>
-        <finalName>${project.name}</finalName>
-
-        <!-- Resources -->
-        <resources>
-            <resource>
-                <targetPath>.</targetPath>
-                <filtering>true</filtering>
-                <directory>${basedir}/src/main/resources</directory>
-                <includes>
-                    <include>plugin.yml</include>
-                    <include>config.yml</include>
-                    <include>*.properties</include>
-                </includes>
-            </resource>
-        </resources>
-
-        <!-- Plugins -->
-        <plugins>
-            <!-- Compilation plugin -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.1</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                    <showDeprecation>true</showDeprecation>
-                    <showWarnings>true</showWarnings>
-                    <fork>true</fork>
-                    <compilerArgs>
-                        <arg>-parameters</arg>
-                    </compilerArgs>
-                </configuration>
-            </plugin>
-
-            <!-- JAR creation plugin -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-jar-plugin</artifactId>
-                <version>2.4</version>
-            </plugin>
-
-            <!-- Release plugin -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-release-plugin</artifactId>
-                <version>2.3.2</version>
-            </plugin>
-            
-            <!-- Shade plugin -->
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.1.0</version>
-                <configuration>
-                    <relocations>
-                        <relocation>
-                            <pattern>org.bstats.bukkit</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>
-                    </relocations>
-                    <artifactSet>
-                        <excludes>
-                            <exclude>org.jetbrains:annotations</exclude>
-                        </excludes>
-                    </artifactSet>
-                </configuration>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                    </execution>
-                </executions>
-            </plugin>
-        </plugins>
-    </build>
-    <!-- Dependencies -->
-    <dependencies>
-        <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.13.2-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.github.MilkBowl</groupId>
-            <artifactId>VaultAPI</artifactId>
-            <version>1.7</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.googlecode.json-simple</groupId>
-            <artifactId>json-simple</artifactId>
-            <version>1.1.1</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.bstats</groupId>
-            <artifactId>bstats-bukkit</artifactId>
-            <version>1.7</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>16.0.2</version>
-        </dependency>
-        <dependency>
-            <groupId>io.papermc</groupId>
-            <artifactId>paperlib</artifactId>
-            <version>1.0.5</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>co.aikar</groupId>
-            <artifactId>acf-paper</artifactId>
-            <version>0.5.0-SNAPSHOT</version>
-        </dependency>
-        <dependency>
-            <groupId>com.github.cryptomorin</groupId>
-            <artifactId>XSeries</artifactId>
-            <version>7.2.1</version>
-        </dependency>
-        <dependency>
-            <groupId>org.reflections</groupId>
-            <artifactId>reflections</artifactId>
-            <version>0.9.12</version>
-        </dependency>
-    </dependencies>
-
-    <!-- Repositories -->
-    <repositories>
-        <repository>
-            <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-        </repository>
-        <repository>
-            <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>jitpack.io</id>
-            <url>https://jitpack.io</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>
-    </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>
-
-    <!-- Upstream Distribution -->
-
-    <distributionManagement>
-        <repository>
-            <id>bintray-roinujnosde-bukkit-plugins</id>
-            <name>roinujnosde-bukkit-plugins</name>
-            <url>https://api.bintray.com/maven/roinujnosde/bukkit-plugins/SimpleClans/;publish=1</url>
-        </repository>
-    </distributionManagement>
-</project>

settings.gradle.kts

@@ -0,0 +1,13 @@
+rootProject.name = "Unions-OG"
+
+ProcessBuilder("sh", "bootstrap.sh").directory(rootDir).inheritIO().start().let {
+    if (it.waitFor() != 0) throw GradleException("bootstrap.sh failed")
+}
+
+file("libs")
+    .listFiles()
+    ?.filter { it.isDirectory && !it.name.startsWith(".") }
+    ?.forEach { dir ->
+        include(":libs:${dir.name}")
+        project(":libs:${dir.name}").projectDir = dir
+    }

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/ClanRequest.java

@@ -1,10 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-/**
- * Clan Requests
- * @author phaed
- */
-public enum ClanRequest
-{
-    DEMOTE, PROMOTE, DISBAND, INVITE, CREATE_ALLY, BREAK_RIVALRY, START_WAR, END_WAR
-}

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/Helper.java

@@ -1,862 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import net.sacredlabyrinth.phaed.simpleclans.utils.KDRFormat;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-import org.json.simple.JSONArray;
-import org.json.simple.JSONObject;
-import org.json.simple.parser.JSONParser;
-import org.json.simple.parser.ParseException;
-
-import java.io.IOException;
-import java.lang.reflect.Method;
-import java.net.HttpURLConnection;
-import java.net.URL;
-import java.text.DecimalFormat;
-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;
-
-/**
- * @author phaed
- */
-public class Helper {
-
-    private Helper() {
-    }
-
-    /**
-     * Dumps stacktrace to log
-     */
-    @Deprecated
-    public static void dumpStackTrace() {
-        for (StackTraceElement el : Thread.currentThread().getStackTrace()) {
-            SimpleClans.debug(el.toString());
-        }
-    }
-
-    /**
-     * @deprecated use {@link KDRFormat}
-     */
-    @Deprecated
-    public static String formatKDR(float kdr) {
-    	DecimalFormat formatter = new DecimalFormat("#.#");
-    	return formatter.format(kdr);
-    }
-
-    @NotNull
-    public static Locale forLanguageTag(@Nullable String languageTag) {
-        Locale defaultLanguage = SimpleClans.getInstance().getSettingsManager().getLanguage();
-        if (languageTag == null) {
-            return defaultLanguage;
-        }
-        return Locale.forLanguageTag(languageTag);
-    }
-    
-    /**
-     * Gets the Player locale
-     * 
-     * @param player the player
-     * @return the locale
-     */
-    @Nullable
-    public static Locale getLocale(@NotNull Player player) {
-        ClanPlayer clanPlayer = SimpleClans.getInstance().getClanManager().getAnyClanPlayer(player.getUniqueId());
-        if (clanPlayer != null) {
-            return clanPlayer.getLocale();
-        }
-        return null;
-    }
-    
-    /**
-     * Converts a JSON String to a list of Ranks
-     * 
-     * @param json
-     * @return a list of ranks or null if the JSON String is null/empty
-     */
-	public static List<Rank> ranksFromJson(String json) {
-    	if (json != null && !json.isEmpty()) {
-	    	try {
-				JSONObject jo = (JSONObject) new JSONParser().parse(json);
-				Object ranks = jo.get("ranks");
-				if (ranks != null) {
-					JSONArray array = (JSONArray) ranks;
-					List<Rank> rankList = new ArrayList<>();
-					for (Object o : array) {
-						JSONObject r = (JSONObject) o;
-						String name = (String) r.get("name");
-						String displayName = (String) r.get("displayName");
-						Set<String> permissions = new HashSet<>();
-						for (Object p : (JSONArray) r.get("permissions")) {
-							permissions.add((String) p);
-						}
-						Rank rank = new Rank(name, displayName, permissions);
-						rankList.add(rank);
-					}
-					
-					return rankList;
-					
-				}
-			} catch (ParseException e) {
-				e.printStackTrace();
-			}
-    	}
-    	return null;
-    }
-    
-    /**
-     * Converts a list of Ranks to a JSON String
-     * 
-     * @param ranks
-     * @return a JSON String
-     */
-    @SuppressWarnings("unchecked")
-	public static String ranksToJson(List<Rank> ranks) {
-    	if (ranks == null)
-    		ranks = new ArrayList<Rank>();
-    	
-    	JSONArray array = new JSONArray();
-    	for (Rank rank : ranks) {
-    		JSONObject o = new JSONObject();
-    		o.put("name", rank.getName());
-    		o.put("displayName", rank.getDisplayName());
-    		JSONArray permArray = new JSONArray();
-    		for (String p : rank.getPermissions()) {
-    			permArray.add(p);
-    		}
-    		o.put("permissions", permArray);
-    		array.add(o);
-    	}
-    	
-    	JSONObject object = new JSONObject();
-    	object.put("ranks", array);
-    	return object.toJSONString();
-    }
-    
-    /**
-     * Converts a resign times map to a JSON String
-     * 
-     * @param resignTimes
-     * @return a JSON String
-     */
-    public static String resignTimesToJson(Map<String, Long> resignTimes) {
-    	return JSONObject.toJSONString(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;
-    }
-    
-    /**
-     * Returns the delay in seconds to the specified hour and minute.
-     * 
-     * @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(hour, minute));
-        long delay;
-        if (now.isAfter(d)) {
-            delay = now.until(d.plusDays(1), ChronoUnit.SECONDS);
-        } else {
-            delay = now.until(d, ChronoUnit.SECONDS);
-        }
-        return delay;
-    }
-
-    /**
-     * Get a players full color name if he is online
-     *
-     * @param playerName
-     * @return
-     */
-    public static String getColorName(String playerName) {
-        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));
-        }
-
-        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
-     */
-    @NotNull
-    public static String toColor(@Nullable String hexValue) {
-        if (hexValue == null) {
-            return "";
-        }
-
-        ChatColor color = ChatColor.getByChar(hexValue);
-        if (color == null) {
-            return "";
-        }
-        return color.toString();
-    }
-
-    /**
-     * Converts string array to ArrayList<String>, remove empty strings
-     *
-     * @param values
-     * @return
-     */
-    public static List<String> fromArray(String... values) {
-        List<String> results = new ArrayList<>();
-        Collections.addAll(results, values);
-        results.remove("");
-        return results;
-    }
-
-    /**
-     * Converts string array to HashSet<String>, remove empty strings
-     *
-     * @param values
-     * @return
-     */
-    public static Set<String> fromArray2(String... values) {
-        HashSet<String> results = new HashSet<>();
-        Collections.addAll(results, values);
-        results.remove("");
-        return results;
-    }
-
-    /**
-     * 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
-     *
-     * @param list
-     * @return
-     */
-    public static String[] toArray(List<String> list) {
-        return list.toArray(new String[list.size()]);
-    }
-    
-    /**
-     * Converts the Permission values array to a String array
-     * 
-     * @return
-     */
-    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 sa;
-    }
-
-    /**
-     * Removes first item from a string array
-     *
-     * @param args
-     * @return
-     */
-    public static String[] removeFirst(String[] args) {
-        List<String> out = fromArray(args);
-
-        if (!out.isEmpty()) {
-            out.remove(0);
-        }
-        return toArray(out);
-    }
-
-    /**
-     * Converts a string array to a space separated string
-     *
-     * @param args
-     * @return
-     */
-    public static String toMessage(String[] args) {
-        StringBuilder out = new StringBuilder();
-
-        for (String arg : args) {
-            out.append(arg).append(" ");
-        }
-
-        return out.toString().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-fk-or]", "");
-        out = out.replaceAll(String.valueOf((char) 194), "");
-        return out.replaceAll("[\u00a7][0-9a-fk-or]", "");
-    }
-
-    /*
-     * 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 "";
-    }
-
-    /**
-     * Cleans up the tag from color codes and makes it lowercase
-     *
-     * @param tag
-     * @return
-     */
-    public static String cleanTag(String tag) {
-        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());
-
-        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
-     *
-     * @param sep
-     * @return
-     */
-    public static String generatePageSeparator(String sep) {
-        String out = "";
-
-        for (int i = 0; i < 320; i++) {
-            out += sep;
-        }
-        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
-     *
-     * @param in
-     * @return
-     */
-    public static List<ClanPlayer> stripOffLinePlayers(List<ClanPlayer> in) {
-        List<ClanPlayer> out = new ArrayList<>();
-
-        for (ClanPlayer cp : in) {
-            if (cp.toPlayer() != null) {
-                out.add(cp);
-            }
-        }
-
-        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(@Nullable String str) {
-        if (str == null) {
-            return "";
-        }
-        return str.replace("'", "''");
-    }
-
-    /**
-     * Returns a prettier coordinate, does not include world
-     *
-     * @param loc
-     * @return
-     */
-    public static String toLocationString(Location loc) {
-        return loc.getBlockX() + " " + loc.getBlockY() + " " + loc.getBlockZ() + " " + loc.getWorld().getName();
-    }
-
-    /**
-     * Whether the two locations refer to the same block
-     *
-     * @param loc
-     * @param loc2
-     * @return
-     */
-    public static boolean isSameBlock(Location loc, Location loc2) {
-        return loc.getBlockX() == loc2.getBlockX() && loc.getBlockY() == loc2.getBlockY() && loc.getBlockZ() == loc2.getBlockZ();
-    }
-
-    /**
-     * 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();
-    }
-
-    /**
-     * Sorts a Map by value
-     *
-     * @param map the Map to sort
-     * @return the Map sorted
-     */
-    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());
-
-        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;
-    }
-
-    @SuppressWarnings("unchecked")
-	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<>();
-    }
-
-    @Deprecated
-    @Nullable
-    public static Player getPlayer(String playerName) {
-    	return Bukkit.getPlayerExact(playerName);
-    }
-
-    /**
-     * Formats the ally chat
-     * 
-     * @param cp Sender
-     * @param msg The message
-     * @param placeholders The placeholders
-     * @return The formated 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.getRankId().isEmpty() ? null : ChatColor.translateAlternateColorCodes('&', cp.getRankDisplayName());
-        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.getRankId().isEmpty() ? null : ChatColor.translateAlternateColorCodes('&', cp.getRankDisplayName());
-        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;
-        } else {
-            return ChatColor.DARK_GRAY + "[" + cp.getTag() + "] " + msg;
-        }
-    }
-}

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

@@ -1,42 +0,0 @@
-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");
-		
-		Type(String shortName) {
-			this.shortName = shortName;
-		}
-		
-		private final String shortName;
-		
-		public String getShortname() {
-			return shortName;
-		}
-	}
-}

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

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

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

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

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

@@ -1,105 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-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<String>();
-		setDisplayName(displayName);
-	}
-	
-	public Rank(String name, 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(String displayName) {
-		if (displayName == null || displayName.isEmpty()) {
-			displayName = name;
-		}
-		this.displayName = displayName;
-	}
-	
-	public void setPermissions(Set<String> permissions) {
-		if (permissions == null) {
-			permissions = new HashSet<String>();
-		}
-		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

@@ -1,89 +0,0 @@
-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),
-	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/SimpleClans.java

@@ -1,304 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import net.sacredlabyrinth.phaed.simpleclans.commands.SCCommandManager;
-import net.sacredlabyrinth.phaed.simpleclans.language.LanguageMigration;
-import net.sacredlabyrinth.phaed.simpleclans.language.LanguageResource;
-import net.sacredlabyrinth.phaed.simpleclans.listeners.SCEntityListener;
-import net.sacredlabyrinth.phaed.simpleclans.listeners.SCPlayerListener;
-import net.sacredlabyrinth.phaed.simpleclans.managers.*;
-import net.sacredlabyrinth.phaed.simpleclans.tasks.*;
-import net.sacredlabyrinth.phaed.simpleclans.ui.InventoryController;
-import net.sacredlabyrinth.phaed.simpleclans.utils.ChatFormatMigration;
-import net.sacredlabyrinth.phaed.simpleclans.utils.UpdateChecker;
-import net.sacredlabyrinth.phaed.simpleclans.uuid.UUIDMigration;
-import org.bstats.bukkit.Metrics;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-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;
-
-/**
- * @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("Minecraft");
-    private SCCommandManager commandManager;
-    private ClanManager clanManager;
-    private RequestManager requestManager;
-    private StorageManager storageManager;
-    private SettingsManager settingsManager;
-    private PermissionsManager permissionsManager;
-    private TeleportManager teleportManager;
-    private boolean hasUUID;
-
-    /**
-     * @return the logger
-     */
-    @Deprecated
-    public static Logger getLog() {
-        return logger;
-    }
-
-    public static void debug(String msg) {
-        if (getInstance().getSettingsManager().isDebugging()) {
-            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();
-        languageResource = new LanguageResource();
-        this.hasUUID = UUIDMigration.canReturnUUID();
-
-        permissionsManager = new PermissionsManager();
-        requestManager = new RequestManager();
-        clanManager = new ClanManager();
-        storageManager = new StorageManager();
-        teleportManager = new TeleportManager();
-        migrateChatFormat();
-        registerEvents();
-        permissionsManager.loadPermissions();
-        commandManager = new SCCommandManager(this);
-
-        logStatus();
-        startTasks();
-        startMetrics();
-        hookIntoPAPI();
-        new UpdateChecker(this).check();
-    }
-
-    private void logStatus() {
-        getLogger().info("Multithreading: " + SimpleClans.getInstance().getSettingsManager().getUseThreads());
-        getLogger().info("BungeeCord: " + SimpleClans.getInstance().getSettingsManager().getUseBungeeCord());
-        getLogger().info("Help us translate SimpleClans to your language! " +
-                "Access https://crowdin.com/project/simpleclans/");
-    }
-
-    private void registerEvents() {
-        getServer().getPluginManager().registerEvents(new SCEntityListener(), this);
-        getServer().getPluginManager().registerEvents(new SCPlayerListener(), this);
-        getServer().getPluginManager().registerEvents(new InventoryController(), this);
-    }
-
-    private void migrateChatFormat() {
-        ChatFormatMigration chatFormatMigration = new ChatFormatMigration();
-        chatFormatMigration.migrateAllyChat();
-        chatFormatMigration.migrateClanChat();
-    }
-
-    private void hookIntoPAPI() {
-        if (getServer().getPluginManager().getPlugin("PlaceholderAPI") != null) {
-            getLogger().info("PlaceholderAPI found. Registering hook...");
-            new PlaceholdersManager(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 Metrics.SingleLineChart("clans", () -> cm.getClans().size()));
-    	metrics.addCustomChart(new Metrics.SingleLineChart("clan_players", () -> cm.getAllClanPlayers().size()));
-    	metrics.addCustomChart(new Metrics.SimplePie("language", () -> sm.getLanguage().toString()));
-    	metrics.addCustomChart(new Metrics.SimplePie("machine_language", () -> Locale.getDefault().toString()));
-    	metrics.addCustomChart(new Metrics.SimplePie("language_chooser", () -> sm.isLanguagePerPlayer() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("database", () -> sm.isUseMysql() ? "MySQL" : "SQLite"));
-    	metrics.addCustomChart(new Metrics.SimplePie("save_periodically", () -> sm.isSavePeriodically() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("save_interval", () -> String.valueOf(sm.getSaveInterval())));
-    	metrics.addCustomChart(new Metrics.SimplePie("upkeep", () -> sm.isClanUpkeep() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("member_fee", () -> sm.isMemberFee() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("rejoin_cooldown", () -> sm.isRejoinCooldown() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("clan_verification", () -> sm.isRequireVerification() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("money_per_kill", () -> sm.isMoneyPerKill() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("threads", () -> sm.getUseThreads() ? on : off));
-    	metrics.addCustomChart(new Metrics.SimplePie("bungeecord", () -> sm.getUseBungeeCord() ? on : off));
-    }
-
-    private void startTasks() {
-    	if (getSettingsManager().isSavePeriodically()) {
-    		new SaveDataTask().start();
-    	}
-        if (getSettingsManager().isMemberFee()) {
-            new CollectFeeTask().start();
-        }
-        if (getSettingsManager().isClanUpkeep()) {
-            new CollectUpkeepTask().start();
-            new UpkeepWarningTask().start();
-        }
-        if (getSettingsManager().isCachePlayerHeads()) {
-            new PlayerHeadCacheTask(this).start();
-        }
-    }
-
-    @Override
-    public void onDisable() {
-        getServer().getScheduler().cancelTasks(this);
-    	if (getSettingsManager().isSavePeriodically()) {
-    		getStorageManager().saveModified();
-    	}
-        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
-     */
-    @NotNull
-    public PermissionsManager getPermissionsManager() {
-        return permissionsManager;
-    }
-
-    public SCCommandManager getCommandManager() {
-        return commandManager;
-    }
-
-    /**
-     * @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 Player player, Object... arguments) {
-        Locale locale = getInstance().getSettingsManager().getLanguage();
-        if (player != null && instance.getSettingsManager().isLanguagePerPlayer()) {
-            Locale playerLocale = Helper.getLocale(player);
-            if (playerLocale != null) {
-                locale = playerLocale;
-            }
-        }
-
-        String lang = languageResource.getLang(key, locale);
-        if (lang == null) {
-            return null;
-        }
-        String message = ChatColor.translateAlternateColorCodes('&', lang);
-        // contains acf placeholders like {commandprefix}
-        if (Pattern.compile("\\{(?<key>[a-zA-Z]+?)}").matcher(message).find()) {
-            return message;
-        }
-        return MessageFormat.format(message, arguments);
-    }
-
-    @NotNull
-    public static String lang(@NotNull String key, @Nullable Player player, Object... arguments) {
-        String lang = optionalLang(key, player, arguments);
-        if (lang == null) {
-            return key;
-        }
-        return 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;
-    }
-
-    public void setUUID(boolean trueOrFalse) {
-        this.hasUUID = trueOrFalse;
-    }
-}

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

@@ -1,86 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans;
-
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-import java.util.UUID;
-
-public class TeleportState {
-    private UUID playerUniqueId;
-    private Location playerLocation;
-    private Location destination;
-    private int counter;
-    private String clanName;
-    private boolean processing;
-
-    public TeleportState(Player player, Location dest, String clanName) {
-        this.destination = dest;
-        this.playerLocation = player.getLocation();
-        this.clanName = clanName;
-        this.counter = SimpleClans.getInstance().getSettingsManager().getWaitSecs();
-        this.playerUniqueId = player.getUniqueId();
-    }
-
-    /**
-     * @return
-     */
-    public Location getLocation() {
-        return this.playerLocation;
-    }
-
-    /**
-     * Whether its time for teleport
-     *
-     * @return
-     */
-    public boolean isTeleportTime() {
-        if (this.counter > 1) {
-            this.counter--;
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     * The player that is waiting for teleport
-     *
-     * @return
-     */
-    public Player getPlayer() {
-    	return SimpleClans.getInstance().getServer().getPlayer(this.playerUniqueId);
-    }
-
-    /**
-     * Get seconds left before teleport
-     *
-     * @return
-     */
-    public int getCounter() {
-        return this.counter;
-    }
-
-    public void setCounter(int counter) {
-        this.counter = counter;
-    }
-
-    public String getClanName() {
-        return this.clanName;
-    }
-
-    public Location getDestination() {
-        return this.destination;
-    }
-
-    public boolean isProcessing() {
-        return this.processing;
-    }
-
-    public void setProcessing(boolean processing) {
-        this.processing = processing;
-    }
-
-    public UUID getUniqueId() {
-        return this.playerUniqueId;
-    }
-}

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

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

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

@@ -1,32 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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/SCCommandManager.java

@@ -1,210 +0,0 @@
-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.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 org.reflections.Reflections;
-
-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;
-
-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() {
-        registerDependencies();
-        enableUnstableAPI("help");
-        addCommandReplacements();
-        registerContexts();
-        registerCommands();
-        registerConditions();
-        registerCompletions();
-    }
-
-    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());
-    }
-
-    private void registerCompletions() {
-        Reflections reflections = new Reflections("net.sacredlabyrinth.phaed.simpleclans.commands.completions");
-        Set<Class<? extends AbstractCompletion>> completions = reflections.getSubTypesOf(AbstractCompletion.class);
-        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() {
-        Reflections reflections = new Reflections("net.sacredlabyrinth.phaed.simpleclans.commands.conditions");
-        Set<Class<? extends AbstractCondition>> conditions = reflections.getSubTypesOf(AbstractCondition.class);
-        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() {
-        Reflections reflections = new Reflections("net.sacredlabyrinth.phaed.simpleclans.commands.contexts");
-        Set<Class<? extends AbstractContextResolver>> resolvers = reflections.getSubTypesOf(AbstractContextResolver.class);
-        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().isForceCommandPriority();
-        Reflections reflections = new Reflections("net.sacredlabyrinth.phaed.simpleclans.commands");
-        Set<Class<? extends BaseCommand>> commands = reflections.getSubTypesOf(BaseCommand.class);
-        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.getCommandClan(),
-                "deny", sm.getCommandDeny(),
-                "more", sm.getCommandMore(),
-                "ally", sm.getCommandAlly(),
-                "accept", sm.getCommandAccept(),
-                "clan_chat", sm.getCommandClanChat()
-        );
-
-        SUBCOMMANDS.forEach(s ->
-                getCommandReplacements().addReplacement(s, (lang(s + ".command") + "|" + s)));
-    }
-    
-    @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", "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");
-    }
-}

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

@@ -1,29 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
-
-import co.aikar.commands.BaseCommand;
-import co.aikar.commands.annotation.*;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-import org.bukkit.entity.Player;
-
-@CommandAlias("%ally")
-@Description("{@@command.description.ally}")
-@CommandPermission("simpleclans.member.ally")
-@Conditions("%basic_conditions|clan_member|rank:name=ALLY_CHAT")
-public class AllyChatCommand extends BaseCommand {
-
-    @Dependency
-    private ClanManager clanManager;
-    @Dependency
-    private SettingsManager settingsManager;
-
-    @Default
-    @HelpSearchTags("chat")
-    public void sendMessage(Player player, @Name("message") String message) {
-        if (!settingsManager.isAllyChatEnable()) {
-            return;
-        }
-        clanManager.processAllyChat(player, message);
-    }
-
-}

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

@@ -1,86 +0,0 @@
-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.PermissionsManager;
-import org.bukkit.entity.Player;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-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;
-        }
-        if (amount < 0) {
-            amount = amount * -1;
-        }
-        clan.withdraw(amount, 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;
-        }
-        if (amount < 0) {
-            amount = amount * -1;
-        }
-        clan.deposit(amount, player);
-    }
-}

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

@@ -1,52 +0,0 @@
-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.StorageManager;
-import org.bukkit.entity.Player;
-
-import java.util.Objects;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-@CommandAlias("%clan")
-@Conditions("%basic_conditions|verified")
-public class BbCommand extends BaseCommand {
-
-    @Dependency
-    private ClanManager cm;
-    @Dependency
-    private StorageManager storage;
-
-    @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")
-    @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(player.getName(), AQUA + player.getName() + ": " + WHITE + msg);
-        storage.updateClan(clan);
-    }
-}

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

@@ -1,29 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.clan;
-
-import co.aikar.commands.BaseCommand;
-import co.aikar.commands.annotation.*;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-import org.bukkit.entity.Player;
-
-@CommandAlias("%clan_chat")
-@Conditions("%basic_conditions")
-@CommandPermission("simpleclans.member.chat")
-@Description("{@@command.description.chat}")
-public class ChatCommand extends BaseCommand {
-
-    @Dependency
-    private ClanManager clanManager;
-    @Dependency
-    private SettingsManager settingsManager;
-
-    @Default
-    @HelpSearchTags("chat")
-    public void sendMessage(Player player, ClanPlayer cp, @Name("message") String message) {
-        if (!settingsManager.getClanChatEnable()) {
-            return;
-        }
-        clanManager.processClanChat(player, cp.getTag(), message);
-    }
-}

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

@@ -1,366 +0,0 @@
-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.events.TagChangeEvent;
-import net.sacredlabyrinth.phaed.simpleclans.managers.*;
-import net.sacredlabyrinth.phaed.simpleclans.utils.TagValidator;
-import org.bukkit.conversations.ConversationFactory;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.List;
-import java.util.Objects;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-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;
-
-    @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 cp, Clan issuerClan, @Name("clan") ClanInput other) {
-        Clan war = other.getClan();
-        if (!issuerClan.isRival(war.getTag())) {
-            ChatBlock.sendMessage(player, RED + lang("you.can.only.start.war.with.rivals", player));
-            return;
-        }
-        if (!issuerClan.isWarring(war.getTag())) {
-            List<ClanPlayer> onlineLeaders = Helper.stripOffLinePlayers(issuerClan.getLeaders());
-
-            if (!onlineLeaders.isEmpty()) {
-                requestManager.addWarStartRequest(cp, war, issuerClan);
-                ChatBlock.sendMessage(player, AQUA + lang("leaders.have.been.asked.to.accept.the.war.request",
-                        player, war.getName()));
-            } else {
-                ChatBlock.sendMessage(player, RED + lang("at.least.one.leader.accept.the.alliance", player));
-            }
-        } else {
-            ChatBlock.sendMessage(player, RED + lang("clans.already.at.war", player));
-        }
-    }
-
-    @Subcommand("%war %end")
-    @CommandPermission("simpleclans.leader.war")
-    @Conditions("verified|rank:name=WAR_END")
-    @Description("{@@command.description.war.end}")
-    @CommandCompletion("@warring_clans")
-    public void endWar(Player player, ClanPlayer cp, Clan issuerClan, @Name("clan") ClanInput other) {
-        Clan war = other.getClan();
-        if (issuerClan.isWarring(war.getTag())) {
-            requestManager.addWarEndRequest(cp, war, issuerClan);
-            ChatBlock.sendMessage(player, AQUA + lang("leaders.asked.to.end.rivalry", player, war.getName()));
-        } else {
-            ChatBlock.sendMessage(player, RED + lang("clans.not.at.war", player));
-        }
-    }
-
-    @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);
-
-        TagValidator validator = new TagValidator(plugin, player, tag);
-        if (validator.getErrorMessage() != null) {
-            ChatBlock.sendMessage(player, validator.getErrorMessage());
-            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(), AQUA + lang("tag.changed.to.0", Helper.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")
-    @Conditions("rank:name=INVITE")
-    @Description("{@@command.description.invite}")
-    public void invite(Player sender, ClanPlayer cp, Clan clan,
-                       @Conditions("not_banned|not_in_clan|online") @Name("player") ClanPlayerInput invited) {
-        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.getMaxMembers()) {
-            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")
-    @Description("{@@command.description.fee.set}")
-    public void setFee(Player player, Clan clan, @Name("fee") double fee) {
-        double maxFee = settings.getMaxMemberFee();
-        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(), AQUA + 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(), AQUA + 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(), AQUA + 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.getClanMinDescriptionLength()) {
-            ChatBlock.sendMessage(player, RED + lang("your.clan.description.must.be.longer.than",
-                    player, settings.getClanMinDescriptionLength()));
-            return;
-        }
-        if (description.length() > settings.getClanMaxDescriptionLength()) {
-            ChatBlock.sendMessage(player, RED + lang("your.clan.description.cannot.be.longer.than",
-                    player, settings.getClanMaxDescriptionLength()));
-            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")
-    @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(), AQUA + lang("has.initiated.a.rivalry", issuerClan.getName(),
-                        rivalInput.getName()), false);
-                issuerClan.addBb(player.getName(), AQUA + 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")
-    @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.getClanMaxAlliances();
-        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(), AQUA + lang("has.broken.the.alliance", issuerClan.getName(),
-                allyInput.getName()), false);
-        issuerClan.addBb(player.getName(), AQUA + lang("has.broken.the.alliance", player.getName(),
-                allyInput.getName()));
-    }
-
-    @Subcommand("%kick")
-    @CommandPermission("simpleclans.leader.kick")
-    @CommandCompletion("@clan_members")
-    @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(), AQUA + lang("has.been.kicked.by", clanPlayer.getName(),
-                sender.getName(), sender));
-        clan.removePlayerFromClan(clanPlayer.getUniqueId());
-    }
-
-    @Subcommand("%resign")
-    @CommandPermission("simpleclans.member.resign")
-    @Description("{@@command.description.resign}")
-    public void resign(@Conditions("clan_member") Player player) {
-        new ConversationFactory(plugin)
-                .withFirstPrompt(new ResignPrompt())
-                .withLocalEcho(true)
-                .withTimeout(10)
-                .buildConversation(player).begin();
-    }
-}

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

@@ -1,68 +0,0 @@
-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.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.data.*;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@CommandAlias("%clan")
-@Conditions("%basic_conditions|verified")
-public class DataCommands extends BaseCommand {
-    @Dependency
-    private SimpleClans plugin;
-
-    @Subcommand("%vitals")
-    @CommandPermission("simpleclans.member.vitals")
-    @Conditions("rank:name=VITALS")
-    @Description("{@@command.description.vitals}")
-    public void vitals(CommandSender sender, Clan clan) {
-        Vitals vitals = new Vitals(plugin, sender, clan);
-        vitals.send();
-    }
-
-    @Subcommand("%stats")
-    @CommandPermission("simpleclans.member.stats")
-    @Conditions("rank:name=STATS")
-    @Description("{@@command.description.stats}")
-    public void stats(Player player, Clan clan) {
-        ClanStats stats = new ClanStats(plugin, player, clan);
-        stats.send();
-    }
-
-    @Subcommand("%profile")
-    @CommandPermission("simpleclans.member.profile")
-    @Description("{@@command.description.profile}")
-    public void profile(CommandSender sender, Clan clan) {
-        ClanProfile p = new ClanProfile(plugin, sender, clan);
-        p.send();
-    }
-
-    @Subcommand("%roster")
-    @CommandPermission("simpleclans.member.roster")
-    @Description("{@@command.description.roster}")
-    public void roster(Player player, Clan clan) {
-        ClanRoster r = new ClanRoster(plugin, player, clan);
-        r.send();
-    }
-
-    @Subcommand("%coords")
-    @CommandPermission("simpleclans.member.coords")
-    @Conditions("rank:name=COORDS")
-    @HelpSearchTags("local location")
-    @Description("{@@command.description.coords}")
-    public void coords(Player player, Clan clan) {
-        if (clan.getOnlineMembers().size() == 1) {
-            ChatBlock.sendMessage(player, RED + lang("you.are.the.only.member.online", player));
-            return;
-        }
-        ClanCoords c = new ClanCoords(plugin, player, clan);
-        c.send();
-    }
-}

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

@@ -1,122 +0,0 @@
-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.events.HomeRegroupEvent;
-import net.sacredlabyrinth.phaed.simpleclans.events.PlayerHomeSetEvent;
-import net.sacredlabyrinth.phaed.simpleclans.managers.*;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-@CommandAlias("%clan")
-@Conditions("%basic_conditions|verified")
-public class HomeCommands extends BaseCommand {
-    @Dependency
-    private SimpleClans plugin;
-    @Dependency
-    private PermissionsManager permissions;
-    @Dependency
-    private SettingsManager settings;
-    @Dependency
-    private ClanManager cm;
-
-    @Subcommand("%regroup %me")
-    @CommandPermission("simpleclans.leader.regroup.me")
-    @Conditions("rank:name=REGROUP_ME")
-    @Description("{@@command.description.regroup.me}")
-    public void regroupMe(Player player, ClanPlayer cp, Clan clan) {
-        if (!settings.getAllowReGroupCommand()) {
-            ChatBlock.sendMessage(player, RED + lang("insufficient.permissions", player));
-            return;
-        }
-
-        processTeleport(player, cp, clan, player.getLocation());
-    }
-
-    private void processTeleport(Player player, ClanPlayer cp, Clan clan, Location location) {
-        HomeRegroupEvent homeRegroupEvent = new HomeRegroupEvent(clan, cp, clan.getOnlineMembers(), location);
-        plugin.getServer().getPluginManager().callEvent(homeRegroupEvent);
-
-        if (homeRegroupEvent.isCancelled() || !cm.purchaseHomeRegroup(player)) {
-            return;
-        }
-
-        plugin.getTeleportManager().teleport(clan, location);
-    }
-
-    @Subcommand("%regroup %home")
-    @CommandPermission("simpleclans.leader.regroup.home")
-    @Conditions("rank:name=REGROUP_HOME")
-    @Description("{@@command.description.regroup.home}")
-    public void regroupHome(Player player, ClanPlayer cp, Clan clan) {
-        if (!settings.getAllowReGroupCommand()) {
-            ChatBlock.sendMessage(player, RED + lang("insufficient.permissions", player));
-            return;
-        }
-        Location location = clan.getHomeLocation();
-        if (location == null) {
-            ChatBlock.sendMessage(player, RED + lang("hombase.not.set", player));
-            return;
-        }
-
-        processTeleport(player, cp, clan, location);
-    }
-
-    @Subcommand("%home")
-    @CommandPermission("simpleclans.member.home")
-    @Conditions("rank:name=HOME_TP")
-    @Description("{@@command.description.home.tp}")
-    public void teleport(Player player, Clan clan, ClanPlayer cp) {
-        Location loc = clan.getHomeLocation();
-
-        if (loc == null) {
-            ChatBlock.sendMessage(player, RED + lang("hombase.not.set", player));
-            return;
-        }
-
-        if (cm.purchaseHomeTeleport(player)) {
-            plugin.getTeleportManager().addPlayer(player, clan.getHomeLocation(), clan.getName());
-        }
-    }
-
-    @Subcommand("%home %clear")
-    @CommandPermission("simpleclans.leader.home-set")
-    @Conditions("rank:name=HOME_SET")
-    @Description("{@@command.description.home.clear}")
-    public void clear(Player player, Clan clan) {
-        if (settings.isHomebaseSetOnce() && clan.getHomeLocation() != null &&
-                !permissions.has(player, "simpleclans.mod.home")) {
-            ChatBlock.sendMessage(player, RED + lang("home.base.only.once", player));
-            return;
-        }
-
-        clan.setHomeLocation(null);
-        ChatBlock.sendMessage(player, AQUA + lang("hombase.cleared", player));
-    }
-
-    @Subcommand("%home %set")
-    @Conditions("rank:name=HOME_SET")
-    @CommandPermission("simpleclans.leader.home-set")
-    @Description("{@@command.description.home.set}")
-    public void set(Player player, ClanPlayer cp, Clan clan) {
-        if (settings.isHomebaseSetOnce() && clan.getHomeLocation() != null &&
-                !permissions.has(player, "simpleclans.mod.home")) {
-            ChatBlock.sendMessage(player, RED + lang("home.base.only.once", player));
-            return;
-        }
-        PlayerHomeSetEvent homeSetEvent = new PlayerHomeSetEvent(clan, cp, player.getLocation());
-        plugin.getServer().getPluginManager().callEvent(homeSetEvent);
-
-        if (homeSetEvent.isCancelled() || !cm.purchaseHomeTeleportSet(player)) {
-            return;
-        }
-
-        clan.setHomeLocation(player.getLocation());
-        ChatBlock.sendMessage(player, AQUA + lang("hombase.set", player, YELLOW +
-                Helper.toLocationString(player.getLocation())));
-    }
-}

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

@@ -1,181 +0,0 @@
-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.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import net.sacredlabyrinth.phaed.simpleclans.managers.*;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-
-import java.util.Objects;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.AQUA;
-import static org.bukkit.ChatColor.RED;
-
-@CommandAlias("%clan")
-@Conditions("%basic_conditions|leader")
-public class LeaderCommands extends BaseCommand {
-
-    @Dependency
-    private StorageManager storage;
-    @Dependency
-    private PermissionsManager permissions;
-    @Dependency
-    private SettingsManager settings;
-    @Dependency
-    private RequestManager requestManager;
-    @Dependency
-    private ClanManager cm;
-
-    @Subcommand("%demote")
-    @CommandCompletion("@clan_leaders")
-    @CommandPermission("simpleclans.leader.demote")
-    @Description("{@@command.description.demote}")
-    public void demote(Player player,
-                       ClanPlayer cp,
-                       Clan clan,
-                       @Conditions("same_clan") @Name("leader") ClanPlayerInput other) {
-        ClanPlayer otherCp = other.getClanPlayer();
-        if (!clan.enoughLeadersOnlineToDemote(otherCp)) {
-            ChatBlock.sendMessage(player, RED + lang("not.enough.leaders.online.to.vote.on.demotion", player));
-            return;
-        }
-        if (!clan.isLeader(otherCp.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("player.is.not.a.leader.of.your.clan", player));
-            return;
-        }
-        if (clan.getLeaders().size() > 2 && settings.isConfirmationForDemote()) {
-            requestManager.addDemoteRequest(cp, otherCp.getName(), clan);
-            ChatBlock.sendMessage(player, AQUA + lang("demotion.vote.has.been.requested.from.all.leaders",
-                    player));
-            return;
-        }
-        clan.addBb(player.getName(), AQUA + lang("demoted.back.to.member", otherCp.getName()));
-        clan.demote(otherCp.getUniqueId());
-    }
-
-    @Subcommand("%promote")
-    @CommandPermission("simpleclans.leader.promote")
-    @CommandCompletion("@clan_non_leaders")
-    @Description("{@@command.description.promote}")
-    public void promote(Player player,
-                        Clan clan,
-                        ClanPlayer cp,
-                        @Conditions("online|same_clan") @Name("member") ClanPlayerInput other) {
-        Player otherPl = Objects.requireNonNull(other.getClanPlayer().toPlayer());
-        if (!permissions.has(otherPl, "simpleclans.leader.promotable")) {
-            ChatBlock.sendMessage(player, RED + lang("the.player.does.not.have.the.permissions.to.lead.a.clan",
-                    player));
-            return;
-        }
-        if (otherPl.getUniqueId().equals(player.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("you.cannot.promote.yourself", player));
-            return;
-        }
-        if (clan.isLeader(otherPl.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("the.player.is.already.a.leader", player));
-            return;
-        }
-        if (settings.isConfirmationForPromote() && clan.getLeaders().size() > 1) {
-            requestManager.addPromoteRequest(cp, otherPl.getName(), clan);
-            ChatBlock.sendMessage(player, AQUA + lang("promotion.vote.has.been.requested.from.all.leaders",
-                    player));
-            return;
-        }
-
-        clan.addBb(player.getName(), AQUA + lang("promoted.to.leader", otherPl.getName()));
-        clan.promote(otherPl.getUniqueId());
-    }
-
-    @Subcommand("%disband")
-    @CommandPermission("simpleclans.leader.disband")
-    @Description("{@@command.description.disband}")
-    public void disband(Player player, ClanPlayer cp, Clan clan) {
-        if (clan.getLeaders().size() != 1) {
-            requestManager.addDisbandRequest(cp, clan);
-            ChatBlock.sendMessage(player, AQUA +
-                    lang("clan.disband.vote.has.been.requested.from.all.leaders", player));
-            return;
-        }
-
-        clan.clanAnnounce(player.getName(), AQUA + lang("clan.has.been.disbanded", clan.getName()));
-        clan.disband();
-    }
-
-    @Subcommand("%verify")
-    @CommandPermission("simpleclans.leader.verify")
-    @Description("{@@command.description.verify}")
-    public void verify(Player player, Clan clan) {
-        if (clan.isVerified()) {
-            ChatBlock.sendMessageKey(player, "your.clan.already.verified");
-            return;
-        }
-        if (!settings.isePurchaseVerification()) {
-            ChatBlock.sendMessageKey(player, "staff.member.verify.clan");
-            return;
-        }
-        int minToVerify = settings.getMinToVerify();
-        if (minToVerify > clan.getAllMembers().size()) {
-            ChatBlock.sendMessage(player, lang("your.clan.must.have.members.to.verify", player, minToVerify));
-            return;
-        }
-        if (cm.purchaseVerification(player)) {
-            clan.verifyClan();
-            clan.addBb(player.getName(), AQUA + lang("clan.0.has.been.verified", clan.getName()));
-            ChatBlock.sendMessage(player, AQUA + lang("the.clan.has.been.verified", player));
-        }
-    }
-
-    @Subcommand("%trust")
-    @CommandPermission("simpleclans.leader.settrust")
-    @CommandCompletion("@clan_members")
-    @Description("{@@command.description.trust}")
-    public void trust(Player player, Clan clan, @Conditions("same_clan") @Name("member") ClanPlayerInput trusted) {
-        ClanPlayer trustedInput = trusted.getClanPlayer();
-        if (player.getUniqueId().equals(trustedInput.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("you.cannot.trust.yourself", player));
-            return;
-        }
-        if (clan.isLeader(trustedInput.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("leaders.are.already.trusted", player));
-            return;
-        }
-        if (trustedInput.isTrusted()) {
-            ChatBlock.sendMessage(player, ChatColor.RED + lang("this.player.is.already.trusted", player));
-            return;
-        }
-        clan.addBb(player.getName(), AQUA + lang("has.been.given.trusted.status.by", trustedInput.getName(),
-                player.getName()));
-        trustedInput.setTrusted(true);
-        storage.updateClanPlayer(trustedInput);
-    }
-
-    @Subcommand("%untrust")
-    @CommandPermission("simpleclans.leader.settrust")
-    @CommandCompletion("@clan_members")
-    @Description("{@@command.description.untrust}")
-    public void untrust(Player player, Clan clan, @Conditions("same_clan") @Name("member") ClanPlayerInput trusted) {
-        ClanPlayer trustedInput = trusted.getClanPlayer();
-        if (trustedInput.getUniqueId().equals(player.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("you.cannot.untrust.yourself", player));
-            return;
-        }
-        if (clan.isLeader(trustedInput.getUniqueId())) {
-            ChatBlock.sendMessage(player, RED + lang("leaders.cannot.be.untrusted", player));
-            return;
-        }
-        if (!trustedInput.isTrusted()) {
-            ChatBlock.sendMessage(player, RED + lang("this.player.is.already.untrusted", player));
-            return;
-        }
-
-        clan.addBb(player.getName(), AQUA + lang("has.been.given.untrusted.status.by", trustedInput.getName(),
-                player.getName()));
-        trustedInput.setTrusted(false);
-        storage.updateClanPlayer(trustedInput);
-    }
-}

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

@@ -1,176 +0,0 @@
-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.ClanPlayerInput;
-import net.sacredlabyrinth.phaed.simpleclans.conversation.CreateRankNamePrompt;
-import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
-import org.bukkit.ChatColor;
-import org.bukkit.conversations.Conversation;
-import org.bukkit.conversations.ConversationFactory;
-import org.bukkit.entity.Player;
-
-import java.util.Comparator;
-import java.util.List;
-import java.util.Set;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.AQUA;
-import static org.bukkit.ChatColor.RED;
-
-@CommandAlias("%clan")
-@Subcommand("%rank")
-@Conditions("%basic_conditions|verified|leader")
-public class RankCommand extends BaseCommand {
-
-    @Dependency
-    private SimpleClans plugin;
-    @Dependency
-    private StorageManager storage;
-    @Dependency
-    private PermissionsManager permissions;
-
-    @Subcommand("%assign")
-    @CommandPermission("simpleclans.leader.rank.assign")
-    @CommandCompletion("@clan_members @ranks")
-    @Description("{@@command.description.rank.assign}")
-    public void assign(Player player,
-                       Clan clan,
-                       @Name("member") @Conditions("same_clan") ClanPlayerInput member,
-                       @Name("rank") Rank rank) {
-        ClanPlayer memberInput = member.getClanPlayer();
-        if (memberInput.getRankId().equals(rank.getName())) {
-            ChatBlock.sendMessage(player, lang("player.already.has.that.rank", player));
-            return;
-        }
-
-        memberInput.setRank(rank.getName());
-        storage.updateClanPlayer(memberInput);
-        ChatBlock.sendMessage(player, AQUA + lang("player.rank.changed", player));
-    }
-
-    @Subcommand("%unassign")
-    @CommandPermission("simpleclans.leader.rank.unassign")
-    @CommandCompletion("@clan_members")
-    @Description("{@@command.description.rank.unassign}")
-    public void unassign(Player player, @Conditions("same_clan") @Name("member") ClanPlayerInput cp) {
-        ClanPlayer cpInput = cp.getClanPlayer();
-        cpInput.setRank(null);
-        storage.updateClanPlayer(cpInput);
-        ChatBlock.sendMessage(player, AQUA + lang("player.unassigned.from.rank", player));
-    }
-
-    @Subcommand("%create")
-    @CommandPermission("simpleclans.leader.rank.create")
-    @Description("{@@command.description.rank.create}")
-    public void create(Player player, Clan clan) {
-        Conversation conversation = new ConversationFactory(plugin).withFirstPrompt(new CreateRankNamePrompt())
-                .withLocalEcho(true).buildConversation(player);
-        conversation.getContext().setSessionData("clan", clan);
-        conversation.begin();
-    }
-
-    @Subcommand("%delete")
-    @CommandPermission("simpleclans.leader.rank.delete")
-    @CommandCompletion("@ranks")
-    @Description("{@@command.description.rank.delete}")
-    public void delete(Player player, Clan clan, @Name("rank") Rank rank) {
-        clan.deleteRank(rank.getName());
-        storage.updateClan(clan, true);
-        ChatBlock.sendMessage(player, AQUA + lang("rank.0.deleted", player, rank.getDisplayName()));
-    }
-
-    @Subcommand("%list")
-    @CommandPermission("simpleclans.leader.rank.list")
-    @Description("{@@command.description.rank.list}")
-    public void list(Player player, Clan clan) {
-        List<Rank> ranks = clan.getRanks();
-
-        if (ranks.isEmpty()) {
-            ChatBlock.sendMessage(player, RED + lang("no.ranks", player));
-            return;
-        }
-
-        ranks.sort(Comparator.reverseOrder());
-        ChatBlock.sendMessage(player, AQUA + lang("clans.ranks", player));
-        int count = 1;
-        for (Rank rank : ranks) {
-            ChatBlock.sendMessage(player, AQUA + lang("ranks.list.item", player, count,
-                    Helper.parseColors(rank.getDisplayName()) + AQUA, rank.getName()));
-            count++;
-        }
-    }
-
-    @Subcommand("%setdisplayname")
-    @CommandPermission("simpleclans.leader.rank.setdisplayname")
-    @CommandCompletion("@ranks @nothing")
-    @Description("{@@command.description.rank.setdisplayname}")
-    public void setDisplayName(Player player, Clan clan, @Name("rank") Rank rank, @Name("displayname") String displayName) {
-        if (displayName.contains("&") && !permissions.has(player, "simpleclans.leader.coloredrank")) {
-            ChatBlock.sendMessage(player, RED + lang("you.cannot.set.colored.ranks", player));
-            return;
-        }
-        rank.setDisplayName(displayName);
-        storage.updateClan(clan, true);
-        ChatBlock.sendMessage(player, ChatColor.AQUA + lang("rank.displayname.updated", player));
-    }
-
-    @Subcommand("%permissions")
-    public class PermissionsCommand extends BaseCommand {
-        private final String validPermissionsToMessage = Helper.toMessage(Helper.fromPermissionArray(), ",");
-
-        @Default
-        @CommandPermission("simpleclans.leader.rank.permissions.available")
-        @Description("{@@command.description.rank.permissions.available}")
-        public void availablePermissions(Player player) {
-            ChatBlock.sendMessage(player, AQUA + lang("available.rank.permissions", player));
-            ChatBlock.sendMessage(player, AQUA + validPermissionsToMessage);
-        }
-
-        @Default
-        @CommandPermission("simpleclans.leader.rank.permissions.list")
-        @CommandCompletion("@ranks")
-        @Description("{@@command.description.rank.permissions.rank}")
-        public void list(Player player, @Name("rank") Rank rank) {
-            Set<String> permissions = rank.getPermissions();
-            if (permissions.isEmpty()) {
-                ChatBlock.sendMessage(player, RED + lang("rank.no.permissions", player));
-                return;
-            }
-            ChatBlock.sendMessage(player, AQUA + lang("rank.0.permissions", player, rank.getDisplayName()));
-            ChatBlock.sendMessage(player, AQUA + Helper.toMessage(permissions.toArray(new String[0]), ","));
-        }
-
-        @Subcommand("%add")
-        @CommandPermission("simpleclans.leader.rank.permissions.add")
-        @CommandCompletion("@ranks @rank_permissions")
-        @Description("{@@command.description.rank.permissions.add}")
-        public void add(Player player,
-                        Clan clan,
-                        @Name("rank") Rank rank,
-                        @Values("@rank_permissions") @Name("permission") String permission) {
-            Set<String> permissions = rank.getPermissions();
-            permissions.add(permission);
-            ChatBlock.sendMessage(player, AQUA + lang("permission.0.added.to.rank.1", player, permission,
-                    rank.getDisplayName()));
-            storage.updateClan(clan, true);
-        }
-
-        @Subcommand("%remove")
-        @CommandCompletion("@ranks @rank_permissions")
-        @CommandPermission("simpleclans.leader.rank.permissions.remove")
-        @Description("{@@command.description.rank.permissions.remove}")
-        public void remove(Player player,
-                           Clan clan,
-                           @Name("rank") Rank rank,
-                           @Values("@rank_permissions") @Name("permission") String permission) {
-            Set<String> permissions = rank.getPermissions();
-            permissions.remove(permission);
-            ChatBlock.sendMessage(player, AQUA + lang("permission.0.removed.from.rank.1", player,
-                    permission, rank.getDisplayName()));
-            storage.updateClan(clan, true);
-        }
-    }
-}

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

@@ -1,84 +0,0 @@
-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.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.managers.StorageManager;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-
-import java.util.function.Consumer;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.AQUA;
-
-@CommandAlias("%clan")
-@Subcommand("%toggle")
-@Conditions("%basic_conditions|verified")
-public class ToggleCommand extends BaseCommand {
-
-    @Dependency
-    private StorageManager storage;
-
-    @Subcommand("%bb")
-    @CommandPermission("simpleclans.member.bb-toggle")
-    @Description("{@@command.description.toggle.bb}")
-    public void bb(Player player, ClanPlayer cp) {
-        toggle(player, "bbon", "bboff", cp.isBbEnabled(), cp::setBbEnabled);
-
-        storage.updateClanPlayer(cp);
-    }
-
-    @Subcommand("%tag")
-    @CommandPermission("simpleclans.member.tag-toggle")
-    @Description("{@@command.description.toggle.tag}")
-    public void tag(Player player, ClanPlayer cp) {
-        toggle(player, "tagon", "tagoff", cp.isTagEnabled(), cp::setTagEnabled);
-
-        storage.updateClanPlayer(cp);
-    }
-
-    @Subcommand("%deposit")
-    @CommandPermission("simpleclans.leader.deposit-toggle")
-    @Conditions("leader")
-    @Description("{@@command.description.toggle.deposit}")
-    public void deposit(Player player, Clan clan) {
-        toggle(player, "depositon", "depositoff", clan.isAllowDeposit(),
-                clan::setAllowDeposit);
-
-        storage.updateClan(clan);
-    }
-
-    @Subcommand("%fee")
-    @CommandPermission("simpleclans.leader.fee")
-    @Conditions("rank:name=FEE_ENABLE")
-    @Description("{@@command.description.toggle.fee}")
-    public void fee(Player player, Clan clan) {
-        toggle(player, "feeon", "feeoff", clan.isMemberFeeEnabled(),
-                clan::setMemberFeeEnabled);
-
-        storage.updateClan(clan);
-    }
-
-    @Subcommand("%withdraw")
-    @CommandPermission("simpleclans.leader.withdraw-toggle")
-    @Conditions("leader")
-    @Description("{@@command.description.toggle.withdraw}")
-    public void withdraw(Player player, Clan clan) {
-        toggle(player, "withdrawon", "withdrawoff", clan.isAllowWithdraw(),
-                clan::setAllowWithdraw);
-
-        storage.updateClan(clan);
-    }
-
-    private void toggle(CommandSender sender, String onMessageKey, String offMessageKey, boolean status,
-                        Consumer<Boolean> consumer) {
-        String messageOn = AQUA + lang(onMessageKey, sender);
-        String messageOff = AQUA + lang(offMessageKey, sender);
-
-        ChatBlock.sendMessage(sender, status ? messageOff : messageOn);
-        consumer.accept(!status);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/AbstractCompletion.java

@@ -1,16 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import org.jetbrains.annotations.NotNull;
-
-public abstract class AbstractCompletion implements IdentifiableCompletion {
-
-    protected final SimpleClans plugin;
-    protected final ClanManager clanManager;
-
-    public AbstractCompletion(@NotNull SimpleClans plugin) {
-        this.plugin = plugin;
-        this.clanManager = plugin.getClanManager();
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/AllNonLeadersCompletion.java

@@ -1,29 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.stream.Collectors;
-
-@SuppressWarnings("unused")
-public class AllNonLeadersCompletion extends AbstractSyncCompletion {
-    public AllNonLeadersCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext context) throws InvalidCommandArgument {
-        return clanManager
-                .getAllClanPlayers().stream().filter(cp -> !cp.isLeader() && cp.getClan() != null)
-                .map(ClanPlayer::getName).collect(Collectors.toList());
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "all_non_leaders";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/ClanLeadersCompletion.java

@@ -1,36 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.stream.Collectors;
-
-public class ClanLeadersCompletion extends AbstractSyncCompletion {
-    public ClanLeadersCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext c) throws InvalidCommandArgument {
-        Player player = c.getPlayer();
-        if (player != null) {
-            Clan clan = clanManager.getClanByPlayerUniqueId(player.getUniqueId());
-            if (clan != null) {
-                return clan.getLeaders().stream().map(ClanPlayer::getName).collect(Collectors.toList());
-            }
-        }
-        return Collections.emptyList();
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_leaders";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/ClanMembersCompletion.java

@@ -1,36 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.stream.Collectors;
-
-public class ClanMembersCompletion extends AbstractSyncCompletion {
-    public ClanMembersCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext c) throws InvalidCommandArgument {
-        Player player = c.getPlayer();
-        if (player != null) {
-            Clan clan = clanManager.getClanByPlayerUniqueId(player.getUniqueId());
-            if (clan != null) {
-                return clan.getAllMembers().stream().map(ClanPlayer::getName).collect(Collectors.toList());
-            }
-        }
-        return Collections.emptyList();
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_members";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/ClanNonLeadersCompletion.java

@@ -1,36 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.stream.Collectors;
-
-@SuppressWarnings("unused")
-public class ClanNonLeadersCompletion extends AbstractSyncCompletion {
-    public ClanNonLeadersCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext c) throws InvalidCommandArgument {
-        Player player = c.getPlayer();
-        if (player != null) {
-            Clan clan = clanManager.getClanByPlayerUniqueId(player.getUniqueId());
-            if (clan != null) {
-                return clan.getNonLeaders().stream().map(ClanPlayer::getName).collect(Collectors.toList());
-            }
-        }
-        return Collections.emptyList();    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_non_leaders";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/ClansCompletion.java

@@ -1,34 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class ClansCompletion extends AbstractSyncCompletion {
-    public ClansCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext c) throws InvalidCommandArgument {
-        Stream<Clan> clans = clanManager.getClans().stream();
-        if (c.hasConfig("has_home")) {
-            clans = clans.filter(clan -> clan.getHomeLocation() != null);
-        }
-        if (c.hasConfig("unverified")) {
-            clans = clans.filter(clan -> !clan.isVerified());
-        }
-        return clans.map(Clan::getTag).collect(Collectors.toList());
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clans";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/NonMembersCompletion.java

@@ -1,32 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.stream.Collectors;
-
-@SuppressWarnings("unused")
-public class NonMembersCompletion extends AbstractSyncCompletion {
-    public NonMembersCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "non_members";
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext c) throws InvalidCommandArgument {
-        Player player = c.getPlayer();
-        return Bukkit.getOnlinePlayers().stream()
-                .filter(p -> clanManager.getClanByPlayerUniqueId(p.getUniqueId()) == null
-                        && (player == null || player.canSee(p)))
-                .map(Player::getName).collect(Collectors.toList());
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/RankPermissionsCompletion.java

@@ -1,25 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import net.sacredlabyrinth.phaed.simpleclans.Helper;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-@SuppressWarnings("unused")
-public class RankPermissionsCompletion extends AbstractStaticCompletion {
-    public RankPermissionsCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public @NotNull Collection<String> getCompletions() {
-        return Arrays.asList(Helper.fromPermissionArray());
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "rank_permissions";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/completions/RanksCompletion.java

@@ -1,35 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.completions;
-
-import co.aikar.commands.BukkitCommandCompletionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.Rank;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.stream.Collectors;
-
-public class RanksCompletion extends AbstractSyncCompletion {
-    public RanksCompletion(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Collection<String> getCompletions(BukkitCommandCompletionContext context) throws InvalidCommandArgument {
-        Player player = context.getPlayer();
-        if (player != null) {
-            Clan clan = clanManager.getClanByPlayerUniqueId(player.getUniqueId());
-            if (clan != null) {
-                return clan.getRanks().stream().map(Rank::getName).collect(Collectors.toList());
-            }
-        }
-        return Collections.emptyList();    }
-
-    @Override
-    public @NotNull String getId() {
-        return "ranks";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/AbstractCommandCondition.java

@@ -1,12 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.CommandConditions;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-public abstract class AbstractCommandCondition extends AbstractCondition implements CommandConditions.Condition<BukkitCommandIssuer> {
-    public AbstractCommandCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/AbstractCondition.java

@@ -1,25 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.PermissionsManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.RequestManager;
-import net.sacredlabyrinth.phaed.simpleclans.managers.SettingsManager;
-import org.jetbrains.annotations.NotNull;
-
-public abstract class AbstractCondition implements IdentifiableCondition {
-
-    protected final SimpleClans plugin;
-    protected final PermissionsManager permissionsManager;
-    protected final ClanManager clanManager;
-    protected final RequestManager requestManager;
-    protected final SettingsManager settingsManager;
-
-    public AbstractCondition(@NotNull SimpleClans plugin) {
-        this.plugin = plugin;
-        permissionsManager = plugin.getPermissionsManager();
-        clanManager = plugin.getClanManager();
-        requestManager = plugin.getRequestManager();
-        settingsManager = plugin.getSettingsManager();
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/AlliedClanCondition.java

@@ -1,38 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class AlliedClanCondition extends AbstractParameterCondition<ClanInput> {
-    public AlliedClanCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanInput> getType() {
-        return ClanInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext,
-                                  ClanInput value) throws InvalidCommandArgument {
-        BukkitCommandIssuer issuer = context.getIssuer();
-        Clan clan = Conditions.assertClanMember(clanManager, issuer);
-        if (!clan.isAlly(value.getClan().getTag())) {
-            throw new ConditionFailedException(RED + lang("your.clans.are.not.allies", issuer));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "allied_clan";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/ClanMemberCondition.java

@@ -1,33 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class ClanMemberCondition extends AbstractParameterCondition<ClanPlayer> {
-    public ClanMemberCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayer> getType() {
-        return ClanPlayer.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext, ClanPlayer value)
-            throws InvalidCommandArgument {
-        Conditions.assertClanMember(clanManager, context.getIssuer());
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_member";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/DifferentClanCondition.java

@@ -1,43 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanInput;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class DifferentClanCondition extends AbstractParameterCondition<ClanInput> {
-
-    public DifferentClanCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanInput> getType() {
-        return ClanInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext,
-                                  ClanInput value) throws InvalidCommandArgument {
-        if (execContext.getIssuer().isPlayer()) {
-            Player player = execContext.getPlayer();
-            ClanPlayer cp = clanManager.getAnyClanPlayer(player.getUniqueId());
-            if (cp != null && cp.getClan() != null) {
-                if (value.getClan().equals(cp.getClan())) {
-                    throw new ConditionFailedException(lang("cannot.be.same.clan", player));
-                }
-            }
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "different";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/InputClanMemberCondition.java

@@ -1,35 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-public class InputClanMemberCondition extends AbstractParameterCondition<ClanPlayerInput> {
-    public InputClanMemberCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext, ClanPlayerInput value)
-            throws InvalidCommandArgument {
-        if (value.getClanPlayer().getClan() == null) {
-            throw new ConditionFailedException(RED + lang("player.not.a.member.of.any.clan",
-                    execContext.getSender()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_member";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/InputVerifiedCondition.java

@@ -1,36 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class InputVerifiedCondition extends AbstractParameterCondition<ClanInput> {
-
-    public InputVerifiedCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanInput> getType() {
-        return ClanInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext,
-                                  ClanInput value)
-            throws InvalidCommandArgument {
-        if (!value.getClan().isVerified()) {
-            throw new ConditionFailedException(lang("other.clan.not.verified", execContext.getSender()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "verified";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/LeaderCondition.java

@@ -1,34 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.ConditionFailedException;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class LeaderCondition extends AbstractCommandCondition {
-    public LeaderCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context) throws InvalidCommandArgument {
-        Player player = Conditions.assertPlayer(context.getIssuer());
-        Clan clan = Conditions.assertClanMember(clanManager, context.getIssuer());
-        if (!clan.isLeader(player)) {
-            throw new ConditionFailedException(ChatColor.RED + lang("no.leader.permissions", player));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "leader";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/MemberFeeEnabledCondition.java

@@ -1,30 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.ConditionFailedException;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.ChatColor;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-public class MemberFeeEnabledCondition extends AbstractCommandCondition {
-    public MemberFeeEnabledCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context) throws InvalidCommandArgument {
-        if (!settingsManager.isMemberFee()) {
-            throw new ConditionFailedException(ChatColor.RED + lang("disabled.command",
-                    context.getIssuer().getIssuer()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "member_fee_enabled";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/MinimumToAllyCondition.java

@@ -1,34 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.ConditionFailedException;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class MinimumToAllyCondition extends AbstractCommandCondition {
-    public MinimumToAllyCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context) throws InvalidCommandArgument {
-        Clan clan = Conditions.assertClanMember(clanManager, context.getIssuer());
-        if (clan.getSize() < settingsManager.getClanMinSizeToAlly()) {
-            throw new ConditionFailedException(RED +
-                    lang("minimum.to.make.alliance", context.getIssuer(), settingsManager.getClanMinSizeToAlly()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "minimum_to_ally";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/NotBannedInputCondition.java

@@ -1,40 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.UUID;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class NotBannedInputCondition extends AbstractParameterCondition<ClanPlayerInput> {
-
-    public NotBannedInputCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext, ClanPlayerInput value)
-            throws InvalidCommandArgument {
-        UUID uniqueId = value.getClanPlayer().getUniqueId();
-        if (settingsManager.isBanned(uniqueId)) {
-            throw new ConditionFailedException(RED + lang("this.player.is.banned.from.using.clan.commands",
-                    execContext.getSender()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "not_banned";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/NotInClanCondition.java

@@ -1,37 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class NotInClanCondition extends AbstractParameterCondition<ClanPlayerInput> {
-
-    public NotInClanCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext, ClanPlayerInput value)
-            throws InvalidCommandArgument {
-        if (value.getClanPlayer().getClan() != null) {
-            throw new ConditionFailedException(RED + lang("the.player.is.already.member.of.another.clan",
-                    execContext.getSender()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "not_in_clan";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/OnlineCondition.java

@@ -1,34 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class OnlineCondition extends AbstractParameterCondition<ClanPlayerInput> {
-
-    public OnlineCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context, BukkitCommandExecutionContext execContext, ClanPlayerInput value) throws InvalidCommandArgument {
-        if (value.getClanPlayer().toPlayer() == null) {
-            throw new ConditionFailedException(lang("other.player.must.be.online", execContext.getSender()));
-        }
-    }
-
-    @Override
-    @NotNull
-    public String getId() {
-        return "online";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/PlayerClanMemberCondition.java

@@ -1,33 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class PlayerClanMemberCondition extends AbstractParameterCondition<Player> {
-    public PlayerClanMemberCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<Player> getType() {
-        return Player.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext,
-                                  Player value) throws InvalidCommandArgument {
-        Conditions.assertClanMember(clanManager, context.getIssuer());
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "clan_member";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/RankPermissionCondition.java

@@ -1,37 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.ConditionFailedException;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.RankPermission;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class RankPermissionCondition extends AbstractCommandCondition {
-
-    public RankPermissionCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context) throws InvalidCommandArgument {
-        String name = context.getConfigValue("name", (String) null);
-        Player player = context.getIssuer().getPlayer();
-        if (player == null || name == null) {
-            return;
-        }
-        RankPermission rankPermission = net.sacredlabyrinth.phaed.simpleclans.RankPermission.valueOf(name);
-
-        if (!permissionsManager.has(player, rankPermission, true)) {
-            throw new ConditionFailedException();
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "rank";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/SameClanCondition.java

@@ -1,38 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.*;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class SameClanCondition extends AbstractParameterCondition<ClanPlayerInput> {
-    public SameClanCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context,
-                                  BukkitCommandExecutionContext execContext,
-                                  ClanPlayerInput value) throws InvalidCommandArgument {
-        BukkitCommandIssuer issuer = context.getIssuer();
-        Clan clan = Conditions.assertClanMember(clanManager, issuer);
-        if (value == null || value.getClanPlayer().getClan() == null ||
-                !value.getClanPlayer().getClan().equals(clan)) {
-            throw new ConditionFailedException(lang("the.player.is.not.a.member.of.your.clan", issuer));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "same_clan";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/conditions/VerifiedCondition.java

@@ -1,33 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.conditions;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.ConditionContext;
-import co.aikar.commands.ConditionFailedException;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-@SuppressWarnings("unused")
-public class VerifiedCondition extends AbstractCommandCondition {
-
-    public VerifiedCondition(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public void validateCondition(ConditionContext<BukkitCommandIssuer> context) throws InvalidCommandArgument {
-        Clan clan = Conditions.assertClanMember(clanManager, context.getIssuer());
-        if (!clan.isVerified()) {
-            throw new ConditionFailedException(lang("clan.is.not.verified",
-                    context.getIssuer()));
-        }
-    }
-
-    @Override
-    public @NotNull String getId() {
-        return "verified";
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/AbstractContextResolver.java

@@ -1,18 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import org.jetbrains.annotations.NotNull;
-
-public abstract class AbstractContextResolver<T> {
-
-    protected final @NotNull SimpleClans plugin;
-    protected final @NotNull ClanManager clanManager;
-
-    public AbstractContextResolver(@NotNull SimpleClans plugin) {
-        this.plugin = plugin;
-        clanManager = plugin.getClanManager();
-    }
-
-    public abstract Class<T> getType();
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/ClanContextResolver.java

@@ -1,24 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class ClanContextResolver extends AbstractIssuerOnlyContextResolver<Clan> {
-    public ClanContextResolver(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Clan getContext(BukkitCommandExecutionContext c) throws InvalidCommandArgument {
-        return Contexts.assertClanMember(clanManager, c.getIssuer());
-    }
-
-    @Override
-    public Class<Clan> getType() {
-        return Clan.class;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/ClanInputContextResolver.java

@@ -1,34 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanInput;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class ClanInputContextResolver extends AbstractInputOnlyContextResolver<ClanInput> {
-    public ClanInputContextResolver(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public ClanInput getContext(BukkitCommandExecutionContext context) throws InvalidCommandArgument {
-        String arg = context.popFirstArg();
-        Clan clan = clanManager.getClan(arg);
-        if (clan == null) {
-            throw new InvalidCommandArgument(RED + lang("the.clan.does.not.exist", context.getSender()),
-                    false);
-        }
-        return new ClanInput(clan);
-    }
-
-    @Override
-    public Class<ClanInput> getType() {
-        return ClanInput.class;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/ClanPlayerContextResolver.java

@@ -1,26 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class ClanPlayerContextResolver extends AbstractIssuerOnlyContextResolver<ClanPlayer> {
-    public ClanPlayerContextResolver(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public ClanPlayer getContext(BukkitCommandExecutionContext context) throws InvalidCommandArgument {
-        Player player = Contexts.assertPlayer(context.getIssuer());
-        return clanManager.getCreateClanPlayer(player.getUniqueId());
-    }
-
-    @Override
-    public Class<ClanPlayer> getType() {
-        return ClanPlayer.class;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/ClanPlayerInputContextResolver.java

@@ -1,32 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.ClanPlayer;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.commands.ClanPlayerInput;
-import org.bukkit.Bukkit;
-import org.bukkit.OfflinePlayer;
-import org.jetbrains.annotations.NotNull;
-
-@SuppressWarnings("unused")
-public class ClanPlayerInputContextResolver extends AbstractInputOnlyContextResolver<ClanPlayerInput> {
-    public ClanPlayerInputContextResolver(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public ClanPlayerInput getContext(BukkitCommandExecutionContext context) throws InvalidCommandArgument {
-        String arg = context.popFirstArg();
-        @SuppressWarnings("deprecation")
-        OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(arg);
-        ClanPlayer cp = clanManager.getCreateClanPlayer(offlinePlayer.getUniqueId());
-
-        return new ClanPlayerInput(cp);
-    }
-
-    @Override
-    public Class<ClanPlayerInput> getType() {
-        return ClanPlayerInput.class;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/Contexts.java

@@ -1,37 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandIssuer;
-import co.aikar.commands.InvalidCommandArgument;
-import co.aikar.commands.MessageKeys;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.managers.ClanManager;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-public class Contexts {
-
-    private Contexts() {
-    }
-
-    @NotNull
-    public static Clan assertClanMember(@NotNull ClanManager clanManager,
-                                        @NotNull BukkitCommandIssuer issuer) {
-        assertPlayer(issuer);
-        Clan clan = clanManager.getClanByPlayerUniqueId(issuer.getUniqueId());
-        if (clan == null) {
-            throw new InvalidCommandArgument(lang("not.a.member.of.any.clan", issuer), false);
-        }
-        return clan;
-    }
-
-    @NotNull
-    public static Player assertPlayer(@NotNull BukkitCommandIssuer issuer) {
-        Player player = issuer.getPlayer();
-        if (player == null) {
-            throw new InvalidCommandArgument(MessageKeys.NOT_ALLOWED_ON_CONSOLE, false);
-        }
-        return player;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/contexts/RankContextResolver.java

@@ -1,35 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.contexts;
-
-import co.aikar.commands.BukkitCommandExecutionContext;
-import co.aikar.commands.InvalidCommandArgument;
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.Rank;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.RED;
-
-@SuppressWarnings("unused")
-public class RankContextResolver extends AbstractInputOnlyContextResolver<Rank> {
-    public RankContextResolver(@NotNull SimpleClans plugin) {
-        super(plugin);
-    }
-
-    @Override
-    public Rank getContext(BukkitCommandExecutionContext context) throws InvalidCommandArgument {
-        Clan clan = Contexts.assertClanMember(clanManager, context.getIssuer());
-        String rankName = context.isLastArg() ? context.joinArgs() : context.popFirstArg();
-        Rank rank = clan.getRank(rankName);
-        if (rank == null) {
-            throw new InvalidCommandArgument(RED + lang("rank.0.does.not.exist", context.getIssuer(), rankName),
-                    false);
-        }
-        return rank;
-    }
-
-    @Override
-    public Class<Rank> getType() {
-        return Rank.class;
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/Alliances.java

@@ -1,49 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-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.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.AQUA;
-import static org.bukkit.ChatColor.DARK_GRAY;
-
-public class Alliances extends Sendable {
-
-    public Alliances(@NotNull SimpleClans plugin, @NotNull CommandSender sender) {
-        super(plugin, sender);
-    }
-
-    @Override
-    public void send() {
-        List<Clan> clans = cm.getClans();
-        cm.sortClansByKDR(clans);
-        sendHeader();
-
-        for (Clan clan : clans) {
-            if (!clan.isVerified()) {
-                continue;
-            }
-
-            chatBlock.addRow("  " + AQUA + clan.getName(), clan.getAllyString(DARK_GRAY + ", "));
-        }
-
-        sendBlock();
-    }
-
-    private void sendHeader() {
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, sm.getServerName() + subColor + " " +
-                lang("alliances", sender) + " " + headColor +
-                Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-
-        chatBlock.setAlignment("l", "l");
-        chatBlock.addRow("  " + headColor + lang("clan", sender), lang("allies", sender));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/ClanList.java

@@ -1,106 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-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.utils.KDRFormat;
-import net.sacredlabyrinth.phaed.simpleclans.utils.RankingNumberResolver;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.List;
-import java.util.stream.Collectors;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static net.sacredlabyrinth.phaed.simpleclans.utils.RankingNumberResolver.RankingType.ORDINAL;
-import static org.bukkit.ChatColor.*;
-
-public class ClanList extends Sendable {
-
-    private final @Nullable String type;
-    private final @Nullable String order;
-
-    public ClanList(@NotNull SimpleClans plugin,
-                    @NotNull CommandSender sender,
-                    @Nullable String type,
-                    @Nullable String order) {
-        super(plugin, sender);
-        this.type = type;
-        this.order = order;
-    }
-
-    @Override
-    public void send() {
-        List<Clan> clans = getListableClans();
-        if (clans.isEmpty()) {
-            ChatBlock.sendMessage(sender, RED + lang("no.clans.have.been.created", sender));
-            return;
-        }
-        RankingNumberResolver<Clan, ? extends Comparable<?>> ranking = getRankingResolver(clans, type, order);
-        sendHeader(clans);
-        for (Clan clan : clans) {
-            addLine(ranking, clan);
-        }
-
-        sendBlock();
-    }
-
-    private RankingNumberResolver<Clan, ? extends Comparable<?>> getRankingResolver(List<Clan> clans,
-                                                                                    @Nullable String type,
-                                                                                    @Nullable String order) {
-        boolean ascending = order == null || lang("list.order.asc").equalsIgnoreCase(order);
-        if (type == null) {
-            type = sm.getListDefaultOrderBy();
-        }
-        if (type.equalsIgnoreCase(lang("list.type.size"))) {
-            return new RankingNumberResolver<>(clans, Clan::getSize, order != null && ascending, ORDINAL);
-        }
-        if (type.equalsIgnoreCase(lang("list.type.active"))) {
-            return new RankingNumberResolver<>(clans, Clan::getLastUsed, order != null && ascending, ORDINAL);
-        }
-        if (type.equalsIgnoreCase(lang("list.type.founded"))) {
-            return new RankingNumberResolver<>(clans, Clan::getFounded, ascending, ORDINAL);
-        }
-        if (type.equalsIgnoreCase(lang("list.type.name"))) {
-            return new RankingNumberResolver<>(clans, Clan::getName, ascending, ORDINAL);
-        }
-        return new RankingNumberResolver<>(clans, clan -> KDRFormat.toBigDecimal(clan.getTotalKDR()),
-                order != null && ascending, sm.getRankingType());
-    }
-
-    @NotNull
-    private List<Clan> getListableClans() {
-        List<Clan> clans = plugin.getClanManager().getClans();
-        clans = clans.stream().filter(clan -> clan.isVerified() || sm.isShowUnverifiedOnList())
-                .collect(Collectors.toList());
-        return clans;
-    }
-
-    private void sendHeader(List<Clan> clans) {
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, sm.getServerName() + subColor + " " + lang("clans.lower", sender)
-                + " " + headColor + Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-        ChatBlock.sendMessage(sender, headColor + lang("total.clans", sender) + " " + subColor + clans.size());
-        ChatBlock.sendBlank(sender);
-        chatBlock.setAlignment("c", "l", "c", "c");
-        chatBlock.setFlexibility(false, true, false, false);
-        chatBlock.addRow("  " + headColor + lang("rank", sender), lang("name", sender),
-                lang("kdr", sender), lang("members", sender));
-    }
-
-    @SuppressWarnings("deprecation")
-    private void addLine(RankingNumberResolver<Clan, ? extends Comparable<?>> ranking, Clan clan) {
-        String tag = sm.getClanChatBracketColor() + sm.getClanChatTagBracketLeft()
-                + sm.getTagDefaultColor() + clan.getColorTag() + sm.getClanChatBracketColor()
-                + sm.getClanChatTagBracketRight();
-        String name = (clan.isVerified() ? sm.getPageClanNameColor() : GRAY) + clan.getName();
-        String fullname = tag + " " + name;
-        String size = WHITE + "" + clan.getSize();
-        String kdr = clan.isVerified() ? YELLOW + "" + KDRFormat.format(clan.getTotalKDR()) : "";
-
-        chatBlock.addRow("  " + ranking.getRankingNumber(clan), fullname, kdr, size);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/ClanProfile.java

@@ -1,66 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-import net.sacredlabyrinth.phaed.simpleclans.Clan;
-import net.sacredlabyrinth.phaed.simpleclans.SimpleClans;
-import net.sacredlabyrinth.phaed.simpleclans.utils.KDRFormat;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-
-public class ClanProfile extends Sendable {
-
-    private final Clan clan;
-
-    public ClanProfile(@NotNull SimpleClans plugin, @NotNull CommandSender sender, @NotNull Clan clan) {
-        super(plugin, sender);
-        this.clan = clan;
-    }
-
-    @Override
-    public void send() {
-        String message = lang("clan.profile").replace("%clan_name%", clan.getName())
-                .replace("%clan_color_tag%", clan.getColorTag())
-                .replace("%clan_description%", getDescription())
-                .replace("%clan_verified%", getVerifiedStatus())
-                .replace("%clan_leaders%", clan.getLeadersString(sm.getPageLeaderColor(), subColor + ", "))
-                .replace("%clan_online_count%", String.valueOf(clan.getOnlineMembers().size()))
-                .replace("%clan_size%", String.valueOf(clan.getSize()))
-                .replace("%clan_kdr%", KDRFormat.format(clan.getTotalKDR()))
-                .replace("%clan_rival_kills%", String.valueOf(clan.getTotalRival()))
-                .replace("%clan_neutral_kills%", String.valueOf(clan.getTotalNeutral()))
-                .replace("%clan_civilian_kills%", String.valueOf(clan.getTotalCivilian()))
-                .replace("%clan_deaths%", String.valueOf(clan.getTotalDeaths()))
-                .replace("%clan_fee_enabled%", getFeeEnabled())
-                .replace("%clan_fee_value%", String.valueOf(clan.getMemberFee()))
-                .replace("%clan_allies%", clan.getAllyString(subColor + ", "))
-                .replace("%clan_rivals%", clan.getRivalString(subColor + ", "))
-                .replace("%clan_founded%", clan.getFoundedString())
-                .replace("%clan_inactive_days%", String.valueOf(clan.getInactiveDays()))
-                .replace("%clan_max_inactive_days%", getMaxInactiveDays());
-        sender.sendMessage(message);
-    }
-
-    @NotNull
-    private String getMaxInactiveDays() {
-        return String.valueOf(clan.isVerified() ?
-                sm.getPurgeClan() : sm.getPurgeUnverified());
-    }
-
-    @NotNull
-    private String getFeeEnabled() {
-        return clan.isMemberFeeEnabled() ? lang("fee.enabled", sender) : lang("fee.disabled", sender);
-    }
-
-    @NotNull
-    private String getVerifiedStatus() {
-        return clan.isVerified() ? sm.getPageTrustedColor() + lang("verified", sender) :
-                sm.getPageUnTrustedColor() + lang("unverified", sender);
-    }
-
-    @NotNull
-    private String getDescription() {
-        return clan.getDescription() != null && !clan.getDescription().isEmpty() ? clan.getDescription() :
-                lang("no.description", sender);
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/ClanRoster.java

@@ -1,73 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-public class ClanRoster extends Sendable {
-
-    private final Clan clan;
-
-    public ClanRoster(@NotNull SimpleClans plugin, @NotNull CommandSender sender, @NotNull Clan clan) {
-        super(plugin, sender);
-        this.clan = clan;
-    }
-
-    @Override
-    public void send() {
-        configureAndSendHeader();
-        addLeaders();
-        addMembers();
-
-        sendBlock();
-    }
-
-    private void addMembers() {
-        List<ClanPlayer> members = clan.getNonLeaders();
-        plugin.getClanManager().sortClanPlayersByLastSeen(members);
-        for (ClanPlayer cp : members) {
-            Player p = cp.toPlayer();
-
-            String name = (cp.isTrusted() ? sm.getPageTrustedColor() : sm.getPageUnTrustedColor()) + cp.getName();
-            String lastSeen = p != null && p.isOnline() && !Helper.isVanished(p) ? GREEN + lang("online", sender) : WHITE + cp.getLastSeenDaysString(sender);
-
-            chatBlock.addRow("  " + name, YELLOW + Helper.parseColors(cp.getRankDisplayName()) + RESET, lastSeen);
-        }
-    }
-
-    private void addLeaders() {
-        List<ClanPlayer> leaders = clan.getLeaders();
-        plugin.getClanManager().sortClanPlayersByLastSeen(leaders);
-        for (ClanPlayer cp : leaders) {
-            Player p = cp.toPlayer();
-
-            String name = sm.getPageLeaderColor() + cp.getName();
-            String lastSeen = p != null && p.isOnline() && !Helper.isVanished(p) ? GREEN + lang("online", sender)
-                    : WHITE + cp.getLastSeenDaysString(sender);
-
-            chatBlock.addRow("  " + name, YELLOW + Helper.parseColors(cp.getRankDisplayName()) + RESET, lastSeen);
-        }
-    }
-
-    private void configureAndSendHeader() {
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, sm.getPageClanNameColor() + clan.getName() + subColor + " " +
-                lang("roster", sender) + " " + headColor + Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-        ChatBlock.sendMessage(sender, headColor + lang("legend", sender) + " " + sm.getPageLeaderColor() +
-                lang("leader", sender) + headColor + ", " + sm.getPageTrustedColor() + lang("trusted", sender) +
-                headColor + ", " + sm.getPageUnTrustedColor() + lang("untrusted", sender));
-        ChatBlock.sendBlank(sender);
-
-        chatBlock.setFlexibility(false, true, false, true);
-        chatBlock.addRow("  " + headColor + lang("player", sender), lang("rank", sender),
-                lang("seen", sender));
-    }
-
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/ClanStats.java

@@ -1,71 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-import net.sacredlabyrinth.phaed.simpleclans.*;
-import net.sacredlabyrinth.phaed.simpleclans.utils.KDRFormat;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.text.NumberFormat;
-import java.util.List;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-public class ClanStats extends Sendable {
-
-    private final Clan clan;
-
-    public ClanStats(@NotNull SimpleClans plugin, @NotNull CommandSender sender, @NotNull Clan clan) {
-        super(plugin, sender);
-        this.clan = clan;
-    }
-
-    @Override
-    public void send() {
-        configureAndSendHeader();
-
-        List<ClanPlayer> leaders = clan.getLeaders();
-        cm.sortClanPlayersByKDR(leaders);
-        addRows(leaders);
-
-        List<ClanPlayer> members = clan.getNonLeaders();
-        cm.sortClanPlayersByKDR(members);
-        addRows(members);
-
-        sendBlock();
-    }
-
-    private void configureAndSendHeader() {
-        ChatBlock.saySingle(sender, sm.getPageClanNameColor() + clan.getName() + subColor + " " +
-                lang("stats", sender) + " " + headColor + Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-        ChatBlock.sendMessage(sender, headColor + lang("kdr", sender) + " = " + subColor +
-                lang("kill.death.ratio", sender));
-        ChatBlock.sendMessage(sender, headColor + lang("weights", sender) + " = " + lang("rival", sender)
-                + ": " + subColor + sm.getKwRival() + headColor + " " + lang("neutral", sender) + ": " + subColor +
-                sm.getKwNeutral() + headColor + " " + lang("civilian", sender) + ": " + subColor +
-                sm.getKwCivilian());
-        ChatBlock.sendBlank(sender);
-
-        chatBlock.setFlexibility(true, false, false, false, false, false, false);
-        chatBlock.setAlignment("l", "c", "c", "c", "c", "c", "c");
-        chatBlock.addRow("  " + headColor + lang("name", sender), lang("kdr", sender),
-                lang("rival", sender), lang("neutral", sender), lang("civilian.abbreviation", sender),
-                lang("deaths", sender));
-    }
-
-    private void addRows(List<ClanPlayer> clanPlayers) {
-        for (ClanPlayer cpm : clanPlayers) {
-            String name = (cpm.isLeader() ? sm.getPageLeaderColor() : (cpm.isTrusted() ? sm.getPageTrustedColor() :
-                    sm.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 = KDRFormat.format(cpm.getKDR());
-
-            chatBlock.addRow("  " + name, YELLOW + kdr, WHITE + rival, GRAY + neutral, DARK_GRAY + civilian,
-                    DARK_RED + deaths);
-        }
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/Leaderboard.java

@@ -1,69 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-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 net.sacredlabyrinth.phaed.simpleclans.utils.KDRFormat;
-import net.sacredlabyrinth.phaed.simpleclans.utils.RankingNumberResolver;
-import org.bukkit.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.math.BigDecimal;
-import java.util.List;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-public class Leaderboard extends Sendable {
-
-    private final RankingNumberResolver<ClanPlayer, BigDecimal> rankingResolver;
-    private final List<ClanPlayer> clanPlayers;
-
-    public Leaderboard(@NotNull SimpleClans plugin, @NotNull CommandSender sender) {
-        super(plugin, sender);
-        clanPlayers = cm.getAllClanPlayers();
-        rankingResolver = new RankingNumberResolver<>(clanPlayers,
-                c -> KDRFormat.toBigDecimal(c.getKDR()), false, sm.getRankingType());
-    }
-
-    @Override
-    public void send() {
-        configureAndSendHeader();
-        addLines();
-        sendBlock();
-    }
-
-    private void addLines() {
-        for (ClanPlayer cp : clanPlayers) {
-            boolean online = cp.toPlayer() != null;
-
-            String name = (cp.isLeader() ? sm.getPageLeaderColor() : (cp.isTrusted() ? sm.getPageTrustedColor() :
-                    sm.getPageUnTrustedColor())) + cp.getName();
-            String lastSeen = online ? GREEN + lang("online", sender) : WHITE + cp.getLastSeenDaysString(sender);
-
-            String clanTag = WHITE + lang("free.agent", sender);
-
-            if (cp.getClan() != null) {
-                clanTag = cp.getClan().getColorTag();
-            }
-
-            chatBlock.addRow("  " + rankingResolver.getRankingNumber(cp),
-                    name, YELLOW + "" + KDRFormat.format(cp.getKDR()), WHITE + clanTag, lastSeen);
-        }
-    }
-
-    private void configureAndSendHeader() {
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, sm.getServerName() + subColor + " " + lang("leaderboard.command", sender)
-                + " " + headColor + Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-        ChatBlock.sendMessage(sender, headColor + lang("total.clan.players.0", sender, subColor +
-                clanPlayers.size()));
-        ChatBlock.sendBlank(sender);
-
-        chatBlock.setAlignment("c", "l", "c", "c", "c", "c");
-        chatBlock.addRow("  " + headColor + lang("rank", sender), lang("player", sender),
-                lang("kdr", sender), lang("clan", sender), lang("seen", sender));
-    }
-}

src/main/java/net/sacredlabyrinth/phaed/simpleclans/commands/data/Rivalries.java

@@ -1,50 +0,0 @@
-package net.sacredlabyrinth.phaed.simpleclans.commands.data;
-
-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.command.CommandSender;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-import static net.sacredlabyrinth.phaed.simpleclans.SimpleClans.lang;
-import static org.bukkit.ChatColor.*;
-
-public class Rivalries extends Sendable {
-
-    public Rivalries(@NotNull SimpleClans plugin, @NotNull CommandSender sender) {
-        super(plugin, sender);
-    }
-
-    @Override
-    public void send() {
-        List<Clan> clans = cm.getClans();
-        cm.sortClansByKDR(clans);
-        sendHeader();
-
-        for (Clan clan : clans) {
-            if (!clan.isVerified()) {
-                continue;
-            }
-
-            chatBlock.addRow("  " + AQUA + clan.getName(), clan.getRivalString(DARK_GRAY + ", "));
-        }
-
-        sendBlock();
-    }
-
-    private void sendHeader() {
-        ChatBlock.sendBlank(sender);
-        ChatBlock.saySingle(sender, sm.getServerName() + subColor + " " +
-                lang("rivalries", sender) + " " + headColor + Helper.generatePageSeparator(sm.getPageSep()));
-        ChatBlock.sendBlank(sender);
-        ChatBlock.sendMessage(sender, headColor + lang("legend", sender) + DARK_RED + " [" +
-                lang("war", sender) + "]");
-        ChatBlock.sendBlank(sender);
-
-        chatBlock.setAlignment("l", "l");
-        chatBlock.addRow(lang("clan", sender), lang("rivals", sender));
-    }
-}