From 8ca0da72f1c044534f3cab5412af490986072a41 Mon Sep 17 00:00:00 2001 From: Justin Su <3387175+injust@users.noreply.github.com> Date: Mon, 22 Jul 2019 07:54:07 -0400 Subject: [PATCH 01/11] Remove duplicate of onblockfade trigger --- spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java | 1 - 1 file changed, 1 deletion(-) diff --git a/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java b/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java index be7e73e1..69393802 100644 --- a/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java +++ b/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java @@ -1194,7 +1194,6 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI { onblockfromto = core.isTrigger("blockfromto"); onblockphysics = core.isTrigger("blockphysics"); onpiston = core.isTrigger("pistonmoved"); - onblockfade = core.isTrigger("blockfaded"); onblockredstone = core.isTrigger("blockredstone"); if(onplace) { From c9ec8c032cd70dce9ca07da9d420b9474b6ebbb4 Mon Sep 17 00:00:00 2001 From: MiniDigger Date: Mon, 4 Nov 2019 17:28:10 +0100 Subject: [PATCH 02/11] Add new repo for bStats --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index a1e9a0e3..92bbd828 100644 --- a/build.gradle +++ b/build.gradle @@ -13,7 +13,7 @@ allprojects { maven { url "http://repo.mikeprimm.com" } maven { url "http://repo.maven.apache.org/maven2" } maven { url "https://hub.spigotmc.org/nexus/content/repositories/snapshots/" } - maven { url "http://repo.bstats.org/content/repositories/releases/" } + maven { url "https://repo.codemc.org/repository/maven-public/" } } apply plugin: 'java' From 95f727d61c5b77ce85b54bed7f1f9b746d296ece Mon Sep 17 00:00:00 2001 From: MiniDigger Date: Mon, 4 Nov 2019 17:29:28 +0100 Subject: [PATCH 03/11] Update bStats to 1.5 --- spigot/build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spigot/build.gradle b/spigot/build.gradle index 121ff590..9f295c27 100644 --- a/spigot/build.gradle +++ b/spigot/build.gradle @@ -11,7 +11,7 @@ dependencies { compile group: 'de.bananaco', name: 'bPermissions', version:'2.9.1' compile group: 'com.platymuus.bukkit.permissions', name: 'PermissionsBukkit', version:'1.6' compile group: 'org.anjocaido', name: 'EssentialsGroupManager', version:'2.10.1' - compile group: 'org.bstats', name: 'bstats-bukkit', version:'1.1' + compile group: 'org.bstats', name: 'bstats-bukkit', version:'1.5' compile group: 'com.googlecode.json-simple', name: 'json-simple', version:'1.1.1' compile group: 'com.google.code.gson', name: 'gson', version:'2.8.2' compile project(':bukkit-helper') From e9518fd048594bb5b26f98ccf89959d4d4569a42 Mon Sep 17 00:00:00 2001 From: Paul Vogel Date: Tue, 5 Nov 2019 13:53:10 +0100 Subject: [PATCH 04/11] Fix typo for "LuckPerms" in plugin.yml softdepend --- spigot/src/main/resources/plugin.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spigot/src/main/resources/plugin.yml b/spigot/src/main/resources/plugin.yml index 2e722eb7..a1ef6a25 100644 --- a/spigot/src/main/resources/plugin.yml +++ b/spigot/src/main/resources/plugin.yml @@ -3,7 +3,7 @@ main: org.dynmap.bukkit.DynmapPlugin version: "${version}-${buildnumber}" authors: [mikeprimm] website: "https://forums.dynmap.us" -softdepend: [ Permissions, PermissionEx, bPermissions, PermissionsBukkit, GroupManager, LuckPerm ] +softdepend: [ Permissions, PermissionEx, bPermissions, PermissionsBukkit, GroupManager, LuckPerms ] commands: dynmap: description: Controls Dynmap. From 4ec3964988de0f65af6604e49a956199ba729e5d Mon Sep 17 00:00:00 2001 From: linuxdaemon Date: Tue, 12 Nov 2019 00:57:51 -0600 Subject: [PATCH 05/11] Fix MariaDB Driver package name The package name for the MariaDB JDBC drivers available from https://mariadb.com/kb/en/library/mariadb-connector-j/ is `org.mariadb` not `com.mariadb`. Fixes #2653 --- .../main/java/org/dynmap/storage/mariadb/MariaDBMapStorage.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/DynmapCore/src/main/java/org/dynmap/storage/mariadb/MariaDBMapStorage.java b/DynmapCore/src/main/java/org/dynmap/storage/mariadb/MariaDBMapStorage.java index 78618bb4..2bfa8049 100644 --- a/DynmapCore/src/main/java/org/dynmap/storage/mariadb/MariaDBMapStorage.java +++ b/DynmapCore/src/main/java/org/dynmap/storage/mariadb/MariaDBMapStorage.java @@ -289,7 +289,7 @@ public class MariaDBMapStorage extends MapStorage { connectionString = "jdbc:mariadb://" + hostname + ":" + port + "/" + database + "?allowReconnect=true"; Log.info("Opening MariaDB database " + hostname + ":" + port + "/" + database + " as map store"); try { - Class.forName("com.mariadb.jdbc.Driver"); + Class.forName("org.mariadb.jdbc.Driver"); // Initialize/update tables, if needed if(!initializeTables()) { return false; From 016441fdab60f651f30e84c4d519d3ce299b99b0 Mon Sep 17 00:00:00 2001 From: Arvind Kumar Date: Tue, 12 Nov 2019 23:51:10 +0530 Subject: [PATCH 06/11] Fixed typo in config file comment --- forge-1.10.2/src/main/resources/configuration.txt | 2 +- forge-1.11.2/src/main/resources/configuration.txt | 2 +- forge-1.12.2/src/main/resources/configuration.txt | 2 +- forge-1.13.2/src/main/resources/configuration.txt | 2 +- forge-1.8.9/src/main/resources/configuration.txt | 2 +- forge-1.9.4/src/main/resources/configuration.txt | 2 +- spigot/src/main/resources/configuration.txt | 2 +- 7 files changed, 7 insertions(+), 7 deletions(-) diff --git a/forge-1.10.2/src/main/resources/configuration.txt b/forge-1.10.2/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.10.2/src/main/resources/configuration.txt +++ b/forge-1.10.2/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/forge-1.11.2/src/main/resources/configuration.txt b/forge-1.11.2/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.11.2/src/main/resources/configuration.txt +++ b/forge-1.11.2/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/forge-1.12.2/src/main/resources/configuration.txt b/forge-1.12.2/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.12.2/src/main/resources/configuration.txt +++ b/forge-1.12.2/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/forge-1.13.2/src/main/resources/configuration.txt b/forge-1.13.2/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.13.2/src/main/resources/configuration.txt +++ b/forge-1.13.2/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/forge-1.8.9/src/main/resources/configuration.txt b/forge-1.8.9/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.8.9/src/main/resources/configuration.txt +++ b/forge-1.8.9/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/forge-1.9.4/src/main/resources/configuration.txt b/forge-1.9.4/src/main/resources/configuration.txt index 45ee61fe..d67e9baa 100644 --- a/forge-1.9.4/src/main/resources/configuration.txt +++ b/forge-1.9.4/src/main/resources/configuration.txt @@ -140,7 +140,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false diff --git a/spigot/src/main/resources/configuration.txt b/spigot/src/main/resources/configuration.txt index 9e398f45..10aee57e 100644 --- a/spigot/src/main/resources/configuration.txt +++ b/spigot/src/main/resources/configuration.txt @@ -141,7 +141,7 @@ components: messagettl: 5 # Optional: set number of lines in scrollable message history: if set, messagettl is not used to age out messages #scrollback: 100 - # Optiona; set maximum number of lines visible for chatbox + # Optional: set maximum number of lines visible for chatbox #visiblelines: 10 # Optional: send push button sendbutton: false From 59578e68243316f867b42aa3c0e62ce5c291ca44 Mon Sep 17 00:00:00 2001 From: Lennart Becker Date: Fri, 29 Nov 2019 12:33:03 +0100 Subject: [PATCH 07/11] Standalone: Load changes immediately after page load --- DynmapCore/src/main/resources/extracted/web/js/map.js | 1 + 1 file changed, 1 insertion(+) diff --git a/DynmapCore/src/main/resources/extracted/web/js/map.js b/DynmapCore/src/main/resources/extracted/web/js/map.js index 9922d02d..9d8ca201 100644 --- a/DynmapCore/src/main/resources/extracted/web/js/map.js +++ b/DynmapCore/src/main/resources/extracted/web/js/map.js @@ -375,6 +375,7 @@ DynMap.prototype = { componentstoload--; if (componentstoload == 0) { // Actually start updating once all components are loaded. + me.update(); setTimeout(function() { me.update(); }, me.options.updaterate); } }); From 9e7174dcdea52746503c0f2c907359975c6e9feb Mon Sep 17 00:00:00 2001 From: Sijmen Schoon Date: Sun, 1 Dec 2019 03:38:05 +0100 Subject: [PATCH 08/11] Update LuckPerms and bStats --- build.gradle | 2 +- spigot/build.gradle | 4 +- .../java/org/dynmap/bukkit/DynmapPlugin.java | 54 +++++++++---------- .../permissions/LuckPermsPermissions.java | 44 ++++++++------- 4 files changed, 54 insertions(+), 50 deletions(-) diff --git a/build.gradle b/build.gradle index a1e9a0e3..92bbd828 100644 --- a/build.gradle +++ b/build.gradle @@ -13,7 +13,7 @@ allprojects { maven { url "http://repo.mikeprimm.com" } maven { url "http://repo.maven.apache.org/maven2" } maven { url "https://hub.spigotmc.org/nexus/content/repositories/snapshots/" } - maven { url "http://repo.bstats.org/content/repositories/releases/" } + maven { url "https://repo.codemc.org/repository/maven-public/" } } apply plugin: 'java' diff --git a/spigot/build.gradle b/spigot/build.gradle index 121ff590..bc4b7994 100644 --- a/spigot/build.gradle +++ b/spigot/build.gradle @@ -4,14 +4,14 @@ description = 'dynmap' dependencies { compile group: 'org.bukkit', name: 'bukkit', version:'1.7.10-R0.1-SNAPSHOT' compile 'com.nijikokun.bukkit:Permissions:3.1.6' - compile 'me.lucko.luckperms:luckperms-api:4.3' + compile 'net.luckperms:api:5.0' compile project(":dynmap-api") compile project(path: ":DynmapCore", configuration: "shadow") compile group: 'ru.tehkode', name: 'PermissionsEx', version:'1.19.1' compile group: 'de.bananaco', name: 'bPermissions', version:'2.9.1' compile group: 'com.platymuus.bukkit.permissions', name: 'PermissionsBukkit', version:'1.6' compile group: 'org.anjocaido', name: 'EssentialsGroupManager', version:'2.10.1' - compile group: 'org.bstats', name: 'bstats-bukkit', version:'1.1' + compile group: 'org.bstats', name: 'bstats-bukkit', version:'1.5' compile group: 'com.googlecode.json-simple', name: 'json-simple', version:'1.1.1' compile group: 'com.google.code.gson', name: 'gson', version:'2.8.2' compile project(':bukkit-helper') diff --git a/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java b/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java index be7e73e1..d36e6484 100644 --- a/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java +++ b/spigot/src/main/java/org/dynmap/bukkit/DynmapPlugin.java @@ -16,7 +16,7 @@ import java.util.concurrent.CancellationException; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import org.bstats.Metrics; +import org.bstats.bukkit.Metrics; import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.Chunk; @@ -1585,35 +1585,31 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI { private void initMetrics() { metrics = new Metrics(this); - metrics.addCustomChart(new Metrics.MultiLineChart("features_used") { - @Override - public HashMap getValues(HashMap hashMap) { - hashMap.put("internal_web_server", core.configuration.getBoolean("disable-webserver", false) ? 0 : 1); - hashMap.put("login_security", core.configuration.getBoolean("login-enabled", false) ? 1 : 0); - hashMap.put("player_info_protected", core.player_info_protected ? 1 : 0); - for (String mod : modsused) - hashMap.put(mod + "_blocks", 1); - return hashMap; - } - }); + metrics.addCustomChart(new Metrics.MultiLineChart("features_used", () -> { + Map hashMap = new HashMap<>(); + hashMap.put("internal_web_server", core.configuration.getBoolean("disable-webserver", false) ? 0 : 1); + hashMap.put("login_security", core.configuration.getBoolean("login-enabled", false) ? 1 : 0); + hashMap.put("player_info_protected", core.player_info_protected ? 1 : 0); + for (String mod : modsused) + hashMap.put(mod + "_blocks", 1); + return hashMap; + })); - metrics.addCustomChart(new Metrics.MultiLineChart("map_data") { - @Override - public HashMap getValues(HashMap hashMap) { - hashMap.put("worlds", core.mapManager != null ? core.mapManager.getWorlds().size() : 0); - int maps = 0, hdmaps = 0; - if (core.mapManager != null) - for (DynmapWorld w : core.mapManager.getWorlds()) { - for (MapType mt : w.maps) - if (mt instanceof HDMap) - ++hdmaps; - maps += w.maps.size(); - } - hashMap.put("maps", maps); - hashMap.put("hd_maps", hdmaps); - return hashMap; - } - }); + metrics.addCustomChart(new Metrics.MultiLineChart("map_data", () -> { + Map hashMap = new HashMap<>(); + hashMap.put("worlds", core.mapManager != null ? core.mapManager.getWorlds().size() : 0); + int maps = 0, hdmaps = 0; + if (core.mapManager != null) + for (DynmapWorld w : core.mapManager.getWorlds()) { + for (MapType mt : w.maps) + if (mt instanceof HDMap) + ++hdmaps; + maps += w.maps.size(); + } + hashMap.put("maps", maps); + hashMap.put("hd_maps", hdmaps); + return hashMap; + })); } @Override public void processSignChange(int blkid, String world, int x, int y, int z, diff --git a/spigot/src/main/java/org/dynmap/bukkit/permissions/LuckPermsPermissions.java b/spigot/src/main/java/org/dynmap/bukkit/permissions/LuckPermsPermissions.java index 7ab582b2..f0848a7e 100644 --- a/spigot/src/main/java/org/dynmap/bukkit/permissions/LuckPermsPermissions.java +++ b/spigot/src/main/java/org/dynmap/bukkit/permissions/LuckPermsPermissions.java @@ -6,9 +6,12 @@ import java.util.UUID; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import me.lucko.luckperms.api.LuckPermsApi; -import me.lucko.luckperms.api.User; -import me.lucko.luckperms.api.caching.PermissionData; +import net.luckperms.api.LuckPerms; +import net.luckperms.api.model.user.User; +import net.luckperms.api.model.user.UserManager; +import net.luckperms.api.cacheddata.CachedPermissionData; +import net.luckperms.api.cacheddata.CachedDataManager; +import net.luckperms.api.query.QueryOptions; import org.bukkit.Bukkit; import org.bukkit.OfflinePlayer; @@ -18,19 +21,19 @@ import org.dynmap.Log; public class LuckPermsPermissions implements PermissionProvider { String name; - LuckPermsApi luckPerms; + LuckPerms luckPerms; public static LuckPermsPermissions create(Server server, String name) { if (!server.getPluginManager().isPluginEnabled("LuckPerms")) return null; - LuckPermsApi luckPerms = server.getServicesManager().load(LuckPermsApi.class); + LuckPerms luckPerms = server.getServicesManager().load(LuckPerms.class); if (luckPerms == null) return null; - Log.info("Using LuckPerms " + luckPerms.getPlatformInfo().getVersion() + " for access control"); + Log.info("Using LuckPerms " + luckPerms.getPluginMetadata().getVersion() + " for access control"); return new LuckPermsPermissions(name, luckPerms); } - public LuckPermsPermissions(String name, LuckPermsApi luckPerms) { + public LuckPermsPermissions(String name, LuckPerms luckPerms) { this.name = name; this.luckPerms = luckPerms; } @@ -43,10 +46,10 @@ public class LuckPermsPermissions implements PermissionProvider { @Override public Set hasOfflinePermissions(String player, Set perms) { Set result = new HashSet<>(); - PermissionData user = getUser(player); + CachedPermissionData user = getUser(player); if (user != null) { for (String p : perms) { - if (user.getPermissionValue(name + "." + p).asBoolean()) + if (user.checkPermission(name + "." + p).asBoolean()) result.add(p); } } @@ -55,34 +58,39 @@ public class LuckPermsPermissions implements PermissionProvider { @Override public boolean hasOfflinePermission(String player, String perm) { - PermissionData user = getUser(player); + CachedPermissionData user = getUser(player); if (user == null) return false; - return user.getPermissionValue(name + "." + perm).asBoolean(); + return user.checkPermission(name + "." + perm).asBoolean(); } - private PermissionData getUser(String username) { + private CachedPermissionData getUser(String username) { OfflinePlayer offlinePlayer = Bukkit.getOfflinePlayer(username); UUID uuid; if (offlinePlayer != null && offlinePlayer.getUniqueId() != null) uuid = offlinePlayer.getUniqueId(); else - uuid = joinFuture(luckPerms.getStorage().getUUID(username)); + uuid = joinFuture(luckPerms.getUserManager().lookupUniqueId(username)); if (uuid == null) return null; - User user = luckPerms.getUser(uuid); + User user = luckPerms.getUserManager().getUser(uuid); if (user == null) { - joinFuture(luckPerms.getStorage().loadUser(uuid)); - user = luckPerms.getUser(uuid); + joinFuture(luckPerms.getUserManager().loadUser(uuid)); + user = luckPerms.getUserManager().getUser(uuid); } if (user == null) return null; - return user.getCachedData().getPermissionData(luckPerms.getContextManager().getStaticContexts()); + CachedDataManager data = user.getCachedData(); + return luckPerms + .getContextManager() + .getQueryOptions(user) + .map(queryOptions -> data.getPermissionData(queryOptions)) + .orElse(null); } private static T joinFuture(Future future) { @@ -92,4 +100,4 @@ public class LuckPermsPermissions implements PermissionProvider { throw new RuntimeException(e); } } -} \ No newline at end of file +} From dd78b11144753f869c1a3dabed373c6364a783df Mon Sep 17 00:00:00 2001 From: Sijmen Schoon Date: Mon, 2 Dec 2019 19:35:18 +0100 Subject: [PATCH 09/11] Bump to beta-7 --- build.gradle | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.gradle b/build.gradle index 92bbd828..ef54d8f5 100644 --- a/build.gradle +++ b/build.gradle @@ -19,7 +19,7 @@ allprojects { apply plugin: 'java' group = 'us.dynmap' - version = '3.0-beta-6' + version = '3.0-beta-7' } From ebd883b1c2b9b6f39800bbd781d734fe1ecfe1b3 Mon Sep 17 00:00:00 2001 From: BuildTools Date: Thu, 12 Dec 2019 21:15:11 +0100 Subject: [PATCH 10/11] Added support for 1.15 --- bukkit-helper-115/.gitignore | 1 + bukkit-helper-115/bin/.gitignore | 1 + .../bin/BukkitVersionHelperSpigot115.java | 193 ++++++++ bukkit-helper-115/build.gradle | 10 + .../v115/BukkitVersionHelperSpigot115.java | 205 ++++++++ .../bukkit/helper/v115/MapChunkCache115.java | 458 ++++++++++++++++++ settings.gradle | 2 + spigot/build.gradle | 4 + .../main/java/org/dynmap/bukkit/Helper.java | 4 + 9 files changed, 878 insertions(+) create mode 100644 bukkit-helper-115/.gitignore create mode 100644 bukkit-helper-115/bin/.gitignore create mode 100644 bukkit-helper-115/bin/BukkitVersionHelperSpigot115.java create mode 100644 bukkit-helper-115/build.gradle create mode 100644 bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/BukkitVersionHelperSpigot115.java create mode 100644 bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/MapChunkCache115.java diff --git a/bukkit-helper-115/.gitignore b/bukkit-helper-115/.gitignore new file mode 100644 index 00000000..84c048a7 --- /dev/null +++ b/bukkit-helper-115/.gitignore @@ -0,0 +1 @@ +/build/ diff --git a/bukkit-helper-115/bin/.gitignore b/bukkit-helper-115/bin/.gitignore new file mode 100644 index 00000000..ddf9c656 --- /dev/null +++ b/bukkit-helper-115/bin/.gitignore @@ -0,0 +1 @@ +/main/ diff --git a/bukkit-helper-115/bin/BukkitVersionHelperSpigot115.java b/bukkit-helper-115/bin/BukkitVersionHelperSpigot115.java new file mode 100644 index 00000000..59722674 --- /dev/null +++ b/bukkit-helper-115/bin/BukkitVersionHelperSpigot115.java @@ -0,0 +1,193 @@ +package org.dynmap.bukkit.helper.v115; + +import java.lang.reflect.Field; + +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.List; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.WorldBorder; +import org.dynmap.DynmapChunk; +import org.dynmap.Log; +import org.dynmap.bukkit.helper.BukkitVersionHelperCB; +import org.dynmap.bukkit.helper.BukkitWorld; +import org.dynmap.bukkit.helper.v115.MapChunkCache115; +import org.dynmap.renderer.DynmapBlockState; +import org.dynmap.utils.MapChunkCache; +import org.dynmap.utils.Polygon; + +import net.minecraft.server.v1_15_R1.BiomeBase; +import net.minecraft.server.v1_15_R1.Block; +import net.minecraft.server.v1_15_R1.BlockFluids; +import net.minecraft.server.v1_15_R1.BlockLogAbstract; +import net.minecraft.server.v1_15_R1.IBlockData; +import net.minecraft.server.v1_15_R1.IRegistry; +import net.minecraft.server.v1_15_R1.Material; + +/** + * Helper for isolation of bukkit version specific issues + */ +public class BukkitVersionHelperSpigot115 extends BukkitVersionHelperCB { + + /** CraftChunkSnapshot */ + protected Class datapalettearray; + private Field blockid_field; + + @Override + protected boolean isBlockIdNeeded() { + return false; + } + + @Override + protected boolean isBiomeBaseListNeeded() { + return false; + } + + public BukkitVersionHelperSpigot115() { + datapalettearray = getNMSClass("[Lnet.minecraft.server.DataPaletteBlock;"); + blockid_field = getPrivateField(craftchunksnapshot, new String[] { "blockids" }, datapalettearray); + } + + @Override + public Object[] getBlockIDFieldFromSnapshot(ChunkSnapshot css) { + try { + return (Object[]) blockid_field.get(css); + } catch (IllegalArgumentException e) { + } catch (IllegalAccessException e) { + } + return null; + } + @Override + public void unloadChunkNoSave(World w, Chunk c, int cx, int cz) { + w.unloadChunk(cx, cz, false); + } + + /** + * Get block short name list + */ + @Override + public String[] getBlockNames() { + int cnt = Block.REGISTRY_ID.a(); + String[] names = new String[cnt]; + for (int i = 0; i < cnt; i++) { + IBlockData bd = Block.getByCombinedId(i); + names[i] = IRegistry.BLOCK.getKey(bd.getBlock()).toString(); + Log.info(i + ": blk=" + names[i] + ", bd=" + bd.toString()); + } + return names; + } + + /** + * Get list of defined biomebase objects + */ + @Override + public Object[] getBiomeBaseList() { + if (biomelist == null) { + biomelist = new Object[1024]; + for (int i = 0; i < 1024; i++) { + biomelist[i] = IRegistry.BIOME.fromId(i); + } + } + return biomelist; + } + + /** Get ID from biomebase */ + @Override + public int getBiomeBaseID(Object bb) { + return IRegistry.BIOME.a((BiomeBase)bb); + } + + public static IdentityHashMap dataToState; + + /** + * Initialize block states (org.dynmap.blockstate.DynmapBlockState) + */ + @Override + public void initializeBlockStates() { + dataToState = new IdentityHashMap(); + HashMap lastBlockState = new HashMap(); + + int cnt = Block.REGISTRY_ID.a(); + // Loop through block data states + for (int i = 0; i < cnt; i++) { + IBlockData bd = Block.getByCombinedId(i); + String bname = IRegistry.BLOCK.getKey(bd.getBlock()).toString(); + DynmapBlockState lastbs = lastBlockState.get(bname); // See if we have seen this one + int idx = 0; + if (lastbs != null) { // Yes + idx = lastbs.getStateCount(); // Get number of states so far, since this is next + } + // Build state name + String sb = ""; + String fname = bd.toString(); + int off1 = fname.indexOf('['); + if (off1 >= 0) { + int off2 = fname.indexOf(']'); + sb = fname.substring(off1+1, off2); + } + Material mat = bd.getMaterial(); + DynmapBlockState bs = new DynmapBlockState(lastbs, idx, bname, sb, mat.toString()); + if ((!bd.getFluid().isEmpty()) && ((bd.getBlock() instanceof BlockFluids) == false)) { // Test if fluid type for block is not empty + bs.setWaterlogged(); + } + if (mat == Material.AIR) { + bs.setAir(); + } + if (mat == Material.LEAVES) { + bs.setLeaves(); + } + if (bd.getBlock() instanceof BlockLogAbstract) { + bs.setLog(); + } + if (mat.isSolid()) { + bs.setSolid(); + } + dataToState.put(bd, bs); + lastBlockState.put(bname, (lastbs == null) ? bs : lastbs); + Log.verboseinfo(i + ": blk=" + bname + ", idx=" + idx + ", state=" + sb + ", waterlogged=" + bs.isWaterlogged()); + } + } + /** + * Create chunk cache for given chunks of given world + * @param dw - world + * @param chunks - chunk list + * @return cache + */ + @Override + public MapChunkCache getChunkCache(BukkitWorld dw, List chunks) { + MapChunkCache115 c = new MapChunkCache115(); + c.setChunks(dw, chunks); + return c; + } + + /** + * Get biome base water multiplier + */ + @Override + public int getBiomeBaseWaterMult(Object bb) { + return ((BiomeBase)bb).p(); + } + + @Override + public Polygon getWorldBorder(World world) { + Polygon p = null; + WorldBorder wb = world.getWorldBorder(); + if (wb != null) { + Location c = wb.getCenter(); + double size = wb.getSize(); + if ((size > 1) && (size < 1E7)) { + size = size / 2; + p = new Polygon(); + p.addVertex(c.getX()-size, c.getZ()-size); + p.addVertex(c.getX()+size, c.getZ()-size); + p.addVertex(c.getX()+size, c.getZ()+size); + p.addVertex(c.getX()-size, c.getZ()+size); + } + } + return p; + } + +} diff --git a/bukkit-helper-115/build.gradle b/bukkit-helper-115/build.gradle new file mode 100644 index 00000000..598021f9 --- /dev/null +++ b/bukkit-helper-115/build.gradle @@ -0,0 +1,10 @@ + +description = 'bukkit-helper-1.15' + +dependencies { + compile project(':bukkit-helper') + compile project(':dynmap-api') + compile project(path: ':DynmapCore', configuration: 'shadow') + compile group: 'org.bukkit', name: 'bukkit', version:'1.15-R0.1-SNAPSHOT' + compile group: 'org.bukkit', name: 'craftbukkit', version:'1.15-R0.1-SNAPSHOT' +} diff --git a/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/BukkitVersionHelperSpigot115.java b/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/BukkitVersionHelperSpigot115.java new file mode 100644 index 00000000..b8772c3c --- /dev/null +++ b/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/BukkitVersionHelperSpigot115.java @@ -0,0 +1,205 @@ +package org.dynmap.bukkit.helper.v115; + +import java.lang.reflect.Field; + +import java.util.HashMap; +import java.util.IdentityHashMap; +import java.util.List; +import org.bukkit.Chunk; +import org.bukkit.ChunkSnapshot; +import org.bukkit.Location; +import org.bukkit.World; +import org.bukkit.WorldBorder; +import org.dynmap.DynmapChunk; +import org.dynmap.Log; +import org.dynmap.bukkit.helper.BukkitVersionHelperCB; +import org.dynmap.bukkit.helper.BukkitWorld; +import org.dynmap.bukkit.helper.v115.MapChunkCache115; +import org.dynmap.renderer.DynmapBlockState; +import org.dynmap.utils.MapChunkCache; +import org.dynmap.utils.Polygon; + +import net.minecraft.server.v1_15_R1.BiomeBase; +import net.minecraft.server.v1_15_R1.Block; +import net.minecraft.server.v1_15_R1.BlockFluids; +import net.minecraft.server.v1_15_R1.BlockLogAbstract; +import net.minecraft.server.v1_15_R1.IBlockData; +import net.minecraft.server.v1_15_R1.IRegistry; +import net.minecraft.server.v1_15_R1.Material; + +/** + * Helper for isolation of bukkit version specific issues + */ +public class BukkitVersionHelperSpigot115 extends BukkitVersionHelperCB { + + /** CraftChunkSnapshot */ + protected Class datapalettearray; + private Field blockid_field; + + @Override + protected boolean isBlockIdNeeded() { + return false; + } + + @Override + protected boolean isBiomeBaseListNeeded() { + return false; + } + + public BukkitVersionHelperSpigot115() { + datapalettearray = getNMSClass("[Lnet.minecraft.server.DataPaletteBlock;"); + blockid_field = getPrivateField(craftchunksnapshot, new String[] { "blockids" }, datapalettearray); + } + + @Override + public Object[] getBlockIDFieldFromSnapshot(ChunkSnapshot css) { + try { + return (Object[]) blockid_field.get(css); + } catch (IllegalArgumentException e) { + } catch (IllegalAccessException e) { + } + return null; + } + @Override + public void unloadChunkNoSave(World w, Chunk c, int cx, int cz) { + w.unloadChunk(cx, cz, false); + } + + /** + * Get block short name list + */ + @Override + public String[] getBlockNames() { + int cnt = Block.REGISTRY_ID.a(); + String[] names = new String[cnt]; + for (int i = 0; i < cnt; i++) { + IBlockData bd = Block.getByCombinedId(i); + names[i] = IRegistry.BLOCK.getKey(bd.getBlock()).toString(); + Log.info(i + ": blk=" + names[i] + ", bd=" + bd.toString()); + } + return names; + } + + /** + * Get list of defined biomebase objects + */ + @Override + public Object[] getBiomeBaseList() { + if (biomelist == null) { + biomelist = new Object[1024]; + for (int i = 0; i < 1024; i++) { + biomelist[i] = IRegistry.BIOME.fromId(i); + } + } + return biomelist; + } + + /** Get ID from biomebase */ + @Override + public int getBiomeBaseID(Object bb) { + return IRegistry.BIOME.a((BiomeBase)bb); + } + + public static IdentityHashMap dataToState; + + /** + * Initialize block states (org.dynmap.blockstate.DynmapBlockState) + */ + @Override + public void initializeBlockStates() { + dataToState = new IdentityHashMap(); + HashMap lastBlockState = new HashMap(); + + int cnt = Block.REGISTRY_ID.a(); + // Loop through block data states + for (int i = 0; i < cnt; i++) { + IBlockData bd = Block.getByCombinedId(i); + String bname = IRegistry.BLOCK.getKey(bd.getBlock()).toString(); + DynmapBlockState lastbs = lastBlockState.get(bname); // See if we have seen this one + int idx = 0; + if (lastbs != null) { // Yes + idx = lastbs.getStateCount(); // Get number of states so far, since this is next + } + // Build state name + String sb = ""; + String fname = bd.toString(); + int off1 = fname.indexOf('['); + if (off1 >= 0) { + int off2 = fname.indexOf(']'); + sb = fname.substring(off1+1, off2); + } + Material mat = bd.getMaterial(); + DynmapBlockState bs = new DynmapBlockState(lastbs, idx, bname, sb, mat.toString()); + if ((!bd.getFluid().isEmpty()) && ((bd.getBlock() instanceof BlockFluids) == false)) { // Test if fluid type for block is not empty + bs.setWaterlogged(); + } + if (mat == Material.AIR) { + bs.setAir(); + } + if (mat == Material.LEAVES) { + bs.setLeaves(); + } + if (bd.getBlock() instanceof BlockLogAbstract) { + bs.setLog(); + } + if (mat.isSolid()) { + bs.setSolid(); + } + dataToState.put(bd, bs); + lastBlockState.put(bname, (lastbs == null) ? bs : lastbs); + Log.verboseinfo(i + ": blk=" + bname + ", idx=" + idx + ", state=" + sb + ", waterlogged=" + bs.isWaterlogged()); + } + } + /** + * Create chunk cache for given chunks of given world + * @param dw - world + * @param chunks - chunk list + * @return cache + */ + @Override + public MapChunkCache getChunkCache(BukkitWorld dw, List chunks) { + MapChunkCache115 c = new MapChunkCache115(); + c.setChunks(dw, chunks); + return c; + } + + /** + * Get biome base water multiplier + */ + @Override + public int getBiomeBaseWaterMult(Object bb) { + return ((BiomeBase)bb).p(); + } + + /** Get temperature from biomebase */ + @Override + public float getBiomeBaseTemperature(Object bb) { + return ((BiomeBase)bb).getTemperature(); + } + + /** Get humidity from biomebase */ + @Override + public float getBiomeBaseHumidity(Object bb) { + return ((BiomeBase)bb).getHumidity(); + } + + @Override + public Polygon getWorldBorder(World world) { + Polygon p = null; + WorldBorder wb = world.getWorldBorder(); + if (wb != null) { + Location c = wb.getCenter(); + double size = wb.getSize(); + if ((size > 1) && (size < 1E7)) { + size = size / 2; + p = new Polygon(); + p.addVertex(c.getX()-size, c.getZ()-size); + p.addVertex(c.getX()+size, c.getZ()-size); + p.addVertex(c.getX()+size, c.getZ()+size); + p.addVertex(c.getX()-size, c.getZ()+size); + } + } + return p; + } + +} diff --git a/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/MapChunkCache115.java b/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/MapChunkCache115.java new file mode 100644 index 00000000..0ae32101 --- /dev/null +++ b/bukkit-helper-115/src/main/java/org/dynmap/bukkit/helper/v115/MapChunkCache115.java @@ -0,0 +1,458 @@ +package org.dynmap.bukkit.helper.v115; + +import org.bukkit.Bukkit; +import org.bukkit.block.Biome; +import org.bukkit.craftbukkit.libs.jline.internal.Log; +import org.bukkit.craftbukkit.v1_15_R1.CraftWorld; + +import java.io.IOException; +import java.util.Arrays; + +import org.bukkit.ChunkSnapshot; +import org.bukkit.World; +import org.dynmap.DynmapChunk; +import org.dynmap.DynmapCore; +import org.dynmap.bukkit.helper.AbstractMapChunkCache; +import org.dynmap.bukkit.helper.BukkitVersionHelper; +import org.dynmap.bukkit.helper.SnapshotCache; +import org.dynmap.bukkit.helper.SnapshotCache.SnapshotRec; +import org.dynmap.renderer.DynmapBlockState; +import org.dynmap.utils.DynIntHashMap; +import org.dynmap.utils.VisibilityLimit; + +import net.minecraft.server.v1_15_R1.Chunk; +import net.minecraft.server.v1_15_R1.ChunkCoordIntPair; +import net.minecraft.server.v1_15_R1.ChunkRegionLoader; +import net.minecraft.server.v1_15_R1.DataBits; +import net.minecraft.server.v1_15_R1.NBTTagCompound; +import net.minecraft.server.v1_15_R1.NBTTagList; + +/** + * Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread + */ +public class MapChunkCache115 extends AbstractMapChunkCache { + + public static class NBTSnapshot implements Snapshot { + private static interface Section { + public DynmapBlockState getBlockType(int x, int y, int z); + public int getBlockSkyLight(int x, int y, int z); + public int getBlockEmittedLight(int x, int y, int z); + public boolean isEmpty(); + } + private final int x, z; + private final Section[] section; + private final int[] hmap; // Height map + private final int[] biome; + private final Object[] biomebase; + private final long captureFulltime; + private final int sectionCnt; + private final long inhabitedTicks; + + private static final int BLOCKS_PER_SECTION = 16 * 16 * 16; + private static final int COLUMNS_PER_CHUNK = 16 * 16 * 4; + private static final byte[] emptyData = new byte[BLOCKS_PER_SECTION / 2]; + private static final byte[] fullData = new byte[BLOCKS_PER_SECTION / 2]; + + static + { + Arrays.fill(fullData, (byte)0xFF); + } + + private static class EmptySection implements Section { + @Override + public DynmapBlockState getBlockType(int x, int y, int z) { + return DynmapBlockState.AIR; + } + @Override + public int getBlockSkyLight(int x, int y, int z) { + return 15; + } + @Override + public int getBlockEmittedLight(int x, int y, int z) { + return 0; + } + @Override + public boolean isEmpty() { + return true; + } + } + + private static final EmptySection empty_section = new EmptySection(); + + private static class StdSection implements Section { + DynmapBlockState[] states; + byte[] skylight; + byte[] emitlight; + + public StdSection() { + states = new DynmapBlockState[BLOCKS_PER_SECTION]; + Arrays.fill(states, DynmapBlockState.AIR); + skylight = emptyData; + emitlight = emptyData; + } + @Override + public DynmapBlockState getBlockType(int x, int y, int z) { + return states[((y & 0xF) << 8) | (z << 4) | x]; + } + @Override + public int getBlockSkyLight(int x, int y, int z) { + int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1); + return (skylight[off] >> (4 * (x & 1))) & 0xF; + } + @Override + public int getBlockEmittedLight(int x, int y, int z) + { + int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1); + return (emitlight[off] >> (4 * (x & 1))) & 0xF; + } + @Override + public boolean isEmpty() { + return false; + } + } + /** + * Construct empty chunk snapshot + * + * @param x + * @param z + */ + public NBTSnapshot(int worldheight, int x, int z, long captime, long inhabitedTime) + { + this.x = x; + this.z = z; + this.captureFulltime = captime; + this.biome = new int[COLUMNS_PER_CHUNK]; + this.biomebase = new Object[COLUMNS_PER_CHUNK]; + this.sectionCnt = worldheight / 16; + /* Allocate arrays indexed by section */ + this.section = new Section[this.sectionCnt]; + + /* Fill with empty data */ + for (int i = 0; i < this.sectionCnt; i++) { + this.section[i] = empty_section; + } + + /* Create empty height map */ + this.hmap = new int[16 * 16]; + + this.inhabitedTicks = inhabitedTime; + } + + public NBTSnapshot(NBTTagCompound nbt, int worldheight) { + this.x = nbt.getInt("xPos"); + this.z = nbt.getInt("zPos"); + this.captureFulltime = 0; + this.hmap = nbt.getIntArray("HeightMap"); + this.sectionCnt = worldheight / 16; + if (nbt.hasKey("InhabitedTime")) { + this.inhabitedTicks = nbt.getLong("InhabitedTime"); + } + else { + this.inhabitedTicks = 0; + } + /* Allocate arrays indexed by section */ + this.section = new Section[this.sectionCnt]; + /* Fill with empty data */ + for (int i = 0; i < this.sectionCnt; i++) { + this.section[i] = empty_section; + } + /* Get sections */ + NBTTagList sect = nbt.getList("Sections", 10); + for (int i = 0; i < sect.size(); i++) { + NBTTagCompound sec = sect.getCompound(i); + int secnum = sec.getByte("Y"); + if (secnum >= this.sectionCnt) { + //Log.info("Section " + (int) secnum + " above world height " + worldheight); + continue; + } + if (secnum < 0) + continue; + //System.out.println("section(" + secnum + ")=" + sec.asString()); + // Create normal section to initialize + StdSection cursect = new StdSection(); + this.section[secnum] = cursect; + DynmapBlockState[] states = cursect.states; + DynmapBlockState[] palette = null; + // If we've got palette and block states list, process non-empty section + if (sec.hasKeyOfType("Palette", 9) && sec.hasKeyOfType("BlockStates", 12)) { + NBTTagList plist = sec.getList("Palette", 10); + long[] statelist = sec.getLongArray("BlockStates"); + palette = new DynmapBlockState[plist.size()]; + for (int pi = 0; pi < plist.size(); pi++) { + NBTTagCompound tc = plist.getCompound(pi); + String pname = tc.getString("Name"); + if (tc.hasKey("Properties")) { + StringBuilder statestr = new StringBuilder(); + NBTTagCompound prop = tc.getCompound("Properties"); + for (String pid : prop.getKeys()) { + if (statestr.length() > 0) statestr.append(','); + statestr.append(pid).append('=').append(prop.get(pid).asString()); + } + palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString()); + } + if (palette[pi] == null) { + palette[pi] = DynmapBlockState.getBaseStateByName(pname); + } + if (palette[pi] == null) { + palette[pi] = DynmapBlockState.AIR; + } + } + int bitsperblock = (statelist.length * 64) / 4096; + DataBits db = new DataBits(bitsperblock, 4096, statelist); + if (bitsperblock > 8) { // Not palette + for (int j = 0; j < 4096; j++) { + states[j] = DynmapBlockState.getStateByGlobalIndex(db.a(j)); + } + } + else { + for (int j = 0; j < 4096; j++) { + int v = db.a(j); + states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR; + } + } + } + cursect.emitlight = sec.getByteArray("BlockLight"); + if (sec.hasKey("SkyLight")) { + cursect.skylight = sec.getByteArray("SkyLight"); + } + } + /* Get biome data */ + this.biome = new int[COLUMNS_PER_CHUNK]; + this.biomebase = new Object[COLUMNS_PER_CHUNK]; + Object[] bbl = BukkitVersionHelper.helper.getBiomeBaseList(); + if (nbt.hasKey("Biomes")) { + int[] bb = nbt.getIntArray("Biomes"); + if (bb != null) { + for (int i = 0; i < bb.length; i++) { + int bv = bb[i]; + if (bv < 0) bv = 0; + this.biome[i] = bv; + this.biomebase[i] = bbl[bv]; + } + } + } + } + + public int getX() + { + return x; + } + + public int getZ() + { + return z; + } + + public DynmapBlockState getBlockType(int x, int y, int z) + { + return section[y >> 4].getBlockType(x, y, z); + } + + public int getBlockSkyLight(int x, int y, int z) + { + return section[y >> 4].getBlockSkyLight(x, y, z); + } + + public int getBlockEmittedLight(int x, int y, int z) + { + return section[y >> 4].getBlockEmittedLight(x, y, z); + } + + public int getHighestBlockYAt(int x, int z) + { + return hmap[z << 4 | x]; + } + + public final long getCaptureFullTime() + { + return captureFulltime; + } + + public boolean isSectionEmpty(int sy) + { + return section[sy].isEmpty(); + } + + public long getInhabitedTicks() { + return inhabitedTicks; + } + + @Override + public Biome getBiome(int x, int z) { + return AbstractMapChunkCache.getBiomeByID(biome[z << 4 | x]); + } + + @Override + public Object[] getBiomeBaseFromSnapshot() { + return this.biomebase; + } + } + + private NBTTagCompound fetchLoadedChunkNBT(World w, int x, int z) { + CraftWorld cw = (CraftWorld) w; + NBTTagCompound nbt = null; + if (cw.isChunkLoaded(x, z)) { + Chunk c = cw.getHandle().getChunkAt(x, z); + if ((c != null) && c.loaded) { + nbt = ChunkRegionLoader.saveChunk(cw.getHandle(), c); + } + } + if (nbt != null) { + nbt = nbt.getCompound("Level"); + if (nbt != null) { + String stat = nbt.getString("Status"); + if ((stat == null) || (stat.equals("full") == false)) { + nbt = null; + } + } + } + return nbt; + } + + private NBTTagCompound loadChunkNBT(World w, int x, int z) { + CraftWorld cw = (CraftWorld) w; + NBTTagCompound nbt = null; + ChunkCoordIntPair cc = new ChunkCoordIntPair(x, z); + try { + nbt = cw.getHandle().getChunkProvider().playerChunkMap.read(cc); + } catch (IOException iox) { + } + if (nbt != null) { + nbt = nbt.getCompound("Level"); + if (nbt != null) { + String stat = nbt.getString("Status"); + if ((stat == null) || (stat.equals("full") == false)) { + nbt = null; + if ((stat == null) || stat.equals("") && DynmapCore.migrateChunks()) { + Chunk c = cw.getHandle().getChunkAt(x, z); + if (c != null) { + nbt = fetchLoadedChunkNBT(w, x, z); + cw.getHandle().unloadChunk(c); + } + } + } + } + } + return nbt; + } + + @Override + public Snapshot wrapChunkSnapshot(ChunkSnapshot css) { + // TODO Auto-generated method stub + return null; + } + + // Load chunk snapshots + @Override + public int loadChunks(int max_to_load) { + if(dw.isLoaded() == false) + return 0; + int cnt = 0; + if(iterator == null) + iterator = chunks.listIterator(); + + DynmapCore.setIgnoreChunkLoads(true); + // Load the required chunks. + while((cnt < max_to_load) && iterator.hasNext()) { + long startTime = System.nanoTime(); + DynmapChunk chunk = iterator.next(); + boolean vis = true; + if(visible_limits != null) { + vis = false; + for(VisibilityLimit limit : visible_limits) { + if (limit.doIntersectChunk(chunk.x, chunk.z)) { + vis = true; + break; + } + } + } + if(vis && (hidden_limits != null)) { + for(VisibilityLimit limit : hidden_limits) { + if (limit.doIntersectChunk(chunk.x, chunk.z)) { + vis = false; + break; + } + } + } + /* Check if cached chunk snapshot found */ + Snapshot ss = null; + long inhabited_ticks = 0; + DynIntHashMap tileData = null; + int idx = (chunk.x-x_min) + (chunk.z - z_min)*x_dim; + SnapshotRec ssr = SnapshotCache.sscache.getSnapshot(dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty); + if(ssr != null) { + inhabited_ticks = ssr.inhabitedTicks; + if(!vis) { + if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) + ss = STONE; + else if(hidestyle == HiddenChunkStyle.FILL_OCEAN) + ss = OCEAN; + else + ss = EMPTY; + } + else { + ss = ssr.ss; + } + snaparray[idx] = ss; + snaptile[idx] = ssr.tileData; + inhabitedTicks[idx] = inhabited_ticks; + + endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT); + continue; + } + // Fetch NTB for chunk if loaded + NBTTagCompound nbt = fetchLoadedChunkNBT(w, chunk.x, chunk.z); + boolean did_load = false; + if (nbt == null) { + // Load NTB for chunk, if it exists + nbt = loadChunkNBT(w, chunk.x, chunk.z); + did_load = true; + } + if (nbt != null) { + NBTSnapshot nss = new NBTSnapshot(nbt, w.getMaxHeight()); + ss = nss; + inhabited_ticks = nss.getInhabitedTicks(); + if(!vis) { + if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) + ss = STONE; + else if(hidestyle == HiddenChunkStyle.FILL_OCEAN) + ss = OCEAN; + else + ss = EMPTY; + } + } + else { + ss = EMPTY; + } + ssr = new SnapshotRec(); + ssr.ss = ss; + ssr.inhabitedTicks = inhabited_ticks; + ssr.tileData = tileData; + SnapshotCache.sscache.putSnapshot(dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty); + snaparray[idx] = ss; + snaptile[idx] = ssr.tileData; + inhabitedTicks[idx] = inhabited_ticks; + if (nbt == null) + endChunkLoad(startTime, ChunkStats.UNGENERATED_CHUNKS); + else if (did_load) + endChunkLoad(startTime, ChunkStats.UNLOADED_CHUNKS); + else + endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS); + cnt++; + } + DynmapCore.setIgnoreChunkLoads(false); + + if(iterator.hasNext() == false) { /* If we're done */ + isempty = true; + /* Fill missing chunks with empty dummy chunk */ + for(int i = 0; i < snaparray.length; i++) { + if(snaparray[i] == null) + snaparray[i] = EMPTY; + else if(snaparray[i] != EMPTY) + isempty = false; + } + } + + return cnt; + } +} diff --git a/settings.gradle b/settings.gradle index c65e3579..e4124566 100644 --- a/settings.gradle +++ b/settings.gradle @@ -5,6 +5,7 @@ include ':bukkit-helper-113-1' include ':bukkit-helper-113-2' include ':bukkit-helper-114' include ':bukkit-helper-114-1' +include ':bukkit-helper-115' include ':bukkit-helper' include ':dynmap-api' include ':DynmapCore' @@ -22,6 +23,7 @@ project(':bukkit-helper-113-1').projectDir = "$rootDir/bukkit-helper-113-1" as F project(':bukkit-helper-113-2').projectDir = "$rootDir/bukkit-helper-113-2" as File project(':bukkit-helper-114').projectDir = "$rootDir/bukkit-helper-114" as File project(':bukkit-helper-114-1').projectDir = "$rootDir/bukkit-helper-114-1" as File +project(':bukkit-helper-115').projectDir = "$rootDir/bukkit-helper-115" as File project(':bukkit-helper').projectDir = "$rootDir/bukkit-helper" as File project(':dynmap-api').projectDir = "$rootDir/dynmap-api" as File project(':DynmapCore').projectDir = "$rootDir/DynmapCore" as File diff --git a/spigot/build.gradle b/spigot/build.gradle index 121ff590..3c7a2ec5 100644 --- a/spigot/build.gradle +++ b/spigot/build.gradle @@ -30,6 +30,9 @@ dependencies { implementation(project(':bukkit-helper-114-1')) { transitive = false } + implementation(project(':bukkit-helper-115')) { + transitive = false + } } processResources { @@ -59,6 +62,7 @@ shadowJar { include(dependency(':bukkit-helper-113-2')) include(dependency(':bukkit-helper-114')) include(dependency(':bukkit-helper-114-1')) + include(dependency(':bukkit-helper-115')) } relocate('org.bstats', 'org.dynmap.bstats') destinationDir = file '../target' diff --git a/spigot/src/main/java/org/dynmap/bukkit/Helper.java b/spigot/src/main/java/org/dynmap/bukkit/Helper.java index c785ba54..fd0b28ca 100644 --- a/spigot/src/main/java/org/dynmap/bukkit/Helper.java +++ b/spigot/src/main/java/org/dynmap/bukkit/Helper.java @@ -10,6 +10,7 @@ import org.dynmap.bukkit.helper.v113_1.BukkitVersionHelperSpigot113_1; import org.dynmap.bukkit.helper.v113_2.BukkitVersionHelperSpigot113_2; import org.dynmap.bukkit.helper.v114.BukkitVersionHelperSpigot114; import org.dynmap.bukkit.helper.v114_1.BukkitVersionHelperSpigot114_1; +import org.dynmap.bukkit.helper.v115.BukkitVersionHelperSpigot115; public class Helper { @@ -34,6 +35,9 @@ public class Helper { else if(Bukkit.getServer().getClass().getName().contains("GlowServer")) { Log.info("Loading Glowstone support"); BukkitVersionHelper.helper = new BukkitVersionHelperGlowstone(); + } + else if (v.contains("(MC: 1.15)")) { + BukkitVersionHelper.helper = new BukkitVersionHelperSpigot115(); } else if (v.contains("(MC: 1.14.1)") || v.contains("(MC: 1.14.2)") || v.contains("(MC: 1.14.3)") || v.contains("(MC: 1.14.4)")) { From 95cc8c687ae40300bb863827316cefb19b0de257 Mon Sep 17 00:00:00 2001 From: Ralph Drake Date: Sat, 14 Dec 2019 18:17:02 -0500 Subject: [PATCH 11/11] Update gradle.properties --- gradle.properties | 1 + 1 file changed, 1 insertion(+) diff --git a/gradle.properties b/gradle.properties index 4687f10d..4e52490b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1 +1,2 @@ org.gradle.jvmargs=-Xmx2G +org.gradle.parallel=true