├── .gitattributes ├── .github ├── dependabot.yml └── workflows │ └── maven.yml ├── .gitignore ├── LICENSE ├── README.md ├── api ├── pom.xml └── src │ └── main │ └── java │ └── org │ └── codemc │ └── worldguardwrapper │ ├── event │ ├── AbstractWrappedEvent.java │ ├── WrappedDamageEntityEvent.java │ ├── WrappedDisallowedPVPEvent.java │ ├── WrappedUseBlockEvent.java │ └── WrappedUseEntityEvent.java │ ├── flag │ ├── IWrappedFlag.java │ ├── IWrappedStatusFlag.java │ └── WrappedState.java │ ├── handler │ └── IHandler.java │ ├── implementation │ └── IWorldGuardImplementation.java │ ├── region │ ├── IWrappedDomain.java │ ├── IWrappedRegion.java │ └── IWrappedRegionSet.java │ ├── selection │ ├── ICuboidSelection.java │ ├── IPolygonalSelection.java │ └── ISelection.java │ └── utility │ └── SelectionUtilities.java ├── implementation ├── legacy │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── org │ │ └── codemc │ │ └── worldguardwrapper │ │ └── implementation │ │ └── legacy │ │ ├── WorldGuardImplementation.java │ │ ├── event │ │ └── EventListener.java │ │ ├── flag │ │ ├── AbstractWrappedFlag.java │ │ ├── WrappedPrimitiveFlag.java │ │ └── WrappedStatusFlag.java │ │ ├── region │ │ └── WrappedRegion.java │ │ └── utility │ │ ├── WorldGuardFlagUtilities.java │ │ └── WorldGuardVectorUtilities.java ├── pom.xml ├── v6 │ ├── pom.xml │ └── src │ │ └── main │ │ └── java │ │ └── org │ │ └── codemc │ │ └── worldguardwrapper │ │ └── implementation │ │ └── v6 │ │ ├── WorldGuardImplementation.java │ │ ├── event │ │ └── EventListener.java │ │ ├── flag │ │ ├── AbstractWrappedFlag.java │ │ ├── WrappedPrimitiveFlag.java │ │ └── WrappedStatusFlag.java │ │ ├── handler │ │ └── ProxyHandler.java │ │ ├── region │ │ └── WrappedRegion.java │ │ └── utility │ │ ├── WorldGuardFlagUtilities.java │ │ └── WorldGuardVectorUtilities.java └── v7 │ ├── pom.xml │ └── src │ └── main │ └── java │ └── org │ └── codemc │ └── worldguardwrapper │ └── implementation │ └── v7 │ ├── WorldGuardImplementation.java │ ├── event │ └── EventListener.java │ ├── flag │ ├── AbstractWrappedFlag.java │ ├── WrappedPrimitiveFlag.java │ └── WrappedStatusFlag.java │ ├── handler │ └── ProxyHandler.java │ ├── region │ └── WrappedRegion.java │ └── utility │ └── WorldGuardFlagUtilities.java ├── library ├── pom.xml └── src │ └── main │ └── java │ └── org │ └── codemc │ └── worldguardwrapper │ └── WorldGuardWrapper.java └── pom.xml /.gitattributes: -------------------------------------------------------------------------------- 1 | # Auto detect text files and perform LF normalization 2 | * text=auto 3 | -------------------------------------------------------------------------------- /.github/dependabot.yml: -------------------------------------------------------------------------------- 1 | version: 2 2 | updates: 3 | - package-ecosystem: maven 4 | directory: "/" 5 | schedule: 6 | interval: daily 7 | open-pull-requests-limit: 10 8 | -------------------------------------------------------------------------------- /.github/workflows/maven.yml: -------------------------------------------------------------------------------- 1 | name: Java CI 2 | 3 | on: [push] 4 | 5 | jobs: 6 | build_and_test: 7 | strategy: 8 | matrix: 9 | jdkversion: [17] 10 | runs-on: ubuntu-latest 11 | steps: 12 | - uses: actions/checkout@v3 13 | - uses: actions/setup-java@v3 14 | with: 15 | distribution: 'temurin' 16 | java-version: ${{ matrix.jdkversion }} 17 | cache: 'maven' 18 | - name: Build with Maven 19 | run: mvn -V -B clean package --file pom.xml 20 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Java source files 2 | *.class 3 | MANIFEST.MF 4 | *.jar 5 | *.war 6 | *.ear 7 | hs_err_pid* 8 | 9 | # Mac 10 | .DS_Store 11 | 12 | # Intellij 13 | *.iml 14 | *.java___jb_tmp___ 15 | .idea/* 16 | *.ipr 17 | *.iws 18 | /out/ 19 | .idea_modules/ 20 | atlassian-ide-plugin.xml 21 | com_crashlytics_export_strings.xml 22 | crashlytics.properties 23 | crashlytics-build.properties 24 | 25 | # Eclipse 26 | *.pydevproject 27 | .metadata 28 | .gradle 29 | bin/ 30 | tmp/ 31 | *.tmp 32 | *.bak 33 | *.swp 34 | *~.nib 35 | local.properties 36 | .settings/ 37 | .loadpath 38 | .project 39 | .externalToolBuilders/ 40 | *.launch 41 | .cproject 42 | .classpath 43 | .buildpath 44 | .factorypath 45 | .target 46 | .texlipse 47 | 48 | # Maven 49 | target/ 50 | pom.xml.tag 51 | pom.xml.releaseBackup 52 | pom.xml.versionsBackup 53 | pom.xml.next 54 | release.properties 55 | dependency-reduced-pom.xml 56 | buildNumber.properties 57 | 58 | # NetBeans 59 | nbproject/private/ 60 | build/ 61 | nbbuild/ 62 | dist/ 63 | nbdist/ 64 | nbactions.xml 65 | nb-configuration.xml 66 | .nb-gradle/ 67 | 68 | # VSCode 69 | .vscode/ -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | The MIT License 2 | 3 | Copyright (c) 2010-2018 CodeMC https://github.com/CodeMC/WorldGuardWrapper 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in 13 | all copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 21 | THE SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # WorldGuardWrapper 2 | [![Build Status](https://ci.codemc.org/buildStatus/icon?job=CodeMC/WorldGuardWrapper)](https://ci.codemc.org/view/Author/job/CodeMC/job/WorldGuardWrapper/) 3 | ![Maven](https://img.shields.io/maven-metadata/v/https/repo.codemc.org/repository/maven-public/org/codemc/worldguardwrapper/worldguardwrapper/maven-metadata.xml.svg) 4 | [![Javadocs](https://img.shields.io/badge/docs-javadocs-brightgreen.svg)](https://ci.codemc.io/job/CodeMC/job/WorldGuardWrapper/javadoc/) 5 | [![Discord](https://img.shields.io/badge/chat-discord-blue.svg)](https://discord.gg/cnKwdsg) 6 | 7 | A wrapper for the WorldGuard API that allows plugins to support both v6 and v7 APIs. 8 | 9 | ## Maven dependency 10 | How to include WorldEditWrapper into your maven project: 11 | 12 | ```xml 13 | 14 | 15 | 16 | codemc-repo 17 | https://repo.codemc.org/repository/maven-public/ 18 | 19 | 20 | 21 | 22 | 23 | org.codemc.worldguardwrapper 24 | worldguardwrapper 25 | 1.2.1-SNAPSHOT 26 | 27 | 28 | 29 | ``` 30 | 31 | Remember to include/relocate the library into your final jar, example: 32 | 33 | ```xml 34 | 35 | 36 | 37 | org.apache.maven.plugins 38 | maven-shade-plugin 39 | 3.2.4 40 | 41 | 42 | package 43 | 44 | shade 45 | 46 | 47 | 48 | 49 | 50 | 51 | org.codemc.worldguardwrapper 52 | YOUR.PLUGIN.PACKAGE.libs.worldguardwrapper 53 | 54 | 55 | 56 | 57 | 58 | 59 | ``` 60 | -------------------------------------------------------------------------------- /api/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-parent 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper-api 15 | 16 | WorldGuardWrapper-API 17 | 18 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/event/AbstractWrappedEvent.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.event; 2 | 3 | import org.bukkit.event.Cancellable; 4 | import org.bukkit.event.Event; 5 | 6 | public abstract class AbstractWrappedEvent extends Event implements Cancellable { 7 | 8 | private Result result = Result.DEFAULT; 9 | 10 | @Override 11 | public boolean isCancelled() { 12 | return result == Result.DENY; 13 | } 14 | 15 | @Override 16 | public void setCancelled(boolean cancel) { 17 | if (cancel) { 18 | setResult(Result.DENY); 19 | } 20 | } 21 | 22 | /** 23 | * Sets the event result. 24 | * 25 | * @param result the new event result 26 | */ 27 | public void setResult(Result result) { 28 | this.result = result; 29 | } 30 | 31 | /** 32 | * Returns the current event result. 33 | * 34 | * @return the event result 35 | */ 36 | public Result getResult() { 37 | return result; 38 | } 39 | 40 | } 41 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/event/WrappedDamageEntityEvent.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.event; 2 | 3 | import lombok.Getter; 4 | import lombok.NonNull; 5 | import lombok.RequiredArgsConstructor; 6 | import org.bukkit.Location; 7 | import org.bukkit.entity.Entity; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.Event; 10 | import org.bukkit.event.HandlerList; 11 | 12 | @RequiredArgsConstructor 13 | @Getter 14 | public class WrappedDamageEntityEvent extends AbstractWrappedEvent { 15 | 16 | private static final HandlerList handlers = new HandlerList(); 17 | 18 | private final Event originalEvent; 19 | private final Player player; 20 | private final Location target; 21 | private final Entity entity; 22 | 23 | @Override 24 | @NonNull 25 | public HandlerList getHandlers() { 26 | return handlers; 27 | } 28 | 29 | @SuppressWarnings("unused") 30 | public static HandlerList getHandlerList() { 31 | return handlers; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/event/WrappedDisallowedPVPEvent.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.event; 2 | 3 | import lombok.Getter; 4 | import lombok.NonNull; 5 | import lombok.RequiredArgsConstructor; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.event.Event; 8 | import org.bukkit.event.HandlerList; 9 | 10 | @RequiredArgsConstructor 11 | @Getter 12 | public class WrappedDisallowedPVPEvent extends AbstractWrappedEvent { 13 | 14 | private static final HandlerList handlers = new HandlerList(); 15 | 16 | private final Player attacker; 17 | private final Player defender; 18 | private final Event cause; 19 | 20 | @Override 21 | @NonNull 22 | public HandlerList getHandlers() { 23 | return handlers; 24 | } 25 | 26 | @SuppressWarnings("unused") 27 | public static HandlerList getHandlerList() { 28 | return handlers; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/event/WrappedUseBlockEvent.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.event; 2 | 3 | import lombok.Getter; 4 | import lombok.NonNull; 5 | import lombok.RequiredArgsConstructor; 6 | import org.bukkit.Material; 7 | import org.bukkit.World; 8 | import org.bukkit.block.Block; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.Event; 11 | import org.bukkit.event.HandlerList; 12 | 13 | import java.util.List; 14 | 15 | @RequiredArgsConstructor 16 | @Getter 17 | public class WrappedUseBlockEvent extends AbstractWrappedEvent { 18 | 19 | private static final HandlerList handlers = new HandlerList(); 20 | 21 | private final Event originalEvent; 22 | private final Player player; 23 | private final World world; 24 | private final List blocks; 25 | private final Material effectiveMaterial; 26 | 27 | @Override 28 | @NonNull 29 | public HandlerList getHandlers() { 30 | return handlers; 31 | } 32 | 33 | @SuppressWarnings("unused") 34 | public static HandlerList getHandlerList() { 35 | return handlers; 36 | } 37 | 38 | } 39 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/event/WrappedUseEntityEvent.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.event; 2 | 3 | import lombok.Getter; 4 | import lombok.NonNull; 5 | import lombok.RequiredArgsConstructor; 6 | import org.bukkit.Location; 7 | import org.bukkit.entity.Entity; 8 | import org.bukkit.entity.Player; 9 | import org.bukkit.event.Event; 10 | import org.bukkit.event.HandlerList; 11 | 12 | @RequiredArgsConstructor 13 | @Getter 14 | public class WrappedUseEntityEvent extends AbstractWrappedEvent { 15 | 16 | private static final HandlerList handlers = new HandlerList(); 17 | 18 | private final Event originalEvent; 19 | private final Player player; 20 | private final Location target; 21 | private final Entity entity; 22 | 23 | @Override 24 | @NonNull 25 | public HandlerList getHandlers() { 26 | return handlers; 27 | } 28 | 29 | @SuppressWarnings("unused") 30 | public static HandlerList getHandlerList() { 31 | return handlers; 32 | } 33 | 34 | } 35 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/flag/IWrappedFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.flag; 2 | 3 | import java.util.Optional; 4 | 5 | @SuppressWarnings("unused") 6 | public interface IWrappedFlag { 7 | 8 | String getName(); 9 | 10 | Optional getDefaultValue(); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/flag/IWrappedStatusFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.flag; 2 | 3 | @SuppressWarnings("unused") 4 | public interface IWrappedStatusFlag extends IWrappedFlag { 5 | } 6 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/flag/WrappedState.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.flag; 2 | 3 | @SuppressWarnings("unused") 4 | public enum WrappedState { 5 | ALLOW, 6 | DENY; 7 | 8 | WrappedState() { 9 | } 10 | } 11 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/handler/IHandler.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.handler; 2 | 3 | import org.bukkit.Location; 4 | import org.bukkit.entity.Player; 5 | import org.codemc.worldguardwrapper.flag.WrappedState; 6 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 7 | import org.codemc.worldguardwrapper.region.IWrappedRegionSet; 8 | 9 | import java.util.Set; 10 | 11 | @SuppressWarnings("unused") 12 | public interface IHandler { 13 | 14 | default void initialize(Player player, Location current, IWrappedRegionSet regionSet) { 15 | } 16 | 17 | default boolean testMoveTo( 18 | Player player, 19 | Location from, 20 | Location to, 21 | IWrappedRegionSet regionSet, 22 | String moveType 23 | ) { 24 | return true; 25 | } 26 | 27 | default boolean onCrossBoundary( 28 | Player player, 29 | Location from, 30 | Location to, 31 | IWrappedRegionSet toSet, 32 | Set entered, 33 | Set exited, 34 | String moveType 35 | ) { 36 | return true; 37 | } 38 | 39 | default void tick(Player player, IWrappedRegionSet regionSet) { 40 | } 41 | 42 | default WrappedState getInvincibility(Player player) { 43 | return null; 44 | } 45 | 46 | } 47 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/implementation/IWorldGuardImplementation.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation; 2 | 3 | import lombok.NonNull; 4 | import org.bukkit.Location; 5 | import org.bukkit.World; 6 | import org.bukkit.entity.Player; 7 | import org.bukkit.plugin.java.JavaPlugin; 8 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 9 | import org.codemc.worldguardwrapper.handler.IHandler; 10 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 11 | import org.codemc.worldguardwrapper.region.IWrappedRegionSet; 12 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 13 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 14 | import org.codemc.worldguardwrapper.selection.ISelection; 15 | 16 | import java.util.*; 17 | import java.util.function.Supplier; 18 | 19 | @SuppressWarnings("unused") 20 | public interface IWorldGuardImplementation { 21 | 22 | /** 23 | * Get an instance of the WorldGuardPlugin class 24 | * 25 | * @return The WorldGuard plugin 26 | */ 27 | JavaPlugin getWorldGuardPlugin(); 28 | 29 | /** 30 | * Get the API version of the loaded WorldGuard plugin (e.g. 6 or 7). 31 | * 32 | * @return The API version 33 | */ 34 | int getApiVersion(); 35 | 36 | void registerHandler(Supplier factory); 37 | 38 | /** 39 | * Query a flag's value for a given player at a given location. 40 | * 41 | * @param player The player 42 | * @param location The location 43 | * @param flag The flag 44 | * @return The flag's value 45 | */ 46 | Optional queryFlag(Player player, @NonNull Location location, @NonNull IWrappedFlag flag); 47 | 48 | /** 49 | * Queries all applicable flags for a given player at a given location. 50 | * 51 | * @param player The player 52 | * @param location The location 53 | * @return The flags 54 | */ 55 | Map, Object> queryApplicableFlags(Player player, Location location); 56 | 57 | /** 58 | * Returns the flag with the given name. 59 | * 60 | * @param name The flag name 61 | * @param type The flag type 62 | * @return The flag, empty if it doesn't exist 63 | */ 64 | Optional> getFlag(String name, Class type); 65 | 66 | /** 67 | * Registers a flag to WorldGuard's flag registry. 68 | * 69 | * @param name The flag name 70 | * @param type The flag type 71 | * @param defaultValue the flag default value (if supported by the type), can be null 72 | * @return The created flag, empty if a name conflict occurred 73 | */ 74 | Optional> registerFlag(@NonNull String name, @NonNull Class type, T defaultValue); 75 | 76 | /** 77 | * Registers a flag to WorldGuard's flag registry. 78 | * 79 | * @param name The flag name 80 | * @param type The flag type 81 | * @return The created flag, empty if a name conflict occurred 82 | */ 83 | default Optional> registerFlag(@NonNull String name, @NonNull Class type) { 84 | return registerFlag(name, type, null); 85 | } 86 | 87 | /** 88 | * Get a region by its ID. 89 | * 90 | * @param world The world 91 | * @param id ID of the region 92 | * @return The region 93 | */ 94 | Optional getRegion(@NonNull World world, @NonNull String id); 95 | 96 | /** 97 | * Get an unmodifiable map of regions containing the state of the 98 | * index at the time of call. 99 | * 100 | *

This call is relatively heavy (and may block other threads), 101 | * so refrain from calling it frequently.

