mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-07-02 21:54:43 +02:00
Compare commits
1 Commits
renovate/n
...
fix/v6/fix
| Author | SHA1 | Date | |
|---|---|---|---|
| 504a4a9247 |
1
.github/ISSUE_TEMPLATE/bug_report.yml
vendored
1
.github/ISSUE_TEMPLATE/bug_report.yml
vendored
@ -27,7 +27,6 @@ body:
|
||||
description: Which server version version you using? If your server version is not listed, it is not supported. Update to a supported version first.
|
||||
multiple: false
|
||||
options:
|
||||
- '1.18.2'
|
||||
- '1.18.1'
|
||||
- '1.18'
|
||||
- '1.17.1'
|
||||
|
||||
6
.github/workflows/build.yml
vendored
6
.github/workflows/build.yml
vendored
@ -8,11 +8,11 @@ jobs:
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout Repository
|
||||
uses: actions/checkout@v3
|
||||
uses: actions/checkout@v2.4.0
|
||||
- name: Validate Gradle Wrapper"
|
||||
uses: gradle/wrapper-validation-action@v1
|
||||
uses: gradle/wrapper-validation-action@v1.0.4
|
||||
- name: Setup Java
|
||||
uses: actions/setup-java@v3
|
||||
uses: actions/setup-java@v2.5.0
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
|
||||
37
.github/workflows/codeql.yml
vendored
37
.github/workflows/codeql.yml
vendored
@ -1,37 +0,0 @@
|
||||
name: "CodeQL"
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ v6 ]
|
||||
pull_request:
|
||||
# The branches below must be a subset of the branches above
|
||||
branches: [ v6 ]
|
||||
|
||||
jobs:
|
||||
analyze:
|
||||
name: Analyze
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
actions: read
|
||||
contents: read
|
||||
security-events: write
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: [ 'java' ]
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v3
|
||||
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v2
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v2
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v2
|
||||
20
.github/workflows/rebase.yml
vendored
Normal file
20
.github/workflows/rebase.yml
vendored
Normal file
@ -0,0 +1,20 @@
|
||||
name: Rebase Pull Request
|
||||
on:
|
||||
issue_comment:
|
||||
types: [created]
|
||||
|
||||
jobs:
|
||||
rebase:
|
||||
name: Rebase
|
||||
if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/rebase') && github.event.comment.author_association == 'MEMBER'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout Repository
|
||||
uses: actions/checkout@v2.4.0
|
||||
with:
|
||||
token: ${{ secrets.REBASE_TOKEN }}
|
||||
fetch-depth: 0
|
||||
- name: Automatic Rebase
|
||||
uses: cirrus-actions/rebase@1.5
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.REBASE_TOKEN }}
|
||||
2
.github/workflows/release-drafter.yml
vendored
2
.github/workflows/release-drafter.yml
vendored
@ -14,6 +14,6 @@ jobs:
|
||||
if: ${{ github.event_name != 'pull_request' || github.repository != github.event.pull_request.head.repo.full_name }}
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: release-drafter/release-drafter@v5.19.0
|
||||
- uses: release-drafter/release-drafter@v5.17.6
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
6
.gitignore
vendored
6
.gitignore
vendored
@ -41,8 +41,7 @@ hs_err_pid*
|
||||
*.iml
|
||||
|
||||
## Directory-based project format:
|
||||
/.idea/*
|
||||
!/.idea/icon.svg
|
||||
.idea/
|
||||
# if you remove the above rule, at least ignore the following:
|
||||
|
||||
# User-specific stuff:
|
||||
@ -75,6 +74,9 @@ hs_err_pid*
|
||||
# IntelliJ
|
||||
/out/
|
||||
|
||||
# mpeltonen/sbt-idea plugin
|
||||
.idea_modules/
|
||||
|
||||
# JIRA plugin
|
||||
atlassian-ide-plugin.xml
|
||||
|
||||
|
||||
49
.idea/icon.svg
generated
49
.idea/icon.svg
generated
@ -1,49 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
|
||||
<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4000 3333.3333" height="3333.3333" width="4000" xml:space="preserve" id="svg2" version="1.1">
|
||||
<metadata id="metadata8">
|
||||
<rdf:RDF>
|
||||
<cc:Work rdf:about="">
|
||||
<dc:format>image/svg+xml</dc:format>
|
||||
<dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
|
||||
</cc:Work>
|
||||
</rdf:RDF>
|
||||
</metadata>
|
||||
<defs id="defs6">
|
||||
<clipPath id="clipPath18" clipPathUnits="userSpaceOnUse">
|
||||
<path id="path16" d="M 0,2500 H 3000 V 0 H 0 Z" />
|
||||
</clipPath>
|
||||
</defs>
|
||||
<g transform="matrix(1.3333333,0,0,-1.3333333,0,3333.3333)" id="g10">
|
||||
<g id="g12">
|
||||
<g clip-path="url(#clipPath18)" id="g14">
|
||||
<g transform="translate(1486.1511,2242.6453)" id="g20">
|
||||
<path id="path22" style="fill:#2b3f56;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 16.533,10.846 33.211,21.453 50.104,31.699 78.972,-48.281 153.985,-102.704 227.269,-159.144 148.61,-115.422 287.884,-243.01 414.393,-382.333 111.39,-122.861 212.751,-255.152 298.898,-396.971 52.744,-87.322 100.544,-177.884 139.514,-272.214 -11.638,-3.551 -23.108,-7.655 -34.362,-12.286 l -0.24,0.288 c -11.135,12.982 -24.141,24.212 -34.915,37.506 -22.557,23.013 -45.425,45.737 -68.03,68.678 -19.725,20.253 -40.601,39.45 -58.958,60.974 -36.355,36.451 -72.517,73.093 -108.944,109.471 -22.628,26.013 -48.064,49.385 -71.965,74.197 -19.029,19.485 -38.706,38.346 -57.519,57.999 -12.166,14.998 -26.684,27.716 -39.93,41.658 -27.668,27.524 -54.903,55.479 -82.571,82.979 -23.924,27.956 -51.664,52.264 -76.692,79.164 -4.68,4.487 -8.855,10.774 -15.886,11.326 -22.34,34.027 -58.311,57.327 -97.377,67.502 -104.312,99.153 -215.487,191.202 -332.661,274.782 -117.942,-83.94 -229.476,-176.781 -334.484,-276.39 -26.684,-0.024 -53.368,0.024 -80.076,-0.024 0.024,-26.564 0.048,-53.104 0,-79.668 -72.229,-73.021 -139.491,-150.937 -202.385,-232.092 -63.758,-82.619 -121.973,-169.51 -173.541,-260.264 131.932,-69.061 257.864,-149.521 375.926,-240.275 0.096,-26.444 -0.12,-52.888 0.096,-79.332 l 0.744,-0.984 c 20.109,-24.14 43.409,-45.233 65.126,-67.861 15.118,-15.382 30.571,-30.404 45.569,-45.881 17.565,-20.733 37.698,-39.042 56.607,-58.503 19.917,-20.781 41.25,-40.218 59.967,-62.151 29.156,-29.299 58.167,-58.815 87.515,-87.922 29.155,-33.043 61.502,-63.111 92.169,-94.738 13.726,-12.67 25.124,-27.571 38.634,-40.457 25.029,-25.365 50.129,-50.657 75.325,-75.853 -37.914,-51.208 -73.741,-103.952 -107.192,-158.183 -167.83,273.317 -397.235,507.305 -662.37,687.158 -81.875,55.335 -167.23,105.584 -255.681,149.641 -52.815,26.276 -106.831,50.248 -162.239,70.381 99.393,233.628 242.795,446.715 410.289,636.79 93.562,106.088 194.634,205.433 301.466,298.13 C -217.335,-155.808 -111.439,-73.789 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1201.7948,1741.5303)" id="g24">
|
||||
<path id="path26" style="fill:#5693ce;fill-opacity:1;fill-rule:nonzero;stroke:none" d="M 0,0 C 105.008,99.609 216.543,192.45 334.485,276.39 451.659,192.81 562.833,100.76 667.146,1.608 c -34.987,8.83 -71.51,9.718 -107.264,6.431 -41.202,-4.296 -82.907,-19.077 -112.543,-48.953 -33.019,-32.155 -49.456,-77.604 -55.311,-122.501 -28.124,27.908 -56.104,55.983 -84.035,84.083 -2.976,2.976 -6.839,4.823 -10.391,6.911 -19.029,26.348 -45.953,46.673 -76.62,57.495 C 187.555,-2.472 151.513,-0.12 116.166,0 Z" />
|
||||
</g>
|
||||
<g transform="translate(919.3342,1429.7462)" id="g28">
|
||||
<path id="path30" style="fill:#5693ce;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 62.894,81.156 130.156,159.072 202.385,232.092 0.048,-244.21 0.024,-488.421 0,-732.631 C 84.323,-409.785 -41.61,-329.325 -173.541,-260.264 -121.973,-169.51 -63.758,-82.619 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1649.134,1700.6166)" id="g32">
|
||||
<path id="path34" style="fill:#feeeef;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 29.635,29.875 71.341,44.657 112.543,48.952 35.754,3.288 72.277,2.4 107.263,-6.431 39.066,-10.174 75.037,-33.474 97.377,-67.501 11.879,-17.661 20.181,-37.411 26.42,-57.687 10.871,-38.802 11.95,-79.356 11.446,-119.358 -44.345,-0.072 -88.69,0.048 -133.035,-0.072 -1.032,30.907 3.263,63.686 -10.175,92.626 -9.526,20.325 -32.107,31.243 -53.751,32.131 -21.453,1.44 -45.065,-4.32 -59.175,-21.597 -12.79,-15.861 -15.382,-37.002 -16.558,-56.655 -1.295,-29.132 3.696,-59.031 17.518,-84.923 16.821,-30.619 39.378,-57.783 64.526,-81.9 31.387,-32.634 67.501,-60.374 97.857,-94.041 27.332,-28.988 51.256,-61.479 68.005,-97.785 20.541,-41.13 26.972,-87.827 25.82,-133.372 -0.912,-32.107 -5.231,-64.406 -16.149,-94.737 -11.59,-31.699 -31.123,-61.047 -58.335,-81.371 -25.124,-19.125 -55.696,-29.852 -86.651,-34.771 -49.552,-6.743 -101.888,-4.847 -148.465,14.854 -35.227,14.829 -64.238,42.689 -81.708,76.548 -20.996,40.242 -27.115,86.339 -27.259,131.212 0.048,17.829 0,35.658 0.048,53.463 44.345,0.048 88.69,-0.023 133.059,0.048 1.728,-35.538 -4.055,-72.06 5.663,-106.807 5.783,-22.173 26.204,-37.794 48.185,-41.754 20.733,-3.431 43.577,-2.015 61.622,9.791 15.502,9.43 23.949,26.78 26.78,44.225 5.903,35.922 1.872,74.293 -15.381,106.688 -16.918,30.595 -39.474,57.711 -64.55,81.899 -33.187,34.099 -71.173,63.254 -102.585,99.081 -26.756,28.867 -49.408,61.646 -65.486,97.641 -24.572,52.48 -26.731,112.422 -20.18,169.102 C -49.456,-77.604 -33.019,-32.155 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1262.7214,1613.126)" id="g36">
|
||||
<path id="path38" style="fill:#feeeef;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 v -301.13 c 23.204,0.024 46.409,-0.048 69.613,0.024 18.525,0.288 38.202,6.575 50.153,21.429 12.43,17.277 13.917,39.522 14.613,60.111 0.024,43.985 -0.048,87.994 0.024,131.979 -0.48,23.637 -0.983,50.369 -17.277,69.23 C 104.864,-5.711 86.867,-0.24 69.589,0 46.385,0.048 23.204,0.024 0,0 m -141.002,128.38 c 26.708,0.048 53.392,0 80.075,0.024 H 55.24 c 35.346,-0.12 71.389,-2.471 104.815,-14.925 30.668,-10.823 57.592,-31.148 76.621,-57.496 26.852,-39.09 36.69,-87.202 38.058,-133.947 0.024,-48.833 0.096,-97.689 -0.024,-146.521 -1.728,-47.993 -11.974,-97.953 -41.514,-136.971 -22.748,-30.644 -57.495,-50.801 -94.281,-59.583 -45.377,-11.878 -92.578,-6.791 -138.891,-7.847 -0.072,-111.799 0,-223.574 -0.024,-335.373 -13.942,0 -27.86,0.024 -41.778,-0.024 -32.802,0.072 -65.605,0 -98.384,0.048 l -0.744,0.984 c -0.216,26.444 0,52.888 -0.096,79.332 0.024,244.211 0.048,488.421 0,732.632 0.048,26.563 0.024,53.103 0,79.667" />
|
||||
</g>
|
||||
<g transform="translate(1966.3174,1675.6364)" id="g40">
|
||||
<path id="path42" style="fill:#2a3746;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 7.031,-0.552 11.206,-6.839 15.885,-11.326 25.029,-26.9 52.768,-51.208 76.693,-79.164 27.667,-27.5 54.903,-55.456 82.571,-82.979 13.246,-13.942 27.764,-26.66 39.93,-41.658 18.813,-19.653 38.49,-38.514 57.519,-57.999 23.9,-24.812 49.337,-48.185 71.965,-74.197 36.427,-36.378 72.589,-73.02 108.943,-109.471 18.358,-21.524 39.234,-40.722 58.959,-60.974 22.605,-22.941 45.473,-45.665 68.03,-68.678 10.774,-13.294 23.78,-24.524 34.914,-37.506 -103.904,-41.97 -203.488,-94.114 -298.922,-152.761 -246.994,-152.28 -466.224,-350.298 -639.333,-583.398 -25.197,25.196 -50.297,50.488 -75.325,75.852 -13.51,12.886 -24.908,27.788 -38.634,40.458 -30.667,31.627 -63.014,61.695 -92.17,94.738 -29.347,29.107 -58.359,58.623 -87.514,87.922 -18.717,21.933 -40.05,41.37 -59.967,62.151 -18.909,19.461 -39.042,37.77 -56.607,58.503 -14.998,15.477 -30.452,30.499 -45.569,45.88 -21.717,22.629 -45.017,43.722 -65.126,67.862 32.779,-0.048 65.582,0.024 98.384,-0.048 114.391,-98.097 220.407,-205.984 315.384,-322.99 92.914,114.318 196.242,220.022 307.753,316.271 30.955,4.919 61.526,15.646 86.65,34.771 27.212,20.325 46.745,49.672 58.335,81.371 107.312,77.988 219.327,149.929 337.509,210.376 -35.299,64.67 -75.829,126.437 -118.254,186.643 C 176.253,-228.037 104.24,-140.115 26.42,-57.687 20.181,-37.41 11.878,-17.661 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1499.3971,1669.1094)" id="g44">
|
||||
<path id="path46" style="fill:#3378bc;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 3.551,-2.088 7.415,-3.935 10.39,-6.911 27.932,-28.1 55.912,-56.175 84.036,-84.083 -6.551,-56.679 -4.392,-116.622 20.18,-169.102 16.078,-35.994 38.73,-68.774 65.486,-97.641 31.412,-35.826 69.398,-64.982 102.585,-99.081 25.076,-24.188 47.632,-51.304 64.55,-81.899 17.253,-32.395 21.284,-70.765 15.381,-106.688 -2.831,-17.445 -11.278,-34.794 -26.78,-44.225 -18.045,-11.806 -40.889,-13.222 -61.622,-9.79 -21.981,3.959 -42.402,19.58 -48.185,41.753 -9.718,34.747 -3.935,71.269 -5.663,106.808 -44.369,-0.072 -88.714,0 -133.059,-0.048 -0.048,-17.806 0,-35.635 -0.048,-53.464 0.144,-44.873 6.263,-90.97 27.259,-131.212 17.47,-33.859 46.481,-61.718 81.708,-76.548 46.577,-19.701 98.913,-21.597 148.465,-14.854 -111.511,-96.249 -214.839,-201.953 -307.753,-316.271 -94.977,117.006 -200.993,224.893 -315.383,322.99 13.918,0.048 27.836,0.024 41.777,0.024 0.024,111.799 -0.048,223.574 0.024,335.372 46.313,1.056 93.514,-4.031 138.891,7.847 36.786,8.783 71.533,28.94 94.282,59.583 29.539,39.018 39.785,88.978 41.513,136.971 0.12,48.833 0.048,97.689 0.024,146.522 C 36.69,-87.203 26.852,-39.09 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1748.0469,1601.6797)" id="g48">
|
||||
<path id="path50" style="fill:#3378bc;fill-opacity:1;fill-rule:nonzero;stroke:none" d="M 0,0 C 14.11,17.277 37.722,23.036 59.175,21.597 80.82,20.709 103.4,9.791 112.927,-10.534 c 13.438,-28.94 9.142,-61.719 10.174,-92.626 44.345,0.12 88.691,0 133.036,0.072 0.504,40.002 -0.576,80.556 -11.447,119.358 77.82,-82.428 149.833,-170.35 215.583,-262.664 42.426,-60.207 82.956,-121.973 118.254,-186.643 -118.182,-60.447 -230.196,-132.388 -337.508,-210.376 10.918,30.331 15.238,62.63 16.149,94.737 1.152,45.545 -5.279,92.242 -25.82,133.372 -16.749,36.306 -40.673,68.797 -68.005,97.785 -30.355,33.667 -66.47,61.406 -97.857,94.041 -25.148,24.117 -47.705,51.28 -64.526,81.9 -13.822,25.892 -18.813,55.791 -17.517,84.923 C -15.382,-37.002 -12.79,-15.862 0,0" />
|
||||
</g>
|
||||
<g transform="translate(1262.7214,1613.126)" id="g52">
|
||||
<path id="path54" style="fill:#3378bc;fill-opacity:1;fill-rule:nonzero;stroke:none" d="m 0,0 c 23.204,0.024 46.385,0.048 69.589,0 17.278,-0.24 35.275,-5.711 47.537,-18.357 16.294,-18.861 16.797,-45.593 17.277,-69.23 -0.072,-43.985 0,-87.994 -0.024,-131.979 -0.696,-20.589 -2.183,-42.834 -14.613,-60.111 -11.951,-14.854 -31.628,-21.141 -50.153,-21.429 -23.204,-0.072 -46.409,0 -69.613,-0.024 z" />
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 10 KiB |
@ -83,7 +83,7 @@ tasks.named<ShadowJar>("shadowJar") {
|
||||
relocate("org.jetbrains", "com.plotsquared.core.annotations")
|
||||
relocate("org.intellij.lang", "com.plotsquared.core.intellij.annotations")
|
||||
relocate("javax.annotation", "com.plotsquared.core.annotation")
|
||||
relocate("com.github.spotbugs", "com.plotsquared.core.spotbugs")
|
||||
relocate("com.google.code.findbugs", "com.plotsquared.core.findbugs")
|
||||
relocate("javax.inject", "com.plotsquared.core.annotation.inject")
|
||||
|
||||
// Get rid of all the libs which are 100% unused.
|
||||
|
||||
@ -238,16 +238,6 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
|
||||
return this.version;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int versionMinHeight() {
|
||||
return serverVersion()[1] >= 18 ? -64 : 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int versionMaxHeight() {
|
||||
return serverVersion()[1] >= 18 ? 319 : 255;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull String serverImplementation() {
|
||||
return Bukkit.getVersion();
|
||||
|
||||
@ -65,10 +65,7 @@ final class BlockStatePopulator extends BlockPopulator {
|
||||
return;
|
||||
}
|
||||
final ChunkWrapper wrap = new ChunkWrapper(area.getWorldName(), source.getX(), source.getZ());
|
||||
final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z,
|
||||
com.plotsquared.bukkit.util.BukkitWorld.getMinWorldHeight(world),
|
||||
com.plotsquared.bukkit.util.BukkitWorld.getMaxWorldHeight(world) - 1
|
||||
);
|
||||
final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z);
|
||||
if (this.plotGenerator.populateChunk(chunk, area)) {
|
||||
this.queue.enqueue();
|
||||
}
|
||||
|
||||
@ -27,7 +27,6 @@ package com.plotsquared.bukkit.generator;
|
||||
|
||||
import com.plotsquared.bukkit.queue.GenChunk;
|
||||
import com.plotsquared.bukkit.util.BukkitUtil;
|
||||
import com.plotsquared.bukkit.util.BukkitWorld;
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.plotsquared.core.generator.GeneratorWrapper;
|
||||
import com.plotsquared.core.generator.IndependentPlotGenerator;
|
||||
@ -160,14 +159,12 @@ public class BukkitPlotGenerator extends ChunkGenerator
|
||||
@NonNull BiomeGrid biome
|
||||
) {
|
||||
|
||||
int minY = BukkitWorld.getMinWorldHeight(world);
|
||||
int maxY = BukkitWorld.getMaxWorldHeight(world);
|
||||
GenChunk result = new GenChunk(minY, maxY);
|
||||
GenChunk result = new GenChunk();
|
||||
if (this.getPlotGenerator() instanceof SingleWorldGenerator) {
|
||||
if (result.getChunkData() != null) {
|
||||
for (int chunkX = 0; chunkX < 16; chunkX++) {
|
||||
for (int chunkZ = 0; chunkZ < 16; chunkZ++) {
|
||||
for (int y = minY; y < maxY; y++) {
|
||||
for (int y = 0; y < world.getMaxHeight(); y++) {
|
||||
biome.setBiome(chunkX, y, chunkZ, Biome.PLAINS);
|
||||
|
||||
}
|
||||
|
||||
@ -74,7 +74,6 @@ import org.bukkit.GameMode;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.block.BlockState;
|
||||
import org.bukkit.block.data.BlockData;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Fireball;
|
||||
@ -93,7 +92,6 @@ import org.bukkit.event.block.BlockFormEvent;
|
||||
import org.bukkit.event.block.BlockFromToEvent;
|
||||
import org.bukkit.event.block.BlockGrowEvent;
|
||||
import org.bukkit.event.block.BlockIgniteEvent;
|
||||
import org.bukkit.event.block.BlockMultiPlaceEvent;
|
||||
import org.bukkit.event.block.BlockPhysicsEvent;
|
||||
import org.bukkit.event.block.BlockPistonExtendEvent;
|
||||
import org.bukkit.event.block.BlockPistonRetractEvent;
|
||||
@ -279,7 +277,7 @@ public class BlockEventListener implements Listener {
|
||||
BukkitPlayer pp = BukkitUtil.adapt(player);
|
||||
Plot plot = area.getPlot(location);
|
||||
if (plot != null) {
|
||||
if ((location.getY() >= area.getMaxBuildHeight() || location.getY() < area
|
||||
if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
|
||||
.getMinBuildHeight()) && !Permissions
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
event.setCancelled(true);
|
||||
@ -354,8 +352,7 @@ public class BlockEventListener implements Listener {
|
||||
Plot plot = area.getPlot(location);
|
||||
if (plot != null) {
|
||||
BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
|
||||
// == rather than <= as we only care about the "ground level" not being destroyed
|
||||
if (event.getBlock().getY() == area.getMinGenHeight()) {
|
||||
if (event.getBlock().getY() == 0) {
|
||||
if (!Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL)) {
|
||||
plotPlayer.sendMessage(
|
||||
@ -365,7 +362,7 @@ public class BlockEventListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
} else if ((location.getY() >= area.getMaxBuildHeight() || location.getY() < area
|
||||
} else if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
|
||||
.getMinBuildHeight()) && !Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
event.setCancelled(true);
|
||||
@ -650,8 +647,7 @@ public class BlockEventListener implements Listener {
|
||||
event.getBlock().breakNaturally();
|
||||
}
|
||||
}
|
||||
// == rather than <= as we only care about the "ground level" not being destroyed
|
||||
if (location.getY() == area.getMinGenHeight()) {
|
||||
if (location.getY() == 0) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
@ -1212,51 +1208,4 @@ public class BlockEventListener implements Listener {
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* BlockMultiPlaceEvent is called unrelated to the BlockPlaceEvent itself and therefore doesn't respect the cancellation.
|
||||
*/
|
||||
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
|
||||
public void onBlockMultiPlace(BlockMultiPlaceEvent event) {
|
||||
// Check if the generic block place event would be cancelled
|
||||
blockCreate(event);
|
||||
if (event.isCancelled()) {
|
||||
return;
|
||||
}
|
||||
|
||||
BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
|
||||
Location placedLocation = BukkitUtil.adapt(event.getBlockReplacedState().getLocation());
|
||||
PlotArea area = placedLocation.getPlotArea();
|
||||
if (area == null) {
|
||||
return;
|
||||
}
|
||||
Plot plot = placedLocation.getPlot();
|
||||
|
||||
for (final BlockState state : event.getReplacedBlockStates()) {
|
||||
Location currentLocation = BukkitUtil.adapt(state.getLocation());
|
||||
if (!Permissions.hasPermission(
|
||||
pp,
|
||||
Permission.PERMISSION_ADMIN_BUILD_ROAD
|
||||
) && !(Objects.equals(currentLocation.getPlot(), plot))) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_BUILD_ROAD))
|
||||
);
|
||||
event.setCancelled(true);
|
||||
break;
|
||||
}
|
||||
if (Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
continue;
|
||||
}
|
||||
if (currentLocation.getY() >= area.getMaxBuildHeight() || currentLocation.getY() < area.getMinBuildHeight()) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("height.height_limit"),
|
||||
Template.of("minHeight", String.valueOf(area.getMinBuildHeight())),
|
||||
Template.of("maxHeight", String.valueOf(area.getMaxBuildHeight()))
|
||||
);
|
||||
event.setCancelled(true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -36,7 +36,6 @@ import com.plotsquared.core.plot.flag.implementations.DoneFlag;
|
||||
import io.papermc.lib.PaperLib;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.entity.ArmorStand;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
@ -192,32 +191,8 @@ public class EntitySpawnListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onTeleport(EntityTeleportEvent event) {
|
||||
Entity entity = event.getEntity();
|
||||
Entity fromLocation = event.getEntity();
|
||||
Block toLocation = event.getTo().getBlock();
|
||||
final Location fromLocLocation = BukkitUtil.adapt(fromLocation.getLocation());
|
||||
final PlotArea fromArea = fromLocLocation.getPlotArea();
|
||||
Location toLocLocation = BukkitUtil.adapt(toLocation.getLocation());
|
||||
PlotArea toArea = toLocLocation.getPlotArea();
|
||||
|
||||
if (toArea == null) {
|
||||
if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
Plot toPlot = toArea.getOwnedPlot(toLocLocation);
|
||||
if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocLocation);
|
||||
|
||||
if (fromPlot != null || toPlot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(toPlot)) && (toPlot == null || !toPlot.equals(fromPlot))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (entity instanceof Vehicle || entity instanceof ArmorStand) {
|
||||
Entity ent = event.getEntity();
|
||||
if (ent instanceof Vehicle || ent instanceof ArmorStand) {
|
||||
testNether(event.getEntity());
|
||||
}
|
||||
}
|
||||
|
||||
@ -44,7 +44,6 @@ import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.flag.implementations.DoneFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.ProjectilesFlag;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
@ -353,15 +352,13 @@ public class PaperListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!plot.isAdded(pp.getUUID())) {
|
||||
if (!plot.getFlag(ProjectilesFlag.class)) {
|
||||
if (!Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER))
|
||||
);
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
}
|
||||
if (!Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER))
|
||||
);
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -76,6 +76,7 @@ import com.plotsquared.core.util.EventDispatcher;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import com.plotsquared.core.util.PremiumVerification;
|
||||
import com.plotsquared.core.util.RegExUtil;
|
||||
import com.plotsquared.core.util.entity.EntityCategories;
|
||||
import com.plotsquared.core.util.task.TaskManager;
|
||||
import com.plotsquared.core.util.task.TaskTime;
|
||||
@ -222,9 +223,10 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("StringSplitter")
|
||||
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
|
||||
public void playerCommand(PlayerCommandPreprocessEvent event) {
|
||||
String msg = event.getMessage().replace("/", "").toLowerCase(Locale.ROOT).trim();
|
||||
String msg = event.getMessage().toLowerCase().replaceAll("/", "").trim();
|
||||
if (msg.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
@ -238,9 +240,11 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
String[] parts = msg.split(" ");
|
||||
Plot plot = plotPlayer.getCurrentPlot();
|
||||
// Check WorldEdit
|
||||
switch (parts[0]) {
|
||||
switch (parts[0].toLowerCase()) {
|
||||
case "up":
|
||||
case "/up":
|
||||
case "worldedit:up":
|
||||
case "worldedit:/up":
|
||||
if (plot == null || (!plot.isAdded(plotPlayer.getUUID()) && !Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_BUILD_OTHER, true))) {
|
||||
event.setCancelled(true);
|
||||
@ -254,67 +258,63 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
List<String> blockedCommands = plot != null ?
|
||||
plot.getFlag(BlockedCmdsFlag.class) :
|
||||
area.getFlag(BlockedCmdsFlag.class);
|
||||
if (blockedCommands.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
if (Permissions.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_INTERACT_BLOCKED_CMDS)) {
|
||||
return;
|
||||
}
|
||||
// When using namespaced commands, we're not interested in the namespace
|
||||
String part = parts[0];
|
||||
if (part.contains(":")) {
|
||||
String[] namespaced = part.split(":");
|
||||
part = namespaced[1];
|
||||
msg = msg.substring(namespaced[0].length() + 1);
|
||||
}
|
||||
msg = replaceAliases(msg, part);
|
||||
for (String blocked : blockedCommands) {
|
||||
if (blocked.equalsIgnoreCase(msg)) {
|
||||
String perm;
|
||||
if (plot != null && plot.isAdded(plotPlayer.getUUID())) {
|
||||
perm = "plots.admin.command.blocked-cmds.shared";
|
||||
if (!blockedCommands.isEmpty() && !Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_INTERACT_BLOCKED_CMDS)) {
|
||||
String part = parts[0];
|
||||
if (parts[0].contains(":")) {
|
||||
part = parts[0].split(":")[1];
|
||||
msg = msg.replace(parts[0].split(":")[0] + ':', "");
|
||||
}
|
||||
String s1 = part;
|
||||
List<String> aliases = new ArrayList<>();
|
||||
for (HelpTopic cmdLabel : Bukkit.getServer().getHelpMap().getHelpTopics()) {
|
||||
if (part.equals(cmdLabel.getName())) {
|
||||
break;
|
||||
}
|
||||
String label = cmdLabel.getName().replaceFirst("/", "");
|
||||
if (aliases.contains(label)) {
|
||||
continue;
|
||||
}
|
||||
PluginCommand p;
|
||||
if ((p = Bukkit.getPluginCommand(label)) != null) {
|
||||
for (String a : p.getAliases()) {
|
||||
if (aliases.contains(a)) {
|
||||
continue;
|
||||
}
|
||||
aliases.add(a);
|
||||
a = a.replaceFirst("/", "");
|
||||
if (!a.equals(label) && a.equals(part)) {
|
||||
part = label;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!s1.equals(part)) {
|
||||
msg = msg.replace(s1, part);
|
||||
}
|
||||
for (String s : blockedCommands) {
|
||||
Pattern pattern;
|
||||
if (!RegExUtil.compiledPatterns.containsKey(s)) {
|
||||
RegExUtil.compiledPatterns.put(s, pattern = Pattern.compile(s));
|
||||
} else {
|
||||
perm = "plots.admin.command.blocked-cmds.road";
|
||||
pattern = RegExUtil.compiledPatterns.get(s);
|
||||
}
|
||||
if (!Permissions.hasPermission(plotPlayer, perm)) {
|
||||
plotPlayer.sendMessage(TranslatableCaption.of("blockedcmds.command_blocked"));
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private String replaceAliases(String msg, String part) {
|
||||
String s1 = part;
|
||||
Set<String> aliases = new HashSet<>();
|
||||
for (HelpTopic cmdLabel : Bukkit.getServer().getHelpMap().getHelpTopics()) {
|
||||
if (part.equals(cmdLabel.getName())) {
|
||||
break;
|
||||
}
|
||||
String label = cmdLabel.getName().replaceFirst("/", "");
|
||||
if (aliases.contains(label)) {
|
||||
continue;
|
||||
}
|
||||
PluginCommand p = Bukkit.getPluginCommand(label);
|
||||
if (p != null) {
|
||||
for (String a : p.getAliases()) {
|
||||
if (aliases.contains(a)) {
|
||||
continue;
|
||||
if (pattern.matcher(msg).matches()) {
|
||||
String perm;
|
||||
if (plot != null && plot.isAdded(plotPlayer.getUUID())) {
|
||||
perm = "plots.admin.command.blocked-cmds.shared";
|
||||
} else {
|
||||
perm = "plots.admin.command.blocked-cmds.road";
|
||||
}
|
||||
aliases.add(a);
|
||||
a = a.replaceFirst("/", "");
|
||||
if (!a.equals(label) && a.equals(part)) {
|
||||
part = label;
|
||||
break;
|
||||
if (!Permissions.hasPermission(plotPlayer, perm)) {
|
||||
plotPlayer.sendMessage(TranslatableCaption.of("blockedcmds.command_blocked"));
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!s1.equals(part)) {
|
||||
msg = msg.replace(s1, part);
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
|
||||
|
||||
@ -35,7 +35,6 @@ import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.PlotHandler;
|
||||
import com.plotsquared.core.plot.flag.implementations.ProjectilesFlag;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
@ -129,15 +128,13 @@ public class ProjectileEventListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!plot.isAdded(pp.getUUID())) {
|
||||
if (!plot.getFlag(ProjectilesFlag.class)) {
|
||||
if (!Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER))
|
||||
);
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
}
|
||||
if (!Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_PROJECTILE_OTHER))
|
||||
);
|
||||
entity.remove();
|
||||
event.setCancelled(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -165,7 +162,7 @@ public class ProjectileEventListener implements Listener {
|
||||
return;
|
||||
}
|
||||
if (plot.isAdded(pp.getUUID()) || Permissions
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER) || plot.getFlag(ProjectilesFlag.class)) {
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
return;
|
||||
}
|
||||
entity.remove();
|
||||
|
||||
@ -46,7 +46,7 @@ import static com.plotsquared.core.util.ReflectionUtils.getRefClass;
|
||||
public class SingleWorldListener implements Listener {
|
||||
|
||||
private final Method methodGetHandleChunk;
|
||||
private Field shouldSave = null;
|
||||
private Field shouldSave;
|
||||
|
||||
public SingleWorldListener() throws Exception {
|
||||
ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
|
||||
@ -59,12 +59,9 @@ public class SingleWorldListener implements Listener {
|
||||
} else {
|
||||
this.shouldSave = classChunk.getField("s").getRealField();
|
||||
}
|
||||
} else if (PlotSquared.platform().serverVersion()[1] == 17) {
|
||||
} else {
|
||||
ReflectionUtils.RefClass classChunk = getRefClass("net.minecraft.world.level.chunk.Chunk");
|
||||
this.shouldSave = classChunk.getField("r").getRealField();
|
||||
} else if (PlotSquared.platform().serverVersion()[1] == 18) {
|
||||
ReflectionUtils.RefClass classChunk = getRefClass("net.minecraft.world.level.chunk.IChunkAccess");
|
||||
this.shouldSave = classChunk.getField("b").getRealField();
|
||||
}
|
||||
} catch (NoSuchFieldException e) {
|
||||
e.printStackTrace();
|
||||
|
||||
@ -74,9 +74,8 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
private final Consumer<Throwable> throwableConsumer;
|
||||
private final boolean unloadAfter;
|
||||
private final int totalSize;
|
||||
private final AtomicInteger expectedSize;
|
||||
private final AtomicInteger loadingChunks = new AtomicInteger();
|
||||
|
||||
private final AtomicInteger expectedSize;
|
||||
private int batchSize;
|
||||
private PlotSquaredTask task;
|
||||
private boolean shouldCancel;
|
||||
@ -151,13 +150,6 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
|
||||
Chunk chunk = this.availableChunks.poll();
|
||||
if (chunk == null) {
|
||||
if (this.availableChunks.isEmpty()) {
|
||||
if (this.requestedChunks.isEmpty() && loadingChunks.get() == 0) {
|
||||
finish();
|
||||
} else {
|
||||
requestBatch();
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
long[] iterationTime = new long[2];
|
||||
@ -205,11 +197,9 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
BlockVector2 chunk;
|
||||
for (int i = 0; i < this.batchSize && (chunk = this.requestedChunks.poll()) != null; i++) {
|
||||
// This required PaperLib to be bumped to version 1.0.4 to mark the request as urgent
|
||||
loadingChunks.incrementAndGet();
|
||||
PaperLib
|
||||
.getChunkAtAsync(this.bukkitWorld, chunk.getX(), chunk.getZ(), true, true)
|
||||
.whenComplete((chunkObject, throwable) -> {
|
||||
loadingChunks.decrementAndGet();
|
||||
if (throwable != null) {
|
||||
throwable.printStackTrace();
|
||||
// We want one less because this couldn't be processed
|
||||
|
||||
@ -111,8 +111,8 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
public boolean enqueue() {
|
||||
final Clipboard regenClipboard;
|
||||
if (isRegen()) {
|
||||
BlockVector3 start = BlockVector3.at(getRegenStart()[0] << 4, getMinY(), getRegenStart()[1] << 4);
|
||||
BlockVector3 end = BlockVector3.at((getRegenEnd()[0] << 4) + 15, getMaxY(), (getRegenEnd()[1] << 4) + 15);
|
||||
BlockVector3 start = BlockVector3.at(getRegenStart()[0] << 4, 0, getRegenStart()[1] << 4);
|
||||
BlockVector3 end = BlockVector3.at((getRegenEnd()[0] << 4) + 15, 255, (getRegenEnd()[1] << 4) + 15);
|
||||
Region region = new CuboidRegion(start, end);
|
||||
regenClipboard = new BlockArrayClipboard(region);
|
||||
regenClipboard.setOrigin(start);
|
||||
@ -134,7 +134,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
int sx = blockVector2.getX() << 4;
|
||||
int sz = blockVector2.getZ() << 4;
|
||||
if (isRegenChunk) {
|
||||
for (int layer = getMinLayer(); layer <= getMaxLayer(); layer++) {
|
||||
for (int layer = 0; layer < 16; layer++) {
|
||||
for (int y = 0; y < 16; y++) {
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
@ -170,7 +170,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
int lx = ChunkUtil.getX(j);
|
||||
int lz = ChunkUtil.getZ(j);
|
||||
int x = sx + lx;
|
||||
int y = ChunkUtil.getY(layer + localChunk.getMinSection(), j);
|
||||
int y = ChunkUtil.getY(layer, j);
|
||||
int z = sz + lz;
|
||||
boolean edge = Settings.QUEUE.UPDATE_EDGES && isEdge(y >> 4, lx, y & 15, lz, blockVector2,
|
||||
localChunk
|
||||
@ -179,7 +179,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int layer = 0; layer < localChunk.getBiomes().length; layer++) {
|
||||
for (int layer = 0; layer < localChunk.getBaseblocks().length; layer++) {
|
||||
BiomeType[] biomesLayer = localChunk.getBiomes()[layer];
|
||||
if (biomesLayer == null) {
|
||||
continue;
|
||||
@ -295,48 +295,47 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
|
||||
private boolean isEdge(int layer, int x, int y, int z, BlockVector2 blockVector2, LocalChunk localChunk) {
|
||||
int layerIndex = (layer - localChunk.getMinSection());
|
||||
if (layer == localChunk.getMinSection() || layerIndex == localChunk.getBaseblocks().length - 1) {
|
||||
if (layer == 0 || layer == localChunk.getBaseblocks().length - 1) {
|
||||
return false;
|
||||
}
|
||||
if (x == 0) {
|
||||
LocalChunk localChunkX = getBlockChunks().get(blockVector2.withX(blockVector2.getX() - 1));
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkX.getBaseblocks()[layerIndex][ChunkUtil.getJ(15, y, z)] != null) {
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layer] == null ||
|
||||
localChunkX.getBaseblocks()[layer][ChunkUtil.getJ(15, y, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
} else if (x == 15) {
|
||||
LocalChunk localChunkX = getBlockChunks().get(blockVector2.withX(blockVector2.getX() + 1));
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkX.getBaseblocks()[layerIndex][ChunkUtil.getJ(0, y, z)] != null) {
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layer] == null ||
|
||||
localChunkX.getBaseblocks()[layer][ChunkUtil.getJ(0, y, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (z == 0) {
|
||||
LocalChunk localChunkZ = getBlockChunks().get(blockVector2.withZ(blockVector2.getZ() - 1));
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkZ.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, y, 15)] != null) {
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layer] == null ||
|
||||
localChunkZ.getBaseblocks()[layer][ChunkUtil.getJ(x, y, 15)] != null) {
|
||||
return true;
|
||||
}
|
||||
} else if (z == 15) {
|
||||
LocalChunk localChunkZ = getBlockChunks().get(blockVector2.withZ(blockVector2.getZ() + 1));
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkZ.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, y, 0)] != null) {
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layer] == null ||
|
||||
localChunkZ.getBaseblocks()[layer][ChunkUtil.getJ(x, y, 0)] != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (y == 0) {
|
||||
if (localChunk.getBaseblocks()[layerIndex - 1] == null ||
|
||||
localChunk.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, 15, z)] != null) {
|
||||
if (localChunk.getBaseblocks()[layer - 1] == null ||
|
||||
localChunk.getBaseblocks()[layer][ChunkUtil.getJ(x, 15, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
} else if (y == 15) {
|
||||
if (localChunk.getBaseblocks()[layerIndex + 1] == null ||
|
||||
localChunk.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, 0, z)] != null) {
|
||||
if (localChunk.getBaseblocks()[layer + 1] == null ||
|
||||
localChunk.getBaseblocks()[layer][ChunkUtil.getJ(x, 0, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
BaseBlock[] baseBlocks = localChunk.getBaseblocks()[layerIndex];
|
||||
BaseBlock[] baseBlocks = localChunk.getBaseblocks()[layer];
|
||||
if (x > 0 && baseBlocks[ChunkUtil.getJ(x - 1, y, z)] == null) {
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -31,7 +31,6 @@ import com.plotsquared.bukkit.util.BukkitUtil;
|
||||
import com.plotsquared.core.location.ChunkWrapper;
|
||||
import com.plotsquared.core.location.Location;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.plotsquared.core.util.AnnotationHelper;
|
||||
import com.plotsquared.core.util.ChunkUtil;
|
||||
import com.plotsquared.core.util.PatternUtil;
|
||||
import com.sk89q.worldedit.bukkit.BukkitAdapter;
|
||||
@ -51,7 +50,6 @@ import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
import java.util.Arrays;
|
||||
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public class GenChunk extends ScopedQueueCoordinator {
|
||||
|
||||
public final Biome[] biomes;
|
||||
@ -63,14 +61,8 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
public int chunkZ;
|
||||
private ChunkData chunkData = null;
|
||||
|
||||
/**
|
||||
* @param minY minimum world Y, inclusive
|
||||
* @param maxY maximum world Y, inclusive
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public GenChunk(int minY, int maxY) {
|
||||
super(null, Location.at("", 0, minY, 0), Location.at("", 15, maxY, 15));
|
||||
public GenChunk() {
|
||||
super(null, Location.at("", 0, 0, 0), Location.at("", 15, 255, 15));
|
||||
this.biomes = Biome.values();
|
||||
}
|
||||
|
||||
@ -125,7 +117,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
return;
|
||||
}
|
||||
Biome biome = BukkitAdapter.adapt(biomeType);
|
||||
for (int y = getMin().getY(); y <= getMax().getY(); y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
this.biomeGrid.setBiome(x, y, z, biome);
|
||||
@ -138,7 +130,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
public void setCuboid(@NonNull Location pos1, @NonNull Location pos2, @NonNull BlockState block) {
|
||||
if (result != null && pos1.getX() == 0 && pos1.getZ() == 0 && pos2.getX() == 15 && pos2.getZ() == 15) {
|
||||
for (int y = pos1.getY(); y <= pos2.getY(); y++) {
|
||||
int layer = getLayerIndex(y);
|
||||
int layer = y >> 4;
|
||||
BlockState[] data = result[layer];
|
||||
if (data == null) {
|
||||
result[layer] = data = new BlockState[4096];
|
||||
@ -172,7 +164,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
*/
|
||||
public boolean setBiome(int x, int z, @NonNull Biome biome) {
|
||||
if (this.biomeGrid != null) {
|
||||
for (int y = getMin().getY(); y <= getMax().getY(); y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
this.setBiome(x, y, z, biome);
|
||||
}
|
||||
return true;
|
||||
@ -205,7 +197,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCache(final int x, final int y, final int z, final @NonNull BlockState id) {
|
||||
int i = getLayerIndex(y);
|
||||
int i = y >> 4;
|
||||
BlockState[] v = this.result[i];
|
||||
if (v == null) {
|
||||
this.result[i] = v = new BlockState[4096];
|
||||
@ -227,7 +219,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @Nullable BlockState getBlock(int x, int y, int z) {
|
||||
int i = getLayerIndex(y);
|
||||
int i = y >> 4;
|
||||
if (result == null) {
|
||||
return BukkitBlockUtil.get(chunkData.getType(x, y, z));
|
||||
}
|
||||
@ -254,16 +246,16 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMax() {
|
||||
return Location.at(getWorld().getName(), 15 + (getX() << 4), super.getMax().getY(), 15 + (getZ() << 4));
|
||||
return Location.at(getWorld().getName(), 15 + (getX() << 4), 255, 15 + (getZ() << 4));
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMin() {
|
||||
return Location.at(getWorld().getName(), getX() << 4, super.getMin().getY(), getZ() << 4);
|
||||
return Location.at(getWorld().getName(), getX() << 4, 0, getZ() << 4);
|
||||
}
|
||||
|
||||
public @NonNull GenChunk clone() {
|
||||
GenChunk toReturn = new GenChunk(getMin().getY(), getMax().getY());
|
||||
GenChunk toReturn = new GenChunk();
|
||||
if (this.result != null) {
|
||||
for (int i = 0; i < this.result.length; i++) {
|
||||
BlockState[] matrix = this.result[i];
|
||||
@ -277,8 +269,4 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
private int getLayerIndex(int y) {
|
||||
return (y - getMin().getY()) >> 4;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -40,6 +40,7 @@ import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.plotsquared.core.util.ChunkManager;
|
||||
import com.plotsquared.core.util.RegionManager;
|
||||
import com.plotsquared.core.util.RegionUtil;
|
||||
import com.plotsquared.core.util.WorldUtil;
|
||||
import com.plotsquared.core.util.entity.EntityCategories;
|
||||
import com.plotsquared.core.util.task.RunnableVal;
|
||||
@ -260,7 +261,7 @@ public class BukkitRegionManager extends RegionManager {
|
||||
if (checkX2 && checkZ2) {
|
||||
map.saveRegion(world, xxt2, xxt, zzt2, zzt); //
|
||||
}
|
||||
CuboidRegion currentPlotClear = new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3());
|
||||
CuboidRegion currentPlotClear = RegionUtil.createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
|
||||
map.saveEntitiesOut(Bukkit.getWorld(world.getName()).getChunkAt(x, z), currentPlotClear);
|
||||
AugmentedUtils.bypass(
|
||||
ignoreAugment,
|
||||
@ -275,9 +276,7 @@ public class BukkitRegionManager extends RegionManager {
|
||||
PlotLoc plotLoc = new PlotLoc(bx + x1, bz + z1);
|
||||
BaseBlock[] ids = map.allBlocks.get(plotLoc);
|
||||
if (ids != null) {
|
||||
int minY = value.getMin().getY();
|
||||
for (int yIndex = 0; yIndex < ids.length; yIndex++) {
|
||||
int y = yIndex + minY;
|
||||
for (int y = 0; y < Math.min(128, ids.length); y++) {
|
||||
BaseBlock id = ids[y];
|
||||
if (id != null) {
|
||||
value.setBlock(x1, y, z1, id);
|
||||
@ -285,6 +284,12 @@ public class BukkitRegionManager extends RegionManager {
|
||||
value.setBlock(x1, y, z1, BlockTypes.AIR.getDefaultState());
|
||||
}
|
||||
}
|
||||
for (int y = Math.min(128, ids.length); y < ids.length; y++) {
|
||||
BaseBlock id = ids[y];
|
||||
if (id != null) {
|
||||
value.setBlock(x1, y, z1, id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -292,7 +297,7 @@ public class BukkitRegionManager extends RegionManager {
|
||||
}, world.getName(), chunk)
|
||||
);
|
||||
//map.restoreBlocks(worldObj, 0, 0);
|
||||
map.restoreEntities(Bukkit.getWorld(world.getName()));
|
||||
map.restoreEntities(Bukkit.getWorld(world.getName()), 0, 0);
|
||||
});
|
||||
regenQueue.setCompleteTask(whenDone);
|
||||
queue.setCompleteTask(regenQueue::enqueue);
|
||||
|
||||
@ -44,6 +44,7 @@ import com.plotsquared.core.util.task.TaskManager;
|
||||
import com.sk89q.worldedit.bukkit.BukkitAdapter;
|
||||
import com.sk89q.worldedit.bukkit.BukkitWorld;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BlockCategories;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
@ -60,6 +61,7 @@ import org.bukkit.Bukkit;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.block.Biome;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.block.Sign;
|
||||
@ -244,9 +246,7 @@ public class BukkitUtil extends WorldUtil {
|
||||
final World bukkitWorld = Objects.requireNonNull(getWorld(world));
|
||||
// Skip top and bottom block
|
||||
int air = 1;
|
||||
int maxY = com.plotsquared.bukkit.util.BukkitWorld.getMaxWorldHeight(bukkitWorld);
|
||||
int minY = com.plotsquared.bukkit.util.BukkitWorld.getMinWorldHeight(bukkitWorld);
|
||||
for (int y = maxY - 1; y >= minY; y--) {
|
||||
for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
|
||||
Block block = bukkitWorld.getBlockAt(x, y, z);
|
||||
Material type = block.getType();
|
||||
if (type.isSolid()) {
|
||||
@ -273,9 +273,7 @@ public class BukkitUtil extends WorldUtil {
|
||||
final World bukkitWorld = Objects.requireNonNull(getWorld(world));
|
||||
// Skip top and bottom block
|
||||
int air = 1;
|
||||
int maxY = com.plotsquared.bukkit.util.BukkitWorld.getMaxWorldHeight(bukkitWorld);
|
||||
int minY = com.plotsquared.bukkit.util.BukkitWorld.getMinWorldHeight(bukkitWorld);
|
||||
for (int y = maxY - 1; y >= minY; y--) {
|
||||
for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
|
||||
Block block = bukkitWorld.getBlockAt(x, y, z);
|
||||
Material type = block.getType();
|
||||
if (type.isSolid()) {
|
||||
@ -347,15 +345,13 @@ public class BukkitUtil extends WorldUtil {
|
||||
final Block block = world.getBlockAt(location.getX(), location.getY(), location.getZ());
|
||||
final Material type = block.getType();
|
||||
if (type != Material.LEGACY_SIGN && type != Material.LEGACY_WALL_SIGN) {
|
||||
BlockFace facing = BlockFace.NORTH;
|
||||
if (!world.getBlockAt(location.getX(), location.getY(), location.getZ() + 1).getType().isSolid()) {
|
||||
if (world.getBlockAt(location.getX() - 1, location.getY(), location.getZ()).getType().isSolid()) {
|
||||
facing = BlockFace.EAST;
|
||||
} else if (world.getBlockAt(location.getX() + 1, location.getY(), location.getZ()).getType().isSolid()) {
|
||||
facing = BlockFace.WEST;
|
||||
} else if (world.getBlockAt(location.getX(), location.getY(), location.getZ() - 1).getType().isSolid()) {
|
||||
facing = BlockFace.SOUTH;
|
||||
}
|
||||
BlockFace facing = BlockFace.EAST;
|
||||
if (world.getBlockAt(location.getX(), location.getY(), location.getZ() + 1).getType().isSolid()) {
|
||||
facing = BlockFace.NORTH;
|
||||
} else if (world.getBlockAt(location.getX() + 1, location.getY(), location.getZ()).getType().isSolid()) {
|
||||
facing = BlockFace.WEST;
|
||||
} else if (world.getBlockAt(location.getX(), location.getY(), location.getZ() - 1).getType().isSolid()) {
|
||||
facing = BlockFace.SOUTH;
|
||||
}
|
||||
if (PlotSquared.platform().serverVersion()[1] == 13) {
|
||||
block.setType(Material.valueOf(area.legacySignMaterial()), false);
|
||||
@ -375,7 +371,7 @@ public class BukkitUtil extends WorldUtil {
|
||||
sign.setLine(i, LEGACY_COMPONENT_SERIALIZER
|
||||
.serialize(MINI_MESSAGE.parse(lines[i].getComponent(LocaleHolder.console()), replacements)));
|
||||
}
|
||||
sign.update(true, false);
|
||||
sign.update(true);
|
||||
}
|
||||
});
|
||||
}
|
||||
@ -386,6 +382,27 @@ public class BukkitUtil extends WorldUtil {
|
||||
return new StringComparison<BlockState>().new ComparisonResult(1, state);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBiomes(
|
||||
final @NonNull String worldName,
|
||||
final @NonNull CuboidRegion region,
|
||||
final @NonNull BiomeType biomeType
|
||||
) {
|
||||
final World world = getWorld(worldName);
|
||||
if (world == null) {
|
||||
LOGGER.warn("An error occurred while setting the biome because the world was null", new RuntimeException());
|
||||
return;
|
||||
}
|
||||
final Biome biome = BukkitAdapter.adapt(biomeType);
|
||||
for (int x = region.getMinimumPoint().getX(); x <= region.getMaximumPoint().getX(); x++) {
|
||||
for (int z = region.getMinimumPoint().getZ(); z <= region.getMaximumPoint().getZ(); z++) {
|
||||
if (world.getBiome(x, z) != biome) {
|
||||
world.setBiome(x, z, biome);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public com.sk89q.worldedit.world.@NonNull World getWeWorld(final @NonNull String world) {
|
||||
return new BukkitWorld(Bukkit.getWorld(world));
|
||||
|
||||
@ -36,18 +36,6 @@ import java.util.Objects;
|
||||
public class BukkitWorld implements World<org.bukkit.World> {
|
||||
|
||||
private static final Map<String, BukkitWorld> worldMap = Maps.newHashMap();
|
||||
private static final boolean HAS_MIN_Y;
|
||||
|
||||
static {
|
||||
boolean temp;
|
||||
try {
|
||||
org.bukkit.World.class.getMethod("getMinHeight");
|
||||
temp = true;
|
||||
} catch (NoSuchMethodException e) {
|
||||
temp = false;
|
||||
}
|
||||
HAS_MIN_Y = temp;
|
||||
}
|
||||
|
||||
private final org.bukkit.World world;
|
||||
|
||||
@ -85,24 +73,6 @@ public class BukkitWorld implements World<org.bukkit.World> {
|
||||
return bukkitWorld;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the min world height from a Bukkit {@link org.bukkit.World}. Inclusive
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public static int getMinWorldHeight(org.bukkit.World world) {
|
||||
return HAS_MIN_Y ? world.getMinHeight() : 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max world height from a Bukkit {@link org.bukkit.World}. Exclusive
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public static int getMaxWorldHeight(org.bukkit.World world) {
|
||||
return HAS_MIN_Y ? world.getMaxHeight() : 256;
|
||||
}
|
||||
|
||||
@Override
|
||||
public org.bukkit.World getPlatformWorld() {
|
||||
return this.world;
|
||||
@ -113,41 +83,34 @@ public class BukkitWorld implements World<org.bukkit.World> {
|
||||
return this.world.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinHeight() {
|
||||
return getMinWorldHeight(world);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxHeight() {
|
||||
return getMaxWorldHeight(world) - 1;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
if (o == this) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
if (!(o instanceof final BukkitWorld other)) {
|
||||
return false;
|
||||
}
|
||||
final BukkitWorld that = (BukkitWorld) o;
|
||||
return world.equals(that.world);
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
if (!Objects.equals(this.world, other.world)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return world.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof BukkitWorld;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $world = this.world;
|
||||
result = result * PRIME + ($world == null ? 43 : $world.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return "BukkitWorld(world=" + this.world + ")";
|
||||
}
|
||||
|
||||
@ -70,7 +70,7 @@ public class ContentMap {
|
||||
}
|
||||
for (int x = x1; x <= x2; x++) {
|
||||
for (int z = z1; z <= z2; z++) {
|
||||
saveBlocks(world, x, z);
|
||||
saveBlocks(world, 256, x, z, 0, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -92,7 +92,14 @@ public class ContentMap {
|
||||
}
|
||||
}
|
||||
|
||||
void saveEntitiesIn(Chunk chunk, CuboidRegion region, boolean delete) {
|
||||
void saveEntitiesIn(Chunk chunk, CuboidRegion region) {
|
||||
saveEntitiesIn(chunk, region, 0, 0, false);
|
||||
}
|
||||
|
||||
void saveEntitiesIn(
|
||||
Chunk chunk, CuboidRegion region, int offsetX, int offsetZ,
|
||||
boolean delete
|
||||
) {
|
||||
for (Entity entity : chunk.getEntities()) {
|
||||
Location location = BukkitUtil.adapt(entity.getLocation());
|
||||
int x = location.getX();
|
||||
@ -104,6 +111,8 @@ public class ContentMap {
|
||||
continue;
|
||||
}
|
||||
EntityWrapper wrap = new ReplicatingEntityWrapper(entity, (short) 2);
|
||||
wrap.x += offsetX;
|
||||
wrap.z += offsetZ;
|
||||
wrap.saveEntity();
|
||||
this.entities.add(wrap);
|
||||
if (delete) {
|
||||
@ -114,10 +123,10 @@ public class ContentMap {
|
||||
}
|
||||
}
|
||||
|
||||
void restoreEntities(World world) {
|
||||
void restoreEntities(World world, int xOffset, int zOffset) {
|
||||
for (EntityWrapper entity : this.entities) {
|
||||
try {
|
||||
entity.spawn(world, 0, 0);
|
||||
entity.spawn(world, xOffset, zOffset);
|
||||
} catch (Exception e) {
|
||||
LOGGER.error("Failed to restore entity", e);
|
||||
}
|
||||
@ -125,13 +134,15 @@ public class ContentMap {
|
||||
this.entities.clear();
|
||||
}
|
||||
|
||||
private void saveBlocks(BukkitWorld world, int x, int z) {
|
||||
BaseBlock[] ids = new BaseBlock[world.getMaxY() - world.getMinY() + 1];
|
||||
for (short yIndex = 0; yIndex <= world.getMaxY() - world.getMinY(); yIndex++) {
|
||||
BaseBlock block = world.getFullBlock(BlockVector3.at(x, yIndex + world.getMinY(), z));
|
||||
ids[yIndex] = block;
|
||||
//todo optimize maxY
|
||||
void saveBlocks(BukkitWorld world, int maxY, int x, int z, int offsetX, int offsetZ) {
|
||||
maxY = Math.min(255, maxY);
|
||||
BaseBlock[] ids = new BaseBlock[maxY + 1];
|
||||
for (short y = 0; y <= maxY; y++) {
|
||||
BaseBlock block = world.getFullBlock(BlockVector3.at(x, y, z));
|
||||
ids[y] = block;
|
||||
}
|
||||
PlotLoc loc = new PlotLoc(x, z);
|
||||
PlotLoc loc = new PlotLoc(x + offsetX, z + offsetZ);
|
||||
this.allBlocks.put(loc, ids);
|
||||
}
|
||||
|
||||
|
||||
@ -110,11 +110,6 @@ public class FaweRegionManager extends BukkitRegionManager {
|
||||
delegate.setBiome(region, extendBiome, biome, world, whenDone);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBiome(CuboidRegion region, int extendBiome, BiomeType biome, PlotArea area, Runnable whenDone) {
|
||||
delegate.setBiome(region, extendBiome, biome, area.getWorldName(), whenDone);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean copyRegion(
|
||||
final @NonNull Location pos1,
|
||||
|
||||
@ -67,7 +67,7 @@ public class FaweSchematicHandler extends SchematicHandler {
|
||||
final PlotPlayer<?> actor,
|
||||
final RunnableVal<Boolean> whenDone
|
||||
) {
|
||||
delegate.paste(schematic, plot, xOffset, yOffset, zOffset, autoHeight, actor, whenDone);
|
||||
delegate.paste(schematic, plot, xOffset, yOffset, zOffset, autoHeight, whenDone);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@ -22,7 +22,7 @@ dependencies {
|
||||
api(libs.guiceassistedinject) {
|
||||
exclude("com.google.inject", "guice")
|
||||
}
|
||||
api(libs.spotbugs)
|
||||
api(libs.findbugs)
|
||||
|
||||
// Plugins
|
||||
compileOnly(libs.worldeditCore) {
|
||||
|
||||
@ -98,22 +98,6 @@ public interface PlotPlatform<P> extends LocaleHolder {
|
||||
*/
|
||||
int[] serverVersion();
|
||||
|
||||
/**
|
||||
* Gets the default minimum world height for the version of Minecraft that the server is running.
|
||||
*
|
||||
* @return minimum world height
|
||||
* @since 6.6.0
|
||||
*/
|
||||
int versionMinHeight();
|
||||
|
||||
/**
|
||||
* Gets the default maximum world height for the version of Minecraft that the server is running.
|
||||
*
|
||||
* @return maximum world height (inclusive)
|
||||
* @since 6.6.0
|
||||
*/
|
||||
int versionMaxHeight();
|
||||
|
||||
/**
|
||||
* Gets the server implementation name and version
|
||||
*
|
||||
|
||||
@ -1020,8 +1020,8 @@ public class PlotSquared {
|
||||
// save configuration
|
||||
|
||||
final List<String> validArguments = Arrays
|
||||
.asList("s=", "size=", "g=", "gap=", "h=", "height=", "minh=", "minheight=", "maxh=", "maxheight=",
|
||||
"f=", "floor=", "m=", "main=", "w=", "wall=", "b=", "border="
|
||||
.asList("s=", "size=", "g=", "gap=", "h=", "height=", "f=", "floor=", "m=", "main=",
|
||||
"w=", "wall=", "b=", "border="
|
||||
);
|
||||
|
||||
// Calculate the number of expected arguments
|
||||
@ -1100,14 +1100,6 @@ public class PlotSquared {
|
||||
ConfigurationUtil.INTEGER.parseString(value).shortValue()
|
||||
);
|
||||
}
|
||||
case "minh", "minheight" -> this.worldConfiguration.set(
|
||||
base + "world.min_gen_height",
|
||||
ConfigurationUtil.INTEGER.parseString(value).shortValue()
|
||||
);
|
||||
case "maxh", "maxheight" -> this.worldConfiguration.set(
|
||||
base + "world.max_gen_height",
|
||||
ConfigurationUtil.INTEGER.parseString(value).shortValue()
|
||||
);
|
||||
case "f", "floor" -> this.worldConfiguration.set(
|
||||
base + "plot.floor",
|
||||
ConfigurationUtil.BLOCK_BUCKET.parseString(value).toString()
|
||||
|
||||
@ -75,7 +75,6 @@ import com.sk89q.worldedit.function.operation.Operations;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.regions.Region;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
@ -192,12 +191,11 @@ public class Area extends SubCommand {
|
||||
final BlockVector3 playerSelectionMin = playerSelectedRegion.getMinimumPoint();
|
||||
final BlockVector3 playerSelectionMax = playerSelectedRegion.getMaximumPoint();
|
||||
// Create a new selection that spans the entire vertical range of the world
|
||||
World world = playerSelectedRegion.getWorld();
|
||||
final CuboidRegion selectedRegion =
|
||||
new CuboidRegion(
|
||||
playerSelectedRegion.getWorld(),
|
||||
BlockVector3.at(playerSelectionMin.getX(), world.getMinY(), playerSelectionMin.getZ()),
|
||||
BlockVector3.at(playerSelectionMax.getX(), world.getMaxY(), playerSelectionMax.getZ())
|
||||
BlockVector3.at(playerSelectionMin.getX(), 0, playerSelectionMin.getZ()),
|
||||
BlockVector3.at(playerSelectionMax.getX(), 255, playerSelectionMax.getZ())
|
||||
);
|
||||
// There's only one plot in the area...
|
||||
final PlotId plotId = PlotId.of(1, 1);
|
||||
@ -280,9 +278,9 @@ public class Area extends SubCommand {
|
||||
if (offsetZ != 0) {
|
||||
this.worldConfiguration.set(path + ".road.offset.z", offsetZ);
|
||||
}
|
||||
final String worldName = this.setupUtils.setupWorld(singleBuilder);
|
||||
if (this.worldUtil.isWorld(worldName)) {
|
||||
PlotSquared.get().loadWorld(worldName, null);
|
||||
final String world = this.setupUtils.setupWorld(singleBuilder);
|
||||
if (this.worldUtil.isWorld(world)) {
|
||||
PlotSquared.get().loadWorld(world, null);
|
||||
player.sendMessage(TranslatableCaption.of("single.single_area_created"));
|
||||
} else {
|
||||
player.sendMessage(
|
||||
@ -371,8 +369,7 @@ public class Area extends SubCommand {
|
||||
int lower = (area.ROAD_WIDTH & 1) == 0 ? area.ROAD_WIDTH / 2 - 1 : area.ROAD_WIDTH / 2;
|
||||
final int offsetX = bx - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
final int offsetZ = bz - (area.ROAD_WIDTH == 0 ? 0 : lower);
|
||||
// Height doesn't matter for this region
|
||||
final CuboidRegion region = RegionUtil.createRegion(bx, tx, 0, 0, bz, tz);
|
||||
final CuboidRegion region = RegionUtil.createRegion(bx, tx, bz, tz);
|
||||
final Set<PlotArea> areas = this.plotAreaManager.getPlotAreasSet(area.getWorldName(), region);
|
||||
if (!areas.isEmpty()) {
|
||||
player.sendMessage(
|
||||
|
||||
@ -28,7 +28,6 @@ package com.plotsquared.core.command;
|
||||
import com.plotsquared.core.configuration.caption.Caption;
|
||||
import com.plotsquared.core.configuration.caption.LocaleHolder;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.player.PlotPlayer;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
/**
|
||||
@ -96,16 +95,4 @@ public enum CommandCategory implements Caption {
|
||||
public String getComponent(@NonNull LocaleHolder localeHolder) {
|
||||
return this.caption.getComponent(localeHolder);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a player has access to this command category
|
||||
*
|
||||
* @param player The player to check against
|
||||
* @return {@code true} if at least one command of this category can be executed by the player, {@code false} otherwise
|
||||
* @since 6.5.0
|
||||
*/
|
||||
boolean canAccess(PlotPlayer<?> player) {
|
||||
return !MainCommand.getInstance().getCommands(this, player).isEmpty();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -48,7 +48,7 @@ public class Confirm extends SubCommand {
|
||||
player.sendMessage(TranslatableCaption.of("confirm.expired_confirm"));
|
||||
return false;
|
||||
}
|
||||
TaskManager.runTask(command.command);
|
||||
TaskManager.runTaskAsync(command.command);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@ -49,7 +49,6 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collection;
|
||||
import java.util.HashSet;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.stream.Collectors;
|
||||
@ -208,7 +207,7 @@ public class DebugExec extends SubCommand {
|
||||
}
|
||||
boolean result;
|
||||
if (HybridUtils.regions != null) {
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, HybridUtils.regions, 0, new LinkedHashSet<>());
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, HybridUtils.regions, 0, new HashSet<>());
|
||||
} else {
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, 0);
|
||||
}
|
||||
|
||||
@ -37,11 +37,11 @@ import net.kyori.adventure.text.Component;
|
||||
import net.kyori.adventure.text.TextComponent;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
@CommandDeclaration(command = "help",
|
||||
aliases = "?",
|
||||
@ -119,9 +119,6 @@ public class Help extends Command {
|
||||
TextComponent.Builder builder = Component.text();
|
||||
builder.append(MINI_MESSAGE.parse(TranslatableCaption.of("help.help_header").getComponent(player)));
|
||||
for (CommandCategory c : CommandCategory.values()) {
|
||||
if (!c.canAccess(player)) {
|
||||
continue;
|
||||
}
|
||||
builder.append(Component.newline()).append(MINI_MESSAGE
|
||||
.parse(
|
||||
TranslatableCaption.of("help.help_info_item").getComponent(player),
|
||||
@ -155,26 +152,12 @@ public class Help extends Command {
|
||||
|
||||
@Override
|
||||
public Collection<Command> tab(PlotPlayer<?> player, String[] args, boolean space) {
|
||||
final String argument = args[0].toLowerCase(Locale.ENGLISH);
|
||||
List<Command> result = new ArrayList<>();
|
||||
|
||||
for (final CommandCategory category : CommandCategory.values()) {
|
||||
if (!category.canAccess(player)) {
|
||||
continue;
|
||||
}
|
||||
String name = category.name().toLowerCase();
|
||||
if (!name.startsWith(argument)) {
|
||||
continue;
|
||||
}
|
||||
result.add(new Command(null, false, name, "", RequiredType.NONE, null) {
|
||||
});
|
||||
}
|
||||
// add the category "all"
|
||||
if ("all".startsWith(argument)) {
|
||||
result.add(new Command(null, false, "all", "", RequiredType.NONE, null) {
|
||||
});
|
||||
}
|
||||
return result;
|
||||
return Stream.of("claiming", "teleport", "settings", "chat", "schematic", "appearance", "info", "debug",
|
||||
"administration", "all"
|
||||
)
|
||||
.filter(value -> value.startsWith(args[0].toLowerCase(Locale.ENGLISH)))
|
||||
.map(value -> new Command(null, false, value, "", RequiredType.NONE, null) {
|
||||
}).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -40,7 +40,6 @@ import com.plotsquared.core.plot.schematic.Schematic;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import com.plotsquared.core.util.SchematicHandler;
|
||||
import com.plotsquared.core.util.TimeUtil;
|
||||
import com.plotsquared.core.util.task.RunnableVal;
|
||||
import com.plotsquared.core.util.task.TaskManager;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
@ -206,7 +205,7 @@ public class Load extends SubCommand {
|
||||
if (split.length < 5) {
|
||||
continue;
|
||||
}
|
||||
String time = TimeUtil.secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
|
||||
String time = secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
|
||||
String world = split[1];
|
||||
PlotId id = PlotId.fromString(split[2] + ';' + split[3]);
|
||||
String size = split[4];
|
||||
@ -224,10 +223,6 @@ public class Load extends SubCommand {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link TimeUtil#secToTime(long)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.2")
|
||||
public String secToTime(long time) {
|
||||
StringBuilder toreturn = new StringBuilder();
|
||||
if (time >= 33868800) {
|
||||
|
||||
@ -104,8 +104,8 @@ public class Save extends SubCommand {
|
||||
TaskManager.runTaskAsync(() -> {
|
||||
String time = (System.currentTimeMillis() / 1000) + "";
|
||||
Location[] corners = plot.getCorners();
|
||||
corners[0] = corners[0].withY(plot.getArea().getMinBuildHeight());
|
||||
corners[1] = corners[1].withY(plot.getArea().getMaxBuildHeight());
|
||||
corners[0] = corners[0].withY(0);
|
||||
corners[1] = corners[1].withY(255);
|
||||
int size = (corners[1].getX() - corners[0].getX()) + 1;
|
||||
PlotId id = plot.getId();
|
||||
String world1 = plot.getArea().toString().replaceAll(";", "-")
|
||||
|
||||
@ -57,12 +57,8 @@ public class SetHome extends SetCommand {
|
||||
Plot base = plot.getBasePlot(false);
|
||||
Location bottom = base.getBottomAbs();
|
||||
Location location = player.getLocationFull();
|
||||
BlockLoc rel = new BlockLoc(
|
||||
location.getX() - bottom.getX(),
|
||||
location.getY(), // y is absolute
|
||||
location.getZ() - bottom.getZ(),
|
||||
location.getYaw(),
|
||||
location.getPitch()
|
||||
BlockLoc rel = new BlockLoc(location.getX() - bottom.getX(), location.getY(),
|
||||
location.getZ() - bottom.getZ(), location.getYaw(), location.getPitch()
|
||||
);
|
||||
base.setHome(rel);
|
||||
player.sendMessage(TranslatableCaption.of("position.position_set"));
|
||||
|
||||
@ -180,12 +180,12 @@ public class Trim extends SubCommand {
|
||||
int bx = cbx << 4;
|
||||
int bz = cbz << 4;
|
||||
CuboidRegion region =
|
||||
RegionUtil.createRegion(bx, bx + 511, 0, 0, bz, bz + 511);
|
||||
RegionUtil.createRegion(bx, bx + 511, bz, bz + 511);
|
||||
for (Plot plot : PlotQuery.newQuery().inWorld(world)) {
|
||||
Location bot = plot.getBottomAbs();
|
||||
Location top = plot.getExtendedTopAbs();
|
||||
CuboidRegion plotReg = RegionUtil
|
||||
.createRegion(bot.getX(), top.getX(), 0, 0, bot.getZ(), top.getZ());
|
||||
.createRegion(bot.getX(), top.getX(), bot.getZ(), top.getZ());
|
||||
if (!RegionUtil.intersects(region, plotReg)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -128,7 +128,7 @@ public class ComponentPresetManager {
|
||||
0,
|
||||
"",
|
||||
"<rainbow:2>Disco Floor</rainbow>",
|
||||
List.of("<gold>Spice up your plot floor</gold>"),
|
||||
Arrays.asList("<gold>Spice up your plot floor</gold>"),
|
||||
ItemTypes.YELLOW_WOOL
|
||||
));
|
||||
yamlConfiguration.set("presets", defaultPreset.stream().map(ComponentPreset::serialize).collect(Collectors.toList()));
|
||||
@ -181,10 +181,6 @@ public class ComponentPresetManager {
|
||||
}
|
||||
allowedPresets.add(componentPreset);
|
||||
}
|
||||
if (allowedPresets.isEmpty()) {
|
||||
player.sendMessage(TranslatableCaption.of("preset.empty"));
|
||||
return null;
|
||||
}
|
||||
final int size = (int) Math.ceil((double) allowedPresets.size() / 9.0D);
|
||||
final PlotInventory plotInventory = new PlotInventory(this.inventoryUtil, player, size,
|
||||
TranslatableCaption.of("preset.title").getComponent(player)) {
|
||||
@ -214,13 +210,7 @@ public class ComponentPresetManager {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (componentPreset.getCost() > 0.0D) {
|
||||
if (!econHandler.isEnabled(plot.getArea())) {
|
||||
getPlayer().sendMessage(
|
||||
TranslatableCaption.of("preset.economy_disabled"),
|
||||
Template.of("preset", componentPreset.getDisplayName()));
|
||||
return false;
|
||||
}
|
||||
if (componentPreset.getCost() > 0.0D && econHandler.isEnabled(plot.getArea())) {
|
||||
if (econHandler.getMoney(getPlayer()) < componentPreset.getCost()) {
|
||||
getPlayer().sendMessage(TranslatableCaption.of("preset.preset_cannot_afford"));
|
||||
return false;
|
||||
@ -256,16 +246,11 @@ public class ComponentPresetManager {
|
||||
for (int i = 0; i < allowedPresets.size(); i++) {
|
||||
final ComponentPreset preset = allowedPresets.get(i);
|
||||
final List<String> lore = new ArrayList<>();
|
||||
if (preset.getCost() > 0) {
|
||||
if (!this.econHandler.isEnabled(plot.getArea())) {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_economy_disabled").getComponent(player))));
|
||||
} else {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_cost").getComponent(player),
|
||||
Template.of("cost", String.format("%.2f", preset.getCost()))
|
||||
)));
|
||||
}
|
||||
if (preset.getCost() > 0 && this.econHandler.isEnabled(plot.getArea())) {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_cost").getComponent(player),
|
||||
Template.of("cost", String.format("%.2f", preset.getCost()))
|
||||
)));
|
||||
}
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_component").getComponent(player),
|
||||
|
||||
@ -70,7 +70,7 @@ public class AugmentedUtils {
|
||||
final int blockZ = chunkZ << 4;
|
||||
// Create a region that contains the
|
||||
// entire chunk
|
||||
CuboidRegion region = RegionUtil.createRegion(blockX, blockX + 15, 0, 0, blockZ, blockZ + 15);
|
||||
CuboidRegion region = RegionUtil.createRegion(blockX, blockX + 15, blockZ, blockZ + 15);
|
||||
// Query for plot areas in the chunk
|
||||
final Set<PlotArea> areas = PlotSquared.get().getPlotAreaManager().getPlotAreasSet(world, region);
|
||||
if (areas.isEmpty()) {
|
||||
@ -122,7 +122,6 @@ public class AugmentedUtils {
|
||||
}
|
||||
QueueCoordinator secondaryMask;
|
||||
BlockState air = BlockTypes.AIR.getDefaultState();
|
||||
int startYOffset = !(area instanceof ClassicPlotWorld) || ((ClassicPlotWorld) area).PLOT_BEDROCK ? 1 : 0;
|
||||
if (area.getTerrain() == PlotAreaTerrainType.ROAD) {
|
||||
PlotManager manager = area.getPlotManager();
|
||||
final boolean[][] canPlace = new boolean[16][16];
|
||||
@ -133,7 +132,7 @@ public class AugmentedUtils {
|
||||
int worldZ = z + blockZ;
|
||||
boolean can = manager.getPlotId(worldX, 0, worldZ) == null;
|
||||
if (can) {
|
||||
for (int y = area.getMinGenHeight() + startYOffset; y <= area.getMaxGenHeight(); y++) {
|
||||
for (int y = 1; y < 128; y++) {
|
||||
queue.setBlock(worldX, y, worldZ, air);
|
||||
}
|
||||
canPlace[x][z] = true;
|
||||
@ -150,7 +149,7 @@ public class AugmentedUtils {
|
||||
secondaryMask = primaryMask;
|
||||
for (int x = relativeBottomX; x <= relativeTopX; x++) {
|
||||
for (int z = relativeBottomZ; z <= relativeTopZ; z++) {
|
||||
for (int y = area.getMinGenHeight() + startYOffset; y <= area.getMaxGenHeight(); y++) {
|
||||
for (int y = 1; y < 128; y++) {
|
||||
queue.setBlock(blockX + x, y, blockZ + z, air);
|
||||
}
|
||||
}
|
||||
@ -167,8 +166,8 @@ public class AugmentedUtils {
|
||||
ScopedQueueCoordinator scoped =
|
||||
new ScopedQueueCoordinator(
|
||||
secondaryMask,
|
||||
Location.at(world, blockX, area.getMinGenHeight(), blockZ),
|
||||
Location.at(world, blockX + 15, area.getMaxGenHeight(), blockZ + 15)
|
||||
Location.at(world, blockX, 0, blockZ),
|
||||
Location.at(world, blockX + 15, 255, blockZ + 15)
|
||||
);
|
||||
generator.generateChunk(scoped, area);
|
||||
generator.populateChunk(scoped, area);
|
||||
|
||||
@ -37,6 +37,7 @@ import com.plotsquared.core.plot.Plot;
|
||||
import com.plotsquared.core.plot.PlotAreaTerrainType;
|
||||
import com.plotsquared.core.plot.PlotId;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.util.BlockUtil;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.plotsquared.core.util.RegionManager;
|
||||
import com.plotsquared.core.util.task.TaskManager;
|
||||
@ -146,15 +147,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
) {
|
||||
Plot plot = classicPlotWorld.getPlotAbs(plotId);
|
||||
if (plot != null && plot.isBasePlot()) {
|
||||
return this.regionManager.setCuboids(
|
||||
classicPlotWorld,
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
classicPlotWorld.getMinBuildHeight(),
|
||||
classicPlotWorld.getMaxBuildHeight(),
|
||||
actor,
|
||||
queue
|
||||
);
|
||||
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks, 1, getWorldHeight(), actor, queue);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -182,7 +175,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
classicPlotWorld.PLOT_HEIGHT + 1,
|
||||
classicPlotWorld.getMaxBuildHeight(),
|
||||
getWorldHeight(),
|
||||
actor,
|
||||
queue
|
||||
);
|
||||
@ -211,7 +204,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld,
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
classicPlotWorld.getMinBuildHeight(),
|
||||
1,
|
||||
classicPlotWorld.PLOT_HEIGHT - 1,
|
||||
actor,
|
||||
queue
|
||||
@ -288,7 +281,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
}
|
||||
}
|
||||
|
||||
int maxY = classicPlotWorld.getMaxBuildHeight();
|
||||
int maxY = classicPlotWorld.getPlotManager().getWorldHeight();
|
||||
if (!plot.isMerged(Direction.NORTH)) {
|
||||
int z = bottom.getZ();
|
||||
for (int x = bottom.getX(); x <= top.getX(); x++) {
|
||||
@ -389,7 +382,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
if (!plot.isMerged(Direction.NORTH)) {
|
||||
int z = bot.getZ();
|
||||
for (int x = bot.getX(); x < top.getX(); x++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -397,7 +390,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
if (!plot.isMerged(Direction.WEST)) {
|
||||
int x = bot.getX();
|
||||
for (int z = bot.getZ(); z < top.getZ(); z++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -405,7 +398,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
if (!plot.isMerged(Direction.SOUTH)) {
|
||||
int z = top.getZ();
|
||||
for (int x = bot.getX(); x < top.getX() + (plot.isMerged(Direction.EAST) ? 0 : 1); x++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -413,7 +406,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
if (!plot.isMerged(Direction.EAST)) {
|
||||
int x = top.getX();
|
||||
for (int z = bot.getZ(); z < top.getZ() + (plot.isMerged(Direction.SOUTH) ? 0 : 1); z++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -508,7 +501,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
enqueue = true;
|
||||
}
|
||||
|
||||
int maxY = classicPlotWorld.getMaxGenHeight();
|
||||
int maxY = getWorldHeight();
|
||||
queue.setCuboid(
|
||||
Location.at(
|
||||
classicPlotWorld.getWorldName(),
|
||||
@ -520,27 +513,27 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
);
|
||||
if (classicPlotWorld.PLOT_BEDROCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight(), sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMinGenHeight(), ez - 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, 0, ez - 1),
|
||||
BlockTypes.BEDROCK.getDefaultState()
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
} else {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
}
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT, ez - 1),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
|
||||
classicPlotWorld.ROAD_BLOCK.toPattern()
|
||||
);
|
||||
|
||||
if (classicPlotWorld.PLACE_TOP_BLOCK) {
|
||||
queue.setCuboid(
|
||||
@ -548,12 +541,24 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, ez - 1),
|
||||
classicPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT, ez - 1),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
if (classicPlotWorld.PLACE_TOP_BLOCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, ez - 1),
|
||||
classicPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
|
||||
classicPlotWorld.ROAD_BLOCK.toPattern()
|
||||
);
|
||||
return !enqueue || queue.enqueue();
|
||||
}
|
||||
|
||||
@ -579,32 +584,19 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
if (classicPlotWorld.PLOT_BEDROCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight(), sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMinGenHeight(), ez),
|
||||
BlockTypes.BEDROCK.getDefaultState()
|
||||
);
|
||||
}
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 0, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, 0, ez),
|
||||
BlockUtil.get((short) 7, (byte) 0)
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, sz),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, ez),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
|
||||
classicPlotWorld.ROAD_BLOCK.toPattern()
|
||||
);
|
||||
|
||||
if (classicPlotWorld.PLACE_TOP_BLOCK) {
|
||||
queue.setCuboid(
|
||||
@ -612,12 +604,24 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, sz),
|
||||
classicPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, ez),
|
||||
classicPlotWorld.WALL_FILLING.toPattern()
|
||||
);
|
||||
if (classicPlotWorld.PLACE_TOP_BLOCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
|
||||
classicPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
|
||||
classicPlotWorld.ROAD_BLOCK.toPattern()
|
||||
);
|
||||
return !enqueue || queue.enqueue();
|
||||
}
|
||||
|
||||
@ -638,19 +642,14 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.ROAD_HEIGHT + 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMaxGenHeight(), ez - 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getPlotManager().getWorldHeight(), ez - 1),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
if (classicPlotWorld.PLOT_BEDROCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight(), sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMinGenHeight(), ez - 1),
|
||||
BlockTypes.BEDROCK.getDefaultState()
|
||||
);
|
||||
}
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 0, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, 0, ez - 1), BlockUtil.get((short) 7, (byte) 0)
|
||||
);
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1),
|
||||
classicPlotWorld.ROAD_BLOCK.toPattern()
|
||||
);
|
||||
@ -680,12 +679,11 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez - 1),
|
||||
classicPlotWorld.MAIN_BLOCK.toPattern()
|
||||
);
|
||||
@ -721,12 +719,11 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT - 1, ez),
|
||||
classicPlotWorld.MAIN_BLOCK.toPattern()
|
||||
);
|
||||
@ -761,12 +758,11 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight() + startYOffset, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez),
|
||||
classicPlotWorld.MAIN_BLOCK.toPattern()
|
||||
);
|
||||
|
||||
@ -127,16 +127,16 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld {
|
||||
public void loadConfiguration(ConfigurationSection config) {
|
||||
super.loadConfiguration(config);
|
||||
this.PLOT_BEDROCK = config.getBoolean("plot.bedrock");
|
||||
this.PLOT_HEIGHT = Math.min(getMaxGenHeight(), config.getInt("plot.height"));
|
||||
this.PLOT_HEIGHT = Math.min(255, config.getInt("plot.height"));
|
||||
this.MAIN_BLOCK = new BlockBucket(config.getString("plot.filling"));
|
||||
this.TOP_BLOCK = new BlockBucket(config.getString("plot.floor"));
|
||||
this.WALL_BLOCK = new BlockBucket(config.getString("wall.block"));
|
||||
this.ROAD_HEIGHT = Math.min(getMaxGenHeight(), config.getInt("road.height"));
|
||||
this.ROAD_HEIGHT = Math.min(255, config.getInt("road.height"));
|
||||
this.ROAD_BLOCK = new BlockBucket(config.getString("road.block"));
|
||||
this.WALL_FILLING = new BlockBucket(config.getString("wall.filling"));
|
||||
this.PLACE_TOP_BLOCK = config.getBoolean("wall.place_top_block");
|
||||
this.WALL_HEIGHT = Math.min(getMaxGenHeight() - (PLACE_TOP_BLOCK ? 1 : 0), config.getInt("wall.height"));
|
||||
this.WALL_HEIGHT = Math.min(254, config.getInt("wall.height"));
|
||||
this.CLAIMED_WALL_BLOCK = new BlockBucket(config.getString("wall.block_claimed"));
|
||||
this.PLACE_TOP_BLOCK = config.getBoolean("wall.place_top_block");
|
||||
}
|
||||
|
||||
int schematicStartHeight() {
|
||||
|
||||
@ -91,7 +91,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
if (hybridPlotWorld.PLOT_BEDROCK) {
|
||||
for (short x = 0; x < 16; x++) {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
result.setBlock(x, hybridPlotWorld.getMinGenHeight(), z, BlockTypes.BEDROCK.getDefaultState());
|
||||
result.setBlock(x, 0, z, BlockTypes.BEDROCK.getDefaultState());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -156,7 +156,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
}
|
||||
// generation
|
||||
int startY = hybridPlotWorld.getMinGenHeight() + (hybridPlotWorld.PLOT_BEDROCK ? 1: 0);
|
||||
int startY = hybridPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
for (short x = 0; x < 16; x++) {
|
||||
if (insideRoadX[x]) {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
|
||||
@ -46,6 +46,7 @@ import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
import com.sk89q.worldedit.world.block.BlockTypes;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
@ -106,32 +107,22 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
|
||||
@Override
|
||||
public boolean createRoadEast(final @NonNull Plot plot, @Nullable QueueCoordinator queue) {
|
||||
boolean enqueue = false;
|
||||
if (queue == null) {
|
||||
queue = hybridPlotWorld.getQueue();
|
||||
enqueue = true;
|
||||
}
|
||||
super.createRoadEast(plot, queue);
|
||||
PlotId id = plot.getId();
|
||||
PlotId id2 = PlotId.of(id.getX() + 1, id.getY());
|
||||
Location bot = getPlotBottomLocAbs(id2);
|
||||
Location top = getPlotTopLocAbs(id);
|
||||
Location pos1 = Location.at(
|
||||
hybridPlotWorld.getWorldName(),
|
||||
top.getX() + 1,
|
||||
hybridPlotWorld.getMinGenHeight(),
|
||||
bot.getZ() - 1
|
||||
);
|
||||
Location pos2 = Location.at(
|
||||
hybridPlotWorld.getWorldName(),
|
||||
bot.getX(),
|
||||
hybridPlotWorld.getMaxGenHeight(),
|
||||
top.getZ() + 1
|
||||
);
|
||||
Location pos1 = Location.at(hybridPlotWorld.getWorldName(), top.getX() + 1, 0, bot.getZ() - 1);
|
||||
Location pos2 = Location.at(hybridPlotWorld.getWorldName(), bot.getX(), Math.min(getWorldHeight(), 255), top.getZ() + 1);
|
||||
this.resetBiome(hybridPlotWorld, pos1, pos2);
|
||||
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
return true;
|
||||
}
|
||||
boolean enqueue = false;
|
||||
if (queue == null) {
|
||||
queue = hybridPlotWorld.getQueue();
|
||||
enqueue = true;
|
||||
}
|
||||
createSchemAbs(queue, pos1, pos2, true);
|
||||
return !enqueue || queue.enqueue();
|
||||
}
|
||||
@ -148,7 +139,7 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
(pos1.getX() + pos2.getX()) / 2,
|
||||
(pos1.getZ() + pos2.getZ()) / 2
|
||||
), biome)) {
|
||||
WorldUtil.setBiome(hybridPlotWorld.getWorldName(), new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()), biome);
|
||||
WorldUtil.setBiome(hybridPlotWorld.getWorldName(), pos1.getX(), pos1.getZ(), pos2.getX(), pos2.getZ(), biome);
|
||||
}
|
||||
}
|
||||
|
||||
@ -199,38 +190,38 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
|
||||
@Override
|
||||
public boolean createRoadSouth(final @NonNull Plot plot, @Nullable QueueCoordinator queue) {
|
||||
boolean enqueue = false;
|
||||
if (queue == null) {
|
||||
enqueue = true;
|
||||
queue = hybridPlotWorld.getQueue();
|
||||
}
|
||||
super.createRoadSouth(plot, queue);
|
||||
PlotId id = plot.getId();
|
||||
PlotId id2 = PlotId.of(id.getX(), id.getY() + 1);
|
||||
Location bot = getPlotBottomLocAbs(id2);
|
||||
Location top = getPlotTopLocAbs(id);
|
||||
Location pos1 = Location.at(hybridPlotWorld.getWorldName(), bot.getX() - 1, hybridPlotWorld.getMinGenHeight(), top.getZ() + 1);
|
||||
Location pos2 = Location.at(hybridPlotWorld.getWorldName(), top.getX() + 1, hybridPlotWorld.getMaxGenHeight(), bot.getZ());
|
||||
Location pos1 = Location.at(hybridPlotWorld.getWorldName(), bot.getX() - 1, 0, top.getZ() + 1);
|
||||
Location pos2 = Location.at(hybridPlotWorld.getWorldName(), top.getX() + 1, Math.min(getWorldHeight(), 255), bot.getZ());
|
||||
this.resetBiome(hybridPlotWorld, pos1, pos2);
|
||||
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
return true;
|
||||
}
|
||||
boolean enqueue = false;
|
||||
if (queue == null) {
|
||||
enqueue = true;
|
||||
queue = hybridPlotWorld.getQueue();
|
||||
}
|
||||
createSchemAbs(queue, pos1, pos2, true);
|
||||
return !enqueue || queue.enqueue();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean createRoadSouthEast(final @NonNull Plot plot, @Nullable QueueCoordinator queue) {
|
||||
super.createRoadSouthEast(plot, queue);
|
||||
PlotId id = plot.getId();
|
||||
PlotId id2 = PlotId.of(id.getX() + 1, id.getY() + 1);
|
||||
Location pos1 = getPlotTopLocAbs(id).add(1, 0, 1).withY(0);
|
||||
Location pos2 = getPlotBottomLocAbs(id2).withY(Math.min(getWorldHeight(), 255));
|
||||
boolean enqueue = false;
|
||||
if (queue == null) {
|
||||
enqueue = true;
|
||||
queue = hybridPlotWorld.getQueue();
|
||||
}
|
||||
super.createRoadSouthEast(plot, queue);
|
||||
PlotId id = plot.getId();
|
||||
PlotId id2 = PlotId.of(id.getX() + 1, id.getY() + 1);
|
||||
Location pos1 = getPlotTopLocAbs(id).add(1, 0, 1);
|
||||
Location pos2 = getPlotBottomLocAbs(id2);
|
||||
createSchemAbs(queue, pos1, pos2, true);
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
createSchemAbs(queue, pos1, pos2, true);
|
||||
@ -280,23 +271,11 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
queue.setCompleteTask(whenDone);
|
||||
}
|
||||
if (!canRegen) {
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.getMinGenHeight()),
|
||||
pos2.withY(hybridPlotWorld.getMinGenHeight()),
|
||||
hybridPlotWorld.PLOT_BEDROCK ? bedrock : filling
|
||||
);
|
||||
queue.setCuboid(pos1.withY(0), pos2.withY(0), bedrock);
|
||||
// Each component has a different layer
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.getMinGenHeight() + 1),
|
||||
pos2.withY(hybridPlotWorld.PLOT_HEIGHT - 1),
|
||||
filling
|
||||
);
|
||||
queue.setCuboid(pos1.withY(1), pos2.withY(hybridPlotWorld.PLOT_HEIGHT - 1), filling);
|
||||
queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT), pos2.withY(hybridPlotWorld.PLOT_HEIGHT), plotfloor);
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.PLOT_HEIGHT + 1),
|
||||
pos2.withY(hybridPlotWorld.getMaxGenHeight()),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
queue.setCuboid(pos1.withY(hybridPlotWorld.PLOT_HEIGHT + 1), pos2.withY(getWorldHeight()), BlockTypes.AIR.getDefaultState());
|
||||
queue.setBiomeCuboid(pos1, pos2, biome);
|
||||
} else {
|
||||
queue.setRegenRegion(new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()));
|
||||
|
||||
@ -79,7 +79,6 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
public int SCHEM_Y;
|
||||
private Location SIGN_LOCATION;
|
||||
private File root = null;
|
||||
private int lastOverlayHeightError = Integer.MIN_VALUE;
|
||||
|
||||
@Inject
|
||||
private SchematicHandler schematicHandler;
|
||||
@ -172,9 +171,9 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
public void loadConfiguration(ConfigurationSection config) {
|
||||
super.loadConfiguration(config);
|
||||
if ((this.ROAD_WIDTH & 1) == 0) {
|
||||
this.PATH_WIDTH_LOWER = (short) (Math.floor(this.ROAD_WIDTH / 2f) - 1);
|
||||
this.PATH_WIDTH_LOWER = (short) (Math.floor(this.ROAD_WIDTH / 2) - 1);
|
||||
} else {
|
||||
this.PATH_WIDTH_LOWER = (short) Math.floor(this.ROAD_WIDTH / 2f);
|
||||
this.PATH_WIDTH_LOWER = (short) Math.floor(this.ROAD_WIDTH / 2);
|
||||
}
|
||||
if (this.ROAD_WIDTH == 0) {
|
||||
this.PATH_WIDTH_UPPER = (short) (this.SIZE + 1);
|
||||
@ -252,34 +251,31 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
Schematic schematic2 = this.schematicHandler.getSchematic(schematic2File);
|
||||
Schematic schematic3 = this.schematicHandler.getSchematic(schematic3File);
|
||||
int shift = this.ROAD_WIDTH / 2;
|
||||
int oddshift = (this.ROAD_WIDTH & 1);
|
||||
int oddshift = (this.ROAD_WIDTH & 1) == 0 ? 0 : 1;
|
||||
|
||||
SCHEM_Y = schematicStartHeight();
|
||||
int plotY = PLOT_HEIGHT - SCHEM_Y;
|
||||
int minRoadWall = Settings.Schematics.USE_WALL_IN_ROAD_SCHEM_HEIGHT ? Math.min(ROAD_HEIGHT, WALL_HEIGHT) : ROAD_HEIGHT;
|
||||
int roadY = minRoadWall - SCHEM_Y;
|
||||
|
||||
int worldHeight = getMaxGenHeight() - getMinGenHeight() + 1;
|
||||
|
||||
// SCHEM_Y should be normalised to the plot "start" height
|
||||
if (schematic3 != null) {
|
||||
if (schematic3.getClipboard().getDimensions().getY() == worldHeight) {
|
||||
if (schematic3.getClipboard().getDimensions().getY() == 256) {
|
||||
SCHEM_Y = plotY = 0;
|
||||
} else if (!Settings.Schematics.PASTE_ON_TOP) {
|
||||
SCHEM_Y = plotY = getMinBuildHeight() - getMinGenHeight();
|
||||
SCHEM_Y = plotY = getMinBuildHeight();
|
||||
}
|
||||
}
|
||||
|
||||
if (schematic1 != null) {
|
||||
if (schematic1.getClipboard().getDimensions().getY() == worldHeight) {
|
||||
SCHEM_Y = roadY = getMinGenHeight();
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
|
||||
if (schematic1.getClipboard().getDimensions().getY() == 256) {
|
||||
SCHEM_Y = roadY = 0;
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256
|
||||
&& !Settings.Schematics.PASTE_ON_TOP) {
|
||||
plotY = PLOT_HEIGHT;
|
||||
}
|
||||
} else if (!Settings.Schematics.PASTE_ROAD_ON_TOP) {
|
||||
SCHEM_Y = roadY = getMinBuildHeight();
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256
|
||||
&& !Settings.Schematics.PASTE_ON_TOP) {
|
||||
plotY = PLOT_HEIGHT;
|
||||
}
|
||||
@ -432,10 +428,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
int pair = MathMan.pair(x, z);
|
||||
BaseBlock[] existing = this.G_SCH.computeIfAbsent(pair, k -> new BaseBlock[height]);
|
||||
if (y >= height) {
|
||||
if (y != lastOverlayHeightError) {
|
||||
lastOverlayHeightError = y;
|
||||
LOGGER.error(String.format("Error adding overlay block. `y > height`. y=%s, height=%s", y, height));
|
||||
}
|
||||
LOGGER.error("Error adding overlay block. `y > height`");
|
||||
return;
|
||||
}
|
||||
existing[y] = id;
|
||||
|
||||
@ -65,7 +65,6 @@ import com.sk89q.worldedit.world.block.BlockTypes;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.ArrayDeque;
|
||||
@ -74,7 +73,6 @@ import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
@ -87,9 +85,7 @@ public class HybridUtils {
|
||||
public static HybridUtils manager;
|
||||
public static Set<BlockVector2> regions;
|
||||
public static int height;
|
||||
// Use ordered for reasonable chunk loading order to reduce paper unloading neighbour chunks and then us attempting to load
|
||||
// them again, causing errors
|
||||
public static Set<BlockVector2> chunks = new LinkedHashSet<>();
|
||||
public static Set<BlockVector2> chunks = new HashSet<>();
|
||||
public static PlotArea area;
|
||||
public static boolean UPDATE = false;
|
||||
|
||||
@ -149,8 +145,6 @@ public class HybridUtils {
|
||||
final int ctz = tz >> 4;
|
||||
final int width = tx - bx + 1;
|
||||
final int length = tz - bz + 1;
|
||||
final int height = area.getMaxGenHeight() - area.getMinGenHeight() + 1;
|
||||
final int minHeight = area.getMinGenHeight();
|
||||
|
||||
final PlotArea area = this.plotAreaManager.getPlotArea(world, null);
|
||||
|
||||
@ -163,7 +157,7 @@ public class HybridUtils {
|
||||
|
||||
final BlockState airBlock = BlockTypes.AIR.getDefaultState();
|
||||
final BlockState[][][] oldBlocks = chunk.getBlocks();
|
||||
final BlockState[][][] newBlocks = new BlockState[height][width][length];
|
||||
final BlockState[][][] newBlocks = new BlockState[256][width][length];
|
||||
for (final BlockState[][] newBlock : newBlocks) {
|
||||
for (final BlockState[] blockStates : newBlock) {
|
||||
Arrays.fill(blockStates, airBlock);
|
||||
@ -217,12 +211,11 @@ public class HybridUtils {
|
||||
int xx = chunkBlockX + x;
|
||||
for (int z = minZ; z <= maxZ; z++) {
|
||||
int zz = chunkBlockZ + z;
|
||||
for (int yIndex = 0; yIndex < height; yIndex++) {
|
||||
int y = yIndex + minHeight;
|
||||
for (int y = 0; y < 256; y++) {
|
||||
BlockState block = queue.getBlock(xx, y, zz);
|
||||
int xr = xb + x;
|
||||
int zr = zb + z;
|
||||
newBlocks[yIndex][xr][zr] = block;
|
||||
newBlocks[y][xr][zr] = block;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -239,10 +232,10 @@ public class HybridUtils {
|
||||
for (int x = 0; x < width; x++) {
|
||||
for (int z = 0; z < length; z++) {
|
||||
Set<BlockType> types = new HashSet<>();
|
||||
for (int yIndex = 0; yIndex < height; yIndex++) {
|
||||
BlockState old = oldBlocks[yIndex][x][z];
|
||||
for (int y = 0; y < 256; y++) {
|
||||
BlockState old = oldBlocks[y][x][z];
|
||||
try {
|
||||
BlockState now = newBlocks[yIndex][x][z];
|
||||
BlockState now = newBlocks[y][x][z];
|
||||
if (!old.equals(now)) {
|
||||
changes[i]++;
|
||||
}
|
||||
@ -251,23 +244,23 @@ public class HybridUtils {
|
||||
} else {
|
||||
// check vertices
|
||||
// modifications_adjacent
|
||||
if (x > 0 && z > 0 && yIndex > 0 && x < width - 1 && z < length - 1 && yIndex < (height - 1)) {
|
||||
if (newBlocks[yIndex - 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
if (x > 0 && z > 0 && y > 0 && x < width - 1 && z < length - 1 && y < 255) {
|
||||
if (newBlocks[y - 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[yIndex][x - 1][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[y][x - 1][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[yIndex][x][z - 1].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[y][x][z - 1].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[yIndex + 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[y + 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[yIndex][x + 1][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[y][x + 1][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[yIndex][x][z + 1].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[y][x][z + 1].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
}
|
||||
@ -415,7 +408,7 @@ public class HybridUtils {
|
||||
}
|
||||
HybridUtils.UPDATE = true;
|
||||
Set<BlockVector2> regions = this.worldUtil.getChunkChunks(area.getWorldName());
|
||||
return scheduleRoadUpdate(area, regions, extend, new LinkedHashSet<>());
|
||||
return scheduleRoadUpdate(area, regions, extend, new HashSet<>());
|
||||
}
|
||||
|
||||
public boolean scheduleSingleRegionRoadUpdate(Plot plot, int extend) {
|
||||
@ -425,7 +418,7 @@ public class HybridUtils {
|
||||
HybridUtils.UPDATE = true;
|
||||
Set<BlockVector2> regions = new HashSet<>();
|
||||
regions.add(RegionManager.getRegion(plot.getCenterSynchronous()));
|
||||
return scheduleRoadUpdate(plot.getArea(), regions, extend, new LinkedHashSet<>());
|
||||
return scheduleRoadUpdate(plot.getArea(), regions, extend, new HashSet<>());
|
||||
}
|
||||
|
||||
public boolean scheduleRoadUpdate(
|
||||
@ -438,29 +431,26 @@ public class HybridUtils {
|
||||
HybridUtils.area = area;
|
||||
HybridUtils.height = extend;
|
||||
HybridUtils.chunks = chunks;
|
||||
final int initial = 1024 * regions.size() + chunks.size();
|
||||
final AtomicInteger count = new AtomicInteger(0);
|
||||
TaskManager.runTask(new Runnable() {
|
||||
@Override
|
||||
public void run() {
|
||||
if (!UPDATE) {
|
||||
Iterator<BlockVector2> iter = chunks.iterator();
|
||||
QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(area.getWorldName()));
|
||||
while (iter.hasNext()) {
|
||||
BlockVector2 chunk = iter.next();
|
||||
iter.remove();
|
||||
boolean regenedRoad = regenerateRoad(area, chunk, extend, queue);
|
||||
boolean regenedRoad = regenerateRoad(area, chunk, extend);
|
||||
if (!regenedRoad) {
|
||||
LOGGER.info("Failed to regenerate roads in chunk {}", chunk);
|
||||
LOGGER.info("Failed to regenerate roads");
|
||||
}
|
||||
}
|
||||
queue.enqueue();
|
||||
LOGGER.info("Cancelled road task");
|
||||
return;
|
||||
}
|
||||
count.incrementAndGet();
|
||||
if (count.intValue() % 10 == 0) {
|
||||
LOGGER.info("Progress: {}%", 100 * (initial - (chunks.size() + 1024 * regions.size())) / initial);
|
||||
if (count.intValue() % 20 == 0) {
|
||||
LOGGER.info("Progress: {}%", 100 * (2048 - chunks.size()) / 2048);
|
||||
}
|
||||
if (HybridUtils.regions.isEmpty() && chunks.isEmpty()) {
|
||||
regeneratePlotWalls(area);
|
||||
@ -472,7 +462,7 @@ public class HybridUtils {
|
||||
final Runnable task = this;
|
||||
TaskManager.runTaskAsync(() -> {
|
||||
try {
|
||||
if (chunks.size() < 64) {
|
||||
if (chunks.size() < 1024) {
|
||||
if (!HybridUtils.regions.isEmpty()) {
|
||||
Iterator<BlockVector2> iterator = HybridUtils.regions.iterator();
|
||||
BlockVector2 loc = iterator.next();
|
||||
@ -485,35 +475,18 @@ public class HybridUtils {
|
||||
}
|
||||
if (!chunks.isEmpty()) {
|
||||
TaskManager.getPlatformImplementation().sync(() -> {
|
||||
long start = System.currentTimeMillis();
|
||||
Iterator<BlockVector2> iterator = chunks.iterator();
|
||||
if (chunks.size() >= 32) {
|
||||
QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(area.getWorldName()));
|
||||
for (int i = 0; i < 32; i++) {
|
||||
final BlockVector2 chunk = iterator.next();
|
||||
iterator.remove();
|
||||
boolean regenedRoads = regenerateRoad(area, chunk, extend, queue);
|
||||
if (!regenedRoads) {
|
||||
LOGGER.info("Failed to regenerate the road in chunk {}", chunk);
|
||||
}
|
||||
}
|
||||
queue.setCompleteTask(task);
|
||||
queue.enqueue();
|
||||
return null;
|
||||
}
|
||||
QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(area.getWorldName()));
|
||||
while (!chunks.isEmpty()) {
|
||||
while (System.currentTimeMillis() - start < 20 && !chunks.isEmpty()) {
|
||||
final BlockVector2 chunk = iterator.next();
|
||||
iterator.remove();
|
||||
boolean regenedRoads = regenerateRoad(area, chunk, extend, queue);
|
||||
boolean regenedRoads = regenerateRoad(area, chunk, extend);
|
||||
if (!regenedRoads) {
|
||||
LOGGER.info("Failed to regenerate road in chunk {}", chunk);
|
||||
LOGGER.info("Failed to regenerate road");
|
||||
}
|
||||
}
|
||||
queue.setCompleteTask(task);
|
||||
queue.enqueue();
|
||||
return null;
|
||||
});
|
||||
return;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
@ -541,6 +514,7 @@ public class HybridUtils {
|
||||
Location bot = plot.getBottomAbs().subtract(1, 0, 1);
|
||||
Location top = plot.getTopAbs();
|
||||
final HybridPlotWorld plotworld = (HybridPlotWorld) plot.getArea();
|
||||
PlotManager plotManager = plotworld.getPlotManager();
|
||||
// Do not use plotworld#schematicStartHeight() here as we want to restore the pre 6.1.4 way of doing it if
|
||||
// USE_WALL_IN_ROAD_SCHEM_HEIGHT is false
|
||||
int schemY = Settings.Schematics.USE_WALL_IN_ROAD_SCHEM_HEIGHT ?
|
||||
@ -550,10 +524,10 @@ public class HybridUtils {
|
||||
int sy = Settings.Schematics.PASTE_ROAD_ON_TOP ? schemY : plot.getArea().getMinBuildHeight();
|
||||
int ex = bot.getX();
|
||||
int ez = top.getZ();
|
||||
int ey = get_ey(plotworld, queue, sx, ex, sz, ez, sy);
|
||||
int ey = get_ey(plotManager, queue, sx, ex, sz, ez, sy);
|
||||
int bz = sz - plotworld.ROAD_WIDTH;
|
||||
int tz = sz - 1;
|
||||
int ty = get_ey(plotworld, queue, sx, ex, bz, tz, sy);
|
||||
int ty = get_ey(plotManager, queue, sx, ex, bz, tz, sy);
|
||||
|
||||
final Set<CuboidRegion> sideRoad = Collections.singleton(RegionUtil.createRegion(sx, ex, sy, ey, sz, ez));
|
||||
final Set<CuboidRegion> intersection = Collections.singleton(RegionUtil.createRegion(sx, ex, sy, ty, bz, tz));
|
||||
@ -579,11 +553,11 @@ public class HybridUtils {
|
||||
return true;
|
||||
}
|
||||
|
||||
private int get_ey(final HybridPlotWorld hpw, QueueCoordinator queue, int sx, int ex, int sz, int ez, int sy) {
|
||||
public int get_ey(final PlotManager pm, QueueCoordinator queue, int sx, int ex, int sz, int ez, int sy) {
|
||||
int ey = sy;
|
||||
for (int x = sx; x <= ex; x++) {
|
||||
for (int z = sz; z <= ez; z++) {
|
||||
for (int y = sy; y <= hpw.getMaxGenHeight(); y++) {
|
||||
for (int y = sy; y <= pm.getWorldHeight(); y++) {
|
||||
if (y > ey) {
|
||||
BlockState block = queue.getBlock(x, y, z);
|
||||
if (!block.getBlockType().getMaterial().isAir()) {
|
||||
@ -596,36 +570,7 @@ public class HybridUtils {
|
||||
return ey;
|
||||
}
|
||||
|
||||
/**
|
||||
* Regenerate the road in a chunk in a plot area.
|
||||
*
|
||||
* @param area Plot area to regenerate road for
|
||||
* @param chunk Chunk location to regenerate
|
||||
* @param extend How far to extend setting air above the road
|
||||
* @return if successful
|
||||
* @deprecated use {@link HybridUtils#regenerateRoad(PlotArea, BlockVector2, int, QueueCoordinator)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public boolean regenerateRoad(final PlotArea area, final BlockVector2 chunk, int extend) {
|
||||
return regenerateRoad(area, chunk, extend, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Regenerate the road in a chunk in a plot area.
|
||||
*
|
||||
* @param area Plot area to regenerate road for
|
||||
* @param chunk Chunk location to regenerate
|
||||
* @param extend How far to extend setting air above the road
|
||||
* @param queueCoordinator {@link QueueCoordinator} to use to set the blocks. Null if one should be created and enqueued
|
||||
* @return if successful
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public boolean regenerateRoad(
|
||||
final PlotArea area,
|
||||
final BlockVector2 chunk,
|
||||
int extend,
|
||||
@Nullable QueueCoordinator queueCoordinator
|
||||
) {
|
||||
int x = chunk.getX() << 4;
|
||||
int z = chunk.getZ() << 4;
|
||||
int ex = x + 15;
|
||||
@ -651,100 +596,92 @@ public class HybridUtils {
|
||||
z -= plotWorld.ROAD_OFFSET_Z;
|
||||
final int finalX = x;
|
||||
final int finalZ = z;
|
||||
final boolean enqueue;
|
||||
final QueueCoordinator queue;
|
||||
if (queueCoordinator == null) {
|
||||
queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()));
|
||||
enqueue = true;
|
||||
} else {
|
||||
queue = queueCoordinator;
|
||||
enqueue = false;
|
||||
}
|
||||
QueueCoordinator queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()));
|
||||
if (id1 == null || id2 == null || id1 != id2) {
|
||||
if (id1 != null) {
|
||||
Plot p1 = area.getPlotAbs(id1);
|
||||
if (p1 != null && p1.hasOwner() && p1.isMerged()) {
|
||||
toCheck.set(true);
|
||||
this.chunkManager.loadChunk(area.getWorldName(), chunk, false).thenRun(() -> {
|
||||
if (id1 != null) {
|
||||
Plot p1 = area.getPlotAbs(id1);
|
||||
if (p1 != null && p1.hasOwner() && p1.isMerged()) {
|
||||
toCheck.set(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (id2 != null && !toCheck.get()) {
|
||||
Plot p2 = area.getPlotAbs(id2);
|
||||
if (p2 != null && p2.hasOwner() && p2.isMerged()) {
|
||||
toCheck.set(true);
|
||||
if (id2 != null && !toCheck.get()) {
|
||||
Plot p2 = area.getPlotAbs(id2);
|
||||
if (p2 != null && p2.hasOwner() && p2.isMerged()) {
|
||||
toCheck.set(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
short size = plotWorld.SIZE;
|
||||
for (int X = 0; X < 16; X++) {
|
||||
short absX = (short) ((finalX + X) % size);
|
||||
for (int Z = 0; Z < 16; Z++) {
|
||||
short absZ = (short) ((finalZ + Z) % size);
|
||||
if (absX < 0) {
|
||||
absX += size;
|
||||
}
|
||||
if (absZ < 0) {
|
||||
absZ += size;
|
||||
}
|
||||
boolean condition;
|
||||
if (toCheck.get()) {
|
||||
condition = manager.getPlotId(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
1,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z
|
||||
) == null;
|
||||
} else {
|
||||
boolean gx = absX > plotWorld.PATH_WIDTH_LOWER;
|
||||
boolean gz = absZ > plotWorld.PATH_WIDTH_LOWER;
|
||||
boolean lx = absX < plotWorld.PATH_WIDTH_UPPER;
|
||||
boolean lz = absZ < plotWorld.PATH_WIDTH_UPPER;
|
||||
condition = !gx || !gz || !lx || !lz;
|
||||
}
|
||||
if (condition) {
|
||||
BaseBlock[] blocks = plotWorld.G_SCH.get(MathMan.pair(absX, absZ));
|
||||
int minY = Settings.Schematics.PASTE_ROAD_ON_TOP ? plotWorld.SCHEM_Y : area.getMinGenHeight() + 1;
|
||||
int maxDy = Math.max(extend, blocks.length);
|
||||
for (int dy = 0; dy < maxDy; dy++) {
|
||||
if (dy > blocks.length - 1) {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + dy,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
WEExtent.AIRBASE
|
||||
);
|
||||
} else {
|
||||
BaseBlock block = blocks[dy];
|
||||
if (block != null) {
|
||||
int size = plotWorld.SIZE;
|
||||
for (int X = 0; X < 16; X++) {
|
||||
short absX = (short) ((finalX + X) % size);
|
||||
for (int Z = 0; Z < 16; Z++) {
|
||||
short absZ = (short) ((finalZ + Z) % size);
|
||||
if (absX < 0) {
|
||||
absX += size;
|
||||
}
|
||||
if (absZ < 0) {
|
||||
absZ += size;
|
||||
}
|
||||
boolean condition;
|
||||
if (toCheck.get()) {
|
||||
condition = manager.getPlotId(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
1,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z
|
||||
) == null;
|
||||
} else {
|
||||
boolean gx = absX > plotWorld.PATH_WIDTH_LOWER;
|
||||
boolean gz = absZ > plotWorld.PATH_WIDTH_LOWER;
|
||||
boolean lx = absX < plotWorld.PATH_WIDTH_UPPER;
|
||||
boolean lz = absZ < plotWorld.PATH_WIDTH_UPPER;
|
||||
condition = !gx || !gz || !lx || !lz;
|
||||
}
|
||||
if (condition) {
|
||||
BaseBlock[] blocks = plotWorld.G_SCH.get(MathMan.pair(absX, absZ));
|
||||
int minY = Settings.Schematics.PASTE_ROAD_ON_TOP ? plotWorld.SCHEM_Y : 1;
|
||||
int maxY = Math.max(extend, blocks.length);
|
||||
for (int y = 0; y < maxY; y++) {
|
||||
if (y > blocks.length - 1) {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + dy,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
block
|
||||
);
|
||||
} else {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + dy,
|
||||
minY + y,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
WEExtent.AIRBASE
|
||||
);
|
||||
} else {
|
||||
BaseBlock block = blocks[y];
|
||||
if (block != null) {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + y,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
block
|
||||
);
|
||||
} else {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + y,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
WEExtent.AIRBASE
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
BiomeType biome = plotWorld.G_SCH_B.get(MathMan.pair(absX, absZ));
|
||||
if (biome != null) {
|
||||
queue.setBiome(finalX + X + plotWorld.ROAD_OFFSET_X, finalZ + Z + plotWorld.ROAD_OFFSET_Z, biome);
|
||||
} else {
|
||||
queue.setBiome(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
plotWorld.getPlotBiome()
|
||||
);
|
||||
BiomeType biome = plotWorld.G_SCH_B.get(MathMan.pair(absX, absZ));
|
||||
if (biome != null) {
|
||||
queue.setBiome(finalX + X + plotWorld.ROAD_OFFSET_X, finalZ + Z + plotWorld.ROAD_OFFSET_Z, biome);
|
||||
} else {
|
||||
queue.setBiome(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
plotWorld.getPlotBiome()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (enqueue) {
|
||||
queue.enqueue();
|
||||
}
|
||||
});
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
||||
@ -96,7 +96,7 @@ public abstract class SquarePlotManager extends GridPlotManager {
|
||||
.floor(squarePlotWorld.ROAD_WIDTH / 2) - 1;
|
||||
int z = (squarePlotWorld.ROAD_OFFSET_Z + (pz * (squarePlotWorld.ROAD_WIDTH + squarePlotWorld.PLOT_WIDTH))) - (int) Math
|
||||
.floor(squarePlotWorld.ROAD_WIDTH / 2) - 1;
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMaxGenHeight(), z);
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, Math.min(getWorldHeight(), 255), z);
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -260,7 +260,7 @@ public abstract class SquarePlotManager extends GridPlotManager {
|
||||
- (int) Math.floor(squarePlotWorld.ROAD_WIDTH / 2);
|
||||
int z = (squarePlotWorld.ROAD_OFFSET_Z + (pz * (squarePlotWorld.ROAD_WIDTH + squarePlotWorld.PLOT_WIDTH))) - squarePlotWorld.PLOT_WIDTH
|
||||
- (int) Math.floor(squarePlotWorld.ROAD_WIDTH / 2);
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMinGenHeight(), z);
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMinBuildHeight(), z);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -309,7 +309,7 @@ public class PlotListener {
|
||||
}
|
||||
if ((lastPlot != null) && plot.getId().equals(lastPlot.getId()) && plot.hasOwner()) {
|
||||
final UUID plotOwner = plot.getOwnerAbs();
|
||||
String owner = PlayerManager.resolveName(plotOwner, true).getComponent(player);
|
||||
String owner = PlayerManager.resolveName(plotOwner, false).getComponent(player);
|
||||
Caption header = fromFlag ? StaticCaption.of(title) : TranslatableCaption.of("titles" +
|
||||
".title_entered_plot");
|
||||
Caption subHeader = fromFlag ? StaticCaption.of(subtitle) : TranslatableCaption.of("titles" +
|
||||
|
||||
@ -35,7 +35,6 @@ import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import com.plotsquared.core.util.WEManager;
|
||||
import com.plotsquared.core.util.WorldUtil;
|
||||
import com.sk89q.worldedit.EditSession;
|
||||
import com.sk89q.worldedit.WorldEdit;
|
||||
import com.sk89q.worldedit.entity.Player;
|
||||
import com.sk89q.worldedit.event.extent.EditSessionEvent;
|
||||
@ -68,9 +67,6 @@ public class WESubscriber {
|
||||
WorldEdit.getInstance().getEventBus().unregister(this);
|
||||
return;
|
||||
}
|
||||
if (event.getStage() != EditSession.Stage.BEFORE_HISTORY) {
|
||||
return;
|
||||
}
|
||||
World worldObj = event.getWorld();
|
||||
if (worldObj == null) {
|
||||
return;
|
||||
|
||||
@ -58,21 +58,6 @@ public interface World<T> {
|
||||
*/
|
||||
@NonNull String getName();
|
||||
|
||||
/**
|
||||
* Get the min world height. Inclusive.
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
int getMinHeight();
|
||||
|
||||
|
||||
/**
|
||||
* Get the max world height. Inclusive.
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
int getMaxHeight();
|
||||
|
||||
class NullWorld<T> implements World<T> {
|
||||
|
||||
private NullWorld() {
|
||||
@ -89,16 +74,6 @@ public interface World<T> {
|
||||
return "";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMinHeight() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getMaxHeight() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object obj) {
|
||||
return obj instanceof NullWorld;
|
||||
|
||||
@ -122,7 +122,7 @@ import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE;
|
||||
*/
|
||||
public class Plot {
|
||||
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
|
||||
public static final int MAX_HEIGHT = 256;
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + Plot.class.getSimpleName());
|
||||
@ -1371,7 +1371,7 @@ public class Plot {
|
||||
int z = largest.getMinimumPoint().getZ() - 1;
|
||||
PlotManager manager = getManager();
|
||||
int y = isLoaded() ? this.worldUtil.getHighestBlockSynchronous(getWorldName(), x, z) : 62;
|
||||
if (area.allowSigns() && (y <= area.getMinGenHeight() || y >= area.getMaxGenHeight())) {
|
||||
if (area.allowSigns() && (y <= 0 || y >= 255)) {
|
||||
y = Math.max(y, manager.getSignLoc(this).getY() - 1);
|
||||
}
|
||||
return Location.at(getWorldName(), x, y + 1, z);
|
||||
@ -1387,7 +1387,7 @@ public class Plot {
|
||||
if (isLoaded()) {
|
||||
this.worldUtil.getHighestBlock(getWorldName(), x, z, y -> {
|
||||
int height = y;
|
||||
if (area.allowSigns() && (y <= area.getMinGenHeight() || y >= area.getMaxGenHeight())) {
|
||||
if (area.allowSigns() && (y <= 0 || y >= 255)) {
|
||||
height = Math.max(y, manager.getSignLoc(this).getY() - 1);
|
||||
}
|
||||
result.accept(Location.at(getWorldName(), x, height + 1, z));
|
||||
@ -1465,7 +1465,7 @@ public class Plot {
|
||||
.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + home.getX(),
|
||||
home.getY(), // y is absolute
|
||||
bottom.getY() + home.getY(),
|
||||
bottom.getZ() + home.getZ(),
|
||||
home.getYaw(),
|
||||
home.getPitch()
|
||||
@ -1619,8 +1619,8 @@ public class Plot {
|
||||
public double getVolume() {
|
||||
double count = 0;
|
||||
for (CuboidRegion region : getRegions()) {
|
||||
// CuboidRegion#getArea is deprecated and we want to ensure use of correct height
|
||||
count += region.getLength() * region.getWidth() * (area.getMaxGenHeight() - area.getMinGenHeight() + 1);
|
||||
count += (region.getMaximumPoint().getX() - (double) region.getMinimumPoint().getX() + 1) * (
|
||||
region.getMaximumPoint().getZ() - (double) region.getMinimumPoint().getZ() + 1) * MAX_HEIGHT;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
@ -1738,6 +1738,7 @@ public class Plot {
|
||||
area.addPlot(this);
|
||||
updateWorldBorder();
|
||||
}
|
||||
this.getPlotModificationManager().setSign(player.getName());
|
||||
player.sendMessage(TranslatableCaption.of("working.claimed"), Template.of("plot", this.getId().toString()));
|
||||
if (teleport) {
|
||||
if (!auto && Settings.Teleport.ON_CLAIM) {
|
||||
@ -1785,7 +1786,6 @@ public class Plot {
|
||||
);
|
||||
}
|
||||
plotworld.getPlotManager().claimPlot(this, null);
|
||||
this.getPlotModificationManager().setSign(player.getName());
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -2438,8 +2438,8 @@ public class Plot {
|
||||
return regions_cache;
|
||||
}
|
||||
if (!this.isMerged()) {
|
||||
Location pos1 = this.getBottomAbs().withY(getArea().getMinBuildHeight());
|
||||
Location pos2 = this.getTopAbs().withY(getArea().getMaxBuildHeight());
|
||||
Location pos1 = this.getBottomAbs();
|
||||
Location pos2 = this.getTopAbs();
|
||||
connected_cache = Sets.newHashSet(this);
|
||||
CuboidRegion rg = new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3());
|
||||
regions_cache = Collections.singleton(rg);
|
||||
|
||||
@ -34,6 +34,8 @@ import com.plotsquared.core.configuration.ConfigurationNode;
|
||||
import com.plotsquared.core.configuration.ConfigurationSection;
|
||||
import com.plotsquared.core.configuration.ConfigurationUtil;
|
||||
import com.plotsquared.core.configuration.Settings;
|
||||
import com.plotsquared.core.configuration.caption.CaptionUtility;
|
||||
import com.plotsquared.core.configuration.caption.LocaleHolder;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.configuration.file.YamlConfiguration;
|
||||
import com.plotsquared.core.generator.GridPlotWorld;
|
||||
@ -52,6 +54,7 @@ import com.plotsquared.core.plot.flag.FlagParseException;
|
||||
import com.plotsquared.core.plot.flag.GlobalFlagContainer;
|
||||
import com.plotsquared.core.plot.flag.PlotFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.DoneFlag;
|
||||
import com.plotsquared.core.plot.flag.types.DoubleFlag;
|
||||
import com.plotsquared.core.queue.GlobalBlockQueue;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
@ -141,10 +144,8 @@ public abstract class PlotArea {
|
||||
private boolean homeAllowNonmember = false;
|
||||
private BlockLoc nonmemberHome;
|
||||
private BlockLoc defaultHome;
|
||||
private int maxBuildHeight = PlotSquared.platform().versionMaxHeight() + 1; // Exclusive
|
||||
private int minBuildHeight = PlotSquared.platform().versionMinHeight() + 1; // Inclusive
|
||||
private int maxGenHeight = PlotSquared.platform().versionMaxHeight(); // Inclusive
|
||||
private int minGenHeight = PlotSquared.platform().versionMinHeight(); // Inclusive
|
||||
private int maxBuildHeight = 256;
|
||||
private int minBuildHeight = 1;
|
||||
private GameMode gameMode = GameModes.CREATIVE;
|
||||
private Map<String, PlotExpression> prices = new HashMap<>();
|
||||
private List<String> schematics = new ArrayList<>();
|
||||
@ -360,8 +361,6 @@ public abstract class PlotArea {
|
||||
this.worldBorder = config.getBoolean("world.border");
|
||||
this.maxBuildHeight = config.getInt("world.max_height");
|
||||
this.minBuildHeight = config.getInt("world.min_height");
|
||||
this.minGenHeight = config.getInt("world.min_gen_height");
|
||||
this.maxGenHeight = config.getInt("world.max_gen_height");
|
||||
|
||||
switch (config.getString("world.gamemode").toLowerCase()) {
|
||||
case "creative", "c", "1" -> this.gameMode = GameModes.CREATIVE;
|
||||
@ -485,8 +484,6 @@ public abstract class PlotArea {
|
||||
options.put("home.nonmembers", position);
|
||||
options.put("world.max_height", this.getMaxBuildHeight());
|
||||
options.put("world.min_height", this.getMinBuildHeight());
|
||||
options.put("world.min_gen_height", this.getMinGenHeight());
|
||||
options.put("world.max_gen_height", this.getMaxGenHeight());
|
||||
options.put("world.gamemode", this.getGameMode().getName().toLowerCase());
|
||||
options.put("road.flags.default", null);
|
||||
|
||||
@ -1081,8 +1078,8 @@ public abstract class PlotArea {
|
||||
BlockVector2 pos1 = BlockVector2.at(value.getP1().getX(), value.getP1().getY());
|
||||
BlockVector2 pos2 = BlockVector2.at(value.getP2().getX(), value.getP2().getY());
|
||||
return new CuboidRegion(
|
||||
pos1.toBlockVector3(getMinGenHeight()),
|
||||
pos2.toBlockVector3(getMaxGenHeight())
|
||||
pos1.toBlockVector3(),
|
||||
pos2.toBlockVector3(Plot.MAX_HEIGHT - 1)
|
||||
);
|
||||
}
|
||||
};
|
||||
@ -1364,38 +1361,14 @@ public abstract class PlotArea {
|
||||
this.defaultHome = defaultHome;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the maximum height players may build in. Exclusive.
|
||||
*/
|
||||
public int getMaxBuildHeight() {
|
||||
return this.maxBuildHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the minimum height players may build in. Inclusive.
|
||||
*/
|
||||
public int getMinBuildHeight() {
|
||||
return this.minBuildHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the min height from which P2 will generate blocks. Inclusive.
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public int getMinGenHeight() {
|
||||
return this.minGenHeight;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max height to which P2 will generate blocks. Inclusive.
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public int getMaxGenHeight() {
|
||||
return this.maxGenHeight;
|
||||
}
|
||||
|
||||
public GameMode getGameMode() {
|
||||
return this.gameMode;
|
||||
}
|
||||
|
||||
@ -89,17 +89,11 @@ public class PlotCluster {
|
||||
}
|
||||
|
||||
private void setRegion() {
|
||||
this.region = RegionUtil.createRegion(this.pos1.getX(), this.pos2.getX(), 0, 0,
|
||||
this.region = RegionUtil.createRegion(this.pos1.getX(), this.pos2.getX(),
|
||||
this.pos1.getY(), this.pos2.getY()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a region of PlotIDs
|
||||
*
|
||||
* @deprecated - returns region of IDs, not of actual blocks.
|
||||
*/
|
||||
@Deprecated
|
||||
public CuboidRegion getRegion() {
|
||||
return this.region;
|
||||
}
|
||||
@ -171,7 +165,7 @@ public class PlotCluster {
|
||||
Consumer<Location> locationConsumer = toReturn ->
|
||||
PlotSquared.platform().worldUtil().getHighestBlock(this.area.getWorldName(), toReturn.getX(), toReturn.getZ(),
|
||||
highest -> {
|
||||
if (highest <= area.getMinBuildHeight()) {
|
||||
if (highest == 0) {
|
||||
highest = 63;
|
||||
}
|
||||
if (highest > toReturn.getY()) {
|
||||
@ -181,12 +175,12 @@ public class PlotCluster {
|
||||
}
|
||||
}
|
||||
);
|
||||
if (home.getY() == Integer.MIN_VALUE) {
|
||||
if (home.getY() == 0) {
|
||||
// default pos
|
||||
Plot center = getCenterPlot();
|
||||
center.getHome(location -> {
|
||||
Location toReturn = location;
|
||||
if (toReturn.getY() <= area.getMinBuildHeight()) {
|
||||
if (toReturn.getY() == 0) {
|
||||
PlotManager manager = this.area.getPlotManager();
|
||||
Location locationSign = manager.getSignLoc(center);
|
||||
toReturn = toReturn.withY(locationSign.getY());
|
||||
|
||||
@ -121,7 +121,7 @@ public class PlotInventory {
|
||||
* @param item the item to place
|
||||
* @return {@code true} if the item could be placed, otherwise {@code false}
|
||||
* @see InventoryUtil#setItemChecked(PlotInventory, int, PlotItemStack)
|
||||
* @since 6.5.0
|
||||
* @since TODO
|
||||
*/
|
||||
public boolean setItemChecked(int index, PlotItemStack item) {
|
||||
if (!this.inventoryUtil.setItemChecked(this, index, item)) {
|
||||
|
||||
@ -54,7 +54,7 @@ public class PlotItemStack {
|
||||
* @param amount Amount of items in the stack
|
||||
* @param name The display name of the item stack
|
||||
* @param lore The item stack lore
|
||||
* @since 6.5.0
|
||||
* @since TODO
|
||||
*/
|
||||
public PlotItemStack(
|
||||
final ItemType type, final int amount, final String name,
|
||||
|
||||
@ -69,6 +69,8 @@ import java.util.concurrent.CompletableFuture;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
import java.util.stream.Collectors;
|
||||
|
||||
import static com.plotsquared.core.plot.Plot.MAX_HEIGHT;
|
||||
|
||||
/**
|
||||
* Manager that handles {@link Plot} modifications
|
||||
*/
|
||||
@ -309,7 +311,7 @@ public final class PlotModificationManager {
|
||||
return;
|
||||
}
|
||||
CuboidRegion region = regions.poll();
|
||||
PlotSquared.platform().regionManager().setBiome(region, extendBiome, biome, plot.getArea(), this);
|
||||
PlotSquared.platform().regionManager().setBiome(region, extendBiome, biome, plot.getWorldName(), this);
|
||||
}
|
||||
};
|
||||
run.run();
|
||||
@ -333,9 +335,10 @@ public final class PlotModificationManager {
|
||||
ids.add(current.getId());
|
||||
}
|
||||
this.plot.clearRatings();
|
||||
QueueCoordinator queue = this.plot.getArea().getQueue();
|
||||
QueueCoordinator queue = null;
|
||||
if (createSign) {
|
||||
this.removeSign();
|
||||
queue = this.plot.getArea().getQueue();
|
||||
}
|
||||
PlotManager manager = this.plot.getArea().getPlotManager();
|
||||
if (createRoad) {
|
||||
@ -524,6 +527,28 @@ public final class PlotModificationManager {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the south road section of a plot<br>
|
||||
* - Used when a plot is merged<br>
|
||||
*
|
||||
* @param queue Nullable {@link QueueCoordinator}. If null, creates own queue and enqueues,
|
||||
* otherwise writes to the queue but does not enqueue.
|
||||
*/
|
||||
public void removeRoadSouth(final @Nullable QueueCoordinator queue) {
|
||||
if (this.plot.getArea().getType() != PlotAreaType.NORMAL && this.plot
|
||||
.getArea()
|
||||
.getTerrain() == PlotAreaTerrainType.ROAD) {
|
||||
Plot other = this.plot.getRelative(Direction.SOUTH);
|
||||
Location bot = other.getBottomAbs();
|
||||
Location top = this.plot.getTopAbs();
|
||||
Location pos1 = Location.at(this.plot.getWorldName(), bot.getX(), 0, top.getZ());
|
||||
Location pos2 = Location.at(this.plot.getWorldName(), top.getX(), MAX_HEIGHT, bot.getZ());
|
||||
PlotSquared.platform().regionManager().regenerateRegion(pos1, pos2, true, null);
|
||||
} else if (this.plot.getArea().getTerrain() != PlotAreaTerrainType.ALL) { // no road generated => no road to remove
|
||||
this.plot.getManager().removeRoadSouth(this.plot, queue);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Auto merge a plot in a specific direction.
|
||||
*
|
||||
@ -890,28 +915,6 @@ public final class PlotModificationManager {
|
||||
return this.setComponent(component, parsed.toPattern(), actor, queue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the south road section of a plot<br>
|
||||
* - Used when a plot is merged<br>
|
||||
*
|
||||
* @param queue Nullable {@link QueueCoordinator}. If null, creates own queue and enqueues,
|
||||
* otherwise writes to the queue but does not enqueue.
|
||||
*/
|
||||
public void removeRoadSouth(final @Nullable QueueCoordinator queue) {
|
||||
if (this.plot.getArea().getType() != PlotAreaType.NORMAL && this.plot
|
||||
.getArea()
|
||||
.getTerrain() == PlotAreaTerrainType.ROAD) {
|
||||
Plot other = this.plot.getRelative(Direction.SOUTH);
|
||||
Location bot = other.getBottomAbs();
|
||||
Location top = this.plot.getTopAbs();
|
||||
Location pos1 = Location.at(this.plot.getWorldName(), bot.getX(), plot.getArea().getMinGenHeight(), top.getZ());
|
||||
Location pos2 = Location.at(this.plot.getWorldName(), top.getX(), plot.getArea().getMaxGenHeight(), bot.getZ());
|
||||
PlotSquared.platform().regionManager().regenerateRegion(pos1, pos2, true, null);
|
||||
} else if (this.plot.getArea().getTerrain() != PlotAreaTerrainType.ALL) { // no road generated => no road to remove
|
||||
this.plot.getManager().removeRoadSouth(this.plot, queue);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Remove the east road section of a plot<br>
|
||||
* - Used when a plot is merged<br>
|
||||
@ -926,8 +929,8 @@ public final class PlotModificationManager {
|
||||
Plot other = this.plot.getRelative(Direction.EAST);
|
||||
Location bot = other.getBottomAbs();
|
||||
Location top = this.plot.getTopAbs();
|
||||
Location pos1 = Location.at(this.plot.getWorldName(), top.getX(), plot.getArea().getMinGenHeight(), bot.getZ());
|
||||
Location pos2 = Location.at(this.plot.getWorldName(), bot.getX(), plot.getArea().getMaxGenHeight(), top.getZ());
|
||||
Location pos1 = Location.at(this.plot.getWorldName(), top.getX(), 0, bot.getZ());
|
||||
Location pos2 = Location.at(this.plot.getWorldName(), bot.getX(), MAX_HEIGHT, top.getZ());
|
||||
PlotSquared.platform().regionManager().regenerateRegion(pos1, pos2, true, null);
|
||||
} else if (this.plot.getArea().getTerrain() != PlotAreaTerrainType.ALL) { // no road generated => no road to remove
|
||||
this.plot.getArea().getPlotManager().removeRoadEast(this.plot, queue);
|
||||
@ -945,8 +948,8 @@ public final class PlotModificationManager {
|
||||
.getArea()
|
||||
.getTerrain() == PlotAreaTerrainType.ROAD) {
|
||||
Plot other = this.plot.getRelative(1, 1);
|
||||
Location pos1 = this.plot.getTopAbs().add(1, 0, 1);
|
||||
Location pos2 = other.getBottomAbs().subtract(1, 0, 1);
|
||||
Location pos1 = this.plot.getTopAbs().add(1, 0, 1).withY(0);
|
||||
Location pos2 = other.getBottomAbs().subtract(1, 0, 1).withY(MAX_HEIGHT);
|
||||
PlotSquared.platform().regionManager().regenerateRegion(pos1, pos2, true, null);
|
||||
} else if (this.plot.getArea().getTerrain() != PlotAreaTerrainType.ALL) { // no road generated => no road to remove
|
||||
this.plot.getArea().getPlotManager().removeRoadSouthEast(this.plot, queue);
|
||||
|
||||
@ -105,29 +105,31 @@ public abstract class PlotWorld {
|
||||
return this.world;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
if (o == this) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
if (!(o instanceof final PlotWorld other)) {
|
||||
return false;
|
||||
}
|
||||
final PlotWorld plotWorld = (PlotWorld) o;
|
||||
return world.equals(plotWorld.world);
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$world = this.getWorld();
|
||||
final Object other$world = other.getWorld();
|
||||
return Objects.equals(this$world, other$world);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return world.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotWorld;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $world = this.getWorld();
|
||||
result = result * PRIME + ($world == null ? 43 : $world.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -136,18 +136,18 @@ public class ExpireManager {
|
||||
}
|
||||
|
||||
public void confirmExpiry(final PlotPlayer<?> pp) {
|
||||
TaskManager.runTask(() -> {
|
||||
try (final MetaDataAccess<Boolean> metaDataAccess = pp.accessTemporaryMetaData(
|
||||
PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
|
||||
if (metaDataAccess.isPresent()) {
|
||||
return;
|
||||
}
|
||||
if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
|
||||
final int num = plotsToDelete.size();
|
||||
while (!plotsToDelete.isEmpty()) {
|
||||
Iterator<Plot> iter = plotsToDelete.iterator();
|
||||
final Plot current = iter.next();
|
||||
if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
|
||||
try (final MetaDataAccess<Boolean> metaDataAccess = pp.accessTemporaryMetaData(
|
||||
PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
|
||||
if (metaDataAccess.isPresent()) {
|
||||
return;
|
||||
}
|
||||
if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
|
||||
final int num = plotsToDelete.size();
|
||||
while (!plotsToDelete.isEmpty()) {
|
||||
Iterator<Plot> iter = plotsToDelete.iterator();
|
||||
final Plot current = iter.next();
|
||||
if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
|
||||
TaskManager.runTask(() -> {
|
||||
metaDataAccess.set(true);
|
||||
current.getCenter(pp::teleport);
|
||||
metaDataAccess.remove();
|
||||
@ -171,15 +171,15 @@ public class ExpireManager {
|
||||
cmd_keep,
|
||||
cmd_no_show_expir
|
||||
);
|
||||
return;
|
||||
} else {
|
||||
iter.remove();
|
||||
}
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
iter.remove();
|
||||
}
|
||||
plotsToDelete.clear();
|
||||
}
|
||||
plotsToDelete.clear();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -307,7 +307,6 @@ public class ExpireManager {
|
||||
this.running = 2;
|
||||
TaskManager.runTaskAsync(new Runnable() {
|
||||
private ConcurrentLinkedDeque<Plot> plots = null;
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
final Runnable task = this;
|
||||
|
||||
@ -371,31 +371,33 @@ public class FlagContainer {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
if (o == this) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
if (!(o instanceof final FlagContainer other)) {
|
||||
return false;
|
||||
}
|
||||
final FlagContainer that = (FlagContainer) o;
|
||||
return flagMap.equals(that.flagMap);
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$flagMap = this.getFlagMap();
|
||||
final Object other$flagMap = other.getFlagMap();
|
||||
return Objects.equals(this$flagMap, other$flagMap);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return flagMap.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof FlagContainer;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $flagMap = this.getFlagMap();
|
||||
result = result * PRIME + ($flagMap == null ? 43 : $flagMap.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update event types used in {@link PlotFlagUpdateHandler}.
|
||||
*/
|
||||
|
||||
@ -93,7 +93,6 @@ import com.plotsquared.core.plot.flag.implementations.PlayerInteractFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PlotTitleFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PreventCreativeCopyFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PriceFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.ProjectilesFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PveFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PvpFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.RedstoneFlag;
|
||||
@ -199,7 +198,6 @@ public final class GlobalFlagContainer extends FlagContainer {
|
||||
this.addFlag(VehicleUseFlag.VEHICLE_USE_FALSE);
|
||||
this.addFlag(VillagerInteractFlag.VILLAGER_INTERACT_FALSE);
|
||||
this.addFlag(VineGrowFlag.VINE_GROW_TRUE);
|
||||
this.addFlag(ProjectilesFlag.PROJECTILES_FALSE);
|
||||
|
||||
// Double flags
|
||||
this.addFlag(PriceFlag.PRICE_NOT_BUYABLE);
|
||||
|
||||
@ -31,7 +31,6 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* A plot flag is any property that can be assigned
|
||||
@ -201,30 +200,34 @@ public abstract class PlotFlag<T, F extends PlotFlag<T, F>> {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
if (o == this) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
if (!(o instanceof final PlotFlag<?, ?> other)) {
|
||||
return false;
|
||||
}
|
||||
final PlotFlag<?, ?> plotFlag = (PlotFlag<?, ?>) o;
|
||||
return value.equals(plotFlag.value);
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$value = this.getValue();
|
||||
final Object other$value = other.getValue();
|
||||
if (this$value == null ? other$value != null : !this$value.equals(other$value)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return value.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotFlag;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $value = this.getValue();
|
||||
result = result * PRIME + ($value == null ? 43 : $value.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -1,46 +0,0 @@
|
||||
/*
|
||||
* _____ _ _ _____ _
|
||||
* | __ \| | | | / ____| | |
|
||||
* | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
|
||||
* | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
|
||||
* | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
|
||||
* |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
|
||||
* | |
|
||||
* |_|
|
||||
* PlotSquared plot management system for Minecraft
|
||||
* Copyright (C) 2014 - 2022 IntellectualSites
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
package com.plotsquared.core.plot.flag.implementations;
|
||||
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.plot.flag.types.BooleanFlag;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
public class ProjectilesFlag extends BooleanFlag<ProjectilesFlag> {
|
||||
|
||||
public static final ProjectilesFlag PROJECTILES_TRUE = new ProjectilesFlag(true);
|
||||
public static final ProjectilesFlag PROJECTILES_FALSE = new ProjectilesFlag(false);
|
||||
|
||||
private ProjectilesFlag(boolean value){
|
||||
super(value, TranslatableCaption.of("flags.flag_description_projectiles"));
|
||||
}
|
||||
|
||||
@Override
|
||||
protected ProjectilesFlag flagOf(@NonNull final Boolean value) {
|
||||
return value ? PROJECTILES_TRUE : PROJECTILES_FALSE;
|
||||
}
|
||||
|
||||
}
|
||||
@ -101,7 +101,7 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BaseBlock id) {
|
||||
if ((y > world.getMaxY()) || (y < world.getMinY())) {
|
||||
if ((y > 255) || (y < 0)) {
|
||||
return false;
|
||||
}
|
||||
LocalChunk chunk = getChunk(x >> 4, z >> 4);
|
||||
@ -121,7 +121,7 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biomeType) {
|
||||
LocalChunk chunk = getChunk(x >> 4, z >> 4);
|
||||
for (int y = world.getMinY(); y <= world.getMaxY(); y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
chunk.setBiome(x & 15, y, z & 15, biomeType);
|
||||
}
|
||||
settingBiomes = true;
|
||||
|
||||
@ -54,12 +54,12 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
@NonNull BlockVector3 top,
|
||||
boolean biomes
|
||||
) {
|
||||
super(null, Location.at("", 0, weWorld.getMinY(), 0), Location.at("", 15, weWorld.getMaxY(), 15));
|
||||
super(null, Location.at("", 0, 0, 0), Location.at("", 15, 255, 15));
|
||||
this.weWorld = weWorld;
|
||||
this.width = top.getX() - bot.getX() + 1;
|
||||
this.length = top.getZ() - bot.getZ() + 1;
|
||||
this.result = new BlockState[weWorld.getMaxY() - weWorld.getMinY() + 1][width][length];
|
||||
this.biomeResult = biomes ? new BiomeType[weWorld.getMaxY() - weWorld.getMinY() + 1][width][length] : null;
|
||||
this.result = new BlockState[256][width][length];
|
||||
this.biomeResult = biomes ? new BiomeType[256][width][length] : null;
|
||||
this.bot = bot;
|
||||
this.top = top;
|
||||
}
|
||||
@ -71,7 +71,7 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biomeType) {
|
||||
if (this.biomeResult != null) {
|
||||
for (int y = weWorld.getMinY(); y <= weWorld.getMaxY(); y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
this.storeCacheBiome(x, y, z, biomeType);
|
||||
}
|
||||
return true;
|
||||
@ -101,10 +101,9 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCache(final int x, final int y, final int z, final @NonNull BlockState id) {
|
||||
int yIndex = getYIndex(y);
|
||||
BlockState[][] resultY = result[yIndex];
|
||||
BlockState[][] resultY = result[y];
|
||||
if (resultY == null) {
|
||||
result[yIndex] = resultY = new BlockState[length][];
|
||||
result[y] = resultY = new BlockState[length][];
|
||||
}
|
||||
BlockState[] resultYZ = resultY[z];
|
||||
if (resultYZ == null) {
|
||||
@ -114,10 +113,9 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCacheBiome(final int x, final int y, final int z, final @NonNull BiomeType id) {
|
||||
int yIndex = getYIndex(y);
|
||||
BiomeType[][] resultY = biomeResult[yIndex];
|
||||
BiomeType[][] resultY = biomeResult[y];
|
||||
if (resultY == null) {
|
||||
biomeResult[yIndex] = resultY = new BiomeType[length][];
|
||||
biomeResult[y] = resultY = new BiomeType[length][];
|
||||
}
|
||||
BiomeType[] resultYZ = resultY[z];
|
||||
if (resultYZ == null) {
|
||||
@ -134,7 +132,7 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @Nullable BlockState getBlock(int x, int y, int z) {
|
||||
BlockState[][] blocksY = result[getYIndex(y)];
|
||||
BlockState[][] blocksY = result[y];
|
||||
if (blocksY != null) {
|
||||
BlockState[] blocksYZ = blocksY[z];
|
||||
if (blocksYZ != null) {
|
||||
@ -159,8 +157,4 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
return Location.at(getWorld().getName(), bot.getX(), bot.getY(), bot.getZ());
|
||||
}
|
||||
|
||||
private int getYIndex(int y) {
|
||||
return y - weWorld.getMinY();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -42,7 +42,6 @@ public class LocalChunk {
|
||||
private final QueueCoordinator parent;
|
||||
private final int x;
|
||||
private final int z;
|
||||
private final int minSection;
|
||||
|
||||
private final BaseBlock[][] baseblocks;
|
||||
private final BiomeType[][] biomes;
|
||||
@ -53,10 +52,8 @@ public class LocalChunk {
|
||||
this.parent = parent;
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
this.minSection = parent.getMinLayer();
|
||||
int sections = parent.getMaxLayer() - parent.getMinLayer() + 1;
|
||||
baseblocks = new BaseBlock[sections][];
|
||||
biomes = new BiomeType[sections][];
|
||||
baseblocks = new BaseBlock[16][];
|
||||
biomes = new BiomeType[16][];
|
||||
}
|
||||
|
||||
public @NonNull QueueCoordinator getParent() {
|
||||
@ -71,15 +68,6 @@ public class LocalChunk {
|
||||
return this.z;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the minimum layer position stored (usually -4 or 0).
|
||||
*
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public int getMinSection() {
|
||||
return this.minSection;
|
||||
}
|
||||
|
||||
public @NonNull BaseBlock[][] getBaseblocks() {
|
||||
return this.baseblocks;
|
||||
}
|
||||
@ -93,7 +81,7 @@ public class LocalChunk {
|
||||
}
|
||||
|
||||
public void setBiome(final int x, final int y, final int z, final @NonNull BiomeType biomeType) {
|
||||
final int i = getLayerIndex(y);
|
||||
final int i = y >> 4;
|
||||
final int j = ChunkUtil.getJ(x, y, z);
|
||||
BiomeType[] array = this.biomes[i];
|
||||
if (array == null) {
|
||||
@ -108,7 +96,7 @@ public class LocalChunk {
|
||||
}
|
||||
|
||||
public void setBlock(final int x, final int y, final int z, final @NonNull BaseBlock baseBlock) {
|
||||
final int i = getLayerIndex(y);
|
||||
final int i = y >> 4;
|
||||
final int j = ChunkUtil.getJ(x, y, z);
|
||||
BaseBlock[] array = baseblocks[i];
|
||||
if (array == null) {
|
||||
@ -129,8 +117,4 @@ public class LocalChunk {
|
||||
return this.entities;
|
||||
}
|
||||
|
||||
private int getLayerIndex(final int y) {
|
||||
return (y >> 4) - minSection;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -87,14 +87,11 @@ public class LocationOffsetDelegateQueueCoordinator extends DelegateQueueCoordin
|
||||
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biome) {
|
||||
try {
|
||||
if (canPlace[x - blockX][z - blockZ]) {
|
||||
return super.setBiome(x, z, biome);
|
||||
}
|
||||
} catch (final Exception e) {
|
||||
throw e;
|
||||
boolean result = true;
|
||||
for (int y = 0; y < 256; y++) {
|
||||
result &= this.setBiome(x, y, z, biome);
|
||||
}
|
||||
return false;
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@ -75,29 +75,12 @@ public abstract class QueueCoordinator {
|
||||
* @param x chunk x coordinate
|
||||
* @param z chunk z coordinate
|
||||
* @return a new {@link ScopedQueueCoordinator}
|
||||
* @deprecated Use {@link ScopedQueueCoordinator#getForChunk(int, int, int, int)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public ScopedQueueCoordinator getForChunk(int x, int z) {
|
||||
if (getWorld() == null) {
|
||||
return getForChunk(x, z, PlotSquared.platform().versionMinHeight(), PlotSquared.platform().versionMaxHeight());
|
||||
}
|
||||
return getForChunk(x, z, getWorld().getMinY(), getWorld().getMaxY());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a {@link ScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
|
||||
*
|
||||
* @param x chunk x coordinate
|
||||
* @param z chunk z coordinate
|
||||
* @return a new {@link ScopedQueueCoordinator}
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public ScopedQueueCoordinator getForChunk(int x, int z, int minY, int maxY) {
|
||||
int bx = x << 4;
|
||||
int bz = z << 4;
|
||||
return new ScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, minY, bz),
|
||||
Location.at(getWorld().getName(), bx + 15, maxY, bz + 15)
|
||||
return new ScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, 0, bz),
|
||||
Location.at(getWorld().getName(), bx + 15, 255, bz + 255)
|
||||
);
|
||||
}
|
||||
|
||||
@ -421,7 +404,7 @@ public abstract class QueueCoordinator {
|
||||
*/
|
||||
public void setCuboid(@NonNull Location pos1, @NonNull Location pos2, @NonNull BlockState block) {
|
||||
int yMin = Math.min(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.max(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int xMin = Math.min(pos1.getX(), pos2.getX());
|
||||
int xMax = Math.max(pos1.getX(), pos2.getX());
|
||||
int zMin = Math.min(pos1.getZ(), pos2.getZ());
|
||||
@ -444,7 +427,7 @@ public abstract class QueueCoordinator {
|
||||
*/
|
||||
public void setCuboid(@NonNull Location pos1, @NonNull Location pos2, @NonNull Pattern blocks) {
|
||||
int yMin = Math.min(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.max(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int xMin = Math.min(pos1.getX(), pos2.getX());
|
||||
int xMax = Math.max(pos1.getX(), pos2.getX());
|
||||
int zMin = Math.min(pos1.getZ(), pos2.getZ());
|
||||
@ -467,7 +450,7 @@ public abstract class QueueCoordinator {
|
||||
*/
|
||||
public void setBiomeCuboid(@NonNull Location pos1, @NonNull Location pos2, @NonNull BiomeType biome) {
|
||||
int yMin = Math.min(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.max(pos1.getY(), pos2.getY());
|
||||
int yMax = Math.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int xMin = Math.min(pos1.getX(), pos2.getX());
|
||||
int xMax = Math.max(pos1.getX(), pos2.getX());
|
||||
int zMin = Math.min(pos1.getZ(), pos2.getZ());
|
||||
@ -481,32 +464,4 @@ public abstract class QueueCoordinator {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the min Y limit associated with the queue
|
||||
*/
|
||||
protected int getMinY() {
|
||||
return getWorld() != null ? getWorld().getMinY() : PlotSquared.platform().versionMinHeight();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max Y limit associated with the queue
|
||||
*/
|
||||
protected int getMaxY() {
|
||||
return getWorld() != null ? getWorld().getMinY() : PlotSquared.platform().versionMaxHeight();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the min chunk layer associated with the queue. Usually 0 or -4;
|
||||
*/
|
||||
protected int getMinLayer() {
|
||||
return (getWorld() != null ? getWorld().getMinY() : PlotSquared.platform().versionMinHeight()) >> 4;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the max chunk layer associated with the queue. Usually 15 or 19
|
||||
*/
|
||||
protected int getMaxLayer() {
|
||||
return (getWorld() != null ? getWorld().getMaxY() : PlotSquared.platform().versionMaxHeight()) >> 4;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -39,8 +39,6 @@ import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
*/
|
||||
public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
|
||||
private final Location min;
|
||||
private final Location max;
|
||||
private final int minX;
|
||||
private final int minY;
|
||||
private final int minZ;
|
||||
@ -53,13 +51,8 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
private final int dy;
|
||||
private final int dz;
|
||||
|
||||
/**
|
||||
* Create a new ScopedQueueCoordinator instance that delegates to a given QueueCoordinator. Locations are inclusive.
|
||||
*/
|
||||
public ScopedQueueCoordinator(@Nullable QueueCoordinator parent, @NonNull Location min, @NonNull Location max) {
|
||||
super(parent);
|
||||
this.min = min;
|
||||
this.max = max;
|
||||
this.minX = min.getX();
|
||||
this.minY = min.getY();
|
||||
this.minZ = min.getZ();
|
||||
@ -119,11 +112,11 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
}
|
||||
|
||||
public @NonNull Location getMin() {
|
||||
return min;
|
||||
return Location.at(this.getWorld().getName(), this.minX, this.minY, this.minZ);
|
||||
}
|
||||
|
||||
public @NonNull Location getMax() {
|
||||
return max;
|
||||
return Location.at(this.getWorld().getName(), this.maxX, this.maxY, this.maxZ);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -31,7 +31,6 @@ import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.plotsquared.core.util.task.RunnableVal;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
@ -48,16 +47,18 @@ public abstract class ChunkManager {
|
||||
String world,
|
||||
BlockVector2 loc
|
||||
) {
|
||||
World weWorld = PlotSquared.platform().worldUtil().getWeWorld(world);
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(weWorld);
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(PlotSquared
|
||||
.platform()
|
||||
.worldUtil()
|
||||
.getWeWorld(world));
|
||||
if (PlotSquared.get().getPlotAreaManager().isAugmented(world) && PlotSquared.get().isNonStandardGeneration(world, loc)) {
|
||||
int blockX = loc.getX() << 4;
|
||||
int blockZ = loc.getZ() << 4;
|
||||
ScopedQueueCoordinator scoped =
|
||||
new ScopedQueueCoordinator(
|
||||
queue,
|
||||
Location.at(world, blockX, weWorld.getMinY(), blockZ),
|
||||
Location.at(world, blockX + 15, weWorld.getMaxY(), blockZ + 15)
|
||||
Location.at(world, blockX, 0, blockZ),
|
||||
Location.at(world, blockX + 15, 255, blockZ + 15)
|
||||
);
|
||||
if (force != null) {
|
||||
force.run(scoped);
|
||||
|
||||
@ -39,27 +39,30 @@ public class ChunkUtil {
|
||||
* - Used for efficient world generation<br>
|
||||
*/
|
||||
private static final short[] x_loc;
|
||||
private static final short[] y_loc;
|
||||
private static final short[][] y_loc;
|
||||
private static final short[] z_loc;
|
||||
private static final short[][][] CACHE_J;
|
||||
|
||||
static {
|
||||
x_loc = new short[4096];
|
||||
y_loc = new short[4096];
|
||||
y_loc = new short[16][4096];
|
||||
z_loc = new short[4096];
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int y = j >> 8;
|
||||
int a = j - ((y & 0xF) << 8);
|
||||
int z1 = a >> 4;
|
||||
int x1 = a - (z1 << 4);
|
||||
x_loc[j] = (short) x1;
|
||||
y_loc[j] = (short) y;
|
||||
z_loc[j] = (short) z1;
|
||||
for (int i = 0; i < 16; i++) {
|
||||
int i4 = i << 4;
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int y = i4 + (j >> 8);
|
||||
int a = j - ((y & 0xF) << 8);
|
||||
int z1 = a >> 4;
|
||||
int x1 = a - (z1 << 4);
|
||||
x_loc[j] = (short) x1;
|
||||
y_loc[i][j] = (short) y;
|
||||
z_loc[j] = (short) z1;
|
||||
}
|
||||
}
|
||||
CACHE_J = new short[16][16][16];
|
||||
CACHE_J = new short[256][16][16];
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
for (int y = 0; y < 16; y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
short j = (short) ((y & 0xF) << 8 | z << 4 | x);
|
||||
CACHE_J[y][x][z] = j;
|
||||
}
|
||||
@ -80,7 +83,7 @@ public class ChunkUtil {
|
||||
* @return J value for xyz position in Array[4096].
|
||||
*/
|
||||
public static int getJ(int x, int y, int z) {
|
||||
return CACHE_J[y & 15][x & 15][z & 15];
|
||||
return CACHE_J[y][x][z];
|
||||
}
|
||||
|
||||
/**
|
||||
@ -94,14 +97,14 @@ public class ChunkUtil {
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the y coordinate for specific I and J values for a Chunk Nx16x16x16 layerxyz Array[N][4096].
|
||||
* Gets the y coordinate for specific I and J values for a Chunk 16x16x16x16 layerxyz Array[16][4096].
|
||||
*
|
||||
* @param i Relative layer of the position in the layerxyz Array[16][4096]. May be negative.
|
||||
* @param i Relative layer of the position in the layerxyz Array[16][4096].
|
||||
* @param j Position in the xyz Array[4096].
|
||||
* @return x coordinate within the chunk
|
||||
*/
|
||||
public static int getY(int i, int j) {
|
||||
return (i << 4) + y_loc[j];
|
||||
return y_loc[i][j];
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@ -45,7 +45,7 @@ public abstract class InventoryUtil {
|
||||
* @param index The index where to place the item
|
||||
* @param item The item to place into the inventory
|
||||
* @return {@code true} if the item could be placed, {@code false} otherwise (e.g. item not available in current version)
|
||||
* @since 6.5.0
|
||||
* @since TODO
|
||||
*/
|
||||
public abstract boolean setItemChecked(
|
||||
final PlotInventory plotInventory, final int index,
|
||||
|
||||
@ -37,21 +37,15 @@ public class MainUtil {
|
||||
* Cache of mapping x,y,z coordinates to the chunk array<br>
|
||||
* - Used for efficient world generation<br>
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static short[][] x_loc;
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static short[][] y_loc;
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static short[][] z_loc;
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static short[][][] CACHE_I = null;
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static short[][][] CACHE_J = null;
|
||||
|
||||
/**
|
||||
* This cache is used for world generation and just saves a bit of calculation time when checking if something is in the plot area.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.0.0")
|
||||
public static void initCache() {
|
||||
if (x_loc == null) {
|
||||
x_loc = new short[16][4096];
|
||||
|
||||
@ -29,7 +29,6 @@ import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
@Deprecated(since = "6.6.2", forRemoval = true)
|
||||
public class RegExUtil {
|
||||
|
||||
public static Map<String, Pattern> compiledPatterns;
|
||||
|
||||
@ -279,10 +279,7 @@ public abstract class RegionManager {
|
||||
fromQueue1.addReadChunks(new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()).getChunks());
|
||||
fromQueue2.addReadChunks(new CuboidRegion(
|
||||
swapPos.getBlockVector3(),
|
||||
BlockVector3.at(swapPos.getX() + pos2.getX() - pos1.getX(),
|
||||
pos1.getY(),
|
||||
swapPos.getZ() + pos2.getZ() - pos1.getZ()
|
||||
)
|
||||
BlockVector3.at(swapPos.getX() + pos2.getX() - pos1.getX(), 0, swapPos.getZ() + pos2.getZ() - pos1.getZ())
|
||||
).getChunks());
|
||||
QueueCoordinator toQueue1 = blockQueue.getNewQueue(world1);
|
||||
QueueCoordinator toQueue2 = blockQueue.getNewQueue(world2);
|
||||
@ -355,7 +352,7 @@ public abstract class RegionManager {
|
||||
int bz = Math.max(pos1.getZ(), cbz) & 15;
|
||||
int tx = Math.min(pos2.getX(), cbx + 15) & 15;
|
||||
int tz = Math.min(pos2.getZ(), cbz + 15) & 15;
|
||||
for (int y = world1.getMinY(); y <= world1.getMaxY(); y++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int x = bx; x <= tx; x++) {
|
||||
for (int z = bz; z <= tz; z++) {
|
||||
int rx = cbx + x;
|
||||
@ -366,10 +363,7 @@ public abstract class RegionManager {
|
||||
}
|
||||
}
|
||||
}
|
||||
Region region = new CuboidRegion(
|
||||
BlockVector3.at(cbx + bx, world1.getMinY(), cbz + bz),
|
||||
BlockVector3.at(cbx + tx, world1.getMaxY(), cbz + tz)
|
||||
);
|
||||
Region region = new CuboidRegion(BlockVector3.at(cbx + bx, 0, cbz + bz), BlockVector3.at(cbx + tx, 255, cbz + tz));
|
||||
toQueue.addEntities(world1.getEntities(region));
|
||||
if (removeEntities) {
|
||||
for (Entity entity : world1.getEntities(region)) {
|
||||
@ -379,7 +373,6 @@ public abstract class RegionManager {
|
||||
});
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public void setBiome(
|
||||
final CuboidRegion region,
|
||||
final int extendBiome,
|
||||
@ -387,48 +380,39 @@ public abstract class RegionManager {
|
||||
final String world,
|
||||
final Runnable whenDone
|
||||
) {
|
||||
setBiome(region, extendBiome, biome, PlotSquared.get().getPlotAreaManager().getPlotAreas(world, region)[0], whenDone);
|
||||
}
|
||||
Location pos1 = Location
|
||||
.at(
|
||||
world,
|
||||
region.getMinimumPoint().getX() - extendBiome,
|
||||
region.getMinimumPoint().getY(),
|
||||
region.getMinimumPoint().getZ() - extendBiome
|
||||
);
|
||||
Location pos2 = Location
|
||||
.at(
|
||||
world,
|
||||
region.getMaximumPoint().getX() + extendBiome,
|
||||
region.getMaximumPoint().getY(),
|
||||
region.getMaximumPoint().getZ() + extendBiome
|
||||
);
|
||||
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(world));
|
||||
|
||||
/**
|
||||
* Set a region to a biome type.
|
||||
*
|
||||
* @param region region to set
|
||||
* @param extendBiome how far outside the region to extent setting the biome too account for 3D biomes being 4x4
|
||||
* @param biome biome to set
|
||||
* @param area {@link PlotArea} in which the biome is being set
|
||||
* @param whenDone task to run when complete
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public void setBiome(
|
||||
final CuboidRegion region,
|
||||
final int extendBiome,
|
||||
final BiomeType biome,
|
||||
final PlotArea area,
|
||||
final Runnable whenDone
|
||||
) {
|
||||
final QueueCoordinator queue = blockQueue.getNewQueue(worldUtil.getWeWorld(area.getWorldName()));
|
||||
final int minX = pos1.getX();
|
||||
final int minZ = pos1.getZ();
|
||||
final int maxX = pos2.getX();
|
||||
final int maxZ = pos2.getZ();
|
||||
queue.addReadChunks(region.getChunks());
|
||||
final BlockVector3 regionMin = region.getMinimumPoint();
|
||||
final BlockVector3 regionMax = region.getMaximumPoint();
|
||||
queue.setChunkConsumer(chunkPos -> {
|
||||
BlockVector3 chunkMin = BlockVector3.at(
|
||||
Math.max(chunkPos.getX() << 4, regionMin.getBlockX()),
|
||||
regionMin.getBlockY(),
|
||||
Math.max(chunkPos.getZ() << 4, regionMin.getBlockZ())
|
||||
);
|
||||
BlockVector3 chunkMax = BlockVector3.at(
|
||||
Math.min((chunkPos.getX() << 4) + 15, regionMax.getBlockX()),
|
||||
regionMax.getBlockY(),
|
||||
Math.min((chunkPos.getZ() << 4) + 15, regionMax.getBlockZ())
|
||||
);
|
||||
CuboidRegion chunkRegion = new CuboidRegion(region.getWorld(), chunkMin, chunkMax);
|
||||
queue.setChunkConsumer(blockVector2 -> {
|
||||
final int cx = blockVector2.getX() << 4;
|
||||
final int cz = blockVector2.getZ() << 4;
|
||||
WorldUtil.setBiome(
|
||||
area.getWorldName(),
|
||||
chunkRegion,
|
||||
world,
|
||||
Math.max(minX, cx),
|
||||
Math.max(minZ, cz),
|
||||
Math.min(maxX, cx + 15),
|
||||
Math.min(maxZ, cz + 15),
|
||||
biome
|
||||
);
|
||||
worldUtil.refreshChunk(chunkPos.getBlockX(), chunkPos.getBlockZ(), area.getWorldName());
|
||||
worldUtil.refreshChunk(blockVector2.getBlockX(), blockVector2.getBlockZ(), world);
|
||||
});
|
||||
queue.setCompleteTask(whenDone);
|
||||
queue.enqueue();
|
||||
|
||||
@ -76,9 +76,8 @@ public class RegionUtil {
|
||||
return new CuboidRegion(min, max);
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public static CuboidRegion createRegion(int pos1x, int pos2x, int pos1z, int pos2z) {
|
||||
return createRegion(pos1x, pos2x, 0, 255, pos1z, pos2z);
|
||||
return createRegion(pos1x, pos2x, 0, Plot.MAX_HEIGHT - 1, pos1z, pos2z);
|
||||
}
|
||||
|
||||
public static CuboidRegion createRegion(
|
||||
|
||||
@ -305,13 +305,12 @@ public abstract class SchematicHandler {
|
||||
final int WIDTH = dimension.getX();
|
||||
final int LENGTH = dimension.getZ();
|
||||
final int HEIGHT = dimension.getY();
|
||||
final int worldHeight = plot.getArea().getMaxGenHeight() - plot.getArea().getMinGenHeight() + 1;
|
||||
// Validate dimensions
|
||||
CuboidRegion region = plot.getLargestRegion();
|
||||
boolean sizeMismatch =
|
||||
((region.getMaximumPoint().getX() - region.getMinimumPoint().getX() + xOffset + 1) < WIDTH) || (
|
||||
(region.getMaximumPoint().getZ() - region.getMinimumPoint().getZ() + zOffset + 1) < LENGTH) || (HEIGHT
|
||||
> worldHeight);
|
||||
> 256);
|
||||
if (!Settings.Schematics.PASTE_MISMATCHES && sizeMismatch) {
|
||||
actor.sendMessage(TranslatableCaption.of("schematics.schematic_size_mismatch"));
|
||||
TaskManager.runTask(whenDone);
|
||||
@ -322,14 +321,14 @@ public abstract class SchematicHandler {
|
||||
// Calculate the optimal height to paste the schematic at
|
||||
final int y_offset_actual;
|
||||
if (autoHeight) {
|
||||
if (HEIGHT >= worldHeight) {
|
||||
if (HEIGHT >= 256) {
|
||||
y_offset_actual = yOffset;
|
||||
} else {
|
||||
PlotArea pw = plot.getArea();
|
||||
if (pw instanceof ClassicPlotWorld) {
|
||||
y_offset_actual = yOffset + pw.getMinBuildHeight() + ((ClassicPlotWorld) pw).PLOT_HEIGHT;
|
||||
} else {
|
||||
y_offset_actual = yOffset + pw.getMinBuildHeight() + this.worldUtil
|
||||
y_offset_actual = yOffset + 1 + this.worldUtil
|
||||
.getHighestBlockSynchronous(plot.getWorldName(), region.getMinimumPoint().getX() + 1,
|
||||
region.getMinimumPoint().getZ() + 1
|
||||
);
|
||||
@ -361,9 +360,9 @@ public abstract class SchematicHandler {
|
||||
// Paste schematic here
|
||||
final QueueCoordinator queue = plot.getArea().getQueue();
|
||||
|
||||
for (int ry = 0; ry < Math.min(worldHeight, HEIGHT); ry++) {
|
||||
for (int ry = 0; ry < Math.min(256, HEIGHT); ry++) {
|
||||
int yy = y_offset_actual + ry;
|
||||
if (yy > plot.getArea().getMaxGenHeight() || yy < plot.getArea().getMinGenHeight()) {
|
||||
if (yy > 255 || yy < 0) {
|
||||
continue;
|
||||
}
|
||||
for (int rz = 0; rz < blockArrayClipboard.getDimensions().getZ(); rz++) {
|
||||
@ -380,18 +379,18 @@ public abstract class SchematicHandler {
|
||||
BlockVector3 loc = BlockVector3.at(rx, ry, rz);
|
||||
BaseBlock id = blockArrayClipboard.getFullBlock(loc);
|
||||
queue.setBlock(xx, yy, zz, id);
|
||||
BiomeType biome = blockArrayClipboard.getBiome(loc);
|
||||
queue.setBiome(xx, yy, zz, biome);
|
||||
if (ry == 0) {
|
||||
BiomeType biome = blockArrayClipboard.getBiome(loc);
|
||||
queue.setBiome(xx, yy, zz, biome);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (actor != null && Settings.QUEUE.NOTIFY_PROGRESS) {
|
||||
queue.addProgressSubscriber(subscriberFactory.createWithActor(actor));
|
||||
}
|
||||
if (whenDone != null) {
|
||||
whenDone.value = true;
|
||||
queue.setCompleteTask(whenDone);
|
||||
}
|
||||
whenDone.value = true;
|
||||
queue.setCompleteTask(whenDone);
|
||||
queue.enqueue();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
|
||||
@ -44,27 +44,27 @@ public final class TimeUtil {
|
||||
StringBuilder toReturn = new StringBuilder();
|
||||
if (time >= 33868800) {
|
||||
int years = (int) (time / 33868800);
|
||||
time -= years * 33868800L;
|
||||
time -= years * 33868800;
|
||||
toReturn.append(years).append("y ");
|
||||
}
|
||||
if (time >= 604800) {
|
||||
int weeks = (int) (time / 604800);
|
||||
time -= weeks * 604800L;
|
||||
time -= weeks * 604800;
|
||||
toReturn.append(weeks).append("w ");
|
||||
}
|
||||
if (time >= 86400) {
|
||||
int days = (int) (time / 86400);
|
||||
time -= days * 86400L;
|
||||
time -= days * 86400;
|
||||
toReturn.append(days).append("d ");
|
||||
}
|
||||
if (time >= 3600) {
|
||||
int hours = (int) (time / 3600);
|
||||
time -= hours * 3600L;
|
||||
time -= hours * 3600;
|
||||
toReturn.append(hours).append("h ");
|
||||
}
|
||||
if (time >= 60) {
|
||||
int minutes = (int) (time / 60);
|
||||
time -= minutes * 60L;
|
||||
time -= minutes * 60;
|
||||
toReturn.append(minutes).append("m ");
|
||||
}
|
||||
if (toReturn.length() == 0 || time > 0) {
|
||||
|
||||
@ -44,9 +44,6 @@ import java.util.UUID;
|
||||
|
||||
public class WEManager {
|
||||
|
||||
private static final BlockVector3 MIN = BlockVector3.at(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
|
||||
private static final BlockVector3 MAX = BlockVector3.at(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
|
||||
|
||||
public static boolean maskContains(Set<CuboidRegion> mask, int x, int y, int z) {
|
||||
for (CuboidRegion region : mask) {
|
||||
if (RegionUtil.contains(region, x, y, z)) {
|
||||
@ -94,7 +91,10 @@ public class WEManager {
|
||||
Location location = player.getLocation();
|
||||
String world = location.getWorldName();
|
||||
if (!PlotSquared.get().getPlotAreaManager().hasPlotArea(world)) {
|
||||
regions.add(new CuboidRegion(MIN, MAX));
|
||||
regions.add(RegionUtil
|
||||
.createRegion(Integer.MIN_VALUE, Integer.MAX_VALUE, Integer.MIN_VALUE,
|
||||
Integer.MAX_VALUE
|
||||
));
|
||||
return regions;
|
||||
}
|
||||
PlotArea area = player.getApplicablePlotArea();
|
||||
|
||||
@ -39,7 +39,6 @@ import com.sk89q.jnbt.Tag;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
import com.sk89q.worldedit.world.block.BlockType;
|
||||
@ -79,29 +78,14 @@ public abstract class WorldUtil {
|
||||
* @param p2x Max X
|
||||
* @param p2z Max Z
|
||||
* @param biome Biome
|
||||
* @deprecated use {@link WorldUtil#setBiome(String, CuboidRegion, BiomeType)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true)
|
||||
public static void setBiome(String world, int p1x, int p1z, int p2x, int p2z, BiomeType biome) {
|
||||
World weWorld = PlotSquared.platform().worldUtil().getWeWorld(world);
|
||||
BlockVector3 pos1 = BlockVector2.at(p1x, p1z).toBlockVector3(weWorld.getMinY());
|
||||
BlockVector3 pos2 = BlockVector2.at(p2x, p2z).toBlockVector3(weWorld.getMaxY());
|
||||
BlockVector3 pos1 = BlockVector2.at(p1x, p1z).toBlockVector3();
|
||||
BlockVector3 pos2 = BlockVector2.at(p2x, p2z).toBlockVector3(Plot.MAX_HEIGHT - 1);
|
||||
CuboidRegion region = new CuboidRegion(pos1, pos2);
|
||||
PlotSquared.platform().worldUtil().setBiomes(world, region, biome);
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the biome in a region
|
||||
*
|
||||
* @param world World name
|
||||
* @param region Region
|
||||
* @param biome Biome
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public static void setBiome(String world, final CuboidRegion region, BiomeType biome) {
|
||||
PlotSquared.platform().worldUtil().setBiomes(world, region, biome);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a given world name corresponds to a real world
|
||||
*
|
||||
@ -233,14 +217,11 @@ public abstract class WorldUtil {
|
||||
/**
|
||||
* Set the biome in a region
|
||||
*
|
||||
* @param worldName World name
|
||||
* @param region Region
|
||||
* @param biome New biome
|
||||
* @param world World name
|
||||
* @param region Region
|
||||
* @param biome New biome
|
||||
*/
|
||||
public void setBiomes(@NonNull String worldName, @NonNull CuboidRegion region, @NonNull BiomeType biome) {
|
||||
final World world = getWeWorld(worldName);
|
||||
region.forEach(bv -> world.setBiome(bv, biome));
|
||||
}
|
||||
public abstract void setBiomes(@NonNull String world, @NonNull CuboidRegion region, @NonNull BiomeType biome);
|
||||
|
||||
/**
|
||||
* Get the WorldEdit {@link com.sk89q.worldedit.world.World} corresponding to a world name
|
||||
|
||||
@ -52,7 +52,8 @@ public class HelpMenu {
|
||||
}
|
||||
|
||||
public HelpMenu getCommands() {
|
||||
this.commands = MainCommand.getInstance().getCommands(this.commandCategory, this.commandCaller);
|
||||
this.commands =
|
||||
MainCommand.getInstance().getCommands(this.commandCategory, this.commandCaller);
|
||||
return this;
|
||||
}
|
||||
|
||||
|
||||
@ -51,29 +51,38 @@ public class UUIDMapping {
|
||||
return this.uuid;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (this == o) {
|
||||
if (o == this) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
if (!(o instanceof final UUIDMapping other)) {
|
||||
return false;
|
||||
}
|
||||
final UUIDMapping that = (UUIDMapping) o;
|
||||
return uuid.equals(that.uuid) && username.equals(that.username);
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$uuid = this.getUuid();
|
||||
final Object other$uuid = other.getUuid();
|
||||
if (!Objects.equals(this$uuid, other$uuid)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$username = this.getUsername();
|
||||
final Object other$username = other.getUsername();
|
||||
return Objects.equals(this$username, other$username);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return Objects.hash(uuid, username);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof UUIDMapping;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $uuid = this.getUuid();
|
||||
result = result * PRIME + $uuid.hashCode();
|
||||
final Object $username = this.getUsername();
|
||||
result = result * PRIME + $username.hashCode();
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -161,9 +161,8 @@
|
||||
"setup.road_width": "<gold>Road width</gold>",
|
||||
"setup.road_height": "<gold>Road height</gold>",
|
||||
"setup.road_block": "<gold>Road block</gold>",
|
||||
"setup.wall_filling_block": "<gold>Wall filling block</gold><gray> (Block(s) been put under the plot border down to min gen height + 1)</gray>",
|
||||
"setup.wall_filling_block": "<gold>Wall filling block</gold><gray> (Block(s) been put under the plot border down to Y1)</gray>",
|
||||
"setup.wall_height": "<gold>Wall height</gold>",
|
||||
"setup.min_gen_height": "<gold>Minimum height from which to generate (for 1.18+ can be negative).</gold>",
|
||||
"setup.bedrock_boolean": "<gold>Whether a bedrock layer under the plot should be generated or not</gold>",
|
||||
"setup.singleplotarea_void_world": "<gold>Void world</gold>",
|
||||
"plotareatype.plot_area_type_normal": "<gray>Standard plot generation</gray>",
|
||||
@ -461,12 +460,9 @@
|
||||
"backups.backup_automatic_failure": "<prefix><red>The automatic backup process failed. Your pending action has been canceled. Reason: </red><gray><reason></gray>",
|
||||
"preset.preset_cannot_afford": "<prefix><red>You cannot afford that preset.</red>",
|
||||
"preset.preset_invalid": "<prefix><red>Could not generate a pattern from that preset.</red>",
|
||||
"preset.preset_lore_cost": "<gray>Cost: </gray><gold><cost></gold>",
|
||||
"preset.preset_lore_economy_disabled": "<gray>Cost: </gray><red>Economy is disabled</red>",
|
||||
"preset.preset_lore_cost": "<prefix><gray>Cost: </gray><gold><cost></gold>",
|
||||
"preset.preset_lore_component": "<gray>Component: </gray><gold><component></gold>",
|
||||
"preset.title": "Plot Components",
|
||||
"preset.empty": "<prefix><red>No plot component presets available.</red>",
|
||||
"preset.economy_disabled": "<prefix><red>The component preset '<preset>' has a price set but economy is disabled.</red>",
|
||||
"generic.generic_other": "<gray>other</gray>",
|
||||
"generic.generic_merged": "<gray>merged</gray>",
|
||||
"generic.generic_unowned": "<gray>unowned</gray>",
|
||||
@ -613,7 +609,6 @@
|
||||
"flags.flag_description_lectern_read_book": "<gray>Prevent players taking books from lecterns.</gray>",
|
||||
"flags.flag_description_prevent_creative_copy": "<gray>Prevents people from copying item NBT data in the plot unless they're added as members.</gray>",
|
||||
"flags.flag_description_leaf_decay": "<gray>Set to `false` to prevent leaves from decaying.",
|
||||
"flags.flag_description_projectiles": "<gray>Prevents guests from shooting projectiles on the plot when set to false.</gray>",
|
||||
"flags.flag_error_boolean": "Flag value must be a boolean (true | false).",
|
||||
"flags.flag_error_enum": "Must be one of: <list>",
|
||||
"flags.flag_error_integer": "Flag value must be a whole positive number.",
|
||||
|
||||
@ -18,7 +18,7 @@ plugins {
|
||||
idea
|
||||
}
|
||||
|
||||
version = "6.7.1-SNAPSHOT"
|
||||
version = "6.4.1-SNAPSHOT"
|
||||
|
||||
allprojects {
|
||||
group = "com.plotsquared"
|
||||
@ -40,9 +40,6 @@ allprojects {
|
||||
maven {
|
||||
name = "Jitpack"
|
||||
url = uri("https://jitpack.io")
|
||||
content {
|
||||
includeModule("com.github.MilkBowl", "VaultAPI")
|
||||
}
|
||||
}
|
||||
|
||||
maven {
|
||||
|
||||
@ -6,34 +6,34 @@ guava = "31.0.1-jre" # Version set by Minecraft
|
||||
|
||||
# Platform expectations
|
||||
paper = "1.18.1-R0.1-SNAPSHOT"
|
||||
checker-qual = "3.22.0"
|
||||
checker-qual = "3.21.1"
|
||||
guice = "5.1.0"
|
||||
spotbugs = "4.6.0"
|
||||
findbugs = "3.0.1"
|
||||
snakeyaml = "1.30" # Version set by Bukkit
|
||||
|
||||
# Adventure & MiniMessage
|
||||
adventure-api = "4.10.1"
|
||||
adventure-text-minimessage = "4.10.1"
|
||||
adventure-platform-bukkit = "4.1.0"
|
||||
adventure-api = "4.9.3"
|
||||
adventure-text-minimessage = "4.1.0-SNAPSHOT"
|
||||
adventure-platform-bukkit = "4.0.1"
|
||||
|
||||
# Plugins
|
||||
worldedit = "7.2.10"
|
||||
fawe = "2.1.2"
|
||||
worldedit = "7.2.9"
|
||||
fawe = "2.0.1"
|
||||
vault = "1.7.1"
|
||||
placeholderapi = "2.11.1"
|
||||
luckperms = "5.4"
|
||||
essentialsx = "2.19.4"
|
||||
luckperms = "5.3"
|
||||
essentialsx = "2.19.2"
|
||||
mvdwapi = "3.1.1"
|
||||
|
||||
# Third party
|
||||
prtree = "2.0.0"
|
||||
aopalliance = "1.0"
|
||||
cloud-services = "1.6.2"
|
||||
cloud-services = "1.6.1"
|
||||
arkitektonika = "2.1.1"
|
||||
paster = "1.1.4"
|
||||
bstats = "3.0.0"
|
||||
paperlib = "1.0.7"
|
||||
squirrelid = "0.3.1"
|
||||
squirrelid = "0.3.0"
|
||||
serverlib = "2.3.1"
|
||||
http4j = "1.3"
|
||||
|
||||
@ -56,7 +56,7 @@ log4j = { group = "org.apache.logging.log4j", name = "log4j-api", version.ref =
|
||||
snakeyaml = { group = "org.yaml", name = "snakeyaml", version.ref = "snakeyaml" }
|
||||
guice = { group = "com.google.inject", name = "guice", version.ref = "guice" }
|
||||
guiceassistedinject = { group = "com.google.inject.extensions", name = "guice-assistedinject", version.ref = "guice" }
|
||||
spotbugs = { group = "com.github.spotbugs", name = "spotbugs-annotations", version.ref = "spotbugs" }
|
||||
findbugs = { group = "com.google.code.findbugs", name = "annotations", version.ref = "findbugs" }
|
||||
|
||||
# Adventure & MiniMessage
|
||||
adventure = { group = "net.kyori", name = "adventure-api", version.ref = "adventure-api" }
|
||||
@ -78,7 +78,7 @@ prtree = { group = "com.intellectualsites.prtree", name = "PRTree", version.ref
|
||||
aopalliance = { group = "aopalliance", name = "aopalliance", version.ref = "aopalliance" }
|
||||
cloudServices = { group = "cloud.commandframework", name = "cloud-services", version.ref = "cloud-services" }
|
||||
mvdwapi = { group = "com.intellectualsites.mvdwplaceholderapi", name = "MVdWPlaceholderAPI", version.ref = "mvdwapi" }
|
||||
squirrelid = { group = "org.enginehub", name = "squirrelid", version.ref = "squirrelid" }
|
||||
squirrelid = { group = "com.github.EngineHub", name = "SquirrelID", version.ref = "squirrelid" }
|
||||
serverlib = { group = "dev.notmyfault.serverlib", name = "ServerLib", version.ref = "serverlib" }
|
||||
bstats = { group = "org.bstats", name = "bstats-bukkit", version.ref = "bstats" }
|
||||
paperlib = { group = "io.papermc", name = "paperlib", version.ref = "paperlib" }
|
||||
|
||||
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
BIN
gradle/wrapper/gradle-wrapper.jar
vendored
Binary file not shown.
2
gradle/wrapper/gradle-wrapper.properties
vendored
2
gradle/wrapper/gradle-wrapper.properties
vendored
@ -1,5 +1,5 @@
|
||||
distributionBase=GRADLE_USER_HOME
|
||||
distributionPath=wrapper/dists
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip
|
||||
distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
@ -8,8 +8,7 @@
|
||||
"com.google.guava:guava",
|
||||
"com.google.code.gson:gson",
|
||||
"gson",
|
||||
"snakeyaml",
|
||||
"net.kyori"
|
||||
"snakeyaml"
|
||||
],
|
||||
"timezone": "Europe/Berlin",
|
||||
"schedule": [
|
||||
|
||||
@ -5,4 +5,5 @@ include("Core", "Bukkit")
|
||||
project(":Core").name = "PlotSquared-Core"
|
||||
project(":Bukkit").name = "PlotSquared-Bukkit"
|
||||
|
||||
enableFeaturePreview("VERSION_CATALOGS")
|
||||
enableFeaturePreview("TYPESAFE_PROJECT_ACCESSORS")
|
||||
|
||||
Reference in New Issue
Block a user