├── .github └── workflows │ └── gradle.yml ├── .gitignore ├── LICENSE ├── README.md ├── build.gradle.kts ├── gradle.properties ├── gradle └── wrapper │ ├── gradle-wrapper.jar │ └── gradle-wrapper.properties ├── gradlew ├── gradlew.bat ├── jitpack.yml ├── settings.gradle.kts └── src └── main ├── java └── net │ └── crashcraft │ └── crashclaim │ ├── CrashClaim.java │ ├── api │ └── CrashClaimAPI.java │ ├── claimobjects │ ├── BaseClaim.java │ ├── Claim.java │ ├── PermState.java │ ├── PermissionGroup.java │ ├── SubClaim.java │ └── permission │ │ ├── GlobalPermissionSet.java │ │ ├── PermissionSet.java │ │ ├── PlayerPermissionSet.java │ │ ├── child │ │ └── SubPermissionGroup.java │ │ └── parent │ │ └── ParentPermissionGroup.java │ ├── commands │ ├── AdminCommand.java │ ├── BypassCommand.java │ ├── ClaimInfoCommand.java │ ├── CommandManager.java │ ├── EjectCommand.java │ ├── HideClaimsCommand.java │ ├── MenuCommand.java │ ├── ShowClaimsCommand.java │ └── claiming │ │ ├── ClaimCommand.java │ │ ├── ClaimMode.java │ │ ├── ClickState.java │ │ ├── UnClaimCommand.java │ │ └── modes │ │ ├── NewClaimMode.java │ │ ├── NewSubClaimMode.java │ │ ├── ResizeClaimMode.java │ │ └── ResizeSubClaimMode.java │ ├── config │ ├── BaseConfig.java │ ├── ConfigManager.java │ ├── GlobalConfig.java │ └── GroupSettings.java │ ├── crashutils │ ├── CrashUtils.java │ ├── ServiceUtil.java │ ├── caches │ │ └── TextureCache.java │ └── menusystem │ │ ├── CrashGuiHolder.java │ │ ├── CrashMenuController.java │ │ ├── GUI.java │ │ └── defaultmenus │ │ ├── ConfirmationMenu.java │ │ └── PlayerListMenu.java │ ├── data │ ├── ClaimDataManager.java │ ├── ClaimResponse.java │ ├── ContributionManager.java │ ├── ErrorType.java │ ├── MaterialName.java │ ├── MathUtils.java │ ├── SaveResponse.java │ ├── StaticClaimLogic.java │ └── providers │ │ ├── DataProvider.java │ │ └── sqlite │ │ ├── DataType.java │ │ ├── DataVersion.java │ │ ├── DataVersionIncrementException.java │ │ ├── DatabaseManager.java │ │ ├── SQLiteDataProvider.java │ │ └── versions │ │ ├── DataRev0.java │ │ ├── DataRev1.java │ │ ├── DataRev2.java │ │ ├── DataRev3.java │ │ └── DataRev4.java │ ├── listeners │ ├── PacketEventsListener.java │ ├── PlayerListener.java │ └── WorldListener.java │ ├── localization │ ├── CrashClaimExpansion.java │ ├── Localization.java │ ├── LocalizationLoader.java │ ├── LocalizationUtils.java │ └── PlaceholderManager.java │ ├── menus │ ├── ClaimMenu.java │ ├── SubClaimMenu.java │ ├── helpers │ │ ├── MenuListHelper.java │ │ └── MenuSwitchType.java │ ├── list │ │ ├── ClaimListMenu.java │ │ ├── PlayerPermListMenu.java │ │ └── SubClaimListMenu.java │ └── permissions │ │ ├── AdvancedPermissionMenu.java │ │ └── SimplePermissionMenu.java │ ├── migration │ ├── MigrationAdapter.java │ ├── MigrationManager.java │ └── adapters │ │ └── GriefPreventionAdaptor.java │ ├── packet │ └── PacketHandler.java │ ├── payment │ ├── PaymentProcessor.java │ ├── PaymentProvider.java │ ├── ProcessorManager.java │ ├── ProviderInitializationException.java │ ├── TransactionRecipe.java │ ├── TransactionResponse.java │ ├── TransactionType.java │ ├── credits.txt │ └── providers │ │ ├── FakePaymentProvider.java │ │ └── VaultPaymentProvider.java │ ├── permissions │ ├── BypassManager.java │ ├── PermissionHelper.java │ ├── PermissionRoute.java │ ├── PermissionRouter.java │ └── PermissionSetup.java │ ├── pluginsupport │ ├── PluginSupport.java │ ├── PluginSupportDistributor.java │ ├── PluginSupportLoader.java │ ├── PluginSupportManager.java │ ├── loader │ │ ├── DeluxeSellwandSupportLoader.java │ │ ├── LuckPermSupportLoader.java │ │ ├── QuickShopHikariSupportLoader.java │ │ └── WorldGuardSupportLoader.java │ └── plugins │ │ ├── DeluxeSellwandSupport.java │ │ ├── LuckPermsSupport.java │ │ ├── QuickShopHikariSupport.java │ │ └── WorldGuardSupport.java │ └── visualize │ ├── VisualizationManager.java │ └── api │ ├── BaseVisual.java │ ├── VisualColor.java │ ├── VisualGroup.java │ ├── VisualProvider.java │ ├── VisualType.java │ ├── VisualUtils.java │ ├── claim │ ├── BlockClaimVisual.java │ └── GlowClaimVisual.java │ ├── marker │ ├── BlockMarkerVisual.java │ └── GlowMarketVisual.java │ ├── providers │ ├── BlockVisualProvider.java │ └── GlowVisualProvider.java │ └── visuals │ ├── BaseBlockVisual.java │ └── BaseGlowVisual.java └── resources ├── languages ├── es_ES.yml └── ko_KR.yml ├── lookup.yml └── plugin.yml /.github/workflows/gradle.yml: -------------------------------------------------------------------------------- 1 | # This workflow uses actions that are not certified by GitHub. 2 | # They are provided by a third-party and are governed by 3 | # separate terms of service, privacy policy, and support 4 | # documentation. 5 | # This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time 6 | # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-java-with-gradle 7 | 8 | name: Java CI with Gradle 9 | 10 | on: 11 | push: 12 | branches: [ "master" ] 13 | 14 | permissions: 15 | contents: read 16 | 17 | jobs: 18 | build: 19 | runs-on: ubuntu-latest 20 | steps: 21 | - uses: actions/checkout@v4 22 | - name: Set up JDK 21 23 | uses: actions/setup-java@v3 24 | with: 25 | distribution: 'temurin' 26 | java-version: 21 27 | - name: Validate Gradle Wrapper 28 | uses: gradle/wrapper-validation-action@v1 29 | - name: Make gradlew executable 30 | run: chmod +x ./gradlew 31 | - name: Build Project 32 | run: ./gradlew assemble 33 | - name: Archive artifacts 34 | uses: actions/upload-artifact@master 35 | with: 36 | name: jar 37 | path: build/libs/ 38 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Java 2 | *.class 3 | 4 | # Eclipse IDE 5 | .settings/ 6 | bin/ 7 | .classpath 8 | .project 9 | 10 | # IntelliJ IDEA 11 | .idea/ 12 | /.idea/ 13 | *.iml 14 | 15 | # Gradle 16 | .gradle/ 17 | **/build/ 18 | **/out/ 19 | .gradletasknamecache 20 | !gradle-wrapper.jar 21 | gradle-app.setting 22 | /build/ 23 | /.gradle/ 24 | 25 | # Mac OSX 26 | .DS_Store -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![](https://i.imgur.com/g5rKXNp.png) 2 | [Discord](https://discord.gg/6FU9eCjcrA) | [SpigotMC](https://www.spigotmc.org/resources/crashclaim-claiming-plugin.94037/) 3 | *** 4 | CrashClaim is a claiming plugin oriented towards improving the claiming experience for survival servers wanting a clean, comprehensive system for their players. 5 | 6 | The latest downloads can be found on our SpigotMC page [here](). 7 | 8 | Check out our [features](https://github.com/WhipDevelopment/CrashClaim/wiki/Features) or [commands](https://github.com/WhipDevelopment/CrashClaim/wiki/Commands). 9 | 10 | 11 | ## Setup 12 | Download or build the latest compatible version for your server. 13 | 14 | Follow our installation and migration guide [here](https://github.com/WhipDevelopment/CrashClaim/wiki/https://github.com/WhipDevelopment/CrashClaim/wiki/Installation). If you need help with your configuration, click [here](https://github.com/WhipDevelopment/CrashClaim/wiki/https://github.com/WhipDevelopment/CrashClaim/wiki/Configuration). 15 | 16 | ## Building 17 | 18 | **Requirements** 19 | - Java 17 JDK or newer 20 | - Git 21 | 22 | **Compiling From Source** 23 | 24 | In order to compile CrashClaim, clone the repo with Git and run the command `./gradlew build`, after compilation you may find the jar from the folder build/libs. 25 | 26 | ## Contribute 27 | If you need a feature that you want to upstream, file a pull request and we will take a look. 28 | 29 | Try to follow the code style currently present in the class your editing and make clean and concise code changes with comments where necessary. 30 | 31 | ## Special Thanks 32 | ![YourKit](https://www.yourkit.com/images/yklogo.png) 33 | 34 | YourKit supports open source projects with innovative and intelligent tools 35 | for monitoring and profiling Java and .NET applications. 36 | YourKit is the creator of [YourKit Java Profiler](https://www.yourkit.com/java/profiler/), [YourKit .NET Profiler](https://www.yourkit.com/.net/profiler/), and [YourKit YouMonitor](https://www.yourkit.com/youmonitor/). 37 | -------------------------------------------------------------------------------- /build.gradle.kts: -------------------------------------------------------------------------------- 1 | plugins { 2 | id("java") 3 | id("maven-publish") 4 | id("io.github.goooler.shadow") version "8.1.7" 5 | } 6 | 7 | repositories { 8 | mavenLocal() 9 | maven("https://repo.codemc.io/repository/maven-public/") 10 | maven("https://repo.codemc.io/repository/maven-snapshots/") 11 | maven("https://ci.ender.zone/plugin/repository/everything/") 12 | maven("https://repo.aikar.co/content/groups/aikar/") 13 | maven("https://repo.dmulloy2.net/repository/releases/") 14 | maven("https://papermc.io/repo/repository/maven-public/") 15 | maven("https://jcenter.bintray.com") 16 | maven("https://hub.spigotmc.org/nexus/content/repositories/snapshots/") 17 | maven("https://jitpack.io") 18 | maven("https://nexus.wesjd.net/repository/thirdparty/") 19 | maven("https://oss.sonatype.org/content/repositories/snapshots/") 20 | maven("https://maven.enginehub.org/repo/") 21 | maven("https://repo.extendedclip.com/content/repositories/placeholderapi/") 22 | maven("https://repo.mikeprimm.com/") 23 | maven("https://repo.maven.apache.org/maven2/") 24 | maven("https://repo.codemc.io/repository/maven-releases/") 25 | 26 | maven { 27 | url = uri("https://repo.papermc.io/repository/maven-public/") 28 | } 29 | 30 | mavenCentral() 31 | } 32 | 33 | dependencies { 34 | // Paper 35 | compileOnly("io.papermc.paper:paper-api:1.20.6-R0.1-SNAPSHOT") 36 | 37 | // Adventure 38 | compileOnly("net.kyori:adventure-api:4.17.0") 39 | implementation("net.kyori:adventure-platform-bukkit:4.3.2") 40 | compileOnly("net.kyori:adventure-text-minimessage:4.17.0") 41 | 42 | // Other 43 | implementation("co.aikar:taskchain-bukkit:3.7.2") 44 | implementation("net.wesjd:anvilgui:1.9.4-SNAPSHOT") 45 | implementation("co.aikar:fastutil-base:3.0-SNAPSHOT") 46 | implementation("co.aikar:fastutil-longbase:3.0-SNAPSHOT") 47 | implementation("co.aikar:fastutil-longhashmap:3.0-SNAPSHOT") 48 | implementation("co.aikar:acf-paper:0.5.1-SNAPSHOT") 49 | implementation("io.papermc:paperlib:1.0.7") 50 | implementation("co.aikar:idb-core:1.0.0-SNAPSHOT") 51 | implementation("com.zaxxer:HikariCP:5.1.0") 52 | implementation("com.github.retrooper.packetevents:spigot:2.3.0") 53 | implementation("org.bstats:bstats-bukkit:3.0.2") 54 | compileOnly("com.github.N0RSKA:DeluxeSellwandsAPI:32c") 55 | compileOnly("com.ghostchu:quickshop-api:5.2.0.8") 56 | compileOnly("com.google.guava:guava:33.2.0-jre") 57 | compileOnly("net.milkbowl.vault:VaultAPI:1.7") 58 | compileOnly("com.sk89q.worldguard:worldguard-bukkit:7.0.9") 59 | compileOnly("com.github.TechFortress:GriefPrevention:16.18.1") 60 | compileOnly("me.clip:placeholderapi:2.11.5") 61 | compileOnly("us.dynmap:dynmap-api:3.4-SNAPSHOT") 62 | compileOnly("net.luckperms:api:5.4") 63 | compileOnly("com.google.auto.service:auto-service:1.1.1") 64 | annotationProcessor("com.google.auto.service:auto-service:1.1.1") 65 | 66 | // Cache2k 67 | val cache2kVersion = "1.2.2.Final" 68 | 69 | implementation("org.cache2k:cache2k-api:${cache2kVersion}") 70 | runtimeOnly("org.cache2k:cache2k-core:${cache2kVersion}") 71 | } 72 | 73 | tasks { 74 | shadowJar { 75 | archiveFileName.set("${rootProject.name}-${version}.jar") 76 | // for some reason cache2k does not like being relocated, likely due to generative class loading & relocation not playing nice 77 | relocate("co.aikar.locales", "net.crashcraft.crashclaim.aikarlocales") 78 | relocate("co.aikar.commands", "net.crashcraft.crashclaim.acf") 79 | relocate("co.aikar.idb", "net.crashcraft.crashclaim.idb") 80 | relocate("co.aikar.taskchain", "net.crashcraft.crashclaim.taskchain") 81 | relocate("io.papermc.lib", "net.crashcraft.crashclaim.paperlib") 82 | relocate("org.bstats", "net.crashcraft.crashclaim.bstats") 83 | relocate("it.unimi.dsi", "net.crashcraft.crashclaim.fastutil") 84 | relocate("com.zaxxer.hikari", "net.crashcraft.crashclaim.hikari") 85 | relocate("com.github.retrooper.packetevents", "net.crashcraft.crashclaim.packetevents.api") 86 | relocate("io.github.retrooper.packetevents", "net.crashcraft.crashclaim.packetevents.impl") 87 | relocate("net.wesjd", "net.crashcraft.crashclaim.anvilgui") 88 | 89 | exclude("/com/google/gson/**") 90 | exclude("/org/intellij/**") 91 | exclude("/org/jetbrains/**") 92 | exclude("/org/slf4j/**") 93 | } 94 | 95 | build { 96 | dependsOn(shadowJar) 97 | dependsOn(publishToMavenLocal) 98 | } 99 | 100 | assemble { 101 | dependsOn(shadowJar) 102 | dependsOn(publishToMavenLocal) 103 | } 104 | 105 | compileJava { 106 | dependsOn(clean) 107 | } 108 | 109 | processResources { 110 | expand(project.properties) 111 | } 112 | } 113 | 114 | group = "net.crashcraft" 115 | version = findProperty("version")!! 116 | description = "CrashClaim" 117 | java.sourceCompatibility = JavaVersion.VERSION_21 118 | 119 | publishing { 120 | publications { 121 | create("maven") { 122 | from(components["java"]) 123 | } 124 | } 125 | } 126 | 127 | tasks.withType { 128 | options.encoding = "UTF-8" 129 | } -------------------------------------------------------------------------------- /gradle.properties: -------------------------------------------------------------------------------- 1 | version = 1.0.42 2 | -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/WhipDevelopment/CrashClaim/d3bf1dfcc8728d5d20acba0bcebc4bb1f51b99e6/gradle/wrapper/gradle-wrapper.jar -------------------------------------------------------------------------------- /gradle/wrapper/gradle-wrapper.properties: -------------------------------------------------------------------------------- 1 | distributionBase=GRADLE_USER_HOME 2 | distributionPath=wrapper/dists 3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip 4 | zipStoreBase=GRADLE_USER_HOME 5 | zipStorePath=wrapper/dists 6 | -------------------------------------------------------------------------------- /gradlew.bat: -------------------------------------------------------------------------------- 1 | @rem 2 | @rem Copyright 2015 the original author or authors. 3 | @rem 4 | @rem Licensed under the Apache License, Version 2.0 (the "License"); 5 | @rem you may not use this file except in compliance with the License. 6 | @rem You may obtain a copy of the License at 7 | @rem 8 | @rem https://www.apache.org/licenses/LICENSE-2.0 9 | @rem 10 | @rem Unless required by applicable law or agreed to in writing, software 11 | @rem distributed under the License is distributed on an "AS IS" BASIS, 12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | @rem See the License for the specific language governing permissions and 14 | @rem limitations under the License. 15 | @rem 16 | 17 | @if "%DEBUG%" == "" @echo off 18 | @rem ########################################################################## 19 | @rem 20 | @rem Gradle startup script for Windows 21 | @rem 22 | @rem ########################################################################## 23 | 24 | @rem Set local scope for the variables with windows NT shell 25 | if "%OS%"=="Windows_NT" setlocal 26 | 27 | set DIRNAME=%~dp0 28 | if "%DIRNAME%" == "" set DIRNAME=. 29 | set APP_BASE_NAME=%~n0 30 | set APP_HOME=%DIRNAME% 31 | 32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter. 33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi 34 | 35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. 36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" 37 | 38 | @rem Find java.exe 39 | if defined JAVA_HOME goto findJavaFromJavaHome 40 | 41 | set JAVA_EXE=java.exe 42 | %JAVA_EXE% -version >NUL 2>&1 43 | if "%ERRORLEVEL%" == "0" goto execute 44 | 45 | echo. 46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 47 | echo. 48 | echo Please set the JAVA_HOME variable in your environment to match the 49 | echo location of your Java installation. 50 | 51 | goto fail 52 | 53 | :findJavaFromJavaHome 54 | set JAVA_HOME=%JAVA_HOME:"=% 55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe 56 | 57 | if exist "%JAVA_EXE%" goto execute 58 | 59 | echo. 60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 61 | echo. 62 | echo Please set the JAVA_HOME variable in your environment to match the 63 | echo location of your Java installation. 64 | 65 | goto fail 66 | 67 | :execute 68 | @rem Setup the command line 69 | 70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar 71 | 72 | 73 | @rem Execute Gradle 74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* 75 | 76 | :end 77 | @rem End local scope for the variables with windows NT shell 78 | if "%ERRORLEVEL%"=="0" goto mainEnd 79 | 80 | :fail 81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of 82 | rem the _cmd.exe /c_ return code! 83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 84 | exit /b 1 85 | 86 | :mainEnd 87 | if "%OS%"=="Windows_NT" endlocal 88 | 89 | :omega 90 | -------------------------------------------------------------------------------- /jitpack.yml: -------------------------------------------------------------------------------- 1 | jdk: openjdk17 2 | before_install: 3 | - source "$HOME/.sdkman/bin/sdkman-init.sh" 4 | - sdk update 5 | - sdk install java 17.0.1-open 6 | - sdk use java 17.0.1-open -------------------------------------------------------------------------------- /settings.gradle.kts: -------------------------------------------------------------------------------- 1 | rootProject.name = "CrashClaim" 2 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/BaseClaim.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.localization.Localization; 5 | import net.md_5.bungee.api.chat.BaseComponent; 6 | 7 | import java.util.UUID; 8 | 9 | public abstract class BaseClaim { 10 | private final int id; 11 | 12 | private int minCornerX; 13 | private int minCornerZ; 14 | private int maxCornerX; 15 | private int maxCornerZ; 16 | 17 | private final UUID world; 18 | 19 | private final PermissionGroup perms; 20 | 21 | private String name; 22 | private String entryMessage; 23 | private BaseComponent[] parsedEntryMessage; // Cached for efficiency 24 | private String exitMessage; 25 | private BaseComponent[] parsedExitMessage; // Cached for efficiency 26 | 27 | private boolean isEditing = false; 28 | private boolean deleted = false; 29 | 30 | public BaseClaim(int id, int maxCornerX, int maxCornerZ, int minCornerX, int minCornerZ, UUID world, PermissionGroup perms) { 31 | this.id = id; 32 | this.maxCornerX = maxCornerX; 33 | this.maxCornerZ = maxCornerZ; 34 | this.minCornerX = minCornerX; 35 | this.minCornerZ = minCornerZ; 36 | this.world = world; 37 | this.perms = perms; 38 | } 39 | 40 | public void setToSave(boolean toSave){ 41 | throw new RuntimeException("Not implemented"); 42 | } 43 | 44 | public boolean isToSave(){ 45 | throw new RuntimeException("Not implemented"); 46 | } 47 | 48 | public int getId() { 49 | return id; 50 | } 51 | 52 | public int getMinX() { 53 | return minCornerX; 54 | } 55 | 56 | public int getMinZ() { 57 | return minCornerZ; 58 | } 59 | 60 | public int getMaxX() { 61 | return maxCornerX; 62 | } 63 | 64 | public int getMaxZ() { 65 | return maxCornerZ; 66 | } 67 | 68 | public UUID getWorld() { 69 | return world; 70 | } 71 | 72 | public PermissionGroup getPerms() { 73 | return perms; 74 | } 75 | 76 | public boolean isEditing() { 77 | return isEditing; 78 | } 79 | 80 | public void setEditing(boolean editing) { 81 | isEditing = editing; 82 | } 83 | 84 | public String getName() { 85 | return name == null ? 86 | Localization.NEW_CLAIM__DEFAULT_CLAIM_NAME.getRawMessage().replace("", Integer.toString(id)) : name; 87 | } 88 | 89 | public String getEntryMessage() { 90 | return entryMessage; 91 | } 92 | 93 | public String getExitMessage() { 94 | return exitMessage; 95 | } 96 | 97 | public void setName(String name) { 98 | this.name = name; 99 | setToSave(true); 100 | } 101 | 102 | public void setEntryMessage(String entryMessage) { 103 | this.entryMessage = entryMessage; 104 | this.parsedEntryMessage = entryMessage == null ? null : Localization.parseRawUserInput(entryMessage); 105 | setToSave(true); 106 | } 107 | 108 | public void setExitMessage(String exitMessage) { 109 | this.exitMessage = exitMessage; 110 | this.parsedExitMessage = exitMessage == null ? null : Localization.parseRawUserInput(exitMessage); 111 | setToSave(true); 112 | } 113 | 114 | public void setMinCornerX(int minCornerX) { 115 | this.minCornerX = minCornerX; 116 | } 117 | 118 | public void setMinCornerZ(int minCornerZ) { 119 | this.minCornerZ = minCornerZ; 120 | } 121 | 122 | public void setMaxCornerX(int maxCornerX) { 123 | this.maxCornerX = maxCornerX; 124 | } 125 | 126 | public void setMaxCornerZ(int maxCornerZ) { 127 | this.maxCornerZ = maxCornerZ; 128 | } 129 | 130 | public boolean isDeleted() { 131 | return deleted; 132 | } 133 | 134 | public void setDeleted() { 135 | this.deleted = true; 136 | } 137 | 138 | public BaseComponent[] getParsedEntryMessage() { 139 | return parsedEntryMessage; 140 | } 141 | 142 | public BaseComponent[] getParsedExitMessage() { 143 | return parsedExitMessage; 144 | } 145 | } 146 | 147 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/PermState.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects; 2 | 3 | public class PermState { 4 | public static final int DISABLE = 0; 5 | public static final int ENABLED = 1; 6 | public static final int NEUTRAL = 2; 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/PermissionGroup.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.permission.GlobalPermissionSet; 4 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 5 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 6 | import org.bukkit.Material; 7 | 8 | import java.util.HashMap; 9 | import java.util.UUID; 10 | 11 | public abstract class PermissionGroup { 12 | /** 13 | * Base Claim will have all perms 14 | * Sub Claim will have all perms except for admin as that gets inherited 15 | */ 16 | 17 | private GlobalPermissionSet globalPermissionSet; 18 | 19 | private HashMap playerPermissions; 20 | 21 | private BaseClaim owner; 22 | 23 | public PermissionGroup(){ 24 | 25 | } 26 | 27 | public PermissionGroup(BaseClaim owner, GlobalPermissionSet globalPermissionSet, HashMap playerPermissions) { 28 | this.owner = owner; 29 | this.globalPermissionSet = globalPermissionSet == null ? 30 | createGlobalPermissionSet() : globalPermissionSet; 31 | this.playerPermissions = playerPermissions == null ? new HashMap<>() : playerPermissions; 32 | } 33 | 34 | public abstract PlayerPermissionSet createPlayerPermissionSet(); 35 | 36 | public abstract GlobalPermissionSet createGlobalPermissionSet(); 37 | 38 | public abstract int checkGlobalValue(int value, PermissionRoute route); 39 | 40 | public abstract int checkPlayerValue(int value, PermissionRoute route); 41 | 42 | public GlobalPermissionSet getGlobalPermissionSet() { 43 | return globalPermissionSet; 44 | } 45 | 46 | public PlayerPermissionSet getPlayerPermissionSet(UUID id) { 47 | if (playerPermissions.containsKey(id)) { 48 | return playerPermissions.get(id); 49 | } else { 50 | PlayerPermissionSet set = createPlayerPermissionSet(); 51 | 52 | playerPermissions.put(id, set); 53 | 54 | return set; 55 | } 56 | } 57 | 58 | //Used for fixing owner permissions only 59 | public void setPlayerPermissionSet(UUID uuid, PlayerPermissionSet permissionSet) { 60 | playerPermissions.put(uuid, permissionSet); 61 | owner.setToSave(true); 62 | } 63 | 64 | public HashMap getPlayerPermissions(){ 65 | return playerPermissions; 66 | } 67 | 68 | public void setOwner(BaseClaim owner){ 69 | this.owner = owner; 70 | } 71 | 72 | public BaseClaim getOwner() { 73 | return owner; 74 | } 75 | 76 | public void setPermission(PermissionRoute route, int value){ 77 | route.setPerm(globalPermissionSet, checkGlobalValue(value, route)); 78 | owner.setToSave(true); 79 | } 80 | 81 | public void setPlayerPermission(UUID uuid, PermissionRoute route, int value){ 82 | route.setPerm(getPlayerPermissionSet(uuid), checkPlayerValue(value, route)); 83 | owner.setToSave(true); 84 | route.postSetPayload(this, route.getPerm(getPlayerPermissionSet(uuid)), uuid); 85 | } 86 | 87 | public void setContainerPermission(int value, Material material){ 88 | PermissionRoute.CONTAINERS.setPerm(globalPermissionSet, checkGlobalValue(value, PermissionRoute.CONTAINERS), material); 89 | owner.setToSave(true); 90 | } 91 | 92 | public void setContainerPlayerPermission(UUID uuid, int value, Material material) { 93 | PermissionRoute.CONTAINERS.setPerm(getPlayerPermissionSet(uuid), checkPlayerValue(value, PermissionRoute.CONTAINERS), material); 94 | owner.setToSave(true); 95 | } 96 | 97 | //JSON needs this 98 | 99 | public void setGlobalPermissionSet(GlobalPermissionSet globalPermissionSet) { 100 | this.globalPermissionSet = globalPermissionSet; 101 | } 102 | 103 | public void setPlayerPermissions(HashMap playerPermissions) { 104 | this.playerPermissions = playerPermissions; 105 | } 106 | } 107 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/SubClaim.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects; 2 | 3 | import java.util.UUID; 4 | 5 | public class SubClaim extends BaseClaim { 6 | private final Claim parent; 7 | 8 | public SubClaim(Claim parent, int id, int upperCornerX, int upperCornerY, int lowerCornerX, int lowerCornerY, UUID world, PermissionGroup perms) { 9 | super(id, upperCornerX, upperCornerY, lowerCornerX, lowerCornerY, world, perms); 10 | this.parent = parent; 11 | } 12 | 13 | @Override 14 | public void setToSave(boolean toSave) { 15 | if (parent == null){ 16 | // Needed for json setting this should never happen after load 17 | return; 18 | } 19 | parent.setToSave(true); 20 | } 21 | 22 | @Override 23 | public boolean isToSave() { 24 | return parent.isToSave(); 25 | } 26 | 27 | @Override 28 | public UUID getWorld(){ 29 | return parent.getWorld(); 30 | } 31 | 32 | public Claim getParent() { 33 | return parent; 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/permission/GlobalPermissionSet.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects.permission; 2 | 3 | import org.bukkit.Material; 4 | 5 | import java.util.HashMap; 6 | 7 | public class GlobalPermissionSet extends PermissionSet { 8 | private int pistons; 9 | private int fluids; 10 | private int explosions; 11 | private int entityGrief; 12 | 13 | public GlobalPermissionSet() { 14 | 15 | } 16 | 17 | public GlobalPermissionSet(int build, int interactions, int entities, int explosions, int entityGrief, int teleportation, int viewSubClaims, HashMap containers, int defaultContainerValue, int pistons, int fluids) { 18 | super(build, interactions, entities, teleportation, viewSubClaims, containers, defaultContainerValue); 19 | this.entityGrief = entityGrief; 20 | this.pistons = pistons; 21 | this.explosions = explosions; 22 | this.fluids = fluids; 23 | } 24 | 25 | public int getPistons() { 26 | return pistons; 27 | } 28 | 29 | public void setPistons(int pistons) { 30 | this.pistons = pistons; 31 | } 32 | 33 | public int getFluids() { 34 | return fluids; 35 | } 36 | 37 | public void setFluids(int fluids) { 38 | this.fluids = fluids; 39 | } 40 | 41 | public int getExplosions() { 42 | return explosions; 43 | } 44 | 45 | public void setExplosions(int explosions) { 46 | this.explosions = explosions; 47 | } 48 | 49 | public int getEntityGrief() { 50 | return entityGrief; 51 | } 52 | 53 | public void setEntityGrief(int entityGrief) { 54 | this.entityGrief = entityGrief; 55 | } 56 | 57 | @Override 58 | public void setContainer(Material material, int value) { 59 | super.setContainer(material, value); 60 | } 61 | 62 | @Override 63 | public void setBuild(int build) { 64 | super.setBuild(build); 65 | } 66 | 67 | @Override 68 | public void setInteractions(int interactions) { 69 | super.setInteractions(interactions); 70 | } 71 | 72 | @Override 73 | public void setEntities(int entities) { 74 | super.setEntities(entities); 75 | } 76 | 77 | @Override 78 | public void setTeleportation(int teleportation) { 79 | super.setTeleportation(teleportation); 80 | } 81 | 82 | @Override 83 | public void setViewSubClaims(int viewSubClaims) { 84 | super.setViewSubClaims(viewSubClaims); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/permission/PermissionSet.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects.permission; 2 | 3 | import org.bukkit.Material; 4 | 5 | import java.util.HashMap; 6 | 7 | public abstract class PermissionSet implements Cloneable{ 8 | private int build; 9 | private int interactions; 10 | private int entities; 11 | private int teleportation; 12 | private int viewSubClaims; 13 | 14 | private HashMap containers; 15 | private int defaultContainerValue; 16 | 17 | public PermissionSet(){ 18 | 19 | } 20 | 21 | public PermissionSet(int build, int interactions, int entities, int teleportation, int viewSubClaims, HashMap containers, int defaultContainerValue) { 22 | this.build = build; 23 | this.interactions = interactions; 24 | this.entities = entities; 25 | this.teleportation = teleportation; 26 | this.viewSubClaims = viewSubClaims; 27 | this.containers = containers; 28 | this.defaultContainerValue = defaultContainerValue; 29 | } 30 | 31 | public int getBuild() { 32 | return build; 33 | } 34 | 35 | public void setBuild(int build) { 36 | this.build = build; 37 | } 38 | 39 | public int getInteractions() { 40 | return interactions; 41 | } 42 | 43 | public void setInteractions(int interactions) { 44 | this.interactions = interactions; 45 | } 46 | 47 | public int getEntities() { 48 | return entities; 49 | } 50 | 51 | public void setEntities(int entities) { 52 | this.entities = entities; 53 | } 54 | 55 | public int getTeleportation() { 56 | return teleportation; 57 | } 58 | 59 | public void setTeleportation(int teleportation) { 60 | this.teleportation = teleportation; 61 | } 62 | 63 | public int getViewSubClaims() { 64 | return viewSubClaims; 65 | } 66 | 67 | public void setViewSubClaims(int viewSubClaims) { 68 | this.viewSubClaims = viewSubClaims; 69 | } 70 | 71 | public void setContainer(Material material, int value){ 72 | this.containers.put(material, value); 73 | } 74 | 75 | public HashMap getContainers() { 76 | return containers; 77 | } 78 | 79 | public PermissionSet clone() { 80 | try { 81 | return (PermissionSet) super.clone(); 82 | } catch (CloneNotSupportedException e){ 83 | e.printStackTrace(); 84 | } 85 | return null; 86 | } 87 | 88 | public int getDefaultConatinerValue() { 89 | return defaultContainerValue; 90 | } 91 | 92 | public void setDefaultConatinerValue(int defaultContainerValue) { 93 | this.defaultContainerValue = defaultContainerValue; 94 | } 95 | } 96 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/permission/PlayerPermissionSet.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects.permission; 2 | 3 | import org.bukkit.Material; 4 | 5 | import java.util.HashMap; 6 | 7 | public class PlayerPermissionSet extends PermissionSet implements Cloneable { 8 | private int modifyPermissions; 9 | private int modifyClaim; 10 | 11 | public PlayerPermissionSet() { 12 | 13 | } 14 | 15 | public PlayerPermissionSet(int build, int interactions, int entities, int explosions, int teleportation, int viewSubClaims, HashMap containers, int defaultContainerValue, int modifyPermissions, int modifyClaim) { 16 | super(build, interactions, entities, teleportation, viewSubClaims, containers, defaultContainerValue); 17 | this.modifyPermissions = modifyPermissions; 18 | this.modifyClaim = modifyClaim; 19 | } 20 | 21 | public int getModifyPermissions() { 22 | return modifyPermissions; 23 | } 24 | 25 | public void setModifyPermissions(int modifyPermissions) { 26 | this.modifyPermissions = modifyPermissions; 27 | } 28 | 29 | public int getModifyClaim() { 30 | return modifyClaim; 31 | } 32 | 33 | public void setModifyClaim(int modifyClaim) { 34 | this.modifyClaim = modifyClaim; 35 | } 36 | 37 | public PlayerPermissionSet clone() { 38 | return (PlayerPermissionSet) super.clone(); 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/permission/child/SubPermissionGroup.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects.permission.child; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.claimobjects.PermState; 5 | import net.crashcraft.crashclaim.claimobjects.PermissionGroup; 6 | import net.crashcraft.crashclaim.claimobjects.permission.GlobalPermissionSet; 7 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 8 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 9 | 10 | import java.util.HashMap; 11 | import java.util.UUID; 12 | 13 | public class SubPermissionGroup extends PermissionGroup { 14 | public SubPermissionGroup() { 15 | 16 | } 17 | 18 | public SubPermissionGroup(BaseClaim owner, GlobalPermissionSet globalPermissionSet, HashMap playerPermissions) { 19 | super(owner, globalPermissionSet, playerPermissions); 20 | } 21 | 22 | @Override 23 | public PlayerPermissionSet createPlayerPermissionSet() { 24 | return new PlayerPermissionSet(PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, 25 | PermState.NEUTRAL, new HashMap<>(), PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL); 26 | } 27 | 28 | @Override 29 | public GlobalPermissionSet createGlobalPermissionSet() { 30 | return new GlobalPermissionSet(PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, 31 | PermState.NEUTRAL, new HashMap<>(), PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL); 32 | } 33 | 34 | @Override 35 | public int checkGlobalValue(int value, PermissionRoute route) { 36 | return value; 37 | } 38 | 39 | @Override 40 | public int checkPlayerValue(int value, PermissionRoute route) { 41 | return value; 42 | } 43 | 44 | //JSON needs this 45 | 46 | 47 | } 48 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/claimobjects/permission/parent/ParentPermissionGroup.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.claimobjects.permission.parent; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.claimobjects.PermState; 5 | import net.crashcraft.crashclaim.claimobjects.PermissionGroup; 6 | import net.crashcraft.crashclaim.claimobjects.permission.GlobalPermissionSet; 7 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 8 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 9 | 10 | import java.util.HashMap; 11 | import java.util.UUID; 12 | 13 | public class ParentPermissionGroup extends PermissionGroup { 14 | public ParentPermissionGroup() { 15 | 16 | } 17 | 18 | public ParentPermissionGroup(BaseClaim owner, GlobalPermissionSet globalPermissionSet, HashMap playerPermissions) { 19 | super(owner, globalPermissionSet, playerPermissions); 20 | } 21 | 22 | @Override 23 | public PlayerPermissionSet createPlayerPermissionSet() { 24 | return new PlayerPermissionSet(PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, PermState.NEUTRAL, 25 | new HashMap<>(), PermState.NEUTRAL, PermState.DISABLE, PermState.DISABLE); 26 | } 27 | 28 | @Override 29 | public GlobalPermissionSet createGlobalPermissionSet() { 30 | return new GlobalPermissionSet(PermState.DISABLE, PermState.DISABLE, PermState.DISABLE, PermState.DISABLE, PermState.DISABLE, PermState.ENABLED, PermState.ENABLED, 31 | new HashMap<>(), PermState.DISABLE, PermState.DISABLE, PermState.DISABLE); 32 | } 33 | 34 | @Override 35 | public int checkGlobalValue(int value, PermissionRoute route) { 36 | if (value == PermState.NEUTRAL) { 37 | return PermState.DISABLE; 38 | } else { 39 | return value; 40 | } 41 | } 42 | 43 | @Override 44 | public int checkPlayerValue(int value, PermissionRoute route) { 45 | switch (route){ 46 | case MODIFY_CLAIM: 47 | case MODIFY_PERMISSIONS: 48 | if (value == PermState.NEUTRAL) { 49 | return PermState.DISABLE; 50 | } else { 51 | return value; 52 | } 53 | default: 54 | return value; 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/BypassCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandPermission; 6 | import net.crashcraft.crashclaim.localization.Localization; 7 | import net.crashcraft.crashclaim.permissions.BypassManager; 8 | import org.bukkit.entity.Player; 9 | 10 | public class BypassCommand extends BaseCommand { 11 | private final BypassManager manager; 12 | 13 | public BypassCommand(BypassManager manager){ 14 | this.manager = manager; 15 | } 16 | 17 | @CommandAlias("bypassClaims") 18 | @CommandPermission("crashclaim.admin.bypass") 19 | public void onByp(Player player){ 20 | if (manager.toggleBypass(player.getUniqueId())){ 21 | player.spigot().sendMessage(Localization.BYPASS__ENABLED.getMessage(player)); 22 | } else { 23 | player.spigot().sendMessage(Localization.BYPASS__DISABLED.getMessage(player)); 24 | } 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/ClaimInfoCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandPermission; 6 | import co.aikar.commands.annotation.Default; 7 | import net.crashcraft.crashclaim.CrashClaim; 8 | import net.crashcraft.crashclaim.claimobjects.Claim; 9 | import net.crashcraft.crashclaim.claimobjects.PermState; 10 | import net.crashcraft.crashclaim.claimobjects.permission.GlobalPermissionSet; 11 | import net.crashcraft.crashclaim.data.ClaimDataManager; 12 | import net.crashcraft.crashclaim.localization.Localization; 13 | import net.crashcraft.crashclaim.localization.LocalizationUtils; 14 | import org.bukkit.Bukkit; 15 | import org.bukkit.Location; 16 | import org.bukkit.Material; 17 | import org.bukkit.entity.Player; 18 | 19 | import java.util.Map; 20 | 21 | @CommandAlias("claiminfo") 22 | @CommandPermission("crashclaim.admin.claiminfo") 23 | public class ClaimInfoCommand extends BaseCommand { 24 | private final ClaimDataManager manager; 25 | 26 | public ClaimInfoCommand(ClaimDataManager manager){ 27 | this.manager = manager; 28 | } 29 | 30 | @Default 31 | public void onClaimInfo(Player player){ 32 | Location location = player.getLocation(); 33 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 34 | if (claim != null){ 35 | GlobalPermissionSet set = claim.getPerms().getGlobalPermissionSet(); 36 | 37 | final String enabled = Localization.CLAIM_INFO__STATUS_ENABLED.getRawMessage(); 38 | final String disabled = Localization.CLAIM_INFO__STATUS_DISABLED.getRawMessage(); 39 | 40 | LocalizationUtils.sendMessageList(player, Localization.CLAIM_INFO__MESSAGE.getMessageList( 41 | player, 42 | "min_x", Integer.toString(claim.getMinX()), 43 | "min_z", Integer.toString(claim.getMinZ()), 44 | "max_x", Integer.toString(claim.getMaxX()), 45 | "max_z", Integer.toString(claim.getMaxZ()), 46 | "id", Integer.toString(claim.getId()), 47 | "name", claim.getName(), 48 | "owner", Bukkit.getOfflinePlayer(claim.getOwner()).getName(), 49 | "build_status", set.getBuild() == PermState.ENABLED ? enabled : disabled, 50 | "entities_status", set.getEntities() == PermState.ENABLED ? enabled : disabled, 51 | "interactions_status", set.getInteractions() == PermState.ENABLED ? enabled : disabled, 52 | "view_sub_claims_status", set.getViewSubClaims() == PermState.ENABLED ? enabled : disabled, 53 | "teleportation_status", set.getTeleportation() == PermState.ENABLED ? enabled : disabled, 54 | "explosions_status", set.getExplosions() == PermState.ENABLED ? enabled : disabled, 55 | "fluids_status", set.getFluids() == PermState.ENABLED ? enabled : disabled, 56 | "pistons_status", set.getPistons() == PermState.ENABLED ? enabled : disabled 57 | )); 58 | 59 | for (Map.Entry entry :set.getContainers().entrySet()) { 60 | player.spigot().sendMessage(Localization.CLAIM_INFO__CONTAINER_MESSAGE.getMessage( 61 | player, 62 | "name", CrashClaim.getPlugin().getMaterialName().getMaterialName(entry.getKey()), 63 | "status", entry.getValue() == PermState.ENABLED ? enabled : disabled 64 | )); 65 | } 66 | } else { 67 | player.spigot().sendMessage(Localization.CLAIM_INFO__NO_CLAIM.getMessage(player)); 68 | } 69 | } 70 | } 71 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/CommandManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.PaperCommandManager; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.commands.claiming.ClaimCommand; 6 | import net.crashcraft.crashclaim.commands.claiming.UnClaimCommand; 7 | import net.crashcraft.crashclaim.data.ClaimDataManager; 8 | import net.crashcraft.crashclaim.migration.MigrationAdapter; 9 | import net.crashcraft.crashclaim.permissions.BypassManager; 10 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 11 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 12 | 13 | import java.util.ArrayList; 14 | 15 | public class CommandManager { 16 | private final PaperCommandManager commandManager; 17 | private final CrashClaim plugin; 18 | 19 | public CommandManager(CrashClaim plugin) { 20 | this.plugin = plugin; 21 | 22 | this.commandManager = new PaperCommandManager(plugin); 23 | 24 | loadCommandCompletions(); 25 | loadCommands(); 26 | } 27 | 28 | private void loadCommands(){ 29 | ClaimDataManager manager = plugin.getDataManager(); 30 | BypassManager bypassManager = PermissionHelper.getPermissionHelper().getBypassManager(); 31 | VisualizationManager visualizationManager = plugin.getVisualizationManager(); 32 | 33 | commandManager.registerCommand(new ShowClaimsCommand(visualizationManager, manager)); 34 | commandManager.registerCommand(new HideClaimsCommand(visualizationManager)); 35 | 36 | commandManager.registerCommand(new ClaimCommand(manager, visualizationManager)); 37 | commandManager.registerCommand(new UnClaimCommand(manager, visualizationManager)); 38 | 39 | 40 | commandManager.registerCommand(new MenuCommand(manager, visualizationManager)); 41 | commandManager.registerCommand(new BypassCommand(bypassManager)); 42 | commandManager.registerCommand(new ClaimInfoCommand(manager)); 43 | commandManager.registerCommand(new EjectCommand(manager)); 44 | commandManager.registerCommand(new AdminCommand(plugin, plugin.getMigrationManager())); 45 | } 46 | 47 | private void loadCommandCompletions(){ 48 | ArrayList adapters = plugin.getMigrationManager().getAdapters(); 49 | String[] completions = new String[adapters.size()]; 50 | 51 | for (int x = 0; x < completions.length; x++){ 52 | completions[x] = adapters.get(x).getIdentifier(); 53 | } 54 | 55 | commandManager.getCommandCompletions().registerStaticCompletion("migrators", completions); 56 | } 57 | 58 | public PaperCommandManager getCommandManager() { 59 | return commandManager; 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/EjectCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandCompletion; 6 | import co.aikar.commands.annotation.CommandPermission; 7 | import co.aikar.commands.annotation.Default; 8 | import co.aikar.commands.annotation.Flags; 9 | import io.papermc.lib.PaperLib; 10 | import net.crashcraft.crashclaim.CrashClaim; 11 | import net.crashcraft.crashclaim.claimobjects.Claim; 12 | import net.crashcraft.crashclaim.config.GlobalConfig; 13 | import net.crashcraft.crashclaim.data.ClaimDataManager; 14 | import net.crashcraft.crashclaim.localization.Localization; 15 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 16 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 17 | import org.bukkit.Location; 18 | import org.bukkit.World; 19 | import org.bukkit.entity.Player; 20 | 21 | @CommandAlias("claimeject|eject") 22 | @CommandPermission("crashclaim.user.claimeject") 23 | public class EjectCommand extends BaseCommand { 24 | private final ClaimDataManager manager; 25 | 26 | public EjectCommand(ClaimDataManager manager){ 27 | this.manager = manager; 28 | } 29 | 30 | @Default 31 | @CommandCompletion("@players @nothing") 32 | public void onDefault(Player player, @Flags("other") String value){ 33 | Player otherPlayer = CrashClaim.getPlugin().getServer().getPlayer(value); 34 | 35 | if (otherPlayer == null) { 36 | player.spigot().sendMessage(Localization.EJECT__INVALID_PLAYER.getMessage(player)); 37 | return; 38 | } 39 | 40 | Location location = player.getLocation(); 41 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 42 | if (claim != null){ 43 | if (!PermissionHelper.getPermissionHelper().hasPermission(player.getUniqueId(), player.getLocation(), PermissionRoute.MODIFY_PERMISSIONS)){ 44 | player.spigot().sendMessage(Localization.EJECT__NO_PERMISSION.getMessage(player)); 45 | return; 46 | } 47 | 48 | Location otherLocation = otherPlayer.getLocation(); 49 | Claim otherClaim = manager.getClaim(otherLocation.getBlockX(), otherLocation.getBlockZ(), otherLocation.getWorld().getUID()); 50 | 51 | if (!claim.equals(otherClaim)){ 52 | player.spigot().sendMessage(Localization.EJECT__NOT_SAME_CLAIM.getMessage(player)); 53 | return; 54 | } 55 | 56 | if (PermissionHelper.getPermissionHelper().hasPermission(otherPlayer.getUniqueId(), otherPlayer.getLocation(), PermissionRoute.MODIFY_PERMISSIONS)){ 57 | player.spigot().sendMessage(Localization.EJECT__HAS_PERMISSION.getMessage(player)); 58 | return; 59 | } 60 | 61 | if (GlobalConfig.useCommandInsteadOfEdgeEject){ 62 | otherPlayer.performCommand(GlobalConfig.claimEjectCommand); 63 | } else { 64 | int distMax = Math.abs(location.getBlockX() - claim.getMaxX()); 65 | int distMin = Math.abs(location.getBlockX() - claim.getMinX()); 66 | 67 | World world = location.getWorld(); 68 | if (distMax > distMin) { //Find closest side 69 | PaperLib.teleportAsync(otherPlayer, new Location(world, claim.getMinX() - 1, 70 | world.getHighestBlockYAt(claim.getMinX() - 1, 71 | location.getBlockZ()), location.getBlockZ())); 72 | } else { 73 | PaperLib.teleportAsync(otherPlayer, new Location(world, claim.getMaxX() + 1, 74 | world.getHighestBlockYAt(claim.getMaxX() + 1, 75 | location.getBlockZ()), location.getBlockZ())); 76 | } 77 | } 78 | 79 | otherPlayer.spigot().sendMessage(Localization.EJECT__BEEN_EJECTED.getMessage(otherPlayer)); 80 | player.spigot().sendMessage(Localization.EJECT__SUCCESS.getMessage(player)); 81 | } else { 82 | player.spigot().sendMessage(Localization.EJECT__NO_CLAIM.getMessage(player)); 83 | } 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/HideClaimsCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandPermission; 6 | import co.aikar.commands.annotation.Default; 7 | import net.crashcraft.crashclaim.localization.Localization; 8 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 9 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 10 | import org.bukkit.entity.Player; 11 | 12 | @CommandAlias("hideclaims") 13 | @CommandPermission("crashclaim.user.hideclaims") 14 | public class HideClaimsCommand extends BaseCommand { 15 | private final VisualizationManager visualizationManager; 16 | 17 | public HideClaimsCommand(VisualizationManager visualizationManager){ 18 | this.visualizationManager = visualizationManager; 19 | } 20 | 21 | @Default 22 | public void onHide(Player player){ 23 | VisualGroup group = visualizationManager.fetchVisualGroup(player, false); 24 | 25 | if (group != null){ 26 | group.removeAllVisuals(); 27 | 28 | player.spigot().sendMessage(Localization.HIDE_CLAIMS__SUCCESS.getMessage(player)); 29 | } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/MenuCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandPermission; 6 | import net.crashcraft.crashclaim.CrashClaim; 7 | import net.crashcraft.crashclaim.claimobjects.Claim; 8 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 9 | import net.crashcraft.crashclaim.config.GlobalConfig; 10 | import net.crashcraft.crashclaim.crashutils.menusystem.defaultmenus.ConfirmationMenu; 11 | import net.crashcraft.crashclaim.data.ClaimDataManager; 12 | import net.crashcraft.crashclaim.localization.Localization; 13 | import net.crashcraft.crashclaim.menus.ClaimMenu; 14 | import net.crashcraft.crashclaim.menus.list.ClaimListMenu; 15 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 16 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 17 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 18 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 19 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 20 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 21 | import org.bukkit.Location; 22 | import org.bukkit.Material; 23 | import org.bukkit.entity.Player; 24 | import org.bukkit.inventory.ItemStack; 25 | 26 | public class MenuCommand extends BaseCommand { 27 | private final ClaimDataManager manager; 28 | private final VisualizationManager visualizationManager; 29 | 30 | public MenuCommand(ClaimDataManager manager, VisualizationManager visualizationManager){ 31 | this.manager = manager; 32 | this.visualizationManager = visualizationManager; 33 | } 34 | 35 | @CommandAlias("claims") 36 | @CommandPermission("crashclaim.user.claims") 37 | public void onClaimMenu(Player player){ 38 | new ClaimListMenu(player, null).open(); 39 | } 40 | 41 | @CommandAlias("claimsettings") 42 | @CommandPermission("crashclaim.user.claimsettings") 43 | public void onClaimMenuSingle(Player player){ 44 | Location location = player.getLocation(); 45 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 46 | if (claim != null){ 47 | new ClaimMenu(player, claim, null).open(); 48 | } else { 49 | player.spigot().sendMessage(Localization.CLAIM_SETTINGS__NO_CLAIM.getMessage(player)); 50 | } 51 | } 52 | 53 | @CommandAlias("unclaimsubclaim|removesubclaim") 54 | @CommandPermission("crashclaim.user.unclaimsubclaim") 55 | public void unSubClaim(Player player){ 56 | Location location = player.getLocation(); 57 | SubClaim claim = (manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()) != null) 58 | ? manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()).getSubClaim(location.getBlockX(), location.getBlockZ()) : null; 59 | if (claim != null) { 60 | ItemStack message = Localization.UN_SUBCLAIM__MENU__CONFIRMATION__MESSAGE.getItem(player); 61 | message.setType(GlobalConfig.visual_menu_items.getOrDefault(claim.getWorld(), Material.OAK_FENCE)); 62 | 63 | new ConfirmationMenu(player, 64 | Localization.UN_SUBCLAIM__MENU__CONFIRMATION__TITLE.getMessage(player), 65 | message, 66 | Localization.UN_SUBCLAIM__MENU__CONFIRMATION__ACCEPT.getItem(player), 67 | Localization.UN_SUBCLAIM__MENU__CONFIRMATION__DENY.getItem(player), 68 | (p, aBoolean) -> { 69 | if (aBoolean) { 70 | if (PermissionHelper.getPermissionHelper().hasPermission(claim, p.getUniqueId(), PermissionRoute.MODIFY_CLAIM)) { 71 | CrashClaim.getPlugin().getDataManager().deleteSubClaim(claim); 72 | 73 | VisualGroup group = visualizationManager.fetchVisualGroup(player, false); 74 | if (group != null){ 75 | group.removeAllVisuals(); 76 | 77 | BaseVisual visual = visualizationManager.getProvider(p.getUniqueId()).spawnClaimVisual(VisualColor.GREEN, group, claim.getParent(), player.getLocation().getBlockY() - 1); 78 | visual.spawn(); 79 | 80 | visualizationManager.deSpawnAfter(visual, 10); 81 | } 82 | } else { 83 | player.spigot().sendMessage(Localization.UN_SUBCLAIM__MENU__NO_PERMISSION.getMessage(player)); 84 | } 85 | } 86 | return ""; 87 | }, p -> "").open(); 88 | } else { 89 | player.spigot().sendMessage(Localization.UN_SUBCLAIM__MENU__NO_CLAIM.getMessage(player)); 90 | } 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/ShowClaimsCommand.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands; 2 | 3 | import co.aikar.commands.BaseCommand; 4 | import co.aikar.commands.annotation.CommandAlias; 5 | import co.aikar.commands.annotation.CommandPermission; 6 | import co.aikar.commands.annotation.Default; 7 | import co.aikar.commands.annotation.Subcommand; 8 | import net.crashcraft.crashclaim.claimobjects.Claim; 9 | import net.crashcraft.crashclaim.data.ClaimDataManager; 10 | import net.crashcraft.crashclaim.localization.Localization; 11 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 12 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 13 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 14 | import org.bukkit.Location; 15 | import org.bukkit.entity.Player; 16 | 17 | @CommandAlias("show") 18 | public class ShowClaimsCommand extends BaseCommand { 19 | private final VisualizationManager visualizationManager; 20 | private final ClaimDataManager claimDataManager; 21 | 22 | public ShowClaimsCommand(VisualizationManager visualizationManager, ClaimDataManager claimDataManager){ 23 | this.visualizationManager = visualizationManager; 24 | this.claimDataManager = claimDataManager; 25 | } 26 | 27 | @Default 28 | @Subcommand("claims") 29 | @CommandPermission("crashclaim.user.show.claims") 30 | public void showClaims(Player player){ 31 | visualizationManager.visualizeSurroundingClaims(player, claimDataManager); 32 | player.spigot().sendMessage(Localization.SHOW_CLAIMS__SUCCESS.getMessage(player)); 33 | } 34 | 35 | @Subcommand("subclaims") 36 | @CommandPermission("crashclaim.user.show.subclaims") 37 | public void showSubClaims(Player player){ 38 | Location location = player.getLocation(); 39 | Claim claim = claimDataManager.getClaim(location.getBlockX(), location.getBlockZ(), player.getWorld().getUID()); 40 | if (claim != null) { 41 | if (!PermissionHelper.getPermissionHelper().hasPermission(claim, player.getUniqueId(), PermissionRoute.VIEW_SUB_CLAIMS)){ 42 | player.spigot().sendMessage(Localization.SHOW__SUBCLAIM__NO_PERMISSION.getMessage(player)); 43 | return; 44 | } 45 | 46 | if (claim.getSubClaims().size() != 0){ 47 | visualizationManager.visualizeSurroundingSubClaims(claim, player); 48 | } else { 49 | player.spigot().sendMessage(Localization.SHOW__SUBCLAIM__NO_SUBCLAIMS.getMessage(player)); 50 | } 51 | } else { 52 | player.spigot().sendMessage(Localization.SHOW__SUBCLAIM__STAND_INSIDE.getMessage(player)); 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/claiming/ClaimMode.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands.claiming; 2 | 3 | import org.bukkit.Location; 4 | import org.bukkit.entity.Player; 5 | 6 | import java.util.UUID; 7 | 8 | public interface ClaimMode { 9 | void click(Player player, Location click); 10 | 11 | void cleanup(UUID player, boolean visuals); 12 | } 13 | 14 | 15 | /* 16 | CLAIM_NONE, 17 | CLAIM, 18 | CLAIM_RESIZE, 19 | SUB_CLAIM_NONE, 20 | SUB_CLAIM, 21 | SUB_CLAIM_RESIZE 22 | 23 | */ -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/claiming/ClickState.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands.claiming; 2 | 3 | public enum ClickState { 4 | CLAIM, 5 | SUB_CLAIM 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/commands/claiming/modes/NewSubClaimMode.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.commands.claiming.modes; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.Claim; 4 | import net.crashcraft.crashclaim.commands.claiming.ClaimCommand; 5 | import net.crashcraft.crashclaim.commands.claiming.ClaimMode; 6 | import net.crashcraft.crashclaim.data.ClaimDataManager; 7 | import net.crashcraft.crashclaim.data.ClaimResponse; 8 | import net.crashcraft.crashclaim.data.MathUtils; 9 | import net.crashcraft.crashclaim.localization.Localization; 10 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 11 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 12 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 13 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 14 | import net.crashcraft.crashclaim.visualize.api.VisualType; 15 | import org.bukkit.Location; 16 | import org.bukkit.entity.Player; 17 | 18 | import java.util.UUID; 19 | 20 | public class NewSubClaimMode implements ClaimMode { 21 | private final ClaimCommand commandManager; 22 | private final Location firstLocation; 23 | private final VisualizationManager visualizationManager; 24 | private final ClaimDataManager manager; 25 | private final Claim claim; 26 | 27 | public NewSubClaimMode(ClaimCommand commandManager, Player player, Claim claim, Location firstLocation) { 28 | this.commandManager = commandManager; 29 | this.claim = claim; 30 | this.firstLocation = firstLocation; 31 | this.visualizationManager = commandManager.getVisualizationManager(); 32 | this.manager = commandManager.getDataManager(); 33 | 34 | VisualGroup group = visualizationManager.fetchVisualGroup(player, true); 35 | group.removeAllVisualsOfType(VisualType.MARKER); 36 | 37 | visualizationManager.getProvider(player.getUniqueId()).spawnMarkerVisual(VisualColor.YELLOW, group, firstLocation.add(0, 1, 0)).spawn(); 38 | 39 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__CLICK_CORNER.getMessage(player)); 40 | } 41 | 42 | @Override 43 | public void click(Player player, Location click) { 44 | if (!MathUtils.iskPointCollide(claim.getMinX(), claim.getMinZ(), 45 | claim.getMaxX(), claim.getMaxZ(), click.getBlockX(), click.getBlockZ())){ 46 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__NOT_INSIDE_PARENT.getMessage(player)); 47 | cleanup(player.getUniqueId(), true); 48 | return; 49 | } 50 | 51 | ClaimResponse response = manager.createSubClaim(claim, firstLocation, click, player.getUniqueId()); 52 | 53 | if (response.isStatus()){ 54 | VisualGroup group = visualizationManager.fetchVisualGroup(player, true); 55 | 56 | group.removeAllVisuals(); 57 | 58 | visualizationManager.visualizeSurroundingSubClaims(claim, player); 59 | 60 | for (BaseVisual visual : group.getActiveVisuals()){ 61 | visualizationManager.deSpawnAfter(visual, 5); 62 | } 63 | 64 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__SUCCESS.getMessage(player)); 65 | 66 | cleanup(player.getUniqueId(), false); 67 | } else { 68 | switch (response.getError()) { 69 | case TOO_SMALL: 70 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__MIN_AREA.getMessage(player)); 71 | break; 72 | case OUT_OF_BOUNDS: 73 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__NEED_PARENT.getMessage(player)); 74 | break; 75 | case OVERLAP_EXISTING_SUBCLAIM: 76 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__NO_OVERLAP.getMessage(player)); 77 | break; 78 | case GENERIC: 79 | player.spigot().sendMessage(Localization.NEW_SUBCLAIM__ERROR.getMessage(player)); 80 | break; 81 | } 82 | cleanup(player.getUniqueId(), true); 83 | } 84 | } 85 | 86 | @Override 87 | public void cleanup(UUID player, boolean visuals) { 88 | claim.setEditing(false); 89 | 90 | commandManager.forceCleanup(player, visuals); 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/config/BaseConfig.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.config; 2 | 3 | import org.bukkit.Bukkit; 4 | import org.bukkit.Material; 5 | import org.bukkit.configuration.file.YamlConfiguration; 6 | 7 | import java.util.List; 8 | 9 | public abstract class BaseConfig { 10 | public static YamlConfiguration config; 11 | 12 | public static void setConfig(YamlConfiguration config) { 13 | BaseConfig.config = config; 14 | } 15 | 16 | protected static boolean fatalError = false; 17 | 18 | protected static void logError(String s) { 19 | Bukkit.getLogger().severe(config.getName() + ": " + s); 20 | } 21 | 22 | protected static void log(String s) { 23 | Bukkit.getLogger().info(config.getName() + ": " + s); 24 | } 25 | 26 | protected static void fatal(String s) { 27 | fatalError = true; 28 | throw new RuntimeException("Fatal " + config.getName() + ".yml config error: " + s); 29 | } 30 | 31 | protected static void set(String path, Object val) { 32 | config.set(path, val); 33 | } 34 | 35 | protected static boolean getBoolean(String path, boolean def) { 36 | config.addDefault(path, def); 37 | return config.getBoolean(path, config.getBoolean(path)); 38 | } 39 | 40 | protected static double getDouble(String path, double def) { 41 | config.addDefault(path, def); 42 | return config.getDouble(path, config.getDouble(path)); 43 | } 44 | 45 | protected static int getInt(String path, int def) { 46 | config.addDefault(path, def); 47 | return config.getInt(path, config.getInt(path)); 48 | } 49 | 50 | protected static List getList(String path, T def) { 51 | config.addDefault(path, def); 52 | return config.getList(path, config.getList(path)); 53 | } 54 | 55 | protected static List getStringList(String path, List def) { 56 | config.addDefault(path, def); 57 | return config.getStringList(path); 58 | } 59 | 60 | protected static String getString(String path, String def) { 61 | config.addDefault(path, def); 62 | return config.getString(path, config.getString(path)); 63 | } 64 | 65 | protected static int[] getRangedValue(String path, int expected, String def) { 66 | config.addDefault(path, def); 67 | String[] value = config.getString(path).split(":", expected); 68 | int[] arr = new int[expected]; 69 | try { 70 | for (int x = 0; x < arr.length; x++) { 71 | arr[x] = Integer.valueOf(value[x]); 72 | } 73 | } catch (NumberFormatException e) { 74 | logError("Invalid number format for, " + path); 75 | } 76 | return arr; 77 | } 78 | 79 | protected static Material getMaterial(String path, Material def) { 80 | config.addDefault(path, def.name()); 81 | return Material.getMaterial(config.getString(path, config.getString(path))); 82 | } 83 | } 84 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/config/ConfigManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.config; 2 | 3 | import org.bukkit.Bukkit; 4 | import org.bukkit.configuration.InvalidConfigurationException; 5 | import org.bukkit.configuration.file.YamlConfiguration; 6 | 7 | import java.io.File; 8 | import java.io.IOException; 9 | import java.lang.reflect.Method; 10 | import java.lang.reflect.Modifier; 11 | import java.util.logging.Level; 12 | 13 | public class ConfigManager { 14 | public static YamlConfiguration initConfig(File configFile, Class clazz) throws Exception{ 15 | return initConfig(configFile, clazz, null); 16 | } 17 | 18 | public static YamlConfiguration initConfig(File configFile, Class clazz, Object instance) throws Exception{ 19 | if (!configFile.exists()){ 20 | configFile.createNewFile(); 21 | } 22 | 23 | YamlConfiguration config = new YamlConfiguration(); 24 | try { 25 | config.load(configFile); 26 | } catch (InvalidConfigurationException ex) { 27 | throw new Exception("Invalid syntax in config file, " + configFile); 28 | } 29 | config.options().copyDefaults(true); 30 | 31 | BaseConfig.setConfig(config); //Set for each load instance should be fine unless threaded - not thread safe 32 | 33 | return readConfig(clazz, instance, config, configFile); 34 | } 35 | 36 | private static YamlConfiguration readConfig(Class clazz, Object instance, YamlConfiguration config, File file) throws Exception{ //Stole from paper their config system is so sexy 37 | for (Method method : clazz.getDeclaredMethods()) { 38 | if (Modifier.isPrivate(method.getModifiers())) { 39 | if (method.getParameterTypes().length == 0 && method.getReturnType() == Void.TYPE) { 40 | try { 41 | method.setAccessible(true); 42 | method.invoke(instance); 43 | } catch (Exception ex) { 44 | ex.printStackTrace(); 45 | throw new Exception("Failed to instantiate config file: " + file + ", method: " + method); 46 | } 47 | } 48 | } 49 | } 50 | 51 | try { 52 | config.save(file); 53 | } catch (IOException ex) { 54 | Bukkit.getLogger().log(Level.SEVERE, "Could not save " + file, ex); //Not completely fatal will not shut server down 55 | } 56 | 57 | return config; 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/config/GroupSettings.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.config; 2 | 3 | public class GroupSettings { 4 | private final int maxClaims; 5 | 6 | public GroupSettings(int maxClaims) { 7 | this.maxClaims = maxClaims; 8 | } 9 | 10 | public int getMaxClaims() { 11 | return maxClaims; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/CrashUtils.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils; 2 | 3 | import io.papermc.lib.PaperLib; 4 | import net.crashcraft.crashclaim.crashutils.caches.TextureCache; 5 | import net.crashcraft.crashclaim.crashutils.menusystem.CrashMenuController; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.plugin.java.JavaPlugin; 9 | 10 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/CrashUtils.java 11 | public class CrashUtils implements Listener { 12 | private static JavaPlugin plugin; 13 | private static TextureCache textureCache; 14 | 15 | public CrashUtils(JavaPlugin javaPlugin){ 16 | plugin = javaPlugin; 17 | } 18 | 19 | public void setupMenuSubSystem(){ 20 | Bukkit.getServer().getPluginManager().registerEvents(new CrashMenuController(plugin), plugin); //Gui controller 21 | } 22 | 23 | public void setupTextureCache(){ 24 | if (textureCache == null) { 25 | textureCache = new TextureCache(); 26 | Bukkit.getServer().getPluginManager().registerEvents(textureCache, plugin); 27 | } 28 | } 29 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/ServiceUtil.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import java.util.ServiceLoader; 6 | 7 | public class ServiceUtil { 8 | public static T getService(Class clazz) { 9 | return ServiceLoader.load(clazz).findFirst().orElseThrow(() -> new IllegalStateException("No service found for " + clazz.getName())); 10 | } 11 | 12 | public static T getService(Class clazz, T def) { 13 | return ServiceLoader.load(clazz).findFirst().orElse(def); 14 | } 15 | 16 | public static T getService(Class clazz, ClassLoader loader) { 17 | return ServiceLoader.load(clazz, loader).findFirst().orElseThrow(() -> new IllegalStateException("No service found for " + clazz.getName())); 18 | } 19 | 20 | public static T getService(Class clazz, ClassLoader loader, T def) { 21 | return ServiceLoader.load(clazz, loader).findFirst().orElse(def); 22 | } 23 | 24 | public static List getServices(Class clazz) { 25 | final List services = new ArrayList<>(); 26 | ServiceLoader.load(clazz).iterator().forEachRemaining(services::add); 27 | return services; 28 | } 29 | 30 | public static List getServices(Class clazz, ClassLoader loader) { 31 | final List services = new ArrayList<>(); 32 | ServiceLoader.load(clazz, loader).iterator().forEachRemaining(services::add); 33 | return services; 34 | } 35 | 36 | public static List getServices(Class clazz, List def) { 37 | final List services = new ArrayList<>(); 38 | ServiceLoader.load(clazz).iterator().forEachRemaining(services::add); 39 | if (services.isEmpty()) { 40 | return def; 41 | } 42 | return services; 43 | } 44 | 45 | public static List getServices(Class clazz, ClassLoader loader, List def) { 46 | final List services = new ArrayList<>(); 47 | ServiceLoader.load(clazz, loader).iterator().forEachRemaining(services::add); 48 | if (services.isEmpty()) { 49 | return def; 50 | } 51 | return services; 52 | } 53 | } 54 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/caches/TextureCache.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils.caches; 2 | 3 | import com.destroystokyo.paper.event.profile.FillProfileEvent; 4 | import com.destroystokyo.paper.event.profile.PreFillProfileEvent; 5 | import com.destroystokyo.paper.profile.PlayerProfile; 6 | import com.destroystokyo.paper.profile.ProfileProperty; 7 | import org.bukkit.event.EventHandler; 8 | import org.bukkit.event.Listener; 9 | import org.cache2k.Cache; 10 | import org.cache2k.Cache2kBuilder; 11 | 12 | import java.util.UUID; 13 | import java.util.concurrent.TimeUnit; 14 | 15 | 16 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/caches/TextureCache.java 17 | public class TextureCache implements Listener { 18 | private final Cache cache; 19 | 20 | public TextureCache(){ 21 | cache = new Cache2kBuilder() {} 22 | .name("TextureCache") 23 | .expireAfterWrite(3, TimeUnit.DAYS) 24 | .entryCapacity(10000) 25 | .disableStatistics(true) 26 | .build(); 27 | } 28 | 29 | @EventHandler 30 | public void onPreFillProfileEvent(PreFillProfileEvent e){ 31 | if (!e.getPlayerProfile().hasTextures()){ 32 | ProfileProperty profileProperty = cache.peek(e.getPlayerProfile().getId()); 33 | if (profileProperty != null) { 34 | e.getPlayerProfile().setProperty(profileProperty); 35 | } 36 | } 37 | } 38 | //TODO make sure this works 39 | @EventHandler 40 | public void onFillProfileEvent(FillProfileEvent e){ 41 | final PlayerProfile profile = e.getPlayerProfile(); 42 | if (profile.getId() != null && profile.hasTextures()){ 43 | for (ProfileProperty profileProperty : profile.getProperties()){ 44 | if (profileProperty.getName().equals("textures")){ 45 | cache.put(profile.getId(), profileProperty); 46 | break; 47 | } 48 | } 49 | } 50 | } 51 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/menusystem/CrashGuiHolder.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils.menusystem; 2 | 3 | import org.bukkit.entity.Player; 4 | import org.bukkit.inventory.Inventory; 5 | import org.bukkit.inventory.InventoryHolder; 6 | import org.bukkit.plugin.Plugin; 7 | 8 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/menusystem/CrashGuiHolder.java 9 | public class CrashGuiHolder implements InventoryHolder { 10 | final private Player player; 11 | final private GUI manager; 12 | final private Plugin plugin; 13 | 14 | private Inventory inventory; 15 | 16 | CrashGuiHolder(Player owner, GUI manager, Plugin plugin){ 17 | this.player = owner; 18 | this.manager = manager; 19 | this.plugin = plugin; 20 | } 21 | 22 | @Override 23 | public Inventory getInventory() { 24 | return this.inventory; 25 | } 26 | 27 | public Player getPlayer(){ 28 | return player; 29 | } 30 | 31 | public void setInventory(Inventory inventory){ 32 | this.inventory = inventory; 33 | } 34 | 35 | public GUI getManager(){ 36 | return manager; 37 | } 38 | 39 | public Plugin getPlugin() { 40 | return plugin; 41 | } 42 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/menusystem/CrashMenuController.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils.menusystem; 2 | 3 | 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.ChatColor; 6 | import org.bukkit.event.EventHandler; 7 | import org.bukkit.event.Listener; 8 | import org.bukkit.event.inventory.InventoryClickEvent; 9 | import org.bukkit.event.inventory.InventoryCloseEvent; 10 | import org.bukkit.event.inventory.InventoryDragEvent; 11 | import org.bukkit.inventory.ItemStack; 12 | import org.bukkit.plugin.Plugin; 13 | 14 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/menusystem/CrashMenuController.java 15 | public class CrashMenuController implements Listener { 16 | private final Plugin plugin; 17 | 18 | public CrashMenuController(Plugin plugin){ 19 | this.plugin = plugin; 20 | } 21 | 22 | @EventHandler 23 | public void onInventoryClickEvent(InventoryClickEvent e){ 24 | /* temporarily (permanently) disable due to a bug that allows 25 | players to put items into the menu's with number keys. 26 | (and probably some other ways too?) 27 | 28 | if (e.getCurrentItem() == null) 29 | return; 30 | 31 | */ 32 | if (e.getInventory().getHolder() instanceof CrashGuiHolder){ 33 | CrashGuiHolder holder = ((CrashGuiHolder) e.getInventory().getHolder()); 34 | 35 | if (!holder.getPlugin().equals(plugin)){ 36 | return; 37 | } 38 | GUI gui = holder.getManager(); 39 | 40 | gui.rawInventoryClickEvent(e); 41 | 42 | if (gui.isLockGUI()){ 43 | e.setCancelled(true); 44 | } 45 | ItemStack clickedItem = e.getCurrentItem(); 46 | 47 | if (clickedItem == null || !clickedItem.hasItemMeta() || !clickedItem.getItemMeta().hasDisplayName()) { 48 | return; 49 | } 50 | gui.onClick(e, ChatColor.stripColor(e.getCurrentItem().getItemMeta().getDisplayName().toLowerCase())); 51 | } 52 | } 53 | 54 | @EventHandler 55 | public void onInventoryCloseEvent(InventoryCloseEvent e) { 56 | if (e.getInventory().getHolder() instanceof CrashGuiHolder) { 57 | ((CrashGuiHolder) e.getInventory().getHolder()).getManager().onClose(); 58 | } 59 | } 60 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/menusystem/GUI.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils.menusystem; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.md_5.bungee.api.chat.BaseComponent; 5 | import org.bukkit.Bukkit; 6 | import org.bukkit.Material; 7 | import org.bukkit.OfflinePlayer; 8 | import org.bukkit.entity.HumanEntity; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.inventory.InventoryClickEvent; 11 | import org.bukkit.inventory.Inventory; 12 | import org.bukkit.inventory.ItemStack; 13 | import org.bukkit.inventory.meta.ItemMeta; 14 | import org.bukkit.inventory.meta.SkullMeta; 15 | import org.bukkit.plugin.Plugin; 16 | 17 | import java.util.ArrayList; 18 | import java.util.List; 19 | import java.util.UUID; 20 | 21 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/menusystem/GUI.java 22 | public abstract class GUI { 23 | private static final Plugin plugin = CrashClaim.getPlugin(); 24 | 25 | private String title; 26 | private int slots; 27 | 28 | protected Inventory inv; 29 | protected Player player; 30 | 31 | private boolean lockGUI = true; 32 | 33 | public GUI(Player player, String title, int slots){ 34 | initialize(player, title, slots); 35 | } 36 | 37 | public GUI(Player player, String title, int slots, boolean lockGUI){ 38 | initialize(player, title, slots); 39 | this.lockGUI = lockGUI; 40 | } 41 | 42 | private void initialize(Player player, String title, int slots){ 43 | this.title = title; 44 | this.slots = slots; 45 | this.player = player; 46 | 47 | CrashGuiHolder guiHolder = new CrashGuiHolder(player, this, plugin); 48 | inv = Bukkit.createInventory(guiHolder, slots, title); 49 | guiHolder.setInventory(inv); 50 | } 51 | 52 | public void forceClose(){ 53 | ArrayList newList = new ArrayList<>(inv.getViewers()); 54 | for (HumanEntity humanEntity : newList){ 55 | if (humanEntity.getOpenInventory().getTopInventory().equals(inv)) 56 | humanEntity.closeInventory(); 57 | } 58 | } 59 | 60 | public void rawInventoryClickEvent(InventoryClickEvent e){ 61 | 62 | } 63 | 64 | public void setupGUI(){ 65 | initialize(); 66 | loadItems(); 67 | } 68 | 69 | public void open(){ 70 | player.openInventory(inv); 71 | } 72 | 73 | public abstract void initialize(); 74 | 75 | public abstract void loadItems(); 76 | 77 | public abstract void onClose(); 78 | 79 | public abstract void onClick(InventoryClickEvent event, String rawItemName); 80 | 81 | public Player getPlayer() { 82 | return player; 83 | } 84 | 85 | public String getTitle() { 86 | return title; 87 | } 88 | 89 | public int getSlots() { 90 | return slots; 91 | } 92 | 93 | public Inventory getInventory() { 94 | return inv; 95 | } 96 | 97 | public boolean isLockGUI(){ 98 | return lockGUI; 99 | } 100 | 101 | // -- ItemUtils -- 102 | 103 | public static ItemStack createGuiItem(BaseComponent[] name, List desc, Material mat) { 104 | ItemStack i = new ItemStack(mat, 1); 105 | ItemMeta iMeta = i.getItemMeta(); 106 | iMeta.setDisplayNameComponent(name); 107 | iMeta.setLoreComponents(desc); 108 | i.setItemMeta(iMeta); 109 | return i; 110 | } 111 | 112 | public static ItemStack createGuiItem(String name, List desc, Material mat) { 113 | ItemStack i = new ItemStack(mat, 1); 114 | ItemMeta iMeta = i.getItemMeta(); 115 | iMeta.setDisplayName(name); 116 | iMeta.setLore(desc); 117 | i.setItemMeta(iMeta); 118 | return i; 119 | } 120 | 121 | public static ItemStack createGuiItem(String name, Material mat) { 122 | ItemStack i = new ItemStack(mat, 1); 123 | ItemMeta iMeta = i.getItemMeta(); 124 | iMeta.setDisplayName(name); 125 | i.setItemMeta(iMeta); 126 | return i; 127 | } 128 | 129 | public static ItemStack createPlayerHead(OfflinePlayer player, String name, List desc) { 130 | ItemStack item = createGuiItem(player.getName(), desc, Material.PLAYER_HEAD); 131 | SkullMeta meta = (SkullMeta) item.getItemMeta(); 132 | meta.setOwningPlayer(player); 133 | meta.setDisplayName(name); 134 | item.setItemMeta(meta); 135 | return item; 136 | } 137 | 138 | public static ItemStack createPlayerHead(OfflinePlayer player, String name) { 139 | ItemStack item = createGuiItem(player.getName(), Material.PLAYER_HEAD); 140 | SkullMeta meta = (SkullMeta) item.getItemMeta(); 141 | meta.setOwningPlayer(player); 142 | meta.setDisplayName(name); 143 | item.setItemMeta(meta); 144 | return item; 145 | } 146 | 147 | public static ItemStack createPlayerHead(UUID uuid, ArrayList desc) { 148 | OfflinePlayer player = Bukkit.getOfflinePlayer(uuid); 149 | return createPlayerHead(player, player.getName(), desc); 150 | } 151 | 152 | public static ItemStack createPlayerHead(UUID uuid) { 153 | OfflinePlayer player = Bukkit.getOfflinePlayer(uuid); 154 | return createPlayerHead(player, player.getName()); 155 | } 156 | 157 | public static ItemStack createPlayerHead(UUID uuid, String name, ArrayList desc) { 158 | OfflinePlayer player = Bukkit.getOfflinePlayer(uuid); 159 | return createPlayerHead(player, name, desc); 160 | } 161 | 162 | public static ItemStack createPlayerHead(UUID uuid, String name) { 163 | OfflinePlayer player = Bukkit.getOfflinePlayer(uuid); 164 | return createPlayerHead(player, name); 165 | } 166 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/crashutils/menusystem/defaultmenus/ConfirmationMenu.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.crashutils.menusystem.defaultmenus; 2 | 3 | import net.crashcraft.crashclaim.crashutils.menusystem.GUI; 4 | import net.md_5.bungee.api.chat.BaseComponent; 5 | import org.bukkit.ChatColor; 6 | import org.bukkit.Material; 7 | import org.bukkit.entity.Player; 8 | import org.bukkit.event.inventory.InventoryClickEvent; 9 | import org.bukkit.inventory.ItemStack; 10 | 11 | import java.util.List; 12 | import java.util.function.BiFunction; 13 | import java.util.function.Function; 14 | 15 | //https://github.com/CrashCraftNetwork/CrashUtils/blob/master/src/main/java/dev/whip/crashutils/menusystem/defaultmenus/ConfirmationMenu.java 16 | public class ConfirmationMenu extends GUI { 17 | private final BiFunction function; 18 | private final Function onCloseFunction; 19 | private final Player player; 20 | 21 | private final ItemStack item; 22 | private final ItemStack acceptItem; 23 | private final ItemStack cancelItem; 24 | 25 | public ConfirmationMenu(Player player, 26 | BaseComponent[] title, 27 | ItemStack item, 28 | ItemStack acceptItem, 29 | ItemStack cancelItem, 30 | BiFunction function, Function onCloseFunction){ 31 | super(player, BaseComponent.toLegacyText(title), 45); 32 | 33 | this.player = player; 34 | this.function = function; 35 | this.onCloseFunction = onCloseFunction; 36 | 37 | this.item = item; 38 | this.acceptItem = acceptItem; 39 | this.cancelItem = cancelItem; 40 | 41 | setupGUI(); 42 | } 43 | 44 | @Override 45 | public void initialize() { 46 | 47 | } 48 | 49 | @Override 50 | public void loadItems() { 51 | inv.setItem(13, item); 52 | 53 | inv.setItem(29, cancelItem); 54 | 55 | inv.setItem(33, acceptItem); 56 | } 57 | 58 | @Override 59 | public void onClose() { 60 | onCloseFunction.apply(player); 61 | } 62 | 63 | @Override 64 | public void onClick(InventoryClickEvent event, String rawItemName) { 65 | switch (event.getSlot()){ 66 | case 33: 67 | player.closeInventory(); 68 | function.apply(player, true); 69 | break; 70 | case 29: 71 | player.closeInventory(); 72 | function.apply(player, false); 73 | break; 74 | } 75 | } 76 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/ClaimResponse.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | 5 | public class ClaimResponse { 6 | private final boolean status; 7 | private final ErrorType error; 8 | private final BaseClaim claim; 9 | 10 | public ClaimResponse(boolean status, ErrorType error) { 11 | this.status = status; 12 | this.error = error; 13 | this.claim = null; 14 | } 15 | 16 | public ClaimResponse(boolean status, BaseClaim claim) { 17 | this.status = status; 18 | this.error = ErrorType.NONE; 19 | this.claim = claim; 20 | } 21 | 22 | public boolean isStatus() { 23 | return status; 24 | } 25 | 26 | public ErrorType getError() { 27 | return error; 28 | } 29 | 30 | public BaseClaim getClaim() { 31 | return claim; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/ContributionManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.claimobjects.Claim; 5 | import net.crashcraft.crashclaim.config.GlobalConfig; 6 | import net.crashcraft.crashclaim.payment.TransactionType; 7 | import net.crashcraft.crashclaim.localization.Localization; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.OfflinePlayer; 10 | import org.bukkit.entity.Player; 11 | 12 | import java.util.Map; 13 | import java.util.UUID; 14 | 15 | public class ContributionManager { 16 | public static int getArea(int minCornerX, int minCornerZ, int maxCornerX, int maxCornerZ){ 17 | return (((maxCornerX + 1) - minCornerX) * ((maxCornerZ + 1) - minCornerZ)); 18 | } 19 | 20 | public static void addContribution(Claim claim, int minCornerX, int minCornerZ, int maxCornerX, int maxCornerZ, UUID player){ 21 | int area = getArea(minCornerX, minCornerZ, maxCornerX, maxCornerZ); 22 | int originalArea = getArea(claim.getMinX(), claim.getMinZ(), claim.getMaxX(), claim.getMaxZ()); 23 | 24 | int difference = area - originalArea; 25 | 26 | if (difference == 0) 27 | return; 28 | 29 | if (difference > 0){ 30 | claim.addContribution(player, difference); //add to contribution 31 | } else { 32 | int value = (int) Math.floor(Math.floor(Math.abs(difference) * GlobalConfig.money_per_block) / claim.getContribution().size()); 33 | 34 | refund(claim, value); 35 | } 36 | } 37 | 38 | public static void refundContributors(Claim claim){ 39 | int area = getArea(claim.getMinX(), claim.getMinZ(), claim.getMaxX(), claim.getMaxZ()); 40 | int value = (int) Math.floor(Math.floor(area * GlobalConfig.money_per_block) / claim.getContribution().size()); 41 | 42 | refund(claim, value); 43 | } 44 | 45 | private static void refund(Claim claim, int value) { 46 | if (value == 0){ 47 | return; 48 | } 49 | 50 | for (Map.Entry entry : claim.getContribution().entrySet()){ 51 | CrashClaim.getPlugin().getPayment().makeTransaction(entry.getKey(), TransactionType.DEPOSIT, "Claim Refund", value, (transaction) -> { 52 | OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(transaction.getOwner()); 53 | if (offlinePlayer.isOnline()){ 54 | Player p = offlinePlayer.getPlayer(); 55 | if (p != null) { 56 | p.spigot().sendMessage(Localization.CONTRIBUTION_REFUND.getMessage(p, 57 | "amount", Integer.toString((int) Math.floor(transaction.getAmount())))); 58 | } 59 | } 60 | }); 61 | } 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/ErrorType.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | public enum ErrorType { 4 | NONE, 5 | OVERLAP_EXISTING, 6 | TOO_SMALL, 7 | CANNOT_FLIP_ON_RESIZE, 8 | CLAIM_LOCATIONS_WERE_NULL, 9 | FILESYSTEM_OR_MEMORY_ERROR, 10 | OUT_OF_BOUNDS, 11 | GENERIC, 12 | OVERLAP_EXISTING_SUBCLAIM, 13 | OVERLAP_EXISTING_OTHER, 14 | NO_PERMISSION 15 | } 16 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/MaterialName.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | import com.google.common.base.CaseFormat; 4 | import org.apache.commons.lang3.StringUtils; 5 | import org.bukkit.Material; 6 | 7 | import java.util.HashMap; 8 | 9 | public class MaterialName { 10 | private final HashMap names; 11 | 12 | public MaterialName(){ 13 | names = new HashMap<>(); 14 | 15 | for (Material material : Material.values()){ 16 | names.put(material, 17 | StringUtils.capitalize(StringUtils.join(StringUtils.split( 18 | CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, material.name()) 19 | ), ' '))); 20 | } 21 | } 22 | 23 | public String getMaterialName(Material material){ 24 | return names.get(material); 25 | } 26 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/MathUtils.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | public class MathUtils { 4 | public static boolean iskPointCollide(int minX, int minZ, int maxX, int maxZ, int x, int z) { 5 | return (z >= minZ && z <= maxZ) && (x >= minX && x <= maxX); 6 | } 7 | 8 | public static boolean doOverlap(int minX_1, int minZ_1, int maxX_1, int maxZ_1, int minX_2, int minZ_2, int maxX_2, int maxZ_2) { 9 | return !(minX_2 > maxX_1 || 10 | minZ_2 > maxZ_1 || 11 | minX_1 > maxX_2 || 12 | minZ_1 > maxZ_2); 13 | } 14 | 15 | public static boolean containedInside(int minX_1, int minZ_1, int maxX_1, int maxZ_1, int minX_2, int minZ_2, int maxX_2, int maxZ_2) { 16 | return iskPointCollide(minX_1, minZ_1, maxX_1, maxZ_1, minX_2, minZ_2) 17 | && iskPointCollide(minX_1, minZ_1, maxX_1, maxZ_1, maxX_2, maxZ_2); 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/SaveResponse.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | public class SaveResponse { 4 | private final String error; 5 | private final String provider; 6 | 7 | public SaveResponse(String error, String provider) { 8 | this.error = error; 9 | this.provider = provider; 10 | } 11 | 12 | public String getError() { 13 | return error; 14 | } 15 | 16 | public String getProvider() { 17 | return provider; 18 | } 19 | 20 | public boolean isSuccsessful(){ 21 | return error == null; 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/StaticClaimLogic.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data; 2 | 3 | import org.bukkit.Location; 4 | 5 | public class StaticClaimLogic { 6 | public static long getChunkHash(long chunkX, long chunkZ) { 7 | return (chunkZ ^ (chunkX << 32)); 8 | } 9 | 10 | public static long getChunkHashFromLocation(int x, int z) { 11 | return getChunkHash(x >> 4, z >> 4); 12 | } 13 | 14 | public static Location calculateMaxCorner(Location loc1, Location loc2){ 15 | return new Location(loc1.getWorld(), Math.max(loc1.getBlockX(), loc2.getBlockX()), loc1.getY(), Math.max(loc1.getBlockZ(), loc2.getBlockZ())); 16 | } 17 | 18 | public static Location calculateMinCorner(Location loc1, Location loc2){ 19 | return new Location(loc1.getWorld(), Math.min(loc1.getBlockX(), loc2.getBlockX()), loc1.getY(), Math.min(loc1.getBlockZ(), loc2.getBlockZ())); 20 | } 21 | 22 | public static boolean isClaimBorder(int min_x, int max_x, int min_z, int max_z, int point_x, int point_z){ 23 | return ((point_x == min_x || point_x == max_x) && (point_z >= min_z && point_z <= max_z)) // Is on X border and falls in Z bounds 24 | || ((point_z == min_z || point_z == max_z) && (point_x >= min_x && point_x <= max_x)); // Is on Z border and falls in X bounds 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/DataProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.claimobjects.Claim; 5 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 6 | import net.crashcraft.crashclaim.data.ClaimDataManager; 7 | import org.bukkit.event.Listener; 8 | 9 | import java.util.Set; 10 | import java.util.UUID; 11 | 12 | public interface DataProvider extends Listener { 13 | void init(CrashClaim plugin, ClaimDataManager manager); 14 | 15 | boolean preInitialSave(Claim claim); 16 | 17 | /** 18 | * Saves and updates a claims data 19 | */ 20 | void saveClaim(Claim claim); 21 | 22 | /** 23 | * Removes a claim and all data 24 | * To remove a subClaim, remove the claim in memory and then save 25 | */ 26 | void removeClaim(Claim claim); 27 | 28 | /** 29 | * Loads a claim into memory from the datasource 30 | * @return A loaded claim object 31 | */ 32 | Claim loadClaim(Integer id); 33 | 34 | /** 35 | * @return a list of permitted claims 36 | */ 37 | Set getPermittedClaims(UUID uuid); 38 | 39 | /** 40 | * @return a list of owned claims 41 | */ 42 | Set getOwnedParentClaims(UUID uuid); 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/DataType.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite; 2 | 3 | public enum DataType { 4 | CLAIM(0), 5 | SUB_CLAIM(1); 6 | 7 | private final int type; 8 | 9 | DataType(int type){ 10 | this.type = type; 11 | } 12 | 13 | public int getType() { 14 | return type; 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/DataVersion.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite; 2 | 3 | import java.sql.SQLException; 4 | 5 | public interface DataVersion { 6 | /** 7 | * @return the revision id of this database set. Needs to be incremented from the previous data revision 8 | */ 9 | int getVersion(); 10 | 11 | /** 12 | * Executes the upgrade queries on the global DB 13 | * @throws SQLException When data version has failed 14 | */ 15 | void executeUpgrade(int fromRevision) throws SQLException; 16 | } 17 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/DataVersionIncrementException.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite; 2 | 3 | public class DataVersionIncrementException extends RuntimeException { 4 | public DataVersionIncrementException(int fromRevision, int toRevision) { 5 | super("Database schema conversion failed: [" + fromRevision + " -> " + toRevision + "]"); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/DatabaseManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite; 2 | 3 | import co.aikar.idb.DB; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.data.providers.sqlite.versions.*; 6 | 7 | import java.sql.SQLException; 8 | import java.util.ArrayList; 9 | import java.util.logging.Logger; 10 | 11 | public class DatabaseManager { 12 | private final CrashClaim plugin; 13 | private final Logger logger; 14 | private final ArrayList dataVersions; 15 | 16 | private int currentRevision; 17 | 18 | public DatabaseManager(CrashClaim plugin){ 19 | this.plugin = plugin; 20 | this.logger = plugin.getLogger(); 21 | this.dataVersions = new ArrayList<>(); 22 | this.currentRevision = -1; // represents no database configured yet 23 | 24 | setInitialParams(); 25 | setupDataVersions(); 26 | validateDataVersions(); 27 | 28 | try { 29 | String value = DB.getFirstColumn("SELECT value FROM properties WHERE `key` = ?", "dataVersion"); 30 | currentRevision = Integer.parseInt(value); 31 | } catch (SQLException e){ // Table does not exist so we assume database is fresh 32 | logger.info("No data version found, creating database schema"); 33 | } 34 | 35 | updateDatabase(); 36 | } 37 | 38 | private void setInitialParams(){ 39 | try { 40 | DB.executeUpdate("PRAGMA foreign_keys=ON"); 41 | } catch (SQLException e){ 42 | plugin.disablePlugin("There was an error enabling SQlite foreign keys support, it is unsafe to continue."); 43 | } 44 | } 45 | 46 | private void updateDatabase(){ 47 | int latestVersion = (dataVersions.get(dataVersions.size() - 1).getVersion()); 48 | if (currentRevision == latestVersion){ 49 | return; 50 | } 51 | 52 | logger.info("Database is converting: [" + currentRevision + " -> " + latestVersion + "]"); 53 | 54 | for (int x = currentRevision == -1 ? 0 : currentRevision + 1; x < dataVersions.size(); x++){ 55 | DataVersion version = dataVersions.get(x); 56 | logger.info("Converting [" + currentRevision + " -> " + version.getVersion() + "]"); 57 | try { 58 | version.executeUpgrade(currentRevision); 59 | currentRevision = version.getVersion(); 60 | } catch (SQLException e){ 61 | e.printStackTrace(); 62 | plugin.disablePlugin("Failed conversion, disabling plugin, manual data fixing may be needed"); 63 | } 64 | 65 | try { 66 | DB.executeInsert("REPLACE INTO properties(key, value) VALUES (?, ?)", "dataVersion", currentRevision); 67 | } catch (SQLException e){ 68 | logger.severe("Failed to write property to database"); 69 | e.printStackTrace(); 70 | } 71 | } 72 | } 73 | 74 | private void setupDataVersions(){ 75 | registerDataVersion(new DataRev0()); 76 | registerDataVersion(new DataRev1()); 77 | registerDataVersion(new DataRev2()); 78 | registerDataVersion(new DataRev3()); 79 | registerDataVersion(new DataRev4()); 80 | } 81 | 82 | private void validateDataVersions(){ 83 | ArrayList failedDataVersions = new ArrayList<>(); 84 | for (int x = 0; x < dataVersions.size(); x++){ 85 | DataVersion version = dataVersions.get(x); 86 | 87 | if (version == null){ 88 | failedDataVersions.add(x); 89 | } 90 | } 91 | 92 | if (failedDataVersions.size() > 0){ 93 | StringBuilder builder = new StringBuilder("Data versions failed to initialize. ["); 94 | for (int version : failedDataVersions){ 95 | builder.append(version).append(", "); 96 | } 97 | builder.append("]"); 98 | plugin.disablePlugin(builder.toString()); 99 | } 100 | } 101 | 102 | private void registerDataVersion(DataVersion version){ 103 | dataVersions.add(version.getVersion(), version); 104 | } 105 | } 106 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/versions/DataRev0.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite.versions; 2 | 3 | import co.aikar.idb.DB; 4 | import net.crashcraft.crashclaim.data.providers.sqlite.DataVersion; 5 | 6 | import java.sql.SQLException; 7 | 8 | public class DataRev0 implements DataVersion { 9 | @Override 10 | public int getVersion() { 11 | return 0; 12 | } 13 | 14 | @Override 15 | public void executeUpgrade(int fromRevision) throws SQLException { 16 | DB.executeUpdate("CREATE TABLE \"claim_data\" (\n" + 17 | "\t\"id\"\tINTEGER,\n" + 18 | "\t\"minX\"\tINTEGER NOT NULL,\n" + 19 | "\t\"minZ\"\tINTEGER NOT NULL,\n" + 20 | "\t\"maxX\"\tINTEGER NOT NULL,\n" + 21 | "\t\"maxZ\"\tINTEGER NOT NULL,\n" + 22 | "\t\"world\"\tINTEGER NOT NULL,\n" + 23 | "\t\"name\"\tTEXT,\n" + 24 | "\t\"entryMessage\"\tTEXT,\n" + 25 | "\t\"exitMessage\"\tTEXT,\n" + 26 | "\tUNIQUE(\"minX\",\"minZ\",\"maxX\",\"maxZ\",\"world\"),\n" + 27 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT),\n" + 28 | "\tFOREIGN KEY(\"world\") REFERENCES \"claimworlds\"(\"id\") ON DELETE CASCADE\n" + 29 | ")"); 30 | DB.executeUpdate("CREATE TABLE \"claims\" (\n" + 31 | "\t\"id\"\tINTEGER UNIQUE,\n" + 32 | "\t\"data\"\tINTEGER NOT NULL,\n" + 33 | "\t\"players_id\"\tINTEGER NOT NULL,\n" + 34 | "\tPRIMARY KEY(\"id\"),\n" + 35 | "\tFOREIGN KEY(\"data\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 36 | "\tFOREIGN KEY(\"players_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE\n" + 37 | ")"); 38 | DB.executeUpdate("CREATE TABLE \"claimworlds\" (\n" + 39 | "\t\"id\"\tINTEGER,\n" + 40 | "\t\"uuid\"\tTEXT NOT NULL UNIQUE,\n" + 41 | "\t\"name\"\tTEXT NOT NULL,\n" + 42 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT)\n" + 43 | ")"); 44 | DB.executeUpdate("CREATE TABLE \"permission_containers\" (\n" + 45 | "\t\"data_id\"\tINTEGER NOT NULL,\n" + 46 | "\t\"player_id\"\tINTEGER NOT NULL,\n" + 47 | "\t\"container\"\tINTEGER NOT NULL,\n" + 48 | "\t\"value\"\tINTEGER NOT NULL,\n" + 49 | "\tPRIMARY KEY(\"data_id\",\"player_id\",\"container\"),\n" + 50 | "\tFOREIGN KEY(\"player_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE,\n" + 51 | "\tFOREIGN KEY(\"container\") REFERENCES \"permissioncontainers\"(\"id\") ON DELETE CASCADE,\n" + 52 | "\tFOREIGN KEY(\"data_id\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE\n" + 53 | ")"); 54 | DB.executeUpdate("CREATE TABLE \"permission_set\" (\n" + 55 | "\t\"data_id\"\tINTEGER NOT NULL,\n" + 56 | "\t\"players_id\"\tINTEGER NOT NULL,\n" + 57 | "\t\"build\"\tINTEGER NOT NULL,\n" + 58 | "\t\"interactions\"\tINTEGER NOT NULL,\n" + 59 | "\t\"entities\"\tINTEGER NOT NULL,\n" + 60 | "\t\"teleportation\"\tINTEGER NOT NULL,\n" + 61 | "\t\"viewSubClaims\"\tINTEGER NOT NULL,\n" + 62 | "\t\"defaultContainer\"\tINTEGER NOT NULL,\n" + 63 | "\t\"explosions\"\tINTEGER,\n" + 64 | "\t\"pistons\"\tINTEGER,\n" + 65 | "\t\"fluids\"\tINTEGER,\n" + 66 | "\t\"modifyPermissions\"\tINTEGER,\n" + 67 | "\t\"modifyClaim\"\tINTEGER,\n" + 68 | "\tFOREIGN KEY(\"data_id\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 69 | "\tFOREIGN KEY(\"players_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE,\n" + 70 | "\tPRIMARY KEY(\"data_id\",\"players_id\")\n" + 71 | ")"); 72 | DB.executeUpdate("CREATE TABLE \"permissioncontainers\" (\n" + 73 | "\t\"id\"\tINTEGER,\n" + 74 | "\t\"identifier\"\tTEXT NOT NULL UNIQUE,\n" + 75 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT)\n" + 76 | ")"); 77 | DB.executeUpdate("CREATE TABLE \"players\" (\n" + 78 | "\t\"id\"\tINTEGER,\n" + 79 | "\t\"uuid\"\tTEXT NOT NULL,\n" + 80 | "\t\"username\"\tTEXT,\n" + 81 | "\tUNIQUE(\"id\",\"uuid\"),\n" + 82 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT)\n" + 83 | ")"); 84 | DB.executeUpdate("CREATE TABLE \"properties\" (\n" + 85 | "\t\"key\"\tTEXT UNIQUE NOT NULL,\n" + 86 | "\t\"value\"\tTEXT NOT NULL,\n" + 87 | "\tUNIQUE(\"value\",\"key\")\n" + 88 | ")"); 89 | DB.executeUpdate("CREATE TABLE \"subclaims\" (\n" + 90 | "\t\"id\"\tINTEGER,\n" + 91 | "\t\"data\"\tINTEGER NOT NULL,\n" + 92 | "\t\"claim_id\"\tINTEGER NOT NULL,\n" + 93 | "\tPRIMARY KEY(\"id\"),\n" + 94 | "\tFOREIGN KEY(\"data\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 95 | "\tFOREIGN KEY(\"claim_id\") REFERENCES \"claims\"(\"id\") ON DELETE CASCADE\n" + 96 | ")"); 97 | } 98 | } 99 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/versions/DataRev1.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite.versions; 2 | 3 | import co.aikar.idb.DB; 4 | import net.crashcraft.crashclaim.data.providers.sqlite.DataVersion; 5 | 6 | import java.sql.SQLException; 7 | 8 | public class DataRev1 implements DataVersion { 9 | @Override 10 | public int getVersion() { 11 | return 1; 12 | } 13 | 14 | @Override 15 | public void executeUpgrade(int fromRevision) throws SQLException { 16 | DB.executeUpdate("CREATE TABLE \"contributions\" (\n" + 17 | "\t\"data_id\"\tINTEGER NOT NULL,\n" + 18 | "\t\"players_id\"\tINTEGER NOT NULL,\n" + 19 | "\t\"amount\"\tINTEGER NOT NULL,\n" + 20 | "\tFOREIGN KEY(\"data_id\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 21 | "\tFOREIGN KEY(\"players_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE,\n" + 22 | "\tPRIMARY KEY(\"data_id\",\"players_id\")\n" + 23 | ");"); 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/versions/DataRev2.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite.versions; 2 | 3 | import co.aikar.idb.DB; 4 | import net.crashcraft.crashclaim.data.providers.sqlite.DataVersion; 5 | 6 | import java.sql.SQLException; 7 | import java.util.List; 8 | 9 | public class DataRev2 implements DataVersion { 10 | @Override 11 | public int getVersion() { 12 | return 2; 13 | } 14 | 15 | @Override 16 | public void executeUpgrade(int fromRevision) throws SQLException { 17 | /* 18 | This code is to fix duplicate entries in the player id table, because of a misused constraint multiple uuid entries were created but only the first is used 19 | so we need to remove all of the entries after the first and then fix the cosntraint. 20 | */ 21 | 22 | List uuids = DB.getFirstColumnResults("SELECT DISTINCT uuid FROM players"); 23 | 24 | for (String uuid : uuids){ 25 | List toRemoveList = DB.getFirstColumnResults( 26 | "SELECT id FROM players \n" + 27 | "\tWHERE uuid = ? \n" + 28 | "\tORDER BY id LIMIT (SELECT count(id) FROM players) OFFSET 1", uuid); 29 | for (int idToRemove : toRemoveList){ 30 | DB.executeUpdate("DELETE FROM players WHERE id = ?", idToRemove); 31 | } 32 | } 33 | 34 | DB.executeUpdate("PRAGMA foreign_keys = OFF"); // Turn foreign keys off 35 | 36 | DB.executeUpdate("CREATE TABLE \"players_backup\" (\n" + 37 | "\t\"id\"\tINTEGER,\n" + 38 | "\t\"uuid\"\tTEXT NOT NULL,\n" + 39 | "\t\"username\"\tTEXT,\n" + 40 | "\tUNIQUE(\"id\",\"uuid\"),\n" + 41 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT)\n" + 42 | ")"); 43 | 44 | DB.executeInsert("INSERT INTO players_backup SELECT * FROM players"); 45 | 46 | DB.executeUpdate("DROP TABLE players"); 47 | 48 | DB.executeUpdate("CREATE TABLE \"players\" (\n" + 49 | "\t\"id\"\tINTEGER,\n" + 50 | "\t\"uuid\"\tTEXT NOT NULL UNIQUE,\n" + 51 | "\t\"username\"\tTEXT,\n" + 52 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT)\n" + 53 | ");"); 54 | 55 | DB.executeInsert("INSERT INTO players SELECT * FROM players_backup"); 56 | 57 | DB.executeUpdate("PRAGMA foreign_keys = ON"); // Undo 58 | } 59 | } 60 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/versions/DataRev3.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite.versions; 2 | 3 | import co.aikar.idb.DB; 4 | import net.crashcraft.crashclaim.claimobjects.PermState; 5 | import net.crashcraft.crashclaim.data.providers.sqlite.DataVersion; 6 | 7 | import java.sql.SQLException; 8 | 9 | public class DataRev3 implements DataVersion { 10 | @Override 11 | public int getVersion() { 12 | return 3; 13 | } 14 | 15 | @Override 16 | public void executeUpgrade(int fromRevision) throws SQLException { 17 | DB.executeUpdate("DROP TABLE players_backup"); // Drop previous data revisions backup 18 | 19 | DB.executeUpdate("PRAGMA foreign_keys = OFF"); // Turn foreign keys off 20 | 21 | DB.executeUpdate("CREATE TABLE \"permission_set_backup\" (\n" + 22 | "\t\"data_id\"\tINTEGER NOT NULL,\n" + 23 | "\t\"players_id\"\tINTEGER NOT NULL,\n" + 24 | "\t\"build\"\tINTEGER NOT NULL,\n" + 25 | "\t\"interactions\"\tINTEGER NOT NULL,\n" + 26 | "\t\"entities\"\tINTEGER NOT NULL,\n" + 27 | "\t\"teleportation\"\tINTEGER NOT NULL,\n" + 28 | "\t\"viewSubClaims\"\tINTEGER NOT NULL,\n" + 29 | "\t\"defaultContainer\"\tINTEGER NOT NULL,\n" + 30 | "\t\"explosions\"\tINTEGER,\n" + 31 | "\t\"pistons\"\tINTEGER,\n" + 32 | "\t\"fluids\"\tINTEGER,\n" + 33 | "\t\"modifyPermissions\"\tINTEGER,\n" + 34 | "\t\"modifyClaim\"\tINTEGER,\n" + 35 | "\tFOREIGN KEY(\"data_id\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 36 | "\tFOREIGN KEY(\"players_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE,\n" + 37 | "\tPRIMARY KEY(\"data_id\",\"players_id\")\n" + 38 | ")"); 39 | 40 | DB.executeInsert("INSERT INTO permission_set_backup SELECT * FROM permission_set"); 41 | 42 | DB.executeUpdate("DROP TABLE permission_set"); 43 | 44 | DB.executeUpdate("CREATE TABLE \"permission_set\" (\n" + 45 | "\t\"data_id\"\tINTEGER NOT NULL,\n" + 46 | "\t\"players_id\"\tINTEGER NOT NULL,\n" + 47 | "\t\"build\"\tINTEGER NOT NULL,\n" + 48 | "\t\"interactions\"\tINTEGER NOT NULL,\n" + 49 | "\t\"entities\"\tINTEGER NOT NULL,\n" + 50 | "\t\"teleportation\"\tINTEGER NOT NULL,\n" + 51 | "\t\"viewSubClaims\"\tINTEGER NOT NULL,\n" + 52 | "\t\"defaultContainer\"\tINTEGER NOT NULL,\n" + 53 | "\t\"explosions\"\tINTEGER,\n" + 54 | "\t\"entityGrief\"\tINTEGER,\n" + 55 | "\t\"pistons\"\tINTEGER,\n" + 56 | "\t\"fluids\"\tINTEGER,\n" + 57 | "\t\"modifyPermissions\"\tINTEGER,\n" + 58 | "\t\"modifyClaim\"\tINTEGER,\n" + 59 | "\tFOREIGN KEY(\"data_id\") REFERENCES \"claim_data\"(\"id\") ON DELETE CASCADE,\n" + 60 | "\tFOREIGN KEY(\"players_id\") REFERENCES \"players\"(\"id\") ON DELETE CASCADE,\n" + 61 | "\tPRIMARY KEY(\"data_id\",\"players_id\")\n" + 62 | ")"); 63 | 64 | DB.executeInsert("INSERT INTO permission_set(data_id, players_id, build, interactions, entities, teleportation, viewSubClaims, defaultContainer, " + 65 | "explosions, pistons, fluids, modifyPermissions, modifyClaim) SELECT * FROM permission_set_backup;"); 66 | 67 | DB.executeInsert("UPDATE permission_set SET entityGrief = ? WHERE players_id = -1", PermState.DISABLE); 68 | 69 | DB.executeUpdate("PRAGMA foreign_keys = ON"); // Undo 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/data/providers/sqlite/versions/DataRev4.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.data.providers.sqlite.versions; 2 | 3 | import co.aikar.idb.DB; 4 | import co.aikar.idb.DbRow; 5 | import net.crashcraft.crashclaim.data.providers.sqlite.DataType; 6 | import net.crashcraft.crashclaim.data.providers.sqlite.DataVersion; 7 | 8 | import java.sql.SQLException; 9 | import java.util.List; 10 | 11 | public class DataRev4 implements DataVersion { 12 | @Override 13 | public int getVersion() { 14 | return 4; 15 | } 16 | 17 | @Override 18 | public void executeUpgrade(int fromRevision) throws SQLException { 19 | DB.executeUpdate("PRAGMA foreign_keys = OFF"); // Turn foreign keys off 20 | 21 | DB.executeUpdate("CREATE TABLE \"claim_data_backup\" (\n" + 22 | "\t\"id\"\tINTEGER,\n" + 23 | "\t\"minX\"\tINTEGER NOT NULL,\n" + 24 | "\t\"minZ\"\tINTEGER NOT NULL,\n" + 25 | "\t\"maxX\"\tINTEGER NOT NULL,\n" + 26 | "\t\"maxZ\"\tINTEGER NOT NULL,\n" + 27 | "\t\"world\"\tINTEGER NOT NULL,\n" + 28 | "\t\"name\"\tTEXT,\n" + 29 | "\t\"entryMessage\"\tTEXT,\n" + 30 | "\t\"exitMessage\"\tTEXT,\n" + 31 | "\tUNIQUE(\"minX\",\"minZ\",\"maxX\",\"maxZ\",\"world\"),\n" + 32 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT),\n" + 33 | "\tFOREIGN KEY(\"world\") REFERENCES \"claimworlds\"(\"id\") ON DELETE CASCADE\n" + 34 | ")"); 35 | 36 | DB.executeInsert("INSERT INTO claim_data_backup SELECT * FROM claim_data"); 37 | 38 | DB.executeUpdate("DROP TABLE claim_data"); 39 | 40 | DB.executeUpdate("CREATE TABLE \"claim_data\" (\n" + 41 | "\t\"id\"\tINTEGER,\n" + 42 | "\t\"type\"\tINTEGER NOT NULL,\n" + 43 | "\t\"minX\"\tINTEGER NOT NULL,\n" + 44 | "\t\"minZ\"\tINTEGER NOT NULL,\n" + 45 | "\t\"maxX\"\tINTEGER NOT NULL,\n" + 46 | "\t\"maxZ\"\tINTEGER NOT NULL,\n" + 47 | "\t\"world\"\tINTEGER NOT NULL,\n" + 48 | "\t\"name\"\tTEXT,\n" + 49 | "\t\"entryMessage\"\tTEXT,\n" + 50 | "\t\"exitMessage\"\tTEXT,\n" + 51 | "\tFOREIGN KEY(\"world\") REFERENCES \"claimworlds\"(\"id\") ON DELETE CASCADE,\n" + 52 | "\tPRIMARY KEY(\"id\" AUTOINCREMENT),\n" + 53 | "\tUNIQUE(\"minX\",\"minZ\",\"maxX\",\"maxZ\",\"world\",\"type\")\n" + 54 | ")"); 55 | 56 | for (DbRow row : DB.getResults("SELECT id, `data` FROM claims")){ 57 | if (row == null){ 58 | continue; 59 | } 60 | 61 | Integer id = row.getInt("id"); 62 | Integer data = row.getInt("data"); 63 | 64 | if (id == null || data == null){ 65 | continue; 66 | } 67 | 68 | DB.executeInsert("INSERT INTO claim_data(id, minX, minZ, maxX, maxZ, world, name, entryMessage, exitMessage, `type`) SELECT *, ? FROM claim_data_backup WHERE id = ?", 69 | DataType.CLAIM.getType(), data); 70 | 71 | List subClaims = DB.getFirstColumnResults("SELECT `data` FROM subclaims WHERE claim_id = ?", id); 72 | for (Integer subData : subClaims){ 73 | if (subData == null){ 74 | continue; 75 | } 76 | 77 | DB.executeInsert("INSERT INTO claim_data(id, minX, minZ, maxX, maxZ, world, name, entryMessage, exitMessage, `type`) SELECT *, ? FROM claim_data_backup WHERE id = ?", 78 | DataType.SUB_CLAIM.getType(), subData); 79 | } 80 | } 81 | 82 | DB.executeUpdate("PRAGMA foreign_keys = ON"); // Undo 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/listeners/PacketEventsListener.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.listeners; 2 | 3 | import com.github.retrooper.packetevents.event.PacketListener; 4 | import com.github.retrooper.packetevents.event.PacketReceiveEvent; 5 | import com.github.retrooper.packetevents.protocol.packettype.PacketType; 6 | import com.github.retrooper.packetevents.protocol.player.InteractionHand; 7 | import com.github.retrooper.packetevents.wrapper.play.client.WrapperPlayClientInteractEntity; 8 | import net.crashcraft.crashclaim.CrashClaim; 9 | import net.crashcraft.crashclaim.claimobjects.Claim; 10 | import net.crashcraft.crashclaim.commands.claiming.ClaimCommand; 11 | import net.crashcraft.crashclaim.data.ClaimDataManager; 12 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 13 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 14 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 15 | import net.crashcraft.crashclaim.visualize.api.visuals.BaseGlowVisual; 16 | import org.bukkit.Bukkit; 17 | import org.bukkit.Location; 18 | import org.bukkit.entity.EntityType; 19 | import org.bukkit.entity.Player; 20 | 21 | 22 | public class PacketEventsListener implements PacketListener { 23 | private final CrashClaim crashClaim; 24 | private final ClaimCommand claimCommand; 25 | 26 | public PacketEventsListener(CrashClaim crashClaim, ClaimCommand claimCommand) { 27 | this.crashClaim = crashClaim; 28 | 29 | ClaimDataManager dataManager = crashClaim.getDataManager(); 30 | VisualizationManager visualizationManager = crashClaim.getVisualizationManager(); 31 | this.claimCommand = new ClaimCommand(dataManager, visualizationManager); 32 | 33 | } 34 | 35 | @Override 36 | public void onPacketReceive(PacketReceiveEvent event) { 37 | if (event.getPacketType() == PacketType.Play.Client.INTERACT_ENTITY) { 38 | WrapperPlayClientInteractEntity interact = new WrapperPlayClientInteractEntity(event); 39 | if (interact.getHand() == InteractionHand.MAIN_HAND) { 40 | Player player = (Player) event.getPlayer(); 41 | 42 | if (player == null) 43 | return; 44 | 45 | VisualGroup group = crashClaim.getVisualizationManager().fetchVisualGroup(player, false); 46 | 47 | if (group == null) 48 | return; 49 | int id = interact.getEntityId(); 50 | 51 | for (BaseVisual visual : group.getActiveVisuals()) { 52 | if (visual instanceof BaseGlowVisual glowVisual) { 53 | Location location = glowVisual.getEntityLocation(id); 54 | if (location != null) { 55 | Bukkit.getScheduler().runTask(crashClaim, () -> claimCommand.click(player, location)); 56 | return; 57 | } 58 | } 59 | } 60 | } 61 | } 62 | } 63 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/localization/CrashClaimExpansion.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.localization; 2 | 3 | import me.clip.placeholderapi.expansion.PlaceholderExpansion; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.claimobjects.Claim; 6 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 7 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 8 | import net.crashcraft.crashclaim.visualize.api.claim.BlockClaimVisual; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.OfflinePlayer; 11 | import org.bukkit.entity.Player; 12 | import org.jetbrains.annotations.NotNull; 13 | 14 | public class CrashClaimExpansion extends PlaceholderExpansion { 15 | private final CrashClaim crashClaim; 16 | 17 | public CrashClaimExpansion(CrashClaim crashClaim){ 18 | this.crashClaim = crashClaim; 19 | } 20 | 21 | @Override 22 | public String onRequest(OfflinePlayer player, @NotNull String params) { 23 | if (player != null){ 24 | switch (params.toLowerCase()) { 25 | case "total_owned_claims" -> { 26 | return Integer.toString(crashClaim.getDataManager().getNumberOwnedClaims(player.getUniqueId())); 27 | } 28 | case "total_owned_parent_claims" -> { 29 | return Integer.toString(crashClaim.getDataManager().getNumberOwnedParentClaims(player.getUniqueId())); 30 | } 31 | case "current_claim_owner" -> { 32 | if (!player.isOnline()){ 33 | return null; 34 | } 35 | 36 | Player onlinePlayer = player.getPlayer(); 37 | 38 | if (onlinePlayer == null){ 39 | return null; 40 | } 41 | 42 | Claim claim = crashClaim.getDataManager().getClaim(onlinePlayer.getLocation()); 43 | 44 | if (claim == null){ 45 | return ""; 46 | } 47 | 48 | OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(claim.getOwner()); 49 | return offlinePlayer.getName(); 50 | } 51 | case "visual_status" -> { 52 | if (!player.isOnline()){ 53 | return null; 54 | } 55 | 56 | Player onlinePlayer = player.getPlayer(); 57 | 58 | if (onlinePlayer == null){ 59 | return null; 60 | } 61 | 62 | VisualGroup group = CrashClaim.getPlugin().getVisualizationManager().fetchVisualGroup(onlinePlayer, false); 63 | 64 | if (group == null){ 65 | return Localization.PLACEHOLDERAPI__VISUAL_STATUS_HIDDEN.getRawMessage(); 66 | } 67 | 68 | for (BaseVisual visual : group.getActiveVisuals()){ 69 | if (visual.getClaim() != null){ 70 | return Localization.PLACEHOLDERAPI__VISUAL_STATUS_SHOWN.getRawMessage(); 71 | } 72 | } 73 | 74 | return Localization.PLACEHOLDERAPI__VISUAL_STATUS_HIDDEN.getRawMessage(); 75 | } 76 | } 77 | } 78 | return null; 79 | } 80 | 81 | @Override 82 | public @NotNull String getIdentifier() { 83 | return crashClaim.getName(); 84 | } 85 | 86 | @Override 87 | public @NotNull String getAuthor() { 88 | return crashClaim.getDescription().getAuthors().get(0); 89 | } 90 | 91 | @Override 92 | public @NotNull String getVersion() { 93 | return crashClaim.getDescription().getVersion(); 94 | } 95 | 96 | @Override 97 | public boolean persist(){ 98 | return true; 99 | } 100 | } 101 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/localization/LocalizationLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.localization; 2 | 3 | import net.kyori.adventure.text.minimessage.MiniMessage; 4 | import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver; 5 | import net.kyori.adventure.text.minimessage.tag.standard.StandardTags; 6 | 7 | public class LocalizationLoader { 8 | static MiniMessage parser; 9 | static MiniMessage userParser; 10 | static PlaceholderManager placeholderManager; 11 | 12 | public static void initialize(){ 13 | parser = MiniMessage.builder().build(); 14 | 15 | userParser = MiniMessage.builder().tags( 16 | TagResolver.builder() 17 | .resolver(StandardTags.color()) 18 | .resolver(StandardTags.decorations()) 19 | .resolver(StandardTags.rainbow()) 20 | .resolver(StandardTags.reset()) 21 | .resolver(StandardTags.gradient()) 22 | .build() 23 | ).build(); 24 | 25 | placeholderManager = new PlaceholderManager(); 26 | 27 | Localization.rebuildCachedMessages(); 28 | } 29 | 30 | public static void register(){ 31 | placeholderManager.registerPlaceholders(); 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/localization/LocalizationUtils.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.localization; 2 | 3 | import net.md_5.bungee.api.chat.BaseComponent; 4 | import org.bukkit.command.CommandSender; 5 | 6 | import java.util.List; 7 | 8 | public class LocalizationUtils { 9 | public static void sendMessageList(CommandSender player, List message){ 10 | for (BaseComponent[] line : message){ 11 | player.spigot().sendMessage(line); 12 | } 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/localization/PlaceholderManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.localization; 2 | 3 | import me.clip.placeholderapi.PlaceholderAPI; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import org.bukkit.Bukkit; 6 | import org.bukkit.OfflinePlayer; 7 | import org.bukkit.entity.Player; 8 | 9 | import java.util.List; 10 | 11 | public class PlaceholderManager { 12 | private final boolean isEnabled; 13 | 14 | public PlaceholderManager(){ 15 | this.isEnabled = Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null; 16 | 17 | if (isEnabled){ 18 | CrashClaim.getPlugin().getLogger().info("PlaceholderAPI Support enabled."); 19 | } 20 | } 21 | 22 | public void registerPlaceholders(){ 23 | if (isEnabled){ 24 | new CrashClaimExpansion(CrashClaim.getPlugin()).register(); 25 | } 26 | } 27 | 28 | public boolean hasPlaceholders(String message){ 29 | if (!isEnabled){ 30 | return false; 31 | } 32 | return PlaceholderAPI.containsPlaceholders(message); 33 | } 34 | 35 | public boolean hasPlaceholders(String... messageList){ 36 | if (!isEnabled) { 37 | return false; 38 | } 39 | 40 | for (String s : messageList) { 41 | if (PlaceholderAPI.containsPlaceholders(s)){ 42 | return true; 43 | } 44 | } 45 | return false; 46 | } 47 | 48 | public String usePlaceholders(OfflinePlayer player, String message){ 49 | if (!isEnabled){ 50 | return message; 51 | } 52 | 53 | return PlaceholderAPI.setPlaceholders(player, message); 54 | } 55 | 56 | public List usePlaceholders(OfflinePlayer player, List messageList){ 57 | if (!isEnabled){ 58 | return messageList; 59 | } 60 | 61 | return PlaceholderAPI.setPlaceholders(player, messageList); 62 | } 63 | } 64 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/menus/helpers/MenuSwitchType.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.menus.helpers; 2 | 3 | public enum MenuSwitchType { 4 | DOUBLE, 5 | TRIPLE, 6 | DOUBLE_DISABLED, 7 | TRIPLE_DISABLED 8 | } 9 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/menus/list/PlayerPermListMenu.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.menus.list; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.claimobjects.Claim; 5 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 6 | import net.crashcraft.crashclaim.crashutils.menusystem.GUI; 7 | import net.crashcraft.crashclaim.crashutils.menusystem.defaultmenus.PlayerListMenu; 8 | import net.crashcraft.crashclaim.localization.Localization; 9 | import net.crashcraft.crashclaim.menus.permissions.SimplePermissionMenu; 10 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 11 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 12 | import net.md_5.bungee.api.chat.BaseComponent; 13 | import org.bukkit.Bukkit; 14 | import org.bukkit.entity.Player; 15 | import org.bukkit.metadata.MetadataValue; 16 | 17 | import java.util.ArrayList; 18 | import java.util.UUID; 19 | 20 | public class PlayerPermListMenu { 21 | public PlayerPermListMenu(BaseClaim claim, Player viewer, GUI previous){ 22 | if (!PermissionHelper.getPermissionHelper().hasPermission(claim, viewer.getUniqueId(), PermissionRoute.MODIFY_PERMISSIONS)){ 23 | viewer.spigot().sendMessage(Localization.MENU__GENERAL__INSUFFICIENT_PERMISSION.getMessage(viewer)); 24 | //Try and close an inventory, want to close a loose end just in case 25 | viewer.closeInventory(); 26 | return; 27 | } 28 | 29 | ArrayList uuids = new ArrayList<>(claim.getPerms().getPlayerPermissions().keySet()); 30 | 31 | for (Player player : Bukkit.getOnlinePlayers()){ 32 | if (isVanished(player)){ 33 | continue; 34 | } 35 | 36 | if (!uuids.contains(player.getUniqueId())) { 37 | uuids.add(player.getUniqueId()); 38 | } 39 | } 40 | 41 | uuids.remove(viewer.getUniqueId()); //Cant modify perms of yourself 42 | 43 | if (claim instanceof SubClaim){ //Owners permissions are off limits. 44 | SubClaim temp = (SubClaim) claim; 45 | uuids.remove(temp.getParent().getOwner()); 46 | } else if (claim instanceof Claim){ 47 | Claim temp = (Claim) claim; 48 | uuids.remove(temp.getOwner()); 49 | } else { 50 | throw new RuntimeException("Claim was not of known type."); 51 | } 52 | 53 | new PlayerListMenu(BaseComponent.toLegacyText(Localization.MENU__LIST_PLAYERS__TITLE.getMessage(null)), viewer, previous, uuids, (gui, uuid) -> { 54 | new SimplePermissionMenu(viewer, claim, uuid, gui).open(); 55 | return ""; 56 | }).open(); 57 | } 58 | 59 | private boolean isVanished(Player player) { 60 | for (MetadataValue meta : player.getMetadata("vanished")) { 61 | if (meta.asBoolean()) return true; 62 | } 63 | return false; 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/menus/list/SubClaimListMenu.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.menus.list; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.Claim; 4 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 5 | import net.crashcraft.crashclaim.config.GlobalConfig; 6 | import net.crashcraft.crashclaim.crashutils.menusystem.GUI; 7 | import net.crashcraft.crashclaim.localization.Localization; 8 | import net.crashcraft.crashclaim.menus.SubClaimMenu; 9 | import net.md_5.bungee.api.chat.BaseComponent; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.Material; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.inventory.InventoryClickEvent; 14 | import org.bukkit.inventory.ItemStack; 15 | 16 | import java.util.ArrayList; 17 | import java.util.HashMap; 18 | 19 | public class SubClaimListMenu extends GUI { 20 | private final GUI previousMenu; 21 | private final Claim claim; 22 | private final HashMap pageItemsDisplay; 23 | 24 | private int page = 1; 25 | private ArrayList claims; 26 | 27 | public SubClaimListMenu(Player player, GUI previousMenu, Claim claim) { 28 | super(player, BaseComponent.toLegacyText(Localization.MENU__SUB_CLAIM_LIST__TITLE.getMessage(null)), 54); 29 | this.previousMenu = previousMenu; 30 | this.claim = claim; 31 | this.pageItemsDisplay = new HashMap<>(); 32 | 33 | setupGUI(); 34 | } 35 | 36 | @Override 37 | public void initialize() { 38 | claims = claim.getSubClaims(); 39 | } 40 | 41 | @Override 42 | public void loadItems() { 43 | inv.clear(); 44 | 45 | ArrayList currentPageItems = getPageFromArray(); 46 | pageItemsDisplay.clear(); 47 | 48 | int slot = 10; 49 | for (SubClaim item : currentPageItems) { 50 | while ((slot % 9) < 1 || (slot % 9) > 7) { 51 | slot++; 52 | } 53 | 54 | pageItemsDisplay.put(slot, item); 55 | 56 | ItemStack descItem; 57 | 58 | if (item.getParent().getOwner().equals(getPlayer().getUniqueId())) { 59 | descItem = Localization.MENU__GENERAL__CLAIM_ITEM_NO_OWNER.getItem(player, 60 | "name", item.getName(), 61 | "min_x", Integer.toString(item.getMinX()), 62 | "min_z", Integer.toString(item.getMinZ()), 63 | "max_x", Integer.toString(item.getMaxX()), 64 | "max_z", Integer.toString(item.getMaxZ()), 65 | "world", Bukkit.getWorld(item.getWorld()).getName() 66 | ); 67 | } else { 68 | descItem = Localization.MENU__GENERAL__CLAIM_ITEM.getItem(player, 69 | "name", item.getName(), 70 | "min_x", Integer.toString(item.getMinX()), 71 | "min_z", Integer.toString(item.getMinZ()), 72 | "max_x", Integer.toString(item.getMaxX()), 73 | "max_z", Integer.toString(item.getMaxZ()), 74 | "world", Bukkit.getWorld(item.getWorld()).getName(), 75 | "owner", Bukkit.getOfflinePlayer(item.getParent().getOwner()).getName() 76 | ); 77 | } 78 | 79 | descItem.setType(GlobalConfig.visual_menu_items.getOrDefault(item.getWorld(), Material.OAK_FENCE)); 80 | 81 | inv.setItem(slot, descItem); 82 | 83 | slot++; 84 | } 85 | 86 | //Controls 87 | if (page > 1) { 88 | inv.setItem(48, Localization.MENU__GENERAL__PREVIOUS_BUTTON.getItem(player)); 89 | } 90 | 91 | int maxPages = (int) Math.ceil((float) claims.size() / 21); 92 | 93 | inv.setItem(49, Localization.MENU__GENERAL__PAGE_DISPLAY.getItem(player, 94 | "page", Integer.toString(page), 95 | "page_total", Integer.toString(maxPages == 0 ? 1 : maxPages) 96 | )); 97 | 98 | if (claims.size() > page * 21) { 99 | inv.setItem(50, Localization.MENU__GENERAL__NEXT_BUTTON.getItem(player)); 100 | } 101 | 102 | if (previousMenu != null) { 103 | inv.setItem(45, Localization.MENU__GENERAL__BACK_BUTTON.getItem(player)); 104 | } 105 | } 106 | 107 | @Override 108 | public void onClose() { 109 | 110 | } 111 | 112 | @Override 113 | public void onClick(InventoryClickEvent e, String rawItemName) { 114 | switch (e.getSlot()) { 115 | case 48: 116 | if (page > 1) { 117 | page--; 118 | loadItems(); 119 | } 120 | break; 121 | case 50: 122 | page++; 123 | loadItems(); 124 | break; 125 | case 45: 126 | if (previousMenu == null) { 127 | return; 128 | } 129 | previousMenu.open(); 130 | break; 131 | default: 132 | SubClaim claim = pageItemsDisplay.get(e.getSlot()); 133 | if (claim == null){ 134 | return; 135 | } 136 | new SubClaimMenu(player, claim).open(); 137 | break; 138 | } 139 | } 140 | 141 | private ArrayList getPageFromArray() { 142 | ArrayList pageItems = new ArrayList<>(); 143 | 144 | for (int x = 21 * (page - 1); x < 21 * page && x < claims.size(); x++) { 145 | pageItems.add(claims.get(x)); 146 | } 147 | 148 | return pageItems; 149 | } 150 | } 151 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/migration/MigrationAdapter.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.migration; 2 | 3 | import java.util.concurrent.CompletableFuture; 4 | 5 | public interface MigrationAdapter { 6 | /** 7 | * Make sure everything is in place before the migration continues 8 | * 9 | * @return an error message to be displayed and stops the migration 10 | */ 11 | String checkRequirements(MigrationManager manager); 12 | 13 | /** 14 | * 15 | * @param manager supplies needed methods to load data into memory 16 | * @return an error message if migration failed 17 | */ 18 | CompletableFuture migrate(MigrationManager manager); 19 | 20 | /** 21 | * Get an identifier for the migration adapter 22 | * 23 | * @return an identifier 24 | */ 25 | String getIdentifier(); 26 | } 27 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/migration/MigrationManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.migration; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.data.ClaimDataManager; 5 | import net.crashcraft.crashclaim.migration.adapters.GriefPreventionAdaptor; 6 | 7 | import java.util.ArrayList; 8 | import java.util.concurrent.CompletableFuture; 9 | import java.util.logging.Logger; 10 | 11 | public class MigrationManager { 12 | private final CrashClaim plugin; 13 | private final ClaimDataManager manager; 14 | private final Logger logger; 15 | private final ArrayList adapters; 16 | 17 | public MigrationManager(CrashClaim plugin){ 18 | this.plugin = plugin; 19 | this.manager = plugin.getDataManager(); 20 | this.logger = plugin.getLogger(); 21 | this.adapters = new ArrayList<>(); 22 | 23 | adapters.add(new GriefPreventionAdaptor()); 24 | } 25 | 26 | public CompletableFuture migrate(MigrationAdapter adapter){ 27 | String requirementCheck = adapter.checkRequirements(this); 28 | if (requirementCheck != null){ 29 | return CompletableFuture.completedFuture("Requirement Check Failed: " + requirementCheck); 30 | } 31 | 32 | plugin.getLogger().info("Starting data migration with [" + adapter.getIdentifier() + "]"); 33 | CompletableFuture migrateFuture = new CompletableFuture<>(); 34 | CompletableFuture completableFuture = adapter.migrate(this); 35 | completableFuture.thenAccept((error) -> { 36 | if (error != null){ 37 | plugin.getLogger().severe("Data migration failed with error: " + error); 38 | 39 | migrateFuture.complete(error); 40 | } 41 | plugin.getLogger().info("Data migration completed successfully"); 42 | 43 | plugin.getLogger().info("Force data save starting..."); 44 | manager.forceSaveClaims().thenAccept((a) -> { 45 | plugin.getLogger().info("Force data save finished."); 46 | migrateFuture.complete(null); 47 | }); 48 | }); 49 | 50 | return migrateFuture; 51 | } 52 | 53 | public MigrationAdapter getMigrationAdaptor(String name){ 54 | String realName = name.toLowerCase(); 55 | 56 | for (MigrationAdapter adapter : adapters){ 57 | if (adapter.getIdentifier().toLowerCase().equals(realName)){ 58 | return adapter; 59 | } 60 | } 61 | 62 | return null; 63 | } 64 | 65 | public ArrayList getAdapters() { 66 | return adapters; 67 | } 68 | 69 | public ClaimDataManager getManager() { 70 | return manager; 71 | } 72 | 73 | public Logger getLogger() { 74 | return logger; 75 | } 76 | } 77 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/packet/PacketHandler.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.packet; 2 | 3 | import com.github.retrooper.packetevents.PacketEvents; 4 | import com.github.retrooper.packetevents.protocol.entity.data.EntityData; 5 | import com.github.retrooper.packetevents.protocol.entity.data.EntityDataTypes; 6 | import com.github.retrooper.packetevents.protocol.entity.type.EntityTypes; 7 | import com.github.retrooper.packetevents.util.Vector3d; 8 | import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerDestroyEntities; 9 | import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerEntityMetadata; 10 | import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerSpawnEntity; 11 | import com.github.retrooper.packetevents.wrapper.play.server.WrapperPlayServerTeams; 12 | import org.bukkit.Location; 13 | import org.bukkit.entity.Player; 14 | 15 | import java.util.*; 16 | 17 | public class PacketHandler { 18 | 19 | public void setEntityTeam(Player player, String team, List uuids){ 20 | WrapperPlayServerTeams.ScoreBoardTeamInfo teamInfo = new WrapperPlayServerTeams.ScoreBoardTeamInfo( 21 | null, null, null, null, null, null, null 22 | ); 23 | 24 | WrapperPlayServerTeams packet = new WrapperPlayServerTeams(team, WrapperPlayServerTeams.TeamMode.ADD_ENTITIES, teamInfo, uuids); 25 | 26 | PacketEvents.getAPI().getPlayerManager().sendPacket(player, packet); 27 | 28 | } 29 | 30 | public void removeEntity(Player player, Set entity_ids){ 31 | WrapperPlayServerDestroyEntities packet = new WrapperPlayServerDestroyEntities(entity_ids.stream().mapToInt(Integer::intValue).toArray()); 32 | PacketEvents.getAPI().getPlayerManager().sendPacket(player, packet); 33 | } 34 | 35 | public void spawnGlowingInvisibleMagmaSlime(Player player, double x, double z, double y, int id, UUID uuid, 36 | HashMap fakeEntities, HashMap entityLocations) { 37 | WrapperPlayServerSpawnEntity spawnEntityPacket = new WrapperPlayServerSpawnEntity(id, uuid, EntityTypes.MAGMA_CUBE, 38 | new com.github.retrooper.packetevents.protocol.world.Location(x, y, z, 0f, 0f), (float) 0, 0, new Vector3d(0, 0, 0)); 39 | 40 | List metadata = new ArrayList<>(); 41 | byte bytevalues = 0x20 | 0x40; 42 | metadata.add(new EntityData(0, EntityDataTypes.BYTE, bytevalues)); 43 | metadata.add(new EntityData(16, EntityDataTypes.INT, 2)); 44 | WrapperPlayServerEntityMetadata metadataPacket = new WrapperPlayServerEntityMetadata(id, metadata); 45 | 46 | PacketEvents.getAPI().getPlayerManager().sendPacket(player, spawnEntityPacket); 47 | PacketEvents.getAPI().getPlayerManager().sendPacket(player, metadataPacket); 48 | 49 | fakeEntities.put(id, uuid.toString()); 50 | entityLocations.put(id, new Location(player.getWorld(), x, y, z)); 51 | } 52 | } 53 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/PaymentProcessor.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | import org.bukkit.Bukkit; 4 | import org.bukkit.plugin.java.JavaPlugin; 5 | 6 | import java.util.UUID; 7 | import java.util.function.Consumer; 8 | 9 | public class PaymentProcessor { 10 | private final JavaPlugin plugin; 11 | private final PaymentProvider provider; 12 | 13 | PaymentProcessor(PaymentProvider provider, JavaPlugin plugin) throws ProviderInitializationException { 14 | this.plugin = plugin; 15 | 16 | if (provider == null || !provider.checkRequirements()) { 17 | throw new RuntimeException("Payment processor was null or failed requirements"); 18 | } 19 | 20 | this.provider = provider; 21 | 22 | provider.setup(); 23 | } 24 | 25 | public void makeTransaction(UUID user, TransactionType type, String comment, double amount, Consumer callback){ 26 | if (amount == 0){ 27 | callback.accept(new TransactionRecipe(user, amount, "Payment Processor Requirement Check", "Transaction amount cannot be 0")); 28 | } 29 | provider.makeTransaction(user, type, comment, amount, callback); 30 | } 31 | 32 | public void makeTransaction(UUID user, String comment, double amount, Consumer callback){ 33 | makeTransaction(user, amount > 0 ? TransactionType.DEPOSIT : TransactionType.WITHDRAW, comment, amount, callback); 34 | } 35 | 36 | public void getBalance(UUID user, Consumer callback){ 37 | provider.getBalance(user, callback); 38 | } 39 | 40 | public void makeTransactionSync(UUID user, TransactionType type, String comment, double amount, Consumer callback){ 41 | Bukkit.getScheduler().runTask(plugin, () -> { 42 | if (amount == 0){ 43 | callback.accept(new TransactionRecipe(user, amount, "Payment Processor Requirement Check", "Transaction amount cannot be 0")); 44 | } 45 | provider.makeTransaction(user, type, comment, amount, callback); 46 | }); 47 | } 48 | 49 | public void makeTransactionSync(UUID user, String comment, double amount, Consumer callback){ 50 | Bukkit.getScheduler().runTask(plugin, () -> { 51 | makeTransaction(user, amount > 0 ? TransactionType.DEPOSIT : TransactionType.WITHDRAW, comment, amount, callback); 52 | }); 53 | } 54 | 55 | public void getBalanceSync(UUID user, Consumer callback){ 56 | Bukkit.getScheduler().runTask(plugin, () -> { 57 | provider.getBalance(user, callback); 58 | }); 59 | } 60 | 61 | public PaymentProvider getProvider() { 62 | return provider; 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/PaymentProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | import java.util.UUID; 4 | import java.util.function.Consumer; 5 | 6 | public interface PaymentProvider { 7 | String getProviderIdentifier(); 8 | 9 | boolean checkRequirements(); 10 | 11 | void setup() throws ProviderInitializationException; 12 | 13 | void makeTransaction(UUID user, TransactionType type, String comment, double amount, Consumer callback); 14 | 15 | void getBalance(UUID user, Consumer callback); 16 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/ProcessorManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | import net.crashcraft.crashclaim.payment.providers.FakePaymentProvider; 4 | import net.crashcraft.crashclaim.payment.providers.VaultPaymentProvider; 5 | import org.bukkit.Bukkit; 6 | import org.bukkit.plugin.RegisteredServiceProvider; 7 | import org.bukkit.plugin.ServicePriority; 8 | import org.bukkit.plugin.java.JavaPlugin; 9 | 10 | import java.util.logging.Logger; 11 | 12 | public class ProcessorManager { 13 | private PaymentProcessor processor; 14 | 15 | public ProcessorManager(JavaPlugin plugin, String providerOverride) throws ProviderInitializationException{ 16 | Logger logger = plugin.getLogger(); 17 | 18 | if (providerOverride == null){ 19 | providerOverride = ""; 20 | } 21 | 22 | ServicePriority tempPriority = null; 23 | PaymentProvider paymentProvider = null; 24 | 25 | for (RegisteredServiceProvider provider : Bukkit.getServicesManager().getRegistrations(PaymentProvider.class)){ 26 | if (paymentProvider == null){ 27 | tempPriority = provider.getPriority(); 28 | paymentProvider = provider.getProvider(); 29 | } else if (tempPriority.ordinal() < provider.getPriority().ordinal()){ 30 | tempPriority = provider.getPriority(); 31 | paymentProvider = provider.getProvider(); 32 | } else if (provider.getProvider().getProviderIdentifier().equalsIgnoreCase(providerOverride)){ 33 | paymentProvider = provider.getProvider(); 34 | break; 35 | } 36 | } 37 | 38 | if (paymentProvider != null){ 39 | logger.info("Using " + paymentProvider.getProviderIdentifier() + " as a payment processor"); 40 | processor = new PaymentProcessor(paymentProvider, plugin); 41 | } else if (Bukkit.getServer().getPluginManager().getPlugin("Vault") != null){ //Try and default to vault 42 | try { 43 | logger.info("Using Vault as a payment processor"); 44 | processor = new PaymentProcessor(new VaultPaymentProvider(), plugin); 45 | } catch (ProviderInitializationException e){ 46 | logger.severe("Vault was unable to supply a valid economy, payments will be reverted to a fake payment provider where all transactions will be approved."); 47 | processor = new PaymentProcessor(new FakePaymentProvider(), plugin); 48 | } 49 | } else { 50 | logger.severe("No payment provider was found, payments will be reverted to a fake payment provider where all transactions will be approved."); 51 | processor = new PaymentProcessor(new FakePaymentProvider(), plugin); 52 | } 53 | } 54 | 55 | public PaymentProcessor getProcessor(){ 56 | return processor; 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/ProviderInitializationException.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | public class ProviderInitializationException extends Exception{ 4 | public ProviderInitializationException(){ 5 | super("Unable to initialize payment provider"); 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/TransactionRecipe.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | import java.util.UUID; 4 | 5 | public class TransactionRecipe { 6 | private final UUID owner; 7 | 8 | private final String comment; 9 | private final double amount; 10 | 11 | private final String transactionError; 12 | 13 | public TransactionRecipe(UUID owner, double amount, String comment) { 14 | this.owner = owner; 15 | this.comment = comment; 16 | this.amount = amount; 17 | this.transactionError = null; 18 | } 19 | 20 | public TransactionRecipe(UUID owner, double amount, String comment, String transactionError) { 21 | this.owner = owner; 22 | this.comment = comment; 23 | this.amount = amount; 24 | this.transactionError = transactionError; 25 | } 26 | 27 | public boolean transactionSuccess(){ 28 | return transactionError == null; 29 | } 30 | 31 | public TransactionResponse getTransactionStatus(){ 32 | return transactionError == null ? TransactionResponse.SUCCESS : TransactionResponse.ERROR; 33 | } 34 | 35 | public UUID getOwner() { 36 | return owner; 37 | } 38 | 39 | public String getComment() { 40 | return comment; 41 | } 42 | 43 | public double getAmount() { 44 | return amount; 45 | } 46 | 47 | public String getTransactionError() { 48 | return transactionError; 49 | } 50 | } 51 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/TransactionResponse.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | public enum TransactionResponse { 4 | SUCCESS, 5 | ERROR 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/TransactionType.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment; 2 | 3 | public enum TransactionType { 4 | WITHDRAW, 5 | DEPOSIT 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/credits.txt: -------------------------------------------------------------------------------- 1 | Code taken from https://github.com/Chasewhip8/CrashPayment -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/providers/FakePaymentProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment.providers; 2 | 3 | 4 | import net.crashcraft.crashclaim.payment.PaymentProvider; 5 | import net.crashcraft.crashclaim.payment.ProviderInitializationException; 6 | import net.crashcraft.crashclaim.payment.TransactionRecipe; 7 | import net.crashcraft.crashclaim.payment.TransactionType; 8 | 9 | import java.util.UUID; 10 | import java.util.function.Consumer; 11 | 12 | public class FakePaymentProvider implements PaymentProvider { 13 | @Override 14 | public String getProviderIdentifier() { 15 | return "Fake Transaction Processor"; 16 | } 17 | 18 | @Override 19 | public boolean checkRequirements() { 20 | return true; 21 | } 22 | 23 | @Override 24 | public void setup() throws ProviderInitializationException { 25 | 26 | } 27 | 28 | @Override 29 | public void makeTransaction(UUID user, TransactionType type, String comment, double amount, Consumer callback) { 30 | callback.accept(new TransactionRecipe(user, amount, comment)); 31 | } 32 | 33 | @Override 34 | public void getBalance(UUID user, Consumer callback) { 35 | callback.accept(Double.MAX_VALUE); 36 | } 37 | } 38 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/payment/providers/VaultPaymentProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.payment.providers; 2 | 3 | import net.crashcraft.crashclaim.payment.PaymentProvider; 4 | import net.crashcraft.crashclaim.payment.ProviderInitializationException; 5 | import net.crashcraft.crashclaim.payment.TransactionRecipe; 6 | import net.crashcraft.crashclaim.payment.TransactionType; 7 | import net.milkbowl.vault.economy.Economy; 8 | import net.milkbowl.vault.economy.EconomyResponse; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.plugin.RegisteredServiceProvider; 11 | 12 | import java.util.UUID; 13 | import java.util.function.Consumer; 14 | 15 | public class VaultPaymentProvider implements PaymentProvider { 16 | private Economy economy; 17 | 18 | @Override 19 | public String getProviderIdentifier() { 20 | return "VaultPaymentProvider"; 21 | } 22 | 23 | @Override 24 | public boolean checkRequirements() { 25 | return Bukkit.getServer().getPluginManager().getPlugin("Vault") != null; 26 | } 27 | 28 | @Override 29 | public void setup() throws ProviderInitializationException { 30 | RegisteredServiceProvider rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class); 31 | 32 | if (rsp == null) { 33 | throw new ProviderInitializationException(); 34 | } 35 | 36 | economy = rsp.getProvider(); 37 | } 38 | 39 | @Override 40 | public void makeTransaction(UUID user, TransactionType type, String comment, double amount, Consumer callback) { 41 | EconomyResponse response = null; 42 | 43 | switch (type){ 44 | case DEPOSIT: 45 | response = economy.depositPlayer(Bukkit.getOfflinePlayer(user), comment, amount); 46 | break; 47 | case WITHDRAW: 48 | response = economy.withdrawPlayer(Bukkit.getOfflinePlayer(user), comment, amount); 49 | break; 50 | } 51 | 52 | if (response == null) { 53 | callback.accept(new TransactionRecipe(user, amount, comment, "Vault response is null")); 54 | return; 55 | } 56 | 57 | if (response.transactionSuccess()) { 58 | callback.accept(new TransactionRecipe(user, amount, comment)); 59 | } else { 60 | callback.accept(new TransactionRecipe(user, amount, comment, response.errorMessage)); 61 | } 62 | } 63 | 64 | @Override 65 | public void getBalance(UUID user, Consumer callback) { 66 | callback.accept(economy.getBalance(Bukkit.getOfflinePlayer(user))); 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/permissions/BypassManager.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.permissions; 2 | 3 | import org.bukkit.event.EventHandler; 4 | import org.bukkit.event.Listener; 5 | import org.bukkit.event.player.PlayerJoinEvent; 6 | 7 | import java.util.ArrayList; 8 | import java.util.UUID; 9 | 10 | public class BypassManager implements Listener { 11 | private final ArrayList bypassMode; 12 | 13 | public BypassManager(){ 14 | bypassMode = new ArrayList<>(); 15 | } 16 | 17 | public boolean isBypass(UUID uuid){ 18 | return bypassMode.contains(uuid); 19 | } 20 | 21 | public boolean toggleBypass(UUID uuid){ 22 | if (bypassMode.contains(uuid)){ 23 | bypassMode.remove(uuid); 24 | return false; 25 | } else { 26 | bypassMode.add(uuid); 27 | return true; 28 | } 29 | } 30 | 31 | public void removeBypass(UUID uuid){ 32 | bypassMode.remove(uuid); 33 | } 34 | 35 | public void addBypass(UUID uuid){ 36 | bypassMode.add(uuid); 37 | } 38 | 39 | @EventHandler 40 | public void onJoin(PlayerJoinEvent e){ 41 | bypassMode.remove(e.getPlayer().getUniqueId()); 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/permissions/PermissionHelper.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.permissions; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 5 | import net.crashcraft.crashclaim.claimobjects.Claim; 6 | import net.crashcraft.crashclaim.claimobjects.PermState; 7 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 8 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 9 | import net.crashcraft.crashclaim.data.ClaimDataManager; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.Location; 12 | import org.bukkit.Material; 13 | 14 | import java.util.UUID; 15 | 16 | @SuppressWarnings("Duplicates") 17 | public class PermissionHelper { 18 | private static PermissionHelper helper; 19 | 20 | private final ClaimDataManager manager; 21 | private final BypassManager bypassManager; 22 | 23 | public PermissionHelper(ClaimDataManager manager){ 24 | helper = this; 25 | 26 | this.manager = manager; 27 | this.bypassManager = new BypassManager(); 28 | 29 | Bukkit.getPluginManager().registerEvents(bypassManager, CrashClaim.getPlugin()); 30 | } 31 | 32 | public Boolean hasPermission(BaseClaim claim, UUID player, PermissionRoute route){ 33 | if (bypassManager.isBypass(player)){ 34 | return true; 35 | } 36 | 37 | // Override owner to grant permissions 38 | if (claim instanceof SubClaim subClaim && subClaim.getParent().getOwner().equals(player)){ 39 | return true; 40 | } 41 | 42 | PlayerPermissionSet set = claim.getPerms().getPlayerPermissionSet(player); 43 | if (set == null){ 44 | return false; 45 | } else { 46 | int value = route.getPerm(set); 47 | if (value == 4){ 48 | return null; 49 | } 50 | return value == PermState.ENABLED; 51 | } 52 | } 53 | 54 | public Boolean hasPermission(BaseClaim claim, UUID player, Material material){ 55 | if (bypassManager.isBypass(player)){ 56 | return true; 57 | } 58 | 59 | // Override owner to grant permissions 60 | if (claim instanceof SubClaim subClaim && subClaim.getParent().getOwner().equals(player)){ 61 | return true; 62 | } 63 | 64 | PlayerPermissionSet set = claim.getPerms().getPlayerPermissionSet(player); 65 | return set != null && PermissionRoute.CONTAINERS.getPerm(set, material) == PermState.ENABLED; 66 | } 67 | 68 | public Boolean hasPermission(UUID player, Location location, Material material){ 69 | if (bypassManager.isBypass(player)){ 70 | return true; 71 | } 72 | 73 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 74 | if (claim == null){ 75 | return true; 76 | } else { 77 | return claim.hasPermission(player, location, material); 78 | } 79 | } 80 | 81 | public Boolean hasPermission(UUID player, Location location, PermissionRoute route){ 82 | if (bypassManager.isBypass(player)){ 83 | return true; 84 | } 85 | 86 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 87 | if (claim == null){ 88 | return true; 89 | } else { 90 | return claim.hasPermission(player, location, route); 91 | } 92 | } 93 | 94 | public Boolean hasPermission(Location location, Material material){ 95 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 96 | if (claim == null){ 97 | return true; 98 | } else { 99 | return claim.hasPermission(location, material); 100 | } 101 | } 102 | 103 | public Boolean hasPermission(Location location, PermissionRoute route) { 104 | Claim claim = manager.getClaim(location.getBlockX(), location.getBlockZ(), location.getWorld().getUID()); 105 | if (claim == null) { 106 | return true; 107 | } else { 108 | return claim.hasPermission(location, route); 109 | } 110 | } 111 | 112 | public BypassManager getBypassManager() { 113 | return bypassManager; 114 | } 115 | 116 | public static PermissionHelper getPermissionHelper(){ 117 | return helper; 118 | } 119 | } 120 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/permissions/PermissionRouter.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.permissions; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.Claim; 4 | import net.crashcraft.crashclaim.claimobjects.PermissionGroup; 5 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 6 | import net.crashcraft.crashclaim.claimobjects.permission.GlobalPermissionSet; 7 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 8 | import org.bukkit.Material; 9 | 10 | import java.util.UUID; 11 | 12 | public class PermissionRouter { 13 | /* 14 | 0 - Disable, 1 - Enable - 2 - Neutral 15 | 16 | Neutral fall back to previous layer 17 | 18 | Global Group [ build: 0, interactions: 1, container{ chest }: 0 ] 19 | Main Group [ build: 0, interactions: 2, container{ chest }: 1 ] 20 | Sub Group [ build: 1, interactions: 2, container{ chest }: 2 ] 21 | 22 | Output [ build: 1, interactions: 1, container{ chest }: 1 ] 23 | */ 24 | 25 | private static int processPerm(int primary, int secondary){ 26 | return secondary == 2 ? primary : secondary; 27 | } 28 | 29 | public static int getLayeredPermission(Claim parent, SubClaim subClaim, PermissionRoute route){ 30 | if (subClaim != null){ 31 | return processPerm(route.getPerm(parent.getPerms().getGlobalPermissionSet()), route.getPerm(subClaim.getPerms().getGlobalPermissionSet())); 32 | } else { 33 | return route.getPerm(parent.getPerms().getGlobalPermissionSet()); 34 | } 35 | } 36 | 37 | public static int getLayeredPermission(Claim parent, SubClaim subClaim, Material material){ 38 | if (subClaim != null){ 39 | return processPerm(PermissionRoute.CONTAINERS.getPerm(parent.getPerms().getGlobalPermissionSet(), material), 40 | PermissionRoute.CONTAINERS.getPerm(subClaim.getPerms().getGlobalPermissionSet(), material)); 41 | } else { 42 | return PermissionRoute.CONTAINERS.getPerm(parent.getPerms().getGlobalPermissionSet(), material); 43 | } 44 | } 45 | 46 | public static int getLayeredPermission(GlobalPermissionSet global, GlobalPermissionSet main, PermissionRoute route){ 47 | return processPerm(route.getPerm(global), route.getPerm(main)); 48 | } 49 | 50 | public static int getLayeredPermission(GlobalPermissionSet global, GlobalPermissionSet main, Material material){ 51 | return processPerm(PermissionRoute.CONTAINERS.getPerm(global, material), PermissionRoute.CONTAINERS.getPerm(main, material)); 52 | } 53 | 54 | public static int getLayeredPermission(GlobalPermissionSet global, PlayerPermissionSet main, PermissionRoute route){ 55 | return main == null ? route.getPerm(global) : processPerm(route.getPerm(global), route.getPerm(main)); 56 | 57 | // return processPerm(route.getPerm(global), main == null ? PermState.NEUTRAL : route.getPerm(main)); 58 | } 59 | 60 | public static int getLayeredPermission(Claim parent, SubClaim subClaim, UUID uuid, PermissionRoute route){ 61 | PermissionGroup parentPerms = parent.getPerms(); 62 | if (subClaim == null){ 63 | PlayerPermissionSet main = parentPerms.getPlayerPermissionSet(uuid); 64 | if (main == null){ 65 | return route.getPerm(parentPerms.getGlobalPermissionSet()); 66 | } else return getLayeredPermission(parentPerms.getGlobalPermissionSet(), main, route); 67 | } else { 68 | PermissionGroup subPerms = subClaim.getPerms(); 69 | 70 | PlayerPermissionSet parentMainSet = parentPerms.getPlayerPermissionSet(uuid); 71 | PlayerPermissionSet subMainSet = subPerms.getPlayerPermissionSet(uuid); 72 | 73 | return processPerm( 74 | getLayeredPermission(parentPerms.getGlobalPermissionSet(), parentMainSet, route), 75 | getLayeredPermission(subPerms.getGlobalPermissionSet(), subMainSet, route) 76 | ); 77 | } 78 | } 79 | 80 | /* 81 | if null or -1 82 | treat as neutral 83 | */ 84 | 85 | 86 | public static int getLayeredContainer(GlobalPermissionSet parent, PlayerPermissionSet secondary, Material material){ 87 | return secondary == null ? PermissionRoute.CONTAINERS.getPerm(parent, material) : processPerm(PermissionRoute.CONTAINERS.getPerm(parent, material), 88 | PermissionRoute.CONTAINERS.getPerm(secondary, material)); 89 | 90 | // return processPerm(route.getPerm(global), main == null ? PermState.NEUTRAL : route.getPerm(main)); 91 | } 92 | 93 | public static int getLayeredContainer(Claim parent, SubClaim subClaim, UUID uuid, Material material){ 94 | PermissionGroup parentPerms = parent.getPerms(); 95 | if (subClaim == null){ 96 | PlayerPermissionSet main = parentPerms.getPlayerPermissionSet(uuid); 97 | if (main == null){ 98 | return PermissionRoute.CONTAINERS.getPerm(parentPerms.getGlobalPermissionSet(), material); 99 | } else return getLayeredContainer(parentPerms.getGlobalPermissionSet(), main, material); 100 | } else { 101 | PermissionGroup subPerms = subClaim.getPerms(); 102 | 103 | PlayerPermissionSet parentMainSet = parentPerms.getPlayerPermissionSet(uuid); 104 | PlayerPermissionSet subMainSet = subPerms.getPlayerPermissionSet(uuid); 105 | 106 | return processPerm( 107 | getLayeredContainer(parentPerms.getGlobalPermissionSet(), parentMainSet, material), 108 | getLayeredContainer(subPerms.getGlobalPermissionSet(), subMainSet, material) 109 | ); 110 | } 111 | } 112 | } 113 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/permissions/PermissionSetup.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.permissions; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.claimobjects.PermState; 5 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 6 | import org.bukkit.Material; 7 | import org.bukkit.block.Container; 8 | import org.bukkit.configuration.file.FileConfiguration; 9 | import org.bukkit.configuration.file.YamlConfiguration; 10 | import org.bukkit.inventory.BlockInventoryHolder; 11 | import org.bukkit.inventory.ItemStack; 12 | import org.bukkit.inventory.meta.BlockStateMeta; 13 | 14 | import java.io.File; 15 | import java.nio.file.Paths; 16 | import java.util.ArrayList; 17 | import java.util.HashMap; 18 | import java.util.logging.Logger; 19 | 20 | public class PermissionSetup { 21 | private final ArrayList trackedContainers; 22 | private final ArrayList untrackedBlocks; 23 | private final ArrayList extraInteractables; 24 | private final ArrayList heldItemInteraction; 25 | 26 | private final PlayerPermissionSet ownerPermissionSet; 27 | 28 | public PermissionSetup(CrashClaim claim){ 29 | Logger logger = claim.getLogger(); 30 | 31 | trackedContainers = new ArrayList<>(); 32 | untrackedBlocks = new ArrayList<>(); 33 | extraInteractables = new ArrayList<>(); 34 | heldItemInteraction = new ArrayList<>(); 35 | 36 | for (Material material : Material.values()){ 37 | ItemStack stack = new ItemStack(material); 38 | 39 | if (stack.getItemMeta() instanceof BlockStateMeta) { 40 | BlockStateMeta meta = (BlockStateMeta) stack.getItemMeta(); 41 | 42 | if (meta == null) 43 | continue; 44 | // checking for BlockInventoryHolder instead of Container due to blocks such as decorated pots technically not being containers, but they still should be here. 45 | // also has the added benefit of being able to specify jukebox usage etc. 46 | if (meta.getBlockState() instanceof BlockInventoryHolder) { 47 | trackedContainers.add(material); 48 | } 49 | } 50 | } 51 | 52 | FileConfiguration lookup = YamlConfiguration.loadConfiguration(new File(Paths.get(claim.getDataFolder().getAbsolutePath(), "lookup.yml").toUri())); 53 | 54 | for (String name : lookup.getStringList("additional-tracked-interactables")){ 55 | if (name.equals("")) 56 | continue; 57 | 58 | Material material = Material.getMaterial(name); 59 | 60 | if (material != null) { 61 | extraInteractables.add(material); 62 | } else { 63 | logger.warning("Material was not found whole parsing lookup.yml -> additional-tracked-interactables: " + name + 64 | "\n Make sure to be using the Bukkit Material names."); 65 | } 66 | } 67 | 68 | for (String name : lookup.getStringList("untracked-blocks")){ 69 | if (name.equals("")) { 70 | continue; 71 | } 72 | 73 | Material material = Material.getMaterial(name); 74 | 75 | if (material != null) { 76 | untrackedBlocks.add(material); 77 | trackedContainers.remove(material); 78 | extraInteractables.remove(material); 79 | } else { 80 | logger.warning("Material was not found whole parsing lookup.yml -> untracked-blocks: " + name + 81 | "\nMake sure to be using the Bukkit Material names."); 82 | } 83 | } 84 | 85 | for (String name : lookup.getStringList("tracked-heldItemInteraction")){ 86 | if (name.equals("")) { 87 | continue; 88 | } 89 | 90 | Material material = Material.getMaterial(name); 91 | 92 | if (material != null) { 93 | heldItemInteraction.add(material); 94 | } else { 95 | logger.warning("Material was not found whole parsing lookup.yml -> tracked-heldItemInteraction: " + name + 96 | "\n Make sure to be using the Bukkit Material names."); 97 | } 98 | } 99 | 100 | HashMap temp = new HashMap<>(); 101 | 102 | for (Material material : trackedContainers){ 103 | temp.put(material, PermState.ENABLED); 104 | } 105 | 106 | ownerPermissionSet = new PlayerPermissionSet(PermState.ENABLED, 107 | PermState.ENABLED, 108 | PermState.ENABLED, 109 | PermState.ENABLED, 110 | PermState.ENABLED, 111 | PermState.ENABLED, 112 | temp, 113 | PermState.ENABLED, 114 | PermState.ENABLED, 115 | PermState.ENABLED); 116 | } 117 | 118 | public ArrayList getTrackedContainers() { 119 | return trackedContainers; 120 | } 121 | 122 | public ArrayList getUntrackedBlocks() { 123 | return untrackedBlocks; 124 | } 125 | 126 | public ArrayList getExtraInteractables() { 127 | return extraInteractables; 128 | } 129 | 130 | public PlayerPermissionSet getOwnerPermissionSet() { 131 | return ownerPermissionSet; 132 | } 133 | 134 | public ArrayList getHeldItemInteraction() { 135 | return heldItemInteraction; 136 | } 137 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/PluginSupport.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport; 2 | 3 | import net.crashcraft.crashclaim.config.GroupSettings; 4 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 5 | import org.bukkit.Location; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.plugin.Plugin; 8 | 9 | public interface PluginSupport { 10 | 11 | boolean isUnsupportedVersion(String version); 12 | 13 | boolean canLoad(); 14 | 15 | String getPluginName(); 16 | 17 | void load(Plugin plugin); 18 | 19 | void enable(Plugin plugin); 20 | 21 | void disable(); 22 | 23 | default boolean canClaim(Location minLoc, Location maxLoc) { 24 | return true; 25 | } 26 | 27 | default boolean canInteract(Player player, Location location) { 28 | return false; 29 | } 30 | 31 | default GroupSettings getPlayerGroupSettings(Player player) { 32 | return null; 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/PluginSupportDistributor.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.api.CrashClaimAPI; 5 | import net.crashcraft.crashclaim.config.GlobalConfig; 6 | import net.crashcraft.crashclaim.config.GroupSettings; 7 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 8 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.Location; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.plugin.Plugin; 13 | 14 | import java.util.Set; 15 | 16 | public class PluginSupportDistributor implements PluginSupport { 17 | private final Set enabled; 18 | private final CrashClaim crashClaim; 19 | 20 | public PluginSupportDistributor(PluginSupportManager manager, CrashClaim crashClaim) { 21 | enabled = manager.getEnabledSupport(); 22 | this.crashClaim = crashClaim; 23 | } 24 | 25 | @Override 26 | public boolean isUnsupportedVersion(String version) { 27 | throw new RuntimeException("Unsupported Operation."); 28 | } 29 | 30 | @Override 31 | public boolean canLoad() { 32 | return true; 33 | } 34 | 35 | @Override 36 | public String getPluginName() { 37 | throw new RuntimeException("Unsupported Operation."); 38 | } 39 | 40 | @Override 41 | public void load(Plugin plugin) { 42 | throw new RuntimeException("Unsupported Operation."); 43 | } 44 | 45 | @Override 46 | public void enable(Plugin plugin) { 47 | throw new RuntimeException("Unsupported Operation."); 48 | } 49 | 50 | @Override 51 | public void disable() { 52 | throw new RuntimeException("Unsupported Operation."); 53 | } 54 | 55 | @Override 56 | public boolean canClaim(Location minLoc, Location maxLoc) { 57 | for (PluginSupport support : enabled) { 58 | if (!support.canClaim(minLoc, maxLoc)) { 59 | return false; 60 | } 61 | } 62 | 63 | return true; 64 | } 65 | 66 | @Override 67 | public boolean canInteract(Player player, Location location) { 68 | for (PluginSupport support : enabled) { 69 | if (support.canInteract(player, location)) { 70 | return true; 71 | } 72 | } 73 | return crashClaim.getApi().getPermissionHelper().hasPermission(player.getUniqueId(), location, PermissionRoute.INTERACTIONS); 74 | } 75 | 76 | @Override 77 | public GroupSettings getPlayerGroupSettings(Player player) { 78 | for (PluginSupport support : enabled) { 79 | GroupSettings groupSettings = support.getPlayerGroupSettings(player); 80 | if (groupSettings != null) { 81 | return groupSettings; 82 | } 83 | } 84 | return GlobalConfig.groupSettings.get("default"); 85 | } 86 | } 87 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/PluginSupportLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport; 2 | 3 | import org.bukkit.plugin.Plugin; 4 | 5 | public interface PluginSupportLoader { 6 | boolean isUnsupportedVersion(String version); 7 | 8 | boolean canLoad(); 9 | 10 | String getPluginName(); 11 | 12 | void load(Plugin plugin); 13 | } 14 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/loader/DeluxeSellwandSupportLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.loader; 2 | 3 | import com.google.auto.service.AutoService; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupportLoader; 6 | import net.crashcraft.crashclaim.pluginsupport.plugins.DeluxeSellwandSupport; 7 | import net.crashcraft.crashclaim.pluginsupport.plugins.LuckPermsSupport; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.plugin.Plugin; 10 | 11 | @AutoService(PluginSupportLoader.class) 12 | public class DeluxeSellwandSupportLoader implements PluginSupportLoader { 13 | 14 | @Override 15 | public boolean isUnsupportedVersion(String version) { 16 | return false; 17 | } 18 | 19 | @Override 20 | public boolean canLoad() { 21 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 22 | } 23 | 24 | @Override 25 | public String getPluginName() { 26 | return "DeluxeSellwands"; 27 | } 28 | 29 | @Override 30 | public void load(Plugin plugin) { 31 | CrashClaim.getPlugin().getPluginSupportManager().register(new DeluxeSellwandSupport()); 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/loader/LuckPermSupportLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.loader; 2 | 3 | import com.google.auto.service.AutoService; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupportLoader; 6 | import net.crashcraft.crashclaim.pluginsupport.plugins.LuckPermsSupport; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.plugin.Plugin; 9 | 10 | @AutoService(PluginSupportLoader.class) 11 | public class LuckPermSupportLoader implements PluginSupportLoader { 12 | 13 | @Override 14 | public boolean isUnsupportedVersion(String version) { 15 | return false; 16 | } 17 | 18 | @Override 19 | public boolean canLoad() { 20 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 21 | } 22 | 23 | @Override 24 | public String getPluginName() { 25 | return "LuckPerms"; 26 | } 27 | 28 | @Override 29 | public void load(Plugin plugin) { 30 | CrashClaim.getPlugin().getPluginSupportManager().register(new LuckPermsSupport()); 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/loader/QuickShopHikariSupportLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.loader; 2 | 3 | import com.google.auto.service.AutoService; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupportLoader; 6 | import net.crashcraft.crashclaim.pluginsupport.plugins.QuickShopHikariSupport; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.plugin.Plugin; 9 | 10 | @AutoService(PluginSupportLoader.class) 11 | public class QuickShopHikariSupportLoader implements PluginSupportLoader { 12 | @Override 13 | public boolean isUnsupportedVersion(String version) { 14 | return false; 15 | } 16 | 17 | @Override 18 | public boolean canLoad() { 19 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 20 | } 21 | 22 | @Override 23 | public String getPluginName() { 24 | return "QuickShop-Hikari"; 25 | } 26 | 27 | @Override 28 | public void load(Plugin plugin) { 29 | CrashClaim.getPlugin().getPluginSupportManager().register(new QuickShopHikariSupport()); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/loader/WorldGuardSupportLoader.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.loader; 2 | 3 | import com.google.auto.service.AutoService; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupportLoader; 6 | import net.crashcraft.crashclaim.pluginsupport.plugins.WorldGuardSupport; 7 | import org.bukkit.Bukkit; 8 | import org.bukkit.plugin.Plugin; 9 | 10 | @AutoService(PluginSupportLoader.class) 11 | public class WorldGuardSupportLoader implements PluginSupportLoader { 12 | @Override 13 | public boolean isUnsupportedVersion(String version) { 14 | return (int) version.charAt(0) < 7; 15 | } 16 | 17 | @Override 18 | public boolean canLoad() { 19 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 20 | } 21 | 22 | @Override 23 | public String getPluginName() { 24 | return "WorldGuard"; 25 | } 26 | 27 | @Override 28 | public void load(Plugin plugin) { 29 | CrashClaim.getPlugin().getPluginSupportManager().register(new WorldGuardSupport()); 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/plugins/DeluxeSellwandSupport.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.plugins; 2 | 3 | import dev.norska.dsw.api.DeluxeSellwandPreSellEvent; 4 | import net.crashcraft.crashclaim.CrashClaim; 5 | import net.crashcraft.crashclaim.localization.Localization; 6 | import net.crashcraft.crashclaim.permissions.PermissionHelper; 7 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 8 | import net.crashcraft.crashclaim.pluginsupport.PluginSupport; 9 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 10 | import org.bukkit.Bukkit; 11 | import org.bukkit.Location; 12 | import org.bukkit.entity.Player; 13 | import org.bukkit.event.EventHandler; 14 | import org.bukkit.event.HandlerList; 15 | import org.bukkit.event.Listener; 16 | import org.bukkit.inventory.BlockInventoryHolder; 17 | import org.bukkit.plugin.Plugin; 18 | 19 | public class DeluxeSellwandSupport implements PluginSupport, Listener { 20 | 21 | private VisualizationManager visual; 22 | 23 | @Override 24 | public boolean isUnsupportedVersion(String version) { 25 | return false; 26 | } 27 | 28 | @Override 29 | public boolean canLoad() { 30 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 31 | } 32 | 33 | @Override 34 | public String getPluginName() { 35 | return "DeluxeSellwands"; 36 | } 37 | 38 | @Override 39 | public void load(Plugin plugin) { 40 | 41 | } 42 | 43 | @Override 44 | public void enable(Plugin plugin) { 45 | Bukkit.getPluginManager().registerEvents(this, CrashClaim.getPlugin()); 46 | visual = CrashClaim.getPlugin().getVisualizationManager(); 47 | } 48 | 49 | @Override 50 | public void disable() { 51 | HandlerList.unregisterAll(this); 52 | } 53 | 54 | @EventHandler 55 | public void onWandUse(DeluxeSellwandPreSellEvent event) { 56 | Player player = event.getPlayer(); 57 | PermissionHelper helper = PermissionHelper.getPermissionHelper(); 58 | Location location = event.getClickedBlock().getLocation(); 59 | 60 | if (event.getClickedBlock().getState() instanceof BlockInventoryHolder){ 61 | if (helper.hasPermission(player.getUniqueId(), location, event.getClickedBlock().getType())){ 62 | return; 63 | } 64 | 65 | event.setCancelled(true); 66 | visual.sendAlert(player, Localization.ALERT__NO_PERMISSIONS__CONTAINERS.getMessage(player)); 67 | } else if (!helper.hasPermission(player.getUniqueId(), location, PermissionRoute.INTERACTIONS)){ 68 | event.setCancelled(true); 69 | visual.sendAlert(player, Localization.ALERT__NO_PERMISSIONS__INTERACTION.getMessage(player)); 70 | } 71 | } 72 | } 73 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/plugins/LuckPermsSupport.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.plugins; 2 | 3 | import net.crashcraft.crashclaim.config.GlobalConfig; 4 | import net.crashcraft.crashclaim.config.GroupSettings; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupport; 6 | import net.luckperms.api.LuckPerms; 7 | import net.luckperms.api.LuckPermsProvider; 8 | import net.luckperms.api.model.PermissionHolder; 9 | import org.bukkit.Bukkit; 10 | import org.bukkit.entity.Player; 11 | import org.bukkit.plugin.Plugin; 12 | 13 | public class LuckPermsSupport implements PluginSupport { 14 | private LuckPerms luckPerms; 15 | 16 | @Override 17 | public boolean isUnsupportedVersion(String version) { 18 | return false; 19 | } 20 | 21 | @Override 22 | public boolean canLoad() { 23 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 24 | } 25 | 26 | @Override 27 | public String getPluginName() { 28 | return "LuckPerms"; 29 | } 30 | 31 | @Override 32 | public void load(Plugin plugin) { 33 | 34 | } 35 | 36 | @Override 37 | public void enable(Plugin plugin) { 38 | luckPerms = LuckPermsProvider.get(); 39 | } 40 | 41 | @Override 42 | public void disable() { 43 | luckPerms = null; 44 | } 45 | 46 | @Override 47 | public GroupSettings getPlayerGroupSettings(Player player) { 48 | PermissionHolder user = luckPerms.getUserManager().getUser(player.getUniqueId()); 49 | 50 | if (user == null){ 51 | return null; 52 | } 53 | 54 | String value = user.getCachedData().getMetaData(user.getQueryOptions()).getPrimaryGroup(); 55 | if (value == null) { 56 | return null; 57 | } 58 | 59 | return GlobalConfig.groupSettings.get(value); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/plugins/QuickShopHikariSupport.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.plugins; 2 | 3 | import com.ghostchu.quickshop.api.QuickShopAPI; 4 | import com.ghostchu.quickshop.api.shop.Shop; 5 | import net.crashcraft.crashclaim.pluginsupport.PluginSupport; 6 | import org.bukkit.Bukkit; 7 | import org.bukkit.Location; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.block.BlockFace; 10 | import org.bukkit.block.data.Directional; 11 | import org.bukkit.entity.Player; 12 | import org.bukkit.plugin.Plugin; 13 | 14 | public class QuickShopHikariSupport implements PluginSupport { 15 | private QuickShopAPI quickShopAPI; 16 | 17 | @Override 18 | public void load(Plugin plugin) { 19 | 20 | } 21 | 22 | @Override 23 | public boolean isUnsupportedVersion(String version) { 24 | return false; 25 | } 26 | 27 | @Override 28 | public boolean canLoad() { 29 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 30 | } 31 | 32 | @Override 33 | public String getPluginName() { 34 | return "QuickShop-Hikari"; 35 | } 36 | 37 | @Override 38 | public void enable(Plugin plugin) { 39 | this.quickShopAPI = QuickShopAPI.getInstance(); 40 | } 41 | 42 | @Override 43 | public void disable() { 44 | 45 | } 46 | 47 | @Override 48 | public boolean canInteract(Player player, Location location) { 49 | if (!(location.getBlock().getBlockData() instanceof Directional directional)) { 50 | return false; 51 | } 52 | 53 | BlockFace face = directional.getFacing(); 54 | BlockFace invertedFace = invertFace(face); 55 | 56 | if (invertedFace == null) { 57 | return false; 58 | } 59 | 60 | Block block = location.getBlock().getRelative(invertedFace); 61 | Shop shop = quickShopAPI.getShopManager().getShop(block.getLocation()); 62 | 63 | return shop != null; 64 | } 65 | 66 | private BlockFace invertFace(BlockFace face){ 67 | return switch (face) { 68 | case NORTH -> BlockFace.SOUTH; 69 | case SOUTH -> BlockFace.NORTH; 70 | case EAST -> BlockFace.WEST; 71 | case WEST -> BlockFace.EAST; 72 | case NORTH_EAST -> BlockFace.SOUTH_WEST; 73 | case NORTH_WEST -> BlockFace.SOUTH_EAST; 74 | case SOUTH_EAST -> BlockFace.NORTH_WEST; 75 | case SOUTH_WEST -> BlockFace.NORTH_EAST; 76 | case EAST_NORTH_EAST -> BlockFace.WEST_SOUTH_WEST; 77 | case EAST_SOUTH_EAST -> BlockFace.WEST_NORTH_WEST; 78 | case NORTH_NORTH_EAST -> BlockFace.SOUTH_SOUTH_WEST; 79 | case NORTH_NORTH_WEST -> BlockFace.SOUTH_SOUTH_EAST; 80 | case SOUTH_SOUTH_EAST -> BlockFace.NORTH_NORTH_WEST; 81 | case SOUTH_SOUTH_WEST -> BlockFace.NORTH_NORTH_EAST; 82 | case WEST_NORTH_WEST -> BlockFace.EAST_SOUTH_EAST; 83 | case WEST_SOUTH_WEST -> BlockFace.EAST_NORTH_EAST; 84 | case UP -> BlockFace.DOWN; 85 | case DOWN -> BlockFace.UP; 86 | case SELF -> BlockFace.SELF; 87 | }; 88 | } 89 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/pluginsupport/plugins/WorldGuardSupport.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.pluginsupport.plugins; 2 | 3 | import com.sk89q.worldedit.bukkit.BukkitAdapter; 4 | import com.sk89q.worldedit.math.BlockVector3; 5 | import com.sk89q.worldguard.WorldGuard; 6 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 7 | import com.sk89q.worldguard.protection.flags.Flag; 8 | import com.sk89q.worldguard.protection.flags.StateFlag; 9 | import com.sk89q.worldguard.protection.flags.registry.FlagConflictException; 10 | import com.sk89q.worldguard.protection.flags.registry.FlagRegistry; 11 | import com.sk89q.worldguard.protection.managers.RegionManager; 12 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 13 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 14 | import com.sk89q.worldguard.protection.regions.RegionContainer; 15 | import net.crashcraft.crashclaim.CrashClaim; 16 | import net.crashcraft.crashclaim.pluginsupport.PluginSupport; 17 | import org.bukkit.Bukkit; 18 | import org.bukkit.Location; 19 | import org.bukkit.plugin.Plugin; 20 | 21 | public class WorldGuardSupport implements PluginSupport { 22 | 23 | private StateFlag ALLOW_CLAIMING; 24 | 25 | @Override 26 | public boolean isUnsupportedVersion(String version) { 27 | return (int) version.charAt(0) < 7; 28 | } 29 | 30 | @Override 31 | public boolean canLoad() { 32 | return Bukkit.getPluginManager().getPlugin(getPluginName()) != null; 33 | } 34 | 35 | @Override 36 | public String getPluginName() { 37 | return "WorldGuard"; 38 | } 39 | 40 | @Override 41 | public void load(Plugin plugin) { 42 | FlagRegistry registry = WorldGuard.getInstance().getFlagRegistry(); 43 | try { 44 | StateFlag flag = new StateFlag("allow-claiming", true); 45 | registry.register(flag); 46 | ALLOW_CLAIMING = flag; 47 | } catch (FlagConflictException e) { 48 | Flag existing = registry.get("allow-claiming"); 49 | if (existing instanceof StateFlag) { 50 | ALLOW_CLAIMING = (StateFlag) existing; 51 | } else { 52 | StateFlag flag = new StateFlag("crashclaim-allow-claiming", true); 53 | 54 | CrashClaim.getPlugin().getLogger().warning("[WorldGuard] The flag 'allow-claiming' was already initialized by another plugin, using 'crashclaim-allow-claiming' now."); 55 | 56 | registry.register(flag); 57 | ALLOW_CLAIMING = flag; 58 | } 59 | } 60 | } 61 | 62 | @Override 63 | public void enable(Plugin plugin) { 64 | 65 | } 66 | 67 | @Override 68 | public void disable() { 69 | 70 | } 71 | 72 | @Override 73 | public boolean canClaim(Location minLoc, Location maxLoc){ 74 | ProtectedRegion test = new ProtectedCuboidRegion("dummy", 75 | BlockVector3.at(minLoc.getX(), minLoc.getWorld().getMinHeight(), minLoc.getZ()), 76 | BlockVector3.at(maxLoc.getX(), maxLoc.getWorld().getMaxHeight(), maxLoc.getZ()) 77 | ); 78 | 79 | RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer(); 80 | RegionManager regions = container.get(BukkitAdapter.adapt(minLoc.getWorld())); 81 | 82 | if (regions == null){ 83 | return true; 84 | } 85 | 86 | ApplicableRegionSet set = regions.getApplicableRegions(test); 87 | 88 | return set.testState(null, ALLOW_CLAIMING); 89 | } 90 | } 91 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/BaseVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import org.bukkit.entity.Player; 5 | 6 | public abstract class BaseVisual { 7 | private final VisualColor color; 8 | private final VisualGroup parent; 9 | private final Player player; 10 | private final VisualType type; 11 | private BaseClaim claim; 12 | private final int y; 13 | 14 | public BaseVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y) { 15 | this.color = color; 16 | this.parent = parent; 17 | this.player = player; 18 | this.type = type; 19 | this.y = y; 20 | 21 | parent.addVisual(this); 22 | } 23 | 24 | public BaseVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y, BaseClaim claim) { 25 | this.color = color; 26 | this.parent = parent; 27 | this.player = player; 28 | this.type = type; 29 | this.y = y; 30 | this.claim = claim; 31 | 32 | parent.addVisual(this); 33 | } 34 | 35 | public abstract void spawn(); 36 | 37 | public abstract void remove(); 38 | 39 | public abstract VisualColor getColor(); 40 | 41 | public VisualColor getDefaultColor() { 42 | return color; 43 | } 44 | 45 | public VisualGroup getParent() { 46 | return parent; 47 | } 48 | 49 | public Player getPlayer() { 50 | return player; 51 | } 52 | 53 | public VisualType getType() { 54 | return type; 55 | } 56 | 57 | public int getY() { 58 | return y; 59 | } 60 | 61 | public BaseClaim getClaim() { 62 | return claim; 63 | } 64 | } 65 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/VisualColor.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | import org.bukkit.Material; 4 | 5 | public enum VisualColor { 6 | GOLD, 7 | RED, 8 | GREEN, 9 | YELLOW, 10 | WHITE; 11 | 12 | private Material material; 13 | 14 | VisualColor(){ 15 | 16 | } 17 | 18 | public void setMaterial(Material material){ 19 | this.material = material; 20 | } 21 | 22 | public Material getMaterial(){ 23 | return material; 24 | } 25 | } 26 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/VisualGroup.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.visualize.VisualizationManager; 5 | import org.bukkit.Bukkit; 6 | import org.bukkit.entity.Player; 7 | 8 | import java.util.ArrayList; 9 | import java.util.Iterator; 10 | import java.util.UUID; 11 | 12 | public class VisualGroup { 13 | private final ArrayList activeVisuals; 14 | private final Player player; 15 | private final VisualizationManager manager; 16 | 17 | public VisualGroup(Player player, VisualizationManager manager) { 18 | this.player = player; 19 | this.manager = manager; 20 | activeVisuals = new ArrayList<>(); 21 | } 22 | 23 | public void addVisual(BaseVisual visual){ 24 | activeVisuals.add(visual); 25 | } 26 | 27 | public void removeVisual(BaseVisual visual){ 28 | visual.remove(); 29 | activeVisuals.remove(visual); 30 | } 31 | 32 | public void removeAllVisuals(){ 33 | for (Iterator it = activeVisuals.iterator(); it.hasNext();){ 34 | BaseVisual visual = it.next(); 35 | visual.remove(); 36 | it.remove(); 37 | } 38 | } 39 | 40 | public void removeAllVisualsOfType(VisualType type){ 41 | for (Iterator it = activeVisuals.iterator(); it.hasNext();){ 42 | BaseVisual visual = it.next(); 43 | if (visual.getType().equals(type)) { 44 | visual.remove(); 45 | it.remove(); 46 | } 47 | } 48 | } 49 | 50 | public int generateUniqueID(){ 51 | return Bukkit.getServer().getUnsafe().nextEntityId(); 52 | } 53 | 54 | public UUID generateUniqueUUID(){ 55 | return UUID.randomUUID(); 56 | } 57 | 58 | public ArrayList getActiveVisuals() { 59 | return activeVisuals; 60 | } 61 | 62 | public Player getPlayer() { 63 | return player; 64 | } 65 | 66 | public VisualizationManager getManager() { 67 | return manager; 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/VisualProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import org.bukkit.Location; 5 | 6 | public interface VisualProvider { 7 | BaseVisual spawnClaimVisual(VisualColor color, VisualGroup parent, BaseClaim claim, int y); 8 | 9 | BaseVisual spawnMarkerVisual(VisualColor color, VisualGroup parent, Location location); 10 | } 11 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/VisualType.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | public enum VisualType { 4 | MARKER, 5 | CLAIM 6 | } 7 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/VisualUtils.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api; 2 | 3 | import java.util.ArrayList; 4 | 5 | public class VisualUtils { 6 | public static ArrayList getLine(int Length){ 7 | ArrayList LineDots = new ArrayList(){}; 8 | LineDots.add(1); 9 | LineDots.add(Length-1); 10 | int Parts = (int) Math.ceil((float) Length/18); 11 | int PartLength = (int) Math.ceil((float) Length/Parts); 12 | for (int i=PartLength; i changedBlocks; 25 | 26 | public BlockClaimVisual(VisualColor color, VisualGroup parent, Player player, int y, BaseClaim claim) { 27 | super(VisualType.CLAIM, color, parent, player, y, claim); 28 | this.changedBlocks = new ArrayList<>(); 29 | } 30 | 31 | @Override 32 | public void remove(){ 33 | for (Location location : changedBlocks){ 34 | revertBlock(getPlayer(), location); 35 | } 36 | } 37 | 38 | private void sendBlock(int x, int z, int y, World world){ 39 | Location location = new Location(world, x, y, z); 40 | changedBlocks.add(location); 41 | setBlock(getPlayer(), location, getColor().getMaterial()); 42 | } 43 | 44 | @Override 45 | public void spawn() { 46 | World world = getPlayer().getWorld(); 47 | 48 | int NWCordX = getClaim().getMinX(); 49 | int NWCordZ = getClaim().getMinZ(); 50 | int SECordX = getClaim().getMaxX(); 51 | int SECordZ = getClaim().getMaxZ(); 52 | 53 | sendBlock(NWCordX, NWCordZ, calcY(NWCordX, NWCordZ, world), world); 54 | sendBlock(NWCordX, SECordZ, calcY(NWCordX, SECordZ, world), world); 55 | 56 | sendBlock(SECordX, SECordZ, calcY(SECordX, SECordZ, world), world); 57 | sendBlock(SECordX, NWCordZ, calcY(SECordX, NWCordZ, world), world); 58 | 59 | for (Integer integer : VisualUtils.getLine(SECordX - NWCordX)){ 60 | sendBlock(NWCordX + integer, NWCordZ, calcY(NWCordX + integer, NWCordZ, world), world); 61 | sendBlock(NWCordX + integer, SECordZ, calcY(NWCordX + integer, SECordZ, world), world); 62 | } 63 | 64 | for (Integer integer : VisualUtils.getLine(SECordZ - NWCordZ)){ 65 | sendBlock(NWCordX, NWCordZ + integer, calcY(NWCordX, NWCordZ + integer, world), world); 66 | sendBlock(SECordX, NWCordZ + integer, calcY(SECordX, NWCordZ + integer, world), world); 67 | } 68 | } 69 | 70 | private int calcY(int x, int z, World world){ 71 | if (GlobalConfig.visual_use_highest_block){ 72 | return world.getHighestBlockYAt(x, z, HeightMap.MOTION_BLOCKING_NO_LEAVES); 73 | } 74 | return getY(); 75 | } 76 | 77 | @Override 78 | public VisualColor getColor() { 79 | if (getDefaultColor() == null){ 80 | PermissionGroup group; 81 | PlayerPermissionSet set; 82 | boolean isEditing; 83 | 84 | if (getClaim() instanceof SubClaim){ 85 | SubClaim subClaim = (SubClaim) getClaim(); 86 | group = subClaim.getParent().getPerms(); 87 | set = group.getPlayerPermissionSet(getParent().getPlayer().getUniqueId()); 88 | isEditing = subClaim.isEditing(); 89 | } else { 90 | group = getClaim().getPerms(); 91 | set = group.getPlayerPermissionSet(getParent().getPlayer().getUniqueId()); 92 | isEditing = getClaim().isEditing(); 93 | } 94 | 95 | if (set == null) { 96 | return VisualColor.RED; 97 | } else if (PermissionRouter.getLayeredPermission(group.getGlobalPermissionSet(), set, PermissionRoute.MODIFY_CLAIM) == PermState.ENABLED){ 98 | if (isEditing) { 99 | return VisualColor.YELLOW; 100 | } else { 101 | return VisualColor.GREEN; 102 | } 103 | } else { 104 | return VisualColor.GOLD; 105 | } 106 | } 107 | return getDefaultColor(); 108 | } 109 | 110 | 111 | } 112 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/claim/GlowClaimVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.claim; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.claimobjects.PermState; 5 | import net.crashcraft.crashclaim.claimobjects.PermissionGroup; 6 | import net.crashcraft.crashclaim.claimobjects.SubClaim; 7 | import net.crashcraft.crashclaim.claimobjects.permission.PlayerPermissionSet; 8 | import net.crashcraft.crashclaim.config.GlobalConfig; 9 | import net.crashcraft.crashclaim.permissions.PermissionRoute; 10 | import net.crashcraft.crashclaim.permissions.PermissionRouter; 11 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 12 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 13 | import net.crashcraft.crashclaim.visualize.api.VisualType; 14 | import net.crashcraft.crashclaim.visualize.api.VisualUtils; 15 | import net.crashcraft.crashclaim.visualize.api.visuals.BaseGlowVisual; 16 | import org.bukkit.HeightMap; 17 | import org.bukkit.World; 18 | import org.bukkit.entity.Player; 19 | 20 | public class GlowClaimVisual extends BaseGlowVisual { 21 | public GlowClaimVisual(VisualColor color, VisualGroup parent, Player player, int y, BaseClaim claim) { 22 | super(VisualType.CLAIM, color, parent, player, y, claim); 23 | } 24 | 25 | @Override 26 | public void remove() { 27 | removeAll(); 28 | } 29 | 30 | @Override 31 | public void spawn() { 32 | World world = getPlayer().getWorld(); 33 | 34 | int NWCordX = getClaim().getMinX(); 35 | int NWCordZ = getClaim().getMinZ(); 36 | int SECordX = getClaim().getMaxX(); 37 | int SECordZ = getClaim().getMaxZ(); 38 | 39 | spawnEntity(NWCordX, NWCordZ, calcY(NWCordX, NWCordZ, world)); 40 | spawnEntity(NWCordX, SECordZ, calcY(NWCordX, SECordZ, world)); 41 | 42 | spawnEntity(SECordX, SECordZ, calcY(SECordX, SECordZ, world)); 43 | spawnEntity(SECordX, NWCordZ, calcY(SECordX, NWCordZ, world)); 44 | 45 | for (Integer integer : VisualUtils.getLine(SECordX - NWCordX)){ 46 | spawnEntity(NWCordX + integer, NWCordZ, calcY(NWCordX + integer, NWCordZ, world)); 47 | spawnEntity(NWCordX + integer, SECordZ, calcY(NWCordX + integer, SECordZ, world)); 48 | } 49 | 50 | for (Integer integer : VisualUtils.getLine(SECordZ - NWCordZ)){ 51 | spawnEntity(NWCordX, NWCordZ + integer, calcY(NWCordX, NWCordZ + integer, world)); 52 | spawnEntity(SECordX, NWCordZ + integer, calcY(SECordX, NWCordZ + integer, world)); 53 | } 54 | 55 | colorEntities(getParent().getPlayer(), getColor(), getEntityUUIDs()); 56 | } 57 | 58 | private int calcY(int x, int z, World world){ 59 | if (GlobalConfig.visual_use_highest_block){ 60 | return world.getHighestBlockYAt(x, z, HeightMap.MOTION_BLOCKING_NO_LEAVES); 61 | } 62 | return getY(); 63 | } 64 | 65 | @Override 66 | public VisualColor getColor() { 67 | if (getDefaultColor() == null){ 68 | PermissionGroup group; 69 | PlayerPermissionSet set; 70 | boolean isEditing; 71 | 72 | if (getClaim() instanceof SubClaim){ 73 | SubClaim subClaim = (SubClaim) getClaim(); 74 | group = subClaim.getParent().getPerms(); 75 | set = group.getPlayerPermissionSet(getParent().getPlayer().getUniqueId()); 76 | isEditing = subClaim.isEditing(); 77 | } else { 78 | group = getClaim().getPerms(); 79 | set = group.getPlayerPermissionSet(getParent().getPlayer().getUniqueId()); 80 | isEditing = getClaim().isEditing(); 81 | } 82 | 83 | if (set == null) { 84 | return VisualColor.RED; 85 | } else if (PermissionRouter.getLayeredPermission(group.getGlobalPermissionSet(), set, PermissionRoute.MODIFY_CLAIM) == PermState.ENABLED){ 86 | if (isEditing) { 87 | return VisualColor.YELLOW; 88 | } else { 89 | return VisualColor.GREEN; 90 | } 91 | } else { 92 | return VisualColor.GOLD; 93 | } 94 | } 95 | return getDefaultColor(); 96 | } 97 | } 98 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/marker/BlockMarkerVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.marker; 2 | 3 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 4 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 5 | import net.crashcraft.crashclaim.visualize.api.VisualType; 6 | import net.crashcraft.crashclaim.visualize.api.visuals.BaseBlockVisual; 7 | import org.bukkit.Location; 8 | import org.bukkit.entity.Player; 9 | 10 | public class BlockMarkerVisual extends BaseBlockVisual { 11 | private final Location location; 12 | 13 | public BlockMarkerVisual(VisualColor color, VisualGroup parent, Player player, Location location) { 14 | super(VisualType.MARKER, color, parent, player, location.getBlockY()); 15 | this.location = location; 16 | } 17 | 18 | @Override 19 | public void spawn() { 20 | setBlock(getPlayer(), location, getColor().getMaterial()); 21 | } 22 | 23 | @Override 24 | public void remove() { 25 | revertBlock(getPlayer(), location); 26 | } 27 | 28 | @Override 29 | public VisualColor getColor() { 30 | if (getDefaultColor() == null){ 31 | return VisualColor.WHITE; 32 | } 33 | return getDefaultColor(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/marker/GlowMarketVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.marker; 2 | 3 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 4 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 5 | import net.crashcraft.crashclaim.visualize.api.VisualType; 6 | import net.crashcraft.crashclaim.visualize.api.visuals.BaseGlowVisual; 7 | import org.bukkit.Location; 8 | import org.bukkit.entity.Player; 9 | 10 | public class GlowMarketVisual extends BaseGlowVisual { 11 | private final Location location; 12 | 13 | public GlowMarketVisual(VisualColor color, VisualGroup parent, Player player, Location location) { 14 | super(VisualType.MARKER, color, parent, player, location.getBlockY()); 15 | this.location = location; 16 | } 17 | 18 | @Override 19 | public void remove() { 20 | removeAll(); 21 | } 22 | 23 | @Override 24 | public void spawn() { 25 | spawnEntity(getParent().getPlayer(), 26 | location.getBlockX(), 27 | location.getBlockZ(), 28 | location.getBlockY(), 29 | getParent().generateUniqueID(), 30 | getParent().generateUniqueUUID()); 31 | 32 | colorEntities(getParent().getPlayer(), getColor(), getEntityUUIDs()); 33 | } 34 | 35 | @Override 36 | public VisualColor getColor() { 37 | if (getDefaultColor() == null){ 38 | return VisualColor.WHITE; 39 | } 40 | return getDefaultColor(); 41 | } 42 | } 43 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/providers/BlockVisualProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.providers; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 5 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 6 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 7 | import net.crashcraft.crashclaim.visualize.api.VisualProvider; 8 | import net.crashcraft.crashclaim.visualize.api.claim.BlockClaimVisual; 9 | import net.crashcraft.crashclaim.visualize.api.marker.BlockMarkerVisual; 10 | import org.bukkit.Location; 11 | 12 | public class BlockVisualProvider implements VisualProvider { 13 | @Override 14 | public BaseVisual spawnClaimVisual(VisualColor color, VisualGroup parent, BaseClaim claim, int y) { 15 | return new BlockClaimVisual(color, parent, parent.getPlayer(), y, claim); 16 | } 17 | 18 | @Override 19 | public BaseVisual spawnMarkerVisual(VisualColor color, VisualGroup parent, Location location) { 20 | return new BlockMarkerVisual(color, parent, parent.getPlayer(), location); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/providers/GlowVisualProvider.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.providers; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 5 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 6 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 7 | import net.crashcraft.crashclaim.visualize.api.VisualProvider; 8 | import net.crashcraft.crashclaim.visualize.api.claim.GlowClaimVisual; 9 | import net.crashcraft.crashclaim.visualize.api.marker.GlowMarketVisual; 10 | import org.bukkit.Location; 11 | 12 | public class GlowVisualProvider implements VisualProvider { 13 | @Override 14 | public BaseVisual spawnClaimVisual(VisualColor color, VisualGroup parent, BaseClaim claim, int y) { 15 | return new GlowClaimVisual(color, parent, parent.getPlayer(), y, claim); 16 | } 17 | 18 | @Override 19 | public BaseVisual spawnMarkerVisual(VisualColor color, VisualGroup parent, Location location) { 20 | return new GlowMarketVisual(color, parent, parent.getPlayer(), location); 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/visuals/BaseBlockVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.visuals; 2 | 3 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 4 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 5 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 6 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 7 | import net.crashcraft.crashclaim.visualize.api.VisualType; 8 | import org.bukkit.Location; 9 | import org.bukkit.Material; 10 | import org.bukkit.entity.Player; 11 | 12 | public abstract class BaseBlockVisual extends BaseVisual { 13 | public BaseBlockVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y) { 14 | super(type, color, parent, player, y); 15 | } 16 | 17 | public BaseBlockVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y, BaseClaim claim) { 18 | super(type, color, parent, player, y, claim); 19 | } 20 | 21 | public void setBlock(Player player, Location location, Material material){ 22 | player.sendBlockChange(location, material.createBlockData()); 23 | } 24 | 25 | public void revertBlock(Player player, Location location){ 26 | player.sendBlockChange(location, player.getWorld().getBlockAt(location).getBlockData()); 27 | } 28 | } -------------------------------------------------------------------------------- /src/main/java/net/crashcraft/crashclaim/visualize/api/visuals/BaseGlowVisual.java: -------------------------------------------------------------------------------- 1 | package net.crashcraft.crashclaim.visualize.api.visuals; 2 | 3 | import net.crashcraft.crashclaim.CrashClaim; 4 | import net.crashcraft.crashclaim.claimobjects.BaseClaim; 5 | import net.crashcraft.crashclaim.visualize.api.BaseVisual; 6 | import net.crashcraft.crashclaim.visualize.api.VisualColor; 7 | import net.crashcraft.crashclaim.visualize.api.VisualGroup; 8 | import net.crashcraft.crashclaim.visualize.api.VisualType; 9 | import org.bukkit.Location; 10 | import org.bukkit.entity.Player; 11 | 12 | import java.util.ArrayList; 13 | import java.util.HashMap; 14 | import java.util.UUID; 15 | 16 | public abstract class BaseGlowVisual extends BaseVisual { 17 | private final HashMap fakeEntities; // id - uuid 18 | private final HashMap entityLocations; // check for hit collision on custom interact event 19 | 20 | public BaseGlowVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y) { 21 | super(type, color, parent, player, y); 22 | this.fakeEntities = new HashMap<>(); 23 | this.entityLocations = new HashMap<>(); 24 | } 25 | 26 | public BaseGlowVisual(VisualType type, VisualColor color, VisualGroup parent, Player player, int y, BaseClaim claim) { 27 | super(type, color, parent, player, y, claim); 28 | 29 | this.fakeEntities = new HashMap<>(); 30 | this.entityLocations = new HashMap<>(); 31 | } 32 | 33 | public void spawnEntity(int x, int z, int y){ 34 | spawnEntity(getPlayer(), 35 | x, 36 | z, 37 | y, 38 | getParent().generateUniqueID(), 39 | getParent().generateUniqueUUID()); 40 | } 41 | 42 | public void removeAll(){ 43 | CrashClaim.getPlugin().getHandler().removeEntity(getPlayer(), fakeEntities.keySet()); 44 | } 45 | 46 | public void colorEntities(Player player, VisualColor color, ArrayList uuids){ 47 | CrashClaim.getPlugin().getHandler().setEntityTeam(player, color.toString(), uuids); 48 | } 49 | 50 | public void spawnEntity(Player player, int x, int z, int y, int id, UUID uuid){ 51 | double dx = x + 0.5; 52 | double dz = z + 0.5; 53 | 54 | CrashClaim.getPlugin().getHandler().spawnGlowingInvisibleMagmaSlime( 55 | player, 56 | dx, 57 | dz, 58 | y, 59 | id, 60 | uuid, 61 | fakeEntities, 62 | entityLocations 63 | ); 64 | } 65 | 66 | public ArrayList getEntityIDs(){ 67 | return new ArrayList<>(fakeEntities.keySet()); 68 | } 69 | 70 | public ArrayList getEntityUUIDs(){ 71 | return new ArrayList<>(fakeEntities.values()); 72 | } 73 | 74 | public Location getEntityLocation(int id){ 75 | return entityLocations.get(id); 76 | } 77 | 78 | public boolean containsID(int id){ 79 | return fakeEntities.containsKey(id); 80 | } 81 | 82 | public boolean containsUUID(String uuid){ 83 | return fakeEntities.containsValue(uuid); 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/main/resources/lookup.yml: -------------------------------------------------------------------------------- 1 | untracked-blocks: 2 | - "" 3 | 4 | #An issue with the Bukkit API has required this list to add intractable block materials to an incomplete list. 5 | #If a block is not falling under the interaction category then add it to this list. Use the Bukkit material name. 6 | additional-tracked-interactables: 7 | - "ACACIA_PRESSURE_PLATE" 8 | - "BIRCH_PRESSURE_PLATE" 9 | - "DARK_OAK_PRESSURE_PLATE" 10 | - "HEAVY_WEIGHTED_PRESSURE_PLATE" 11 | - "JUNGLE_PRESSURE_PLATE" 12 | - "LIGHT_WEIGHTED_PRESSURE_PLATE" 13 | - "SPRUCE_PRESSURE_PLATE" 14 | - "OAK_PRESSURE_PLATE" 15 | - "STONE_PRESSURE_PLATE" 16 | - "TRIPWIRE" 17 | - "REDSTONE_ORE" 18 | - "FARMLAND" 19 | - "CARROTS" 20 | - "BEETROOTS" 21 | - "CHORUS_FLOWER" 22 | - "MELON_STEM" 23 | - "NETHER_WART" 24 | - "POTATOES" 25 | - "PUMPKIN_STEM" 26 | - "SWEET_BERRY_BUSH" 27 | - "WHEAT" 28 | - "WHEAT" -------------------------------------------------------------------------------- /src/main/resources/plugin.yml: -------------------------------------------------------------------------------- 1 | name: CrashClaim 2 | version: ${version} 3 | description: A modern advanced user oriented claiming system 4 | author: Chasewhip 5 | softdepend: [Vault, GriefPrevention, WorldGuard, PlaceholderAPI, Multiverse-Core, Hyperverse, LuckPerms, QuickShop-Hikari, DeluxeSellwands ] 6 | main: net.crashcraft.crashclaim.CrashClaim 7 | api-version: 1.16 --------------------------------------------------------------------------------