mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-07-26 09:05:28 +02:00
Compare commits
1 Commits
feature/v6
...
renovate/c
| Author | SHA1 | Date | |
|---|---|---|---|
|
e4948376e7 |
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@v3.0.0
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
|
||||
8
.github/workflows/codeql.yml
vendored
8
.github/workflows/codeql.yml
vendored
@@ -23,15 +23,15 @@ jobs:
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v3
|
||||
uses: actions/checkout@v2
|
||||
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v2
|
||||
uses: github/codeql-action/init@v1
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v2
|
||||
uses: github/codeql-action/autobuild@v1
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v2
|
||||
uses: github/codeql-action/analyze@v1
|
||||
|
||||
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
|
||||
- uses: release-drafter/release-drafter@v5.18.1
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
||||
10
.gitignore
vendored
10
.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
|
||||
|
||||
@@ -131,9 +133,5 @@ local.properties
|
||||
checkstyle.xml
|
||||
classes/
|
||||
*.bat
|
||||
|
||||
# Other
|
||||
docs/
|
||||
build/
|
||||
|
||||
.DS_Store
|
||||
|
||||
50
.idea/icon.svg
generated
50
.idea/icon.svg
generated
@@ -1,50 +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" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" version="1.1" id="svg2" xml:space="preserve" width="4000" height="3333.3333" viewBox="0 0 4000 3333.3333" sodipodi:docname="PlotSquared.ai">
|
||||
<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 clipPathUnits="userSpaceOnUse" id="clipPath18">
|
||||
<path d="M 0,2500 H 3000 V 0 H 0 Z" id="path16" />
|
||||
</clipPath>
|
||||
</defs>
|
||||
<sodipodi:namedview pagecolor="#ffffff" bordercolor="#666666" borderopacity="1" objecttolerance="10" gridtolerance="10" guidetolerance="10" inkscape:pageopacity="0" inkscape:pageshadow="2" inkscape:window-width="640" inkscape:window-height="480" id="namedview4" />
|
||||
<g id="g10" inkscape:groupmode="layer" inkscape:label="PlotSquared" transform="matrix(1.3333333,0,0,-1.3333333,0,3333.3333)">
|
||||
<g id="g12">
|
||||
<g id="g14" clip-path="url(#clipPath18)">
|
||||
<g id="g20" transform="translate(1486.1511,2242.6453)">
|
||||
<path 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" style="fill:#062f4c;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path22" />
|
||||
</g>
|
||||
<g id="g24" transform="translate(1201.7948,1741.5303)">
|
||||
<path 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" style="fill:#4c8fcc;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path26" />
|
||||
</g>
|
||||
<g id="g28" transform="translate(919.3342,1429.7462)">
|
||||
<path 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" style="fill:#4c8fcc;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path30" />
|
||||
</g>
|
||||
<g id="g32" transform="translate(1649.134,1700.6166)">
|
||||
<path 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" style="fill:#feeeee;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path34" />
|
||||
</g>
|
||||
<g id="g36" transform="translate(1262.7214,1613.126)">
|
||||
<path 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" style="fill:#feeeee;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path38" />
|
||||
</g>
|
||||
<g id="g40" transform="translate(1966.3174,1675.6364)">
|
||||
<path 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" style="fill:#042338;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path42" />
|
||||
</g>
|
||||
<g id="g44" transform="translate(1499.3971,1669.1094)">
|
||||
<path 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" style="fill:#1c72ba;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path46" />
|
||||
</g>
|
||||
<g id="g48" transform="translate(1748.0469,1601.6797)">
|
||||
<path 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" style="fill:#1c72ba;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path50" />
|
||||
</g>
|
||||
<g id="g52" transform="translate(1262.7214,1613.126)">
|
||||
<path 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" style="fill:#1c72ba;fill-opacity:1;fill-rule:nonzero;stroke:none" id="path54" />
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</g>
|
||||
</svg>
|
||||
|
Before Width: | Height: | Size: 11 KiB |
4
.lift.toml
Normal file
4
.lift.toml
Normal file
@@ -0,0 +1,4 @@
|
||||
jdkVersion = "17"
|
||||
build = "gradle clean build -x test"
|
||||
tools = ["findsecbugs", "ErrorProne", "Semgrep", "Detekt", "Infer"]
|
||||
ignoreRules = ["CatchAndPrintStackTrace", "ReferenceEquality", "FallThrough", "FutureReturnValueIgnored", "MixedMutabilityReturnType", "EmptyCatch", "MissingCasesInEnumSwitch", "OperatorPrecedence", "StaticAssignmentInConstructor", "ReferenceEquality", "EqualsHashCode", "EqualsGetClass", "TypeParameterUnusedInFormals", "StringSplitter", "InlineMeSuggester", "NULL_DEREFERENCE"]
|
||||
@@ -8,7 +8,7 @@ repositories {
|
||||
|
||||
maven {
|
||||
name = "PaperMC"
|
||||
url = uri("https://repo.papermc.io/repository/maven-public/")
|
||||
url = uri("https://papermc.io/repo/repository/maven-public/")
|
||||
}
|
||||
|
||||
maven {
|
||||
@@ -21,20 +21,20 @@ dependencies {
|
||||
api(projects.plotSquaredCore)
|
||||
|
||||
// Metrics
|
||||
implementation("org.bstats:bstats-bukkit")
|
||||
implementation(libs.bstats)
|
||||
|
||||
// Paper
|
||||
compileOnly(libs.paper)
|
||||
implementation("io.papermc:paperlib")
|
||||
implementation(libs.paperlib)
|
||||
|
||||
// Plugins
|
||||
compileOnly(libs.worldeditBukkit) {
|
||||
exclude(group = "org.bukkit")
|
||||
exclude(group = "org.spigotmc")
|
||||
}
|
||||
compileOnly("com.fastasyncworldedit:FastAsyncWorldEdit-Bukkit") { isTransitive = false }
|
||||
testImplementation("com.fastasyncworldedit:FastAsyncWorldEdit-Bukkit") { isTransitive = false }
|
||||
compileOnly("com.github.MilkBowl:VaultAPI") {
|
||||
compileOnly(libs.fastasyncworldeditBukkit) { isTransitive = false }
|
||||
testImplementation(libs.fastasyncworldeditBukkit) { isTransitive = false }
|
||||
compileOnly(libs.vault) {
|
||||
exclude(group = "org.bukkit")
|
||||
}
|
||||
compileOnly(libs.placeholderapi)
|
||||
@@ -44,15 +44,15 @@ dependencies {
|
||||
|
||||
// Other libraries
|
||||
implementation(libs.squirrelid) { isTransitive = false }
|
||||
implementation("dev.notmyfault.serverlib:ServerLib")
|
||||
implementation(libs.serverlib)
|
||||
|
||||
// Our libraries
|
||||
implementation(libs.arkitektonika)
|
||||
implementation(libs.http4j)
|
||||
implementation("com.intellectualsites.paster:Paster")
|
||||
implementation(libs.paster)
|
||||
|
||||
// Adventure
|
||||
implementation("net.kyori:adventure-platform-bukkit")
|
||||
implementation(libs.adventurePlatformBukkit)
|
||||
}
|
||||
|
||||
tasks.processResources {
|
||||
@@ -83,10 +83,8 @@ 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")
|
||||
relocate("net.jcip", "com.plotsquared.core.annotations.jcip")
|
||||
relocate("edu.umd.cs.findbugs", "com.plotsquared.core.annotations.findbugs")
|
||||
|
||||
// Get rid of all the libs which are 100% unused.
|
||||
minimize()
|
||||
@@ -97,7 +95,7 @@ tasks.named<ShadowJar>("shadowJar") {
|
||||
tasks {
|
||||
withType<Javadoc> {
|
||||
val opt = options as StandardJavadocDocletOptions
|
||||
opt.links("https://jd.papermc.io/paper/1.18/")
|
||||
opt.links("https://papermc.io/javadocs/paper/1.18/")
|
||||
opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-bukkit/" + libs.worldeditBukkit.get().versionConstraint.toString())
|
||||
opt.links("https://javadoc.io/doc/com.plotsquared/PlotSquared-Core/latest/")
|
||||
opt.links("https://jd.adventure.kyori.net/api/" + libs.adventure.get().versionConstraint.toString())
|
||||
|
||||
@@ -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();
|
||||
@@ -513,10 +503,8 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
|
||||
this.backgroundPipeline.registerService(essentialsUUIDService);
|
||||
}
|
||||
|
||||
if (Settings.UUID.IMPROMPTU_SERVICE_MOJANG_API) {
|
||||
final SquirrelIdUUIDService impromptuMojangService = new SquirrelIdUUIDService(Settings.UUID.IMPROMPTU_LIMIT);
|
||||
this.impromptuPipeline.registerService(impromptuMojangService);
|
||||
}
|
||||
final SquirrelIdUUIDService impromptuMojangService = new SquirrelIdUUIDService(Settings.UUID.IMPROMPTU_LIMIT);
|
||||
this.impromptuPipeline.registerService(impromptuMojangService);
|
||||
final SquirrelIdUUIDService backgroundMojangService = new SquirrelIdUUIDService(Settings.UUID.BACKGROUND_LIMIT);
|
||||
this.backgroundPipeline.registerService(backgroundMojangService);
|
||||
} else {
|
||||
|
||||
@@ -25,18 +25,17 @@
|
||||
*/
|
||||
package com.plotsquared.bukkit.generator;
|
||||
|
||||
import com.plotsquared.bukkit.queue.LimitedRegionWrapperQueue;
|
||||
import com.plotsquared.core.generator.HybridPlotWorld;
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.plotsquared.core.generator.IndependentPlotGenerator;
|
||||
import com.plotsquared.core.location.Location;
|
||||
import com.plotsquared.core.location.UncheckedWorldLocation;
|
||||
import com.plotsquared.core.location.ChunkWrapper;
|
||||
import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.plot.world.SinglePlotArea;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.sk89q.worldedit.bukkit.BukkitWorld;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.generator.BlockPopulator;
|
||||
import org.bukkit.generator.LimitedRegion;
|
||||
import org.bukkit.generator.WorldInfo;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.Random;
|
||||
@@ -44,51 +43,32 @@ import java.util.Random;
|
||||
final class BlockStatePopulator extends BlockPopulator {
|
||||
|
||||
private final IndependentPlotGenerator plotGenerator;
|
||||
private final PlotAreaManager plotAreaManager;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
public BlockStatePopulator(
|
||||
final @NonNull IndependentPlotGenerator plotGenerator
|
||||
) {
|
||||
this.plotGenerator = plotGenerator;
|
||||
}
|
||||
private QueueCoordinator queue;
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link BlockStatePopulator#BlockStatePopulator(IndependentPlotGenerator)} as plotAreManager is unused
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public BlockStatePopulator(
|
||||
final @NonNull IndependentPlotGenerator plotGenerator,
|
||||
final @NonNull PlotAreaManager plotAreaManager
|
||||
) {
|
||||
this.plotGenerator = plotGenerator;
|
||||
this.plotAreaManager = plotAreaManager;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void populate(
|
||||
@NonNull final WorldInfo worldInfo,
|
||||
@NonNull final Random random,
|
||||
final int chunkX,
|
||||
final int chunkZ,
|
||||
@NonNull final LimitedRegion limitedRegion
|
||||
) {
|
||||
PlotArea area = UncheckedWorldLocation.at(worldInfo.getName(), chunkX << 4, 0, chunkZ << 4).getPlotArea();
|
||||
if (area == null || (area instanceof HybridPlotWorld hpw && !hpw.populationNeeded()) || area instanceof SinglePlotArea) {
|
||||
public void populate(final @NonNull World world, final @NonNull Random random, final @NonNull Chunk source) {
|
||||
if (this.queue == null) {
|
||||
this.queue = PlotSquared.platform().globalBlockQueue().getNewQueue(new BukkitWorld(world));
|
||||
}
|
||||
final PlotArea area = this.plotAreaManager.getPlotArea(world.getName(), null);
|
||||
if (area == null) {
|
||||
return;
|
||||
}
|
||||
LimitedRegionWrapperQueue wrapped = new LimitedRegionWrapperQueue(limitedRegion);
|
||||
// It is possible for the region to be larger than the chunk, but there is no reason for P2 to need to populate
|
||||
// outside of the actual chunk area.
|
||||
Location min = UncheckedWorldLocation.at(worldInfo.getName(), chunkX << 4, worldInfo.getMinHeight(), chunkZ << 4);
|
||||
Location max = UncheckedWorldLocation.at(
|
||||
worldInfo.getName(),
|
||||
(chunkX << 4) + 15,
|
||||
worldInfo.getMaxHeight(),
|
||||
(chunkZ << 4) + 15
|
||||
);
|
||||
ScopedQueueCoordinator offsetChunkQueue = new ScopedQueueCoordinator(wrapped, min, max);
|
||||
this.plotGenerator.populateChunk(offsetChunkQueue, area);
|
||||
final ChunkWrapper wrap = new ChunkWrapper(area.getWorldName(), source.getX(), source.getZ());
|
||||
final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z);
|
||||
if (this.plotGenerator.populateChunk(chunk, area)) {
|
||||
this.queue.enqueue();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -25,11 +25,7 @@
|
||||
*/
|
||||
package com.plotsquared.bukkit.generator;
|
||||
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.plotsquared.core.generator.AugmentedUtils;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.sk89q.worldedit.bukkit.BukkitAdapter;
|
||||
import com.sk89q.worldedit.util.SideEffectSet;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.generator.BlockPopulator;
|
||||
@@ -56,14 +52,7 @@ public class BukkitAugmentedGenerator extends BlockPopulator {
|
||||
|
||||
@Override
|
||||
public void populate(@NonNull World world, @NonNull Random random, @NonNull Chunk source) {
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(BukkitAdapter.adapt(world));
|
||||
// The chunk is already loaded and we do not want to load the chunk in "fully" by using any PaperLib methods.
|
||||
queue.setForceSync(true);
|
||||
queue.setSideEffectSet(SideEffectSet.none());
|
||||
queue.setBiomesEnabled(false);
|
||||
queue.setChunkObject(source);
|
||||
AugmentedUtils.generateChunk(world.getName(), source.getX(), source.getZ(), queue);
|
||||
queue.enqueue();
|
||||
AugmentedUtils.generate(source, world.getName(), source.getX(), source.getZ(), null);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
@@ -49,7 +48,8 @@ import java.util.List;
|
||||
import java.util.Random;
|
||||
import java.util.Set;
|
||||
|
||||
public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrapper<ChunkGenerator> {
|
||||
public class BukkitPlotGenerator extends ChunkGenerator
|
||||
implements GeneratorWrapper<ChunkGenerator> {
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public final boolean PAPER_ASYNC_SAFE = true;
|
||||
@@ -72,12 +72,7 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
|
||||
this.plotGenerator = generator;
|
||||
this.platformGenerator = this;
|
||||
this.populators = new ArrayList<>();
|
||||
int minecraftMinorVersion = PlotSquared.platform().serverVersion()[1];
|
||||
if (minecraftMinorVersion >= 17) {
|
||||
this.populators.add(new BlockStatePopulator(this.plotGenerator));
|
||||
} else {
|
||||
this.populators.add(new LegacyBlockStatePopulator(this.plotGenerator));
|
||||
}
|
||||
this.populators.add(new BlockStatePopulator(this.plotGenerator, this.plotAreaManager));
|
||||
this.full = true;
|
||||
}
|
||||
|
||||
@@ -163,14 +158,13 @@ public class BukkitPlotGenerator extends ChunkGenerator implements GeneratorWrap
|
||||
@NonNull World world, @NonNull Random random, int x, int z,
|
||||
@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);
|
||||
|
||||
}
|
||||
|
||||
@@ -80,8 +80,7 @@ final class DelegatePlotGenerator extends IndependentPlotGenerator {
|
||||
result.setBiome(x, z, BukkitAdapter.adapt(biome));
|
||||
}
|
||||
|
||||
//do not annotate with Override until we discontinue support for 1.4.4 (we no longer support 1.4.4)
|
||||
@Override
|
||||
//do not annotate with Override until we discontinue support for 1.4.4
|
||||
public void setBiome(int x, int y, int z, @NonNull Biome biome) {
|
||||
result.setBiome(x, z, BukkitAdapter.adapt(biome));
|
||||
|
||||
|
||||
@@ -1,81 +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.bukkit.generator;
|
||||
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.plotsquared.core.generator.HybridPlotWorld;
|
||||
import com.plotsquared.core.generator.IndependentPlotGenerator;
|
||||
import com.plotsquared.core.location.Location;
|
||||
import com.plotsquared.core.location.UncheckedWorldLocation;
|
||||
import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.world.SinglePlotArea;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.sk89q.worldedit.bukkit.BukkitWorld;
|
||||
import com.sk89q.worldedit.util.SideEffectSet;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.generator.BlockPopulator;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.jetbrains.annotations.NotNull;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
final class LegacyBlockStatePopulator extends BlockPopulator {
|
||||
|
||||
private final IndependentPlotGenerator plotGenerator;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
public LegacyBlockStatePopulator(
|
||||
final @NonNull IndependentPlotGenerator plotGenerator
|
||||
) {
|
||||
this.plotGenerator = plotGenerator;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void populate(@NotNull final World world, @NotNull final Random random, @NotNull final Chunk source) {
|
||||
int chunkMinX = source.getX() << 4;
|
||||
int chunkMinZ = source.getZ() << 4;
|
||||
PlotArea area = Location.at(world.getName(), chunkMinX, 0, chunkMinZ).getPlotArea();
|
||||
if (area == null || (area instanceof HybridPlotWorld hpw && !hpw.populationNeeded()) || area instanceof SinglePlotArea) {
|
||||
return;
|
||||
}
|
||||
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(new BukkitWorld(world));
|
||||
queue.setForceSync(true);
|
||||
queue.setSideEffectSet(SideEffectSet.none());
|
||||
queue.setBiomesEnabled(false);
|
||||
queue.setChunkObject(source);
|
||||
Location min = UncheckedWorldLocation.at(world.getName(), chunkMinX, world.getMinHeight(), chunkMinZ);
|
||||
Location max = UncheckedWorldLocation.at(world.getName(), chunkMinX + 15, world.getMaxHeight(), chunkMinZ + 15);
|
||||
ScopedQueueCoordinator offsetChunkQueue = new ScopedQueueCoordinator(queue, min, max);
|
||||
this.plotGenerator.populateChunk(offsetChunkQueue, area);
|
||||
queue.enqueue();
|
||||
}
|
||||
|
||||
}
|
||||
@@ -354,8 +354,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(
|
||||
@@ -551,10 +550,6 @@ public class BlockEventListener implements Listener {
|
||||
if (plot == null) {
|
||||
return;
|
||||
}
|
||||
if (location.getY() >= area.getMaxBuildHeight() || location.getY() < area.getMinBuildHeight()) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
switch (event.getNewState().getType()) {
|
||||
case SNOW:
|
||||
case SNOW_BLOCK:
|
||||
@@ -654,8 +649,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;
|
||||
}
|
||||
@@ -754,66 +748,62 @@ public class BlockEventListener implements Listener {
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
|
||||
public void onChange(BlockFromToEvent event) {
|
||||
Block fromBlock = event.getBlock();
|
||||
Block from = event.getBlock();
|
||||
|
||||
// Check liquid flow flag inside of origin plot too
|
||||
final Location fromLocation = BukkitUtil.adapt(fromBlock.getLocation());
|
||||
final PlotArea fromArea = fromLocation.getPlotArea();
|
||||
final Location fLocation = BukkitUtil.adapt(from.getLocation());
|
||||
final PlotArea fromArea = fLocation.getPlotArea();
|
||||
if (fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocation);
|
||||
if (fromPlot != null && fromPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
|
||||
final Plot plot = fromArea.getOwnedPlot(fLocation);
|
||||
if (plot != null && plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
|
||||
.getBlock()
|
||||
.isLiquid()) {
|
||||
fromPlot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
plot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Block toBlock = event.getToBlock();
|
||||
Location toLocation = BukkitUtil.adapt(toBlock.getLocation());
|
||||
PlotArea toArea = toLocation.getPlotArea();
|
||||
if (toArea == null) {
|
||||
if (fromBlock.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
Block to = event.getToBlock();
|
||||
Location tLocation = BukkitUtil.adapt(to.getLocation());
|
||||
PlotArea area = tLocation.getPlotArea();
|
||||
if (area == null) {
|
||||
if (from.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (toLocation.getY() >= toArea.getMaxBuildHeight() || toLocation.getY() < toArea.getMinBuildHeight()) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
Plot toPlot = toArea.getOwnedPlot(toLocation);
|
||||
Plot plot = area.getOwnedPlot(tLocation);
|
||||
|
||||
if (fromBlock.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocation);
|
||||
if (from.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fLocation);
|
||||
|
||||
if (fromPlot != null || toPlot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(toPlot)) && (toPlot == null || !toPlot.equals(fromPlot))) {
|
||||
if (fromPlot != null || plot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(plot)) && (plot == null || !plot.equals(fromPlot))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (toPlot != null) {
|
||||
if (!toArea.contains(fromLocation.getX(), fromLocation.getZ()) || !Objects.equals(toPlot, toArea.getOwnedPlot(fromLocation))) {
|
||||
if (plot != null) {
|
||||
if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
if (toPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event.getBlock().isLiquid()) {
|
||||
if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event.getBlock().isLiquid()) {
|
||||
return;
|
||||
}
|
||||
if (toPlot.getFlag(DisablePhysicsFlag.class)) {
|
||||
toPlot.debug(event.getBlock().getType() + " could not update because disable-physics = true");
|
||||
if (plot.getFlag(DisablePhysicsFlag.class)) {
|
||||
plot.debug(event.getBlock().getType() + " could not update because disable-physics = true");
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
if (toPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
|
||||
toPlot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
|
||||
plot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!toArea.contains(fromLocation.getX(), fromLocation.getZ()) || !Objects.equals(null, toArea.getOwnedPlot(fromLocation))) {
|
||||
} else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(null, area.getOwnedPlot(fLocation))) {
|
||||
event.setCancelled(true);
|
||||
} else if (event.getBlock().isLiquid()) {
|
||||
final org.bukkit.Location location = event.getBlock().getLocation();
|
||||
|
||||
@@ -168,7 +168,6 @@ public class EntityEventListener implements Listener {
|
||||
case "RAID":
|
||||
case "SHEARED":
|
||||
case "SILVERFISH_BLOCK":
|
||||
case "ENDER_PEARL":
|
||||
case "TRAP":
|
||||
case "VILLAGE_DEFENSE":
|
||||
case "VILLAGE_INVASION":
|
||||
|
||||
@@ -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;
|
||||
@@ -196,7 +195,6 @@ public class PaperListener implements Listener {
|
||||
case "RAID":
|
||||
case "SHEARED":
|
||||
case "SILVERFISH_BLOCK":
|
||||
case "ENDER_PEARL":
|
||||
case "TRAP":
|
||||
case "VILLAGE_DEFENSE":
|
||||
case "VILLAGE_INVASION":
|
||||
@@ -354,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,13 +74,11 @@ 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 boolean forceSync;
|
||||
|
||||
private final AtomicInteger expectedSize;
|
||||
private int batchSize;
|
||||
private PlotSquaredTask task;
|
||||
private volatile boolean shouldCancel;
|
||||
private boolean shouldCancel;
|
||||
private boolean finished;
|
||||
|
||||
@Inject
|
||||
@@ -93,8 +91,7 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
@Assisted final @NonNull Runnable whenDone,
|
||||
@Assisted final @NonNull Consumer<Throwable> throwableConsumer,
|
||||
@Assisted final boolean unloadAfter,
|
||||
@Assisted final @NonNull Collection<ProgressSubscriber> progressSubscribers,
|
||||
@Assisted final boolean forceSync
|
||||
@Assisted final @NonNull Collection<ProgressSubscriber> progressSubscribers
|
||||
) {
|
||||
this.requestedChunks = new LinkedBlockingQueue<>(requestedChunks);
|
||||
this.availableChunks = new LinkedBlockingQueue<>();
|
||||
@@ -109,27 +106,14 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
this.plugin = JavaPlugin.getPlugin(BukkitPlatform.class);
|
||||
this.bukkitWorld = Bukkit.getWorld(world.getName());
|
||||
this.progressSubscribers.addAll(progressSubscribers);
|
||||
this.forceSync = forceSync;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void start() {
|
||||
if (!forceSync) {
|
||||
// Request initial batch
|
||||
this.requestBatch();
|
||||
// Wait until next tick to give the chunks a chance to be loaded
|
||||
TaskManager.runTaskLater(() -> task = TaskManager.runTaskRepeat(this, TaskTime.ticks(1)), TaskTime.ticks(1));
|
||||
} else {
|
||||
try {
|
||||
while (!shouldCancel && !requestedChunks.isEmpty()) {
|
||||
chunkConsumer.accept(requestedChunks.poll());
|
||||
}
|
||||
} catch (Throwable t) {
|
||||
throwableConsumer.accept(t);
|
||||
} finally {
|
||||
finish();
|
||||
}
|
||||
}
|
||||
// Request initial batch
|
||||
this.requestBatch();
|
||||
// Wait until next tick to give the chunks a chance to be loaded
|
||||
TaskManager.runTaskLater(() -> task = TaskManager.runTaskRepeat(this, TaskTime.ticks(1)), TaskTime.ticks(1));
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -146,9 +130,7 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
for (final ProgressSubscriber subscriber : this.progressSubscribers) {
|
||||
subscriber.notifyEnd();
|
||||
}
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
}
|
||||
task.cancel();
|
||||
finished = true;
|
||||
}
|
||||
}
|
||||
@@ -168,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];
|
||||
@@ -222,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
|
||||
|
||||
@@ -51,7 +51,6 @@ import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.Container;
|
||||
import org.bukkit.block.data.BlockData;
|
||||
@@ -63,27 +62,10 @@ import java.util.function.Consumer;
|
||||
|
||||
public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
|
||||
private static final SideEffectSet NO_SIDE_EFFECT_SET;
|
||||
private static final SideEffectSet EDGE_SIDE_EFFECT_SET;
|
||||
private static final SideEffectSet LIGHTING_SIDE_EFFECT_SET;
|
||||
private static final SideEffectSet EDGE_LIGHTING_SIDE_EFFECT_SET;
|
||||
|
||||
static {
|
||||
NO_SIDE_EFFECT_SET = SideEffectSet.none().with(SideEffect.LIGHTING, SideEffect.State.OFF).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.OFF
|
||||
);
|
||||
EDGE_SIDE_EFFECT_SET = SideEffectSet.none().with(SideEffect.UPDATE, SideEffect.State.ON).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.ON
|
||||
);
|
||||
LIGHTING_SIDE_EFFECT_SET = SideEffectSet.none().with(SideEffect.NEIGHBORS, SideEffect.State.OFF);
|
||||
EDGE_LIGHTING_SIDE_EFFECT_SET = SideEffectSet.none().with(SideEffect.UPDATE, SideEffect.State.ON).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.ON
|
||||
);
|
||||
}
|
||||
|
||||
private final SideEffectSet noSideEffectSet;
|
||||
private final SideEffectSet lightingSideEffectSet;
|
||||
private final SideEffectSet edgeSideEffectSet;
|
||||
private final SideEffectSet edgeLightingSideEffectSet;
|
||||
private org.bukkit.World bukkitWorld;
|
||||
@Inject
|
||||
private ChunkCoordinatorBuilderFactory chunkCoordinatorBuilderFactory;
|
||||
@@ -94,6 +76,19 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
@Inject
|
||||
public BukkitQueueCoordinator(@NonNull World world) {
|
||||
super(world);
|
||||
noSideEffectSet = SideEffectSet.none().with(SideEffect.LIGHTING, SideEffect.State.OFF).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.OFF
|
||||
);
|
||||
lightingSideEffectSet = SideEffectSet.none().with(SideEffect.NEIGHBORS, SideEffect.State.OFF);
|
||||
edgeSideEffectSet = noSideEffectSet.with(SideEffect.UPDATE, SideEffect.State.ON).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.ON
|
||||
);
|
||||
edgeLightingSideEffectSet = noSideEffectSet.with(SideEffect.UPDATE, SideEffect.State.ON).with(
|
||||
SideEffect.NEIGHBORS,
|
||||
SideEffect.State.ON
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
@@ -116,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);
|
||||
@@ -139,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++) {
|
||||
@@ -175,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
|
||||
@@ -184,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;
|
||||
@@ -206,7 +201,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
localChunk.getTiles().forEach((blockVector3, tag) -> {
|
||||
try {
|
||||
BaseBlock block = getWorld().getBlock(blockVector3).toBaseBlock(tag);
|
||||
getWorld().setBlock(blockVector3, block, getSideEffectSet(SideEffectState.NONE));
|
||||
getWorld().setBlock(blockVector3, block, noSideEffectSet);
|
||||
} catch (WorldEditException ignored) {
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
sw.restoreTag(getWorld().getName(), blockVector3.getX(), blockVector3.getY(), blockVector3.getZ());
|
||||
@@ -263,21 +258,15 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
SideEffectSet sideEffectSet;
|
||||
if (lighting) {
|
||||
sideEffectSet = getSideEffectSet(edge ? SideEffectState.EDGE_LIGHTING : SideEffectState.LIGHTING);
|
||||
sideEffectSet = edge ? edgeLightingSideEffectSet : lightingSideEffectSet;
|
||||
} else {
|
||||
sideEffectSet = getSideEffectSet(edge ? SideEffectState.EDGE : SideEffectState.NONE);
|
||||
sideEffectSet = edge ? edgeSideEffectSet : noSideEffectSet;
|
||||
}
|
||||
getWorld().setBlock(loc, block, sideEffectSet);
|
||||
} catch (WorldEditException ignored) {
|
||||
// Fallback to not so nice method
|
||||
BlockData blockData = BukkitAdapter.adapt(block);
|
||||
Block existing;
|
||||
// Assume a chunk object has been given only when it should have been.
|
||||
if (getChunkObject() instanceof Chunk chunkObject) {
|
||||
existing = chunkObject.getBlock(x & 15, y, z & 15);
|
||||
} else {
|
||||
existing = getBukkitWorld().getBlockAt(x, y, z);
|
||||
}
|
||||
Block existing = getBukkitWorld().getBlockAt(x, y, z);
|
||||
final BlockState existingBaseBlock = BukkitAdapter.adapt(existing.getBlockData());
|
||||
if (BukkitBlockUtil.get(existing).equals(existingBaseBlock) && existing.getBlockData().matches(blockData)) {
|
||||
return;
|
||||
@@ -293,7 +282,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
CompoundTag tag = block.getNbtData();
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
|
||||
sw.restoreTag(existing);
|
||||
sw.restoreTag(getWorld().getName(), existing.getX(), existing.getY(), existing.getZ());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -306,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;
|
||||
}
|
||||
@@ -386,23 +374,4 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
return false;
|
||||
}
|
||||
|
||||
private SideEffectSet getSideEffectSet(SideEffectState state) {
|
||||
if (getSideEffectSet() != null) {
|
||||
return getSideEffectSet();
|
||||
}
|
||||
return switch (state) {
|
||||
case NONE -> NO_SIDE_EFFECT_SET;
|
||||
case EDGE -> EDGE_SIDE_EFFECT_SET;
|
||||
case LIGHTING -> LIGHTING_SIDE_EFFECT_SET;
|
||||
case EDGE_LIGHTING -> EDGE_LIGHTING_SIDE_EFFECT_SET;
|
||||
};
|
||||
}
|
||||
|
||||
private enum SideEffectState {
|
||||
NONE,
|
||||
EDGE,
|
||||
LIGHTING,
|
||||
EDGE_LIGHTING
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -1,128 +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.bukkit.queue;
|
||||
|
||||
import com.plotsquared.bukkit.schematic.StateWrapper;
|
||||
import com.plotsquared.core.queue.DelegateQueueCoordinator;
|
||||
import com.sk89q.jnbt.CompoundTag;
|
||||
import com.sk89q.worldedit.bukkit.BukkitAdapter;
|
||||
import com.sk89q.worldedit.entity.Entity;
|
||||
import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
import org.apache.logging.log4j.LogManager;
|
||||
import org.apache.logging.log4j.Logger;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.generator.LimitedRegion;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
/**
|
||||
* Wraps a {@link LimitedRegion} inside a {@link com.plotsquared.core.queue.QueueCoordinator} so it can be written to.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
public class LimitedRegionWrapperQueue extends DelegateQueueCoordinator {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + LimitedRegionWrapperQueue.class.getSimpleName());
|
||||
|
||||
private final LimitedRegion limitedRegion;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
public LimitedRegionWrapperQueue(LimitedRegion limitedRegion) {
|
||||
super(null);
|
||||
this.limitedRegion = limitedRegion;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(final int x, final int y, final int z, @NonNull final Pattern pattern) {
|
||||
return setBlock(x, y, z, pattern.applyBlock(BlockVector3.at(x, y, z)));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(final int x, final int y, final int z, @NonNull final BaseBlock id) {
|
||||
boolean result = setBlock(x, y, z, id.toImmutableState());
|
||||
if (result && id.hasNbtData()) {
|
||||
CompoundTag tag = id.getNbtData();
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
try {
|
||||
sw.restoreTag(limitedRegion.getBlockState(x, y, z).getBlock());
|
||||
} catch (IllegalArgumentException e) {
|
||||
LOGGER.error("Error attempting to populate tile entity into the world at location {},{},{}", x, y, z, e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(final int x, final int y, final int z, @NonNull final BlockState id) {
|
||||
try {
|
||||
limitedRegion.setType(x, y, z, BukkitAdapter.adapt(id.getBlockType()));
|
||||
limitedRegion.setBlockData(x, y, z, BukkitAdapter.adapt(id));
|
||||
} catch (IllegalArgumentException e) {
|
||||
LOGGER.error("Error attempting to populate block into the world at location {},{},{}", x, y, z, e);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setEntity(@NonNull final Entity entity) {
|
||||
EntityType type = BukkitAdapter.adapt(entity.getState().getType());
|
||||
double x = entity.getLocation().getX();
|
||||
double y = entity.getLocation().getY();
|
||||
double z = entity.getLocation().getZ();
|
||||
Location location = new Location(limitedRegion.getWorld(), x, y, z);
|
||||
try {
|
||||
limitedRegion.spawnEntity(location, type);
|
||||
} catch (IllegalArgumentException e) {
|
||||
LOGGER.error("Error attempting to populate entity into the world at location {},{},{}", (int) x, (int) y, (int) z, e);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setTile(final int x, final int y, final int z, @NonNull final CompoundTag tag) {
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
try {
|
||||
return sw.restoreTag(limitedRegion.getBlockState(x, y, z).getBlock());
|
||||
} catch (IllegalArgumentException e) {
|
||||
LOGGER.error("Error attempting to populate tile entity into the world at location {},{},{}", x, y, z, e);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean isSettingTiles() {
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -35,18 +35,15 @@ import com.sk89q.jnbt.Tag;
|
||||
import com.sk89q.worldedit.blocks.BaseItemStack;
|
||||
import com.sk89q.worldedit.bukkit.BukkitAdapter;
|
||||
import com.sk89q.worldedit.world.item.ItemType;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.Container;
|
||||
import org.bukkit.block.Sign;
|
||||
import org.bukkit.block.Skull;
|
||||
import org.bukkit.enchantments.Enchantment;
|
||||
import org.bukkit.inventory.Inventory;
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
@@ -59,11 +56,6 @@ public class StateWrapper {
|
||||
public org.bukkit.block.BlockState state = null;
|
||||
public CompoundTag tag = null;
|
||||
|
||||
/**
|
||||
* @deprecated in favour of using WE methods for obtaining NBT, specifically by obtaining a
|
||||
* {@link com.sk89q.worldedit.world.block.BaseBlock} and then using {@link com.sk89q.worldedit.world.block.BaseBlock#getNbtData()}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public StateWrapper(org.bukkit.block.BlockState state) {
|
||||
this.state = state;
|
||||
}
|
||||
@@ -174,32 +166,14 @@ public class StateWrapper {
|
||||
return str;
|
||||
}
|
||||
|
||||
/**
|
||||
* Restore the TileEntity data to the given world at the given coordinates.
|
||||
*
|
||||
* @param worldName World name
|
||||
* @param x x position
|
||||
* @param y y position
|
||||
* @param z z position
|
||||
* @return true if successful
|
||||
*/
|
||||
@SuppressWarnings("deprecation") // #setLine is needed for Spigot compatibility
|
||||
public boolean restoreTag(String worldName, int x, int y, int z) {
|
||||
World world = BukkitUtil.getWorld(worldName);
|
||||
if (world == null) {
|
||||
if (this.tag == null) {
|
||||
return false;
|
||||
}
|
||||
return restoreTag(world.getBlockAt(x, y, z));
|
||||
}
|
||||
|
||||
/**
|
||||
* Restore the TileEntity data to the given block
|
||||
*
|
||||
* @param block Block to restore to
|
||||
* @return true if successful
|
||||
*/
|
||||
@SuppressWarnings("deprecation") // #setLine is needed for Spigot compatibility
|
||||
public boolean restoreTag(@NonNull Block block) {
|
||||
if (this.tag == null) {
|
||||
World world = BukkitUtil.getWorld(worldName);
|
||||
Block block = world.getBlockAt(x, y, z);
|
||||
if (block == null) {
|
||||
return false;
|
||||
}
|
||||
org.bukkit.block.BlockState state = block.getState();
|
||||
@@ -237,37 +211,10 @@ public class StateWrapper {
|
||||
}
|
||||
return false;
|
||||
}
|
||||
case "skull" -> {
|
||||
if (state instanceof Skull skull) {
|
||||
CompoundTag skullOwner = ((CompoundTag) this.tag.getValue().get("SkullOwner"));
|
||||
if (skullOwner == null) {
|
||||
return true;
|
||||
}
|
||||
String player = skullOwner.getString("Name");
|
||||
if (player == null || player.isEmpty()) {
|
||||
return false;
|
||||
}
|
||||
try {
|
||||
skull.setOwningPlayer(Bukkit.getOfflinePlayer(player));
|
||||
skull.update(true);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a CompoundTag of the contents of a block's inventory (chest, furnace, etc.).
|
||||
*
|
||||
* @deprecated in favour of using WorldEdit methods for obtaining NBT, specifically by obtaining a
|
||||
* {@link com.sk89q.worldedit.world.block.BaseBlock} and then using {@link com.sk89q.worldedit.world.block.BaseBlock#getNbtData()}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public CompoundTag getTag() {
|
||||
if (this.tag != null) {
|
||||
return this.tag;
|
||||
|
||||
@@ -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,16 +276,20 @@ 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;
|
||||
BaseBlock id = ids[yIndex];
|
||||
for (int y = 0; y < Math.min(128, ids.length); y++) {
|
||||
BaseBlock id = ids[y];
|
||||
if (id != null) {
|
||||
value.setBlock(x1, y, z1, id);
|
||||
} else {
|
||||
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);
|
||||
|
||||
@@ -76,7 +76,7 @@ public class BukkitSetupUtils extends SetupUtils {
|
||||
|
||||
@Override
|
||||
public void updateGenerators(final boolean force) {
|
||||
if (loaded && !SetupUtils.generators.isEmpty() && !force) {
|
||||
if (!SetupUtils.generators.isEmpty() && !force) {
|
||||
return;
|
||||
}
|
||||
String testWorld = "CheckingPlotSquaredGenerator";
|
||||
@@ -100,7 +100,6 @@ public class BukkitSetupUtils extends SetupUtils {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
loaded = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
||||
@@ -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,16 +83,6 @@ 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) {
|
||||
@@ -143,7 +103,7 @@ public class BukkitWorld implements World<org.bukkit.World> {
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof BukkitWorld;
|
||||
}
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
|
||||
## Enforcement
|
||||
|
||||
Instances of abusive, harassing, or otherwise unacceptable behavior may be
|
||||
reported by contacting the project team at contact@intellectualsites.com. All
|
||||
reported by contacting the project team at contact@alexander-soderberg.com. All
|
||||
complaints will be reviewed and investigated and will result in a response that
|
||||
is deemed necessary and appropriate to the circumstances. The project team is
|
||||
obligated to maintain confidentiality with regard to the reporter of an incident.
|
||||
|
||||
@@ -2,18 +2,18 @@ import java.time.format.DateTimeFormatter
|
||||
|
||||
dependencies {
|
||||
// Expected everywhere.
|
||||
compileOnlyApi("org.checkerframework:checker-qual")
|
||||
compileOnlyApi(libs.checkerqual)
|
||||
|
||||
// Minecraft expectations
|
||||
compileOnlyApi("com.google.code.gson:gson")
|
||||
compileOnly("com.google.guava:guava")
|
||||
compileOnlyApi(libs.gson)
|
||||
compileOnly(libs.guava)
|
||||
|
||||
// Platform expectations
|
||||
compileOnlyApi("org.yaml:snakeyaml")
|
||||
compileOnlyApi(libs.snakeyaml)
|
||||
|
||||
// Adventure
|
||||
api("net.kyori:adventure-api")
|
||||
api("net.kyori:adventure-text-minimessage")
|
||||
api(libs.adventure)
|
||||
api(libs.minimessage)
|
||||
|
||||
// Guice
|
||||
api(libs.guice) {
|
||||
@@ -22,7 +22,7 @@ dependencies {
|
||||
api(libs.guiceassistedinject) {
|
||||
exclude("com.google.inject", "guice")
|
||||
}
|
||||
api(libs.spotbugs)
|
||||
api(libs.findbugs)
|
||||
|
||||
// Plugins
|
||||
compileOnly(libs.worldeditCore) {
|
||||
@@ -31,18 +31,18 @@ dependencies {
|
||||
exclude(group = "dummypermscompat")
|
||||
}
|
||||
testImplementation(libs.worldeditCore)
|
||||
compileOnly("com.fastasyncworldedit:FastAsyncWorldEdit-Core") { isTransitive = false }
|
||||
testImplementation("com.fastasyncworldedit:FastAsyncWorldEdit-Core") { isTransitive = false }
|
||||
compileOnly(libs.fastasyncworldeditCore) { isTransitive = false }
|
||||
testImplementation(libs.fastasyncworldeditCore) { isTransitive = false }
|
||||
|
||||
// Logging
|
||||
compileOnlyApi("org.apache.logging.log4j:log4j-api")
|
||||
compileOnlyApi(libs.log4j)
|
||||
|
||||
// Other libraries
|
||||
api(libs.prtree)
|
||||
api(libs.aopalliance)
|
||||
api(libs.cloudServices)
|
||||
api(libs.arkitektonika)
|
||||
api("com.intellectualsites.paster:Paster")
|
||||
api(libs.paster)
|
||||
}
|
||||
|
||||
tasks.processResources {
|
||||
|
||||
@@ -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
|
||||
*
|
||||
|
||||
@@ -889,8 +889,8 @@ public class PlotSquared {
|
||||
e.printStackTrace();
|
||||
}
|
||||
LOGGER.info("| generator: {}>{}", baseGenerator, areaGen);
|
||||
LOGGER.info("| plot world: {}", pa.getClass().getCanonicalName());
|
||||
LOGGER.info("| manager: {}", pa.getPlotManager().getClass().getCanonicalName());
|
||||
LOGGER.info("| plot world: {}", pa);
|
||||
LOGGER.info("| manager: {}", pa);
|
||||
LOGGER.info("Note: Area created for cluster '{}' (invalid or old configuration?)", name);
|
||||
areaGen.getPlotGenerator().initialize(pa);
|
||||
areaGen.augment(pa);
|
||||
@@ -906,13 +906,6 @@ public class PlotSquared {
|
||||
throw new IllegalArgumentException("Invalid Generator: " + gen_string);
|
||||
}
|
||||
PlotArea pa = areaGen.getPlotGenerator().getNewPlotArea(world, null, null, null);
|
||||
LOGGER.info("- generator: {}>{}", baseGenerator, areaGen);
|
||||
LOGGER.info("- plot world: {}", pa.getClass().getCanonicalName());
|
||||
LOGGER.info("- plot area manager: {}", pa.getPlotManager().getClass().getCanonicalName());
|
||||
if (!this.worldConfiguration.contains(path)) {
|
||||
this.worldConfiguration.createSection(path);
|
||||
worldSection = this.worldConfiguration.getConfigurationSection(path);
|
||||
}
|
||||
pa.saveConfiguration(worldSection);
|
||||
pa.loadDefaultConfiguration(worldSection);
|
||||
try {
|
||||
@@ -920,6 +913,9 @@ public class PlotSquared {
|
||||
} catch (IOException e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
LOGGER.info("- generator: {}>{}", baseGenerator, areaGen);
|
||||
LOGGER.info("- plot world: {}", pa);
|
||||
LOGGER.info("- plot area manager: {}", pa.getPlotManager());
|
||||
areaGen.getPlotGenerator().initialize(pa);
|
||||
areaGen.augment(pa);
|
||||
addPlotArea(pa);
|
||||
@@ -1024,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
|
||||
@@ -1104,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(
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -161,7 +161,6 @@ public class Deny extends SubCommand {
|
||||
}
|
||||
|
||||
private void handleKick(PlotPlayer<?> player, Plot plot) {
|
||||
plot = plot.getBasePlot(false);
|
||||
if (player == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -32,7 +32,6 @@ import com.plotsquared.core.configuration.caption.Caption;
|
||||
import com.plotsquared.core.configuration.caption.CaptionHolder;
|
||||
import com.plotsquared.core.configuration.caption.Templates;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.database.DBFunc;
|
||||
import com.plotsquared.core.permissions.Permission;
|
||||
import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
@@ -40,7 +39,6 @@ import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.expiration.ExpireManager;
|
||||
import com.plotsquared.core.plot.flag.implementations.DoneFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.PriceFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.ServerPlotFlag;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.util.EconHandler;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
@@ -420,7 +418,7 @@ public class ListCmd extends SubCommand {
|
||||
Caption color;
|
||||
if (plot.getOwner() == null) {
|
||||
color = TranslatableCaption.of("info.plot_list_no_owner");
|
||||
} else if (plot.isOwner(player.getUUID()) || plot.getOwner().equals(DBFunc.EVERYONE)) {
|
||||
} else if (plot.isOwner(player.getUUID())) {
|
||||
color = TranslatableCaption.of("info.plot_list_owned_by");
|
||||
} else if (plot.isAdded(player.getUUID())) {
|
||||
color = TranslatableCaption.of("info.plot_list_added_to");
|
||||
@@ -458,60 +456,37 @@ public class ListCmd extends SubCommand {
|
||||
String prefix = "";
|
||||
String online = TranslatableCaption.of("info.plot_list_player_online").getComponent(player);
|
||||
String offline = TranslatableCaption.of("info.plot_list_player_offline").getComponent(player);
|
||||
String unknown = TranslatableCaption.of("info.plot_list_player_unknown").getComponent(player);
|
||||
String server = TranslatableCaption.of("info.plot_list_player_server").getComponent(player);
|
||||
String everyone = TranslatableCaption.of("info.plot_list_player_everyone").getComponent(player);
|
||||
TextComponent.Builder builder = Component.text();
|
||||
if (plot.getFlag(ServerPlotFlag.class)) {
|
||||
Template serverTemplate = Template.of(
|
||||
"info.server",
|
||||
TranslatableCaption.of("info.server").getComponent(player)
|
||||
);
|
||||
builder.append(MINI_MESSAGE.parse(server, serverTemplate));
|
||||
} else {
|
||||
try {
|
||||
final List<UUIDMapping> names = PlotSquared.get().getImpromptuUUIDPipeline().getNames(plot.getOwners())
|
||||
.get(Settings.UUID.BLOCKING_TIMEOUT, TimeUnit.MILLISECONDS);
|
||||
for (final UUIDMapping uuidMapping : names) {
|
||||
PlotPlayer<?> pp = PlotSquared.platform().playerManager().getPlayerIfExists(uuidMapping.getUuid());
|
||||
Template prefixTemplate = Template.of("prefix", prefix);
|
||||
Template playerTemplate = Template.of("player", uuidMapping.getUsername());
|
||||
if (pp != null) {
|
||||
builder.append(MINI_MESSAGE.parse(online, prefixTemplate, playerTemplate));
|
||||
} else if (uuidMapping.getUsername().equalsIgnoreCase("unknown")) {
|
||||
Template unknownTemplate = Template.of(
|
||||
"info.unknown",
|
||||
TranslatableCaption.of("info.unknown").getComponent(player)
|
||||
);
|
||||
builder.append(MINI_MESSAGE.parse(unknown, unknownTemplate));
|
||||
} else if (uuidMapping.getUuid().equals(DBFunc.EVERYONE)) {
|
||||
Template everyoneTemplate = Template.of(
|
||||
"info.everyone",
|
||||
TranslatableCaption.of("info.everyone").getComponent(player)
|
||||
);
|
||||
builder.append(MINI_MESSAGE.parse(everyone, everyoneTemplate));
|
||||
} else {
|
||||
builder.append(MINI_MESSAGE.parse(offline, prefixTemplate, playerTemplate));
|
||||
}
|
||||
prefix = ", ";
|
||||
try {
|
||||
final List<UUIDMapping> names = PlotSquared.get().getImpromptuUUIDPipeline().getNames(plot.getOwners())
|
||||
.get(Settings.UUID.BLOCKING_TIMEOUT, TimeUnit.MILLISECONDS);
|
||||
for (final UUIDMapping uuidMapping : names) {
|
||||
PlotPlayer<?> pp = PlotSquared.platform().playerManager().getPlayerIfExists(uuidMapping.getUuid());
|
||||
Template prefixTemplate = Template.of("prefix", prefix);
|
||||
Template playerTemplate = Template.of("player", uuidMapping.getUsername());
|
||||
if (pp != null) {
|
||||
builder.append(MINI_MESSAGE.parse(online, prefixTemplate, playerTemplate));
|
||||
} else {
|
||||
builder.append(MINI_MESSAGE.parse(offline, prefixTemplate, playerTemplate));
|
||||
}
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
final StringBuilder playerBuilder = new StringBuilder();
|
||||
final Iterator<UUID> uuidIterator = plot.getOwners().iterator();
|
||||
while (uuidIterator.hasNext()) {
|
||||
final UUID uuid = uuidIterator.next();
|
||||
playerBuilder.append(uuid);
|
||||
if (uuidIterator.hasNext()) {
|
||||
playerBuilder.append(", ");
|
||||
}
|
||||
}
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("errors.invalid_player"),
|
||||
Templates.of("value", playerBuilder.toString())
|
||||
);
|
||||
} catch (TimeoutException e) {
|
||||
player.sendMessage(TranslatableCaption.of("players.fetching_players_timeout"));
|
||||
prefix = ", ";
|
||||
}
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
final StringBuilder playerBuilder = new StringBuilder();
|
||||
final Iterator<UUID> uuidIterator = plot.getOwners().iterator();
|
||||
while (uuidIterator.hasNext()) {
|
||||
final UUID uuid = uuidIterator.next();
|
||||
playerBuilder.append(uuid);
|
||||
if (uuidIterator.hasNext()) {
|
||||
playerBuilder.append(", ");
|
||||
}
|
||||
}
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("errors.invalid_player"),
|
||||
Templates.of("value", playerBuilder.toString())
|
||||
);
|
||||
} catch (TimeoutException e) {
|
||||
player.sendMessage(TranslatableCaption.of("players.fetching_players_timeout"));
|
||||
}
|
||||
Template players = Template.of("players", builder.asComponent());
|
||||
caption.set(TranslatableCaption.of("info.plot_list_item"));
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -249,9 +249,6 @@ public class Settings extends Config {
|
||||
public static int UUID_CACHE_SIZE = 100000;
|
||||
@Comment("Rate limit (per 10 minutes) for background UUID fetching from the Mojang API")
|
||||
public static int BACKGROUND_LIMIT = 200;
|
||||
@Comment("Whether the Mojang API service is enabled for impromptu api calls. If false only the Background task will use" +
|
||||
" http requests to fill the UUID cache (requires restart)")
|
||||
public static boolean IMPROMPTU_SERVICE_MOJANG_API = true;
|
||||
@Comment("Rate limit (per 10 minutes) for random UUID fetching from the Mojang API")
|
||||
public static int IMPROMPTU_LIMIT = 300;
|
||||
@Comment("Timeout (in milliseconds) for non-blocking UUID requests (mostly commands)")
|
||||
@@ -694,7 +691,6 @@ public class Settings extends Config {
|
||||
@Comment({"If blocks at the edges of queued operations should be set causing updates",
|
||||
" - Slightly slower, but prevents issues such as fences left connected to nothing"})
|
||||
public static boolean UPDATE_EDGES = true;
|
||||
|
||||
}
|
||||
|
||||
@Comment("Settings related to tab completion")
|
||||
|
||||
@@ -54,23 +54,12 @@ public class AugmentedUtils {
|
||||
enabled = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate an augmented world chunk at the given location. If a queue is given, the data will be written to it, else a new
|
||||
* queue will be created and written to world. Returns true if generation occurred.
|
||||
*
|
||||
* @param world World name to generate data for. Must be a PlotSquared world containing one or more areas else nothing will
|
||||
* happen.
|
||||
* @param chunkX Chunk X position
|
||||
* @param chunkZ Chunk Z position
|
||||
* @param queue Queue to write to, if desired.
|
||||
* @return true if generation occurred.
|
||||
* @since 6.8.0
|
||||
*/
|
||||
public static boolean generateChunk(
|
||||
public static boolean generate(
|
||||
@Nullable Object chunkObject,
|
||||
final @NonNull String world,
|
||||
final int chunkX,
|
||||
final int chunkZ,
|
||||
@Nullable QueueCoordinator queue
|
||||
QueueCoordinator queue
|
||||
) {
|
||||
if (!enabled) {
|
||||
return false;
|
||||
@@ -81,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()) {
|
||||
@@ -108,6 +97,9 @@ public class AugmentedUtils {
|
||||
.platform()
|
||||
.worldUtil()
|
||||
.getWeWorld(world));
|
||||
if (chunkObject != null) {
|
||||
queue.setChunkObject(chunkObject);
|
||||
}
|
||||
}
|
||||
QueueCoordinator primaryMask;
|
||||
// coordinates
|
||||
@@ -130,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];
|
||||
@@ -141,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;
|
||||
@@ -158,24 +149,30 @@ 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);
|
||||
}
|
||||
}
|
||||
}
|
||||
generationResult = true;
|
||||
}
|
||||
if (chunkObject != null) {
|
||||
primaryMask.setChunkObject(chunkObject);
|
||||
}
|
||||
if (chunkObject != null) {
|
||||
secondaryMask.setChunkObject(chunkObject);
|
||||
}
|
||||
|
||||
// This queue should not be enqueued as it is simply used to restrict block setting, and then delegate to the
|
||||
// actual queue
|
||||
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);
|
||||
scoped.setForceSync(true);
|
||||
scoped.enqueue();
|
||||
}
|
||||
if (enqueue) {
|
||||
queue.enqueue();
|
||||
@@ -183,19 +180,4 @@ public class AugmentedUtils {
|
||||
return generationResult;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Use {@link AugmentedUtils#generateChunk(String, int, int, QueueCoordinator)} as chunkObject is not required
|
||||
* in the above method
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.8.0")
|
||||
public static boolean generate(
|
||||
@Nullable Object chunkObject,
|
||||
final @NonNull String world,
|
||||
final int chunkX,
|
||||
final int chunkZ,
|
||||
QueueCoordinator queue
|
||||
) {
|
||||
return generateChunk(world, chunkX, chunkZ, queue);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -35,23 +35,13 @@ import com.plotsquared.core.plot.PlotArea;
|
||||
import com.plotsquared.core.plot.PlotId;
|
||||
import com.plotsquared.core.queue.ScopedQueueCoordinator;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.sk89q.worldedit.entity.BaseEntity;
|
||||
import com.sk89q.worldedit.entity.Entity;
|
||||
import com.sk89q.worldedit.extent.Extent;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import com.sk89q.worldedit.math.Vector3;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.regions.RegionOperationException;
|
||||
import com.sk89q.worldedit.world.NullWorld;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
import com.sk89q.worldedit.world.block.BlockTypes;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
public class HybridGen extends IndependentPlotGenerator {
|
||||
|
||||
private static final CuboidRegion CHUNK = new CuboidRegion(BlockVector3.ZERO, BlockVector3.at(15, 396, 15));
|
||||
private final HybridPlotWorldFactory hybridPlotWorldFactory;
|
||||
|
||||
@Inject
|
||||
@@ -65,17 +55,12 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
|
||||
private void placeSchem(
|
||||
HybridPlotWorld world,
|
||||
ScopedQueueCoordinator result,
|
||||
short relativeX,
|
||||
short relativeZ,
|
||||
int x,
|
||||
int z,
|
||||
boolean isRoad,
|
||||
boolean isPopulating
|
||||
HybridPlotWorld world, ScopedQueueCoordinator result, short relativeX,
|
||||
short relativeZ, int x, int z, boolean isRoad
|
||||
) {
|
||||
int minY; // Math.min(world.PLOT_HEIGHT, world.ROAD_HEIGHT);
|
||||
if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad && Settings.Schematics.PASTE_ON_TOP)) {
|
||||
if ((isRoad && Settings.Schematics.PASTE_ROAD_ON_TOP) || (!isRoad
|
||||
&& Settings.Schematics.PASTE_ON_TOP)) {
|
||||
minY = world.SCHEM_Y;
|
||||
} else {
|
||||
minY = world.getMinBuildHeight();
|
||||
@@ -84,9 +69,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
if (blocks != null) {
|
||||
for (int y = 0; y < blocks.length; y++) {
|
||||
if (blocks[y] != null) {
|
||||
if (!isPopulating || blocks[y].hasNbtData()) {
|
||||
result.setBlock(x, minY + y, z, blocks[y]);
|
||||
}
|
||||
result.setBlock(x, minY + y, z, blocks[y]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -108,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());
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -138,38 +121,42 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
short[] relativeX = new short[16];
|
||||
boolean[] insideRoadX = new boolean[16];
|
||||
boolean[] insideWallX = new boolean[16];
|
||||
short offsetX = relativeOffsetX;
|
||||
for (short i = 0; i < 16; i++) {
|
||||
if (offsetX >= hybridPlotWorld.SIZE) {
|
||||
offsetX -= hybridPlotWorld.SIZE;
|
||||
short v = (short) (relativeOffsetX + i);
|
||||
while (v >= hybridPlotWorld.SIZE) {
|
||||
v -= hybridPlotWorld.SIZE;
|
||||
}
|
||||
relativeX[i] = offsetX;
|
||||
relativeX[i] = v;
|
||||
if (hybridPlotWorld.ROAD_WIDTH != 0) {
|
||||
insideRoadX[i] = offsetX < hybridPlotWorld.PATH_WIDTH_LOWER || offsetX > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideWallX[i] = offsetX == hybridPlotWorld.PATH_WIDTH_LOWER || offsetX == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideRoadX[i] =
|
||||
v < hybridPlotWorld.PATH_WIDTH_LOWER || v > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideWallX[i] =
|
||||
v == hybridPlotWorld.PATH_WIDTH_LOWER || v == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
}
|
||||
offsetX++;
|
||||
}
|
||||
// The Z-coordinate of a given Z coordinate, relative to the
|
||||
// plot (Counting from the corner with the least positive
|
||||
// coordinates)
|
||||
short[] relativeZ = new short[16];
|
||||
// Whether or not the given Z coordinate belongs to the road
|
||||
boolean[] insideRoadZ = new boolean[16];
|
||||
// Whether or not the given Z coordinate belongs to the wall
|
||||
boolean[] insideWallZ = new boolean[16];
|
||||
short offsetZ = relativeOffsetZ;
|
||||
for (short i = 0; i < 16; i++) {
|
||||
if (offsetZ >= hybridPlotWorld.SIZE) {
|
||||
offsetZ -= hybridPlotWorld.SIZE;
|
||||
short v = (short) (relativeOffsetZ + i);
|
||||
while (v >= hybridPlotWorld.SIZE) {
|
||||
v -= hybridPlotWorld.SIZE;
|
||||
}
|
||||
relativeZ[i] = offsetZ;
|
||||
relativeZ[i] = v;
|
||||
if (hybridPlotWorld.ROAD_WIDTH != 0) {
|
||||
insideRoadZ[i] = offsetZ < hybridPlotWorld.PATH_WIDTH_LOWER || offsetZ > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideWallZ[i] = offsetZ == hybridPlotWorld.PATH_WIDTH_LOWER || offsetZ == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideRoadZ[i] =
|
||||
v < hybridPlotWorld.PATH_WIDTH_LOWER || v > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideWallZ[i] =
|
||||
v == hybridPlotWorld.PATH_WIDTH_LOWER || v == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
}
|
||||
offsetZ++;
|
||||
}
|
||||
// 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++) {
|
||||
@@ -178,7 +165,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
|
||||
}
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true);
|
||||
}
|
||||
}
|
||||
} else if (insideWallX[x]) {
|
||||
@@ -189,7 +176,9 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
|
||||
}
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
|
||||
true
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// wall
|
||||
@@ -198,10 +187,14 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
if (hybridPlotWorld.PLACE_TOP_BLOCK) {
|
||||
result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z, hybridPlotWorld.WALL_BLOCK.toPattern());
|
||||
result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
|
||||
hybridPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
} else {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
|
||||
true
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -213,7 +206,9 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
result.setBlock(x, y, z, hybridPlotWorld.ROAD_BLOCK.toPattern());
|
||||
}
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
|
||||
true
|
||||
);
|
||||
}
|
||||
} else if (insideWallZ[z]) {
|
||||
// wall
|
||||
@@ -222,19 +217,27 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
if (hybridPlotWorld.PLACE_TOP_BLOCK) {
|
||||
result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z, hybridPlotWorld.WALL_BLOCK.toPattern());
|
||||
result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
|
||||
hybridPlotWorld.WALL_BLOCK.toPattern()
|
||||
);
|
||||
}
|
||||
} else {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
|
||||
true
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// plot
|
||||
for (int y = startY; y < hybridPlotWorld.PLOT_HEIGHT; y++) {
|
||||
result.setBlock(x, y, z, hybridPlotWorld.MAIN_BLOCK.toPattern());
|
||||
}
|
||||
result.setBlock(x, hybridPlotWorld.PLOT_HEIGHT, z, hybridPlotWorld.TOP_BLOCK.toPattern());
|
||||
result.setBlock(x, hybridPlotWorld.PLOT_HEIGHT, z,
|
||||
hybridPlotWorld.TOP_BLOCK.toPattern()
|
||||
);
|
||||
if (hybridPlotWorld.PLOT_SCHEMATIC) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, false, false);
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
|
||||
false
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -242,138 +245,6 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean populateChunk(final ScopedQueueCoordinator result, final PlotArea settings) {
|
||||
HybridPlotWorld hybridPlotWorld = (HybridPlotWorld) settings;
|
||||
if (!hybridPlotWorld.populationNeeded()) {
|
||||
return false;
|
||||
}
|
||||
// Coords
|
||||
Location min = result.getMin();
|
||||
int bx = min.getX() - hybridPlotWorld.ROAD_OFFSET_X;
|
||||
int bz = min.getZ() - hybridPlotWorld.ROAD_OFFSET_Z;
|
||||
// The relative X-coordinate (within the plot) of the minimum X coordinate
|
||||
// contained in the scoped queue
|
||||
short relativeOffsetX;
|
||||
if (bx < 0) {
|
||||
relativeOffsetX = (short) (hybridPlotWorld.SIZE + (bx % hybridPlotWorld.SIZE));
|
||||
} else {
|
||||
relativeOffsetX = (short) (bx % hybridPlotWorld.SIZE);
|
||||
}
|
||||
// The relative Z-coordinate (within the plot) of the minimum Z coordinate
|
||||
// contained in the scoped queue
|
||||
short relativeOffsetZ;
|
||||
if (bz < 0) {
|
||||
relativeOffsetZ = (short) (hybridPlotWorld.SIZE + (bz % hybridPlotWorld.SIZE));
|
||||
} else {
|
||||
relativeOffsetZ = (short) (bz % hybridPlotWorld.SIZE);
|
||||
}
|
||||
boolean allRoad = true;
|
||||
boolean overlap = false;
|
||||
|
||||
// The X-coordinate of a given X coordinate, relative to the
|
||||
// plot (Counting from the corner with the least positive
|
||||
// coordinates)
|
||||
short[] relativeX = new short[16];
|
||||
boolean[] insideRoadX = new boolean[16];
|
||||
boolean[] insideWallX = new boolean[16];
|
||||
short offsetX = relativeOffsetX;
|
||||
for (short i = 0; i < 16; i++) {
|
||||
if (offsetX >= hybridPlotWorld.SIZE) {
|
||||
offsetX -= hybridPlotWorld.SIZE;
|
||||
overlap = true;
|
||||
}
|
||||
relativeX[i] = offsetX;
|
||||
if (hybridPlotWorld.ROAD_WIDTH != 0) {
|
||||
boolean insideRoad = offsetX < hybridPlotWorld.PATH_WIDTH_LOWER || offsetX > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
boolean insideWall = offsetX == hybridPlotWorld.PATH_WIDTH_LOWER || offsetX == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideRoadX[i] = insideRoad;
|
||||
insideWallX[i] = insideWall;
|
||||
allRoad &= insideRoad && insideWall;
|
||||
}
|
||||
offsetX++;
|
||||
}
|
||||
|
||||
// The Z-coordinate of a given Z coordinate, relative to the
|
||||
// plot (Counting from the corner with the least positive
|
||||
// coordinates)
|
||||
short[] relativeZ = new short[16];
|
||||
boolean[] insideRoadZ = new boolean[16];
|
||||
boolean[] insideWallZ = new boolean[16];
|
||||
short offsetZ = relativeOffsetZ;
|
||||
for (short i = 0; i < 16; i++) {
|
||||
if (offsetZ >= hybridPlotWorld.SIZE) {
|
||||
offsetZ -= hybridPlotWorld.SIZE;
|
||||
overlap = true;
|
||||
}
|
||||
relativeZ[i] = offsetZ;
|
||||
if (hybridPlotWorld.ROAD_WIDTH != 0) {
|
||||
boolean insideRoad = offsetZ < hybridPlotWorld.PATH_WIDTH_LOWER || offsetZ > hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
boolean insideWall = offsetZ == hybridPlotWorld.PATH_WIDTH_LOWER || offsetZ == hybridPlotWorld.PATH_WIDTH_UPPER;
|
||||
insideRoadZ[i] = insideRoad;
|
||||
insideWallZ[i] = insideWall;
|
||||
allRoad &= insideRoad && insideWall;
|
||||
}
|
||||
offsetZ++;
|
||||
}
|
||||
for (short x = 0; x < 16; x++) {
|
||||
if (insideRoadX[x] || insideWallX[x]) {
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, true);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
if (insideRoadZ[z] || insideWallZ[z]) {
|
||||
if (hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, true, true);
|
||||
}
|
||||
} else if (hybridPlotWorld.PLOT_SCHEMATIC) {
|
||||
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z, false, true);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!allRoad && hybridPlotWorld.getPlotSchematicEntities() != null && !hybridPlotWorld
|
||||
.getPlotSchematicEntities()
|
||||
.isEmpty()) {
|
||||
CuboidRegion region = CHUNK.clone();
|
||||
try {
|
||||
region.shift(hybridPlotWorld
|
||||
.getPlotSchematicMinPoint()
|
||||
.add(relativeOffsetX, 0, relativeOffsetZ)
|
||||
.subtract(hybridPlotWorld.PATH_WIDTH_LOWER + 1, 0, hybridPlotWorld.PATH_WIDTH_LOWER + 1));
|
||||
for (Entity entity : hybridPlotWorld.getPlotSchematicEntities()) {
|
||||
if (region.contains(entity.getLocation().toVector().toBlockPoint())) {
|
||||
Vector3 pos = (entity.getLocation().toVector()
|
||||
.subtract(region.getMinimumPoint().withY(hybridPlotWorld.getPlotSchematicMinPoint().getY()).toVector3()))
|
||||
.add(min.getBlockVector3().withY(hybridPlotWorld.SCHEM_Y).toVector3());
|
||||
result.setEntity(new PopulatingEntity(
|
||||
entity,
|
||||
new com.sk89q.worldedit.util.Location(NullWorld.getInstance(), pos)
|
||||
));
|
||||
}
|
||||
}
|
||||
} catch (RegionOperationException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
if (overlap) {
|
||||
try {
|
||||
region.shift(BlockVector3.at(-hybridPlotWorld.SIZE, 0, -hybridPlotWorld.SIZE));
|
||||
for (Entity entity : hybridPlotWorld.getPlotSchematicEntities()) {
|
||||
if (region.contains(entity.getLocation().toVector().toBlockPoint())) {
|
||||
result.setEntity(entity);
|
||||
}
|
||||
}
|
||||
} catch (RegionOperationException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public PlotArea getNewPlotArea(String world, String id, PlotId min, PlotId max) {
|
||||
return this.hybridPlotWorldFactory.create(world, id, this, min, max);
|
||||
@@ -384,58 +255,4 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
// All initialization is done in the PlotArea class
|
||||
}
|
||||
|
||||
/**
|
||||
* Wrapper to allow a WorldEdit {@link Entity} to effectively have a mutable location as the location in its NBT should be changed
|
||||
* when set to the world.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
private static final class PopulatingEntity implements Entity {
|
||||
|
||||
private final Entity parent;
|
||||
private com.sk89q.worldedit.util.Location location;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
private PopulatingEntity(Entity parent, com.sk89q.worldedit.util.Location location) {
|
||||
this.parent = parent;
|
||||
this.location = location;
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Override
|
||||
public BaseEntity getState() {
|
||||
return parent.getState();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean remove() {
|
||||
return parent.remove();
|
||||
}
|
||||
|
||||
@Override
|
||||
public com.sk89q.worldedit.util.Location getLocation() {
|
||||
return location;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setLocation(final com.sk89q.worldedit.util.Location location) {
|
||||
this.location = location;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Extent getExtent() {
|
||||
return parent.getExtent();
|
||||
}
|
||||
|
||||
@Nullable
|
||||
@Override
|
||||
public <T> T getFacet(final Class<? extends T> cls) {
|
||||
return parent.getFacet(cls);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -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()));
|
||||
|
||||
@@ -40,13 +40,11 @@ import com.plotsquared.core.plot.PlotId;
|
||||
import com.plotsquared.core.plot.PlotManager;
|
||||
import com.plotsquared.core.plot.schematic.Schematic;
|
||||
import com.plotsquared.core.queue.GlobalBlockQueue;
|
||||
import com.plotsquared.core.util.AnnotationHelper;
|
||||
import com.plotsquared.core.util.FileUtils;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.plotsquared.core.util.SchematicHandler;
|
||||
import com.sk89q.jnbt.CompoundTag;
|
||||
import com.sk89q.jnbt.CompoundTagBuilder;
|
||||
import com.sk89q.worldedit.entity.Entity;
|
||||
import com.sk89q.worldedit.extent.clipboard.Clipboard;
|
||||
import com.sk89q.worldedit.extent.transform.BlockTransformExtent;
|
||||
import com.sk89q.worldedit.internal.helper.MCDirections;
|
||||
@@ -60,13 +58,11 @@ import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
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 javax.annotation.Nullable;
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
|
||||
public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
@@ -75,7 +71,6 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
private static final AffineTransform transform = new AffineTransform().rotateY(90);
|
||||
public boolean ROAD_SCHEMATIC_ENABLED;
|
||||
public boolean PLOT_SCHEMATIC = false;
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public int PLOT_SCHEMATIC_HEIGHT = -1;
|
||||
public short PATH_WIDTH_LOWER;
|
||||
public short PATH_WIDTH_UPPER;
|
||||
@@ -84,12 +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;
|
||||
private List<Entity> schem3Entities = null;
|
||||
private BlockVector3 schem3MinPoint = null;
|
||||
private boolean schem1PopulationNeeded = false;
|
||||
private boolean schem2PopulationNeeded = false;
|
||||
private boolean schem3PopulationNeeded = false;
|
||||
|
||||
@Inject
|
||||
private SchematicHandler schematicHandler;
|
||||
@@ -108,7 +97,6 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
PlotSquared.platform().injector().injectMembers(this);
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public static byte wrap(byte data, int start) {
|
||||
if ((data >= start) && (data < (start + 4))) {
|
||||
data = (byte) ((((data - start) + 2) & 3) + start);
|
||||
@@ -116,7 +104,6 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
return data;
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public static byte wrap2(byte data, int start) {
|
||||
if ((data >= start) && (data < (start + 2))) {
|
||||
data = (byte) ((((data - start) + 1) & 1) + start);
|
||||
@@ -124,6 +111,8 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
return data;
|
||||
}
|
||||
|
||||
// FIXME depends on block ids
|
||||
// Possibly make abstract?
|
||||
public static BaseBlock rotate(BaseBlock id) {
|
||||
|
||||
CompoundTag tag = id.getNbtData();
|
||||
@@ -182,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);
|
||||
@@ -261,43 +250,32 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
Schematic schematic1 = this.schematicHandler.getSchematic(schematic1File);
|
||||
Schematic schematic2 = this.schematicHandler.getSchematic(schematic2File);
|
||||
Schematic schematic3 = this.schematicHandler.getSchematic(schematic3File);
|
||||
|
||||
// If the plot schematic contains entities, then they need to be populated upon generation.
|
||||
if (schematic3 != null && !schematic3.getClipboard().getEntities().isEmpty()) {
|
||||
this.schem3Entities = new ArrayList<>(schematic3.getClipboard().getEntities());
|
||||
this.schem3MinPoint = schematic3.getClipboard().getMinimumPoint();
|
||||
this.schem3PopulationNeeded = true;
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
@@ -332,34 +310,24 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
for (short x = 0; x < w3; x++) {
|
||||
for (short z = 0; z < l3; z++) {
|
||||
for (short y = 0; y < h3; y++) {
|
||||
BaseBlock id = blockArrayClipboard3.getFullBlock(BlockVector3.at(
|
||||
x + min.getBlockX(),
|
||||
y + min.getBlockY(),
|
||||
z + min.getBlockZ()
|
||||
));
|
||||
BaseBlock id =
|
||||
blockArrayClipboard3.getFullBlock(BlockVector3.at(
|
||||
x + min.getBlockX(),
|
||||
y + min.getBlockY(),
|
||||
z + min.getBlockZ()
|
||||
));
|
||||
if (!id.getBlockType().getMaterial().isAir()) {
|
||||
schem3PopulationNeeded |= id.hasNbtData();
|
||||
addOverlayBlock(
|
||||
(short) (x + shift + oddshift + centerShiftX),
|
||||
(short) (y + plotY),
|
||||
(short) (z + shift + oddshift + centerShiftZ),
|
||||
id,
|
||||
false,
|
||||
h3
|
||||
addOverlayBlock((short) (x + shift + oddshift + centerShiftX), (short) (y + plotY),
|
||||
(short) (z + shift + oddshift + centerShiftZ), id, false, h3
|
||||
);
|
||||
}
|
||||
}
|
||||
if (blockArrayClipboard3.hasBiomes()) {
|
||||
BiomeType biome = blockArrayClipboard3.getBiome(BlockVector2.at(
|
||||
x + min.getBlockX(),
|
||||
z + min.getBlockZ()
|
||||
));
|
||||
addOverlayBiome(
|
||||
(short) (x + shift + oddshift + centerShiftX),
|
||||
(short) (z + shift + oddshift + centerShiftZ),
|
||||
biome
|
||||
);
|
||||
}
|
||||
BiomeType biome = blockArrayClipboard3.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
|
||||
addOverlayBiome(
|
||||
(short) (x + shift + oddshift + centerShiftX),
|
||||
(short) (z + shift + oddshift + centerShiftZ),
|
||||
biome
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -367,7 +335,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
LOGGER.info("- plot schematic: {}", schematic3File.getPath());
|
||||
}
|
||||
}
|
||||
if ((schematic1 == null && schematic2 == null) || this.ROAD_WIDTH == 0) {
|
||||
if ((schematic1 == null&& schematic2 == null) || this.ROAD_WIDTH == 0) {
|
||||
if (Settings.DEBUG) {
|
||||
LOGGER.info("- schematic: false");
|
||||
}
|
||||
@@ -398,7 +366,6 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
z + min.getBlockZ()
|
||||
));
|
||||
if (!id.getBlockType().getMaterial().isAir()) {
|
||||
schem1PopulationNeeded |= id.hasNbtData();
|
||||
addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z + shift + oddshift), id, false, h1);
|
||||
addOverlayBlock(
|
||||
(short) (z + shift + oddshift),
|
||||
@@ -410,11 +377,9 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
);
|
||||
}
|
||||
}
|
||||
if (blockArrayClipboard1.hasBiomes()) {
|
||||
BiomeType biome = blockArrayClipboard1.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
|
||||
addOverlayBiome((short) (x - shift), (short) (z + shift + oddshift), biome);
|
||||
addOverlayBiome((short) (z + shift + oddshift), (short) (shift - x + (oddshift - 1)), biome);
|
||||
}
|
||||
BiomeType biome = blockArrayClipboard1.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
|
||||
addOverlayBiome((short) (x - shift), (short) (z + shift + oddshift), biome);
|
||||
addOverlayBiome((short) (z + shift + oddshift), (short) (shift - x + (oddshift - 1)), biome);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -437,14 +402,11 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
z + min.getBlockZ()
|
||||
));
|
||||
if (!id.getBlockType().getMaterial().isAir()) {
|
||||
schem2PopulationNeeded |= id.hasNbtData();
|
||||
addOverlayBlock((short) (x - shift), (short) (y + roadY), (short) (z - shift), id, false, h2);
|
||||
}
|
||||
}
|
||||
if (blockArrayClipboard2.hasBiomes()) {
|
||||
BiomeType biome = blockArrayClipboard2.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
|
||||
addOverlayBiome((short) (x - shift), (short) (z - shift), biome);
|
||||
}
|
||||
BiomeType biome = blockArrayClipboard2.getBiome(BlockVector2.at(x + min.getBlockX(), z + min.getBlockZ()));
|
||||
addOverlayBiome((short) (x - shift), (short) (z - shift), biome);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -466,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;
|
||||
@@ -490,52 +449,8 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
this.G_SCH_B.put(pair, id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the entities contained within the plot schematic for generation. Intended for internal use only.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public @Nullable List<Entity> getPlotSchematicEntities() {
|
||||
return schem3Entities;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the minimum point of the plot schematic for generation. Intended for internal use only.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public @Nullable BlockVector3 getPlotSchematicMinPoint() {
|
||||
return schem3MinPoint;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get if post-generation population of chunks with tiles/entities is needed for this world. Not for public API use.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public boolean populationNeeded() {
|
||||
return schem1PopulationNeeded || schem2PopulationNeeded || schem3PopulationNeeded;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated in favour of {@link HybridPlotWorld#getSchematicRoot()}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public File getRoot() {
|
||||
return this.root;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the root folder for this world's generation schematics. May be null if schematics not initialised via
|
||||
* {@link HybridPlotWorld#setupSchematics()}
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
public @Nullable File getSchematicRoot() {
|
||||
return this.root;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -41,7 +41,7 @@ import com.plotsquared.core.plot.flag.GlobalFlagContainer;
|
||||
import com.plotsquared.core.plot.flag.PlotFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.AnalysisFlag;
|
||||
import com.plotsquared.core.plot.world.PlotAreaManager;
|
||||
import com.plotsquared.core.queue.BlockArrayCacheScopedQueueCoordinator;
|
||||
import com.plotsquared.core.queue.ChunkQueueCoordinator;
|
||||
import com.plotsquared.core.queue.GlobalBlockQueue;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.util.ChunkManager;
|
||||
@@ -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;
|
||||
@@ -83,14 +81,11 @@ import java.util.concurrent.atomic.AtomicInteger;
|
||||
public class HybridUtils {
|
||||
|
||||
private static final Logger LOGGER = LogManager.getLogger("PlotSquared/" + HybridUtils.class.getSimpleName());
|
||||
private static final BlockState AIR = BlockTypes.AIR.getDefaultState();
|
||||
|
||||
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;
|
||||
|
||||
@@ -137,11 +132,6 @@ public class HybridUtils {
|
||||
*
|
||||
*/
|
||||
TaskManager.runTaskAsync(() -> {
|
||||
final PlotArea area = this.plotAreaManager.getPlotArea(world, null);
|
||||
if (!(area instanceof HybridPlotWorld hpw)) {
|
||||
return;
|
||||
}
|
||||
|
||||
final BlockVector3 bot = region.getMinimumPoint();
|
||||
final BlockVector3 top = region.getMaximumPoint();
|
||||
|
||||
@@ -155,31 +145,38 @@ 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 BlockState[][][] newBlocks = new BlockState[height][width][length];
|
||||
final PlotArea area = this.plotAreaManager.getPlotArea(world, null);
|
||||
|
||||
BlockArrayCacheScopedQueueCoordinator oldBlockQueue = new BlockArrayCacheScopedQueueCoordinator(
|
||||
Location.at("", region.getMinimumPoint().withY(hpw.getMinGenHeight())),
|
||||
Location.at("", region.getMaximumPoint().withY(hpw.getMaxGenHeight()))
|
||||
);
|
||||
if (!(area instanceof HybridPlotWorld hpw)) {
|
||||
return;
|
||||
}
|
||||
|
||||
region.getChunks().forEach(chunkPos -> {
|
||||
int relChunkX = chunkPos.getX() - cbx;
|
||||
int relChunkZ = chunkPos.getZ() - cbz;
|
||||
oldBlockQueue.setOffsetX(relChunkX << 4);
|
||||
oldBlockQueue.setOffsetZ(relChunkZ << 4);
|
||||
hpw.getGenerator().generateChunk(oldBlockQueue, hpw);
|
||||
});
|
||||
ChunkQueueCoordinator chunk = new ChunkQueueCoordinator(worldUtil.getWeWorld(world), bot, top, false);
|
||||
hpw.getGenerator().generateChunk(chunk, hpw);
|
||||
|
||||
final BlockState[][][] oldBlocks = oldBlockQueue.getBlockStates();
|
||||
final BlockState airBlock = BlockTypes.AIR.getDefaultState();
|
||||
final BlockState[][][] oldBlocks = chunk.getBlocks();
|
||||
final BlockState[][][] newBlocks = new BlockState[256][width][length];
|
||||
for (final BlockState[][] newBlock : newBlocks) {
|
||||
for (final BlockState[] blockStates : newBlock) {
|
||||
Arrays.fill(blockStates, airBlock);
|
||||
}
|
||||
}
|
||||
for (final BlockState[][] oldBlock : oldBlocks) {
|
||||
for (final BlockState[] blockStates : oldBlock) {
|
||||
Arrays.fill(blockStates, airBlock);
|
||||
}
|
||||
}
|
||||
|
||||
System.gc();
|
||||
System.gc();
|
||||
|
||||
QueueCoordinator queue = area.getQueue();
|
||||
queue.addReadChunks(region.getChunks());
|
||||
queue.setChunkConsumer(chunkPos -> {
|
||||
int X = chunkPos.getX();
|
||||
int Z = chunkPos.getZ();
|
||||
queue.setChunkConsumer(blockVector2 -> {
|
||||
int X = blockVector2.getX();
|
||||
int Z = blockVector2.getZ();
|
||||
int minX;
|
||||
if (X == cbx) {
|
||||
minX = bx & 15;
|
||||
@@ -214,15 +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);
|
||||
if (block == null) {
|
||||
block = AIR;
|
||||
}
|
||||
int xr = xb + x;
|
||||
int zr = zb + z;
|
||||
newBlocks[yIndex][xr][zr] = block;
|
||||
newBlocks[y][xr][zr] = block;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -239,11 +232,11 @@ 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]; // Nullable
|
||||
for (int y = 0; y < 256; y++) {
|
||||
BlockState old = oldBlocks[y][x][z];
|
||||
try {
|
||||
BlockState now = newBlocks[yIndex][x][z]; // Not null
|
||||
if (!now.equals(old) && !(old == null && now.getBlockType().equals(BlockTypes.AIR))) {
|
||||
BlockState now = newBlocks[y][x][z];
|
||||
if (!old.equals(now)) {
|
||||
changes[i]++;
|
||||
}
|
||||
if (now.getBlockType().getMaterial().isAir()) {
|
||||
@@ -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]++;
|
||||
}
|
||||
}
|
||||
@@ -301,6 +294,8 @@ public class HybridUtils {
|
||||
analysis.data_sd = (int) (MathMan.getSD(data, analysis.data) * 100);
|
||||
analysis.air_sd = (int) (MathMan.getSD(air, analysis.air) * 100);
|
||||
analysis.variety_sd = (int) (MathMan.getSD(variety, analysis.variety) * 100);
|
||||
System.gc();
|
||||
System.gc();
|
||||
whenDone.value = analysis;
|
||||
whenDone.run();
|
||||
});
|
||||
@@ -413,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) {
|
||||
@@ -423,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(
|
||||
@@ -436,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);
|
||||
@@ -470,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();
|
||||
@@ -483,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();
|
||||
@@ -539,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 ?
|
||||
@@ -548,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));
|
||||
@@ -577,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()) {
|
||||
@@ -594,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;
|
||||
@@ -649,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;
|
||||
|
||||
@@ -47,25 +47,16 @@ public abstract class IndependentPlotGenerator {
|
||||
public abstract String getName();
|
||||
|
||||
/**
|
||||
* Generate chunk block data
|
||||
* Use the setBlock or setBiome method of the PlotChunk result parameter to make changes.
|
||||
* The PlotArea settings is the same one this was initialized with.
|
||||
* The PseudoRandom random is a fast random object.
|
||||
*
|
||||
* @param result queue
|
||||
* @param settings PlotArea (settings)
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public abstract void generateChunk(ScopedQueueCoordinator result, PlotArea settings);
|
||||
|
||||
/**
|
||||
* Populates the queue representing a chunk area with tile entities and entities
|
||||
*
|
||||
* @param result Queue to write to
|
||||
* @param settings PlotArea (settings)
|
||||
* @return True if any population occurred
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public boolean populateChunk(ScopedQueueCoordinator result, PlotArea settings) {
|
||||
public boolean populateChunk(ScopedQueueCoordinator result, PlotArea setting) {
|
||||
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;
|
||||
|
||||
@@ -41,17 +41,14 @@ import org.khelekore.prtree.SimpleMBR;
|
||||
* An unmodifiable 6-tuple (world,x,y,z,yaw,pitch)
|
||||
*/
|
||||
@SuppressWarnings("unused")
|
||||
public sealed class Location extends BlockLoc implements Comparable<Location> permits UncheckedWorldLocation {
|
||||
public final class Location extends BlockLoc implements Comparable<Location> {
|
||||
|
||||
private final float yaw;
|
||||
private final float pitch;
|
||||
private final BlockVector3 blockVector3;
|
||||
private final World<?> world;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
protected Location(
|
||||
private Location(
|
||||
final @NonNull World<?> world, final @NonNull BlockVector3 blockVector3,
|
||||
final float yaw, final float pitch
|
||||
) {
|
||||
|
||||
@@ -1,77 +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.location;
|
||||
|
||||
import com.plotsquared.core.util.AnnotationHelper;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
/**
|
||||
* Used internally for generation to reference locations in worlds that "don't exist yet". There is no guarantee that the world
|
||||
* name provided by {@link UncheckedWorldLocation#getWorldName()} exists on the server.
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public final class UncheckedWorldLocation extends Location {
|
||||
|
||||
private final String worldName;
|
||||
|
||||
/**
|
||||
* @since TODO
|
||||
*/
|
||||
private UncheckedWorldLocation(
|
||||
final @NonNull String worldName, final int x, final int y, final int z
|
||||
) {
|
||||
super(World.nullWorld(), BlockVector3.at(x, y, z), 0f, 0f);
|
||||
this.worldName = worldName;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a new location with yaw and pitch equal to 0
|
||||
*
|
||||
* @param world World
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @return New location
|
||||
*
|
||||
* @since TODO
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public static @NonNull UncheckedWorldLocation at(
|
||||
final @NonNull String world, final int x, final int y, final int z
|
||||
) {
|
||||
return new UncheckedWorldLocation(world, x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to changes at any time.")
|
||||
public @NonNull String getWorldName() {
|
||||
return this.worldName;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -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));
|
||||
@@ -1420,7 +1420,15 @@ public class Plot {
|
||||
0
|
||||
);
|
||||
}
|
||||
Location location = toHomeLocation(bottom, home);
|
||||
Location location = Location
|
||||
.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + home.getX(),
|
||||
bottom.getY() + home.getY(),
|
||||
bottom.getZ() + home.getZ(),
|
||||
home.getYaw(),
|
||||
home.getPitch()
|
||||
);
|
||||
if (!this.worldUtil.getBlockSynchronous(location).getBlockType().getMaterial().isAir()) {
|
||||
location = location.withY(
|
||||
Math.max(1 + this.worldUtil.getHighestBlockSynchronous(
|
||||
@@ -1453,7 +1461,15 @@ public class Plot {
|
||||
return;
|
||||
}
|
||||
Location bottom = this.getBottomAbs();
|
||||
Location location = toHomeLocation(bottom, home);
|
||||
Location location = Location
|
||||
.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + home.getX(),
|
||||
bottom.getY() + home.getY(),
|
||||
bottom.getZ() + home.getZ(),
|
||||
home.getYaw(),
|
||||
home.getPitch()
|
||||
);
|
||||
this.worldUtil.getBlock(location, block -> {
|
||||
if (!block.getBlockType().getMaterial().isAir()) {
|
||||
this.worldUtil.getHighestBlock(this.getWorldName(), location.getX(), location.getZ(),
|
||||
@@ -1466,17 +1482,6 @@ public class Plot {
|
||||
}
|
||||
}
|
||||
|
||||
private Location toHomeLocation(Location bottom, BlockLoc relativeHome) {
|
||||
return Location.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + relativeHome.getX(),
|
||||
relativeHome.getY(), // y is absolute
|
||||
bottom.getZ() + relativeHome.getZ(),
|
||||
relativeHome.getYaw(),
|
||||
relativeHome.getPitch()
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the home location
|
||||
*
|
||||
@@ -1614,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;
|
||||
}
|
||||
@@ -1733,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) {
|
||||
@@ -1780,7 +1786,6 @@ public class Plot {
|
||||
);
|
||||
}
|
||||
plotworld.getPlotManager().claimPlot(this, null);
|
||||
this.getPlotModificationManager().setSign(player.getName());
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -2433,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());
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -125,7 +125,7 @@ public abstract class PlotWorld {
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotWorld;
|
||||
}
|
||||
|
||||
@@ -75,9 +75,9 @@ public class ExpiryTask {
|
||||
plots = plots != null ? plots : getPlotsToCheck();
|
||||
int diff = settings.REQUIRED_PLOTS;
|
||||
boolean min = true;
|
||||
if (plots.size() > settings.REQUIRED_PLOTS) {
|
||||
if (settings.REQUIRED_PLOTS - plots.size() < settings.REQUIRED_PLOTS) {
|
||||
min = false;
|
||||
diff = plots.size() - settings.REQUIRED_PLOTS;
|
||||
diff = settings.REQUIRED_PLOTS - plots.size();
|
||||
}
|
||||
List<Long> entireList =
|
||||
plots.stream().map(plot -> ExpireManager.IMP.getAge(plot, settings.DELETE_IF_OWNER_IS_UNKNOWN))
|
||||
|
||||
@@ -391,7 +391,7 @@ public class FlagContainer {
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof FlagContainer;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -221,7 +221,7 @@ public abstract class PlotFlag<T, F extends PlotFlag<T, F>> {
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotFlag;
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -34,7 +34,6 @@ import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.util.Location;
|
||||
import com.sk89q.worldedit.util.SideEffectSet;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
@@ -62,7 +61,6 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
private int lastX = Integer.MIN_VALUE;
|
||||
private int lastZ = Integer.MIN_VALUE;
|
||||
private boolean settingBiomes = false;
|
||||
private boolean disableBiomes = false;
|
||||
private boolean settingTiles = false;
|
||||
private boolean regen = false;
|
||||
private int[] regenStart;
|
||||
@@ -70,8 +68,7 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
private CuboidRegion regenRegion = null;
|
||||
private Consumer<BlockVector2> consumer = null;
|
||||
private boolean unloadAfter = true;
|
||||
private Runnable whenDone = null;
|
||||
private SideEffectSet sideEffectSet = null;
|
||||
private Runnable whenDone;
|
||||
@Nullable
|
||||
private LightingMode lightingMode = LightingMode.valueOf(Settings.QUEUE.LIGHTING_MODE);
|
||||
|
||||
@@ -104,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);
|
||||
@@ -123,11 +120,8 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
@SuppressWarnings("removal")
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biomeType) {
|
||||
if (disableBiomes) {
|
||||
return false;
|
||||
}
|
||||
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;
|
||||
@@ -136,9 +130,6 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
|
||||
@Override
|
||||
public final boolean setBiome(int x, int y, int z, @NonNull BiomeType biomeType) {
|
||||
if (disableBiomes) {
|
||||
return false;
|
||||
}
|
||||
LocalChunk chunk = getChunk(x >> 4, z >> 4);
|
||||
chunk.setBiome(x & 15, y, z & 15, biomeType);
|
||||
settingBiomes = true;
|
||||
@@ -150,12 +141,6 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
return this.settingBiomes;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBiomesEnabled(boolean settingBiomes) {
|
||||
this.settingBiomes = settingBiomes;
|
||||
this.disableBiomes = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setTile(int x, int y, int z, @NonNull CompoundTag tag) {
|
||||
LocalChunk chunk = getChunk(x >> 4, z >> 4);
|
||||
@@ -330,29 +315,6 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
this.whenDone = whenDone;
|
||||
}
|
||||
|
||||
@Override
|
||||
public SideEffectSet getSideEffectSet() {
|
||||
return sideEffectSet;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSideEffectSet(SideEffectSet sideEffectSet) {
|
||||
this.sideEffectSet = sideEffectSet;
|
||||
}
|
||||
|
||||
// Don't ask about the @NonNull placement. That's how it needs to be else it errors.
|
||||
@Override
|
||||
public void setBiomeCuboid(
|
||||
final com.plotsquared.core.location.@NonNull Location pos1,
|
||||
final com.plotsquared.core.location.@NonNull Location pos2,
|
||||
@NonNull final BiomeType biome
|
||||
) {
|
||||
if (disableBiomes) {
|
||||
return;
|
||||
}
|
||||
super.setBiomeCuboid(pos1, pos2, biome);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the {@link LocalChunk} from the queue at the given chunk coordinates. Returns a new instance if one doesn't exist
|
||||
*/
|
||||
|
||||
@@ -1,175 +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.queue;
|
||||
|
||||
import com.plotsquared.core.location.Location;
|
||||
import com.plotsquared.core.util.AnnotationHelper;
|
||||
import com.sk89q.jnbt.CompoundTag;
|
||||
import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.math.BlockVector3;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
import com.sk89q.worldedit.world.block.BlockState;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
/**
|
||||
* {@link QueueCoordinator} that caches all blocks set to it in a given array of form BlockState[][][]. An offset can be
|
||||
* applied to blocks set to it, and the scope limited. This should have blocks set to it one chunk at a time, based on the
|
||||
* result of {@link BlockArrayCacheScopedQueueCoordinator#getMin()} and {@link BlockArrayCacheScopedQueueCoordinator#getMax()}.
|
||||
* The min and max points of this queue are offset according to the minimum point given in the constructor, and the offsets set
|
||||
* in {@link BlockArrayCacheScopedQueueCoordinator#setOffsetX(int)} and
|
||||
* {@link BlockArrayCacheScopedQueueCoordinator#setOffsetZ(int)}
|
||||
*/
|
||||
@AnnotationHelper.ApiDescription(info = "Internal use only. Subject to change at any time and created for specific use cases.")
|
||||
public class BlockArrayCacheScopedQueueCoordinator extends ScopedQueueCoordinator {
|
||||
|
||||
private final BlockState[][][] blockStates;
|
||||
private final int height;
|
||||
private final int width;
|
||||
private final int length;
|
||||
private final int minY;
|
||||
private final int maxY;
|
||||
private final int scopeMinX;
|
||||
private final int scopeMinZ;
|
||||
private final int scopeMaxX;
|
||||
private final int scopeMaxZ;
|
||||
private int offsetX = 0;
|
||||
private int offsetZ = 0;
|
||||
/**
|
||||
* Construct a new instance
|
||||
*
|
||||
* @param min Inclusive location of the minimum point to limit the scope to.
|
||||
* @param max Inclusive location of the maximum point to limit the scope to.
|
||||
* @since 6.8.0
|
||||
*/
|
||||
public BlockArrayCacheScopedQueueCoordinator(Location min, Location max) {
|
||||
super(null, min, max);
|
||||
this.width = max.getX() - min.getX() + 1;
|
||||
this.length = max.getZ() - min.getZ() + 1;
|
||||
this.minY = min.getY();
|
||||
this.maxY = max.getY();
|
||||
this.height = maxY - minY + 1;
|
||||
|
||||
this.scopeMinX = min.getX() & 15;
|
||||
this.scopeMinZ = min.getZ() & 15;
|
||||
this.scopeMaxX = scopeMinX + width;
|
||||
this.scopeMaxZ = scopeMinZ + length;
|
||||
this.blockStates = new BlockState[height][width][length];
|
||||
}
|
||||
|
||||
public BlockState[][][] getBlockStates() {
|
||||
return blockStates;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, final int y, int z, final @NonNull BlockState id) {
|
||||
x += offsetX;
|
||||
z += offsetZ;
|
||||
if (x >= scopeMinX && x < scopeMaxX && y >= minY && y <= maxY && z >= scopeMinZ && z < scopeMaxZ) {
|
||||
blockStates[y - minY][x - scopeMinX][z - scopeMinZ] = id;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(final int x, final int y, final int z, @NonNull final Pattern pattern) {
|
||||
int rx = x + offsetX;
|
||||
int rz = z + offsetZ;
|
||||
if (rx >= scopeMinX && rx < scopeMaxX && y >= minY && y <= maxY && rz >= scopeMinZ && rz < scopeMaxZ) {
|
||||
BlockState state = pattern
|
||||
.applyBlock(super.getMin().getBlockVector3().add(BlockVector3.at(x, y, z)))
|
||||
.toImmutableState();
|
||||
blockStates[y - minY][rx - scopeMinX][rz - scopeMinZ] = state;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMin() {
|
||||
return super.getMin().add(offsetX - scopeMinX, 0, offsetZ - scopeMinZ);
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMax() {
|
||||
return getMin().add(15, 0, 15).withY(maxY);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, final @NonNull BaseBlock id) {
|
||||
x += offsetX;
|
||||
z += offsetZ;
|
||||
if (x >= scopeMinX && x < scopeMaxX && y >= minY && y <= maxY && z >= scopeMinZ && z < scopeMaxZ) {
|
||||
blockStates[y - minY][x][z] = id.toImmutableState();
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public @Nullable BlockState getBlock(final int x, final int y, final int z) {
|
||||
if (x >= 0 && x < width && y >= minY && y <= maxY && z >= 0 && z < length) {
|
||||
return blockStates[y - minY][x][z];
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
public void setOffsetX(final int offsetX) {
|
||||
this.offsetX = offsetX;
|
||||
}
|
||||
|
||||
public void setOffsetZ(final int offsetZ) {
|
||||
this.offsetZ = offsetZ;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int size() {
|
||||
return height * width * length;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBiome(final int x, final int z, @NonNull final BiomeType biome) {
|
||||
//do nothing
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBiome(final int x, final int y, final int z, @NonNull final BiomeType biome) {
|
||||
//do nothing
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void fillBiome(final BiomeType biome) {
|
||||
//do nothing
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setTile(final int x, final int y, final int z, @NonNull final CompoundTag tag) {
|
||||
//do nothing
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@@ -36,12 +36,8 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
/**
|
||||
* Queue that is limited to a single chunk. It does not allow a delegate queue and should be treated as a cache for changes to
|
||||
* be set to. Does not support tile entities or entities.
|
||||
*
|
||||
* @deprecated This class is poorly designed and will no longer be used in P2
|
||||
* Queue that is limited to a single chunk
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.8.0")
|
||||
public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
|
||||
public final BiomeType[][][] biomeResult;
|
||||
@@ -58,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;
|
||||
}
|
||||
@@ -75,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;
|
||||
@@ -105,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) {
|
||||
@@ -118,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) {
|
||||
@@ -138,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) {
|
||||
@@ -163,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();
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -32,7 +32,6 @@ import com.sk89q.worldedit.entity.Entity;
|
||||
import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.util.SideEffectSet;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
@@ -136,13 +135,6 @@ public class DelegateQueueCoordinator extends QueueCoordinator {
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setBiomesEnabled(final boolean enabled) {
|
||||
if (parent != null) {
|
||||
parent.setBiomesEnabled(enabled);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setEntity(@NonNull Entity entity) {
|
||||
if (parent != null) {
|
||||
@@ -256,21 +248,6 @@ public class DelegateQueueCoordinator extends QueueCoordinator {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public SideEffectSet getSideEffectSet() {
|
||||
if (parent != null) {
|
||||
return parent.getSideEffectSet();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setSideEffectSet(final SideEffectSet sideEffectSet) {
|
||||
if (parent != null) {
|
||||
parent.setSideEffectSet(sideEffectSet);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull List<BlockVector2> getReadChunks() {
|
||||
if (parent != null) {
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -35,7 +35,6 @@ import com.sk89q.worldedit.entity.Entity;
|
||||
import com.sk89q.worldedit.function.pattern.Pattern;
|
||||
import com.sk89q.worldedit.math.BlockVector2;
|
||||
import com.sk89q.worldedit.regions.CuboidRegion;
|
||||
import com.sk89q.worldedit.util.SideEffectSet;
|
||||
import com.sk89q.worldedit.world.World;
|
||||
import com.sk89q.worldedit.world.biome.BiomeType;
|
||||
import com.sk89q.worldedit.world.block.BaseBlock;
|
||||
@@ -76,31 +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
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
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)
|
||||
);
|
||||
}
|
||||
|
||||
@@ -146,8 +126,7 @@ public abstract class QueueCoordinator {
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a chunk object (e.g. the Bukkit Chunk object) to the queue. This will be used as fallback in case of WNA failure.
|
||||
* Should ONLY be used in specific cases (i.e. generation, where a chunk is being populated)
|
||||
* Set a chunk object (e.g. the Bukkit Chunk object) to the queue
|
||||
*
|
||||
* @param chunkObject chunk object. Usually the implementation-specific chunk (e.g. bukkit Chunk)
|
||||
*/
|
||||
@@ -251,14 +230,6 @@ public abstract class QueueCoordinator {
|
||||
*/
|
||||
public abstract boolean isSettingBiomes();
|
||||
|
||||
/**
|
||||
* If the queue should accept biome placement
|
||||
*
|
||||
* @param enabled If biomes should be enabled
|
||||
* @since 6.8.0
|
||||
*/
|
||||
public abstract void setBiomesEnabled(boolean enabled);
|
||||
|
||||
/**
|
||||
* Add entities to be created
|
||||
*
|
||||
@@ -424,20 +395,6 @@ public abstract class QueueCoordinator {
|
||||
*/
|
||||
public abstract void setLightingMode(@Nullable LightingMode mode);
|
||||
|
||||
/**
|
||||
* Get the overriding {@link SideEffectSet} to be used by the queue if it exists, else null
|
||||
*
|
||||
* @return Overriding {@link SideEffectSet} or null
|
||||
*/
|
||||
public abstract @Nullable SideEffectSet getSideEffectSet();
|
||||
|
||||
/**
|
||||
* Set the overriding {@link SideEffectSet} to be used by the queue. Null to use default side effects.
|
||||
*
|
||||
* @param sideEffectSet side effects to override with, or null to use default
|
||||
*/
|
||||
public abstract void setSideEffectSet(@Nullable SideEffectSet sideEffectSet);
|
||||
|
||||
/**
|
||||
* Fill a cuboid between two positions with a BlockState
|
||||
*
|
||||
@@ -447,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());
|
||||
@@ -470,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());
|
||||
@@ -493,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());
|
||||
@@ -507,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;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -35,39 +35,34 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
/**
|
||||
* Queue that only sets blocks with a designated X-Z area, will accept any Y values. Requires all blocks be set normalized in
|
||||
* the x and z directions, i.e. starting from 0,0. An offset of the minimum point of the region will then be applied to x and z.
|
||||
*
|
||||
* @deprecated This should be renamed to NormalizedScopedQueueCoordinator or something.
|
||||
* Queue that only sets blocks with a designated area
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.8.0")
|
||||
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;
|
||||
|
||||
private final int maxX;
|
||||
private final int maxY;
|
||||
private final int maxZ;
|
||||
|
||||
private final int dx;
|
||||
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();
|
||||
|
||||
this.maxX = max.getX();
|
||||
this.maxY = max.getY();
|
||||
this.maxZ = max.getZ();
|
||||
|
||||
this.dx = maxX - minX;
|
||||
this.dy = maxY - minY;
|
||||
this.dz = maxZ - minZ;
|
||||
}
|
||||
|
||||
@@ -78,11 +73,11 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBiome(int x, int y, int z, @NonNull BiomeType biome) {
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBiome(x + minX, y, z + minZ, biome);
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBiome(x + minX, y + minY, z + minZ, biome);
|
||||
}
|
||||
|
||||
public void fillBiome(BiomeType biome) {
|
||||
for (int y = min.getY(); y <= max.getY(); y++) {
|
||||
for (int y = 0; y <= dy; y++) {
|
||||
for (int x = 0; x <= dx; x++) {
|
||||
for (int z = 0; z < dz; z++) {
|
||||
setBiome(x, y, z, biome);
|
||||
@@ -93,30 +88,35 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BaseBlock id) {
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, id);
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(x + minX, y + minY, z + minZ, id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BlockState id) {
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, id);
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(x + minX, y + minY, z + minZ, id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull Pattern pattern) {
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, pattern);
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(
|
||||
x + minX,
|
||||
y + minY,
|
||||
z + minZ,
|
||||
pattern
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setTile(int x, int y, int z, @NonNull CompoundTag tag) {
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setTile(x + minX, y, z + minZ, tag);
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setTile(x + minX, y + minY, z + minZ, tag);
|
||||
}
|
||||
|
||||
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;
|
||||
@@ -42,26 +41,24 @@ public abstract class ChunkManager {
|
||||
private static final Map<BlockVector2, RunnableVal<ScopedQueueCoordinator>> forceChunks = new ConcurrentHashMap<>();
|
||||
private static final Map<BlockVector2, RunnableVal<ScopedQueueCoordinator>> addChunks = new ConcurrentHashMap<>();
|
||||
|
||||
/**
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public static void setChunkInPlotArea(
|
||||
RunnableVal<ScopedQueueCoordinator> force,
|
||||
RunnableVal<ScopedQueueCoordinator> add,
|
||||
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);
|
||||
@@ -83,10 +80,6 @@ public abstract class ChunkManager {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public static boolean preProcessChunk(BlockVector2 loc, ScopedQueueCoordinator queue) {
|
||||
final RunnableVal<ScopedQueueCoordinator> forceChunk = forceChunks.get(loc);
|
||||
if (forceChunk != null) {
|
||||
@@ -97,10 +90,6 @@ public abstract class ChunkManager {
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated {@link ScopedQueueCoordinator} will be renamed in v7.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
public static boolean postProcessChunk(BlockVector2 loc, ScopedQueueCoordinator queue) {
|
||||
final RunnableVal<ScopedQueueCoordinator> addChunk = forceChunks.get(loc);
|
||||
if (addChunk != null) {
|
||||
|
||||
@@ -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];
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -34,7 +34,6 @@ import java.util.HashMap;
|
||||
public abstract class SetupUtils {
|
||||
|
||||
public static HashMap<String, GeneratorWrapper<?>> generators = new HashMap<>();
|
||||
protected boolean loaded = false;
|
||||
|
||||
/**
|
||||
* @since 6.1.0
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -38,7 +38,6 @@ import com.plotsquared.core.player.PlotPlayer;
|
||||
import com.plotsquared.core.plot.Plot;
|
||||
import com.plotsquared.core.plot.flag.GlobalFlagContainer;
|
||||
import com.plotsquared.core.plot.flag.PlotFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.ServerPlotFlag;
|
||||
import com.plotsquared.core.util.EventDispatcher;
|
||||
import com.plotsquared.core.util.PlayerManager;
|
||||
import net.kyori.adventure.text.Component;
|
||||
@@ -111,9 +110,6 @@ public final class PlaceholderRegistry {
|
||||
return plot.getAlias();
|
||||
});
|
||||
this.createPlaceholder("currentplot_owner", (player, plot) -> {
|
||||
if (plot.getFlag(ServerPlotFlag.class)){
|
||||
return legacyComponent(TranslatableCaption.of("info.server"), player);
|
||||
}
|
||||
final UUID plotOwner = plot.getOwnerAbs();
|
||||
if (plotOwner == null) {
|
||||
return legacyComponent(TranslatableCaption.of("generic.generic_unowned"), player);
|
||||
|
||||
@@ -71,7 +71,7 @@ public class UUIDMapping {
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof UUIDMapping;
|
||||
}
|
||||
|
||||
@@ -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>",
|
||||
@@ -381,9 +380,6 @@
|
||||
"info.plot_list_default": "<gold><plot></gold>",
|
||||
"info.plot_list_player_online": "<dark_aqua><prefix></dark_aqua><hover:show_text:\"<dark_aqua>Online</dark_aqua>\"><gold><player></gold></hover>",
|
||||
"info.plot_list_player_offline": "<dark_aqua><prefix></dark_aqua><hover:show_text:\"<dark_gray>Offline</dark_gray>\"><gold><player></gold></hover>",
|
||||
"info.plot_list_player_unknown": "<hover:show_text:\"<red>The owner of this plot is unknown</red>\"><white><info.unknown></white></hover>",
|
||||
"info.plot_list_player_server": "<hover:show_text:\"<red>The plot is owned by the server</red>\"><white><info.server></white></hover>",
|
||||
"info.plot_list_player_everyone": "<hover:show_text:\"<blue>The plot is owned by everyone</blue>\"><white><info.everyone></white></hover>",
|
||||
"info.area_info_format": "<header>\n<reset><gold>Name: </gold><gray><name></gray>\n<gold>Type: </gold><gray><type></gray>\n<gold>Terrain: </gold><gray><terrain></gray>\n<gold>Usage: </gold><gray><usage>%</gray>\n<gold>Claimed: </gold><gray><claimed></gray>\n<gold>Clusters: </gold><gray><clusters></gray>\n<gold>Region: </gold><gray><region></gray>\n<gold>Generator: </gold><gray><generator></gray>\n<footer>",
|
||||
"info.area_list_tooltip": "<gold>Claimed=</gold><gray><claimed></gray>\n<gold>Usage=</gold><gray><usage></gray>\n<gold>Clusters=</gold><gray><clusters></gray>\n<gold>Region=</gold><gray><region></gray>\n<gold>Generator=</gold><gray><generator></gray>",
|
||||
"info.area_list_item": "<click:run_command:<command_tp>><hover:show_text:\"<command_tp>\"><dark_gray>[</dark_gray><gold><number></gold><dark_gray>]</dark_gray></hover></click> <click:run_command:<command_info>><hover:show_text:\"<hover_info>\"><gold><area_name></gold></hover></click><gray> - </gray><gray><area_type>:<area_terrain></gray>",
|
||||
@@ -616,7 +612,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.",
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<p align="center">
|
||||
<img src="https://raw.githubusercontent.com/IntellectualSites/Assets/main/plugins/PlotSquared/PlotSquared.svg" width="300">
|
||||
<img src="https://i.imgur.com/33Y65YL.png" width="150">
|
||||
</p>
|
||||
|
||||
---
|
||||
|
||||
@@ -18,7 +18,7 @@ plugins {
|
||||
idea
|
||||
}
|
||||
|
||||
version = "6.8.2-SNAPSHOT"
|
||||
version = "6.5.2-SNAPSHOT"
|
||||
|
||||
allprojects {
|
||||
group = "com.plotsquared"
|
||||
@@ -34,15 +34,12 @@ allprojects {
|
||||
|
||||
maven {
|
||||
name = "Sonatype OSS (S01)"
|
||||
url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots/")
|
||||
url = uri("https://s01.oss.sonatype.org/content/repositories/snapshots")
|
||||
}
|
||||
|
||||
maven {
|
||||
name = "Jitpack"
|
||||
url = uri("https://jitpack.io")
|
||||
content {
|
||||
includeModule("com.github.MilkBowl", "VaultAPI")
|
||||
}
|
||||
}
|
||||
|
||||
maven {
|
||||
@@ -64,12 +61,9 @@ subprojects {
|
||||
plugin<EclipsePlugin>()
|
||||
plugin<IdeaPlugin>()
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation(platform("com.intellectualsites.bom:bom-1.18.x:1.2"))
|
||||
}
|
||||
}
|
||||
|
||||
val javadocDir = rootDir.resolve("docs").resolve("javadoc").resolve(project.name)
|
||||
allprojects {
|
||||
dependencies {
|
||||
// Tests
|
||||
@@ -143,7 +137,7 @@ allprojects {
|
||||
}
|
||||
developer {
|
||||
id.set("NotMyFault")
|
||||
name.set("Alexander Brandes")
|
||||
name.set("NotMyFault")
|
||||
organization.set("IntellectualSites")
|
||||
email.set("contact@notmyfault.dev")
|
||||
}
|
||||
@@ -175,6 +169,11 @@ allprojects {
|
||||
}
|
||||
|
||||
tasks {
|
||||
named<Delete>("clean") {
|
||||
doFirst {
|
||||
javadocDir.deleteRecursively()
|
||||
}
|
||||
}
|
||||
|
||||
compileJava {
|
||||
options.compilerArgs.addAll(arrayOf("-Xmaxerrs", "1000"))
|
||||
@@ -185,6 +184,16 @@ allprojects {
|
||||
options.encoding = "UTF-8"
|
||||
}
|
||||
|
||||
javadoc {
|
||||
val opt = options as StandardJavadocDocletOptions
|
||||
opt.addStringOption("Xdoclint:none", "-quiet")
|
||||
opt.tags(
|
||||
"apiNote:a:API Note:",
|
||||
"implSpec:a:Implementation Requirements:",
|
||||
"implNote:a:Implementation Note:"
|
||||
)
|
||||
}
|
||||
|
||||
shadowJar {
|
||||
this.archiveClassifier.set(null as String?)
|
||||
this.archiveFileName.set("${project.name}-${project.version}.${this.archiveExtension.getOrElse("jar")}")
|
||||
@@ -209,3 +218,37 @@ nexusPublishing {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tasks {
|
||||
val aggregatedJavadocs = create<Javadoc>("aggregatedJavadocs") {
|
||||
title = "${project.name} ${project.version} API"
|
||||
setDestinationDir(javadocDir)
|
||||
options.destinationDirectory = javadocDir
|
||||
|
||||
doFirst {
|
||||
javadocDir.deleteRecursively()
|
||||
}
|
||||
}.also {
|
||||
it.group = "Documentation"
|
||||
it.description = "Generate javadocs from all child projects as if it was a single project"
|
||||
}
|
||||
|
||||
subprojects.forEach { subProject ->
|
||||
subProject.afterEvaluate {
|
||||
subProject.tasks.withType<Javadoc>().forEach { task ->
|
||||
aggregatedJavadocs.source += task.source
|
||||
aggregatedJavadocs.classpath += task.classpath
|
||||
aggregatedJavadocs.excludes += task.excludes
|
||||
aggregatedJavadocs.includes += task.includes
|
||||
|
||||
val rootOptions = aggregatedJavadocs.options as StandardJavadocDocletOptions
|
||||
val subOptions = task.options as StandardJavadocDocletOptions
|
||||
rootOptions.links(*subOptions.links.orEmpty().minus(rootOptions.links.orEmpty().toSet()).toTypedArray())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
build {
|
||||
dependsOn(aggregatedJavadocs)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,9 +1,15 @@
|
||||
[versions]
|
||||
# Minecraft expectations
|
||||
gson = "2.8.8" # Version set by Minecraft
|
||||
log4j-api = "2.17.1" # Version set by Minecraft
|
||||
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.2"
|
||||
guice = "5.1.0"
|
||||
spotbugs = "4.7.0"
|
||||
findbugs = "3.0.1"
|
||||
snakeyaml = "1.30" # Version set by Bukkit
|
||||
|
||||
# Adventure & MiniMessage
|
||||
adventure-api = "4.9.3"
|
||||
@@ -11,10 +17,12 @@ adventure-text-minimessage = "4.1.0-SNAPSHOT"
|
||||
adventure-platform-bukkit = "4.0.1"
|
||||
|
||||
# Plugins
|
||||
worldedit = "7.2.10"
|
||||
worldedit = "7.2.9"
|
||||
fawe = "2.0.1"
|
||||
vault = "1.7.1"
|
||||
placeholderapi = "2.11.1"
|
||||
luckperms = "5.4"
|
||||
essentialsx = "2.19.4"
|
||||
essentialsx = "2.19.2"
|
||||
mvdwapi = "3.1.1"
|
||||
|
||||
# Third party
|
||||
@@ -22,7 +30,11 @@ prtree = "2.0.0"
|
||||
aopalliance = "1.0"
|
||||
cloud-services = "1.6.2"
|
||||
arkitektonika = "2.1.1"
|
||||
squirrelid = "0.3.1"
|
||||
paster = "1.1.4"
|
||||
bstats = "3.0.0"
|
||||
paperlib = "1.0.7"
|
||||
squirrelid = "0.3.0"
|
||||
serverlib = "2.3.1"
|
||||
http4j = "1.3"
|
||||
|
||||
# Gradle plugins
|
||||
@@ -36,10 +48,15 @@ nexus = "1.1.0"
|
||||
paper = { group = "io.papermc.paper", name = "paper-api", version.ref = "paper" }
|
||||
checkerqual = { group = "org.checkerframework", name = "checker-qual", version.ref = "checker-qual" }
|
||||
|
||||
# Minecraft expectations
|
||||
gson = { group = "com.google.code.gson", name = "gson", version.ref = "gson" }
|
||||
log4j = { group = "org.apache.logging.log4j", name = "log4j-api", version.ref = "log4j-api" }
|
||||
|
||||
# Platform expectations
|
||||
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" }
|
||||
@@ -49,6 +66,9 @@ adventurePlatformBukkit = { group = "net.kyori", name = "adventure-platform-bukk
|
||||
# Plugins
|
||||
worldeditCore = { group = "com.sk89q.worldedit", name = "worldedit-core", version.ref = "worldedit" }
|
||||
worldeditBukkit = { group = "com.sk89q.worldedit", name = "worldedit-bukkit", version.ref = "worldedit" }
|
||||
fastasyncworldeditBukkit = { group = "com.fastasyncworldedit", name = "FastAsyncWorldEdit-Bukkit", version.ref = "fawe" }
|
||||
fastasyncworldeditCore = { group = "com.fastasyncworldedit", name = "FastAsyncWorldEdit-Core", version.ref = "fawe" }
|
||||
vault = { group = "com.github.MilkBowl", name = "VaultAPI", version.ref = "vault" }
|
||||
placeholderapi = { group = "me.clip", name = "placeholderapi", version.ref = "placeholderapi" }
|
||||
luckperms = { group = "net.luckperms", name = "api", version.ref = "luckperms" }
|
||||
essentialsx = { group = "net.essentialsx", name = "EssentialsX", version.ref = "essentialsx" }
|
||||
@@ -58,9 +78,14 @@ 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" }
|
||||
arkitektonika = { group = "com.intellectualsites.arkitektonika", name = "Arkitektonika-Client", version.ref = "arkitektonika" }
|
||||
http4j = { group = "com.intellectualsites.http", name = "HTTP4J", version.ref = "http4j" }
|
||||
paster = { group = "com.intellectualsites.paster", name = "Paster", version.ref = "paster" }
|
||||
guava = { group = "com.google.guava", name = "guava", version.ref = "guava" }
|
||||
|
||||
[plugins]
|
||||
shadow = { id = "com.github.johnrengelman.shadow", version.ref = "shadow" }
|
||||
|
||||
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.4-all.zip
|
||||
zipStoreBase=GRADLE_USER_HOME
|
||||
zipStorePath=wrapper/dists
|
||||
|
||||
BIN
plotsquared-logo.png
Normal file
BIN
plotsquared-logo.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 36 KiB |
@@ -8,8 +8,7 @@
|
||||
"com.google.guava:guava",
|
||||
"com.google.code.gson:gson",
|
||||
"gson",
|
||||
"snakeyaml",
|
||||
"net.kyori"
|
||||
"snakeyaml"
|
||||
],
|
||||
"timezone": "Europe/Berlin",
|
||||
"schedule": [
|
||||
|
||||
Reference in New Issue
Block a user