102 | * 103 | * @param world The world 104 | * @return A map of regions 105 | */ 106 | Map getRegions(@NonNull World world); 107 | 108 | /** 109 | * Get a set of regions at the given location. 110 | * 111 | * @param location The location 112 | * @return A set of regions 113 | */ 114 | Set getRegions(@NonNull Location location); 115 | 116 | 117 | /** 118 | * Get a set of regions in the given cuboid area. 119 | * 120 | * @param minimum The minimum location of the area 121 | * @param maximum The maximum location of the area 122 | * @return A set of regions 123 | */ 124 | Set getRegions(@NonNull Location minimum, @NonNull Location maximum); 125 | 126 | /** 127 | * Get the applicable region set at the given location- 128 | * 129 | * @param location The location 130 | * @return The region set 131 | */ 132 | Optional getRegionSet(@NonNull Location location); 133 | 134 | /** 135 | * Add a region. If only two points are given, a cuboid region will be created. 136 | * 137 | * @param id The region ID 138 | * @param points A {@link List} of points that the region should contain 139 | * @param minY The minimum y coordinate 140 | * @param maxY The maximum y coordinate 141 | * @return The added region 142 | */ 143 | Optional addRegion(@NonNull String id, @NonNull List points, int minY, int maxY); 144 | 145 | /** 146 | * Add a cuboid region. 147 | * 148 | * @param id The region ID 149 | * @param point1 The first point of the region 150 | * @param point2 The second point of the region 151 | * @return The added region 152 | */ 153 | default Optional addCuboidRegion( 154 | @NonNull String id, 155 | @NonNull Location point1, 156 | @NonNull Location point2 157 | ) { 158 | return addRegion(id, Arrays.asList(point1, point2), 0, 0); 159 | } 160 | 161 | /** 162 | * Add a region for the given selection. 163 | * 164 | * @param id The region ID 165 | * @param selection The selection for the region's volume 166 | * @return The added region 167 | */ 168 | default Optional addRegion(@NonNull String id, @NonNull ISelection selection) { 169 | if (selection instanceof ICuboidSelection) { 170 | ICuboidSelection sel = (ICuboidSelection) selection; 171 | return addCuboidRegion(id, sel.getMinimumPoint(), sel.getMaximumPoint()); 172 | } else if (selection instanceof IPolygonalSelection) { 173 | IPolygonalSelection sel = (IPolygonalSelection) selection; 174 | return addRegion(id, new ArrayList<>(sel.getPoints()), sel.getMinimumY(), sel.getMaximumY()); 175 | } else { 176 | throw new UnsupportedOperationException("Unknown " + selection.getClass().getSimpleName() 177 | + " selection type!"); 178 | } 179 | } 180 | 181 | /** 182 | * Remove a region, including inheriting children. 183 | * 184 | * @param world The world 185 | * @param id The region ID 186 | * @return A list of removed regions where the first entry is the region specified by {@code id} 187 | */ 188 | Optional> removeRegion(@NonNull World world, @NonNull String id); 189 | 190 | /** 191 | * Returns the current selection of the given player. 192 | * 193 | * @param player The player 194 | * @return The current player's selection 195 | */ 196 | Optional getPlayerSelection(@NonNull Player player); 197 | 198 | } 199 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/region/IWrappedDomain.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.region; 2 | 3 | import java.util.Set; 4 | import java.util.UUID; 5 | 6 | @SuppressWarnings("unused") 7 | public interface IWrappedDomain { 8 | 9 | Set getPlayers(); 10 | 11 | void addPlayer(UUID uuid); 12 | 13 | void removePlayer(UUID uuid); 14 | 15 | Set getGroups(); 16 | 17 | void addGroup(String name); 18 | 19 | void removeGroup(String name); 20 | 21 | } 22 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/region/IWrappedRegion.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.region; 2 | 3 | import org.bukkit.Location; 4 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 5 | import org.codemc.worldguardwrapper.selection.ISelection; 6 | 7 | import java.util.Map; 8 | import java.util.Optional; 9 | 10 | @SuppressWarnings("unused") 11 | public interface IWrappedRegion { 12 | 13 | ISelection getSelection(); 14 | 15 | String getId(); 16 | 17 | Map, Object> getFlags(); 18 | 19 | Optional getFlag(IWrappedFlag flag); 20 | 21 | void setFlag(IWrappedFlag flag, T value); 22 | 23 | int getPriority(); 24 | 25 | void setPriority(int priority); 26 | 27 | IWrappedDomain getOwners(); 28 | 29 | IWrappedDomain getMembers(); 30 | 31 | boolean contains(Location location); 32 | 33 | } 34 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/region/IWrappedRegionSet.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.region; 2 | 3 | import org.bukkit.OfflinePlayer; 4 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 5 | 6 | import java.util.Collection; 7 | import java.util.Optional; 8 | import java.util.Set; 9 | 10 | @SuppressWarnings("unused") 11 | public interface IWrappedRegionSet extends Iterable { 12 | 13 | boolean isVirtual(); 14 | 15 | Optional queryValue(OfflinePlayer subject, IWrappedFlag flag); 16 | 17 | Collection queryAllValues(OfflinePlayer subject, IWrappedFlag flag); 18 | 19 | boolean isOwnerOfAll(OfflinePlayer player); 20 | 21 | boolean isMemberOfAll(OfflinePlayer player); 22 | 23 | int size(); 24 | 25 | Set getRegions(); 26 | 27 | } 28 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/selection/ICuboidSelection.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.selection; 2 | 3 | import org.bukkit.Location; 4 | 5 | @SuppressWarnings("unused") 6 | public interface ICuboidSelection extends ISelection { 7 | 8 | Location getMinimumPoint(); 9 | 10 | Location getMaximumPoint(); 11 | 12 | } 13 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/selection/IPolygonalSelection.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.selection; 2 | 3 | import org.bukkit.Location; 4 | 5 | import java.util.Set; 6 | 7 | @SuppressWarnings("unused") 8 | public interface IPolygonalSelection extends ISelection { 9 | 10 | Set getPoints(); 11 | 12 | int getMinimumY(); 13 | 14 | int getMaximumY(); 15 | 16 | } 17 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/selection/ISelection.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.selection; 2 | 3 | @SuppressWarnings("unused") 4 | public interface ISelection { 5 | } 6 | -------------------------------------------------------------------------------- /api/src/main/java/org/codemc/worldguardwrapper/utility/SelectionUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.utility; 2 | 3 | import lombok.experimental.UtilityClass; 4 | import org.bukkit.Location; 5 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 6 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 7 | 8 | import java.util.Collection; 9 | import java.util.HashSet; 10 | import java.util.Set; 11 | 12 | @SuppressWarnings("unused") 13 | @UtilityClass 14 | public class SelectionUtilities { 15 | 16 | /** 17 | * Creates a static cuboid selection. 18 | * 19 | * @param first the first point of the cuboid 20 | * @param second the second point of the cuboid 21 | * @return the selection 22 | */ 23 | public ICuboidSelection createCuboidSelection(Location first, Location second) { 24 | Location minimum; 25 | Location maximum; 26 | if (first.getBlockY() > second.getBlockY()) { 27 | maximum = first; 28 | minimum = second; 29 | } else { 30 | maximum = second; 31 | minimum = first; 32 | } 33 | return new ICuboidSelection() { 34 | @Override 35 | public Location getMinimumPoint() { 36 | return minimum; 37 | } 38 | 39 | @Override 40 | public Location getMaximumPoint() { 41 | return maximum; 42 | } 43 | }; 44 | } 45 | 46 | /** 47 | * Creates a static polygonal selection. 48 | * 49 | * @param points the points of the selection 50 | * @param minY the minimum Y coordinate of the selection 51 | * @param maxY the maximum Y coordinate of the selection 52 | * @return the selection 53 | */ 54 | public IPolygonalSelection createPolygonalSelection(Collection points, int minY, int maxY) { 55 | return new IPolygonalSelection() { 56 | @Override 57 | public Set getPoints() { 58 | return new HashSet<>(points); 59 | } 60 | 61 | @Override 62 | public int getMinimumY() { 63 | return minY; 64 | } 65 | 66 | @Override 67 | public int getMaximumY() { 68 | return maxY; 69 | } 70 | }; 71 | } 72 | 73 | } 74 | -------------------------------------------------------------------------------- /implementation/legacy/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-implementation 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper-implementation-legacy 15 | 16 | WorldGuardWrapper-Implementation-Legacy 17 | 18 | 19 | 20 | enginehub-repo 21 | https://maven.enginehub.org/repo/ 22 | 23 | always 24 | 25 | 26 | 27 | 28 | 29 | 30 | ${project.groupId} 31 | worldguardwrapper-api 32 | 1.2.1-SNAPSHOT 33 | provided 34 | 35 | 36 | com.sk89q 37 | worldguard 38 | 6.1 39 | provided 40 | 41 | 42 | com.sk89q.spigot 43 | bukkit-classloader-check 44 | 45 | 46 | org.bukkit 47 | bukkit 48 | 49 | 50 | com.sk89q 51 | commandbook 52 | 53 | 54 | de.schlichtherle 55 | truezip 56 | 57 | 58 | rhino 59 | js 60 | 61 | 62 | com.sk89q 63 | jchronic 64 | 65 | 66 | com.google.code.findbugs 67 | jsr305 68 | 69 | 70 | 71 | 72 | 73 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/WorldGuardImplementation.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy; 2 | 3 | import com.google.common.collect.Iterators; 4 | import com.sk89q.minecraft.util.commands.CommandException; 5 | import com.sk89q.worldedit.BlockVector; 6 | import com.sk89q.worldedit.bukkit.WorldEditPlugin; 7 | import com.sk89q.worldedit.bukkit.selections.CuboidSelection; 8 | import com.sk89q.worldedit.bukkit.selections.Polygonal2DSelection; 9 | import com.sk89q.worldguard.LocalPlayer; 10 | import com.sk89q.worldguard.bukkit.WorldGuardPlugin; 11 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 12 | import com.sk89q.worldguard.protection.flags.DefaultFlag; 13 | import com.sk89q.worldguard.protection.flags.Flag; 14 | import com.sk89q.worldguard.protection.managers.RegionManager; 15 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 16 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 17 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 18 | import lombok.NonNull; 19 | import org.bukkit.Location; 20 | import org.bukkit.OfflinePlayer; 21 | import org.bukkit.World; 22 | import org.bukkit.entity.Player; 23 | import org.bukkit.plugin.java.JavaPlugin; 24 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 25 | import org.codemc.worldguardwrapper.handler.IHandler; 26 | import org.codemc.worldguardwrapper.implementation.IWorldGuardImplementation; 27 | import org.codemc.worldguardwrapper.implementation.legacy.flag.AbstractWrappedFlag; 28 | import org.codemc.worldguardwrapper.implementation.legacy.region.WrappedRegion; 29 | import org.codemc.worldguardwrapper.implementation.legacy.utility.WorldGuardFlagUtilities; 30 | import org.codemc.worldguardwrapper.implementation.legacy.utility.WorldGuardVectorUtilities; 31 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 32 | import org.codemc.worldguardwrapper.region.IWrappedRegionSet; 33 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 34 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 35 | import org.codemc.worldguardwrapper.selection.ISelection; 36 | 37 | import java.util.*; 38 | import java.util.function.Supplier; 39 | import java.util.stream.Collectors; 40 | 41 | public class WorldGuardImplementation implements IWorldGuardImplementation { 42 | 43 | private final WorldGuardPlugin worldGuardPlugin; 44 | private final WorldEditPlugin worldEditPlugin; 45 | 46 | public WorldGuardImplementation() { 47 | worldGuardPlugin = WorldGuardPlugin.inst(); 48 | try { 49 | worldEditPlugin = worldGuardPlugin.getWorldEdit(); 50 | } catch (CommandException e) { 51 | throw new RuntimeException(e); 52 | } 53 | } 54 | 55 | private Optional wrapPlayer(OfflinePlayer player) { 56 | return Optional.ofNullable(player).map(bukkitPlayer -> bukkitPlayer.isOnline() ? 57 | worldGuardPlugin.wrapPlayer((Player) bukkitPlayer) : worldGuardPlugin.wrapOfflinePlayer(bukkitPlayer)); 58 | } 59 | 60 | private Optional getWorldManager(@NonNull World world) { 61 | return Optional.ofNullable(worldGuardPlugin.getRegionManager(world)); 62 | } 63 | 64 | private Optional getApplicableRegions(@NonNull Location location) { 65 | return getWorldManager(Objects.requireNonNull(location.getWorld())) 66 | .map(manager -> manager.getApplicableRegions(location)); 67 | } 68 | 69 | private Optional getApplicableRegions(@NonNull Location minimum, @NonNull Location maximum) { 70 | return getWorldManager(Objects.requireNonNull(minimum.getWorld())) 71 | .map(manager -> 72 | manager.getApplicableRegions( 73 | new ProtectedCuboidRegion( 74 | "temp", 75 | WorldGuardVectorUtilities.toBlockVector(minimum), 76 | WorldGuardVectorUtilities.toBlockVector(maximum) 77 | ) 78 | ) 79 | ); 80 | } 81 | 82 | private Optional queryValue(Player player, @NonNull Location location, @NonNull Flag flag) { 83 | return getApplicableRegions(location) 84 | .map(applicableRegions -> applicableRegions.queryValue(wrapPlayer(player).orElse(null), flag)); 85 | } 86 | 87 | private IWrappedRegionSet wrapRegionSet(@NonNull World world, @NonNull ApplicableRegionSet regionSet) { 88 | return new IWrappedRegionSet() { 89 | 90 | @Override 91 | public Iterator iterator() { 92 | return Iterators.transform(regionSet.iterator(), region -> new WrappedRegion(world, region)); 93 | } 94 | 95 | @Override 96 | public boolean isVirtual() { 97 | return regionSet.isVirtual(); 98 | } 99 | 100 | @Override 101 | public Optional queryValue(OfflinePlayer subject, IWrappedFlag flag) { 102 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 103 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 104 | return Optional.ofNullable(regionSet.queryValue(subjectHandle, wrappedFlag.getHandle())) 105 | .flatMap(wrappedFlag::fromWGValue); 106 | } 107 | 108 | @Override 109 | public Collection queryAllValues(OfflinePlayer subject, IWrappedFlag flag) { 110 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 111 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 112 | return regionSet.queryAllValues(subjectHandle, wrappedFlag.getHandle()).stream() 113 | .map(wrappedFlag::fromWGValue) 114 | .filter(Optional::isPresent) 115 | .map(Optional::get) 116 | .collect(Collectors.toList()); 117 | } 118 | 119 | @Override 120 | public boolean isOwnerOfAll(OfflinePlayer player) { 121 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 122 | return regionSet.isOwnerOfAll(playerHandle); 123 | } 124 | 125 | @Override 126 | public boolean isMemberOfAll(OfflinePlayer player) { 127 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 128 | return regionSet.isMemberOfAll(playerHandle); 129 | } 130 | 131 | @Override 132 | public int size() { 133 | return regionSet.size(); 134 | } 135 | 136 | @Override 137 | public Set getRegions() { 138 | return regionSet.getRegions().stream() 139 | .map(region -> new WrappedRegion(world, region)).collect(Collectors.toSet()); 140 | } 141 | }; 142 | } 143 | 144 | @Override 145 | public JavaPlugin getWorldGuardPlugin() { 146 | return WorldGuardPlugin.inst(); 147 | } 148 | 149 | @Override 150 | public int getApiVersion() { 151 | return -6; 152 | } 153 | 154 | @Override 155 | public void registerHandler(Supplier factory) { 156 | throw new UnsupportedOperationException("Custom flag handlers aren't supported in this version of WorldGuard!"); 157 | } 158 | 159 | @Override 160 | public Optional> getFlag(String name, Class type) { 161 | for (Flag currentFlag : DefaultFlag.getFlags()) { 162 | if (currentFlag.getName().equalsIgnoreCase(name)) { 163 | return Optional.of(WorldGuardFlagUtilities.wrap(currentFlag, type)); 164 | } 165 | } 166 | return Optional.empty(); 167 | } 168 | 169 | @Override 170 | public Optional queryFlag(Player player, @NonNull Location location, @NonNull IWrappedFlag flag) { 171 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 172 | 173 | return queryValue(player, location, wrappedFlag.getHandle()).flatMap(wrappedFlag::fromWGValue); 174 | } 175 | 176 | @Override 177 | public Map, Object> queryApplicableFlags(Player player, Location location) { 178 | ApplicableRegionSet applicableSet = getApplicableRegions(location).orElse(null); 179 | if (applicableSet == null) { 180 | return Collections.emptyMap(); 181 | } 182 | 183 | LocalPlayer localPlayer = wrapPlayer(player).orElse(null); 184 | Map, Object> flags = new HashMap<>(); 185 | Set seen = new HashSet<>(); 186 | 187 | for (ProtectedRegion region : applicableSet.getRegions()) { 188 | for (Flag flag : region.getFlags().keySet()) { 189 | if (seen.add(flag.getName())) { 190 | Object value = applicableSet.queryValue(localPlayer, flag); 191 | if (value == null) { 192 | continue; 193 | } 194 | 195 | try { 196 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 197 | flags.put(wrapped.getKey(), wrapped.getValue()); 198 | } catch (IllegalArgumentException e) { 199 | // Unsupported flag type 200 | } 201 | } 202 | } 203 | } 204 | 205 | return flags; 206 | } 207 | 208 | @Override 209 | public Optional> registerFlag(@NonNull String name, @NonNull Class type, T defaultValue) { 210 | throw new UnsupportedOperationException("Custom flags aren't supported in this version of WorldGuard!"); 211 | } 212 | 213 | @Override 214 | public Optional getRegion(@NonNull World world, @NonNull String id) { 215 | return getWorldManager(world) 216 | .map(regionManager -> regionManager.getRegion(id)) 217 | .map(region -> new WrappedRegion(world, region)); 218 | } 219 | 220 | @Override 221 | public Map getRegions(@NonNull World world) { 222 | RegionManager regionManager = worldGuardPlugin.getRegionManager(world); 223 | Map regions = regionManager.getRegions(); 224 | 225 | Map map = new HashMap<>(); 226 | regions.forEach((name, region) -> map.put(name, new WrappedRegion(world, region))); 227 | 228 | return map; 229 | } 230 | 231 | @Override 232 | public Set getRegions(@NonNull Location location) { 233 | ApplicableRegionSet regionSet = getApplicableRegions(location).orElse(null); 234 | Set set = new HashSet<>(); 235 | 236 | if (regionSet == null) { 237 | return set; 238 | } 239 | 240 | regionSet.forEach(region -> set.add(new WrappedRegion(location.getWorld(), region))); 241 | return set; 242 | } 243 | 244 | @Override 245 | public Set getRegions(@NonNull Location minimum, @NonNull Location maximum) { 246 | ApplicableRegionSet regionSet = getApplicableRegions(minimum, maximum).orElse(null); 247 | Set set = new HashSet<>(); 248 | 249 | if (regionSet == null) { 250 | return set; 251 | } 252 | 253 | regionSet.forEach(region -> set.add(new WrappedRegion(minimum.getWorld(), region))); 254 | return set; 255 | } 256 | 257 | @Override 258 | public Optional getRegionSet(@NonNull Location location) { 259 | return getApplicableRegions(location) 260 | .map(regionSet -> wrapRegionSet(Objects.requireNonNull(location.getWorld()), regionSet)); 261 | } 262 | 263 | @Override 264 | public Optional addRegion(@NonNull String id, @NonNull List points, int minY, int maxY) { 265 | ProtectedRegion region; 266 | World world = Objects.requireNonNull(points.get(0).getWorld()); 267 | if (points.size() == 2) { 268 | region = new ProtectedCuboidRegion( 269 | id, 270 | WorldGuardVectorUtilities.toBlockVector(points.get(0)), 271 | WorldGuardVectorUtilities.toBlockVector(points.get(1)) 272 | ); 273 | } else { 274 | region = new ProtectedPolygonalRegion( 275 | id, 276 | WorldGuardVectorUtilities.toBlockVector2DList(points), 277 | minY, 278 | maxY 279 | ); 280 | } 281 | 282 | Optional manager = getWorldManager(world); 283 | if (manager.isPresent()) { 284 | manager.get().addRegion(region); 285 | return Optional.of(new WrappedRegion(world, region)); 286 | } else { 287 | return Optional.empty(); 288 | } 289 | } 290 | 291 | @Override 292 | public Optional> removeRegion(@NonNull World world, @NonNull String id) { 293 | Optional> set = getWorldManager(world).map(manager -> manager.removeRegion(id)); 294 | return set.map(protectedRegions -> protectedRegions.stream().map(region -> new WrappedRegion(world, region)) 295 | .collect(Collectors.toSet())); 296 | } 297 | 298 | @Override 299 | public Optional getPlayerSelection(@NonNull Player player) { 300 | return Optional.ofNullable(worldEditPlugin.getSelection(player)) 301 | .map(selection -> { 302 | if (selection instanceof CuboidSelection) { 303 | return new ICuboidSelection() { 304 | @Override 305 | public Location getMinimumPoint() { 306 | return selection.getMinimumPoint(); 307 | } 308 | 309 | @Override 310 | public Location getMaximumPoint() { 311 | return selection.getMaximumPoint(); 312 | } 313 | }; 314 | } else if (selection instanceof Polygonal2DSelection) { 315 | return new IPolygonalSelection() { 316 | @Override 317 | public Set getPoints() { 318 | return ((Polygonal2DSelection) selection).getNativePoints().stream() 319 | .map(vector -> new BlockVector(vector.toVector())) 320 | .map(vector -> 321 | WorldGuardVectorUtilities.fromBlockVector( 322 | selection.getWorld(), 323 | vector 324 | ) 325 | ) 326 | .collect(Collectors.toSet()); 327 | } 328 | 329 | @Override 330 | public int getMinimumY() { 331 | return selection.getMinimumPoint().getBlockY(); 332 | } 333 | 334 | @Override 335 | public int getMaximumY() { 336 | return selection.getMaximumPoint().getBlockY(); 337 | } 338 | }; 339 | } else { 340 | throw new UnsupportedOperationException("Unsupported " + selection.getClass().getSimpleName() 341 | + " selection!"); 342 | } 343 | }); 344 | } 345 | } 346 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/event/EventListener.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.event; 2 | 3 | import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent; 4 | import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent; 5 | import com.sk89q.worldguard.bukkit.event.entity.UseEntityEvent; 6 | import com.sk89q.worldguard.protection.events.DisallowedPVPEvent; 7 | import lombok.NoArgsConstructor; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.Event.Result; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.Listener; 14 | import org.codemc.worldguardwrapper.event.*; 15 | 16 | @NoArgsConstructor 17 | public class EventListener implements Listener { 18 | 19 | @EventHandler(priority = EventPriority.LOW) 20 | public void onUseBlock(UseBlockEvent worldGuardEvent) { 21 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 22 | if (player == null) { 23 | // Only forward player events for now 24 | return; 25 | } 26 | 27 | AbstractWrappedEvent event = new WrappedUseBlockEvent( 28 | worldGuardEvent.getOriginalEvent(), 29 | player, worldGuardEvent.getWorld(), 30 | worldGuardEvent.getBlocks(), 31 | worldGuardEvent.getEffectiveMaterial()); 32 | Bukkit.getServer().getPluginManager().callEvent(event); 33 | 34 | if (event.getResult() != Result.DEFAULT) { 35 | // DEFAULT = Result probably has not been touched by the handler, 36 | // so don't touch the original result either. 37 | worldGuardEvent.setResult(event.getResult()); 38 | } 39 | } 40 | 41 | @EventHandler(priority = EventPriority.LOW) 42 | public void onUseEntity(UseEntityEvent worldGuardEvent) { 43 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 44 | if (player == null) { 45 | // Only forward player events for now 46 | return; 47 | } 48 | 49 | AbstractWrappedEvent event = new WrappedUseEntityEvent( 50 | worldGuardEvent.getOriginalEvent(), 51 | player, 52 | worldGuardEvent.getTarget(), 53 | worldGuardEvent.getEntity()); 54 | Bukkit.getServer().getPluginManager().callEvent(event); 55 | 56 | if (event.getResult() != Result.DEFAULT) { 57 | // DEFAULT = Result probably has not been touched by the handler, 58 | // so don't touch the original result either. 59 | worldGuardEvent.setResult(event.getResult()); 60 | } 61 | } 62 | 63 | @EventHandler(priority = EventPriority.LOW) 64 | public void onDamageEntity(DamageEntityEvent worldGuardEvent) { 65 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 66 | if (player == null) { 67 | // Only forward player events for now 68 | return; 69 | } 70 | 71 | AbstractWrappedEvent event = new WrappedDamageEntityEvent( 72 | worldGuardEvent.getOriginalEvent(), 73 | player, 74 | worldGuardEvent.getTarget(), 75 | worldGuardEvent.getEntity()); 76 | Bukkit.getServer().getPluginManager().callEvent(event); 77 | 78 | if (event.getResult() != Result.DEFAULT) { 79 | // DEFAULT = Result probably has not been touched by the handler, 80 | // so don't touch the original result either. 81 | worldGuardEvent.setResult(event.getResult()); 82 | } 83 | } 84 | 85 | @EventHandler(priority = EventPriority.LOW) 86 | public void onDisallowedPVP(DisallowedPVPEvent worldGuardEvent) { 87 | AbstractWrappedEvent event = new WrappedDisallowedPVPEvent( 88 | worldGuardEvent.getAttacker(), 89 | worldGuardEvent.getDefender(), 90 | worldGuardEvent.getCause()); 91 | Bukkit.getServer().getPluginManager().callEvent(event); 92 | 93 | if (event.getResult() != Result.DEFAULT) { 94 | // DEFAULT = Result probably has not been touched by the handler, 95 | // so don't touch the original result either. 96 | worldGuardEvent.setCancelled(event.getResult() == Result.DENY); 97 | } 98 | } 99 | 100 | } 101 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/flag/AbstractWrappedFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import lombok.AllArgsConstructor; 5 | import lombok.Getter; 6 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 7 | 8 | import java.util.Optional; 9 | 10 | @AllArgsConstructor 11 | @Getter 12 | public abstract class AbstractWrappedFlag implements IWrappedFlag { 13 | 14 | private final Flag handle; 15 | 16 | @Override 17 | public String getName() { 18 | return handle.getName(); 19 | } 20 | 21 | public abstract Optional fromWGValue(Object value); 22 | 23 | public abstract Optional fromWrapperValue(T value); 24 | 25 | @Override 26 | public Optional getDefaultValue() { 27 | return fromWGValue(handle.getDefault()); 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/flag/WrappedPrimitiveFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import org.bukkit.Location; 5 | import org.bukkit.util.Vector; 6 | import org.codemc.worldguardwrapper.implementation.legacy.utility.WorldGuardFlagUtilities; 7 | 8 | import java.util.Optional; 9 | 10 | public class WrappedPrimitiveFlag extends AbstractWrappedFlag { 11 | 12 | public WrappedPrimitiveFlag(Flag handle) { 13 | super(handle); 14 | } 15 | 16 | @SuppressWarnings("unchecked") 17 | @Override 18 | public Optional fromWGValue(Object value) { 19 | if (value instanceof com.sk89q.worldedit.Location) { 20 | return Optional.of((T) WorldGuardFlagUtilities.adaptLocation((com.sk89q.worldedit.Location) value)); 21 | } else if (value instanceof com.sk89q.worldedit.Vector) { 22 | return Optional.of((T) WorldGuardFlagUtilities.adaptVector((com.sk89q.worldedit.Vector) value)); 23 | } 24 | return Optional.ofNullable((T) value); 25 | } 26 | 27 | @Override 28 | public Optional fromWrapperValue(T value) { 29 | if (value instanceof Location) { 30 | return Optional.of(WorldGuardFlagUtilities.adaptLocation((Location) value)); 31 | } else if (value instanceof Vector) { 32 | return Optional.of(WorldGuardFlagUtilities.adaptVector((Vector) value)); 33 | } 34 | return Optional.ofNullable(value); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/flag/WrappedStatusFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import com.sk89q.worldguard.protection.flags.StateFlag; 5 | import org.codemc.worldguardwrapper.flag.IWrappedStatusFlag; 6 | import org.codemc.worldguardwrapper.flag.WrappedState; 7 | 8 | import java.util.Optional; 9 | 10 | public class WrappedStatusFlag extends AbstractWrappedFlag implements IWrappedStatusFlag { 11 | 12 | public WrappedStatusFlag(Flag handle) { 13 | super(handle); 14 | } 15 | 16 | @Override 17 | public Optional fromWGValue(Object value) { 18 | return Optional.ofNullable(value) 19 | .map(state -> state == StateFlag.State.ALLOW ? WrappedState.ALLOW : WrappedState.DENY); 20 | } 21 | 22 | @Override 23 | public Optional fromWrapperValue(WrappedState value) { 24 | return Optional.ofNullable(value) 25 | .map(state -> state == WrappedState.ALLOW ? StateFlag.State.ALLOW : StateFlag.State.DENY); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/region/WrappedRegion.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.region; 2 | 3 | import com.sk89q.worldedit.BlockVector; 4 | import com.sk89q.worldguard.protection.flags.Flag; 5 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 6 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 7 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 8 | import lombok.AllArgsConstructor; 9 | import lombok.Getter; 10 | import org.bukkit.Location; 11 | import org.bukkit.World; 12 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 13 | import org.codemc.worldguardwrapper.implementation.legacy.flag.AbstractWrappedFlag; 14 | import org.codemc.worldguardwrapper.implementation.legacy.utility.WorldGuardFlagUtilities; 15 | import org.codemc.worldguardwrapper.implementation.legacy.utility.WorldGuardVectorUtilities; 16 | import org.codemc.worldguardwrapper.region.IWrappedDomain; 17 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 18 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 19 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 20 | import org.codemc.worldguardwrapper.selection.ISelection; 21 | 22 | import java.util.*; 23 | import java.util.stream.Collectors; 24 | 25 | @AllArgsConstructor 26 | @Getter 27 | public class WrappedRegion implements IWrappedRegion { 28 | 29 | private final World world; 30 | private final ProtectedRegion handle; 31 | 32 | @Override 33 | public ISelection getSelection() { 34 | if (handle instanceof ProtectedCuboidRegion) { 35 | return new ICuboidSelection() { 36 | @Override 37 | public Location getMinimumPoint() { 38 | return WorldGuardVectorUtilities.fromBlockVector(world, handle.getMinimumPoint()); 39 | } 40 | 41 | @Override 42 | public Location getMaximumPoint() { 43 | return WorldGuardVectorUtilities.fromBlockVector(world, handle.getMaximumPoint()); 44 | } 45 | }; 46 | } else if (handle instanceof ProtectedPolygonalRegion) { 47 | return new IPolygonalSelection() { 48 | @Override 49 | public Set getPoints() { 50 | return handle.getPoints().stream() 51 | .map(vector -> new BlockVector(vector.toVector())) 52 | .map(vector -> WorldGuardVectorUtilities.fromBlockVector(world, vector)) 53 | .collect(Collectors.toSet()); 54 | } 55 | 56 | @Override 57 | public int getMinimumY() { 58 | return handle.getMinimumPoint().getBlockY(); 59 | } 60 | 61 | @Override 62 | public int getMaximumY() { 63 | return handle.getMaximumPoint().getBlockY(); 64 | } 65 | }; 66 | } else { 67 | throw new UnsupportedOperationException("Unsupported " + handle.getClass().getSimpleName() + " region!"); 68 | } 69 | } 70 | 71 | @Override 72 | public String getId() { 73 | return handle.getId(); 74 | } 75 | 76 | @Override 77 | public Map, Object> getFlags() { 78 | Map, Object> result = new HashMap<>(); 79 | handle.getFlags().forEach((flag, value) -> { 80 | if (value != null) { 81 | try { 82 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 83 | result.put(wrapped.getKey(), wrapped.getValue()); 84 | } catch (IllegalArgumentException ignored) {/* Unsupported flag type */} 85 | } 86 | }); 87 | return result; 88 | } 89 | 90 | @SuppressWarnings("unchecked") 91 | @Override 92 | public Optional getFlag(IWrappedFlag flag) { 93 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 94 | return Optional.ofNullable(handle.getFlag(wrappedFlag.getHandle())) 95 | .map(value -> (T) wrappedFlag.fromWGValue(value)); 96 | } 97 | 98 | @SuppressWarnings("unchecked") 99 | @Override 100 | public void setFlag(IWrappedFlag flag, T value) { 101 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 102 | handle.setFlag((Flag) wrappedFlag.getHandle(), wrappedFlag.fromWrapperValue(value).orElse(null)); 103 | } 104 | 105 | @Override 106 | public int getPriority() { 107 | return handle.getPriority(); 108 | } 109 | 110 | @Override 111 | public void setPriority(int priority) { 112 | handle.setPriority(priority); 113 | } 114 | 115 | @Override 116 | public IWrappedDomain getOwners() { 117 | return new IWrappedDomain() { 118 | @Override 119 | public Set getPlayers() { 120 | return handle.getOwners().getUniqueIds(); 121 | } 122 | 123 | @Override 124 | public void addPlayer(UUID uuid) { 125 | handle.getOwners().addPlayer(uuid); 126 | } 127 | 128 | @Override 129 | public void removePlayer(UUID uuid) { 130 | handle.getOwners().removePlayer(uuid); 131 | } 132 | 133 | @Override 134 | public Set getGroups() { 135 | return handle.getOwners().getGroups(); 136 | } 137 | 138 | @Override 139 | public void addGroup(String name) { 140 | handle.getOwners().addGroup(name); 141 | } 142 | 143 | @Override 144 | public void removeGroup(String name) { 145 | handle.getOwners().removeGroup(name); 146 | } 147 | }; 148 | } 149 | 150 | @Override 151 | public IWrappedDomain getMembers() { 152 | return new IWrappedDomain() { 153 | @Override 154 | public Set getPlayers() { 155 | return handle.getMembers().getUniqueIds(); 156 | } 157 | 158 | @Override 159 | public void addPlayer(UUID uuid) { 160 | handle.getMembers().addPlayer(uuid); 161 | } 162 | 163 | @Override 164 | public void removePlayer(UUID uuid) { 165 | handle.getMembers().removePlayer(uuid); 166 | } 167 | 168 | @Override 169 | public Set getGroups() { 170 | return handle.getMembers().getGroups(); 171 | } 172 | 173 | @Override 174 | public void addGroup(String name) { 175 | handle.getMembers().addGroup(name); 176 | } 177 | 178 | @Override 179 | public void removeGroup(String name) { 180 | handle.getMembers().removeGroup(name); 181 | } 182 | }; 183 | } 184 | 185 | @Override 186 | public boolean contains(Location location) { 187 | return handle.contains(WorldGuardVectorUtilities.toBlockVector(location)); 188 | } 189 | 190 | } 191 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/utility/WorldGuardFlagUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.utility; 2 | 3 | import com.google.common.collect.Maps; 4 | import com.sk89q.worldedit.bukkit.BukkitWorld; 5 | import com.sk89q.worldguard.protection.flags.Flag; 6 | import com.sk89q.worldguard.protection.flags.StateFlag; 7 | import lombok.experimental.UtilityClass; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.Location; 10 | import org.bukkit.World; 11 | import org.bukkit.util.Vector; 12 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 13 | import org.codemc.worldguardwrapper.flag.WrappedState; 14 | import org.codemc.worldguardwrapper.implementation.legacy.flag.AbstractWrappedFlag; 15 | import org.codemc.worldguardwrapper.implementation.legacy.flag.WrappedPrimitiveFlag; 16 | import org.codemc.worldguardwrapper.implementation.legacy.flag.WrappedStatusFlag; 17 | 18 | import java.util.Map; 19 | 20 | @UtilityClass 21 | public class WorldGuardFlagUtilities { 22 | 23 | // TODO: find a better way to define wrapper mappings and register mappings 24 | @SuppressWarnings({"unchecked", "rawtypes"}) 25 | public IWrappedFlag wrap(Flag flag, Class type) { 26 | final IWrappedFlag wrappedFlag; 27 | if (type.equals(WrappedState.class)) { 28 | wrappedFlag = (IWrappedFlag) new WrappedStatusFlag((Flag) flag); 29 | } else if (type.equals(Boolean.class) || type.equals(boolean.class)) { 30 | wrappedFlag = new WrappedPrimitiveFlag(flag); 31 | } else if (type.equals(Double.class) || type.equals(double.class)) { 32 | wrappedFlag = new WrappedPrimitiveFlag(flag); 33 | } else if (type.equals(Enum.class)) { 34 | wrappedFlag = new WrappedPrimitiveFlag(flag); 35 | } else if (type.equals(Integer.class) || type.equals(int.class)) { 36 | wrappedFlag = new WrappedPrimitiveFlag(flag); 37 | } else if (type.equals(Location.class)) { 38 | wrappedFlag = new WrappedPrimitiveFlag(flag); 39 | } else if (type.equals(String.class)) { 40 | wrappedFlag = new WrappedPrimitiveFlag(flag); 41 | } else if (type.equals(Vector.class)) { 42 | wrappedFlag = new WrappedPrimitiveFlag(flag); 43 | } else if (type.equals(Object.class)) { 44 | wrappedFlag = new WrappedPrimitiveFlag(flag); 45 | } else { 46 | throw new IllegalArgumentException("Unsupported flag type " + type.getName()); 47 | } 48 | return wrappedFlag; 49 | } 50 | 51 | // Used when the flag's type is not known, so it has to be derived from a sample value's class 52 | public IWrappedFlag wrapFixType(Flag flag, Class type) { 53 | if (StateFlag.State.class.isAssignableFrom(type)) { 54 | // StateFlag 55 | type = WrappedState.class; 56 | } else if (com.sk89q.worldedit.Location.class.isAssignableFrom(type)) { 57 | // LocationFlag 58 | type = org.bukkit.Location.class; 59 | } else if (com.sk89q.worldedit.Vector.class.isAssignableFrom(type)) { 60 | // VectorFlag 61 | type = Vector.class; 62 | } 63 | 64 | return wrap(flag, type); 65 | } 66 | 67 | public Map.Entry, Object> wrap(Flag flag, Object value) { 68 | IWrappedFlag wrappedFlag = wrapFixType(flag, value.getClass()); 69 | Object wrappedValue = ((AbstractWrappedFlag) wrappedFlag).fromWGValue(value) 70 | .orElseThrow(NullPointerException::new); // value should never be null 71 | return Maps.immutableEntry(wrappedFlag, wrappedValue); 72 | } 73 | 74 | public Vector adaptVector(com.sk89q.worldedit.Vector vector) { 75 | return new Vector(vector.getX(), vector.getY(), vector.getZ()); 76 | } 77 | 78 | public com.sk89q.worldedit.Vector adaptVector(Vector vector) { 79 | return new com.sk89q.worldedit.Vector(vector.getX(), vector.getY(), vector.getZ()); 80 | } 81 | 82 | public Location adaptLocation(com.sk89q.worldedit.Location location) { 83 | com.sk89q.worldedit.Vector pos = location.getPosition(); 84 | World world = location.getWorld() instanceof BukkitWorld 85 | ? ((BukkitWorld) location.getWorld()).getWorld() 86 | : Bukkit.getWorld(location.getWorld().getName()); 87 | 88 | return new Location(world, pos.getX(), pos.getY(), pos.getZ()); 89 | } 90 | 91 | public com.sk89q.worldedit.Location adaptLocation(Location location) { 92 | return new com.sk89q.worldedit.Location(new BukkitWorld(location.getWorld()), 93 | new com.sk89q.worldedit.Vector(location.getX(), location.getY(), location.getZ())); 94 | } 95 | 96 | } 97 | -------------------------------------------------------------------------------- /implementation/legacy/src/main/java/org/codemc/worldguardwrapper/implementation/legacy/utility/WorldGuardVectorUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.legacy.utility; 2 | 3 | import com.sk89q.worldedit.BlockVector; 4 | import com.sk89q.worldedit.BlockVector2D; 5 | import lombok.experimental.UtilityClass; 6 | import org.bukkit.Location; 7 | import org.bukkit.World; 8 | 9 | import java.util.List; 10 | import java.util.stream.Collectors; 11 | 12 | @UtilityClass 13 | public class WorldGuardVectorUtilities { 14 | 15 | public BlockVector toBlockVector(Location location) { 16 | return new BlockVector(location.getX(), location.getY(), location.getZ()); 17 | } 18 | 19 | public Location fromBlockVector(World world, BlockVector vector) { 20 | return new Location(world, vector.getX(), vector.getY(), vector.getZ()); 21 | } 22 | 23 | public List toBlockVector2DList(List locations) { 24 | return locations.stream() 25 | .map(location -> new BlockVector2D(location.getX(), location.getZ())) 26 | .collect(Collectors.toList()); 27 | } 28 | 29 | } 30 | -------------------------------------------------------------------------------- /implementation/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-parent 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper-implementation 15 | pom 16 | 17 | 18 | legacy 19 | v6 20 | v7 21 | 22 | 23 | WorldGuardWrapper-Implementation 24 | 25 | 26 | true 27 | 28 | 29 | 30 | 31 | org.javassist 32 | javassist 33 | 34 | 35 | 36 | -------------------------------------------------------------------------------- /implementation/v6/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-implementation 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper-implementation-v6 15 | 16 | WorldGuardWrapper-Implementation-V6 17 | 18 | 19 | 20 | enginehub-repo 21 | https://maven.enginehub.org/repo/ 22 | 23 | always 24 | 25 | 26 | 27 | 28 | 29 | 30 | ${project.groupId} 31 | worldguardwrapper-api 32 | 1.2.1-SNAPSHOT 33 | provided 34 | 35 | 36 | com.sk89q.worldguard 37 | worldguard-legacy 38 | 6.2 39 | provided 40 | 41 | 42 | com.sk89q.worldedit 43 | worldedit-bukkit 44 | 6.1.5 45 | provided 46 | 47 | 48 | com.sk89q.worldedit 49 | worldedit-core 50 | 6.1.3-SNAPSHOT 51 | provided 52 | 53 | 54 | de.schlichtherle 55 | truezip 56 | 57 | 58 | com.google.guava 59 | guava 60 | 61 | 62 | rhino 63 | js 64 | 65 | 66 | org.yaml 67 | snakeyaml 68 | 69 | 70 | com.thoughtworks.paranamer 71 | paranamer 72 | 73 | 74 | com.google.code.gson 75 | gson 76 | 77 | 78 | com.sk89q.lib 79 | jlibnoise 80 | 81 | 82 | com.sk89q 83 | jchronic 84 | 85 | 86 | com.google.code.findbugs 87 | jsr305 88 | 89 | 90 | 91 | 92 | 93 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/WorldGuardImplementation.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6; 2 | 3 | import com.google.common.collect.Iterators; 4 | import com.sk89q.minecraft.util.commands.CommandException; 5 | import com.sk89q.worldedit.BlockVector; 6 | import com.sk89q.worldedit.bukkit.WorldEditPlugin; 7 | import com.sk89q.worldedit.bukkit.selections.CuboidSelection; 8 | import com.sk89q.worldedit.bukkit.selections.Polygonal2DSelection; 9 | import com.sk89q.worldguard.LocalPlayer; 10 | import com.sk89q.worldguard.bukkit.WorldGuardPlugin; 11 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 12 | import com.sk89q.worldguard.protection.flags.*; 13 | import com.sk89q.worldguard.protection.flags.registry.FlagConflictException; 14 | import com.sk89q.worldguard.protection.flags.registry.FlagRegistry; 15 | import com.sk89q.worldguard.protection.managers.RegionManager; 16 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 17 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 18 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 19 | import com.sk89q.worldguard.session.Session; 20 | import com.sk89q.worldguard.session.handler.Handler; 21 | import javassist.util.proxy.ProxyFactory; 22 | import lombok.NonNull; 23 | import org.bukkit.Location; 24 | import org.bukkit.OfflinePlayer; 25 | import org.bukkit.World; 26 | import org.bukkit.entity.Player; 27 | import org.bukkit.plugin.java.JavaPlugin; 28 | import org.bukkit.util.Vector; 29 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 30 | import org.codemc.worldguardwrapper.flag.WrappedState; 31 | import org.codemc.worldguardwrapper.handler.IHandler; 32 | import org.codemc.worldguardwrapper.implementation.IWorldGuardImplementation; 33 | import org.codemc.worldguardwrapper.implementation.v6.flag.AbstractWrappedFlag; 34 | import org.codemc.worldguardwrapper.implementation.v6.handler.ProxyHandler; 35 | import org.codemc.worldguardwrapper.implementation.v6.region.WrappedRegion; 36 | import org.codemc.worldguardwrapper.implementation.v6.utility.WorldGuardFlagUtilities; 37 | import org.codemc.worldguardwrapper.implementation.v6.utility.WorldGuardVectorUtilities; 38 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 39 | import org.codemc.worldguardwrapper.region.IWrappedRegionSet; 40 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 41 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 42 | import org.codemc.worldguardwrapper.selection.ISelection; 43 | 44 | import java.lang.reflect.Constructor; 45 | import java.lang.reflect.InvocationTargetException; 46 | import java.util.*; 47 | import java.util.function.Supplier; 48 | import java.util.stream.Collectors; 49 | 50 | public class WorldGuardImplementation implements IWorldGuardImplementation { 51 | 52 | private final WorldGuardPlugin worldGuardPlugin; 53 | private final WorldEditPlugin worldEditPlugin; 54 | private final FlagRegistry flagRegistry; 55 | 56 | public WorldGuardImplementation() { 57 | worldGuardPlugin = WorldGuardPlugin.inst(); 58 | try { 59 | worldEditPlugin = worldGuardPlugin.getWorldEdit(); 60 | } catch (CommandException e) { 61 | throw new RuntimeException(e); 62 | } 63 | flagRegistry = worldGuardPlugin.getFlagRegistry(); 64 | } 65 | 66 | private Optional wrapPlayer(OfflinePlayer player) { 67 | return Optional.ofNullable(player).map(bukkitPlayer -> { 68 | if (bukkitPlayer.isOnline()) { 69 | return worldGuardPlugin.wrapPlayer((Player) bukkitPlayer); 70 | } 71 | return worldGuardPlugin.wrapOfflinePlayer(bukkitPlayer); 72 | }); 73 | } 74 | 75 | private Optional getWorldManager(@NonNull World world) { 76 | return Optional.ofNullable(worldGuardPlugin.getRegionManager(world)); 77 | } 78 | 79 | private Optional getApplicableRegions(@NonNull Location location) { 80 | return getWorldManager(Objects.requireNonNull(location.getWorld())) 81 | .map(manager -> manager.getApplicableRegions(location)); 82 | } 83 | 84 | private Optional getApplicableRegions(@NonNull Location minimum, @NonNull Location maximum) { 85 | return getWorldManager(Objects.requireNonNull(minimum.getWorld())) 86 | .map(manager -> manager.getApplicableRegions( 87 | new ProtectedCuboidRegion( 88 | "temp", 89 | WorldGuardVectorUtilities.toBlockVector(minimum), 90 | WorldGuardVectorUtilities.toBlockVector(maximum) 91 | ) 92 | )); 93 | } 94 | 95 | private Optional queryValue(Player player, @NonNull Location location, @NonNull Flag flag) { 96 | return getApplicableRegions(location) 97 | .map(applicableRegions -> applicableRegions.queryValue(wrapPlayer(player).orElse(null), flag)); 98 | } 99 | 100 | public IWrappedRegionSet wrapRegionSet(@NonNull World world, @NonNull ApplicableRegionSet regionSet) { 101 | return new IWrappedRegionSet() { 102 | 103 | @Override 104 | public Iterator iterator() { 105 | return Iterators.transform(regionSet.iterator(), region -> new WrappedRegion(world, region)); 106 | } 107 | 108 | @Override 109 | public boolean isVirtual() { 110 | return regionSet.isVirtual(); 111 | } 112 | 113 | @Override 114 | public Optional queryValue(OfflinePlayer subject, IWrappedFlag flag) { 115 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 116 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 117 | return Optional.ofNullable(regionSet.queryValue(subjectHandle, wrappedFlag.getHandle())) 118 | .flatMap(wrappedFlag::fromWGValue); 119 | } 120 | 121 | @Override 122 | public Collection queryAllValues(OfflinePlayer subject, IWrappedFlag flag) { 123 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 124 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 125 | return regionSet.queryAllValues(subjectHandle, wrappedFlag.getHandle()).stream() 126 | .map(wrappedFlag::fromWGValue) 127 | .filter(Optional::isPresent) 128 | .map(Optional::get) 129 | .collect(Collectors.toList()); 130 | } 131 | 132 | @Override 133 | public boolean isOwnerOfAll(OfflinePlayer player) { 134 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 135 | return regionSet.isOwnerOfAll(playerHandle); 136 | } 137 | 138 | @Override 139 | public boolean isMemberOfAll(OfflinePlayer player) { 140 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 141 | return regionSet.isMemberOfAll(playerHandle); 142 | } 143 | 144 | @Override 145 | public int size() { 146 | return regionSet.size(); 147 | } 148 | 149 | @Override 150 | public Set getRegions() { 151 | return regionSet.getRegions() 152 | .stream() 153 | .map(region -> new WrappedRegion(world, region)) 154 | .collect(Collectors.toSet()); 155 | } 156 | }; 157 | } 158 | 159 | @Override 160 | public JavaPlugin getWorldGuardPlugin() { 161 | return WorldGuardPlugin.inst(); 162 | } 163 | 164 | @Override 165 | public int getApiVersion() { 166 | return 6; 167 | } 168 | 169 | @Override 170 | public void registerHandler(Supplier factory) { 171 | ProxyFactory proxyFactory = new ProxyFactory(); 172 | proxyFactory.setUseCache(false); 173 | proxyFactory.setSuperclass(ProxyHandler.class); 174 | 175 | Class handlerClass; 176 | Constructor handlerConstructor; 177 | try { 178 | //noinspection unchecked 179 | handlerClass = (Class) proxyFactory.createClass(); 180 | handlerConstructor = handlerClass.getDeclaredConstructor( 181 | WorldGuardImplementation.class, 182 | IHandler.class, 183 | Session.class 184 | ); 185 | } catch (NoSuchMethodException e) { 186 | throw new RuntimeException(e); 187 | } 188 | 189 | worldGuardPlugin.getSessionManager().registerHandler(new Handler.Factory() { 190 | @Override 191 | public Handler create(Session session) { 192 | IHandler handler = factory.get(); 193 | try { 194 | return handlerConstructor.newInstance(WorldGuardImplementation.this, handler, session); 195 | } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { 196 | throw new RuntimeException(e); 197 | } 198 | } 199 | }, null); 200 | } 201 | 202 | @Override 203 | public Optional> getFlag(String name, Class type) { 204 | return Optional.ofNullable(flagRegistry.get(name)) 205 | .map(flag -> WorldGuardFlagUtilities.wrap(flag, type)); 206 | } 207 | 208 | @Override 209 | public Optional queryFlag(Player player, @NonNull Location location, @NonNull IWrappedFlag flag) { 210 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 211 | return queryValue(player, location, wrappedFlag.getHandle()).flatMap(wrappedFlag::fromWGValue); 212 | } 213 | 214 | @Override 215 | public Map, Object> queryApplicableFlags(Player player, Location location) { 216 | ApplicableRegionSet applicableSet = getApplicableRegions(location).orElse(null); 217 | if (applicableSet == null) { 218 | return Collections.emptyMap(); 219 | } 220 | 221 | LocalPlayer localPlayer = wrapPlayer(player).orElse(null); 222 | Map, Object> flags = new HashMap<>(); 223 | Set seen = new HashSet<>(); 224 | 225 | for (ProtectedRegion region : applicableSet.getRegions()) { 226 | for (Flag flag : region.getFlags().keySet()) { 227 | if (seen.add(flag.getName())) { 228 | Object value = applicableSet.queryValue(localPlayer, flag); 229 | if (value == null) { 230 | continue; 231 | } 232 | 233 | try { 234 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 235 | flags.put(wrapped.getKey(), wrapped.getValue()); 236 | } catch (IllegalArgumentException e) { 237 | // Unsupported flag type 238 | } 239 | } 240 | } 241 | } 242 | 243 | return flags; 244 | } 245 | 246 | @SuppressWarnings({"unchecked", "rawtypes"}) 247 | @Override 248 | public Optional> registerFlag(@NonNull String name, @NonNull Class type, T defaultValue) { 249 | final Flag flag; 250 | if (type.equals(WrappedState.class)) { 251 | flag = new StateFlag(name, defaultValue == WrappedState.ALLOW); 252 | } else if (type.equals(Boolean.class) || type.equals(boolean.class)) { 253 | flag = new BooleanFlag(name); 254 | } else if (type.equals(Double.class) || type.equals(double.class)) { 255 | flag = new DoubleFlag(name); 256 | } else if (type.equals(Enum.class)) { 257 | flag = new EnumFlag(name, type); 258 | } else if (type.equals(Integer.class) || type.equals(int.class)) { 259 | flag = new IntegerFlag(name); 260 | } else if (type.equals(Location.class)) { 261 | flag = new LocationFlag(name); 262 | } else if (type.equals(String.class)) { 263 | flag = new StringFlag(name, (String) defaultValue); 264 | } else if (type.equals(Vector.class)) { 265 | flag = new VectorFlag(name); 266 | } else { 267 | throw new IllegalArgumentException("Unsupported flag type " + type.getName()); 268 | } 269 | try { 270 | flagRegistry.register(flag); 271 | return Optional.of(WorldGuardFlagUtilities.wrap(flag, type)); 272 | } catch (FlagConflictException ignored) { 273 | } 274 | return Optional.empty(); 275 | } 276 | 277 | @Override 278 | public Optional getRegion(@NonNull World world, @NonNull String id) { 279 | return getWorldManager(world) 280 | .map(regionManager -> regionManager.getRegion(id)) 281 | .map(region -> new WrappedRegion(world, region)); 282 | } 283 | 284 | @Override 285 | public Map getRegions(@NonNull World world) { 286 | RegionManager regionManager = worldGuardPlugin.getRegionManager(world); 287 | Map regions = regionManager.getRegions(); 288 | 289 | Map map = new HashMap<>(); 290 | regions.forEach((name, region) -> map.put(name, new WrappedRegion(world, region))); 291 | 292 | return map; 293 | } 294 | 295 | @Override 296 | public Set getRegions(@NonNull Location location) { 297 | ApplicableRegionSet regionSet = getApplicableRegions(location).orElse(null); 298 | Set set = new HashSet<>(); 299 | 300 | if (regionSet == null) { 301 | return set; 302 | } 303 | 304 | regionSet.forEach(region -> set.add(new WrappedRegion(location.getWorld(), region))); 305 | return set; 306 | } 307 | 308 | @Override 309 | public Set getRegions(@NonNull Location minimum, @NonNull Location maximum) { 310 | ApplicableRegionSet regionSet = getApplicableRegions(minimum, maximum).orElse(null); 311 | Set set = new HashSet<>(); 312 | 313 | if (regionSet == null) { 314 | return set; 315 | } 316 | 317 | regionSet.forEach(region -> set.add(new WrappedRegion(minimum.getWorld(), region))); 318 | return set; 319 | } 320 | 321 | @Override 322 | public Optional getRegionSet(@NonNull Location location) { 323 | return getApplicableRegions(location) 324 | .map(regionSet -> wrapRegionSet(Objects.requireNonNull(location.getWorld()), regionSet)); 325 | } 326 | 327 | @Override 328 | public Optional addRegion(@NonNull String id, @NonNull List points, int minY, int maxY) { 329 | ProtectedRegion region; 330 | World world = Objects.requireNonNull(points.get(0).getWorld()); 331 | if (points.size() == 2) { 332 | region = new ProtectedCuboidRegion( 333 | id, 334 | WorldGuardVectorUtilities.toBlockVector(points.get(0)), 335 | WorldGuardVectorUtilities.toBlockVector(points.get(1)) 336 | ); 337 | } else { 338 | region = new ProtectedPolygonalRegion( 339 | id, 340 | WorldGuardVectorUtilities.toBlockVector2DList(points), 341 | minY, 342 | maxY 343 | ); 344 | } 345 | 346 | Optional manager = getWorldManager(world); 347 | if (manager.isPresent()) { 348 | manager.get().addRegion(region); 349 | return Optional.of(new WrappedRegion(world, region)); 350 | } else { 351 | return Optional.empty(); 352 | } 353 | } 354 | 355 | @Override 356 | public Optional> removeRegion(@NonNull World world, @NonNull String id) { 357 | Optional> set = getWorldManager(world).map(manager -> manager.removeRegion(id)); 358 | return set.map(protectedRegions -> 359 | protectedRegions.stream() 360 | .map(region -> new WrappedRegion(world, region)) 361 | .collect(Collectors.toSet()) 362 | ); 363 | } 364 | 365 | @Override 366 | public Optional getPlayerSelection(@NonNull Player player) { 367 | return Optional.ofNullable(worldEditPlugin.getSelection(player)) 368 | .map(selection -> { 369 | if (selection instanceof CuboidSelection) { 370 | return new ICuboidSelection() { 371 | @Override 372 | public Location getMinimumPoint() { 373 | return selection.getMinimumPoint(); 374 | } 375 | 376 | @Override 377 | public Location getMaximumPoint() { 378 | return selection.getMaximumPoint(); 379 | } 380 | }; 381 | } else if (selection instanceof Polygonal2DSelection) { 382 | return new IPolygonalSelection() { 383 | @Override 384 | public Set getPoints() { 385 | return ((Polygonal2DSelection) selection).getNativePoints().stream() 386 | .map(vector -> new BlockVector(vector.toVector())) 387 | .map(vector -> 388 | WorldGuardVectorUtilities.fromBlockVector( 389 | selection.getWorld(), 390 | vector 391 | ) 392 | ) 393 | .collect(Collectors.toSet()); 394 | } 395 | 396 | @Override 397 | public int getMinimumY() { 398 | return selection.getMinimumPoint().getBlockY(); 399 | } 400 | 401 | @Override 402 | public int getMaximumY() { 403 | return selection.getMaximumPoint().getBlockY(); 404 | } 405 | }; 406 | } else { 407 | throw new UnsupportedOperationException("Unsupported " + selection.getClass().getSimpleName() 408 | + " selection!"); 409 | } 410 | }); 411 | } 412 | } 413 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/event/EventListener.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.event; 2 | 3 | import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent; 4 | import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent; 5 | import com.sk89q.worldguard.bukkit.event.entity.UseEntityEvent; 6 | import com.sk89q.worldguard.protection.events.DisallowedPVPEvent; 7 | import lombok.NoArgsConstructor; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.Event.Result; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.Listener; 14 | import org.codemc.worldguardwrapper.event.*; 15 | 16 | @NoArgsConstructor 17 | public class EventListener implements Listener { 18 | 19 | @EventHandler(priority = EventPriority.LOW) 20 | public void onUseBlock(UseBlockEvent worldGuardEvent) { 21 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 22 | if (player == null) { 23 | // Only forward player events for now 24 | return; 25 | } 26 | 27 | AbstractWrappedEvent event = new WrappedUseBlockEvent( 28 | worldGuardEvent.getOriginalEvent(), 29 | player, worldGuardEvent.getWorld(), 30 | worldGuardEvent.getBlocks(), 31 | worldGuardEvent.getEffectiveMaterial()); 32 | Bukkit.getServer().getPluginManager().callEvent(event); 33 | 34 | if (event.getResult() != Result.DEFAULT) { 35 | // DEFAULT = Result probably has not been touched by the handler, 36 | // so don't touch the original result either. 37 | worldGuardEvent.setResult(event.getResult()); 38 | } 39 | } 40 | 41 | @EventHandler(priority = EventPriority.LOW) 42 | public void onUseEntity(UseEntityEvent worldGuardEvent) { 43 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 44 | if (player == null) { 45 | // Only forward player events for now 46 | return; 47 | } 48 | 49 | AbstractWrappedEvent event = new WrappedUseEntityEvent( 50 | worldGuardEvent.getOriginalEvent(), 51 | player, 52 | worldGuardEvent.getTarget(), 53 | worldGuardEvent.getEntity()); 54 | Bukkit.getServer().getPluginManager().callEvent(event); 55 | 56 | if (event.getResult() != Result.DEFAULT) { 57 | // DEFAULT = Result probably has not been touched by the handler, 58 | // so don't touch the original result either. 59 | worldGuardEvent.setResult(event.getResult()); 60 | } 61 | } 62 | 63 | @EventHandler(priority = EventPriority.LOW) 64 | public void onDamageEntity(DamageEntityEvent worldGuardEvent) { 65 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 66 | if (player == null) { 67 | // Only forward player events for now 68 | return; 69 | } 70 | 71 | AbstractWrappedEvent event = new WrappedDamageEntityEvent( 72 | worldGuardEvent.getOriginalEvent(), 73 | player, 74 | worldGuardEvent.getTarget(), 75 | worldGuardEvent.getEntity()); 76 | Bukkit.getServer().getPluginManager().callEvent(event); 77 | 78 | if (event.getResult() != Result.DEFAULT) { 79 | // DEFAULT = Result probably has not been touched by the handler, 80 | // so don't touch the original result either. 81 | worldGuardEvent.setResult(event.getResult()); 82 | } 83 | } 84 | 85 | @EventHandler(priority = EventPriority.LOW) 86 | public void onDisallowedPVP(DisallowedPVPEvent worldGuardEvent) { 87 | AbstractWrappedEvent event = new WrappedDisallowedPVPEvent( 88 | worldGuardEvent.getAttacker(), 89 | worldGuardEvent.getDefender(), 90 | worldGuardEvent.getCause()); 91 | Bukkit.getServer().getPluginManager().callEvent(event); 92 | 93 | if (event.getResult() != Result.DEFAULT) { 94 | // DEFAULT = Result probably has not been touched by the handler, 95 | // so don't touch the original result either. 96 | worldGuardEvent.setCancelled(event.getResult() == Result.DENY); 97 | } 98 | } 99 | 100 | } 101 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/flag/AbstractWrappedFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import lombok.AllArgsConstructor; 5 | import lombok.Getter; 6 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 7 | 8 | import java.util.Optional; 9 | 10 | @AllArgsConstructor 11 | @Getter 12 | public abstract class AbstractWrappedFlag implements IWrappedFlag { 13 | 14 | private final Flag handle; 15 | 16 | @Override 17 | public String getName() { 18 | return handle.getName(); 19 | } 20 | 21 | public abstract Optional fromWGValue(Object value); 22 | 23 | public abstract Optional fromWrapperValue(T value); 24 | 25 | @Override 26 | public Optional getDefaultValue() { 27 | return fromWGValue(handle.getDefault()); 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/flag/WrappedPrimitiveFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import org.bukkit.Location; 5 | import org.bukkit.util.Vector; 6 | import org.codemc.worldguardwrapper.implementation.v6.utility.WorldGuardFlagUtilities; 7 | 8 | import java.util.Optional; 9 | 10 | public class WrappedPrimitiveFlag extends AbstractWrappedFlag { 11 | 12 | public WrappedPrimitiveFlag(Flag handle) { 13 | super(handle); 14 | } 15 | 16 | @SuppressWarnings("unchecked") 17 | @Override 18 | public Optional fromWGValue(Object value) { 19 | if (value instanceof com.sk89q.worldedit.util.Location) { 20 | return Optional.of((T) WorldGuardFlagUtilities.adaptLocation((com.sk89q.worldedit.util.Location) value)); 21 | } else if (value instanceof com.sk89q.worldedit.Vector) { 22 | return Optional.of((T) WorldGuardFlagUtilities.adaptVector((com.sk89q.worldedit.Vector) value)); 23 | } 24 | return Optional.ofNullable((T) value); 25 | } 26 | 27 | @Override 28 | public Optional fromWrapperValue(T value) { 29 | if (value instanceof Location) { 30 | return Optional.of(WorldGuardFlagUtilities.adaptLocation((Location) value)); 31 | } else if (value instanceof Vector) { 32 | return Optional.of(WorldGuardFlagUtilities.adaptVector((Vector) value)); 33 | } 34 | return Optional.ofNullable(value); 35 | } 36 | 37 | } 38 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/flag/WrappedStatusFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import com.sk89q.worldguard.protection.flags.StateFlag; 5 | import org.codemc.worldguardwrapper.flag.IWrappedStatusFlag; 6 | import org.codemc.worldguardwrapper.flag.WrappedState; 7 | 8 | import java.util.Optional; 9 | 10 | public class WrappedStatusFlag extends AbstractWrappedFlag implements IWrappedStatusFlag { 11 | 12 | public WrappedStatusFlag(Flag handle) { 13 | super(handle); 14 | } 15 | 16 | @Override 17 | public Optional fromWGValue(Object value) { 18 | return Optional.ofNullable(value) 19 | .map(state -> state == StateFlag.State.ALLOW ? WrappedState.ALLOW : WrappedState.DENY); 20 | } 21 | 22 | @Override 23 | public Optional fromWrapperValue(WrappedState value) { 24 | return Optional.ofNullable(value) 25 | .map(state -> state == WrappedState.ALLOW ? StateFlag.State.ALLOW : StateFlag.State.DENY); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/handler/ProxyHandler.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.handler; 2 | 3 | import com.google.common.collect.Collections2; 4 | import com.google.common.collect.ImmutableSet; 5 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 6 | import com.sk89q.worldguard.protection.flags.StateFlag; 7 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 8 | import com.sk89q.worldguard.session.MoveType; 9 | import com.sk89q.worldguard.session.Session; 10 | import com.sk89q.worldguard.session.handler.Handler; 11 | import org.bukkit.Location; 12 | import org.bukkit.entity.Player; 13 | import org.codemc.worldguardwrapper.flag.WrappedState; 14 | import org.codemc.worldguardwrapper.handler.IHandler; 15 | import org.codemc.worldguardwrapper.implementation.v6.WorldGuardImplementation; 16 | import org.codemc.worldguardwrapper.implementation.v6.region.WrappedRegion; 17 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 18 | 19 | import javax.annotation.Nullable; 20 | import java.util.Objects; 21 | import java.util.Set; 22 | 23 | public class ProxyHandler extends Handler { 24 | 25 | private final WorldGuardImplementation implementation; 26 | private final IHandler handler; 27 | 28 | public ProxyHandler(WorldGuardImplementation implementation, IHandler handler, Session session) { 29 | super(session); 30 | this.implementation = implementation; 31 | this.handler = handler; 32 | } 33 | 34 | @Override 35 | public void initialize(Player player, Location current, ApplicableRegionSet set) { 36 | handler.initialize( 37 | player, 38 | current, 39 | implementation.wrapRegionSet(Objects.requireNonNull(current.getWorld()), set) 40 | ); 41 | } 42 | 43 | @Override 44 | public boolean testMoveTo(Player player, Location from, Location to, ApplicableRegionSet toSet, MoveType moveType) { 45 | return handler.testMoveTo(player, 46 | from, 47 | to, 48 | implementation.wrapRegionSet(Objects.requireNonNull(to.getWorld()), toSet), 49 | moveType.name() 50 | ); 51 | } 52 | 53 | @Override 54 | public boolean onCrossBoundary( 55 | Player player, 56 | Location from, 57 | Location to, 58 | ApplicableRegionSet toSet, 59 | Set entered, 60 | Set exited, 61 | MoveType moveType 62 | ) { 63 | Set mappedEntered = ImmutableSet.copyOf( 64 | Collections2.transform(entered, region -> new WrappedRegion(to.getWorld(), region)) 65 | ); 66 | Set mappedExited = ImmutableSet.copyOf( 67 | Collections2.transform(exited, region -> new WrappedRegion(from.getWorld(), region)) 68 | ); 69 | return handler.onCrossBoundary( 70 | player, 71 | from, 72 | to, 73 | implementation.wrapRegionSet(Objects.requireNonNull(to.getWorld()), toSet), 74 | mappedEntered, 75 | mappedExited, 76 | moveType.name() 77 | ); 78 | } 79 | 80 | @Override 81 | public void tick(Player player, ApplicableRegionSet set) { 82 | handler.tick(player, implementation.wrapRegionSet(player.getWorld(), set)); 83 | } 84 | 85 | @Nullable 86 | @Override 87 | public StateFlag.State getInvincibility(Player player) { 88 | WrappedState state = handler.getInvincibility(player); 89 | if (state == null) { 90 | return null; 91 | } 92 | return state == WrappedState.ALLOW ? StateFlag.State.ALLOW : StateFlag.State.DENY; 93 | } 94 | } 95 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/region/WrappedRegion.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.region; 2 | 3 | import com.sk89q.worldedit.BlockVector; 4 | import com.sk89q.worldguard.protection.flags.Flag; 5 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 6 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 7 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 8 | import lombok.AllArgsConstructor; 9 | import lombok.Getter; 10 | import org.bukkit.Location; 11 | import org.bukkit.World; 12 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 13 | import org.codemc.worldguardwrapper.implementation.v6.flag.AbstractWrappedFlag; 14 | import org.codemc.worldguardwrapper.implementation.v6.utility.WorldGuardFlagUtilities; 15 | import org.codemc.worldguardwrapper.implementation.v6.utility.WorldGuardVectorUtilities; 16 | import org.codemc.worldguardwrapper.region.IWrappedDomain; 17 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 18 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 19 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 20 | import org.codemc.worldguardwrapper.selection.ISelection; 21 | 22 | import java.util.*; 23 | import java.util.stream.Collectors; 24 | 25 | @AllArgsConstructor 26 | @Getter 27 | public class WrappedRegion implements IWrappedRegion { 28 | 29 | private final World world; 30 | private final ProtectedRegion handle; 31 | 32 | @Override 33 | public ISelection getSelection() { 34 | if (handle instanceof ProtectedCuboidRegion) { 35 | return new ICuboidSelection() { 36 | @Override 37 | public Location getMinimumPoint() { 38 | return WorldGuardVectorUtilities.fromBlockVector(world, handle.getMinimumPoint()); 39 | } 40 | 41 | @Override 42 | public Location getMaximumPoint() { 43 | return WorldGuardVectorUtilities.fromBlockVector(world, handle.getMaximumPoint()); 44 | } 45 | }; 46 | } else if (handle instanceof ProtectedPolygonalRegion) { 47 | return new IPolygonalSelection() { 48 | @Override 49 | public Set getPoints() { 50 | return handle.getPoints().stream() 51 | .map(vector -> new BlockVector(vector.toVector())) 52 | .map(vector -> WorldGuardVectorUtilities.fromBlockVector(world, vector)) 53 | .collect(Collectors.toSet()); 54 | } 55 | 56 | @Override 57 | public int getMinimumY() { 58 | return handle.getMinimumPoint().getBlockY(); 59 | } 60 | 61 | @Override 62 | public int getMaximumY() { 63 | return handle.getMaximumPoint().getBlockY(); 64 | } 65 | }; 66 | } else { 67 | throw new UnsupportedOperationException("Unsupported " + handle.getClass().getSimpleName() + " region!"); 68 | } 69 | } 70 | 71 | @Override 72 | public String getId() { 73 | return handle.getId(); 74 | } 75 | 76 | @Override 77 | public Map, Object> getFlags() { 78 | Map, Object> result = new HashMap<>(); 79 | handle.getFlags().forEach((flag, value) -> { 80 | if (value != null) { 81 | try { 82 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 83 | result.put(wrapped.getKey(), wrapped.getValue()); 84 | } catch (IllegalArgumentException ignored) {/* Unsupported flag type */} 85 | } 86 | }); 87 | return result; 88 | } 89 | 90 | @SuppressWarnings("unchecked") 91 | @Override 92 | public Optional getFlag(IWrappedFlag flag) { 93 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 94 | return Optional.ofNullable(handle.getFlag(wrappedFlag.getHandle())) 95 | .map(value -> (T) wrappedFlag.fromWGValue(value)); 96 | } 97 | 98 | @SuppressWarnings("unchecked") 99 | @Override 100 | public void setFlag(IWrappedFlag flag, T value) { 101 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 102 | handle.setFlag((Flag) wrappedFlag.getHandle(), wrappedFlag.fromWrapperValue(value).orElse(null)); 103 | } 104 | 105 | @Override 106 | public int getPriority() { 107 | return handle.getPriority(); 108 | } 109 | 110 | @Override 111 | public void setPriority(int priority) { 112 | handle.setPriority(priority); 113 | } 114 | 115 | @Override 116 | public IWrappedDomain getOwners() { 117 | return new IWrappedDomain() { 118 | @Override 119 | public Set getPlayers() { 120 | return handle.getOwners().getUniqueIds(); 121 | } 122 | 123 | @Override 124 | public void addPlayer(UUID uuid) { 125 | handle.getOwners().addPlayer(uuid); 126 | } 127 | 128 | @Override 129 | public void removePlayer(UUID uuid) { 130 | handle.getOwners().removePlayer(uuid); 131 | } 132 | 133 | @Override 134 | public Set getGroups() { 135 | return handle.getOwners().getGroups(); 136 | } 137 | 138 | @Override 139 | public void addGroup(String name) { 140 | handle.getOwners().addGroup(name); 141 | } 142 | 143 | @Override 144 | public void removeGroup(String name) { 145 | handle.getOwners().removeGroup(name); 146 | } 147 | }; 148 | } 149 | 150 | @Override 151 | public IWrappedDomain getMembers() { 152 | return new IWrappedDomain() { 153 | @Override 154 | public Set getPlayers() { 155 | return handle.getMembers().getUniqueIds(); 156 | } 157 | 158 | @Override 159 | public void addPlayer(UUID uuid) { 160 | handle.getMembers().addPlayer(uuid); 161 | } 162 | 163 | @Override 164 | public void removePlayer(UUID uuid) { 165 | handle.getMembers().removePlayer(uuid); 166 | } 167 | 168 | @Override 169 | public Set getGroups() { 170 | return handle.getMembers().getGroups(); 171 | } 172 | 173 | @Override 174 | public void addGroup(String name) { 175 | handle.getMembers().addGroup(name); 176 | } 177 | 178 | @Override 179 | public void removeGroup(String name) { 180 | handle.getMembers().removeGroup(name); 181 | } 182 | }; 183 | } 184 | 185 | @Override 186 | public boolean contains(Location location) { 187 | return handle.contains(WorldGuardVectorUtilities.toBlockVector(location)); 188 | } 189 | 190 | } 191 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/utility/WorldGuardFlagUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.utility; 2 | 3 | import com.google.common.collect.Maps; 4 | import com.sk89q.worldedit.bukkit.BukkitWorld; 5 | import com.sk89q.worldguard.protection.flags.Flag; 6 | import com.sk89q.worldguard.protection.flags.StateFlag; 7 | import lombok.experimental.UtilityClass; 8 | import org.bukkit.Location; 9 | import org.bukkit.World; 10 | import org.bukkit.util.Vector; 11 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 12 | import org.codemc.worldguardwrapper.flag.WrappedState; 13 | import org.codemc.worldguardwrapper.implementation.v6.flag.AbstractWrappedFlag; 14 | import org.codemc.worldguardwrapper.implementation.v6.flag.WrappedPrimitiveFlag; 15 | import org.codemc.worldguardwrapper.implementation.v6.flag.WrappedStatusFlag; 16 | 17 | import java.util.Map; 18 | 19 | @UtilityClass 20 | public class WorldGuardFlagUtilities { 21 | 22 | // TODO: find a better way to define wrapper mappings and register mappings 23 | @SuppressWarnings({"unchecked", "rawtypes"}) 24 | public IWrappedFlag wrap(Flag flag, Class type) { 25 | final IWrappedFlag wrappedFlag; 26 | if (type.equals(WrappedState.class)) { 27 | wrappedFlag = (IWrappedFlag) new WrappedStatusFlag((Flag) flag); 28 | } else if (type.equals(Boolean.class) || type.equals(boolean.class)) { 29 | wrappedFlag = new WrappedPrimitiveFlag(flag); 30 | } else if (type.equals(Double.class) || type.equals(double.class)) { 31 | wrappedFlag = new WrappedPrimitiveFlag(flag); 32 | } else if (type.equals(Enum.class)) { 33 | wrappedFlag = new WrappedPrimitiveFlag(flag); 34 | } else if (type.equals(Integer.class) || type.equals(int.class)) { 35 | wrappedFlag = new WrappedPrimitiveFlag(flag); 36 | } else if (type.equals(Location.class)) { 37 | wrappedFlag = new WrappedPrimitiveFlag(flag); 38 | } else if (type.equals(String.class)) { 39 | wrappedFlag = new WrappedPrimitiveFlag(flag); 40 | } else if (type.equals(Vector.class)) { 41 | wrappedFlag = new WrappedPrimitiveFlag(flag); 42 | } else if (type.equals(Object.class)) { 43 | wrappedFlag = new WrappedPrimitiveFlag(flag); 44 | } else { 45 | throw new IllegalArgumentException("Unsupported flag type " + type.getName()); 46 | } 47 | return wrappedFlag; 48 | } 49 | 50 | // Used when the flag's type is not known, so it has to be derived from a sample value's class 51 | public IWrappedFlag wrapFixType(Flag flag, Class type) { 52 | if (StateFlag.State.class.isAssignableFrom(type)) { 53 | // StateFlag 54 | type = WrappedState.class; 55 | } else if (com.sk89q.worldedit.util.Location.class.isAssignableFrom(type)) { 56 | // LocationFlag 57 | type = org.bukkit.Location.class; 58 | } else if (com.sk89q.worldedit.Vector.class.isAssignableFrom(type)) { 59 | // VectorFlag 60 | type = Vector.class; 61 | } 62 | 63 | return wrap(flag, type); 64 | } 65 | 66 | public Map.Entry, Object> wrap(Flag flag, Object value) { 67 | IWrappedFlag wrappedFlag = wrapFixType(flag, value.getClass()); 68 | //noinspection OptionalGetWithoutIsPresent 69 | Object wrappedValue = ((AbstractWrappedFlag) wrappedFlag).fromWGValue(value).get(); // value is non-null 70 | return Maps.immutableEntry(wrappedFlag, wrappedValue); 71 | } 72 | 73 | public Vector adaptVector(com.sk89q.worldedit.Vector vector) { 74 | return new Vector(vector.getX(), vector.getY(), vector.getZ()); 75 | } 76 | 77 | public com.sk89q.worldedit.Vector adaptVector(Vector vector) { 78 | return new com.sk89q.worldedit.Vector(vector.getX(), vector.getY(), vector.getZ()); 79 | } 80 | 81 | public Location adaptLocation(com.sk89q.worldedit.util.Location location) { 82 | World world = location.getExtent() instanceof BukkitWorld 83 | ? ((BukkitWorld) location.getExtent()).getWorld() : null; 84 | 85 | return new Location(world, location.getX(), location.getY(), location.getZ()); 86 | } 87 | 88 | public com.sk89q.worldedit.util.Location adaptLocation(Location location) { 89 | return new com.sk89q.worldedit.util.Location(new BukkitWorld(location.getWorld()), 90 | location.getX(), location.getY(), location.getZ()); 91 | } 92 | 93 | } 94 | -------------------------------------------------------------------------------- /implementation/v6/src/main/java/org/codemc/worldguardwrapper/implementation/v6/utility/WorldGuardVectorUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v6.utility; 2 | 3 | import com.sk89q.worldedit.BlockVector; 4 | import com.sk89q.worldedit.BlockVector2D; 5 | import lombok.experimental.UtilityClass; 6 | import org.bukkit.Location; 7 | import org.bukkit.World; 8 | 9 | import java.util.List; 10 | import java.util.stream.Collectors; 11 | 12 | @UtilityClass 13 | public class WorldGuardVectorUtilities { 14 | 15 | public BlockVector toBlockVector(Location location) { 16 | return new BlockVector(location.getX(), location.getY(), location.getZ()); 17 | } 18 | 19 | public Location fromBlockVector(World world, BlockVector vector) { 20 | return new Location(world, vector.getX(), vector.getY(), vector.getZ()); 21 | } 22 | 23 | public List toBlockVector2DList(List locations) { 24 | return locations.stream() 25 | .map(location -> new BlockVector2D(location.getX(), location.getZ())).collect(Collectors.toList()); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /implementation/v7/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-implementation 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper-implementation-v7 15 | 16 | WorldGuardWrapper-Implementation-V7 17 | 18 | 19 | 20 | enginehub-repo 21 | https://maven.enginehub.org/repo/ 22 | 23 | always 24 | 25 | 26 | 27 | 28 | 29 | 30 | ${project.groupId} 31 | worldguardwrapper-api 32 | 1.2.1-SNAPSHOT 33 | provided 34 | 35 | 36 | com.sk89q.worldguard 37 | worldguard-bukkit 38 | 7.0.8 39 | provided 40 | 41 | 42 | org.bukkit 43 | bukkit 44 | 45 | 46 | com.sk89q 47 | commandbook 48 | 49 | 50 | com.sk89q 51 | dummypermscompat 52 | 53 | 54 | com.sk89q.intake 55 | intake 56 | 57 | 58 | com.sk89q 59 | squirrelid 60 | 61 | 62 | org.khelekore 63 | prtree 64 | 65 | 66 | net.sf.opencsv 67 | opencsv 68 | 69 | 70 | com.googlecode.json-simple 71 | json-simple 72 | 73 | 74 | org.flywaydb 75 | flyway-core 76 | 77 | 78 | io.papermc 79 | paperlib 80 | 81 | 82 | com.destroystokyo.paper 83 | paper-api 84 | 85 | 86 | org.bstats.bStats-Metrics 87 | bstats-bukkit 88 | 89 | 90 | org.bstats 91 | bstats-bukkit 92 | 93 | 94 | rhino 95 | js 96 | 97 | 98 | org.yaml 99 | snakeyaml 100 | 101 | 102 | de.schlichtherle 103 | truezip 104 | 105 | 106 | com.google.guava 107 | guava 108 | 109 | 110 | com.sk89q 111 | jchronic 112 | 113 | 114 | com.google.code.findbugs 115 | jsr305 116 | 117 | 118 | com.thoughtworks.paranamer 119 | paranamer 120 | 121 | 122 | com.google.code.gson 123 | gson 124 | 125 | 126 | com.sk89q.lib 127 | jlibnoise 128 | 129 | 130 | 131 | 132 | 133 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/WorldGuardImplementation.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7; 2 | 3 | import com.google.common.collect.Iterators; 4 | import com.sk89q.worldedit.IncompleteRegionException; 5 | import com.sk89q.worldedit.WorldEdit; 6 | import com.sk89q.worldedit.bukkit.BukkitAdapter; 7 | import com.sk89q.worldedit.bukkit.BukkitWorld; 8 | import com.sk89q.worldedit.math.BlockVector2; 9 | import com.sk89q.worldedit.regions.CuboidRegion; 10 | import com.sk89q.worldedit.regions.Polygonal2DRegion; 11 | import com.sk89q.worldedit.regions.Region; 12 | import com.sk89q.worldguard.LocalPlayer; 13 | import com.sk89q.worldguard.WorldGuard; 14 | import com.sk89q.worldguard.bukkit.WorldGuardPlugin; 15 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 16 | import com.sk89q.worldguard.protection.flags.*; 17 | import com.sk89q.worldguard.protection.flags.registry.FlagConflictException; 18 | import com.sk89q.worldguard.protection.flags.registry.FlagRegistry; 19 | import com.sk89q.worldguard.protection.managers.RegionManager; 20 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 21 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 22 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 23 | import com.sk89q.worldguard.session.Session; 24 | import com.sk89q.worldguard.session.handler.Handler; 25 | import javassist.util.proxy.ProxyFactory; 26 | import lombok.NonNull; 27 | import org.bukkit.Location; 28 | import org.bukkit.OfflinePlayer; 29 | import org.bukkit.World; 30 | import org.bukkit.entity.Player; 31 | import org.bukkit.plugin.java.JavaPlugin; 32 | import org.bukkit.util.Vector; 33 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 34 | import org.codemc.worldguardwrapper.flag.WrappedState; 35 | import org.codemc.worldguardwrapper.handler.IHandler; 36 | import org.codemc.worldguardwrapper.implementation.IWorldGuardImplementation; 37 | import org.codemc.worldguardwrapper.implementation.v7.flag.AbstractWrappedFlag; 38 | import org.codemc.worldguardwrapper.implementation.v7.handler.ProxyHandler; 39 | import org.codemc.worldguardwrapper.implementation.v7.region.WrappedRegion; 40 | import org.codemc.worldguardwrapper.implementation.v7.utility.WorldGuardFlagUtilities; 41 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 42 | import org.codemc.worldguardwrapper.region.IWrappedRegionSet; 43 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 44 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 45 | import org.codemc.worldguardwrapper.selection.ISelection; 46 | 47 | import java.lang.reflect.Constructor; 48 | import java.lang.reflect.InvocationTargetException; 49 | import java.util.*; 50 | import java.util.function.Supplier; 51 | import java.util.stream.Collectors; 52 | 53 | public class WorldGuardImplementation implements IWorldGuardImplementation { 54 | 55 | private final WorldGuard core; 56 | private final FlagRegistry flagRegistry; 57 | 58 | public WorldGuardImplementation() { 59 | core = WorldGuard.getInstance(); 60 | flagRegistry = core.getFlagRegistry(); 61 | } 62 | 63 | private Optional wrapPlayer(OfflinePlayer player) { 64 | return Optional.ofNullable(player).map(bukkitPlayer -> { 65 | if (bukkitPlayer.isOnline()) { 66 | return WorldGuardPlugin.inst().wrapPlayer((Player) bukkitPlayer); 67 | } 68 | return WorldGuardPlugin.inst().wrapOfflinePlayer(bukkitPlayer); 69 | }); 70 | } 71 | 72 | private Optional getWorldManager(@NonNull World world) { 73 | return Optional.ofNullable(core.getPlatform().getRegionContainer().get(BukkitAdapter.adapt(world))); 74 | } 75 | 76 | private Optional getApplicableRegions(@NonNull Location location) { 77 | return getWorldManager(Objects.requireNonNull(location.getWorld())) 78 | .map(manager -> manager.getApplicableRegions(BukkitAdapter.asBlockVector(location))); 79 | } 80 | 81 | private Optional getApplicableRegions(@NonNull Location minimum, @NonNull Location maximum) { 82 | return getWorldManager(Objects.requireNonNull(minimum.getWorld())) 83 | .map(manager -> manager.getApplicableRegions( 84 | new ProtectedCuboidRegion( 85 | "temp", 86 | BukkitAdapter.asBlockVector(minimum), 87 | BukkitAdapter.asBlockVector(maximum) 88 | ) 89 | )); 90 | } 91 | 92 | private Optional queryValue(Player player, @NonNull Location location, @NonNull Flag flag) { 93 | return getApplicableRegions(location) 94 | .map(applicableRegions -> applicableRegions.queryValue(wrapPlayer(player).orElse(null), flag)); 95 | } 96 | 97 | public IWrappedRegionSet wrapRegionSet(@NonNull World world, @NonNull ApplicableRegionSet regionSet) { 98 | return new IWrappedRegionSet() { 99 | 100 | @Override 101 | public Iterator iterator() { 102 | return Iterators.transform(regionSet.iterator(), region -> new WrappedRegion(world, region)); 103 | } 104 | 105 | @Override 106 | public boolean isVirtual() { 107 | return regionSet.isVirtual(); 108 | } 109 | 110 | @Override 111 | public Optional queryValue(OfflinePlayer subject, IWrappedFlag flag) { 112 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 113 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 114 | return Optional.ofNullable(regionSet.queryValue(subjectHandle, wrappedFlag.getHandle())) 115 | .flatMap(wrappedFlag::fromWGValue); 116 | } 117 | 118 | @Override 119 | public Collection queryAllValues(OfflinePlayer subject, IWrappedFlag flag) { 120 | LocalPlayer subjectHandle = wrapPlayer(subject).orElse(null); 121 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 122 | return regionSet.queryAllValues(subjectHandle, wrappedFlag.getHandle()).stream() 123 | .map(wrappedFlag::fromWGValue) 124 | .filter(Optional::isPresent) 125 | .map(Optional::get) 126 | .collect(Collectors.toList()); 127 | } 128 | 129 | @Override 130 | public boolean isOwnerOfAll(OfflinePlayer player) { 131 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 132 | return regionSet.isOwnerOfAll(playerHandle); 133 | } 134 | 135 | @Override 136 | public boolean isMemberOfAll(OfflinePlayer player) { 137 | LocalPlayer playerHandle = wrapPlayer(player).orElse(null); 138 | return regionSet.isMemberOfAll(playerHandle); 139 | } 140 | 141 | @Override 142 | public int size() { 143 | return regionSet.size(); 144 | } 145 | 146 | @Override 147 | public Set getRegions() { 148 | return regionSet.getRegions().stream() 149 | .map(region -> new WrappedRegion(world, region)).collect(Collectors.toSet()); 150 | } 151 | }; 152 | } 153 | 154 | @Override 155 | public JavaPlugin getWorldGuardPlugin() { 156 | return WorldGuardPlugin.inst(); 157 | } 158 | 159 | @Override 160 | public int getApiVersion() { 161 | return 7; 162 | } 163 | 164 | @Override 165 | public void registerHandler(Supplier factory) { 166 | ProxyFactory proxyFactory = new ProxyFactory(); 167 | proxyFactory.setUseCache(false); 168 | proxyFactory.setSuperclass(ProxyHandler.class); 169 | 170 | Class handlerClass; 171 | Constructor handlerConstructor; 172 | try { 173 | //noinspection unchecked 174 | handlerClass = (Class) proxyFactory.createClass(); 175 | handlerConstructor = handlerClass.getDeclaredConstructor( 176 | WorldGuardImplementation.class, 177 | IHandler.class, 178 | Session.class 179 | ); 180 | } catch (NoSuchMethodException e) { 181 | throw new RuntimeException(e); 182 | } 183 | 184 | core.getPlatform().getSessionManager().registerHandler(new Handler.Factory() { 185 | @Override 186 | public Handler create(Session session) { 187 | IHandler handler = factory.get(); 188 | try { 189 | return handlerConstructor.newInstance(WorldGuardImplementation.this, handler, session); 190 | } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) { 191 | throw new RuntimeException(e); 192 | } 193 | } 194 | }, null); 195 | } 196 | 197 | @Override 198 | public Optional> getFlag(String name, Class type) { 199 | return Optional.ofNullable(flagRegistry.get(name)) 200 | .map(flag -> WorldGuardFlagUtilities.wrap(flag, type)); 201 | } 202 | 203 | @Override 204 | public Optional queryFlag(Player player, @NonNull Location location, @NonNull IWrappedFlag flag) { 205 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 206 | return queryValue(player, location, wrappedFlag.getHandle()).flatMap(wrappedFlag::fromWGValue); 207 | } 208 | 209 | @Override 210 | public Map, Object> queryApplicableFlags(Player player, Location location) { 211 | ApplicableRegionSet applicableSet = getApplicableRegions(location).orElse(null); 212 | if (applicableSet == null) { 213 | return Collections.emptyMap(); 214 | } 215 | 216 | LocalPlayer localPlayer = wrapPlayer(player).orElse(null); 217 | Map, Object> flags = new HashMap<>(); 218 | Set seen = new HashSet<>(); 219 | 220 | for (ProtectedRegion region : applicableSet.getRegions()) { 221 | for (Flag flag : region.getFlags().keySet()) { 222 | if (seen.add(flag.getName())) { 223 | Object value = applicableSet.queryValue(localPlayer, flag); 224 | if (value == null) { 225 | continue; 226 | } 227 | 228 | try { 229 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 230 | flags.put(wrapped.getKey(), wrapped.getValue()); 231 | } catch (IllegalArgumentException e) { 232 | // Unsupported flag type 233 | } 234 | } 235 | } 236 | } 237 | 238 | return flags; 239 | } 240 | 241 | @SuppressWarnings({"unchecked", "rawtypes"}) 242 | @Override 243 | public Optional> registerFlag(@NonNull String name, @NonNull Class type, T defaultValue) { 244 | final Flag flag; 245 | if (type.equals(WrappedState.class)) { 246 | flag = new StateFlag(name, defaultValue == WrappedState.ALLOW); 247 | } else if (type.equals(Boolean.class) || type.equals(boolean.class)) { 248 | flag = new BooleanFlag(name); 249 | } else if (type.equals(Double.class) || type.equals(double.class)) { 250 | flag = new DoubleFlag(name); 251 | } else if (type.equals(Enum.class)) { 252 | flag = new EnumFlag(name, type); 253 | } else if (type.equals(Integer.class) || type.equals(int.class)) { 254 | flag = new IntegerFlag(name); 255 | } else if (type.equals(Location.class)) { 256 | flag = new LocationFlag(name); 257 | } else if (type.equals(String.class)) { 258 | flag = new StringFlag(name, (String) defaultValue); 259 | } else if (type.equals(Vector.class)) { 260 | flag = new VectorFlag(name); 261 | } else { 262 | throw new IllegalArgumentException("Unsupported flag type " + type.getName()); 263 | } 264 | try { 265 | flagRegistry.register(flag); 266 | return Optional.of(WorldGuardFlagUtilities.wrap(flag, type)); 267 | } catch (FlagConflictException ignored) { 268 | } 269 | return Optional.empty(); 270 | } 271 | 272 | @Override 273 | public Optional getRegion(@NonNull World world, @NonNull String id) { 274 | return getWorldManager(world) 275 | .map(regionManager -> regionManager.getRegion(id)) 276 | .map(region -> new WrappedRegion(world, region)); 277 | } 278 | 279 | @Override 280 | public Map getRegions(@NonNull World world) { 281 | RegionManager regionManager = core.getPlatform().getRegionContainer().get(new BukkitWorld(world)); 282 | if (regionManager == null) { 283 | return Collections.emptyMap(); 284 | } 285 | 286 | Map regions = regionManager.getRegions(); 287 | Map map = new HashMap<>(); 288 | regions.forEach((name, region) -> map.put(name, new WrappedRegion(world, region))); 289 | return map; 290 | } 291 | 292 | @Override 293 | public Set getRegions(@NonNull Location location) { 294 | ApplicableRegionSet regionSet = getApplicableRegions(location).orElse(null); 295 | if (regionSet == null) { 296 | return Collections.emptySet(); 297 | } 298 | 299 | return regionSet.getRegions().stream() 300 | .map(region -> new WrappedRegion(location.getWorld(), region)) 301 | .collect(Collectors.toSet()); 302 | } 303 | 304 | @Override 305 | public Set getRegions(@NonNull Location minimum, @NonNull Location maximum) { 306 | ApplicableRegionSet regionSet = getApplicableRegions(minimum, maximum).orElse(null); 307 | if (regionSet == null) { 308 | return Collections.emptySet(); 309 | } 310 | 311 | return regionSet.getRegions().stream() 312 | .map(region -> new WrappedRegion(minimum.getWorld(), region)) 313 | .collect(Collectors.toSet()); 314 | } 315 | 316 | @Override 317 | public Optional getRegionSet(@NonNull Location location) { 318 | return Optional.empty(); 319 | } 320 | 321 | @Override 322 | public Optional addRegion(@NonNull String id, @NonNull List points, int minY, int maxY) { 323 | ProtectedRegion region; 324 | World world = Objects.requireNonNull(points.get(0).getWorld()); 325 | if (points.size() == 2) { 326 | region = new ProtectedCuboidRegion(id, BukkitAdapter.asBlockVector(points.get(0)), 327 | BukkitAdapter.asBlockVector(points.get(1))); 328 | } else { 329 | List vectorPoints = points.stream() 330 | .map(location -> BukkitAdapter.asBlockVector(location).toBlockVector2()) 331 | .collect(Collectors.toList()); 332 | 333 | region = new ProtectedPolygonalRegion(id, vectorPoints, minY, maxY); 334 | } 335 | 336 | Optional manager = getWorldManager(world); 337 | if (manager.isPresent()) { 338 | manager.get().addRegion(region); 339 | return Optional.of(new WrappedRegion(world, region)); 340 | } else { 341 | return Optional.empty(); 342 | } 343 | } 344 | 345 | @Override 346 | public Optional> removeRegion(@NonNull World world, @NonNull String id) { 347 | Optional> set = getWorldManager(world).map(manager -> manager.removeRegion(id)); 348 | return set.map(protectedRegions -> protectedRegions.stream() 349 | .map(region -> new WrappedRegion(world, region)).collect(Collectors.toSet())); 350 | } 351 | 352 | @Override 353 | public Optional getPlayerSelection(@NonNull Player player) { 354 | Region region; 355 | try { 356 | region = WorldEdit.getInstance() 357 | .getSessionManager() 358 | .get(BukkitAdapter.adapt(player)) 359 | .getSelection(BukkitAdapter.adapt(player.getWorld())); 360 | } catch (IncompleteRegionException e) { 361 | region = null; 362 | } 363 | return Optional.ofNullable(region) 364 | .map(selection -> { 365 | World world = Optional.ofNullable(selection.getWorld()) 366 | .map(BukkitAdapter::adapt) 367 | .orElse(null); 368 | if (world == null) { 369 | return null; 370 | } 371 | if (selection instanceof CuboidRegion) { 372 | return new ICuboidSelection() { 373 | @Override 374 | public Location getMinimumPoint() { 375 | return BukkitAdapter.adapt(world, selection.getMinimumPoint()); 376 | } 377 | 378 | @Override 379 | public Location getMaximumPoint() { 380 | return BukkitAdapter.adapt(world, selection.getMaximumPoint()); 381 | } 382 | }; 383 | } else if (selection instanceof Polygonal2DRegion) { 384 | return new IPolygonalSelection() { 385 | @Override 386 | public Set getPoints() { 387 | return ((Polygonal2DRegion) selection).getPoints().stream() 388 | .map(BlockVector2::toBlockVector3) 389 | .map(vector -> BukkitAdapter.adapt(world, vector)) 390 | .collect(Collectors.toSet()); 391 | } 392 | 393 | @Override 394 | public int getMinimumY() { 395 | return selection.getMinimumPoint().getBlockY(); 396 | } 397 | 398 | @Override 399 | public int getMaximumY() { 400 | return selection.getMaximumPoint().getBlockY(); 401 | } 402 | }; 403 | } else { 404 | throw new UnsupportedOperationException("Unsupported " + selection.getClass().getSimpleName() 405 | + " selection!"); 406 | } 407 | }); 408 | } 409 | } 410 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/event/EventListener.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.event; 2 | 3 | import com.sk89q.worldguard.bukkit.event.block.UseBlockEvent; 4 | import com.sk89q.worldguard.bukkit.event.entity.DamageEntityEvent; 5 | import com.sk89q.worldguard.bukkit.event.entity.UseEntityEvent; 6 | import com.sk89q.worldguard.bukkit.protection.events.DisallowedPVPEvent; 7 | import lombok.NoArgsConstructor; 8 | import org.bukkit.Bukkit; 9 | import org.bukkit.entity.Player; 10 | import org.bukkit.event.Event.Result; 11 | import org.bukkit.event.EventHandler; 12 | import org.bukkit.event.EventPriority; 13 | import org.bukkit.event.Listener; 14 | import org.codemc.worldguardwrapper.event.*; 15 | 16 | @NoArgsConstructor 17 | public class EventListener implements Listener { 18 | 19 | @EventHandler(priority = EventPriority.LOW) 20 | public void onUseBlock(UseBlockEvent worldGuardEvent) { 21 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 22 | if (player == null) { 23 | // Only forward player events for now 24 | return; 25 | } 26 | 27 | AbstractWrappedEvent event = new WrappedUseBlockEvent( 28 | worldGuardEvent.getOriginalEvent(), 29 | player, worldGuardEvent.getWorld(), 30 | worldGuardEvent.getBlocks(), 31 | worldGuardEvent.getEffectiveMaterial()); 32 | Bukkit.getServer().getPluginManager().callEvent(event); 33 | 34 | if (event.getResult() != Result.DEFAULT) { 35 | // DEFAULT = Result probably has not been touched by the handler, 36 | // so don't touch the original result either. 37 | worldGuardEvent.setResult(event.getResult()); 38 | } 39 | } 40 | 41 | @EventHandler(priority = EventPriority.LOW) 42 | public void onUseEntity(UseEntityEvent worldGuardEvent) { 43 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 44 | if (player == null) { 45 | // Only forward player events for now 46 | return; 47 | } 48 | 49 | AbstractWrappedEvent event = new WrappedUseEntityEvent( 50 | worldGuardEvent.getOriginalEvent(), 51 | player, 52 | worldGuardEvent.getTarget(), 53 | worldGuardEvent.getEntity()); 54 | Bukkit.getServer().getPluginManager().callEvent(event); 55 | 56 | if (event.getResult() != Result.DEFAULT) { 57 | // DEFAULT = Result probably has not been touched by the handler, 58 | // so don't touch the original result either. 59 | worldGuardEvent.setResult(event.getResult()); 60 | } 61 | } 62 | 63 | @EventHandler(priority = EventPriority.LOW) 64 | public void onDamageEntity(DamageEntityEvent worldGuardEvent) { 65 | Player player = worldGuardEvent.getCause().getFirstPlayer(); 66 | if (player == null) { 67 | // Only forward player events for now 68 | return; 69 | } 70 | 71 | AbstractWrappedEvent event = new WrappedDamageEntityEvent( 72 | worldGuardEvent.getOriginalEvent(), 73 | player, 74 | worldGuardEvent.getTarget(), 75 | worldGuardEvent.getEntity()); 76 | Bukkit.getServer().getPluginManager().callEvent(event); 77 | 78 | if (event.getResult() != Result.DEFAULT) { 79 | // DEFAULT = Result probably has not been touched by the handler, 80 | // so don't touch the original result either. 81 | worldGuardEvent.setResult(event.getResult()); 82 | } 83 | } 84 | 85 | @EventHandler(priority = EventPriority.LOW) 86 | public void onDisallowedPVP(DisallowedPVPEvent worldGuardEvent) { 87 | AbstractWrappedEvent event = new WrappedDisallowedPVPEvent( 88 | worldGuardEvent.getAttacker(), 89 | worldGuardEvent.getDefender(), 90 | worldGuardEvent.getCause()); 91 | Bukkit.getServer().getPluginManager().callEvent(event); 92 | 93 | if (event.getResult() != Result.DEFAULT) { 94 | // DEFAULT = Result probably has not been touched by the handler, 95 | // so don't touch the original result either. 96 | worldGuardEvent.setCancelled(event.getResult() == Result.DENY); 97 | } 98 | } 99 | 100 | } 101 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/flag/AbstractWrappedFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import lombok.AllArgsConstructor; 5 | import lombok.Getter; 6 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 7 | 8 | import java.util.Optional; 9 | 10 | @AllArgsConstructor 11 | @Getter 12 | public abstract class AbstractWrappedFlag implements IWrappedFlag { 13 | 14 | private final Flag handle; 15 | 16 | @Override 17 | public String getName() { 18 | return handle.getName(); 19 | } 20 | 21 | public abstract Optional fromWGValue(Object value); 22 | 23 | public abstract Optional fromWrapperValue(T value); 24 | 25 | @Override 26 | public Optional getDefaultValue() { 27 | return fromWGValue(handle.getDefault()); 28 | } 29 | 30 | } 31 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/flag/WrappedPrimitiveFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.flag; 2 | 3 | import com.sk89q.worldedit.bukkit.BukkitAdapter; 4 | import com.sk89q.worldedit.math.Vector3; 5 | import com.sk89q.worldguard.protection.flags.Flag; 6 | import org.bukkit.Location; 7 | import org.bukkit.util.Vector; 8 | import org.codemc.worldguardwrapper.implementation.v7.utility.WorldGuardFlagUtilities; 9 | 10 | import java.util.Optional; 11 | 12 | public class WrappedPrimitiveFlag extends AbstractWrappedFlag { 13 | 14 | public WrappedPrimitiveFlag(Flag handle) { 15 | super(handle); 16 | } 17 | 18 | @SuppressWarnings("unchecked") 19 | @Override 20 | public Optional fromWGValue(Object value) { 21 | if (value instanceof com.sk89q.worldedit.util.Location) { 22 | return Optional.of((T) BukkitAdapter.adapt((com.sk89q.worldedit.util.Location) value)); 23 | } else if (value instanceof Vector3) { 24 | return Optional.of((T) WorldGuardFlagUtilities.adaptVector((Vector3) value)); 25 | } 26 | return Optional.ofNullable((T) value); 27 | } 28 | 29 | @Override 30 | public Optional fromWrapperValue(T value) { 31 | if (value instanceof Location) { 32 | return Optional.of(BukkitAdapter.adapt((Location) value)); 33 | } else if (value instanceof Vector) { 34 | return Optional.of(WorldGuardFlagUtilities.adaptVector((Vector) value)); 35 | } 36 | return Optional.ofNullable(value); 37 | } 38 | 39 | } 40 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/flag/WrappedStatusFlag.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.flag; 2 | 3 | import com.sk89q.worldguard.protection.flags.Flag; 4 | import com.sk89q.worldguard.protection.flags.StateFlag; 5 | import org.codemc.worldguardwrapper.flag.IWrappedStatusFlag; 6 | import org.codemc.worldguardwrapper.flag.WrappedState; 7 | 8 | import java.util.Optional; 9 | 10 | public class WrappedStatusFlag extends AbstractWrappedFlag implements IWrappedStatusFlag { 11 | 12 | public WrappedStatusFlag(Flag handle) { 13 | super(handle); 14 | } 15 | 16 | @Override 17 | public Optional fromWGValue(Object value) { 18 | return Optional.ofNullable(value) 19 | .map(state -> state == StateFlag.State.ALLOW ? WrappedState.ALLOW : WrappedState.DENY); 20 | } 21 | 22 | @Override 23 | public Optional fromWrapperValue(WrappedState value) { 24 | return Optional.ofNullable(value) 25 | .map(state -> state == WrappedState.ALLOW ? StateFlag.State.ALLOW : StateFlag.State.DENY); 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/handler/ProxyHandler.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.handler; 2 | 3 | import com.google.common.collect.Collections2; 4 | import com.google.common.collect.ImmutableSet; 5 | import com.sk89q.worldedit.bukkit.BukkitAdapter; 6 | import com.sk89q.worldguard.LocalPlayer; 7 | import com.sk89q.worldguard.protection.ApplicableRegionSet; 8 | import com.sk89q.worldguard.protection.flags.StateFlag; 9 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 10 | import com.sk89q.worldguard.session.MoveType; 11 | import com.sk89q.worldguard.session.Session; 12 | import com.sk89q.worldguard.session.handler.Handler; 13 | import org.bukkit.Location; 14 | import org.bukkit.entity.Player; 15 | import org.codemc.worldguardwrapper.flag.WrappedState; 16 | import org.codemc.worldguardwrapper.handler.IHandler; 17 | import org.codemc.worldguardwrapper.implementation.v7.WorldGuardImplementation; 18 | import org.codemc.worldguardwrapper.implementation.v7.region.WrappedRegion; 19 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 20 | 21 | import javax.annotation.Nullable; 22 | import java.util.Objects; 23 | import java.util.Set; 24 | 25 | public class ProxyHandler extends Handler { 26 | 27 | private final WorldGuardImplementation implementation; 28 | private final IHandler handler; 29 | 30 | public ProxyHandler(WorldGuardImplementation implementation, IHandler handler, Session session) { 31 | super(session); 32 | this.implementation = implementation; 33 | this.handler = handler; 34 | } 35 | 36 | @Override 37 | public void initialize(LocalPlayer player, com.sk89q.worldedit.util.Location current, ApplicableRegionSet set) { 38 | Player bukkitPlayer = BukkitAdapter.adapt(player); 39 | Location bukkitLocation = BukkitAdapter.adapt(current); 40 | handler.initialize( 41 | bukkitPlayer, 42 | bukkitLocation, 43 | implementation.wrapRegionSet(Objects.requireNonNull(bukkitLocation.getWorld()),set) 44 | ); 45 | } 46 | 47 | @Override 48 | public boolean testMoveTo( 49 | LocalPlayer player, 50 | com.sk89q.worldedit.util.Location from, 51 | com.sk89q.worldedit.util.Location to, 52 | ApplicableRegionSet toSet, 53 | MoveType moveType 54 | ) { 55 | Player bukkitPlayer = BukkitAdapter.adapt(player); 56 | Location bukkitFrom = BukkitAdapter.adapt(from); 57 | Location bukkitTo = BukkitAdapter.adapt(to); 58 | return handler.testMoveTo( 59 | bukkitPlayer, 60 | bukkitFrom, 61 | bukkitTo, 62 | implementation.wrapRegionSet(Objects.requireNonNull(bukkitTo.getWorld()), toSet), 63 | moveType.name() 64 | ); 65 | } 66 | 67 | @Override 68 | public boolean onCrossBoundary( 69 | LocalPlayer player, 70 | com.sk89q.worldedit.util.Location from, 71 | com.sk89q.worldedit.util.Location to, 72 | ApplicableRegionSet toSet, 73 | Set entered, 74 | Set exited, 75 | MoveType moveType 76 | ) { 77 | Player bukkitPlayer = BukkitAdapter.adapt(player); 78 | Location bukkitFrom = BukkitAdapter.adapt(from); 79 | Location bukkitTo = BukkitAdapter.adapt(to); 80 | Set mappedEntered = ImmutableSet.copyOf(Collections2.transform(entered, region -> 81 | new WrappedRegion(bukkitTo.getWorld(), region) 82 | )); 83 | Set mappedExited = ImmutableSet.copyOf(Collections2.transform(exited, region -> 84 | new WrappedRegion(bukkitFrom.getWorld(), region) 85 | )); 86 | return handler.onCrossBoundary( 87 | bukkitPlayer, 88 | bukkitFrom, 89 | bukkitTo, 90 | implementation.wrapRegionSet(Objects.requireNonNull(bukkitTo.getWorld()), toSet), 91 | mappedEntered, 92 | mappedExited, 93 | moveType.name() 94 | ); 95 | } 96 | 97 | @Override 98 | public void tick(LocalPlayer player, ApplicableRegionSet set) { 99 | Player bukkitPlayer = BukkitAdapter.adapt(player); 100 | handler.tick(bukkitPlayer, implementation.wrapRegionSet(bukkitPlayer.getWorld(), set)); 101 | } 102 | 103 | @Nullable 104 | @Override 105 | public StateFlag.State getInvincibility(LocalPlayer player) { 106 | Player bukkitPlayer = BukkitAdapter.adapt(player); 107 | WrappedState state = handler.getInvincibility(bukkitPlayer); 108 | if (state == null) { 109 | return null; 110 | } 111 | return state == WrappedState.ALLOW ? StateFlag.State.ALLOW : StateFlag.State.DENY; 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/region/WrappedRegion.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.region; 2 | 3 | import com.sk89q.worldedit.bukkit.BukkitAdapter; 4 | import com.sk89q.worldedit.math.BlockVector2; 5 | import com.sk89q.worldguard.protection.flags.Flag; 6 | import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion; 7 | import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion; 8 | import com.sk89q.worldguard.protection.regions.ProtectedRegion; 9 | import lombok.AllArgsConstructor; 10 | import lombok.Getter; 11 | import org.bukkit.Location; 12 | import org.bukkit.World; 13 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 14 | import org.codemc.worldguardwrapper.implementation.v7.flag.AbstractWrappedFlag; 15 | import org.codemc.worldguardwrapper.implementation.v7.utility.WorldGuardFlagUtilities; 16 | import org.codemc.worldguardwrapper.region.IWrappedDomain; 17 | import org.codemc.worldguardwrapper.region.IWrappedRegion; 18 | import org.codemc.worldguardwrapper.selection.ICuboidSelection; 19 | import org.codemc.worldguardwrapper.selection.IPolygonalSelection; 20 | import org.codemc.worldguardwrapper.selection.ISelection; 21 | 22 | import java.util.*; 23 | import java.util.stream.Collectors; 24 | 25 | @AllArgsConstructor 26 | @Getter 27 | public class WrappedRegion implements IWrappedRegion { 28 | 29 | private final World world; 30 | private final ProtectedRegion handle; 31 | 32 | @Override 33 | public ISelection getSelection() { 34 | if (handle instanceof ProtectedCuboidRegion) { 35 | return new ICuboidSelection() { 36 | @Override 37 | public Location getMinimumPoint() { 38 | return BukkitAdapter.adapt(world, handle.getMinimumPoint()); 39 | } 40 | 41 | @Override 42 | public Location getMaximumPoint() { 43 | return BukkitAdapter.adapt(world, handle.getMaximumPoint()); 44 | } 45 | }; 46 | } else if (handle instanceof ProtectedPolygonalRegion) { 47 | return new IPolygonalSelection() { 48 | @Override 49 | public Set getPoints() { 50 | return handle.getPoints().stream() 51 | .map(BlockVector2::toBlockVector3) 52 | .map(vector -> BukkitAdapter.adapt(world, vector)) 53 | .collect(Collectors.toSet()); 54 | } 55 | 56 | @Override 57 | public int getMinimumY() { 58 | return handle.getMinimumPoint().getBlockY(); 59 | } 60 | 61 | @Override 62 | public int getMaximumY() { 63 | return handle.getMaximumPoint().getBlockY(); 64 | } 65 | }; 66 | } else { 67 | throw new UnsupportedOperationException("Unsupported " + handle.getClass().getSimpleName() + " region!"); 68 | } 69 | } 70 | 71 | @Override 72 | public String getId() { 73 | return handle.getId(); 74 | } 75 | 76 | @Override 77 | public Map, Object> getFlags() { 78 | Map, Object> result = new HashMap<>(); 79 | handle.getFlags().forEach((flag, value) -> { 80 | if (value != null) { 81 | try { 82 | Map.Entry, Object> wrapped = WorldGuardFlagUtilities.wrap(flag, value); 83 | result.put(wrapped.getKey(), wrapped.getValue()); 84 | } catch (IllegalArgumentException ignored) {/* Unsupported flag type */} 85 | } 86 | }); 87 | return result; 88 | } 89 | 90 | @SuppressWarnings("unchecked") 91 | @Override 92 | public Optional getFlag(IWrappedFlag flag) { 93 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 94 | return Optional.ofNullable(handle.getFlag(wrappedFlag.getHandle())) 95 | .map(value -> (T) wrappedFlag.fromWGValue(value)); 96 | } 97 | 98 | @SuppressWarnings("unchecked") 99 | @Override 100 | public void setFlag(IWrappedFlag flag, T value) { 101 | AbstractWrappedFlag wrappedFlag = (AbstractWrappedFlag) flag; 102 | handle.setFlag((Flag) wrappedFlag.getHandle(), wrappedFlag.fromWrapperValue(value).orElse(null)); 103 | } 104 | 105 | @Override 106 | public int getPriority() { 107 | return handle.getPriority(); 108 | } 109 | 110 | @Override 111 | public void setPriority(int priority) { 112 | handle.setPriority(priority); 113 | } 114 | 115 | @Override 116 | public IWrappedDomain getOwners() { 117 | return new IWrappedDomain() { 118 | @Override 119 | public Set getPlayers() { 120 | return handle.getOwners().getUniqueIds(); 121 | } 122 | 123 | @Override 124 | public void addPlayer(UUID uuid) { 125 | handle.getOwners().addPlayer(uuid); 126 | } 127 | 128 | @Override 129 | public void removePlayer(UUID uuid) { 130 | handle.getOwners().removePlayer(uuid); 131 | } 132 | 133 | @Override 134 | public Set getGroups() { 135 | return handle.getOwners().getGroups(); 136 | } 137 | 138 | @Override 139 | public void addGroup(String name) { 140 | handle.getOwners().addGroup(name); 141 | } 142 | 143 | @Override 144 | public void removeGroup(String name) { 145 | handle.getOwners().removeGroup(name); 146 | } 147 | }; 148 | } 149 | 150 | @Override 151 | public IWrappedDomain getMembers() { 152 | return new IWrappedDomain() { 153 | @Override 154 | public Set getPlayers() { 155 | return handle.getMembers().getUniqueIds(); 156 | } 157 | 158 | @Override 159 | public void addPlayer(UUID uuid) { 160 | handle.getMembers().addPlayer(uuid); 161 | } 162 | 163 | @Override 164 | public void removePlayer(UUID uuid) { 165 | handle.getMembers().removePlayer(uuid); 166 | } 167 | 168 | @Override 169 | public Set getGroups() { 170 | return handle.getMembers().getGroups(); 171 | } 172 | 173 | @Override 174 | public void addGroup(String name) { 175 | handle.getMembers().addGroup(name); 176 | } 177 | 178 | @Override 179 | public void removeGroup(String name) { 180 | handle.getMembers().removeGroup(name); 181 | } 182 | }; 183 | } 184 | 185 | @Override 186 | public boolean contains(Location location) { 187 | return handle.contains(BukkitAdapter.asBlockVector(location)); 188 | } 189 | 190 | } 191 | -------------------------------------------------------------------------------- /implementation/v7/src/main/java/org/codemc/worldguardwrapper/implementation/v7/utility/WorldGuardFlagUtilities.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper.implementation.v7.utility; 2 | 3 | import com.google.common.collect.Maps; 4 | import com.sk89q.worldedit.math.Vector3; 5 | import com.sk89q.worldguard.protection.flags.Flag; 6 | import com.sk89q.worldguard.protection.flags.StateFlag; 7 | import lombok.experimental.UtilityClass; 8 | import org.bukkit.Location; 9 | import org.bukkit.util.Vector; 10 | import org.codemc.worldguardwrapper.flag.IWrappedFlag; 11 | import org.codemc.worldguardwrapper.flag.WrappedState; 12 | import org.codemc.worldguardwrapper.implementation.v7.flag.AbstractWrappedFlag; 13 | import org.codemc.worldguardwrapper.implementation.v7.flag.WrappedPrimitiveFlag; 14 | import org.codemc.worldguardwrapper.implementation.v7.flag.WrappedStatusFlag; 15 | 16 | import java.util.Map; 17 | 18 | @UtilityClass 19 | public class WorldGuardFlagUtilities { 20 | 21 | // TODO: find a better way to define wrapper mappings and register mappings 22 | @SuppressWarnings({"unchecked", "rawtypes"}) 23 | public IWrappedFlag wrap(Flag flag, Class type) { 24 | final IWrappedFlag wrappedFlag; 25 | if (type.equals(WrappedState.class)) { 26 | wrappedFlag = (IWrappedFlag) new WrappedStatusFlag((Flag) flag); 27 | } else if (type.equals(Boolean.class) || type.equals(boolean.class)) { 28 | wrappedFlag = new WrappedPrimitiveFlag(flag); 29 | } else if (type.equals(Double.class) || type.equals(double.class)) { 30 | wrappedFlag = new WrappedPrimitiveFlag(flag); 31 | } else if (type.equals(Enum.class)) { 32 | wrappedFlag = new WrappedPrimitiveFlag(flag); 33 | } else if (type.equals(Integer.class) || type.equals(int.class)) { 34 | wrappedFlag = new WrappedPrimitiveFlag(flag); 35 | } else if (type.equals(Location.class)) { 36 | wrappedFlag = new WrappedPrimitiveFlag(flag); 37 | } else if (type.equals(String.class)) { 38 | wrappedFlag = new WrappedPrimitiveFlag(flag); 39 | } else if (type.equals(Vector.class)) { 40 | wrappedFlag = new WrappedPrimitiveFlag(flag); 41 | } else if (type.equals(Object.class)) { 42 | wrappedFlag = new WrappedPrimitiveFlag(flag); 43 | } else { 44 | throw new IllegalArgumentException("Unsupported flag type " + type.getName()); 45 | } 46 | return wrappedFlag; 47 | } 48 | 49 | // Used when the flag's type is not known, so it has to be derived from a sample value's class 50 | public IWrappedFlag wrapFixType(Flag flag, Class type) { 51 | if (StateFlag.State.class.isAssignableFrom(type)) { 52 | // StateFlag 53 | type = WrappedState.class; 54 | } else if (com.sk89q.worldedit.util.Location.class.isAssignableFrom(type)) { 55 | // LocationFlag 56 | type = org.bukkit.Location.class; 57 | } else if (Vector3.class.isAssignableFrom(type)) { 58 | // VectorFlag 59 | type = Vector.class; 60 | } 61 | 62 | return wrap(flag, type); 63 | } 64 | 65 | public Map.Entry, Object> wrap(Flag flag, Object value) { 66 | IWrappedFlag wrappedFlag = wrapFixType(flag, value.getClass()); 67 | //noinspection OptionalGetWithoutIsPresent 68 | Object wrappedValue = ((AbstractWrappedFlag) wrappedFlag).fromWGValue(value).get(); // value is non-null 69 | return Maps.immutableEntry(wrappedFlag, wrappedValue); 70 | } 71 | 72 | public Vector adaptVector(Vector3 vector) { 73 | return new Vector(vector.getX(), vector.getY(), vector.getZ()); 74 | } 75 | 76 | public Vector3 adaptVector(Vector vector) { 77 | return Vector3.at(vector.getX(), vector.getY(), vector.getZ()); 78 | } 79 | 80 | } -------------------------------------------------------------------------------- /library/pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | 8 | org.codemc.worldguardwrapper 9 | worldguardwrapper-parent 10 | 1.2.1-SNAPSHOT 11 | ../pom.xml 12 | 13 | 14 | worldguardwrapper 15 | 16 | WorldGuardWrapper-Library 17 | 18 | 19 | 20 | ${project.groupId} 21 | worldguardwrapper-api 22 | 1.2.1-SNAPSHOT 23 | true 24 | 25 | 26 | ${project.groupId} 27 | worldguardwrapper-implementation-legacy 28 | 1.2.1-SNAPSHOT 29 | true 30 | 31 | 32 | ${project.groupId} 33 | worldguardwrapper-implementation-v6 34 | 1.2.1-SNAPSHOT 35 | true 36 | 37 | 38 | ${project.groupId} 39 | worldguardwrapper-implementation-v7 40 | 1.2.1-SNAPSHOT 41 | true 42 | 43 | 44 | 45 | 46 | 47 | 48 | org.apache.maven.plugins 49 | maven-shade-plugin 50 | 51 | 52 | 53 | javassist 54 | org.codemc.worldguardwrapper.shaded.javassist 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | *:* 63 | 64 | META-INF/*.SF 65 | META-INF/*.DSA 66 | META-INF/*.RSA 67 | META-INF/*.RSA 68 | META-INF/*.MF 69 | META-INF/DEPENDENCIES 70 | META-INF/**/module-info.class 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | false 79 | 80 | 81 | 82 | 83 | 84 | 85 | package 86 | 87 | shade 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | -------------------------------------------------------------------------------- /library/src/main/java/org/codemc/worldguardwrapper/WorldGuardWrapper.java: -------------------------------------------------------------------------------- 1 | package org.codemc.worldguardwrapper; 2 | 3 | import lombok.experimental.Delegate; 4 | import org.bukkit.Bukkit; 5 | import org.bukkit.event.Listener; 6 | import org.bukkit.plugin.java.JavaPlugin; 7 | import org.codemc.worldguardwrapper.implementation.IWorldGuardImplementation; 8 | 9 | 10 | @SuppressWarnings("unused") 11 | public class WorldGuardWrapper implements IWorldGuardImplementation { 12 | 13 | private static WorldGuardWrapper instance; 14 | 15 | /** 16 | * Returns the wrapper singleton instance. 17 | * 18 | * @return the wrapper singleton 19 | */ 20 | public static WorldGuardWrapper getInstance() { 21 | if (instance == null) { 22 | instance = new WorldGuardWrapper(); 23 | } 24 | return instance; 25 | } 26 | 27 | @Delegate 28 | private final IWorldGuardImplementation implementation; 29 | private final Listener listener; 30 | 31 | private WorldGuardWrapper() { 32 | int targetVersion; 33 | try { 34 | Class.forName("com.sk89q.worldguard.WorldGuard"); 35 | targetVersion = 7; 36 | } catch (ClassNotFoundException e) { 37 | try { 38 | Class.forName("com.sk89q.worldguard.protection.flags.registry.FlagRegistry"); 39 | targetVersion = 6; 40 | } catch (ClassNotFoundException e1) { 41 | targetVersion = -6; 42 | } 43 | } 44 | if (targetVersion == 6) { 45 | implementation = new org.codemc.worldguardwrapper.implementation.v6.WorldGuardImplementation(); 46 | listener = new org.codemc.worldguardwrapper.implementation.v6.event.EventListener(); 47 | } else if (targetVersion == -6) { 48 | implementation = new org.codemc.worldguardwrapper.implementation.legacy.WorldGuardImplementation(); 49 | listener = new org.codemc.worldguardwrapper.implementation.legacy.event.EventListener(); 50 | } else { 51 | implementation = new org.codemc.worldguardwrapper.implementation.v7.WorldGuardImplementation(); 52 | listener = new org.codemc.worldguardwrapper.implementation.v7.event.EventListener(); 53 | } 54 | } 55 | 56 | /** 57 | * Forward WorldGuard event calls to wrapped events to allow listening to them 58 | * without having to use WorldGuard's events. This is optional. 59 | * 60 | * @param plugin the plugin instance 61 | */ 62 | public void registerEvents(JavaPlugin plugin) { 63 | Bukkit.getPluginManager().registerEvents(listener, plugin); 64 | } 65 | 66 | } 67 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | org.codemc.worldguardwrapper 8 | worldguardwrapper-parent 9 | 1.2.1-SNAPSHOT 10 | pom 11 | 12 | 13 | api 14 | library 15 | implementation 16 | 17 | 18 | WorldGuardWrapper-Parent 19 | A wrapper for the WorldGuard API that allows plugins to support both v6 and v7 APIs. 20 | https://github.com/CodeMC/WorldGuardWrapper 21 | 2018 22 | 23 | 24 | scm:git:https://github.com/CodeMC/WorldGuardWrapper.git 25 | scm:git:git@github.com:CodeMC/WorldGuardWrapper.git 26 | https://github.com/CodeMC/WorldGuardWrapper 27 | 28 | 29 | 30 | jenkins 31 | https://ci.codemc.io/job/CodeMC/job/WorldGuardWrapper/ 32 | 33 | 34 | 35 | GitHub 36 | https://github.com/CodeMC/WorldGuardWrapper/issues 37 | 38 | 39 | 40 | 41 | codemc-snapshots 42 | https://repo.codemc.org/repository/maven-snapshots/ 43 | 44 | 45 | codemc-releases 46 | https://repo.codemc.org/repository/maven-releases/ 47 | 48 | 49 | 50 | 51 | UTF-8 52 | UTF-8 53 | 1.20.1-R0.1-SNAPSHOT 54 | 55 | 56 | 57 | 58 | spigotmc-repo 59 | https://hub.spigotmc.org/nexus/content/groups/public/ 60 | 61 | 62 | 63 | 64 | 65 | 66 | org.spigotmc 67 | spigot-api 68 | ${spigot-api.version} 69 | provided 70 | 71 | 72 | com.googlecode.json-simple 73 | json-simple 74 | 75 | 76 | com.google.code.gson 77 | gson 78 | 79 | 80 | org.yaml 81 | snakeyaml 82 | 83 | 84 | net.md-5 85 | bungeecord-chat 86 | 87 | 88 | 89 | 90 | org.projectlombok 91 | lombok 92 | 1.18.28 93 | provided 94 | 95 | 96 | org.javassist 97 | javassist 98 | 3.29.2-GA 99 | true 100 | 101 | 102 | com.google.code.findbugs 103 | jsr305 104 | 3.0.2 105 | provided 106 | 107 | 108 | 109 | 110 | 111 | 112 | org.spigotmc 113 | spigot-api 114 | 115 | 116 | org.projectlombok 117 | lombok 118 | 119 | 120 | com.google.code.findbugs 121 | jsr305 122 | 123 | 124 | 125 | 126 | clean package 127 | 128 | 129 | src/main/resources 130 | true 131 | 132 | 133 | 134 | 135 | org.apache.maven.plugins 136 | maven-clean-plugin 137 | 3.3.1 138 | 139 | 140 | org.apache.maven.plugins 141 | maven-resources-plugin 142 | 3.3.1 143 | 144 | 145 | org.apache.maven.plugins 146 | maven-compiler-plugin 147 | 3.11.0 148 | 149 | 1.8 150 | 1.8 151 | 8 152 | 153 | 154 | 155 | org.apache.maven.plugins 156 | maven-surefire-plugin 157 | 3.1.2 158 | 159 | 160 | org.apache.maven.plugins 161 | maven-jar-plugin 162 | 3.3.0 163 | 164 | 165 | org.apache.maven.plugins 166 | maven-javadoc-plugin 167 | 3.5.0 168 | 169 | public 170 | false 171 | 172 | 173 | 174 | org.apache.maven.plugins 175 | maven-source-plugin 176 | 3.3.0 177 | 178 | 179 | org.apache.maven.plugins 180 | maven-shade-plugin 181 | 3.5.0 182 | 183 | false 184 | 185 | 186 | 187 | org.apache.maven.plugins 188 | maven-install-plugin 189 | 3.1.1 190 | 191 | 192 | org.apache.maven.plugins 193 | maven-deploy-plugin 194 | 3.1.1 195 | 196 | 197 | 198 | 199 | --------------------------------------------------------------------------------