mirror of
https://github.com/IntellectualSites/PlotSquared.git
synced 2025-07-03 06:04:43 +02:00
Compare commits
111 Commits
docs/v6/ja
...
renovate/a
Author | SHA1 | Date | |
---|---|---|---|
b278c4eaaf | |||
0a32268784 | |||
ae3b8c06f6 | |||
713c4ad0d2 | |||
48386c0828 | |||
625b3921e1 | |||
48aa37d173 | |||
2c2314e95c | |||
5eb2fc3ad0 | |||
82cd9a092c | |||
62754362c2 | |||
2e9dfd6f6f | |||
fc9fe1462f | |||
41f546ca6b | |||
d037da33cb | |||
dc2d08c67e | |||
96dfc27411 | |||
171d2e5e99 | |||
4433892431 | |||
98a07dad1b | |||
0ffa22b7a6 | |||
60a0129fe9 | |||
d5f8a0842b | |||
f7d55ce105 | |||
85911646f3 | |||
8b75dece69 | |||
7d6e515ba8 | |||
13d7357c85 | |||
16e26b910c | |||
faadebd30e | |||
2aeacb3dcf | |||
9db7791835 | |||
f49ddb819d | |||
d71c62771e | |||
a6aaa9538f | |||
0974fb2834 | |||
8982b33b6c | |||
a7b3b3b7df | |||
888bb20e78 | |||
b11bb6fa22 | |||
e5764b958d | |||
bfe3141ff1 | |||
73c82deeb0 | |||
38682ecff6 | |||
6a54dc7eff | |||
8454c29c91 | |||
b2c9311a47 | |||
c4aa497a2b | |||
c13f544390 | |||
c28177d6af | |||
8a80f252cf | |||
93571c72d1 | |||
6fd7379221 | |||
dc5c80d812 | |||
96e9a61e7c | |||
b9bd9b81e6 | |||
ec77812879 | |||
efc2083798 | |||
3a6f845c01 | |||
7efd42ae45 | |||
f43f4cbf5d | |||
104cc4b7a4 | |||
218be43143 | |||
308dba5601 | |||
5f233bb5d1 | |||
5e188d114f | |||
660e05d27f | |||
4c0ad148bf | |||
5c7bfb988c | |||
b46f486680 | |||
05797d0c78 | |||
36ef2cf9ba | |||
26ec31a012 | |||
fd4a542062 | |||
dc13f2565f | |||
9f632af0ae | |||
d698c6a1e5 | |||
40e1bd9897 | |||
75f31c5bf6 | |||
954c813cef | |||
05e055e9cf | |||
2ea21c150f | |||
c2fd4edad5 | |||
78b8696778 | |||
e653961385 | |||
b21d12fd52 | |||
7557df96c7 | |||
61797c3aff | |||
78125ff1e2 | |||
d7c8715b25 | |||
34f005c244 | |||
6fbd1376ca | |||
951767dc64 | |||
16928b05f1 | |||
fff14b05cb | |||
e619c867e9 | |||
543284e016 | |||
0d78ba5f35 | |||
9ba2b62fc2 | |||
f10ee27fdd | |||
3278ce1fe9 | |||
fefb0334bd | |||
d06a827e31 | |||
10bb520f3a | |||
126aa53b61 | |||
ac71046feb | |||
7c290e6bd0 | |||
4d297cc829 | |||
5ab410a5c5 | |||
1f28bac955 | |||
92c54de5e9 |
3
.github/ISSUE_TEMPLATE/bug_report.yml
vendored
3
.github/ISSUE_TEMPLATE/bug_report.yml
vendored
@ -7,7 +7,7 @@ body:
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for taking the time to fill out this bug report for PlotSquared! Fill out the following form to your best ability to help us fix the problem.
|
||||
Only use this if you're absolutely sure that you found a bug and can reproduce it. For anything else, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://github.com/IntellectualSites/PlotSquared-Documentation/wiki).
|
||||
Only use this if you're absolutely sure that you found a bug and can reproduce it. For anything else, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://intellectualsites.github.io/plotsquared-documentation/).
|
||||
Do NOT use the public issue tracker to report security vulnerabilities! They are disclosed using [this](https://forms.gle/btgdRn9yhGtzEiGW8) form!
|
||||
|
||||
- type: dropdown
|
||||
@ -27,6 +27,7 @@ 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'
|
||||
|
2
.github/ISSUE_TEMPLATE/config.yml
vendored
2
.github/ISSUE_TEMPLATE/config.yml
vendored
@ -4,5 +4,5 @@ contact_links:
|
||||
url: https://discord.gg/intellectualsites
|
||||
about: Our support Discord, please ask questions and seek support here.
|
||||
- name: PlotSquared Wiki
|
||||
url: https://github.com/IntellectualSites/PlotSquared-Documentation/wiki
|
||||
url: https://intellectualsites.github.io/plotsquared-documentation/
|
||||
about: Take a look at the wiki page for instructions how to setup PlotSquared and use its commands.
|
||||
|
2
.github/ISSUE_TEMPLATE/feature_request.yml
vendored
2
.github/ISSUE_TEMPLATE/feature_request.yml
vendored
@ -7,7 +7,7 @@ body:
|
||||
attributes:
|
||||
value: |
|
||||
Thanks for taking the time to fill out this feature request for PlotSquared! Fill out the following form to your best ability to help us understand your feature request and greately improve the change of it getting added.
|
||||
For anything else than a feature request, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://github.com/IntellectualSites/PlotSquared-Documentation/wiki).
|
||||
For anything else than a feature request, use: [our Discord server](https://discord.gg/intellectualsites) or [the wiki](https://intellectualsites.github.io/plotsquared-documentation/).
|
||||
|
||||
- type: textarea
|
||||
attributes:
|
||||
|
7
.github/workflows/build.yml
vendored
7
.github/workflows/build.yml
vendored
@ -4,14 +4,15 @@ on: [ pull_request, push ]
|
||||
|
||||
jobs:
|
||||
build:
|
||||
if: ${{ github.event_name != 'pull_request' || github.repository != github.event.pull_request.head.repo.full_name }}
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout Repository
|
||||
uses: actions/checkout@v2.4.0
|
||||
uses: actions/checkout@v3
|
||||
- name: Validate Gradle Wrapper"
|
||||
uses: gradle/wrapper-validation-action@v1.0.4
|
||||
uses: gradle/wrapper-validation-action@v1
|
||||
- name: Setup Java
|
||||
uses: actions/setup-java@v2.5.0
|
||||
uses: actions/setup-java@v3
|
||||
with:
|
||||
distribution: temurin
|
||||
java-version: 17
|
||||
|
37
.github/workflows/codeql.yml
vendored
Normal file
37
.github/workflows/codeql.yml
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
name: "CodeQL"
|
||||
|
||||
on:
|
||||
push:
|
||||
branches: [ v6 ]
|
||||
pull_request:
|
||||
# The branches below must be a subset of the branches above
|
||||
branches: [ v6 ]
|
||||
|
||||
jobs:
|
||||
analyze:
|
||||
name: Analyze
|
||||
runs-on: ubuntu-latest
|
||||
permissions:
|
||||
actions: read
|
||||
contents: read
|
||||
security-events: write
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
language: [ 'java' ]
|
||||
|
||||
steps:
|
||||
- name: Checkout repository
|
||||
uses: actions/checkout@v3
|
||||
|
||||
- name: Initialize CodeQL
|
||||
uses: github/codeql-action/init@v2
|
||||
with:
|
||||
languages: ${{ matrix.language }}
|
||||
|
||||
- name: Autobuild
|
||||
uses: github/codeql-action/autobuild@v2
|
||||
|
||||
- name: Perform CodeQL Analysis
|
||||
uses: github/codeql-action/analyze@v2
|
20
.github/workflows/rebase.yml
vendored
20
.github/workflows/rebase.yml
vendored
@ -1,20 +0,0 @@
|
||||
name: Rebase Pull Request
|
||||
on:
|
||||
issue_comment:
|
||||
types: [created]
|
||||
|
||||
jobs:
|
||||
rebase:
|
||||
name: Rebase
|
||||
if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/rebase') && github.event.comment.author_association == 'MEMBER'
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- name: Checkout Repository
|
||||
uses: actions/checkout@v2.4.0
|
||||
with:
|
||||
token: ${{ secrets.REBASE_TOKEN }}
|
||||
fetch-depth: 0
|
||||
- name: Automatic Rebase
|
||||
uses: cirrus-actions/rebase@1.5
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.REBASE_TOKEN }}
|
3
.github/workflows/release-drafter.yml
vendored
3
.github/workflows/release-drafter.yml
vendored
@ -11,8 +11,9 @@ on:
|
||||
|
||||
jobs:
|
||||
update_release_draft:
|
||||
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.17.6
|
||||
- uses: release-drafter/release-drafter@v5
|
||||
env:
|
||||
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
||||
|
10
.gitignore
vendored
10
.gitignore
vendored
@ -41,7 +41,8 @@ hs_err_pid*
|
||||
*.iml
|
||||
|
||||
## Directory-based project format:
|
||||
.idea/
|
||||
/.idea/*
|
||||
!/.idea/icon.svg
|
||||
# if you remove the above rule, at least ignore the following:
|
||||
|
||||
# User-specific stuff:
|
||||
@ -74,9 +75,6 @@ hs_err_pid*
|
||||
# IntelliJ
|
||||
/out/
|
||||
|
||||
# mpeltonen/sbt-idea plugin
|
||||
.idea_modules/
|
||||
|
||||
# JIRA plugin
|
||||
atlassian-ide-plugin.xml
|
||||
|
||||
@ -133,5 +131,9 @@ local.properties
|
||||
checkstyle.xml
|
||||
classes/
|
||||
*.bat
|
||||
|
||||
# Other
|
||||
docs/
|
||||
build/
|
||||
|
||||
.DS_Store
|
||||
|
50
.idea/icon.svg
generated
Normal file
50
.idea/icon.svg
generated
Normal file
@ -0,0 +1,50 @@
|
||||
<?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>
|
After Width: | Height: | Size: 11 KiB |
@ -1,4 +0,0 @@
|
||||
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"]
|
13
.whitesource
13
.whitesource
@ -1,13 +0,0 @@
|
||||
{
|
||||
"scanSettings": {
|
||||
"baseBranches": ["v6"]
|
||||
},
|
||||
"checkRunSettings": {
|
||||
"vulnerableCheckRunConclusionLevel": "success",
|
||||
"displayMode": "diff"
|
||||
},
|
||||
"issueSettings": {
|
||||
"minSeverityLevel": "LOW"
|
||||
},
|
||||
"enableRenovate": "true"
|
||||
}
|
@ -8,7 +8,7 @@ repositories {
|
||||
|
||||
maven {
|
||||
name = "PaperMC"
|
||||
url = uri("https://papermc.io/repo/repository/maven-public/")
|
||||
url = uri("https://repo.papermc.io/repository/maven-public/")
|
||||
}
|
||||
|
||||
maven {
|
||||
@ -83,8 +83,10 @@ 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.google.code.findbugs", "com.plotsquared.core.findbugs")
|
||||
relocate("com.github.spotbugs", "com.plotsquared.core.spotbugs")
|
||||
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()
|
||||
@ -95,11 +97,11 @@ tasks.named<ShadowJar>("shadowJar") {
|
||||
tasks {
|
||||
withType<Javadoc> {
|
||||
val opt = options as StandardJavadocDocletOptions
|
||||
opt.links("https://papermc.io/javadocs/paper/1.18/")
|
||||
opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-bukkit/7.2.8/")
|
||||
opt.links("https://jd.papermc.io/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/4.9.3/")
|
||||
opt.links("https://google.github.io/guice/api-docs/5.0.1/javadoc/")
|
||||
opt.links("https://jd.adventure.kyori.net/api/" + libs.adventure.get().versionConstraint.toString())
|
||||
opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
|
||||
opt.links("https://checkerframework.org/api/")
|
||||
}
|
||||
}
|
||||
|
@ -238,6 +238,16 @@ 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();
|
||||
@ -503,8 +513,10 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
|
||||
this.backgroundPipeline.registerService(essentialsUUIDService);
|
||||
}
|
||||
|
||||
final SquirrelIdUUIDService impromptuMojangService = new SquirrelIdUUIDService(Settings.UUID.IMPROMPTU_LIMIT);
|
||||
this.impromptuPipeline.registerService(impromptuMojangService);
|
||||
if (Settings.UUID.IMPROMPTU_SERVICE_MOJANG_API) {
|
||||
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 {
|
||||
|
@ -65,7 +65,10 @@ final class BlockStatePopulator extends BlockPopulator {
|
||||
return;
|
||||
}
|
||||
final ChunkWrapper wrap = new ChunkWrapper(area.getWorldName(), source.getX(), source.getZ());
|
||||
final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z);
|
||||
final ScopedQueueCoordinator chunk = this.queue.getForChunk(wrap.x, wrap.z,
|
||||
com.plotsquared.bukkit.util.BukkitWorld.getMinWorldHeight(world),
|
||||
com.plotsquared.bukkit.util.BukkitWorld.getMaxWorldHeight(world) - 1
|
||||
);
|
||||
if (this.plotGenerator.populateChunk(chunk, area)) {
|
||||
this.queue.enqueue();
|
||||
}
|
||||
|
@ -25,7 +25,11 @@
|
||||
*/
|
||||
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;
|
||||
@ -52,7 +56,14 @@ public class BukkitAugmentedGenerator extends BlockPopulator {
|
||||
|
||||
@Override
|
||||
public void populate(@NonNull World world, @NonNull Random random, @NonNull Chunk source) {
|
||||
AugmentedUtils.generate(source, world.getName(), source.getX(), source.getZ(), null);
|
||||
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();
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -27,6 +27,7 @@ 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;
|
||||
@ -159,12 +160,14 @@ public class BukkitPlotGenerator extends ChunkGenerator
|
||||
@NonNull BiomeGrid biome
|
||||
) {
|
||||
|
||||
GenChunk result = new GenChunk();
|
||||
int minY = BukkitWorld.getMinWorldHeight(world);
|
||||
int maxY = BukkitWorld.getMaxWorldHeight(world);
|
||||
GenChunk result = new GenChunk(minY, maxY);
|
||||
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 = 0; y < world.getMaxHeight(); y++) {
|
||||
for (int y = minY; y < maxY; y++) {
|
||||
biome.setBiome(chunkX, y, chunkZ, Biome.PLAINS);
|
||||
|
||||
}
|
||||
|
@ -80,7 +80,8 @@ 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
|
||||
//do not annotate with Override until we discontinue support for 1.4.4 (we no longer support 1.4.4)
|
||||
@Override
|
||||
public void setBiome(int x, int y, int z, @NonNull Biome biome) {
|
||||
result.setBiome(x, z, BukkitAdapter.adapt(biome));
|
||||
|
||||
|
@ -74,6 +74,7 @@ import org.bukkit.GameMode;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.block.BlockState;
|
||||
import org.bukkit.block.data.BlockData;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Fireball;
|
||||
@ -92,6 +93,7 @@ import org.bukkit.event.block.BlockFormEvent;
|
||||
import org.bukkit.event.block.BlockFromToEvent;
|
||||
import org.bukkit.event.block.BlockGrowEvent;
|
||||
import org.bukkit.event.block.BlockIgniteEvent;
|
||||
import org.bukkit.event.block.BlockMultiPlaceEvent;
|
||||
import org.bukkit.event.block.BlockPhysicsEvent;
|
||||
import org.bukkit.event.block.BlockPistonExtendEvent;
|
||||
import org.bukkit.event.block.BlockPistonRetractEvent;
|
||||
@ -166,7 +168,7 @@ public class BlockEventListener implements Listener {
|
||||
}
|
||||
if (Settings.Redstone.DISABLE_OFFLINE) {
|
||||
boolean disable = false;
|
||||
if (!plot.getOwner().equals(DBFunc.SERVER)) {
|
||||
if (!DBFunc.SERVER.equals(plot.getOwner())) {
|
||||
if (plot.isMerged()) {
|
||||
disable = true;
|
||||
for (UUID owner : plot.getOwners()) {
|
||||
@ -277,7 +279,7 @@ public class BlockEventListener implements Listener {
|
||||
BukkitPlayer pp = BukkitUtil.adapt(player);
|
||||
Plot plot = area.getPlot(location);
|
||||
if (plot != null) {
|
||||
if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
|
||||
if ((location.getY() >= area.getMaxBuildHeight() || location.getY() < area
|
||||
.getMinBuildHeight()) && !Permissions
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
event.setCancelled(true);
|
||||
@ -352,7 +354,8 @@ public class BlockEventListener implements Listener {
|
||||
Plot plot = area.getPlot(location);
|
||||
if (plot != null) {
|
||||
BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
|
||||
if (event.getBlock().getY() == 0) {
|
||||
// == rather than <= as we only care about the "ground level" not being destroyed
|
||||
if (event.getBlock().getY() == area.getMinGenHeight()) {
|
||||
if (!Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL)) {
|
||||
plotPlayer.sendMessage(
|
||||
@ -362,7 +365,7 @@ public class BlockEventListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
} else if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
|
||||
} else if ((location.getY() >= area.getMaxBuildHeight() || location.getY() < area
|
||||
.getMinBuildHeight()) && !Permissions
|
||||
.hasPermission(plotPlayer, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
event.setCancelled(true);
|
||||
@ -548,6 +551,10 @@ 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:
|
||||
@ -647,7 +654,8 @@ public class BlockEventListener implements Listener {
|
||||
event.getBlock().breakNaturally();
|
||||
}
|
||||
}
|
||||
if (location.getY() == 0) {
|
||||
// == rather than <= as we only care about the "ground level" not being destroyed
|
||||
if (location.getY() == area.getMinGenHeight()) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
@ -746,62 +754,66 @@ public class BlockEventListener implements Listener {
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
|
||||
public void onChange(BlockFromToEvent event) {
|
||||
Block from = event.getBlock();
|
||||
Block fromBlock = event.getBlock();
|
||||
|
||||
// Check liquid flow flag inside of origin plot too
|
||||
final Location fLocation = BukkitUtil.adapt(from.getLocation());
|
||||
final PlotArea fromArea = fLocation.getPlotArea();
|
||||
final Location fromLocation = BukkitUtil.adapt(fromBlock.getLocation());
|
||||
final PlotArea fromArea = fromLocation.getPlotArea();
|
||||
if (fromArea != null) {
|
||||
final Plot plot = fromArea.getOwnedPlot(fLocation);
|
||||
if (plot != null && plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocation);
|
||||
if (fromPlot != null && fromPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
|
||||
.getBlock()
|
||||
.isLiquid()) {
|
||||
plot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
fromPlot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
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) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
Plot plot = area.getOwnedPlot(tLocation);
|
||||
if (toLocation.getY() >= toArea.getMaxBuildHeight() || toLocation.getY() < toArea.getMinBuildHeight()) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
Plot toPlot = toArea.getOwnedPlot(toLocation);
|
||||
|
||||
if (from.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fLocation);
|
||||
if (fromBlock.getType() == Material.DRAGON_EGG && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocation);
|
||||
|
||||
if (fromPlot != null || plot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(plot)) && (plot == null || !plot.equals(fromPlot))) {
|
||||
if (fromPlot != null || toPlot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(toPlot)) && (toPlot == null || !toPlot.equals(fromPlot))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (plot != null) {
|
||||
if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
|
||||
if (toPlot != null) {
|
||||
if (!toArea.contains(fromLocation.getX(), fromLocation.getZ()) || !Objects.equals(toPlot, toArea.getOwnedPlot(fromLocation))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event.getBlock().isLiquid()) {
|
||||
if (toPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event.getBlock().isLiquid()) {
|
||||
return;
|
||||
}
|
||||
if (plot.getFlag(DisablePhysicsFlag.class)) {
|
||||
plot.debug(event.getBlock().getType() + " could not update because disable-physics = true");
|
||||
if (toPlot.getFlag(DisablePhysicsFlag.class)) {
|
||||
toPlot.debug(event.getBlock().getType() + " could not update because disable-physics = true");
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
|
||||
plot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
if (toPlot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
|
||||
toPlot.debug("Liquid could not flow because liquid-flow = disabled");
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(null, area.getOwnedPlot(fLocation))) {
|
||||
} else if (!toArea.contains(fromLocation.getX(), fromLocation.getZ()) || !Objects.equals(null, toArea.getOwnedPlot(fromLocation))) {
|
||||
event.setCancelled(true);
|
||||
} else if (event.getBlock().isLiquid()) {
|
||||
final org.bukkit.Location location = event.getBlock().getLocation();
|
||||
@ -1208,4 +1220,51 @@ public class BlockEventListener implements Listener {
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* BlockMultiPlaceEvent is called unrelated to the BlockPlaceEvent itself and therefore doesn't respect the cancellation.
|
||||
*/
|
||||
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
|
||||
public void onBlockMultiPlace(BlockMultiPlaceEvent event) {
|
||||
// Check if the generic block place event would be cancelled
|
||||
blockCreate(event);
|
||||
if (event.isCancelled()) {
|
||||
return;
|
||||
}
|
||||
|
||||
BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
|
||||
Location placedLocation = BukkitUtil.adapt(event.getBlockReplacedState().getLocation());
|
||||
PlotArea area = placedLocation.getPlotArea();
|
||||
if (area == null) {
|
||||
return;
|
||||
}
|
||||
Plot plot = placedLocation.getPlot();
|
||||
|
||||
for (final BlockState state : event.getReplacedBlockStates()) {
|
||||
Location currentLocation = BukkitUtil.adapt(state.getLocation());
|
||||
if (!Permissions.hasPermission(
|
||||
pp,
|
||||
Permission.PERMISSION_ADMIN_BUILD_ROAD
|
||||
) && !(Objects.equals(currentLocation.getPlot(), plot))) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("permission.no_permission_event"),
|
||||
Template.of("node", String.valueOf(Permission.PERMISSION_ADMIN_BUILD_ROAD))
|
||||
);
|
||||
event.setCancelled(true);
|
||||
break;
|
||||
}
|
||||
if (Permissions.hasPermission(pp, Permission.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
|
||||
continue;
|
||||
}
|
||||
if (currentLocation.getY() >= area.getMaxBuildHeight() || currentLocation.getY() < area.getMinBuildHeight()) {
|
||||
pp.sendMessage(
|
||||
TranslatableCaption.of("height.height_limit"),
|
||||
Template.of("minHeight", String.valueOf(area.getMinBuildHeight())),
|
||||
Template.of("maxHeight", String.valueOf(area.getMaxBuildHeight()))
|
||||
);
|
||||
event.setCancelled(true);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -168,6 +168,7 @@ public class EntityEventListener implements Listener {
|
||||
case "RAID":
|
||||
case "SHEARED":
|
||||
case "SILVERFISH_BLOCK":
|
||||
case "ENDER_PEARL":
|
||||
case "TRAP":
|
||||
case "VILLAGE_DEFENSE":
|
||||
case "VILLAGE_INVASION":
|
||||
|
@ -36,6 +36,7 @@ import com.plotsquared.core.plot.flag.implementations.DoneFlag;
|
||||
import io.papermc.lib.PaperLib;
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.entity.ArmorStand;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.EntityType;
|
||||
@ -191,8 +192,32 @@ public class EntitySpawnListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onTeleport(EntityTeleportEvent event) {
|
||||
Entity ent = event.getEntity();
|
||||
if (ent instanceof Vehicle || ent instanceof ArmorStand) {
|
||||
Entity entity = event.getEntity();
|
||||
Entity fromLocation = event.getEntity();
|
||||
Block toLocation = event.getTo().getBlock();
|
||||
final Location fromLocLocation = BukkitUtil.adapt(fromLocation.getLocation());
|
||||
final PlotArea fromArea = fromLocLocation.getPlotArea();
|
||||
Location toLocLocation = BukkitUtil.adapt(toLocation.getLocation());
|
||||
PlotArea toArea = toLocLocation.getPlotArea();
|
||||
|
||||
if (toArea == null) {
|
||||
if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
return;
|
||||
}
|
||||
Plot toPlot = toArea.getOwnedPlot(toLocLocation);
|
||||
if (fromLocation.getType() == EntityType.SHULKER && fromArea != null) {
|
||||
final Plot fromPlot = fromArea.getOwnedPlot(fromLocLocation);
|
||||
|
||||
if (fromPlot != null || toPlot != null) {
|
||||
if ((fromPlot == null || !fromPlot.equals(toPlot)) && (toPlot == null || !toPlot.equals(fromPlot))) {
|
||||
event.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (entity instanceof Vehicle || entity instanceof ArmorStand) {
|
||||
testNether(event.getEntity());
|
||||
}
|
||||
}
|
||||
|
@ -44,6 +44,7 @@ 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;
|
||||
@ -195,6 +196,7 @@ public class PaperListener implements Listener {
|
||||
case "RAID":
|
||||
case "SHEARED":
|
||||
case "SILVERFISH_BLOCK":
|
||||
case "ENDER_PEARL":
|
||||
case "TRAP":
|
||||
case "VILLAGE_DEFENSE":
|
||||
case "VILLAGE_INVASION":
|
||||
@ -352,13 +354,15 @@ public class PaperListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!plot.isAdded(pp.getUUID())) {
|
||||
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 (!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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -76,7 +76,6 @@ 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;
|
||||
@ -223,10 +222,9 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("StringSplitter")
|
||||
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
|
||||
public void playerCommand(PlayerCommandPreprocessEvent event) {
|
||||
String msg = event.getMessage().toLowerCase().replaceAll("/", "").trim();
|
||||
String msg = event.getMessage().replace("/", "").toLowerCase(Locale.ROOT).trim();
|
||||
if (msg.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
@ -240,11 +238,9 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
String[] parts = msg.split(" ");
|
||||
Plot plot = plotPlayer.getCurrentPlot();
|
||||
// Check WorldEdit
|
||||
switch (parts[0].toLowerCase()) {
|
||||
switch (parts[0]) {
|
||||
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);
|
||||
@ -258,63 +254,67 @@ public class PlayerEventListener extends PlotListener implements Listener {
|
||||
List<String> blockedCommands = plot != null ?
|
||||
plot.getFlag(BlockedCmdsFlag.class) :
|
||||
area.getFlag(BlockedCmdsFlag.class);
|
||||
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));
|
||||
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";
|
||||
} else {
|
||||
pattern = RegExUtil.compiledPatterns.get(s);
|
||||
perm = "plots.admin.command.blocked-cmds.road";
|
||||
}
|
||||
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";
|
||||
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 (!Permissions.hasPermission(plotPlayer, perm)) {
|
||||
plotPlayer.sendMessage(TranslatableCaption.of("blockedcmds.command_blocked"));
|
||||
event.setCancelled(true);
|
||||
aliases.add(a);
|
||||
a = a.replaceFirst("/", "");
|
||||
if (!a.equals(label) && a.equals(part)) {
|
||||
part = label;
|
||||
break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!s1.equals(part)) {
|
||||
msg = msg.replace(s1, part);
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
|
||||
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
|
||||
|
@ -35,6 +35,7 @@ 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;
|
||||
@ -128,13 +129,15 @@ public class ProjectileEventListener implements Listener {
|
||||
event.setCancelled(true);
|
||||
}
|
||||
} else if (!plot.isAdded(pp.getUUID())) {
|
||||
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 (!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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -162,7 +165,7 @@ public class ProjectileEventListener implements Listener {
|
||||
return;
|
||||
}
|
||||
if (plot.isAdded(pp.getUUID()) || Permissions
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER)) {
|
||||
.hasPermission(pp, Permission.PERMISSION_ADMIN_PROJECTILE_OTHER) || plot.getFlag(ProjectilesFlag.class)) {
|
||||
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;
|
||||
private Field shouldSave = null;
|
||||
|
||||
public SingleWorldListener() throws Exception {
|
||||
ReflectionUtils.RefClass classCraftChunk = getRefClass("{cb}.CraftChunk");
|
||||
@ -59,9 +59,12 @@ public class SingleWorldListener implements Listener {
|
||||
} else {
|
||||
this.shouldSave = classChunk.getField("s").getRealField();
|
||||
}
|
||||
} else {
|
||||
} else if (PlotSquared.platform().serverVersion()[1] == 17) {
|
||||
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,11 +74,13 @@ 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 int batchSize;
|
||||
private PlotSquaredTask task;
|
||||
private boolean shouldCancel;
|
||||
private volatile boolean shouldCancel;
|
||||
private boolean finished;
|
||||
|
||||
@Inject
|
||||
@ -91,7 +93,8 @@ 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 @NonNull Collection<ProgressSubscriber> progressSubscribers,
|
||||
@Assisted final boolean forceSync
|
||||
) {
|
||||
this.requestedChunks = new LinkedBlockingQueue<>(requestedChunks);
|
||||
this.availableChunks = new LinkedBlockingQueue<>();
|
||||
@ -106,14 +109,27 @@ 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() {
|
||||
// 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));
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -130,7 +146,9 @@ public final class BukkitChunkCoordinator extends ChunkCoordinator {
|
||||
for (final ProgressSubscriber subscriber : this.progressSubscribers) {
|
||||
subscriber.notifyEnd();
|
||||
}
|
||||
task.cancel();
|
||||
if (task != null) {
|
||||
task.cancel();
|
||||
}
|
||||
finished = true;
|
||||
}
|
||||
}
|
||||
@ -150,6 +168,13 @@ 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];
|
||||
@ -197,9 +222,11 @@ 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,6 +51,7 @@ 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;
|
||||
@ -62,10 +63,27 @@ import java.util.function.Consumer;
|
||||
|
||||
public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
|
||||
private final SideEffectSet noSideEffectSet;
|
||||
private final SideEffectSet lightingSideEffectSet;
|
||||
private final SideEffectSet edgeSideEffectSet;
|
||||
private final SideEffectSet edgeLightingSideEffectSet;
|
||||
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 org.bukkit.World bukkitWorld;
|
||||
@Inject
|
||||
private ChunkCoordinatorBuilderFactory chunkCoordinatorBuilderFactory;
|
||||
@ -76,19 +94,6 @@ 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
|
||||
@ -111,8 +116,8 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
public boolean enqueue() {
|
||||
final Clipboard regenClipboard;
|
||||
if (isRegen()) {
|
||||
BlockVector3 start = BlockVector3.at(getRegenStart()[0] << 4, 0, getRegenStart()[1] << 4);
|
||||
BlockVector3 end = BlockVector3.at((getRegenEnd()[0] << 4) + 15, 255, (getRegenEnd()[1] << 4) + 15);
|
||||
BlockVector3 start = BlockVector3.at(getRegenStart()[0] << 4, getMinY(), getRegenStart()[1] << 4);
|
||||
BlockVector3 end = BlockVector3.at((getRegenEnd()[0] << 4) + 15, getMaxY(), (getRegenEnd()[1] << 4) + 15);
|
||||
Region region = new CuboidRegion(start, end);
|
||||
regenClipboard = new BlockArrayClipboard(region);
|
||||
regenClipboard.setOrigin(start);
|
||||
@ -134,7 +139,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
int sx = blockVector2.getX() << 4;
|
||||
int sz = blockVector2.getZ() << 4;
|
||||
if (isRegenChunk) {
|
||||
for (int layer = 0; layer < 16; layer++) {
|
||||
for (int layer = getMinLayer(); layer <= getMaxLayer(); layer++) {
|
||||
for (int y = 0; y < 16; y++) {
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
@ -170,7 +175,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, j);
|
||||
int y = ChunkUtil.getY(layer + localChunk.getMinSection(), j);
|
||||
int z = sz + lz;
|
||||
boolean edge = Settings.QUEUE.UPDATE_EDGES && isEdge(y >> 4, lx, y & 15, lz, blockVector2,
|
||||
localChunk
|
||||
@ -179,7 +184,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int layer = 0; layer < localChunk.getBaseblocks().length; layer++) {
|
||||
for (int layer = 0; layer < localChunk.getBiomes().length; layer++) {
|
||||
BiomeType[] biomesLayer = localChunk.getBiomes()[layer];
|
||||
if (biomesLayer == null) {
|
||||
continue;
|
||||
@ -201,7 +206,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
localChunk.getTiles().forEach((blockVector3, tag) -> {
|
||||
try {
|
||||
BaseBlock block = getWorld().getBlock(blockVector3).toBaseBlock(tag);
|
||||
getWorld().setBlock(blockVector3, block, noSideEffectSet);
|
||||
getWorld().setBlock(blockVector3, block, getSideEffectSet(SideEffectState.NONE));
|
||||
} catch (WorldEditException ignored) {
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
sw.restoreTag(getWorld().getName(), blockVector3.getX(), blockVector3.getY(), blockVector3.getZ());
|
||||
@ -258,15 +263,21 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
SideEffectSet sideEffectSet;
|
||||
if (lighting) {
|
||||
sideEffectSet = edge ? edgeLightingSideEffectSet : lightingSideEffectSet;
|
||||
sideEffectSet = getSideEffectSet(edge ? SideEffectState.EDGE_LIGHTING : SideEffectState.LIGHTING);
|
||||
} else {
|
||||
sideEffectSet = edge ? edgeSideEffectSet : noSideEffectSet;
|
||||
sideEffectSet = getSideEffectSet(edge ? SideEffectState.EDGE : SideEffectState.NONE);
|
||||
}
|
||||
getWorld().setBlock(loc, block, sideEffectSet);
|
||||
} catch (WorldEditException ignored) {
|
||||
// Fallback to not so nice method
|
||||
BlockData blockData = BukkitAdapter.adapt(block);
|
||||
Block existing = getBukkitWorld().getBlockAt(x, y, z);
|
||||
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);
|
||||
}
|
||||
final BlockState existingBaseBlock = BukkitAdapter.adapt(existing.getBlockData());
|
||||
if (BukkitBlockUtil.get(existing).equals(existingBaseBlock) && existing.getBlockData().matches(blockData)) {
|
||||
return;
|
||||
@ -282,7 +293,7 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
CompoundTag tag = block.getNbtData();
|
||||
StateWrapper sw = new StateWrapper(tag);
|
||||
|
||||
sw.restoreTag(getWorld().getName(), existing.getX(), existing.getY(), existing.getZ());
|
||||
sw.restoreTag(existing);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -295,47 +306,48 @@ public class BukkitQueueCoordinator extends BasicQueueCoordinator {
|
||||
}
|
||||
|
||||
private boolean isEdge(int layer, int x, int y, int z, BlockVector2 blockVector2, LocalChunk localChunk) {
|
||||
if (layer == 0 || layer == localChunk.getBaseblocks().length - 1) {
|
||||
int layerIndex = (layer - localChunk.getMinSection());
|
||||
if (layer == localChunk.getMinSection() || layerIndex == localChunk.getBaseblocks().length - 1) {
|
||||
return false;
|
||||
}
|
||||
if (x == 0) {
|
||||
LocalChunk localChunkX = getBlockChunks().get(blockVector2.withX(blockVector2.getX() - 1));
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layer] == null ||
|
||||
localChunkX.getBaseblocks()[layer][ChunkUtil.getJ(15, y, z)] != null) {
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkX.getBaseblocks()[layerIndex][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()[layer] == null ||
|
||||
localChunkX.getBaseblocks()[layer][ChunkUtil.getJ(0, y, z)] != null) {
|
||||
if (localChunkX == null || localChunkX.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkX.getBaseblocks()[layerIndex][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()[layer] == null ||
|
||||
localChunkZ.getBaseblocks()[layer][ChunkUtil.getJ(x, y, 15)] != null) {
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkZ.getBaseblocks()[layerIndex][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()[layer] == null ||
|
||||
localChunkZ.getBaseblocks()[layer][ChunkUtil.getJ(x, y, 0)] != null) {
|
||||
if (localChunkZ == null || localChunkZ.getBaseblocks()[layerIndex] == null ||
|
||||
localChunkZ.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, y, 0)] != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if (y == 0) {
|
||||
if (localChunk.getBaseblocks()[layer - 1] == null ||
|
||||
localChunk.getBaseblocks()[layer][ChunkUtil.getJ(x, 15, z)] != null) {
|
||||
if (localChunk.getBaseblocks()[layerIndex - 1] == null ||
|
||||
localChunk.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, 15, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
} else if (y == 15) {
|
||||
if (localChunk.getBaseblocks()[layer + 1] == null ||
|
||||
localChunk.getBaseblocks()[layer][ChunkUtil.getJ(x, 0, z)] != null) {
|
||||
if (localChunk.getBaseblocks()[layerIndex + 1] == null ||
|
||||
localChunk.getBaseblocks()[layerIndex][ChunkUtil.getJ(x, 0, z)] != null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
BaseBlock[] baseBlocks = localChunk.getBaseblocks()[layer];
|
||||
BaseBlock[] baseBlocks = localChunk.getBaseblocks()[layerIndex];
|
||||
if (x > 0 && baseBlocks[ChunkUtil.getJ(x - 1, y, z)] == null) {
|
||||
return true;
|
||||
}
|
||||
@ -374,4 +386,23 @@ 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,6 +31,7 @@ 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;
|
||||
@ -50,6 +51,7 @@ 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;
|
||||
@ -61,8 +63,14 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
public int chunkZ;
|
||||
private ChunkData chunkData = null;
|
||||
|
||||
public GenChunk() {
|
||||
super(null, Location.at("", 0, 0, 0), Location.at("", 15, 255, 15));
|
||||
/**
|
||||
* @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));
|
||||
this.biomes = Biome.values();
|
||||
}
|
||||
|
||||
@ -117,7 +125,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
return;
|
||||
}
|
||||
Biome biome = BukkitAdapter.adapt(biomeType);
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int y = getMin().getY(); y <= getMax().getY(); y++) {
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
this.biomeGrid.setBiome(x, y, z, biome);
|
||||
@ -130,7 +138,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 = y >> 4;
|
||||
int layer = getLayerIndex(y);
|
||||
BlockState[] data = result[layer];
|
||||
if (data == null) {
|
||||
result[layer] = data = new BlockState[4096];
|
||||
@ -164,7 +172,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
*/
|
||||
public boolean setBiome(int x, int z, @NonNull Biome biome) {
|
||||
if (this.biomeGrid != null) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int y = getMin().getY(); y <= getMax().getY(); y++) {
|
||||
this.setBiome(x, y, z, biome);
|
||||
}
|
||||
return true;
|
||||
@ -197,7 +205,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCache(final int x, final int y, final int z, final @NonNull BlockState id) {
|
||||
int i = y >> 4;
|
||||
int i = getLayerIndex(y);
|
||||
BlockState[] v = this.result[i];
|
||||
if (v == null) {
|
||||
this.result[i] = v = new BlockState[4096];
|
||||
@ -219,7 +227,7 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @Nullable BlockState getBlock(int x, int y, int z) {
|
||||
int i = y >> 4;
|
||||
int i = getLayerIndex(y);
|
||||
if (result == null) {
|
||||
return BukkitBlockUtil.get(chunkData.getType(x, y, z));
|
||||
}
|
||||
@ -246,16 +254,16 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMax() {
|
||||
return Location.at(getWorld().getName(), 15 + (getX() << 4), 255, 15 + (getZ() << 4));
|
||||
return Location.at(getWorld().getName(), 15 + (getX() << 4), super.getMax().getY(), 15 + (getZ() << 4));
|
||||
}
|
||||
|
||||
@Override
|
||||
public @NonNull Location getMin() {
|
||||
return Location.at(getWorld().getName(), getX() << 4, 0, getZ() << 4);
|
||||
return Location.at(getWorld().getName(), getX() << 4, super.getMin().getY(), getZ() << 4);
|
||||
}
|
||||
|
||||
public @NonNull GenChunk clone() {
|
||||
GenChunk toReturn = new GenChunk();
|
||||
GenChunk toReturn = new GenChunk(getMin().getY(), getMax().getY());
|
||||
if (this.result != null) {
|
||||
for (int i = 0; i < this.result.length; i++) {
|
||||
BlockState[] matrix = this.result[i];
|
||||
@ -269,4 +277,8 @@ public class GenChunk extends ScopedQueueCoordinator {
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
private int getLayerIndex(int y) {
|
||||
return (y - getMin().getY()) >> 4;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -44,6 +44,7 @@ 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;
|
||||
@ -166,14 +167,32 @@ public class StateWrapper {
|
||||
return str;
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation") // #setLine is needed for Spigot compatibility
|
||||
/**
|
||||
* 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
|
||||
*/
|
||||
public boolean restoreTag(String worldName, int x, int y, int z) {
|
||||
if (this.tag == null) {
|
||||
World world = BukkitUtil.getWorld(worldName);
|
||||
if (world == null) {
|
||||
return false;
|
||||
}
|
||||
World world = BukkitUtil.getWorld(worldName);
|
||||
Block block = world.getBlockAt(x, y, z);
|
||||
if (block == null) {
|
||||
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) {
|
||||
return false;
|
||||
}
|
||||
org.bukkit.block.BlockState state = block.getState();
|
||||
|
@ -42,6 +42,7 @@ import org.bukkit.inventory.InventoryView;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.inventory.PlayerInventory;
|
||||
import org.bukkit.inventory.meta.ItemMeta;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
@ -50,11 +51,15 @@ import java.util.stream.IntStream;
|
||||
@Singleton
|
||||
public class BukkitInventoryUtil extends InventoryUtil {
|
||||
|
||||
private static ItemStack getItem(PlotItemStack item) {
|
||||
private static @Nullable ItemStack getItem(PlotItemStack item) {
|
||||
if (item == null) {
|
||||
return null;
|
||||
}
|
||||
ItemStack stack = new ItemStack(BukkitAdapter.adapt(item.getType()), item.getAmount());
|
||||
Material material = BukkitAdapter.adapt(item.getType());
|
||||
if (material == null) {
|
||||
return null;
|
||||
}
|
||||
ItemStack stack = new ItemStack(material, item.getAmount());
|
||||
ItemMeta meta = null;
|
||||
if (item.getName() != null) {
|
||||
meta = stack.getItemMeta();
|
||||
@ -104,14 +109,19 @@ public class BukkitInventoryUtil extends InventoryUtil {
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setItem(PlotInventory inv, int index, PlotItemStack item) {
|
||||
public boolean setItemChecked(PlotInventory inv, int index, PlotItemStack item) {
|
||||
BukkitPlayer bp = (BukkitPlayer) inv.getPlayer();
|
||||
InventoryView opened = bp.player.getOpenInventory();
|
||||
if (!inv.isOpen()) {
|
||||
return;
|
||||
ItemStack stack = getItem(item);
|
||||
if (stack == null) {
|
||||
return false;
|
||||
}
|
||||
opened.setItem(index, getItem(item));
|
||||
if (!inv.isOpen()) {
|
||||
return true;
|
||||
}
|
||||
opened.setItem(index, stack);
|
||||
bp.player.updateInventory();
|
||||
return true;
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation") // Paper deprecation
|
||||
|
@ -40,7 +40,6 @@ 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;
|
||||
@ -261,7 +260,7 @@ public class BukkitRegionManager extends RegionManager {
|
||||
if (checkX2 && checkZ2) {
|
||||
map.saveRegion(world, xxt2, xxt, zzt2, zzt); //
|
||||
}
|
||||
CuboidRegion currentPlotClear = RegionUtil.createRegion(pos1.getX(), pos2.getX(), pos1.getZ(), pos2.getZ());
|
||||
CuboidRegion currentPlotClear = new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3());
|
||||
map.saveEntitiesOut(Bukkit.getWorld(world.getName()).getChunkAt(x, z), currentPlotClear);
|
||||
AugmentedUtils.bypass(
|
||||
ignoreAugment,
|
||||
@ -276,20 +275,16 @@ public class BukkitRegionManager extends RegionManager {
|
||||
PlotLoc plotLoc = new PlotLoc(bx + x1, bz + z1);
|
||||
BaseBlock[] ids = map.allBlocks.get(plotLoc);
|
||||
if (ids != null) {
|
||||
for (int y = 0; y < Math.min(128, ids.length); y++) {
|
||||
BaseBlock id = ids[y];
|
||||
int minY = value.getMin().getY();
|
||||
for (int yIndex = 0; yIndex < ids.length; yIndex++) {
|
||||
int y = yIndex + minY;
|
||||
BaseBlock id = ids[yIndex];
|
||||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -297,7 +292,7 @@ public class BukkitRegionManager extends RegionManager {
|
||||
}, world.getName(), chunk)
|
||||
);
|
||||
//map.restoreBlocks(worldObj, 0, 0);
|
||||
map.restoreEntities(Bukkit.getWorld(world.getName()), 0, 0);
|
||||
map.restoreEntities(Bukkit.getWorld(world.getName()));
|
||||
});
|
||||
regenQueue.setCompleteTask(whenDone);
|
||||
queue.setCompleteTask(regenQueue::enqueue);
|
||||
|
@ -76,7 +76,7 @@ public class BukkitSetupUtils extends SetupUtils {
|
||||
|
||||
@Override
|
||||
public void updateGenerators(final boolean force) {
|
||||
if (!SetupUtils.generators.isEmpty() && !force) {
|
||||
if (loaded && !SetupUtils.generators.isEmpty() && !force) {
|
||||
return;
|
||||
}
|
||||
String testWorld = "CheckingPlotSquaredGenerator";
|
||||
@ -100,6 +100,7 @@ public class BukkitSetupUtils extends SetupUtils {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
loaded = true;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -44,7 +44,6 @@ 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;
|
||||
@ -61,7 +60,6 @@ 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;
|
||||
@ -246,7 +244,9 @@ public class BukkitUtil extends WorldUtil {
|
||||
final World bukkitWorld = Objects.requireNonNull(getWorld(world));
|
||||
// Skip top and bottom block
|
||||
int air = 1;
|
||||
for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
|
||||
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--) {
|
||||
Block block = bukkitWorld.getBlockAt(x, y, z);
|
||||
Material type = block.getType();
|
||||
if (type.isSolid()) {
|
||||
@ -273,7 +273,9 @@ public class BukkitUtil extends WorldUtil {
|
||||
final World bukkitWorld = Objects.requireNonNull(getWorld(world));
|
||||
// Skip top and bottom block
|
||||
int air = 1;
|
||||
for (int y = bukkitWorld.getMaxHeight() - 1; y >= 0; y--) {
|
||||
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--) {
|
||||
Block block = bukkitWorld.getBlockAt(x, y, z);
|
||||
Material type = block.getType();
|
||||
if (type.isSolid()) {
|
||||
@ -345,13 +347,15 @@ 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.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;
|
||||
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;
|
||||
}
|
||||
}
|
||||
if (PlotSquared.platform().serverVersion()[1] == 13) {
|
||||
block.setType(Material.valueOf(area.legacySignMaterial()), false);
|
||||
@ -371,7 +375,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);
|
||||
sign.update(true, false);
|
||||
}
|
||||
});
|
||||
}
|
||||
@ -382,27 +386,6 @@ 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,6 +36,18 @@ 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;
|
||||
|
||||
@ -73,6 +85,24 @@ 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;
|
||||
@ -83,34 +113,41 @@ 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 (o == this) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (!(o instanceof final BukkitWorld other)) {
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
if (!Objects.equals(this.world, other.world)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
final BukkitWorld that = (BukkitWorld) o;
|
||||
return world.equals(that.world);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return world.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof BukkitWorld;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $world = this.world;
|
||||
result = result * PRIME + ($world == null ? 43 : $world.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return "BukkitWorld(world=" + this.world + ")";
|
||||
}
|
||||
|
@ -70,7 +70,7 @@ public class ContentMap {
|
||||
}
|
||||
for (int x = x1; x <= x2; x++) {
|
||||
for (int z = z1; z <= z2; z++) {
|
||||
saveBlocks(world, 256, x, z, 0, 0);
|
||||
saveBlocks(world, x, z);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -92,14 +92,7 @@ public class ContentMap {
|
||||
}
|
||||
}
|
||||
|
||||
void saveEntitiesIn(Chunk chunk, CuboidRegion region) {
|
||||
saveEntitiesIn(chunk, region, 0, 0, false);
|
||||
}
|
||||
|
||||
void saveEntitiesIn(
|
||||
Chunk chunk, CuboidRegion region, int offsetX, int offsetZ,
|
||||
boolean delete
|
||||
) {
|
||||
void saveEntitiesIn(Chunk chunk, CuboidRegion region, boolean delete) {
|
||||
for (Entity entity : chunk.getEntities()) {
|
||||
Location location = BukkitUtil.adapt(entity.getLocation());
|
||||
int x = location.getX();
|
||||
@ -111,8 +104,6 @@ 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) {
|
||||
@ -123,10 +114,10 @@ public class ContentMap {
|
||||
}
|
||||
}
|
||||
|
||||
void restoreEntities(World world, int xOffset, int zOffset) {
|
||||
void restoreEntities(World world) {
|
||||
for (EntityWrapper entity : this.entities) {
|
||||
try {
|
||||
entity.spawn(world, xOffset, zOffset);
|
||||
entity.spawn(world, 0, 0);
|
||||
} catch (Exception e) {
|
||||
LOGGER.error("Failed to restore entity", e);
|
||||
}
|
||||
@ -134,15 +125,13 @@ public class ContentMap {
|
||||
this.entities.clear();
|
||||
}
|
||||
|
||||
//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;
|
||||
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;
|
||||
}
|
||||
PlotLoc loc = new PlotLoc(x + offsetX, z + offsetZ);
|
||||
PlotLoc loc = new PlotLoc(x, z);
|
||||
this.allBlocks.put(loc, ids);
|
||||
}
|
||||
|
||||
|
@ -110,6 +110,11 @@ 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, whenDone);
|
||||
delegate.paste(schematic, plot, xOffset, yOffset, zOffset, autoHeight, actor, whenDone);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -22,7 +22,7 @@ dependencies {
|
||||
api(libs.guiceassistedinject) {
|
||||
exclude("com.google.inject", "guice")
|
||||
}
|
||||
api(libs.findbugs)
|
||||
api(libs.spotbugs)
|
||||
|
||||
// Plugins
|
||||
compileOnly(libs.worldeditCore) {
|
||||
@ -58,9 +58,9 @@ tasks.processResources {
|
||||
tasks {
|
||||
withType<Javadoc> {
|
||||
val opt = options as StandardJavadocDocletOptions
|
||||
opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-core/7.2.8/")
|
||||
opt.links("https://jd.adventure.kyori.net/api/4.9.3/")
|
||||
opt.links("https://google.github.io/guice/api-docs/5.0.1/javadoc/")
|
||||
opt.links("https://docs.enginehub.org/javadoc/com.sk89q.worldedit/worldedit-core/" + libs.worldeditCore.get().versionConstraint.toString())
|
||||
opt.links("https://jd.adventure.kyori.net/api/" + libs.adventure.get().versionConstraint.toString())
|
||||
opt.links("https://google.github.io/guice/api-docs/" + libs.guice.get().versionConstraint.toString() + "/javadoc/")
|
||||
opt.links("https://checkerframework.org/api/")
|
||||
}
|
||||
}
|
||||
|
@ -98,6 +98,22 @@ 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);
|
||||
LOGGER.info("| manager: {}", pa);
|
||||
LOGGER.info("| plot world: {}", pa.getClass().getCanonicalName());
|
||||
LOGGER.info("| manager: {}", pa.getPlotManager().getClass().getCanonicalName());
|
||||
LOGGER.info("Note: Area created for cluster '{}' (invalid or old configuration?)", name);
|
||||
areaGen.getPlotGenerator().initialize(pa);
|
||||
areaGen.augment(pa);
|
||||
@ -906,6 +906,13 @@ 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 {
|
||||
@ -913,9 +920,6 @@ 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);
|
||||
@ -1020,8 +1024,8 @@ public class PlotSquared {
|
||||
// save configuration
|
||||
|
||||
final List<String> validArguments = Arrays
|
||||
.asList("s=", "size=", "g=", "gap=", "h=", "height=", "f=", "floor=", "m=", "main=",
|
||||
"w=", "wall=", "b=", "border="
|
||||
.asList("s=", "size=", "g=", "gap=", "h=", "height=", "minh=", "minheight=", "maxh=", "maxheight=",
|
||||
"f=", "floor=", "m=", "main=", "w=", "wall=", "b=", "border="
|
||||
);
|
||||
|
||||
// Calculate the number of expected arguments
|
||||
@ -1100,6 +1104,14 @@ 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,6 +75,7 @@ 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;
|
||||
|
||||
@ -191,11 +192,12 @@ 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(), 0, playerSelectionMin.getZ()),
|
||||
BlockVector3.at(playerSelectionMax.getX(), 255, playerSelectionMax.getZ())
|
||||
BlockVector3.at(playerSelectionMin.getX(), world.getMinY(), playerSelectionMin.getZ()),
|
||||
BlockVector3.at(playerSelectionMax.getX(), world.getMaxY(), playerSelectionMax.getZ())
|
||||
);
|
||||
// There's only one plot in the area...
|
||||
final PlotId plotId = PlotId.of(1, 1);
|
||||
@ -278,9 +280,9 @@ public class Area extends SubCommand {
|
||||
if (offsetZ != 0) {
|
||||
this.worldConfiguration.set(path + ".road.offset.z", offsetZ);
|
||||
}
|
||||
final String world = this.setupUtils.setupWorld(singleBuilder);
|
||||
if (this.worldUtil.isWorld(world)) {
|
||||
PlotSquared.get().loadWorld(world, null);
|
||||
final String worldName = this.setupUtils.setupWorld(singleBuilder);
|
||||
if (this.worldUtil.isWorld(worldName)) {
|
||||
PlotSquared.get().loadWorld(worldName, null);
|
||||
player.sendMessage(TranslatableCaption.of("single.single_area_created"));
|
||||
} else {
|
||||
player.sendMessage(
|
||||
@ -369,7 +371,8 @@ 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);
|
||||
final CuboidRegion region = RegionUtil.createRegion(bx, tx, bz, tz);
|
||||
// Height doesn't matter for this region
|
||||
final CuboidRegion region = RegionUtil.createRegion(bx, tx, 0, 0, bz, tz);
|
||||
final Set<PlotArea> areas = this.plotAreaManager.getPlotAreasSet(area.getWorldName(), region);
|
||||
if (!areas.isEmpty()) {
|
||||
player.sendMessage(
|
||||
|
@ -28,6 +28,7 @@ package com.plotsquared.core.command;
|
||||
import com.plotsquared.core.configuration.caption.Caption;
|
||||
import com.plotsquared.core.configuration.caption.LocaleHolder;
|
||||
import com.plotsquared.core.configuration.caption.TranslatableCaption;
|
||||
import com.plotsquared.core.player.PlotPlayer;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
/**
|
||||
@ -95,4 +96,16 @@ public enum CommandCategory implements Caption {
|
||||
public String getComponent(@NonNull LocaleHolder localeHolder) {
|
||||
return this.caption.getComponent(localeHolder);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if a player has access to this command category
|
||||
*
|
||||
* @param player The player to check against
|
||||
* @return {@code true} if at least one command of this category can be executed by the player, {@code false} otherwise
|
||||
* @since 6.5.0
|
||||
*/
|
||||
boolean canAccess(PlotPlayer<?> player) {
|
||||
return !MainCommand.getInstance().getCommands(this, player).isEmpty();
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -48,7 +48,7 @@ public class Confirm extends SubCommand {
|
||||
player.sendMessage(TranslatableCaption.of("confirm.expired_confirm"));
|
||||
return false;
|
||||
}
|
||||
TaskManager.runTaskAsync(command.command);
|
||||
TaskManager.runTask(command.command);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -49,6 +49,7 @@ 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;
|
||||
@ -207,7 +208,7 @@ public class DebugExec extends SubCommand {
|
||||
}
|
||||
boolean result;
|
||||
if (HybridUtils.regions != null) {
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, HybridUtils.regions, 0, new HashSet<>());
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, HybridUtils.regions, 0, new LinkedHashSet<>());
|
||||
} else {
|
||||
result = this.hybridUtils.scheduleRoadUpdate(area, 0);
|
||||
}
|
||||
|
@ -161,6 +161,7 @@ public class Deny extends SubCommand {
|
||||
}
|
||||
|
||||
private void handleKick(PlotPlayer<?> player, Plot plot) {
|
||||
plot = plot.getBasePlot(false);
|
||||
if (player == null) {
|
||||
return;
|
||||
}
|
||||
|
@ -126,7 +126,7 @@ public class Done extends SubCommand {
|
||||
long flagValue = System.currentTimeMillis() / 1000;
|
||||
PlotFlag<?, ?> plotFlag = plot.getFlagContainer().getFlag(DoneFlag.class)
|
||||
.createFlagInstance(Long.toString(flagValue));
|
||||
PlotFlagAddEvent event = new PlotFlagAddEvent(plotFlag, plot);
|
||||
PlotFlagAddEvent event = eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
player.sendMessage(TranslatableCaption.of("events.event_denied"));
|
||||
return;
|
||||
|
@ -25,6 +25,7 @@
|
||||
*/
|
||||
package com.plotsquared.core.command;
|
||||
|
||||
import com.google.inject.Inject;
|
||||
import com.plotsquared.core.PlotSquared;
|
||||
import com.plotsquared.core.configuration.Settings;
|
||||
import com.plotsquared.core.configuration.caption.CaptionUtility;
|
||||
@ -44,6 +45,7 @@ import com.plotsquared.core.plot.flag.InternalFlag;
|
||||
import com.plotsquared.core.plot.flag.PlotFlag;
|
||||
import com.plotsquared.core.plot.flag.types.IntegerFlag;
|
||||
import com.plotsquared.core.plot.flag.types.ListFlag;
|
||||
import com.plotsquared.core.util.EventDispatcher;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import com.plotsquared.core.util.StringComparison;
|
||||
@ -79,8 +81,12 @@ import java.util.stream.Stream;
|
||||
@SuppressWarnings("unused")
|
||||
public final class FlagCommand extends Command {
|
||||
|
||||
public FlagCommand() {
|
||||
private final EventDispatcher eventDispatcher;
|
||||
|
||||
@Inject
|
||||
public FlagCommand(final @NonNull EventDispatcher eventDispatcher) {
|
||||
super(MainCommand.getInstance(), true);
|
||||
this.eventDispatcher = eventDispatcher;
|
||||
}
|
||||
|
||||
private static boolean sendMessage(PlotPlayer<?> player) {
|
||||
@ -114,7 +120,7 @@ public final class FlagCommand extends Command {
|
||||
TranslatableCaption.of("permission.no_permission"),
|
||||
Template.of(
|
||||
"node",
|
||||
perm
|
||||
perm + "." + numeric
|
||||
)
|
||||
);
|
||||
}
|
||||
@ -335,7 +341,7 @@ public final class FlagCommand extends Command {
|
||||
return;
|
||||
}
|
||||
Plot plot = player.getLocation().getPlotAbs();
|
||||
PlotFlagAddEvent event = new PlotFlagAddEvent(plotFlag, plot);
|
||||
PlotFlagAddEvent event = eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
@ -394,7 +400,7 @@ public final class FlagCommand extends Command {
|
||||
return;
|
||||
}
|
||||
Plot plot = player.getLocation().getPlotAbs();
|
||||
PlotFlagAddEvent event = new PlotFlagAddEvent(plotFlag, plot);
|
||||
PlotFlagAddEvent event = eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
@ -463,7 +469,7 @@ public final class FlagCommand extends Command {
|
||||
return;
|
||||
}
|
||||
final Plot plot = player.getLocation().getPlotAbs();
|
||||
PlotFlagRemoveEvent event = new PlotFlagRemoveEvent(flag, plot);
|
||||
PlotFlagRemoveEvent event = eventDispatcher.callFlagRemove(flag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
@ -516,7 +522,7 @@ public final class FlagCommand extends Command {
|
||||
}
|
||||
} else {
|
||||
PlotFlag<?, ?> plotFlag = parsedFlag.createFlagInstance(list);
|
||||
PlotFlagAddEvent addEvent = new PlotFlagAddEvent(plotFlag, plot);
|
||||
PlotFlagAddEvent addEvent = eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (addEvent.getEventResult() == Result.DENY) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
|
@ -37,11 +37,11 @@ import net.kyori.adventure.text.Component;
|
||||
import net.kyori.adventure.text.TextComponent;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
import java.util.Locale;
|
||||
import java.util.concurrent.CompletableFuture;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
@CommandDeclaration(command = "help",
|
||||
aliases = "?",
|
||||
@ -119,6 +119,9 @@ public class Help extends Command {
|
||||
TextComponent.Builder builder = Component.text();
|
||||
builder.append(MINI_MESSAGE.parse(TranslatableCaption.of("help.help_header").getComponent(player)));
|
||||
for (CommandCategory c : CommandCategory.values()) {
|
||||
if (!c.canAccess(player)) {
|
||||
continue;
|
||||
}
|
||||
builder.append(Component.newline()).append(MINI_MESSAGE
|
||||
.parse(
|
||||
TranslatableCaption.of("help.help_info_item").getComponent(player),
|
||||
@ -152,12 +155,26 @@ public class Help extends Command {
|
||||
|
||||
@Override
|
||||
public Collection<Command> tab(PlotPlayer<?> player, String[] args, boolean space) {
|
||||
return Stream.of("claiming", "teleport", "settings", "chat", "schematic", "appearance", "info", "debug",
|
||||
"administration", "all"
|
||||
)
|
||||
.filter(value -> value.startsWith(args[0].toLowerCase(Locale.ENGLISH)))
|
||||
.map(value -> new Command(null, false, value, "", RequiredType.NONE, null) {
|
||||
}).collect(Collectors.toList());
|
||||
final String argument = args[0].toLowerCase(Locale.ENGLISH);
|
||||
List<Command> result = new ArrayList<>();
|
||||
|
||||
for (final CommandCategory category : CommandCategory.values()) {
|
||||
if (!category.canAccess(player)) {
|
||||
continue;
|
||||
}
|
||||
String name = category.name().toLowerCase();
|
||||
if (!name.startsWith(argument)) {
|
||||
continue;
|
||||
}
|
||||
result.add(new Command(null, false, name, "", RequiredType.NONE, null) {
|
||||
});
|
||||
}
|
||||
// add the category "all"
|
||||
if ("all".startsWith(argument)) {
|
||||
result.add(new Command(null, false, "all", "", RequiredType.NONE, null) {
|
||||
});
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -32,6 +32,7 @@ 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;
|
||||
@ -39,6 +40,7 @@ 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;
|
||||
@ -418,7 +420,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())) {
|
||||
} else if (plot.isOwner(player.getUUID()) || plot.getOwner().equals(DBFunc.EVERYONE)) {
|
||||
color = TranslatableCaption.of("info.plot_list_owned_by");
|
||||
} else if (plot.isAdded(player.getUUID())) {
|
||||
color = TranslatableCaption.of("info.plot_list_added_to");
|
||||
@ -456,37 +458,60 @@ 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();
|
||||
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));
|
||||
}
|
||||
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())
|
||||
if (plot.getFlag(ServerPlotFlag.class)) {
|
||||
Template serverTemplate = Template.of(
|
||||
"info.server",
|
||||
TranslatableCaption.of("info.server").getComponent(player)
|
||||
);
|
||||
} catch (TimeoutException e) {
|
||||
player.sendMessage(TranslatableCaption.of("players.fetching_players_timeout"));
|
||||
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 = ", ";
|
||||
}
|
||||
} 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,6 +40,7 @@ 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;
|
||||
@ -205,7 +206,7 @@ public class Load extends SubCommand {
|
||||
if (split.length < 5) {
|
||||
continue;
|
||||
}
|
||||
String time = secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
|
||||
String time = TimeUtil.secToTime((System.currentTimeMillis() / 1000) - Long.parseLong(split[0]));
|
||||
String world = split[1];
|
||||
PlotId id = PlotId.fromString(split[2] + ';' + split[3]);
|
||||
String size = split[4];
|
||||
@ -223,6 +224,10 @@ 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) {
|
||||
|
@ -38,10 +38,13 @@ import com.plotsquared.core.plot.PlotInventory;
|
||||
import com.plotsquared.core.plot.PlotItemStack;
|
||||
import com.plotsquared.core.plot.flag.PlotFlag;
|
||||
import com.plotsquared.core.plot.flag.implementations.MusicFlag;
|
||||
import com.plotsquared.core.util.EventDispatcher;
|
||||
import com.plotsquared.core.util.InventoryUtil;
|
||||
import com.plotsquared.core.util.Permissions;
|
||||
import com.sk89q.worldedit.world.item.ItemType;
|
||||
import com.sk89q.worldedit.world.item.ItemTypes;
|
||||
import net.kyori.adventure.text.minimessage.Template;
|
||||
import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.util.Arrays;
|
||||
@ -63,10 +66,12 @@ public class Music extends SubCommand {
|
||||
);
|
||||
|
||||
private final InventoryUtil inventoryUtil;
|
||||
private final EventDispatcher eventDispatcher;
|
||||
|
||||
@Inject
|
||||
public Music(final @Nullable InventoryUtil inventoryUtil) {
|
||||
public Music(final @Nullable InventoryUtil inventoryUtil, final @NonNull EventDispatcher eventDispatcher) {
|
||||
this.inventoryUtil = inventoryUtil;
|
||||
this.eventDispatcher = eventDispatcher;
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -104,7 +109,7 @@ public class Music extends SubCommand {
|
||||
if (item.getType() == ItemTypes.BEDROCK) {
|
||||
PlotFlag<?, ?> plotFlag = plot.getFlagContainer().getFlag(MusicFlag.class)
|
||||
.createFlagInstance(item.getType());
|
||||
PlotFlagRemoveEvent event = new PlotFlagRemoveEvent(plotFlag, plot);
|
||||
PlotFlagRemoveEvent event = eventDispatcher.callFlagRemove(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
getPlayer().sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
@ -121,7 +126,7 @@ public class Music extends SubCommand {
|
||||
} else if (item.getName().toLowerCase(Locale.ENGLISH).contains("disc")) {
|
||||
PlotFlag<?, ?> plotFlag = plot.getFlagContainer().getFlag(MusicFlag.class)
|
||||
.createFlagInstance(item.getType());
|
||||
PlotFlagAddEvent event = new PlotFlagAddEvent(plotFlag, plot);
|
||||
PlotFlagAddEvent event = eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
getPlayer().sendMessage(
|
||||
TranslatableCaption.of("events.event_denied"),
|
||||
@ -144,8 +149,14 @@ public class Music extends SubCommand {
|
||||
for (final String disc : DISCS) {
|
||||
final String name = String.format("<gold>%s</gold>", disc);
|
||||
final String[] lore = {TranslatableCaption.of("plotjukebox.click_to_play").getComponent(player)};
|
||||
final PlotItemStack item = new PlotItemStack(disc, 1, name, lore);
|
||||
inv.setItem(index++, item);
|
||||
ItemType type = ItemTypes.get(disc);
|
||||
if (type == null) {
|
||||
continue;
|
||||
}
|
||||
final PlotItemStack item = new PlotItemStack(type, 1, name, lore);
|
||||
if (inv.setItemChecked(index, item)) {
|
||||
index++;
|
||||
}
|
||||
}
|
||||
|
||||
// Always add the cancel button
|
||||
|
@ -51,7 +51,7 @@ public class PluginCmd extends SubCommand {
|
||||
player.sendMessage(StaticCaption.of(
|
||||
"<gray>>> </gray><gold><bold>Authors<reset><gray>: </gray><gold>Citymonstret </gold><gray>& </gray><gold>Empire92 </gold><gray>& </gray><gold>MattBDev </gold><gray>& </gray><gold>dordsor21 </gold><gray>& </gray><gold>NotMyFault </gold><gray>& </gray><gold>SirYwell</gold>"));
|
||||
player.sendMessage(StaticCaption.of(
|
||||
"<gray>>> </gray><gold><bold>Wiki<reset><gray>: </gray><gold><click:open_url:https://github.com/IntellectualSites/PlotSquared-Documentation/wiki>https://github.com/IntellectualSites/PlotSquared-Documentation/wiki</gold>"));
|
||||
"<gray>>> </gray><gold><bold>Wiki<reset><gray>: </gray><gold><click:open_url:https://intellectualsites.github.io/plotsquared-documentation/>https://intellectualsites.github.io/plotsquared-documentation/</gold>"));
|
||||
player.sendMessage(StaticCaption.of(
|
||||
"<gray>>> </gray><gold><bold>Discord<reset><gray>: </gray><gold><click:open_url:https://discord.gg/intellectualsites>https://discord.gg/intellectualsites</gold>"));
|
||||
player.sendMessage(
|
||||
|
@ -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(0);
|
||||
corners[1] = corners[1].withY(255);
|
||||
corners[0] = corners[0].withY(plot.getArea().getMinBuildHeight());
|
||||
corners[1] = corners[1].withY(plot.getArea().getMaxBuildHeight());
|
||||
int size = (corners[1].getX() - corners[0].getX()) + 1;
|
||||
PlotId id = plot.getId();
|
||||
String world1 = plot.getArea().toString().replaceAll(";", "-")
|
||||
|
@ -57,8 +57,12 @@ 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(),
|
||||
location.getZ() - bottom.getZ(), location.getYaw(), location.getPitch()
|
||||
BlockLoc rel = new BlockLoc(
|
||||
location.getX() - bottom.getX(),
|
||||
location.getY(), // y is absolute
|
||||
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, bz, bz + 511);
|
||||
RegionUtil.createRegion(bx, bx + 511, 0, 0, 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(), bot.getZ(), top.getZ());
|
||||
.createRegion(bot.getX(), top.getX(), 0, 0, bot.getZ(), top.getZ());
|
||||
if (!RegionUtil.intersects(region, plotReg)) {
|
||||
continue;
|
||||
}
|
||||
|
@ -128,7 +128,7 @@ public class ComponentPresetManager {
|
||||
0,
|
||||
"",
|
||||
"<rainbow:2>Disco Floor</rainbow>",
|
||||
Arrays.asList("<gold>Spice up your plot floor</gold>"),
|
||||
List.of("<gold>Spice up your plot floor</gold>"),
|
||||
ItemTypes.YELLOW_WOOL
|
||||
));
|
||||
yamlConfiguration.set("presets", defaultPreset.stream().map(ComponentPreset::serialize).collect(Collectors.toList()));
|
||||
@ -181,6 +181,10 @@ public class ComponentPresetManager {
|
||||
}
|
||||
allowedPresets.add(componentPreset);
|
||||
}
|
||||
if (allowedPresets.isEmpty()) {
|
||||
player.sendMessage(TranslatableCaption.of("preset.empty"));
|
||||
return null;
|
||||
}
|
||||
final int size = (int) Math.ceil((double) allowedPresets.size() / 9.0D);
|
||||
final PlotInventory plotInventory = new PlotInventory(this.inventoryUtil, player, size,
|
||||
TranslatableCaption.of("preset.title").getComponent(player)) {
|
||||
@ -210,7 +214,13 @@ public class ComponentPresetManager {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (componentPreset.getCost() > 0.0D && econHandler.isEnabled(plot.getArea())) {
|
||||
if (componentPreset.getCost() > 0.0D) {
|
||||
if (!econHandler.isEnabled(plot.getArea())) {
|
||||
getPlayer().sendMessage(
|
||||
TranslatableCaption.of("preset.economy_disabled"),
|
||||
Template.of("preset", componentPreset.getDisplayName()));
|
||||
return false;
|
||||
}
|
||||
if (econHandler.getMoney(getPlayer()) < componentPreset.getCost()) {
|
||||
getPlayer().sendMessage(TranslatableCaption.of("preset.preset_cannot_afford"));
|
||||
return false;
|
||||
@ -246,11 +256,16 @@ public class ComponentPresetManager {
|
||||
for (int i = 0; i < allowedPresets.size(); i++) {
|
||||
final ComponentPreset preset = allowedPresets.get(i);
|
||||
final List<String> lore = new ArrayList<>();
|
||||
if (preset.getCost() > 0 && this.econHandler.isEnabled(plot.getArea())) {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_cost").getComponent(player),
|
||||
Template.of("cost", String.format("%.2f", preset.getCost()))
|
||||
)));
|
||||
if (preset.getCost() > 0) {
|
||||
if (!this.econHandler.isEnabled(plot.getArea())) {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_economy_disabled").getComponent(player))));
|
||||
} else {
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_cost").getComponent(player),
|
||||
Template.of("cost", String.format("%.2f", preset.getCost()))
|
||||
)));
|
||||
}
|
||||
}
|
||||
lore.add(MINI_MESSAGE.serialize(MINI_MESSAGE.parse(
|
||||
TranslatableCaption.of("preset.preset_lore_component").getComponent(player),
|
||||
|
@ -201,7 +201,7 @@ public class Settings extends Config {
|
||||
public List<String> WORLDS = new ArrayList<>(Collections.singletonList("*"));
|
||||
|
||||
|
||||
@Comment("See: https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Plot-analysis for a description of each value.")
|
||||
@Comment("See: https://intellectualsites.github.io/plotsquared-documentation/optimization/plot-analysis for a description of each value.")
|
||||
public static final class CALIBRATION {
|
||||
|
||||
public int VARIETY = 0;
|
||||
@ -221,7 +221,7 @@ public class Settings extends Config {
|
||||
|
||||
|
||||
@Comment({"Chunk processor related settings",
|
||||
"See https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Chunk-processor for more information."})
|
||||
"See https://intellectualsites.github.io/plotsquared-documentation/optimization/chunk-processor for more information."})
|
||||
public static class Chunk_Processor {
|
||||
|
||||
@Comment("Auto trim will not save chunks which aren't claimed")
|
||||
@ -249,6 +249,9 @@ 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)")
|
||||
@ -284,7 +287,7 @@ public class Settings extends Config {
|
||||
@Comment("Always show explosion Particles, even if explosion flag is set to false")
|
||||
public static boolean ALWAYS_SHOW_EXPLOSIONS = false;
|
||||
@Comment({"Blocks that may not be used in plot components",
|
||||
"Checkout the wiki article regarding plot components before modifying: https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Plot-Components"})
|
||||
"Checkout the wiki article regarding plot components before modifying: https://intellectualsites.github.io/plotsquared-documentation/customization/plot-components"})
|
||||
public static List<String>
|
||||
INVALID_BLOCKS = Arrays.asList(
|
||||
// Acacia Stuff
|
||||
@ -406,7 +409,7 @@ public class Settings extends Config {
|
||||
|
||||
|
||||
@Comment({"Schematic Settings",
|
||||
"See https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Schematic-on-Claim for more information."})
|
||||
"See https://intellectualsites.github.io/plotsquared-documentation/schematics/schematic-on-claim for more information."})
|
||||
public static final class Schematics {
|
||||
|
||||
@Comment(
|
||||
@ -535,7 +538,7 @@ public class Settings extends Config {
|
||||
|
||||
|
||||
@Comment({"Backup related settings",
|
||||
"See https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Backups for more information."})
|
||||
"See https://intellectualsites.github.io/plotsquared-documentation/plot-backups for more information."})
|
||||
public static final class Backup {
|
||||
|
||||
@Comment("Automatically backup plots when destructive commands are performed, e.g. /plot clear")
|
||||
@ -691,6 +694,7 @@ 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")
|
||||
@ -784,7 +788,7 @@ public class Settings extends Config {
|
||||
public static boolean
|
||||
PERSISTENT_ROAD_REGEN = true;
|
||||
@Comment({"Enable the `/plot component` preset GUI",
|
||||
"Read more about components here: https://github.com/IntellectualSites/PlotSquared-Documentation/wiki/Plot-Components"})
|
||||
"Read more about components here: https://intellectualsites.github.io/plotsquared-documentation/customization/plot-components"})
|
||||
public static boolean COMPONENT_PRESETS = true;
|
||||
@Comment("Enable per user locale")
|
||||
public static boolean PER_USER_LOCALE = false;
|
||||
|
@ -54,12 +54,23 @@ public class AugmentedUtils {
|
||||
enabled = true;
|
||||
}
|
||||
|
||||
public static boolean generate(
|
||||
@Nullable Object chunkObject,
|
||||
/**
|
||||
* 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(
|
||||
final @NonNull String world,
|
||||
final int chunkX,
|
||||
final int chunkZ,
|
||||
QueueCoordinator queue
|
||||
@Nullable QueueCoordinator queue
|
||||
) {
|
||||
if (!enabled) {
|
||||
return false;
|
||||
@ -70,7 +81,7 @@ public class AugmentedUtils {
|
||||
final int blockZ = chunkZ << 4;
|
||||
// Create a region that contains the
|
||||
// entire chunk
|
||||
CuboidRegion region = RegionUtil.createRegion(blockX, blockX + 15, blockZ, blockZ + 15);
|
||||
CuboidRegion region = RegionUtil.createRegion(blockX, blockX + 15, 0, 0, blockZ, blockZ + 15);
|
||||
// Query for plot areas in the chunk
|
||||
final Set<PlotArea> areas = PlotSquared.get().getPlotAreaManager().getPlotAreasSet(world, region);
|
||||
if (areas.isEmpty()) {
|
||||
@ -97,9 +108,6 @@ public class AugmentedUtils {
|
||||
.platform()
|
||||
.worldUtil()
|
||||
.getWeWorld(world));
|
||||
if (chunkObject != null) {
|
||||
queue.setChunkObject(chunkObject);
|
||||
}
|
||||
}
|
||||
QueueCoordinator primaryMask;
|
||||
// coordinates
|
||||
@ -122,6 +130,7 @@ 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];
|
||||
@ -132,7 +141,7 @@ public class AugmentedUtils {
|
||||
int worldZ = z + blockZ;
|
||||
boolean can = manager.getPlotId(worldX, 0, worldZ) == null;
|
||||
if (can) {
|
||||
for (int y = 1; y < 128; y++) {
|
||||
for (int y = area.getMinGenHeight() + startYOffset; y <= area.getMaxGenHeight(); y++) {
|
||||
queue.setBlock(worldX, y, worldZ, air);
|
||||
}
|
||||
canPlace[x][z] = true;
|
||||
@ -149,30 +158,24 @@ public class AugmentedUtils {
|
||||
secondaryMask = primaryMask;
|
||||
for (int x = relativeBottomX; x <= relativeTopX; x++) {
|
||||
for (int z = relativeBottomZ; z <= relativeTopZ; z++) {
|
||||
for (int y = 1; y < 128; y++) {
|
||||
for (int y = area.getMinGenHeight() + startYOffset; y <= area.getMaxGenHeight(); 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, 0, blockZ),
|
||||
Location.at(world, blockX + 15, 255, blockZ + 15)
|
||||
Location.at(world, blockX, area.getMinGenHeight(), blockZ),
|
||||
Location.at(world, blockX + 15, area.getMaxGenHeight(), blockZ + 15)
|
||||
);
|
||||
generator.generateChunk(scoped, area);
|
||||
generator.populateChunk(scoped, area);
|
||||
scoped.setForceSync(true);
|
||||
scoped.enqueue();
|
||||
}
|
||||
if (enqueue) {
|
||||
queue.enqueue();
|
||||
@ -180,4 +183,19 @@ 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,7 +37,6 @@ 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;
|
||||
@ -147,7 +146,15 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
) {
|
||||
Plot plot = classicPlotWorld.getPlotAbs(plotId);
|
||||
if (plot != null && plot.isBasePlot()) {
|
||||
return this.regionManager.setCuboids(classicPlotWorld, plot.getRegions(), blocks, 1, getWorldHeight(), actor, queue);
|
||||
return this.regionManager.setCuboids(
|
||||
classicPlotWorld,
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
classicPlotWorld.getMinBuildHeight(),
|
||||
classicPlotWorld.getMaxBuildHeight(),
|
||||
actor,
|
||||
queue
|
||||
);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
@ -175,7 +182,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
classicPlotWorld.PLOT_HEIGHT + 1,
|
||||
getWorldHeight(),
|
||||
classicPlotWorld.getMaxBuildHeight(),
|
||||
actor,
|
||||
queue
|
||||
);
|
||||
@ -204,7 +211,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld,
|
||||
plot.getRegions(),
|
||||
blocks,
|
||||
1,
|
||||
classicPlotWorld.getMinBuildHeight(),
|
||||
classicPlotWorld.PLOT_HEIGHT - 1,
|
||||
actor,
|
||||
queue
|
||||
@ -281,7 +288,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
}
|
||||
}
|
||||
|
||||
int maxY = classicPlotWorld.getPlotManager().getWorldHeight();
|
||||
int maxY = classicPlotWorld.getMaxBuildHeight();
|
||||
if (!plot.isMerged(Direction.NORTH)) {
|
||||
int z = bottom.getZ();
|
||||
for (int x = bottom.getX(); x <= top.getX(); x++) {
|
||||
@ -382,7 +389,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 = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -390,7 +397,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 = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -398,7 +405,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 = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -406,7 +413,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 = 1; y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
for (int y = classicPlotWorld.getMinBuildHeight(); y <= classicPlotWorld.WALL_HEIGHT; y++) {
|
||||
queue.setBlock(x, y, z, blocks);
|
||||
}
|
||||
}
|
||||
@ -501,7 +508,7 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
enqueue = true;
|
||||
}
|
||||
|
||||
int maxY = getWorldHeight();
|
||||
int maxY = classicPlotWorld.getMaxGenHeight();
|
||||
queue.setCuboid(
|
||||
Location.at(
|
||||
classicPlotWorld.getWorldName(),
|
||||
@ -513,27 +520,27 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
);
|
||||
if (classicPlotWorld.PLOT_BEDROCK) {
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 0, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, 0, ez - 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight(), sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMinGenHeight(), 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(), sx, 1, sz + 1),
|
||||
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, 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(
|
||||
@ -541,24 +548,12 @@ 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();
|
||||
}
|
||||
|
||||
@ -584,19 +579,32 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMaxGenHeight(), 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, 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(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, 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(
|
||||
@ -604,24 +612,12 @@ 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();
|
||||
}
|
||||
|
||||
@ -642,14 +638,19 @@ 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.getPlotManager().getWorldHeight(), ez - 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.getMaxGenHeight(), ez - 1),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
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)
|
||||
);
|
||||
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, 1, sz + 1),
|
||||
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()
|
||||
);
|
||||
@ -679,11 +680,12 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight() + startYOffset, sz + 1),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez - 1),
|
||||
classicPlotWorld.MAIN_BLOCK.toPattern()
|
||||
);
|
||||
@ -719,11 +721,12 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.getMinGenHeight() + startYOffset, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT - 1, ez),
|
||||
classicPlotWorld.MAIN_BLOCK.toPattern()
|
||||
);
|
||||
@ -758,11 +761,12 @@ public class ClassicPlotManager extends SquarePlotManager {
|
||||
classicPlotWorld.schematicStartHeight() + 1,
|
||||
sz
|
||||
),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getPlotManager().getWorldHeight(), ez),
|
||||
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.getMaxGenHeight(), ez),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
int startYOffset = classicPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
queue.setCuboid(
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, 1, sz),
|
||||
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.getMinGenHeight() + startYOffset, 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(255, config.getInt("plot.height"));
|
||||
this.PLOT_HEIGHT = Math.min(getMaxGenHeight(), 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(255, config.getInt("road.height"));
|
||||
this.ROAD_HEIGHT = Math.min(getMaxGenHeight(), config.getInt("road.height"));
|
||||
this.ROAD_BLOCK = new BlockBucket(config.getString("road.block"));
|
||||
this.WALL_FILLING = new BlockBucket(config.getString("wall.filling"));
|
||||
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");
|
||||
this.WALL_HEIGHT = Math.min(getMaxGenHeight() - (PLACE_TOP_BLOCK ? 1 : 0), config.getInt("wall.height"));
|
||||
this.CLAIMED_WALL_BLOCK = new BlockBucket(config.getString("wall.block_claimed"));
|
||||
}
|
||||
|
||||
int schematicStartHeight() {
|
||||
|
@ -91,7 +91,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
if (hybridPlotWorld.PLOT_BEDROCK) {
|
||||
for (short x = 0; x < 16; x++) {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
result.setBlock(x, 0, z, BlockTypes.BEDROCK.getDefaultState());
|
||||
result.setBlock(x, hybridPlotWorld.getMinGenHeight(), z, BlockTypes.BEDROCK.getDefaultState());
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -156,7 +156,7 @@ public class HybridGen extends IndependentPlotGenerator {
|
||||
}
|
||||
}
|
||||
// generation
|
||||
int startY = hybridPlotWorld.PLOT_BEDROCK ? 1 : 0;
|
||||
int startY = hybridPlotWorld.getMinGenHeight() + (hybridPlotWorld.PLOT_BEDROCK ? 1: 0);
|
||||
for (short x = 0; x < 16; x++) {
|
||||
if (insideRoadX[x]) {
|
||||
for (short z = 0; z < 16; z++) {
|
||||
|
@ -46,7 +46,6 @@ 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;
|
||||
@ -107,22 +106,32 @@ 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, 0, bot.getZ() - 1);
|
||||
Location pos2 = Location.at(hybridPlotWorld.getWorldName(), bot.getX(), Math.min(getWorldHeight(), 255), top.getZ() + 1);
|
||||
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
|
||||
);
|
||||
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();
|
||||
}
|
||||
@ -139,7 +148,7 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
(pos1.getX() + pos2.getX()) / 2,
|
||||
(pos1.getZ() + pos2.getZ()) / 2
|
||||
), biome)) {
|
||||
WorldUtil.setBiome(hybridPlotWorld.getWorldName(), pos1.getX(), pos1.getZ(), pos2.getX(), pos2.getZ(), biome);
|
||||
WorldUtil.setBiome(hybridPlotWorld.getWorldName(), new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()), biome);
|
||||
}
|
||||
}
|
||||
|
||||
@ -190,38 +199,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, 0, top.getZ() + 1);
|
||||
Location pos2 = Location.at(hybridPlotWorld.getWorldName(), top.getX() + 1, Math.min(getWorldHeight(), 255), bot.getZ());
|
||||
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());
|
||||
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);
|
||||
@ -271,11 +280,23 @@ public class HybridPlotManager extends ClassicPlotManager {
|
||||
queue.setCompleteTask(whenDone);
|
||||
}
|
||||
if (!canRegen) {
|
||||
queue.setCuboid(pos1.withY(0), pos2.withY(0), bedrock);
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.getMinGenHeight()),
|
||||
pos2.withY(hybridPlotWorld.getMinGenHeight()),
|
||||
hybridPlotWorld.PLOT_BEDROCK ? bedrock : filling
|
||||
);
|
||||
// Each component has a different layer
|
||||
queue.setCuboid(pos1.withY(1), pos2.withY(hybridPlotWorld.PLOT_HEIGHT - 1), filling);
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.getMinGenHeight() + 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(getWorldHeight()), BlockTypes.AIR.getDefaultState());
|
||||
queue.setCuboid(
|
||||
pos1.withY(hybridPlotWorld.PLOT_HEIGHT + 1),
|
||||
pos2.withY(hybridPlotWorld.getMaxGenHeight()),
|
||||
BlockTypes.AIR.getDefaultState()
|
||||
);
|
||||
queue.setBiomeCuboid(pos1, pos2, biome);
|
||||
} else {
|
||||
queue.setRegenRegion(new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3()));
|
||||
|
@ -79,6 +79,7 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
public int SCHEM_Y;
|
||||
private Location SIGN_LOCATION;
|
||||
private File root = null;
|
||||
private int lastOverlayHeightError = Integer.MIN_VALUE;
|
||||
|
||||
@Inject
|
||||
private SchematicHandler schematicHandler;
|
||||
@ -171,9 +172,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 / 2) - 1);
|
||||
this.PATH_WIDTH_LOWER = (short) (Math.floor(this.ROAD_WIDTH / 2f) - 1);
|
||||
} else {
|
||||
this.PATH_WIDTH_LOWER = (short) Math.floor(this.ROAD_WIDTH / 2);
|
||||
this.PATH_WIDTH_LOWER = (short) Math.floor(this.ROAD_WIDTH / 2f);
|
||||
}
|
||||
if (this.ROAD_WIDTH == 0) {
|
||||
this.PATH_WIDTH_UPPER = (short) (this.SIZE + 1);
|
||||
@ -251,31 +252,34 @@ public class HybridPlotWorld extends ClassicPlotWorld {
|
||||
Schematic schematic2 = this.schematicHandler.getSchematic(schematic2File);
|
||||
Schematic schematic3 = this.schematicHandler.getSchematic(schematic3File);
|
||||
int shift = this.ROAD_WIDTH / 2;
|
||||
int oddshift = (this.ROAD_WIDTH & 1) == 0 ? 0 : 1;
|
||||
int oddshift = (this.ROAD_WIDTH & 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() == 256) {
|
||||
if (schematic3.getClipboard().getDimensions().getY() == worldHeight) {
|
||||
SCHEM_Y = plotY = 0;
|
||||
} else if (!Settings.Schematics.PASTE_ON_TOP) {
|
||||
SCHEM_Y = plotY = getMinBuildHeight();
|
||||
SCHEM_Y = plotY = getMinBuildHeight() - getMinGenHeight();
|
||||
}
|
||||
}
|
||||
|
||||
if (schematic1 != null) {
|
||||
if (schematic1.getClipboard().getDimensions().getY() == 256) {
|
||||
SCHEM_Y = roadY = 0;
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != 256
|
||||
if (schematic1.getClipboard().getDimensions().getY() == worldHeight) {
|
||||
SCHEM_Y = roadY = getMinGenHeight();
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
|
||||
&& !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() != 256
|
||||
if (schematic3 != null && schematic3.getClipboard().getDimensions().getY() != worldHeight
|
||||
&& !Settings.Schematics.PASTE_ON_TOP) {
|
||||
plotY = PLOT_HEIGHT;
|
||||
}
|
||||
@ -428,7 +432,10 @@ 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) {
|
||||
LOGGER.error("Error adding overlay block. `y > height`");
|
||||
if (y != lastOverlayHeightError) {
|
||||
lastOverlayHeightError = y;
|
||||
LOGGER.error(String.format("Error adding overlay block. `y > height`. y=%s, height=%s", y, height));
|
||||
}
|
||||
return;
|
||||
}
|
||||
existing[y] = id;
|
||||
|
@ -41,10 +41,11 @@ 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.ChunkQueueCoordinator;
|
||||
import com.plotsquared.core.queue.BlockArrayCacheScopedQueueCoordinator;
|
||||
import com.plotsquared.core.queue.GlobalBlockQueue;
|
||||
import com.plotsquared.core.queue.QueueCoordinator;
|
||||
import com.plotsquared.core.util.ChunkManager;
|
||||
import com.plotsquared.core.util.EventDispatcher;
|
||||
import com.plotsquared.core.util.MathMan;
|
||||
import com.plotsquared.core.util.RegionManager;
|
||||
import com.plotsquared.core.util.RegionUtil;
|
||||
@ -64,6 +65,7 @@ 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;
|
||||
@ -72,6 +74,7 @@ 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;
|
||||
@ -80,11 +83,14 @@ 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;
|
||||
public static Set<BlockVector2> chunks = new HashSet<>();
|
||||
// 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 PlotArea area;
|
||||
public static boolean UPDATE = false;
|
||||
|
||||
@ -93,6 +99,7 @@ public class HybridUtils {
|
||||
private final GlobalBlockQueue blockQueue;
|
||||
private final WorldUtil worldUtil;
|
||||
private final SchematicHandler schematicHandler;
|
||||
private final EventDispatcher eventDispatcher;
|
||||
|
||||
@Inject
|
||||
public HybridUtils(
|
||||
@ -100,13 +107,15 @@ public class HybridUtils {
|
||||
final @NonNull ChunkManager chunkManager,
|
||||
final @NonNull GlobalBlockQueue blockQueue,
|
||||
final @NonNull WorldUtil worldUtil,
|
||||
final @NonNull SchematicHandler schematicHandler
|
||||
final @NonNull SchematicHandler schematicHandler,
|
||||
final @NonNull EventDispatcher eventDispatcher
|
||||
) {
|
||||
this.plotAreaManager = plotAreaManager;
|
||||
this.chunkManager = chunkManager;
|
||||
this.blockQueue = blockQueue;
|
||||
this.worldUtil = worldUtil;
|
||||
this.schematicHandler = schematicHandler;
|
||||
this.eventDispatcher = eventDispatcher;
|
||||
}
|
||||
|
||||
public void regeneratePlotWalls(final PlotArea area) {
|
||||
@ -128,6 +137,11 @@ 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();
|
||||
|
||||
@ -141,38 +155,31 @@ public class HybridUtils {
|
||||
final int ctz = tz >> 4;
|
||||
final int width = tx - bx + 1;
|
||||
final int length = tz - bz + 1;
|
||||
final int height = area.getMaxGenHeight() - area.getMinGenHeight() + 1;
|
||||
final int minHeight = area.getMinGenHeight();
|
||||
|
||||
final PlotArea area = this.plotAreaManager.getPlotArea(world, null);
|
||||
final BlockState[][][] newBlocks = new BlockState[height][width][length];
|
||||
|
||||
if (!(area instanceof HybridPlotWorld hpw)) {
|
||||
return;
|
||||
}
|
||||
BlockArrayCacheScopedQueueCoordinator oldBlockQueue = new BlockArrayCacheScopedQueueCoordinator(
|
||||
Location.at("", region.getMinimumPoint().withY(hpw.getMinGenHeight())),
|
||||
Location.at("", region.getMaximumPoint().withY(hpw.getMaxGenHeight()))
|
||||
);
|
||||
|
||||
ChunkQueueCoordinator chunk = new ChunkQueueCoordinator(worldUtil.getWeWorld(world), bot, top, false);
|
||||
hpw.getGenerator().generateChunk(chunk, hpw);
|
||||
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);
|
||||
});
|
||||
|
||||
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();
|
||||
final BlockState[][][] oldBlocks = oldBlockQueue.getBlockStates();
|
||||
|
||||
QueueCoordinator queue = area.getQueue();
|
||||
queue.addReadChunks(region.getChunks());
|
||||
queue.setChunkConsumer(blockVector2 -> {
|
||||
int X = blockVector2.getX();
|
||||
int Z = blockVector2.getZ();
|
||||
queue.setChunkConsumer(chunkPos -> {
|
||||
int X = chunkPos.getX();
|
||||
int Z = chunkPos.getZ();
|
||||
int minX;
|
||||
if (X == cbx) {
|
||||
minX = bx & 15;
|
||||
@ -207,11 +214,15 @@ public class HybridUtils {
|
||||
int xx = chunkBlockX + x;
|
||||
for (int z = minZ; z <= maxZ; z++) {
|
||||
int zz = chunkBlockZ + z;
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int yIndex = 0; yIndex < height; yIndex++) {
|
||||
int y = yIndex + minHeight;
|
||||
BlockState block = queue.getBlock(xx, y, zz);
|
||||
if (block == null) {
|
||||
block = AIR;
|
||||
}
|
||||
int xr = xb + x;
|
||||
int zr = zb + z;
|
||||
newBlocks[y][xr][zr] = block;
|
||||
newBlocks[yIndex][xr][zr] = block;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -228,11 +239,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 y = 0; y < 256; y++) {
|
||||
BlockState old = oldBlocks[y][x][z];
|
||||
for (int yIndex = 0; yIndex < height; yIndex++) {
|
||||
BlockState old = oldBlocks[yIndex][x][z]; // Nullable
|
||||
try {
|
||||
BlockState now = newBlocks[y][x][z];
|
||||
if (!old.equals(now)) {
|
||||
BlockState now = newBlocks[yIndex][x][z]; // Not null
|
||||
if (!now.equals(old) && !(old == null && now.getBlockType().equals(BlockTypes.AIR))) {
|
||||
changes[i]++;
|
||||
}
|
||||
if (now.getBlockType().getMaterial().isAir()) {
|
||||
@ -240,23 +251,23 @@ public class HybridUtils {
|
||||
} else {
|
||||
// check vertices
|
||||
// modifications_adjacent
|
||||
if (x > 0 && z > 0 && y > 0 && x < width - 1 && z < length - 1 && y < 255) {
|
||||
if (newBlocks[y - 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
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()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[y][x - 1][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[yIndex][x - 1][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[y][x][z - 1].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[yIndex][x][z - 1].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[y + 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[yIndex + 1][x][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[y][x + 1][z].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[yIndex][x + 1][z].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
if (newBlocks[y][x][z + 1].getBlockType().getMaterial().isAir()) {
|
||||
if (newBlocks[yIndex][x][z + 1].getBlockType().getMaterial().isAir()) {
|
||||
faces[i]++;
|
||||
}
|
||||
}
|
||||
@ -290,8 +301,6 @@ 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();
|
||||
});
|
||||
@ -348,7 +357,7 @@ public class HybridUtils {
|
||||
result.add(whenDone.value.variety_sd);
|
||||
PlotFlag<?, ?> plotFlag = GlobalFlagContainer.getInstance().getFlag(AnalysisFlag.class).createFlagInstance(
|
||||
result);
|
||||
PlotFlagAddEvent event = new PlotFlagAddEvent(plotFlag, origin);
|
||||
PlotFlagAddEvent event = eventDispatcher.callFlagAdd(plotFlag, origin);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
return;
|
||||
}
|
||||
@ -404,7 +413,7 @@ public class HybridUtils {
|
||||
}
|
||||
HybridUtils.UPDATE = true;
|
||||
Set<BlockVector2> regions = this.worldUtil.getChunkChunks(area.getWorldName());
|
||||
return scheduleRoadUpdate(area, regions, extend, new HashSet<>());
|
||||
return scheduleRoadUpdate(area, regions, extend, new LinkedHashSet<>());
|
||||
}
|
||||
|
||||
public boolean scheduleSingleRegionRoadUpdate(Plot plot, int extend) {
|
||||
@ -414,7 +423,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 HashSet<>());
|
||||
return scheduleRoadUpdate(plot.getArea(), regions, extend, new LinkedHashSet<>());
|
||||
}
|
||||
|
||||
public boolean scheduleRoadUpdate(
|
||||
@ -427,26 +436,29 @@ 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);
|
||||
boolean regenedRoad = regenerateRoad(area, chunk, extend, queue);
|
||||
if (!regenedRoad) {
|
||||
LOGGER.info("Failed to regenerate roads");
|
||||
LOGGER.info("Failed to regenerate roads in chunk {}", chunk);
|
||||
}
|
||||
}
|
||||
queue.enqueue();
|
||||
LOGGER.info("Cancelled road task");
|
||||
return;
|
||||
}
|
||||
count.incrementAndGet();
|
||||
if (count.intValue() % 20 == 0) {
|
||||
LOGGER.info("Progress: {}%", 100 * (2048 - chunks.size()) / 2048);
|
||||
if (count.intValue() % 10 == 0) {
|
||||
LOGGER.info("Progress: {}%", 100 * (initial - (chunks.size() + 1024 * regions.size())) / initial);
|
||||
}
|
||||
if (HybridUtils.regions.isEmpty() && chunks.isEmpty()) {
|
||||
regeneratePlotWalls(area);
|
||||
@ -458,7 +470,7 @@ public class HybridUtils {
|
||||
final Runnable task = this;
|
||||
TaskManager.runTaskAsync(() -> {
|
||||
try {
|
||||
if (chunks.size() < 1024) {
|
||||
if (chunks.size() < 64) {
|
||||
if (!HybridUtils.regions.isEmpty()) {
|
||||
Iterator<BlockVector2> iterator = HybridUtils.regions.iterator();
|
||||
BlockVector2 loc = iterator.next();
|
||||
@ -471,18 +483,35 @@ public class HybridUtils {
|
||||
}
|
||||
if (!chunks.isEmpty()) {
|
||||
TaskManager.getPlatformImplementation().sync(() -> {
|
||||
long start = System.currentTimeMillis();
|
||||
Iterator<BlockVector2> iterator = chunks.iterator();
|
||||
while (System.currentTimeMillis() - start < 20 && !chunks.isEmpty()) {
|
||||
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()) {
|
||||
final BlockVector2 chunk = iterator.next();
|
||||
iterator.remove();
|
||||
boolean regenedRoads = regenerateRoad(area, chunk, extend);
|
||||
boolean regenedRoads = regenerateRoad(area, chunk, extend, queue);
|
||||
if (!regenedRoads) {
|
||||
LOGGER.info("Failed to regenerate road");
|
||||
LOGGER.info("Failed to regenerate road in chunk {}", chunk);
|
||||
}
|
||||
}
|
||||
queue.setCompleteTask(task);
|
||||
queue.enqueue();
|
||||
return null;
|
||||
});
|
||||
return;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
@ -510,7 +539,6 @@ 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 ?
|
||||
@ -520,10 +548,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(plotManager, queue, sx, ex, sz, ez, sy);
|
||||
int ey = get_ey(plotworld, queue, sx, ex, sz, ez, sy);
|
||||
int bz = sz - plotworld.ROAD_WIDTH;
|
||||
int tz = sz - 1;
|
||||
int ty = get_ey(plotManager, queue, sx, ex, bz, tz, sy);
|
||||
int ty = get_ey(plotworld, 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));
|
||||
@ -549,11 +577,11 @@ public class HybridUtils {
|
||||
return true;
|
||||
}
|
||||
|
||||
public int get_ey(final PlotManager pm, QueueCoordinator queue, int sx, int ex, int sz, int ez, int sy) {
|
||||
private int get_ey(final HybridPlotWorld hpw, 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 <= pm.getWorldHeight(); y++) {
|
||||
for (int y = sy; y <= hpw.getMaxGenHeight(); y++) {
|
||||
if (y > ey) {
|
||||
BlockState block = queue.getBlock(x, y, z);
|
||||
if (!block.getBlockType().getMaterial().isAir()) {
|
||||
@ -566,7 +594,36 @@ 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;
|
||||
@ -592,92 +649,100 @@ public class HybridUtils {
|
||||
z -= plotWorld.ROAD_OFFSET_Z;
|
||||
final int finalX = x;
|
||||
final int finalZ = z;
|
||||
QueueCoordinator queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()));
|
||||
final boolean enqueue;
|
||||
final QueueCoordinator queue;
|
||||
if (queueCoordinator == null) {
|
||||
queue = this.blockQueue.getNewQueue(worldUtil.getWeWorld(plotWorld.getWorldName()));
|
||||
enqueue = true;
|
||||
} else {
|
||||
queue = queueCoordinator;
|
||||
enqueue = false;
|
||||
}
|
||||
if (id1 == null || id2 == null || id1 != id2) {
|
||||
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 (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);
|
||||
}
|
||||
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) {
|
||||
}
|
||||
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) {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + y,
|
||||
minY + dy,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
block
|
||||
);
|
||||
} else {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + dy,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
WEExtent.AIRBASE
|
||||
);
|
||||
} else {
|
||||
BaseBlock block = blocks[y];
|
||||
if (block != null) {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + y,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
block
|
||||
);
|
||||
} else {
|
||||
queue.setBlock(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
minY + y,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
WEExtent.AIRBASE
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
BiomeType biome = plotWorld.G_SCH_B.get(MathMan.pair(absX, absZ));
|
||||
if (biome != null) {
|
||||
queue.setBiome(finalX + X + plotWorld.ROAD_OFFSET_X, finalZ + Z + plotWorld.ROAD_OFFSET_Z, biome);
|
||||
} else {
|
||||
queue.setBiome(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
plotWorld.getPlotBiome()
|
||||
);
|
||||
}
|
||||
}
|
||||
BiomeType biome = plotWorld.G_SCH_B.get(MathMan.pair(absX, absZ));
|
||||
if (biome != null) {
|
||||
queue.setBiome(finalX + X + plotWorld.ROAD_OFFSET_X, finalZ + Z + plotWorld.ROAD_OFFSET_Z, biome);
|
||||
} else {
|
||||
queue.setBiome(
|
||||
finalX + X + plotWorld.ROAD_OFFSET_X,
|
||||
finalZ + Z + plotWorld.ROAD_OFFSET_Z,
|
||||
plotWorld.getPlotBiome()
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if (enqueue) {
|
||||
queue.enqueue();
|
||||
});
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
|
@ -96,7 +96,7 @@ public abstract class SquarePlotManager extends GridPlotManager {
|
||||
.floor(squarePlotWorld.ROAD_WIDTH / 2) - 1;
|
||||
int z = (squarePlotWorld.ROAD_OFFSET_Z + (pz * (squarePlotWorld.ROAD_WIDTH + squarePlotWorld.PLOT_WIDTH))) - (int) Math
|
||||
.floor(squarePlotWorld.ROAD_WIDTH / 2) - 1;
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, Math.min(getWorldHeight(), 255), z);
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMaxGenHeight(), 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.getMinBuildHeight(), z);
|
||||
return Location.at(squarePlotWorld.getWorldName(), x, squarePlotWorld.getMinGenHeight(), z);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -174,21 +174,9 @@ public class PlotListener {
|
||||
String greeting = plot.getFlag(GreetingFlag.class);
|
||||
if (!greeting.isEmpty()) {
|
||||
if (!Settings.Chat.NOTIFICATION_AS_ACTIONBAR) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("flags.greeting_flag_format"),
|
||||
Template.of("world", plot.getWorldName()),
|
||||
Template.of("plot_id", plot.getId().toString()),
|
||||
Template.of("alias", plot.getAlias()),
|
||||
Template.of("greeting", greeting)
|
||||
);
|
||||
plot.format(StaticCaption.of(greeting), player, false).thenAcceptAsync(player::sendMessage);
|
||||
} else {
|
||||
player.sendActionBar(
|
||||
TranslatableCaption.of("flags.greeting_flag_format"),
|
||||
Template.of("world", plot.getWorldName()),
|
||||
Template.of("plot_id", plot.getId().toString()),
|
||||
Template.of("alias", plot.getAlias()),
|
||||
Template.of("greeting", greeting)
|
||||
);
|
||||
plot.format(StaticCaption.of(greeting), player, false).thenAcceptAsync(player::sendActionBar);
|
||||
}
|
||||
}
|
||||
|
||||
@ -321,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, false).getComponent(player);
|
||||
String owner = PlayerManager.resolveName(plotOwner, true).getComponent(player);
|
||||
Caption header = fromFlag ? StaticCaption.of(title) : TranslatableCaption.of("titles" +
|
||||
".title_entered_plot");
|
||||
Caption subHeader = fromFlag ? StaticCaption.of(subtitle) : TranslatableCaption.of("titles" +
|
||||
@ -413,21 +401,9 @@ public class PlotListener {
|
||||
String farewell = plot.getFlag(FarewellFlag.class);
|
||||
if (!farewell.isEmpty()) {
|
||||
if (!Settings.Chat.NOTIFICATION_AS_ACTIONBAR) {
|
||||
player.sendMessage(
|
||||
TranslatableCaption.of("flags.farewell_flag_format"),
|
||||
Template.of("world", plot.getWorldName()),
|
||||
Template.of("plot_id", plot.getId().toString()),
|
||||
Template.of("alias", plot.getAlias()),
|
||||
Template.of("farewell", farewell)
|
||||
);
|
||||
plot.format(StaticCaption.of(farewell), player, false).thenAcceptAsync(player::sendMessage);
|
||||
} else {
|
||||
player.sendActionBar(
|
||||
TranslatableCaption.of("flags.farewell_flag_format"),
|
||||
Template.of("world", plot.getWorldName()),
|
||||
Template.of("plot_id", plot.getId().toString()),
|
||||
Template.of("alias", plot.getAlias()),
|
||||
Template.of("farewell", farewell)
|
||||
);
|
||||
plot.format(StaticCaption.of(farewell), player, false).thenAcceptAsync(player::sendActionBar);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -35,6 +35,7 @@ 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;
|
||||
@ -67,6 +68,9 @@ public class WESubscriber {
|
||||
WorldEdit.getInstance().getEventBus().unregister(this);
|
||||
return;
|
||||
}
|
||||
if (event.getStage() != EditSession.Stage.BEFORE_HISTORY) {
|
||||
return;
|
||||
}
|
||||
World worldObj = event.getWorld();
|
||||
if (worldObj == null) {
|
||||
return;
|
||||
|
@ -58,6 +58,21 @@ 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() {
|
||||
@ -74,6 +89,16 @@ 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 <= 0 || y >= 255)) {
|
||||
if (area.allowSigns() && (y <= area.getMinGenHeight() || y >= area.getMaxGenHeight())) {
|
||||
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 <= 0 || y >= 255)) {
|
||||
if (area.allowSigns() && (y <= area.getMinGenHeight() || y >= area.getMaxGenHeight())) {
|
||||
height = Math.max(y, manager.getSignLoc(this).getY() - 1);
|
||||
}
|
||||
result.accept(Location.at(getWorldName(), x, height + 1, z));
|
||||
@ -1420,15 +1420,7 @@ public class Plot {
|
||||
0
|
||||
);
|
||||
}
|
||||
Location location = Location
|
||||
.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + home.getX(),
|
||||
bottom.getY() + home.getY(),
|
||||
bottom.getZ() + home.getZ(),
|
||||
home.getYaw(),
|
||||
home.getPitch()
|
||||
);
|
||||
Location location = toHomeLocation(bottom, home);
|
||||
if (!this.worldUtil.getBlockSynchronous(location).getBlockType().getMaterial().isAir()) {
|
||||
location = location.withY(
|
||||
Math.max(1 + this.worldUtil.getHighestBlockSynchronous(
|
||||
@ -1461,15 +1453,7 @@ public class Plot {
|
||||
return;
|
||||
}
|
||||
Location bottom = this.getBottomAbs();
|
||||
Location location = Location
|
||||
.at(
|
||||
bottom.getWorldName(),
|
||||
bottom.getX() + home.getX(),
|
||||
bottom.getY() + home.getY(),
|
||||
bottom.getZ() + home.getZ(),
|
||||
home.getYaw(),
|
||||
home.getPitch()
|
||||
);
|
||||
Location location = toHomeLocation(bottom, home);
|
||||
this.worldUtil.getBlock(location, block -> {
|
||||
if (!block.getBlockType().getMaterial().isAir()) {
|
||||
this.worldUtil.getHighestBlock(this.getWorldName(), location.getX(), location.getZ(),
|
||||
@ -1482,6 +1466,17 @@ 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
|
||||
*
|
||||
@ -1619,8 +1614,8 @@ public class Plot {
|
||||
public double getVolume() {
|
||||
double count = 0;
|
||||
for (CuboidRegion region : getRegions()) {
|
||||
count += (region.getMaximumPoint().getX() - (double) region.getMinimumPoint().getX() + 1) * (
|
||||
region.getMaximumPoint().getZ() - (double) region.getMinimumPoint().getZ() + 1) * MAX_HEIGHT;
|
||||
// CuboidRegion#getArea is deprecated and we want to ensure use of correct height
|
||||
count += region.getLength() * region.getWidth() * (area.getMaxGenHeight() - area.getMinGenHeight() + 1);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
@ -1738,7 +1733,6 @@ 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) {
|
||||
@ -1786,6 +1780,7 @@ public class Plot {
|
||||
);
|
||||
}
|
||||
plotworld.getPlotManager().claimPlot(this, null);
|
||||
this.getPlotModificationManager().setSign(player.getName());
|
||||
return true;
|
||||
}
|
||||
|
||||
@ -2438,8 +2433,8 @@ public class Plot {
|
||||
return regions_cache;
|
||||
}
|
||||
if (!this.isMerged()) {
|
||||
Location pos1 = this.getBottomAbs();
|
||||
Location pos2 = this.getTopAbs();
|
||||
Location pos1 = this.getBottomAbs().withY(getArea().getMinBuildHeight());
|
||||
Location pos2 = this.getTopAbs().withY(getArea().getMaxBuildHeight());
|
||||
connected_cache = Sets.newHashSet(this);
|
||||
CuboidRegion rg = new CuboidRegion(pos1.getBlockVector3(), pos2.getBlockVector3());
|
||||
regions_cache = Collections.singleton(rg);
|
||||
|
@ -34,8 +34,6 @@ 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;
|
||||
@ -54,7 +52,6 @@ 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;
|
||||
@ -144,8 +141,10 @@ public abstract class PlotArea {
|
||||
private boolean homeAllowNonmember = false;
|
||||
private BlockLoc nonmemberHome;
|
||||
private BlockLoc defaultHome;
|
||||
private int maxBuildHeight = 256;
|
||||
private int minBuildHeight = 1;
|
||||
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 GameMode gameMode = GameModes.CREATIVE;
|
||||
private Map<String, PlotExpression> prices = new HashMap<>();
|
||||
private List<String> schematics = new ArrayList<>();
|
||||
@ -361,6 +360,8 @@ 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;
|
||||
@ -484,6 +485,8 @@ 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);
|
||||
|
||||
@ -1078,8 +1081,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(),
|
||||
pos2.toBlockVector3(Plot.MAX_HEIGHT - 1)
|
||||
pos1.toBlockVector3(getMinGenHeight()),
|
||||
pos2.toBlockVector3(getMaxGenHeight())
|
||||
);
|
||||
}
|
||||
};
|
||||
@ -1361,14 +1364,38 @@ 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,11 +89,17 @@ public class PlotCluster {
|
||||
}
|
||||
|
||||
private void setRegion() {
|
||||
this.region = RegionUtil.createRegion(this.pos1.getX(), this.pos2.getX(),
|
||||
this.region = RegionUtil.createRegion(this.pos1.getX(), this.pos2.getX(), 0, 0,
|
||||
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;
|
||||
}
|
||||
@ -165,7 +171,7 @@ public class PlotCluster {
|
||||
Consumer<Location> locationConsumer = toReturn ->
|
||||
PlotSquared.platform().worldUtil().getHighestBlock(this.area.getWorldName(), toReturn.getX(), toReturn.getZ(),
|
||||
highest -> {
|
||||
if (highest == 0) {
|
||||
if (highest <= area.getMinBuildHeight()) {
|
||||
highest = 63;
|
||||
}
|
||||
if (highest > toReturn.getY()) {
|
||||
@ -175,12 +181,12 @@ public class PlotCluster {
|
||||
}
|
||||
}
|
||||
);
|
||||
if (home.getY() == 0) {
|
||||
if (home.getY() == Integer.MIN_VALUE) {
|
||||
// default pos
|
||||
Plot center = getCenterPlot();
|
||||
center.getHome(location -> {
|
||||
Location toReturn = location;
|
||||
if (toReturn.getY() == 0) {
|
||||
if (toReturn.getY() <= area.getMinBuildHeight()) {
|
||||
PlotManager manager = this.area.getPlotManager();
|
||||
Location locationSign = manager.getSignLoc(center);
|
||||
toReturn = toReturn.withY(locationSign.getY());
|
||||
|
@ -103,9 +103,32 @@ public class PlotInventory {
|
||||
this.open = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Put an item into this inventory
|
||||
*
|
||||
* @param index the index (= slot) where to place the item
|
||||
* @param item the item to place
|
||||
* @see #setItemChecked(int, PlotItemStack)
|
||||
*/
|
||||
public void setItem(int index, PlotItemStack item) {
|
||||
setItemChecked(index, item);
|
||||
}
|
||||
|
||||
/**
|
||||
* Put an item into this inventory, while also checking the existence of the material in the current version
|
||||
*
|
||||
* @param index the index (= slot) where to place the item
|
||||
* @param item the item to place
|
||||
* @return {@code true} if the item could be placed, otherwise {@code false}
|
||||
* @see InventoryUtil#setItemChecked(PlotInventory, int, PlotItemStack)
|
||||
* @since 6.5.0
|
||||
*/
|
||||
public boolean setItemChecked(int index, PlotItemStack item) {
|
||||
if (!this.inventoryUtil.setItemChecked(this, index, item)) {
|
||||
return false;
|
||||
}
|
||||
this.items[index] = item;
|
||||
this.inventoryUtil.setItem(this, index, item);
|
||||
return true;
|
||||
}
|
||||
|
||||
public PlotItemStack getItem(int index) {
|
||||
|
@ -46,7 +46,21 @@ public class PlotItemStack {
|
||||
final String id, final int amount, final String name,
|
||||
final String... lore
|
||||
) {
|
||||
this.type = ItemTypes.get(id);
|
||||
this(ItemTypes.get(id), amount, name, lore);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param type The item type
|
||||
* @param amount Amount of items in the stack
|
||||
* @param name The display name of the item stack
|
||||
* @param lore The item stack lore
|
||||
* @since 6.5.0
|
||||
*/
|
||||
public PlotItemStack(
|
||||
final ItemType type, final int amount, final String name,
|
||||
final String... lore
|
||||
) {
|
||||
this.type = type;
|
||||
this.amount = amount;
|
||||
this.name = name;
|
||||
this.lore = lore;
|
||||
|
@ -69,8 +69,6 @@ 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
|
||||
*/
|
||||
@ -262,7 +260,9 @@ public final class PlotModificationManager {
|
||||
if (queue.size() > 0) {
|
||||
queue.setCompleteTask(run);
|
||||
queue.enqueue();
|
||||
return;
|
||||
}
|
||||
run.run();
|
||||
return;
|
||||
}
|
||||
Plot current = queue.poll();
|
||||
@ -309,7 +309,7 @@ public final class PlotModificationManager {
|
||||
return;
|
||||
}
|
||||
CuboidRegion region = regions.poll();
|
||||
PlotSquared.platform().regionManager().setBiome(region, extendBiome, biome, plot.getWorldName(), this);
|
||||
PlotSquared.platform().regionManager().setBiome(region, extendBiome, biome, plot.getArea(), this);
|
||||
}
|
||||
};
|
||||
run.run();
|
||||
@ -333,10 +333,9 @@ public final class PlotModificationManager {
|
||||
ids.add(current.getId());
|
||||
}
|
||||
this.plot.clearRatings();
|
||||
QueueCoordinator queue = null;
|
||||
QueueCoordinator queue = this.plot.getArea().getQueue();
|
||||
if (createSign) {
|
||||
this.removeSign();
|
||||
queue = this.plot.getArea().getQueue();
|
||||
}
|
||||
PlotManager manager = this.plot.getArea().getPlotManager();
|
||||
if (createRoad) {
|
||||
@ -525,28 +524,6 @@ 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.
|
||||
*
|
||||
@ -913,6 +890,28 @@ 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>
|
||||
@ -927,8 +926,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(), 0, bot.getZ());
|
||||
Location pos2 = Location.at(this.plot.getWorldName(), bot.getX(), MAX_HEIGHT, top.getZ());
|
||||
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());
|
||||
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);
|
||||
@ -946,8 +945,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).withY(0);
|
||||
Location pos2 = other.getBottomAbs().subtract(1, 0, 1).withY(MAX_HEIGHT);
|
||||
Location pos1 = this.plot.getTopAbs().add(1, 0, 1);
|
||||
Location pos2 = other.getBottomAbs().subtract(1, 0, 1);
|
||||
PlotSquared.platform().regionManager().regenerateRegion(pos1, pos2, true, null);
|
||||
} else if (this.plot.getArea().getTerrain() != PlotAreaTerrainType.ALL) { // no road generated => no road to remove
|
||||
this.plot.getArea().getPlotManager().removeRoadSouthEast(this.plot, queue);
|
||||
|
@ -105,31 +105,29 @@ public abstract class PlotWorld {
|
||||
return this.world;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (o == this) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (!(o instanceof final PlotWorld other)) {
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$world = this.getWorld();
|
||||
final Object other$world = other.getWorld();
|
||||
return Objects.equals(this$world, other$world);
|
||||
final PlotWorld plotWorld = (PlotWorld) o;
|
||||
return world.equals(plotWorld.world);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return world.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotWorld;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $world = this.getWorld();
|
||||
result = result * PRIME + ($world == null ? 43 : $world.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -136,18 +136,18 @@ public class ExpireManager {
|
||||
}
|
||||
|
||||
public void confirmExpiry(final PlotPlayer<?> pp) {
|
||||
try (final MetaDataAccess<Boolean> metaDataAccess = pp.accessTemporaryMetaData(
|
||||
PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
|
||||
if (metaDataAccess.isPresent()) {
|
||||
return;
|
||||
}
|
||||
if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
|
||||
final int num = plotsToDelete.size();
|
||||
while (!plotsToDelete.isEmpty()) {
|
||||
Iterator<Plot> iter = plotsToDelete.iterator();
|
||||
final Plot current = iter.next();
|
||||
if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
|
||||
TaskManager.runTask(() -> {
|
||||
TaskManager.runTask(() -> {
|
||||
try (final MetaDataAccess<Boolean> metaDataAccess = pp.accessTemporaryMetaData(
|
||||
PlayerMetaDataKeys.TEMPORARY_IGNORE_EXPIRE_TASK)) {
|
||||
if (metaDataAccess.isPresent()) {
|
||||
return;
|
||||
}
|
||||
if (plotsToDelete != null && !plotsToDelete.isEmpty() && pp.hasPermission("plots.admin.command.autoclear")) {
|
||||
final int num = plotsToDelete.size();
|
||||
while (!plotsToDelete.isEmpty()) {
|
||||
Iterator<Plot> iter = plotsToDelete.iterator();
|
||||
final Plot current = iter.next();
|
||||
if (!isExpired(new ArrayDeque<>(tasks), current).isEmpty()) {
|
||||
metaDataAccess.set(true);
|
||||
current.getCenter(pp::teleport);
|
||||
metaDataAccess.remove();
|
||||
@ -171,15 +171,15 @@ public class ExpireManager {
|
||||
cmd_keep,
|
||||
cmd_no_show_expir
|
||||
);
|
||||
});
|
||||
return;
|
||||
} else {
|
||||
iter.remove();
|
||||
return;
|
||||
} else {
|
||||
iter.remove();
|
||||
}
|
||||
}
|
||||
plotsToDelete.clear();
|
||||
}
|
||||
plotsToDelete.clear();
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@ -307,6 +307,7 @@ public class ExpireManager {
|
||||
this.running = 2;
|
||||
TaskManager.runTaskAsync(new Runnable() {
|
||||
private ConcurrentLinkedDeque<Plot> plots = null;
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
final Runnable task = this;
|
||||
@ -359,7 +360,7 @@ public class ExpireManager {
|
||||
.getFlag(AnalysisFlag.class)
|
||||
.createFlagInstance(changed.asList());
|
||||
PlotFlagAddEvent event =
|
||||
new PlotFlagAddEvent(plotFlag, newPlot);
|
||||
eventDispatcher.callFlagAdd(plotFlag, plot);
|
||||
if (event.getEventResult() == Result.DENY) {
|
||||
return;
|
||||
}
|
||||
@ -451,7 +452,7 @@ public class ExpireManager {
|
||||
plot.getPlotModificationManager().deletePlot(null, whenDone);
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
@Deprecated(forRemoval = true, since = "6.4.0")
|
||||
public long getAge(UUID uuid) {
|
||||
return getAge(uuid, false);
|
||||
}
|
||||
@ -462,7 +463,7 @@ public class ExpireManager {
|
||||
* @param uuid the uuid of the owner to check against
|
||||
* @param shouldDeleteUnknownOwner {@code true} if an unknown player should be counted as never online
|
||||
* @return the millis since the player was last online, or {@link Long#MAX_VALUE} if player was never online
|
||||
* @since TODO
|
||||
* @since 6.4.0
|
||||
*/
|
||||
public long getAge(UUID uuid, final boolean shouldDeleteUnknownOwner) {
|
||||
if (PlotSquared.platform().playerManager().getPlayerIfExists(uuid) != null) {
|
||||
|
@ -75,9 +75,9 @@ public class ExpiryTask {
|
||||
plots = plots != null ? plots : getPlotsToCheck();
|
||||
int diff = settings.REQUIRED_PLOTS;
|
||||
boolean min = true;
|
||||
if (settings.REQUIRED_PLOTS - plots.size() < settings.REQUIRED_PLOTS) {
|
||||
if (plots.size() > settings.REQUIRED_PLOTS) {
|
||||
min = false;
|
||||
diff = settings.REQUIRED_PLOTS - plots.size();
|
||||
diff = plots.size() - settings.REQUIRED_PLOTS;
|
||||
}
|
||||
List<Long> entireList =
|
||||
plots.stream().map(plot -> ExpireManager.IMP.getAge(plot, settings.DELETE_IF_OWNER_IS_UNKNOWN))
|
||||
@ -160,7 +160,7 @@ public class ExpiryTask {
|
||||
/**
|
||||
* Returns {@code true} if this task respects unknown owners
|
||||
* @return {@code true} if unknown owners should be counted as never online
|
||||
* @since TODO
|
||||
* @since 6.4.0
|
||||
*/
|
||||
public boolean shouldDeleteForUnknownOwner() {
|
||||
return settings.DELETE_IF_OWNER_IS_UNKNOWN;
|
||||
|
@ -371,33 +371,31 @@ public class FlagContainer {
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (o == this) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (!(o instanceof final FlagContainer other)) {
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$flagMap = this.getFlagMap();
|
||||
final Object other$flagMap = other.getFlagMap();
|
||||
return Objects.equals(this$flagMap, other$flagMap);
|
||||
final FlagContainer that = (FlagContainer) o;
|
||||
return flagMap.equals(that.flagMap);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return flagMap.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof FlagContainer;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $flagMap = this.getFlagMap();
|
||||
result = result * PRIME + ($flagMap == null ? 43 : $flagMap.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Update event types used in {@link PlotFlagUpdateHandler}.
|
||||
*/
|
||||
|
@ -93,6 +93,7 @@ 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;
|
||||
@ -134,17 +135,28 @@ public final class GlobalFlagContainer extends FlagContainer {
|
||||
stringClassMap = new HashMap<>();
|
||||
|
||||
// Register all default flags here
|
||||
// Block type list flags
|
||||
this.addFlag(BreakFlag.BREAK_NONE);
|
||||
this.addFlag(UseFlag.USE_NONE);
|
||||
this.addFlag(PlaceFlag.PLACE_NONE);
|
||||
|
||||
// Boolean flags
|
||||
this.addFlag(ExplosionFlag.EXPLOSION_FALSE);
|
||||
this.addFlag(UntrustedVisitFlag.UNTRUSTED_VISIT_FLAG_TRUE);
|
||||
this.addFlag(DenyExitFlag.DENY_EXIT_FLAG_FALSE);
|
||||
this.addFlag(AnimalAttackFlag.ANIMAL_ATTACK_FALSE);
|
||||
this.addFlag(AnimalInteractFlag.ANIMAL_INTERACT_FALSE);
|
||||
this.addFlag(BlockBurnFlag.BLOCK_BURN_FALSE);
|
||||
this.addFlag(BlockIgnitionFlag.BLOCK_IGNITION_TRUE);
|
||||
this.addFlag(ChatFlag.CHAT_FLAG_TRUE);
|
||||
this.addFlag(CopperOxideFlag.COPPER_OXIDE_FALSE);
|
||||
this.addFlag(CoralDryFlag.CORAL_DRY_FALSE);
|
||||
this.addFlag(CropGrowFlag.CROP_GROW_TRUE);
|
||||
this.addFlag(DenyExitFlag.DENY_EXIT_FLAG_FALSE);
|
||||
this.addFlag(DenyPortalsFlag.DENY_PORTALS_FALSE);
|
||||
this.addFlag(DenyPortalTravelFlag.DENY_PORTAL_TRAVEL_FALSE);
|
||||
this.addFlag(DeviceInteractFlag.DEVICE_INTERACT_FALSE);
|
||||
this.addFlag(DisablePhysicsFlag.DISABLE_PHYSICS_FALSE);
|
||||
this.addFlag(DropProtectionFlag.DROP_PROTECTION_FALSE);
|
||||
this.addFlag(EntityChangeBlockFlag.ENTITY_CHANGE_BLOCK_FALSE);
|
||||
this.addFlag(ExplosionFlag.EXPLOSION_FALSE);
|
||||
this.addFlag(ForcefieldFlag.FORCEFIELD_FALSE);
|
||||
this.addFlag(GrassGrowFlag.GRASS_GROW_TRUE);
|
||||
this.addFlag(HangingBreakFlag.HANGING_BREAK_FALSE);
|
||||
@ -154,52 +166,54 @@ public final class GlobalFlagContainer extends FlagContainer {
|
||||
this.addFlag(HostileInteractFlag.HOSTILE_INTERACT_FALSE);
|
||||
this.addFlag(IceFormFlag.ICE_FORM_FALSE);
|
||||
this.addFlag(IceMeltFlag.ICE_MELT_FALSE);
|
||||
this.addFlag(InstabreakFlag.INSTABREAK_FALSE);
|
||||
this.addFlag(InvincibleFlag.INVINCIBLE_FALSE);
|
||||
this.addFlag(ItemDropFlag.ITEM_DROP_TRUE);
|
||||
this.addFlag(KeepInventoryFlag.KEEP_INVENTORY_FALSE);
|
||||
this.addFlag(KelpGrowFlag.KELP_GROW_TRUE);
|
||||
this.addFlag(RedstoneFlag.REDSTONE_TRUE);
|
||||
this.addFlag(ServerPlotFlag.SERVER_PLOT_FALSE);
|
||||
this.addFlag(LeafDecayFlag.LEAF_DECAY_TRUE);
|
||||
this.addFlag(LecternReadBookFlag.LECTERN_READ_BOOK_FALSE);
|
||||
this.addFlag(MiscBreakFlag.MISC_BREAK_FALSE);
|
||||
this.addFlag(MobBreakFlag.MOB_BREAK_FALSE);
|
||||
this.addFlag(MobPlaceFlag.MOB_PLACE_FALSE);
|
||||
this.addFlag(MiscInteractFlag.MISC_INTERACT_FALSE);
|
||||
this.addFlag(MiscPlaceFlag.MISC_PLACE_FALSE);
|
||||
this.addFlag(MycelGrowFlag.MYCEL_GROW_TRUE);
|
||||
this.addFlag(NotifyEnterFlag.NOTIFY_ENTER_FALSE);
|
||||
this.addFlag(NotifyLeaveFlag.NOTIFY_LEAVE_FALSE);
|
||||
this.addFlag(NoWorldeditFlag.NO_WORLDEDIT_FALSE);
|
||||
this.addFlag(PlayerInteractFlag.PLAYER_INTERACT_FALSE);
|
||||
this.addFlag(PreventCreativeCopyFlag.PREVENT_CREATIVE_COPY_FALSE);
|
||||
this.addFlag(PveFlag.PVE_FALSE);
|
||||
this.addFlag(PvpFlag.PVP_FALSE);
|
||||
this.addFlag(RedstoneFlag.REDSTONE_TRUE);
|
||||
this.addFlag(ServerPlotFlag.SERVER_PLOT_FALSE);
|
||||
this.addFlag(SnowFormFlag.SNOW_FORM_FALSE);
|
||||
this.addFlag(SnowMeltFlag.SNOW_MELT_TRUE);
|
||||
this.addFlag(SoilDryFlag.SOIL_DRY_FALSE);
|
||||
this.addFlag(CoralDryFlag.CORAL_DRY_FALSE);
|
||||
this.addFlag(TamedAttackFlag.TAMED_ATTACK_FALSE);
|
||||
this.addFlag(TamedInteractFlag.TAMED_INTERACT_FALSE);
|
||||
this.addFlag(UntrustedVisitFlag.UNTRUSTED_VISIT_FLAG_TRUE);
|
||||
this.addFlag(VehicleBreakFlag.VEHICLE_BREAK_FALSE);
|
||||
this.addFlag(VehiclePlaceFlag.VEHICLE_PLACE_FALSE);
|
||||
this.addFlag(VehicleUseFlag.VEHICLE_USE_FALSE);
|
||||
this.addFlag(VillagerInteractFlag.VILLAGER_INTERACT_FALSE);
|
||||
this.addFlag(VineGrowFlag.VINE_GROW_TRUE);
|
||||
this.addFlag(ItemDropFlag.ITEM_DROP_TRUE);
|
||||
this.addFlag(InstabreakFlag.INSTABREAK_FALSE);
|
||||
this.addFlag(InvincibleFlag.INVINCIBLE_FALSE);
|
||||
this.addFlag(ChatFlag.CHAT_FLAG_TRUE);
|
||||
this.addFlag(MiscPlaceFlag.MISC_PLACE_FALSE);
|
||||
this.addFlag(MiscInteractFlag.MISC_INTERACT_FALSE);
|
||||
this.addFlag(KeepInventoryFlag.KEEP_INVENTORY_FALSE);
|
||||
this.addFlag(PreventCreativeCopyFlag.PREVENT_CREATIVE_COPY_FALSE);
|
||||
this.addFlag(LeafDecayFlag.LEAF_DECAY_TRUE);
|
||||
this.addFlag(CropGrowFlag.CROP_GROW_TRUE);
|
||||
this.addFlag(DenyPortalTravelFlag.DENY_PORTAL_TRAVEL_FALSE);
|
||||
this.addFlag(DenyPortalsFlag.DENY_PORTALS_FALSE);
|
||||
this.addFlag(LecternReadBookFlag.LECTERN_READ_BOOK_FALSE);
|
||||
this.addFlag(EntityChangeBlockFlag.ENTITY_CHANGE_BLOCK_FALSE);
|
||||
this.addFlag(CopperOxideFlag.COPPER_OXIDE_FALSE);
|
||||
this.addFlag(ProjectilesFlag.PROJECTILES_FALSE);
|
||||
|
||||
// Double flags
|
||||
this.addFlag(PriceFlag.PRICE_NOT_BUYABLE);
|
||||
|
||||
// Enum Flags
|
||||
this.addFlag(WeatherFlag.PLOT_WEATHER_FLAG_OFF);
|
||||
this.addFlag(DenyTeleportFlag.DENY_TELEPORT_FLAG_NONE);
|
||||
this.addFlag(TitlesFlag.TITLES_NONE);
|
||||
this.addFlag(FlyFlag.FLIGHT_FLAG_DEFAULT);
|
||||
this.addFlag(LiquidFlowFlag.LIQUID_FLOW_DEFAULT);
|
||||
this.addFlag(TitlesFlag.TITLES_NONE);
|
||||
this.addFlag(WeatherFlag.PLOT_WEATHER_FLAG_OFF);
|
||||
|
||||
// Internal flags
|
||||
this.addFlag(new AnalysisFlag(Collections.emptyList()));
|
||||
this.addFlag(new DoneFlag(""));
|
||||
|
||||
// Integer flags
|
||||
this.addFlag(AnimalCapFlag.ANIMAL_CAP_UNLIMITED);
|
||||
@ -210,22 +224,10 @@ public final class GlobalFlagContainer extends FlagContainer {
|
||||
this.addFlag(TimeFlag.TIME_DISABLED);
|
||||
this.addFlag(VehicleCapFlag.VEHICLE_CAP_UNLIMITED);
|
||||
|
||||
// Timed flags
|
||||
this.addFlag(FeedFlag.FEED_NOTHING);
|
||||
this.addFlag(HealFlag.HEAL_NOTHING);
|
||||
|
||||
// Double flags
|
||||
this.addFlag(PriceFlag.PRICE_NOT_BUYABLE);
|
||||
|
||||
// Block type list flags
|
||||
this.addFlag(BreakFlag.BREAK_NONE);
|
||||
this.addFlag(PlaceFlag.PLACE_NONE);
|
||||
this.addFlag(UseFlag.USE_NONE);
|
||||
|
||||
// Misc
|
||||
this.addFlag(BlockedCmdsFlag.BLOCKED_CMDS_FLAG_NONE);
|
||||
this.addFlag(GamemodeFlag.GAMEMODE_FLAG_DEFAULT);
|
||||
this.addFlag(GuestGamemodeFlag.GUEST_GAMEMODE_FLAG_DEFAULT);
|
||||
this.addFlag(BlockedCmdsFlag.BLOCKED_CMDS_FLAG_NONE);
|
||||
this.addFlag(KeepFlag.KEEP_FLAG_FALSE);
|
||||
this.addFlag(MusicFlag.MUSIC_FLAG_NONE);
|
||||
|
||||
@ -235,9 +237,9 @@ public final class GlobalFlagContainer extends FlagContainer {
|
||||
this.addFlag(FarewellFlag.FAREWELL_FLAG_EMPTY);
|
||||
this.addFlag(PlotTitleFlag.TITLE_FLAG_DEFAULT);
|
||||
|
||||
// Internal flags
|
||||
this.addFlag(new AnalysisFlag(Collections.emptyList()));
|
||||
this.addFlag(new DoneFlag(""));
|
||||
// Timed flags
|
||||
this.addFlag(FeedFlag.FEED_NOTHING);
|
||||
this.addFlag(HealFlag.HEAL_NOTHING);
|
||||
}
|
||||
|
||||
public static void setup() {
|
||||
|
@ -31,6 +31,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Objects;
|
||||
|
||||
/**
|
||||
* A plot flag is any property that can be assigned
|
||||
@ -200,34 +201,30 @@ public abstract class PlotFlag<T, F extends PlotFlag<T, F>> {
|
||||
return Collections.emptyList();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(final Object o) {
|
||||
if (o == this) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (!(o instanceof final PlotFlag<?, ?> other)) {
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
if (!other.canEqual(this)) {
|
||||
return false;
|
||||
}
|
||||
final Object this$value = this.getValue();
|
||||
final Object other$value = other.getValue();
|
||||
if (this$value == null ? other$value != null : !this$value.equals(other$value)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
final PlotFlag<?, ?> plotFlag = (PlotFlag<?, ?>) o;
|
||||
return value.equals(plotFlag.value);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return value.hashCode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated This method is not meant to be invoked or overridden, with no replacement.
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
protected boolean canEqual(final Object other) {
|
||||
return other instanceof PlotFlag;
|
||||
}
|
||||
|
||||
public int hashCode() {
|
||||
final int PRIME = 59;
|
||||
int result = 1;
|
||||
final Object $value = this.getValue();
|
||||
result = result * PRIME + ($value == null ? 43 : $value.hashCode());
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -0,0 +1,46 @@
|
||||
/*
|
||||
* _____ _ _ _____ _
|
||||
* | __ \| | | | / ____| | |
|
||||
* | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
|
||||
* | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
|
||||
* | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
|
||||
* |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
|
||||
* | |
|
||||
* |_|
|
||||
* 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,6 +34,7 @@ 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;
|
||||
@ -61,6 +62,7 @@ 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;
|
||||
@ -68,7 +70,8 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
private CuboidRegion regenRegion = null;
|
||||
private Consumer<BlockVector2> consumer = null;
|
||||
private boolean unloadAfter = true;
|
||||
private Runnable whenDone;
|
||||
private Runnable whenDone = null;
|
||||
private SideEffectSet sideEffectSet = null;
|
||||
@Nullable
|
||||
private LightingMode lightingMode = LightingMode.valueOf(Settings.QUEUE.LIGHTING_MODE);
|
||||
|
||||
@ -101,7 +104,7 @@ public abstract class BasicQueueCoordinator extends QueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BaseBlock id) {
|
||||
if ((y > 255) || (y < 0)) {
|
||||
if ((y > world.getMaxY()) || (y < world.getMinY())) {
|
||||
return false;
|
||||
}
|
||||
LocalChunk chunk = getChunk(x >> 4, z >> 4);
|
||||
@ -120,8 +123,11 @@ 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 = 0; y < 256; y++) {
|
||||
for (int y = world.getMinY(); y <= world.getMaxY(); y++) {
|
||||
chunk.setBiome(x & 15, y, z & 15, biomeType);
|
||||
}
|
||||
settingBiomes = true;
|
||||
@ -130,6 +136,9 @@ 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;
|
||||
@ -141,6 +150,12 @@ 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);
|
||||
@ -315,6 +330,29 @@ 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
|
||||
*/
|
||||
|
@ -0,0 +1,175 @@
|
||||
/*
|
||||
* _____ _ _ _____ _
|
||||
* | __ \| | | | / ____| | |
|
||||
* | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
|
||||
* | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
|
||||
* | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
|
||||
* |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
|
||||
* | |
|
||||
* |_|
|
||||
* 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,8 +36,12 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
/**
|
||||
* Queue that is limited to a single chunk
|
||||
* 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
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.8.0")
|
||||
public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
|
||||
public final BiomeType[][][] biomeResult;
|
||||
@ -54,12 +58,12 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
@NonNull BlockVector3 top,
|
||||
boolean biomes
|
||||
) {
|
||||
super(null, Location.at("", 0, 0, 0), Location.at("", 15, 255, 15));
|
||||
super(null, Location.at("", 0, weWorld.getMinY(), 0), Location.at("", 15, weWorld.getMaxY(), 15));
|
||||
this.weWorld = weWorld;
|
||||
this.width = top.getX() - bot.getX() + 1;
|
||||
this.length = top.getZ() - bot.getZ() + 1;
|
||||
this.result = new BlockState[256][width][length];
|
||||
this.biomeResult = biomes ? new BiomeType[256][width][length] : null;
|
||||
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.bot = bot;
|
||||
this.top = top;
|
||||
}
|
||||
@ -71,7 +75,7 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biomeType) {
|
||||
if (this.biomeResult != null) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int y = weWorld.getMinY(); y <= weWorld.getMaxY(); y++) {
|
||||
this.storeCacheBiome(x, y, z, biomeType);
|
||||
}
|
||||
return true;
|
||||
@ -101,9 +105,10 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCache(final int x, final int y, final int z, final @NonNull BlockState id) {
|
||||
BlockState[][] resultY = result[y];
|
||||
int yIndex = getYIndex(y);
|
||||
BlockState[][] resultY = result[yIndex];
|
||||
if (resultY == null) {
|
||||
result[y] = resultY = new BlockState[length][];
|
||||
result[yIndex] = resultY = new BlockState[length][];
|
||||
}
|
||||
BlockState[] resultYZ = resultY[z];
|
||||
if (resultYZ == null) {
|
||||
@ -113,9 +118,10 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
}
|
||||
|
||||
private void storeCacheBiome(final int x, final int y, final int z, final @NonNull BiomeType id) {
|
||||
BiomeType[][] resultY = biomeResult[y];
|
||||
int yIndex = getYIndex(y);
|
||||
BiomeType[][] resultY = biomeResult[yIndex];
|
||||
if (resultY == null) {
|
||||
biomeResult[y] = resultY = new BiomeType[length][];
|
||||
biomeResult[yIndex] = resultY = new BiomeType[length][];
|
||||
}
|
||||
BiomeType[] resultYZ = resultY[z];
|
||||
if (resultYZ == null) {
|
||||
@ -132,7 +138,7 @@ public class ChunkQueueCoordinator extends ScopedQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public @Nullable BlockState getBlock(int x, int y, int z) {
|
||||
BlockState[][] blocksY = result[y];
|
||||
BlockState[][] blocksY = result[getYIndex(y)];
|
||||
if (blocksY != null) {
|
||||
BlockState[] blocksYZ = blocksY[z];
|
||||
if (blocksYZ != null) {
|
||||
@ -157,4 +163,8 @@ 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,6 +32,7 @@ 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;
|
||||
@ -135,6 +136,13 @@ 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) {
|
||||
@ -248,6 +256,21 @@ 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,6 +42,7 @@ 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;
|
||||
@ -52,8 +53,10 @@ public class LocalChunk {
|
||||
this.parent = parent;
|
||||
this.x = x;
|
||||
this.z = z;
|
||||
baseblocks = new BaseBlock[16][];
|
||||
biomes = new BiomeType[16][];
|
||||
this.minSection = parent.getMinLayer();
|
||||
int sections = parent.getMaxLayer() - parent.getMinLayer() + 1;
|
||||
baseblocks = new BaseBlock[sections][];
|
||||
biomes = new BiomeType[sections][];
|
||||
}
|
||||
|
||||
public @NonNull QueueCoordinator getParent() {
|
||||
@ -68,6 +71,15 @@ 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;
|
||||
}
|
||||
@ -81,7 +93,7 @@ public class LocalChunk {
|
||||
}
|
||||
|
||||
public void setBiome(final int x, final int y, final int z, final @NonNull BiomeType biomeType) {
|
||||
final int i = y >> 4;
|
||||
final int i = getLayerIndex(y);
|
||||
final int j = ChunkUtil.getJ(x, y, z);
|
||||
BiomeType[] array = this.biomes[i];
|
||||
if (array == null) {
|
||||
@ -96,7 +108,7 @@ public class LocalChunk {
|
||||
}
|
||||
|
||||
public void setBlock(final int x, final int y, final int z, final @NonNull BaseBlock baseBlock) {
|
||||
final int i = y >> 4;
|
||||
final int i = getLayerIndex(y);
|
||||
final int j = ChunkUtil.getJ(x, y, z);
|
||||
BaseBlock[] array = baseblocks[i];
|
||||
if (array == null) {
|
||||
@ -117,4 +129,8 @@ public class LocalChunk {
|
||||
return this.entities;
|
||||
}
|
||||
|
||||
private int getLayerIndex(final int y) {
|
||||
return (y >> 4) - minSection;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -87,11 +87,14 @@ public class LocationOffsetDelegateQueueCoordinator extends DelegateQueueCoordin
|
||||
|
||||
@Override
|
||||
public boolean setBiome(int x, int z, @NonNull BiomeType biome) {
|
||||
boolean result = true;
|
||||
for (int y = 0; y < 256; y++) {
|
||||
result &= this.setBiome(x, y, z, biome);
|
||||
try {
|
||||
if (canPlace[x - blockX][z - blockZ]) {
|
||||
return super.setBiome(x, z, biome);
|
||||
}
|
||||
} catch (final Exception e) {
|
||||
throw e;
|
||||
}
|
||||
return result;
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -35,6 +35,7 @@ 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;
|
||||
@ -75,12 +76,29 @@ public abstract class QueueCoordinator {
|
||||
* @param x chunk x coordinate
|
||||
* @param z chunk z coordinate
|
||||
* @return a new {@link ScopedQueueCoordinator}
|
||||
* @deprecated Use {@link ScopedQueueCoordinator#getForChunk(int, int, int, int)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public ScopedQueueCoordinator getForChunk(int x, int z) {
|
||||
if (getWorld() == null) {
|
||||
return getForChunk(x, z, PlotSquared.platform().versionMinHeight(), PlotSquared.platform().versionMaxHeight());
|
||||
}
|
||||
return getForChunk(x, z, getWorld().getMinY(), getWorld().getMaxY());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a {@link ScopedQueueCoordinator} limited to the chunk at the specific chunk Coordinates
|
||||
*
|
||||
* @param x chunk x coordinate
|
||||
* @param z chunk z coordinate
|
||||
* @return a new {@link ScopedQueueCoordinator}
|
||||
* @since 6.6.0
|
||||
*/
|
||||
public ScopedQueueCoordinator getForChunk(int x, int z, int minY, int maxY) {
|
||||
int bx = x << 4;
|
||||
int bz = z << 4;
|
||||
return new ScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, 0, bz),
|
||||
Location.at(getWorld().getName(), bx + 15, 255, bz + 255)
|
||||
return new ScopedQueueCoordinator(this, Location.at(getWorld().getName(), bx, minY, bz),
|
||||
Location.at(getWorld().getName(), bx + 15, maxY, bz + 15)
|
||||
);
|
||||
}
|
||||
|
||||
@ -126,7 +144,8 @@ public abstract class QueueCoordinator {
|
||||
}
|
||||
|
||||
/**
|
||||
* Set a chunk object (e.g. the Bukkit Chunk object) to the queue
|
||||
* 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)
|
||||
*
|
||||
* @param chunkObject chunk object. Usually the implementation-specific chunk (e.g. bukkit Chunk)
|
||||
*/
|
||||
@ -230,6 +249,14 @@ 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
|
||||
*
|
||||
@ -395,6 +422,20 @@ 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
|
||||
*
|
||||
@ -404,7 +445,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.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int yMax = 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());
|
||||
@ -427,7 +468,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.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int yMax = 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());
|
||||
@ -450,7 +491,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.min(255, Math.max(pos1.getY(), pos2.getY()));
|
||||
int yMax = 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());
|
||||
@ -464,4 +505,32 @@ 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,34 +35,39 @@ import org.checkerframework.checker.nullness.qual.NonNull;
|
||||
import org.checkerframework.checker.nullness.qual.Nullable;
|
||||
|
||||
/**
|
||||
* Queue that only sets blocks with a designated area
|
||||
* 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.
|
||||
*/
|
||||
@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;
|
||||
}
|
||||
|
||||
@ -73,11 +78,11 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBiome(int x, int y, int z, @NonNull BiomeType biome) {
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBiome(x + minX, y + minY, z + minZ, biome);
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBiome(x + minX, y, z + minZ, biome);
|
||||
}
|
||||
|
||||
public void fillBiome(BiomeType biome) {
|
||||
for (int y = 0; y <= dy; y++) {
|
||||
for (int y = min.getY(); y <= max.getY(); y++) {
|
||||
for (int x = 0; x <= dx; x++) {
|
||||
for (int z = 0; z < dz; z++) {
|
||||
setBiome(x, y, z, biome);
|
||||
@ -88,35 +93,30 @@ public class ScopedQueueCoordinator extends DelegateQueueCoordinator {
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BaseBlock id) {
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(x + minX, y + minY, z + minZ, id);
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull BlockState id) {
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(x + minX, y + minY, z + minZ, id);
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, id);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setBlock(int x, int y, int z, @NonNull Pattern pattern) {
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setBlock(
|
||||
x + minX,
|
||||
y + minY,
|
||||
z + minZ,
|
||||
pattern
|
||||
);
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setBlock(x + minX, y, z + minZ, pattern);
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean setTile(int x, int y, int z, @NonNull CompoundTag tag) {
|
||||
return x >= 0 && x <= dx && y >= 0 && y <= dy && z >= 0 && z <= dz && super.setTile(x + minX, y + minY, z + minZ, tag);
|
||||
return x >= 0 && x <= dx && z >= 0 && z <= dz && super.setTile(x + minX, y, z + minZ, tag);
|
||||
}
|
||||
|
||||
public @NonNull Location getMin() {
|
||||
return Location.at(this.getWorld().getName(), this.minX, this.minY, this.minZ);
|
||||
return min;
|
||||
}
|
||||
|
||||
public @NonNull Location getMax() {
|
||||
return Location.at(this.getWorld().getName(), this.maxX, this.maxY, this.maxZ);
|
||||
return max;
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -31,6 +31,7 @@ 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;
|
||||
@ -47,18 +48,16 @@ public abstract class ChunkManager {
|
||||
String world,
|
||||
BlockVector2 loc
|
||||
) {
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(PlotSquared
|
||||
.platform()
|
||||
.worldUtil()
|
||||
.getWeWorld(world));
|
||||
World weWorld = PlotSquared.platform().worldUtil().getWeWorld(world);
|
||||
QueueCoordinator queue = PlotSquared.platform().globalBlockQueue().getNewQueue(weWorld);
|
||||
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, 0, blockZ),
|
||||
Location.at(world, blockX + 15, 255, blockZ + 15)
|
||||
Location.at(world, blockX, weWorld.getMinY(), blockZ),
|
||||
Location.at(world, blockX + 15, weWorld.getMaxY(), blockZ + 15)
|
||||
);
|
||||
if (force != null) {
|
||||
force.run(scoped);
|
||||
|
@ -39,30 +39,27 @@ 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[16][4096];
|
||||
y_loc = new short[4096];
|
||||
z_loc = new short[4096];
|
||||
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;
|
||||
}
|
||||
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;
|
||||
}
|
||||
CACHE_J = new short[256][16][16];
|
||||
CACHE_J = new short[16][16][16];
|
||||
for (int x = 0; x < 16; x++) {
|
||||
for (int z = 0; z < 16; z++) {
|
||||
for (int y = 0; y < 256; y++) {
|
||||
for (int y = 0; y < 16; y++) {
|
||||
short j = (short) ((y & 0xF) << 8 | z << 4 | x);
|
||||
CACHE_J[y][x][z] = j;
|
||||
}
|
||||
@ -83,7 +80,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][x][z];
|
||||
return CACHE_J[y & 15][x & 15][z & 15];
|
||||
}
|
||||
|
||||
/**
|
||||
@ -97,14 +94,14 @@ public class ChunkUtil {
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the y coordinate for specific I and J values for a Chunk 16x16x16x16 layerxyz Array[16][4096].
|
||||
* Gets the y coordinate for specific I and J values for a Chunk Nx16x16x16 layerxyz Array[N][4096].
|
||||
*
|
||||
* @param i Relative layer of the position in the layerxyz Array[16][4096].
|
||||
* @param i Relative layer of the position in the layerxyz Array[16][4096]. May be negative.
|
||||
* @param j Position in the xyz Array[4096].
|
||||
* @return x coordinate within the chunk
|
||||
*/
|
||||
public static int getY(int i, int j) {
|
||||
return y_loc[i][j];
|
||||
return (i << 4) + y_loc[j];
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -38,11 +38,33 @@ public abstract class InventoryUtil {
|
||||
|
||||
public abstract void close(final PlotInventory inv);
|
||||
|
||||
public abstract void setItem(
|
||||
/**
|
||||
* Attempts to set an item into a {@link PlotInventory} while also checking the existence of the material
|
||||
*
|
||||
* @param plotInventory The inventory where the item should be placed
|
||||
* @param index The index where to place the item
|
||||
* @param item The item to place into the inventory
|
||||
* @return {@code true} if the item could be placed, {@code false} otherwise (e.g. item not available in current version)
|
||||
* @since 6.5.0
|
||||
*/
|
||||
public abstract boolean setItemChecked(
|
||||
final PlotInventory plotInventory, final int index,
|
||||
final PlotItemStack item
|
||||
);
|
||||
|
||||
/**
|
||||
* Attempts to set an item into a {@link PlotInventory}
|
||||
*
|
||||
* @param plotInventory The inventory where the item should be placed
|
||||
* @param index The index where to place the item
|
||||
* @param item The item to place into the inventory
|
||||
* @see #setItemChecked(PlotInventory, int, PlotItemStack)
|
||||
*/
|
||||
public void setItem(final PlotInventory plotInventory, final int index,
|
||||
final PlotItemStack item) {
|
||||
setItemChecked(plotInventory, index, item);
|
||||
}
|
||||
|
||||
public abstract PlotItemStack[] getItems(final PlotPlayer<?> player);
|
||||
|
||||
public abstract boolean isOpen(final PlotInventory plotInventory);
|
||||
|
@ -37,15 +37,21 @@ 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];
|
||||
|
@ -166,7 +166,7 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
|
||||
* @return The player's name, None, Everyone or Unknown
|
||||
* @deprecated Use {@link #resolveName(UUID)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
@Deprecated(forRemoval = true, since = "6.4.0")
|
||||
public static @NonNull String getName(final @Nullable UUID owner) {
|
||||
return getName(owner, true);
|
||||
}
|
||||
@ -179,7 +179,7 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
|
||||
* @return The player's name, None, Everyone or Unknown
|
||||
* @deprecated Use {@link #resolveName(UUID, boolean)}
|
||||
*/
|
||||
@Deprecated(forRemoval = true, since = "TODO")
|
||||
@Deprecated(forRemoval = true, since = "6.4.0")
|
||||
public static @NonNull String getName(final @Nullable UUID owner, final boolean blocking) {
|
||||
if (owner == null) {
|
||||
TranslatableCaption.of("info.none");
|
||||
@ -217,7 +217,7 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
|
||||
* @param owner The UUID of the owner
|
||||
* @return A caption containing either the name, {@code None}, {@code Everyone} or {@code Unknown}
|
||||
* @see #resolveName(UUID, boolean)
|
||||
* @since TODO
|
||||
* @since 6.4.0
|
||||
*/
|
||||
public static @NonNull Caption resolveName(final @Nullable UUID owner) {
|
||||
return resolveName(owner, true);
|
||||
@ -229,7 +229,7 @@ public abstract class PlayerManager<P extends PlotPlayer<? extends T>, T> {
|
||||
* @param owner The UUID of the owner
|
||||
* @param blocking If the operation should block the current thread for {@link Settings.UUID#BLOCKING_TIMEOUT} milliseconds
|
||||
* @return A caption containing either the name, {@code None}, {@code Everyone} or {@code Unknown}
|
||||
* @since TODO
|
||||
* @since 6.4.0
|
||||
*/
|
||||
public static @NonNull Caption resolveName(final @Nullable UUID owner, final boolean blocking) {
|
||||
if (owner == null) {
|
||||
|
@ -29,6 +29,7 @@ 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,7 +279,10 @@ 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(), 0, swapPos.getZ() + pos2.getZ() - pos1.getZ())
|
||||
BlockVector3.at(swapPos.getX() + pos2.getX() - pos1.getX(),
|
||||
pos1.getY(),
|
||||
swapPos.getZ() + pos2.getZ() - pos1.getZ()
|
||||
)
|
||||
).getChunks());
|
||||
QueueCoordinator toQueue1 = blockQueue.getNewQueue(world1);
|
||||
QueueCoordinator toQueue2 = blockQueue.getNewQueue(world2);
|
||||
@ -352,7 +355,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 = 0; y < 256; y++) {
|
||||
for (int y = world1.getMinY(); y <= world1.getMaxY(); y++) {
|
||||
for (int x = bx; x <= tx; x++) {
|
||||
for (int z = bz; z <= tz; z++) {
|
||||
int rx = cbx + x;
|
||||
@ -363,7 +366,10 @@ public abstract class RegionManager {
|
||||
}
|
||||
}
|
||||
}
|
||||
Region region = new CuboidRegion(BlockVector3.at(cbx + bx, 0, cbz + bz), BlockVector3.at(cbx + tx, 255, cbz + tz));
|
||||
Region region = new CuboidRegion(
|
||||
BlockVector3.at(cbx + bx, world1.getMinY(), cbz + bz),
|
||||
BlockVector3.at(cbx + tx, world1.getMaxY(), cbz + tz)
|
||||
);
|
||||
toQueue.addEntities(world1.getEntities(region));
|
||||
if (removeEntities) {
|
||||
for (Entity entity : world1.getEntities(region)) {
|
||||
@ -373,6 +379,7 @@ public abstract class RegionManager {
|
||||
});
|
||||
}
|
||||
|
||||
@Deprecated(forRemoval = true, since = "6.6.0")
|
||||
public void setBiome(
|
||||
final CuboidRegion region,
|
||||
final int extendBiome,
|
||||
@ -380,39 +387,48 @@ public abstract class RegionManager {
|
||||
final String world,
|
||||
final Runnable 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));
|
||||
setBiome(region, extendBiome, biome, PlotSquared.get().getPlotAreaManager().getPlotAreas(world, region)[0], whenDone);
|
||||
}
|
||||
|
||||
final int minX = pos1.getX();
|
||||
final int minZ = pos1.getZ();
|
||||
final int maxX = pos2.getX();
|
||||
final int maxZ = pos2.getZ();
|
||||
/**
|
||||
* 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()));
|
||||
queue.addReadChunks(region.getChunks());
|
||||
queue.setChunkConsumer(blockVector2 -> {
|
||||
final int cx = blockVector2.getX() << 4;
|
||||
final int cz = blockVector2.getZ() << 4;
|
||||
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);
|
||||
WorldUtil.setBiome(
|
||||
world,
|
||||
Math.max(minX, cx),
|
||||
Math.max(minZ, cz),
|
||||
Math.min(maxX, cx + 15),
|
||||
Math.min(maxZ, cz + 15),
|
||||
area.getWorldName(),
|
||||
chunkRegion,
|
||||
biome
|
||||
);
|
||||
worldUtil.refreshChunk(blockVector2.getBlockX(), blockVector2.getBlockZ(), world);
|
||||
worldUtil.refreshChunk(chunkPos.getBlockX(), chunkPos.getBlockZ(), area.getWorldName());
|
||||
});
|
||||
queue.setCompleteTask(whenDone);
|
||||
queue.enqueue();
|
||||
|
@ -76,8 +76,9 @@ 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, Plot.MAX_HEIGHT - 1, pos1z, pos2z);
|
||||
return createRegion(pos1x, pos2x, 0, 255, pos1z, pos2z);
|
||||
}
|
||||
|
||||
public static CuboidRegion createRegion(
|
||||
|
@ -305,12 +305,13 @@ 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
|
||||
> 256);
|
||||
> worldHeight);
|
||||
if (!Settings.Schematics.PASTE_MISMATCHES && sizeMismatch) {
|
||||
actor.sendMessage(TranslatableCaption.of("schematics.schematic_size_mismatch"));
|
||||
TaskManager.runTask(whenDone);
|
||||
@ -321,14 +322,14 @@ public abstract class SchematicHandler {
|
||||
// Calculate the optimal height to paste the schematic at
|
||||
final int y_offset_actual;
|
||||
if (autoHeight) {
|
||||
if (HEIGHT >= 256) {
|
||||
if (HEIGHT >= worldHeight) {
|
||||
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 + 1 + this.worldUtil
|
||||
y_offset_actual = yOffset + pw.getMinBuildHeight() + this.worldUtil
|
||||
.getHighestBlockSynchronous(plot.getWorldName(), region.getMinimumPoint().getX() + 1,
|
||||
region.getMinimumPoint().getZ() + 1
|
||||
);
|
||||
@ -360,9 +361,9 @@ public abstract class SchematicHandler {
|
||||
// Paste schematic here
|
||||
final QueueCoordinator queue = plot.getArea().getQueue();
|
||||
|
||||
for (int ry = 0; ry < Math.min(256, HEIGHT); ry++) {
|
||||
for (int ry = 0; ry < Math.min(worldHeight, HEIGHT); ry++) {
|
||||
int yy = y_offset_actual + ry;
|
||||
if (yy > 255 || yy < 0) {
|
||||
if (yy > plot.getArea().getMaxGenHeight() || yy < plot.getArea().getMinGenHeight()) {
|
||||
continue;
|
||||
}
|
||||
for (int rz = 0; rz < blockArrayClipboard.getDimensions().getZ(); rz++) {
|
||||
@ -379,18 +380,18 @@ public abstract class SchematicHandler {
|
||||
BlockVector3 loc = BlockVector3.at(rx, ry, rz);
|
||||
BaseBlock id = blockArrayClipboard.getFullBlock(loc);
|
||||
queue.setBlock(xx, yy, zz, id);
|
||||
if (ry == 0) {
|
||||
BiomeType biome = blockArrayClipboard.getBiome(loc);
|
||||
queue.setBiome(xx, yy, zz, biome);
|
||||
}
|
||||
BiomeType biome = blockArrayClipboard.getBiome(loc);
|
||||
queue.setBiome(xx, yy, zz, biome);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (actor != null && Settings.QUEUE.NOTIFY_PROGRESS) {
|
||||
queue.addProgressSubscriber(subscriberFactory.createWithActor(actor));
|
||||
}
|
||||
whenDone.value = true;
|
||||
queue.setCompleteTask(whenDone);
|
||||
if (whenDone != null) {
|
||||
whenDone.value = true;
|
||||
queue.setCompleteTask(whenDone);
|
||||
}
|
||||
queue.enqueue();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
|
@ -34,6 +34,7 @@ import java.util.HashMap;
|
||||
public abstract class SetupUtils {
|
||||
|
||||
public static HashMap<String, GeneratorWrapper<?>> generators = new HashMap<>();
|
||||
protected boolean loaded = false;
|
||||
|
||||
/**
|
||||
* @since 6.1.0
|
||||
|
@ -328,7 +328,7 @@ public class StringMan {
|
||||
/**
|
||||
* @param message an input string
|
||||
* @return a list of strings
|
||||
* @since TODO
|
||||
* @since 6.4.0
|
||||
*
|
||||
* <table border="1">
|
||||
* <caption>Converts multiple quoted and single strings into a list of strings</caption>
|
||||
|
@ -44,27 +44,27 @@ public final class TimeUtil {
|
||||
StringBuilder toReturn = new StringBuilder();
|
||||
if (time >= 33868800) {
|
||||
int years = (int) (time / 33868800);
|
||||
time -= years * 33868800;
|
||||
time -= years * 33868800L;
|
||||
toReturn.append(years).append("y ");
|
||||
}
|
||||
if (time >= 604800) {
|
||||
int weeks = (int) (time / 604800);
|
||||
time -= weeks * 604800;
|
||||
time -= weeks * 604800L;
|
||||
toReturn.append(weeks).append("w ");
|
||||
}
|
||||
if (time >= 86400) {
|
||||
int days = (int) (time / 86400);
|
||||
time -= days * 86400;
|
||||
time -= days * 86400L;
|
||||
toReturn.append(days).append("d ");
|
||||
}
|
||||
if (time >= 3600) {
|
||||
int hours = (int) (time / 3600);
|
||||
time -= hours * 3600;
|
||||
time -= hours * 3600L;
|
||||
toReturn.append(hours).append("h ");
|
||||
}
|
||||
if (time >= 60) {
|
||||
int minutes = (int) (time / 60);
|
||||
time -= minutes * 60;
|
||||
time -= minutes * 60L;
|
||||
toReturn.append(minutes).append("m ");
|
||||
}
|
||||
if (toReturn.length() == 0 || time > 0) {
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user