diff --git a/bukkit-helper-113/.settings/org.eclipse.buildship.core.prefs b/bukkit-helper-113/.settings/org.eclipse.buildship.core.prefs index a7b84d92..d5947ba5 100644 --- a/bukkit-helper-113/.settings/org.eclipse.buildship.core.prefs +++ b/bukkit-helper-113/.settings/org.eclipse.buildship.core.prefs @@ -1,2 +1,2 @@ -connection.project.dir=.. +connection.project.dir=../forge-1.10.2 eclipse.preferences.version=1 diff --git a/bukkit-helper/.settings/org.eclipse.buildship.core.prefs b/bukkit-helper/.settings/org.eclipse.buildship.core.prefs index a7b84d92..d5947ba5 100644 --- a/bukkit-helper/.settings/org.eclipse.buildship.core.prefs +++ b/bukkit-helper/.settings/org.eclipse.buildship.core.prefs @@ -1,2 +1,2 @@ -connection.project.dir=.. +connection.project.dir=../forge-1.10.2 eclipse.preferences.version=1 diff --git a/forge-1.13.2/.gitignore b/forge-1.13.2/.gitignore new file mode 100644 index 00000000..54603950 --- /dev/null +++ b/forge-1.13.2/.gitignore @@ -0,0 +1,3 @@ +/build/ +/.gradle/ +/bin/ diff --git a/forge-1.13.2/build.gradle b/forge-1.13.2/build.gradle new file mode 100644 index 00000000..4c36b167 --- /dev/null +++ b/forge-1.13.2/build.gradle @@ -0,0 +1,141 @@ +buildscript { + repositories { + jcenter() + maven { + name = "forge" + url = "http://files.minecraftforge.net/maven" + } + maven {url = "https://oss.sonatype.org/content/repositories/snapshots/"} + } + dependencies { + classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true + } +} + +apply plugin: 'net.minecraftforge.gradle' + +dependencies { + compile project(":DynmapCore") + compile project(":DynmapCoreAPI") + minecraft 'net.minecraftforge:forge:1.13.2-25.0.63' +} + +sourceCompatibility = 1.8 +targetCompatibility = 1.8 +ext.buildNumber = System.getenv().BUILD_NUMBER ?: "Dev" + +repositories { + maven { + name = 'forge' + url = 'http://files.minecraftforge.net/maven' + } +} +minecraft { + mappings channel: 'snapshot', version: '20180921-1.13' + + runs { + client { + workingDirectory project.file('run') + + // Recommended logging data for a userdev environment + property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP' + + // Recommended logging level for the console + property 'forge.logging.console.level', 'debug' + + mods { + examplemod { + source sourceSets.main + } + } + } + + server { + workingDirectory project.file('run') + + // Recommended logging data for a userdev environment + property 'forge.logging.markers', 'SCAN,REGISTRIES,REGISTRYDUMP' + + // Recommended logging level for the console + property 'forge.logging.console.level', 'debug' + + mods { + examplemod { + source sourceSets.main + } + } + } + } + //replaceIn "Version.java" + //replace "@VERSION@", project.version + '-' + project.ext.buildNumber + //replace "@BUILD_NUMBER@", project.ext.buildNumber +} + +project.archivesBaseName = "${project.archivesBaseName}-forge-1.12.2" + +processResources +{ + // replace stuff in mcmod.info, nothing else + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info' + + // replace version and mcversion + expand( + version: project.version + '-' + project.ext.buildNumber, + mcversion: "1.13.2" + ) + } + + // copy everything else, thats not the mcmod.info + from(sourceSets.main.resources.srcDirs) { + exclude 'mcmod.info' + } + // Move access transformer to META-INF + rename '(.+_at.cfg)', 'META-INF/$1' +} + +jar { + manifest { + attributes 'FMLAT': 'dynmap_at.cfg' + } +} + +shadowJar { + dependencies { + include(dependency('com.googlecode.json-simple:json-simple:')) + include(dependency('org.yaml:snakeyaml:')) + include(dependency('com.googlecode.owasp-java-html-sanitizer:owasp-java-html-sanitizer:')) + include(dependency('org.eclipse.jetty::')) + include(dependency('org.eclipse.jetty.orbit:javax.servlet:')) + include(dependency(':DynmapCore')) + include(dependency(':DynmapCoreAPI')) + } + relocate('org.json.simple', 'org.dynmap.json.simple') + relocate('org.yaml.snakeyaml', 'org.dynmap.snakeyaml') + relocate('org.eclipse.jetty', 'org.dynmap.jetty') + relocate('org.owasp.html', 'org.dynmap.org.owasp.html') + relocate('javax.servlet', 'org.dynmap.javax.servlet' ) + archiveName = "Dynmap-${parent.version}-forge-1.12.2.jar" + destinationDir = file '../target' +} + +shadowJar.doLast { + task -> + ant.checksum file: task.archivePath +} + + +//reobf { +// mappings channel: 'snapshot', version: '20180921-1.13' +//} + +task deobfJar(type: Jar) { + from sourceSets.main.output + classifier = 'dev' +} + +artifacts { + archives deobfJar +} + +build.dependsOn(shadowJar) diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ChunkSnapshot.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ChunkSnapshot.java new file mode 100644 index 00000000..d42b4264 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ChunkSnapshot.java @@ -0,0 +1,307 @@ +package org.dynmap.forge_1_13_2; + +import java.util.Arrays; + +import org.dynmap.Log; +import org.dynmap.renderer.DynmapBlockState; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; + +/** + * Represents a static, thread-safe snapshot of chunk of blocks + * Purpose is to allow clean, efficient copy of a chunk data to be made, and then handed off for processing in another thread (e.g. map rendering) + */ +public class ChunkSnapshot +{ + 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 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; + 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 ChunkSnapshot(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.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 ChunkSnapshot(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); + byte secnum = sec.getByte("Y"); + if (secnum >= this.sectionCnt) { + Log.info("Section " + (int) secnum + " above world height " + worldheight); + continue; + } + // Create normal section to initialize + StdSection cursect = new StdSection(); + this.section[secnum] = cursect; + DynmapBlockState[] states = cursect.states; + // JEI format + if (sec.hasKey("Palette")) { + int[] p = sec.getIntArray("Palette"); + // Palette is list of state values, where Blocks=bit 11-4 of index, Data=bit 3-0 + byte[] msb_bytes = sec.getByteArray("Blocks"); + int mlen = msb_bytes.length / 2; + byte[] lsb_bytes = sec.getByteArray("Data"); + int llen = BLOCKS_PER_SECTION / 2; + if (llen > lsb_bytes.length) llen = lsb_bytes.length; + for(int j = 0; j < llen; j++) { + int idx = lsb_bytes[j] & 0xF; + int idx2 = (lsb_bytes[j] & 0xF0) >>> 4; + if (j < mlen) { + idx += (255 & msb_bytes[2*j]) << 4; + idx2 += (255 & msb_bytes[2*j+1]) << 4; + } + // Get even block id + states[2*j] = DynmapPlugin.stateByID[(idx < p.length) ? p[idx] : 0]; + // Get odd block id + states[2*j+1] = DynmapPlugin.stateByID[(idx2 < p.length) ? p[idx2] : 0]; + } + } + else { + // Get block IDs + byte[] lsb_bytes = sec.getByteArray("Blocks"); + if (lsb_bytes.length < BLOCKS_PER_SECTION) { + lsb_bytes = Arrays.copyOf(lsb_bytes, BLOCKS_PER_SECTION); + } + // Get any additional ID data + byte[] addid = null; + if (sec.hasKey("Add")) { /* If additional data, add it */ + addid = sec.getByteArray("Add"); + if (addid.length < (BLOCKS_PER_SECTION / 2)) { + addid = Arrays.copyOf(addid, (BLOCKS_PER_SECTION / 2)); + } + } + // Check for NEID additional additional ID data + byte[] addid2 = null; + if (sec.hasKey("Add2")) { /* If additional data (NEID), add it */ + addid2 = sec.getByteArray("Add2"); + if (addid2.length < (BLOCKS_PER_SECTION / 2)) { + addid2 = Arrays.copyOf(addid2, (BLOCKS_PER_SECTION / 2)); + } + } + // Get meta nibble data + byte[] bd = null; + if (sec.hasKey("Data")) { + bd = sec.getByteArray("Data"); + if (bd.length < (BLOCKS_PER_SECTION / 2)) { + bd = Arrays.copyOf(bd, (BLOCKS_PER_SECTION / 2)); + } + } + // Traverse section + for(int j = 0; j < BLOCKS_PER_SECTION; j += 2) { + // Start with block ID + int id = (0xFF & lsb_bytes[j]) << 4; + int id2 = (0xFF & lsb_bytes[j+1]) << 4; + // Add in additional parts + if (addid != null) { + byte b = addid[j >> 1]; + id += (0xF & b) << 12; + id2 += (0xF0 & b) << 8; + } + // Add in additional additional parts + if (addid2 != null) { + byte b = addid2[j >> 1]; + id += (0xF & b) << 16; + id2 += (0xF0 & b) << 12; + } + // Add in metadata + if (bd != null) { + byte b = bd[j >> 1]; + id += (0xF & b); + id2 += (0xF0 & b) >> 4; + } + // Compute states + states[j] = DynmapPlugin.stateByID[id]; + states[j+1] = DynmapPlugin.stateByID[id2]; + } + } + cursect.emitlight = sec.getByteArray("BlockLight"); + if (sec.hasKey("SkyLight")) { + cursect.skylight = sec.getByteArray("SkyLight"); + } + } + /* Get biome data */ + this.biome = new int[COLUMNS_PER_CHUNK]; + if (nbt.hasKey("Biomes")) { + byte[] b = nbt.getByteArray("Biomes"); + if (b != null) { + for (int i = 0; i < b.length; i++) { + int bv = 255 & b[i]; + this.biome[i] = (bv == 255) ? 0 : bv; + } + } + else { // Check JEI biomes + int[] bb = nbt.getIntArray("Biomes"); + if (bb != null) { + for (int i = 0; i < bb.length; i++) { + int bv = bb[i]; + this.biome[i] = (bv < 0) ? 0 : 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 int getBiome(int x, int z) + { + return biome[z << 4 | x]; + } + + public final long getCaptureFullTime() + { + return captureFulltime; + } + + public boolean isSectionEmpty(int sy) + { + return section[sy].isEmpty(); + } + + public long getInhabitedTicks() { + return inhabitedTicks; + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ClientProxy.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ClientProxy.java new file mode 100644 index 00000000..1d3fa005 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ClientProxy.java @@ -0,0 +1,6 @@ +package org.dynmap.forge_1_13_2; + +public class ClientProxy extends Proxy { + public ClientProxy() { + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapMod.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapMod.java new file mode 100644 index 00000000..c749db92 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapMod.java @@ -0,0 +1,121 @@ +package org.dynmap.forge_1_13_2; + +import java.io.File; + +import org.dynmap.DynmapCommonAPI; +import org.dynmap.DynmapCommonAPIListener; +import org.dynmap.Log; +import org.dynmap.forge_1_13_2.DynmapPlugin.OurLog; + +import net.minecraft.server.MinecraftServer; +import net.minecraftforge.fml.common.Mod; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.eventbus.api.SubscribeEvent; +import net.minecraftforge.fml.DistExecutor; +import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent; +import net.minecraftforge.fml.event.lifecycle.FMLLoadCompleteEvent; +import net.minecraftforge.fml.event.server.FMLServerStartingEvent; +import net.minecraftforge.fml.event.server.FMLServerStoppingEvent; +import net.minecraftforge.fml.event.server.FMLServerStartedEvent; +import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext; + +@Mod("dynmap") +public class DynmapMod +{ + // The instance of your mod that Forge uses. + public static DynmapMod instance; + + // Says where the client and server 'proxy' code is loaded. + public static Proxy proxy = DistExecutor.runForDist(() -> ClientProxy::new, () -> Proxy::new); + + public static DynmapPlugin plugin; + public static File jarfile; + public static boolean useforcedchunks; + + public class APICallback extends DynmapCommonAPIListener { + @Override + public void apiListenerAdded() { + if(plugin == null) { + plugin = proxy.startServer(server); + } + } + @Override + public void apiEnabled(DynmapCommonAPI api) { + } + } + + //TODO + //public class LoadingCallback implements net.minecraftforge.common.ForgeChunkManager.LoadingCallback { + // @Override + // public void ticketsLoaded(List tickets, World world) { + // if(tickets.size() > 0) { + // DynmapPlugin.setBusy(world, tickets.get(0)); + // for(int i = 1; i < tickets.size(); i++) { + // ForgeChunkManager.releaseTicket(tickets.get(i)); + // } + // } + // } + //} + + public DynmapMod() { + instance = this; + FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup); + FMLJavaModLoadingContext.get().getModEventBus().addListener(this::init); + + MinecraftForge.EVENT_BUS.register(this); + + Log.setLogger(new OurLog()); + org.dynmap.modsupport.ModSupportImpl.init(); + } + + public void setup(final FMLCommonSetupEvent event) + { + //TOOO + //jarfile = event.getSourceFile(); + //// Load configuration file - use suggested (config/WesterosBlocks.cfg) + //Configuration cfg = new Configuration(event.getSuggestedConfigurationFile()); + //try { + // cfg.load(); + // + // useforcedchunks = cfg.get("Settings", "UseForcedChunks", true).getBoolean(true); + //} + //finally + //{ + // cfg.save(); + //} + } + + public void init(FMLLoadCompleteEvent event) + { + /* Set up for chunk loading notice from chunk manager */ + //TODO + //if(useforcedchunks) { + // ForgeChunkManager.setForcedChunkLoadingCallback(DynmapMod.instance, new LoadingCallback()); + //} + //else { + // System.out.println("[Dynmap] World loading using forced chunks is disabled"); + //} + } + + private MinecraftServer server; + + @SubscribeEvent + public void onServerStarting(FMLServerStartingEvent event) { + server = event.getServer(); + } + + @SubscribeEvent + public void onServerStarted(FMLServerStartedEvent event) { + DynmapCommonAPIListener.register(new APICallback()); + if(plugin == null) + plugin = proxy.startServer(server); + plugin.serverStarted(); + } + + @SubscribeEvent + public void serverStopping(FMLServerStoppingEvent event) + { + proxy.stopServer(plugin); + plugin = null; + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapPlugin.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapPlugin.java new file mode 100644 index 00000000..740739a2 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/DynmapPlugin.java @@ -0,0 +1,2052 @@ +package org.dynmap.forge_1_13_2; + +import java.io.File; +import java.io.InputStream; +import java.lang.reflect.Field; +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Optional; +import java.util.PriorityQueue; +import java.util.Set; +import java.util.UUID; +import java.util.concurrent.Callable; +import java.util.concurrent.CancellationException; +import java.util.concurrent.ConcurrentLinkedQueue; +import java.util.concurrent.ExecutionException; +import java.util.concurrent.Future; +import java.util.concurrent.FutureTask; +import java.util.regex.Pattern; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.block.state.IBlockState; +import net.minecraft.command.CommandException; +import net.minecraft.command.CommandSource; +import net.minecraft.command.Commands; +import net.minecraft.command.ICommandSource; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.network.NetHandlerPlayServer; +import net.minecraft.network.NetworkManager; +import net.minecraft.particles.IParticleData; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.management.UserListBans; +import net.minecraft.server.management.UserListIPBans; +import net.minecraft.server.management.UserListOps; +import net.minecraft.server.management.PlayerProfileCache; +import net.minecraft.util.ObjectIntIdentityMap; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.SoundCategory; +import net.minecraft.util.SoundEvent; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.util.text.ITextComponent; +import net.minecraft.util.text.TextComponentString; +import net.minecraft.world.IBlockReader; +import net.minecraft.world.IWorld; +import net.minecraft.world.IWorldEventListener; +import net.minecraft.world.World; +import net.minecraft.world.WorldServer; +import net.minecraft.world.biome.Biome; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.ChunkSection; +import net.minecraft.world.chunk.IChunk; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.ServerChatEvent; +import net.minecraftforge.event.world.ChunkEvent; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.ModContainer; +import net.minecraftforge.fml.ModList; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerChangedDimensionEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedInEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerLoggedOutEvent; +import net.minecraftforge.fml.common.gameevent.PlayerEvent.PlayerRespawnEvent; +import net.minecraftforge.registries.RegistryManager; +import net.minecraftforge.fml.common.gameevent.TickEvent; +import net.minecraftforge.fml.common.registry.GameRegistry; +import net.minecraftforge.fml.loading.moddiscovery.ModFileInfo; +import net.minecraftforge.fml.loading.moddiscovery.ModInfo; +import net.minecraftforge.forgespi.language.IModInfo; + +import org.apache.commons.codec.Charsets; +import org.apache.commons.codec.binary.Base64; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.maven.artifact.versioning.ArtifactVersion; +import org.dynmap.ConfigurationNode; +import org.dynmap.DynmapChunk; +import org.dynmap.DynmapCommonAPIListener; +import org.dynmap.DynmapCore; +import org.dynmap.DynmapLocation; +import org.dynmap.DynmapWorld; +import org.dynmap.Log; +import org.dynmap.MapManager; +import org.dynmap.PlayerList; +import org.dynmap.common.BiomeMap; +import org.dynmap.common.DynmapCommandSender; +import org.dynmap.common.DynmapPlayer; +import org.dynmap.common.DynmapServerInterface; +import org.dynmap.common.DynmapListenerManager.EventType; +import org.dynmap.debug.Debug; +import org.dynmap.forge_1_13_2.DmapCommand; +import org.dynmap.forge_1_13_2.DmarkerCommand; +import org.dynmap.forge_1_13_2.DynmapCommand; +import org.dynmap.forge_1_13_2.DynmapMod; +import org.dynmap.forge_1_13_2.permissions.FilePermissions; +import org.dynmap.forge_1_13_2.permissions.OpPermissions; +import org.dynmap.forge_1_13_2.permissions.PermissionProvider; +import org.dynmap.permissions.PermissionsHandler; +import org.dynmap.renderer.DynmapBlockState; +import org.dynmap.utils.DynIntHashMap; +import org.dynmap.utils.DynmapLogger; +import org.dynmap.utils.MapChunkCache; +import org.dynmap.utils.VisibilityLimit; + +import com.google.common.collect.Iterables; +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonParseException; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.properties.Property; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; + +import net.minecraft.state.IProperty; +import net.minecraftforge.eventbus.api.SubscribeEvent; + +public class DynmapPlugin +{ + private DynmapCore core; + private PermissionProvider permissions; + private boolean core_enabled; + public SnapshotCache sscache; + public PlayerList playerList; + private MapManager mapManager; + private net.minecraft.server.MinecraftServer server; + public static DynmapPlugin plugin; + private ChatHandler chathandler; + private HashMap sortWeights = new HashMap(); + // Drop world load ticket after 30 seconds + private long worldIdleTimeoutNS = 30 * 1000000000L; + private HashMap worlds = new HashMap(); + private IWorld last_world; + private ForgeWorld last_fworld; + private Map players = new HashMap(); + //TODO private ForgeMetrics metrics; + private HashSet modsused = new HashSet(); + private ForgeServer fserver = new ForgeServer(); + private boolean tickregistered = false; + // TPS calculator + private double tps; + private long lasttick; + private long avgticklen; + // Per tick limit, in nsec + private long perTickLimit = (50000000); // 50 ms + private boolean isMCPC = false; + private boolean useSaveFolder = true; + private Field displayName = null; // MCPC+ display name + + private static final String[] TRIGGER_DEFAULTS = { "blockupdate", "chunkpopulate", "chunkgenerate" }; + + private static final Pattern patternControlCode = Pattern.compile("(?i)\\u00A7[0-9A-FK-OR]"); + + public static class BlockUpdateRec { + IWorld w; + String wid; + int x, y, z; + } + ConcurrentLinkedQueue blockupdatequeue = new ConcurrentLinkedQueue(); + + public static DynmapBlockState[] stateByID; + + /** + * Initialize block states (org.dynmap.blockstate.DynmapBlockState) + */ + public void initializeBlockStates() { + stateByID = new DynmapBlockState[512*16]; // Simple map - scale as needed + Arrays.fill(stateByID, DynmapBlockState.AIR); // Default to air + + ObjectIntIdentityMap bsids = Block.BLOCK_STATE_IDS; + + DynmapBlockState basebs = null; + Block baseb = null; + int baseidx = 0; + + Iterator iter = bsids.iterator(); + while (iter.hasNext()) { + IBlockState bs = iter.next(); + int idx = bsids.get(bs); + if (idx >= stateByID.length) { + int plen = stateByID.length; + stateByID = Arrays.copyOf(stateByID, idx+1); + Arrays.fill(stateByID, plen, stateByID.length, DynmapBlockState.AIR); + } + Block b = bs.getBlock(); + // If this is new block vs last, it's the base block state + if (b != baseb) { + basebs = null; + baseidx = idx; + } + + ResourceLocation ui = b.getRegistryName(); + if (ui == null) { + continue; + } + String bn = ui.getNamespace() + ":" + ui.getPath(); + // Only do defined names, and not "air" + if (!bn.equals(DynmapBlockState.AIR_BLOCK)) { + Material mat = bs.getMaterial(); + String statename = ""; + for(IProperty p : bs.getProperties()) { + if (statename.length() > 0) { + statename += ","; + } + statename += p.getName() + "=" + bs.get(p).toString(); + } + DynmapBlockState dbs = new DynmapBlockState(basebs, idx - baseidx, bn, statename, mat.toString(), idx); + stateByID[idx] = dbs; + if (mat.isSolid()) { + dbs.setSolid(); + } + if (mat == Material.AIR) { + dbs.setAir(); + } + if (mat == Material.WOOD) { + dbs.setLog(); + } + if (mat == Material.LEAVES) { + dbs.setLeaves(); + } + } + } + for (int gidx = 0; gidx < DynmapBlockState.getGlobalIndexMax(); gidx++) { + DynmapBlockState bs = DynmapBlockState.getStateByGlobalIndex(gidx); + Log.info(gidx + ":" + bs.toString() + ", gidx=" + bs.globalStateIndex + ", sidx=" + bs.stateIndex); + } + } + + public static final Item getItemByID(int id) { + return Item.getItemById(id); + } + + public static final String getBlockUnlocalizedName(Block b) { + return b.getNameTextComponent().getString(); + } + + private static Biome[] biomelist = null; + + public static final Biome[] getBiomeList() { + if (biomelist == null) { + biomelist = new Biome[256]; + Iterator iter = Biome.MUTATION_TO_BASE_ID_MAP.iterator(); + while (iter.hasNext()) { + Biome b = iter.next(); + int bidx = Biome.MUTATION_TO_BASE_ID_MAP.get(b); + if (bidx >= biomelist.length) { + biomelist = Arrays.copyOf(biomelist, bidx + biomelist.length); + } + biomelist[bidx] = b; + } + } + return biomelist; + } + public static final NetworkManager getNetworkManager(NetHandlerPlayServer nh) { + return nh.netManager; + } + + private ForgePlayer getOrAddPlayer(EntityPlayer p) { + String name = p.getEntity().getName().getString(); + ForgePlayer fp = players.get(name); + if(fp != null) { + fp.player = p; + } + else { + fp = new ForgePlayer(p); + players.put(name, fp); + } + return fp; + } + + private static class TaskRecord implements Comparable + { + private long ticktorun; + private long id; + private FutureTask future; + @Override + public int compareTo(Object o) + { + TaskRecord tr = (TaskRecord)o; + + if (this.ticktorun < tr.ticktorun) + { + return -1; + } + else if (this.ticktorun > tr.ticktorun) + { + return 1; + } + else if (this.id < tr.id) + { + return -1; + } + else if (this.id > tr.id) + { + return 1; + } + else + { + return 0; + } + } + } + + private class ChatMessage { + String message; + EntityPlayer sender; + } + private ConcurrentLinkedQueue msgqueue = new ConcurrentLinkedQueue(); + + public class ChatHandler { + @SubscribeEvent + public void handleChat(ServerChatEvent event) { + String msg = event.getMessage(); + if(!msg.startsWith("/")) { + ChatMessage cm = new ChatMessage(); + cm.message = msg; + cm.sender = event.getPlayer(); + msgqueue.add(cm); + } + } + } + + /** TODO: depends on forge chunk manager + private static class WorldBusyRecord { + long last_ts; + Ticket ticket; + } + private static HashMap busy_worlds = new HashMap(); + + private void setBusy(World w) { + setBusy(w, null); + } + static void setBusy(World w, Ticket t) { + if(w == null) return; + if (!DynmapMod.useforcedchunks) return; + WorldBusyRecord wbr = busy_worlds.get(w.provider.getDimension()); + if(wbr == null) { // Not busy, make ticket and keep spawn loaded + Debug.debug("World " + w.getWorldInfo().getWorldName() + "/"+ w.provider.getDimensionType().getName() + " is busy"); + wbr = new WorldBusyRecord(); + if(t != null) + wbr.ticket = t; + else + wbr.ticket = ForgeChunkManager.requestTicket(DynmapMod.instance, w, ForgeChunkManager.Type.NORMAL); + if(wbr.ticket != null) { + BlockPos cc = w.getSpawnPoint(); + ChunkPos ccip = new ChunkPos(cc.getX() >> 4, cc.getZ() >> 4); + ForgeChunkManager.forceChunk(wbr.ticket, ccip); + busy_worlds.put(w.provider.getDimension(), wbr); // Add to busy list + } + } + wbr.last_ts = System.nanoTime(); + } + + private void doIdleOutOfWorlds() { + if (!DynmapMod.useforcedchunks) return; + long ts = System.nanoTime() - worldIdleTimeoutNS; + for(Iterator itr = busy_worlds.values().iterator(); itr.hasNext();) { + WorldBusyRecord wbr = itr.next(); + if(wbr.last_ts < ts) { + World w = wbr.ticket.world; + Debug.debug("World " + w.getWorldInfo().getWorldName() + "/" + wbr.ticket.world.provider.getDimensionType().getName() + " is idle"); + if (wbr.ticket != null) + ForgeChunkManager.releaseTicket(wbr.ticket); // Release hold on world + itr.remove(); + } + } + } + */ + + public static class OurLog implements DynmapLogger { + Logger log; + public static final String DM = "[Dynmap] "; + OurLog() { + log = LogManager.getLogger("Dynmap"); + } + @Override + public void info(String s) { + log.info(DM + s); + } + + @Override + public void severe(Throwable t) { + log.fatal(t); + } + + @Override + public void severe(String s) { + log.fatal(DM + s); + } + + @Override + public void severe(String s, Throwable t) { + log.fatal(DM + s, t); + } + + @Override + public void verboseinfo(String s) { + log.info(DM + s); + } + + @Override + public void warning(String s) { + log.warn(DM + s); + } + + @Override + public void warning(String s, Throwable t) { + log.warn(DM + s, t); + } + } + + public DynmapPlugin(MinecraftServer srv) + { + plugin = this; + this.server = srv; + + displayName = null; + try { + displayName = EntityPlayerMP.class.getField("displayName"); + } catch (SecurityException e) { + } catch (NoSuchFieldException e) { + } + } + + public boolean isOp(String player) { + String[] ops = server.getPlayerList().getOppedPlayers().getKeys(); + for (String op : ops) { + if (op.equalsIgnoreCase(player)) { + return true; + } + } + return (server.isSinglePlayer() && player.equalsIgnoreCase(server.getServerOwner())); + } + + private boolean hasPerm(ICommandSource sender, String permission) { + PermissionsHandler ph = PermissionsHandler.getHandler(); + if(ph != null) { + if((sender instanceof EntityPlayer) && ph.hasPermission(((EntityPlayer)sender).getEntity().getName().getString(), permission)) { + return true; + } + } + return permissions.has(sender, permission); + } + + private boolean hasPermNode(ICommandSource sender, String permission) { + PermissionsHandler ph = PermissionsHandler.getHandler(); + if(ph != null) { + if((sender instanceof EntityPlayer) && ph.hasPermissionNode(((EntityPlayer)sender).getEntity().getName().getString(), permission)) { + return true; + } + } + return permissions.hasPermissionNode(sender, permission); + } + + private Set hasOfflinePermissions(String player, Set perms) { + Set rslt = null; + PermissionsHandler ph = PermissionsHandler.getHandler(); + if(ph != null) { + rslt = ph.hasOfflinePermissions(player, perms); + } + Set rslt2 = hasOfflinePermissions(player, perms); + if((rslt != null) && (rslt2 != null)) { + Set newrslt = new HashSet(rslt); + newrslt.addAll(rslt2); + rslt = newrslt; + } + else if(rslt2 != null) { + rslt = rslt2; + } + return rslt; + } + private boolean hasOfflinePermission(String player, String perm) { + PermissionsHandler ph = PermissionsHandler.getHandler(); + if(ph != null) { + if(ph.hasOfflinePermission(player, perm)) { + return true; + } + } + return permissions.hasOfflinePermission(player, perm); + } + + /** + * Server access abstraction class + */ + public class ForgeServer extends DynmapServerInterface + { + /* Server thread scheduler */ + private Object schedlock = new Object(); + private long cur_tick; + private long next_id; + private long cur_tick_starttime; + private PriorityQueue runqueue = new PriorityQueue(); + + public ForgeServer() { + } + + private GameProfile getProfileByName(String player) { + PlayerProfileCache cache = server.getPlayerProfileCache(); + return cache.getGameProfileForUsername(player); + } + + @Override + public int getBlockIDAt(String wname, int x, int y, int z) { + return -1; + } + + @Override + public void scheduleServerTask(Runnable run, long delay) + { + TaskRecord tr = new TaskRecord(); + tr.future = new FutureTask(run, null); + + /* Add task record to queue */ + synchronized (schedlock) + { + tr.id = next_id++; + tr.ticktorun = cur_tick + delay; + runqueue.add(tr); + } + } + @Override + public DynmapPlayer[] getOnlinePlayers() + { + if(server.getPlayerList() == null) + return new DynmapPlayer[0]; + List playlist = server.getPlayerList().getPlayers(); + int pcnt = playlist.size(); + DynmapPlayer[] dplay = new DynmapPlayer[pcnt]; + + for (int i = 0; i < pcnt; i++) + { + EntityPlayer p = (EntityPlayer)playlist.get(i); + dplay[i] = getOrAddPlayer(p); + } + + return dplay; + } + @Override + public void reload() + { + plugin.onDisable(); + plugin.onEnable(); + plugin.onStart(); + } + @Override + public DynmapPlayer getPlayer(String name) + { + List players = server.getPlayerList().getPlayers(); + + for (Object o : players) + { + EntityPlayer p = (EntityPlayer)o; + + if (p.getEntity().getName().getString().equalsIgnoreCase(name)) + { + return getOrAddPlayer(p); + } + } + + return null; + } + @Override + public Set getIPBans() + { + UserListIPBans bl = server.getPlayerList().getBannedIPs(); + Set ips = new HashSet(); + + for (String s : bl.getKeys()) { + ips.add(s); + } + + return ips; + } + @Override + public Future callSyncMethod(Callable task) { + return callSyncMethod(task, 0); + } + public Future callSyncMethod(Callable task, long delay) + { + TaskRecord tr = new TaskRecord(); + FutureTask ft = new FutureTask(task); + tr.future = ft; + + /* Add task record to queue */ + synchronized (schedlock) + { + tr.id = next_id++; + tr.ticktorun = cur_tick + delay; + runqueue.add(tr); + } + + return ft; + } + @Override + public String getServerName() + { + String sn; + if (server.isSinglePlayer()) + sn = "Integrated"; + else + sn = server.getServerHostname(); + if(sn == null) sn = "Unknown Server"; + return sn; + } + @Override + public boolean isPlayerBanned(String pid) + { + UserListBans bl = server.getPlayerList().getBannedPlayers(); + return bl.isBanned(getProfileByName(pid)); + } + + @Override + public String stripChatColor(String s) + { + return patternControlCode.matcher(s).replaceAll(""); + } + private Set registered = new HashSet(); + @Override + public boolean requestEventNotification(EventType type) + { + if (registered.contains(type)) + { + return true; + } + + switch (type) + { + case WORLD_LOAD: + case WORLD_UNLOAD: + /* Already called for normal world activation/deactivation */ + break; + + case WORLD_SPAWN_CHANGE: + /*TODO + pm.registerEvents(new Listener() { + @EventHandler(priority=EventPriority.MONITOR) + public void onSpawnChange(SpawnChangeEvent evt) { + DynmapWorld w = new BukkitWorld(evt.getWorld()); + core.listenerManager.processWorldEvent(EventType.WORLD_SPAWN_CHANGE, w); + } + }, DynmapPlugin.this); + */ + break; + + case PLAYER_JOIN: + case PLAYER_QUIT: + /* Already handled */ + break; + + case PLAYER_BED_LEAVE: + /*TODO + pm.registerEvents(new Listener() { + @EventHandler(priority=EventPriority.MONITOR) + public void onPlayerBedLeave(PlayerBedLeaveEvent evt) { + DynmapPlayer p = new BukkitPlayer(evt.getPlayer()); + core.listenerManager.processPlayerEvent(EventType.PLAYER_BED_LEAVE, p); + } + }, DynmapPlugin.this); + */ + break; + + case PLAYER_CHAT: + if (chathandler == null) { + chathandler = new ChatHandler(); + MinecraftForge.EVENT_BUS.register(chathandler); + } + break; + + case BLOCK_BREAK: + /*TODO + pm.registerEvents(new Listener() { + @EventHandler(priority=EventPriority.MONITOR) + public void onBlockBreak(BlockBreakEvent evt) { + if(evt.isCancelled()) return; + Block b = evt.getBlock(); + if(b == null) return; + Location l = b.getLocation(); + core.listenerManager.processBlockEvent(EventType.BLOCK_BREAK, b.getType().getId(), + BukkitWorld.normalizeWorldName(l.getWorld().getName()), l.getBlockX(), l.getBlockY(), l.getBlockZ()); + } + }, DynmapPlugin.this); + */ + break; + + case SIGN_CHANGE: + /*TODO + pm.registerEvents(new Listener() { + @EventHandler(priority=EventPriority.MONITOR) + public void onSignChange(SignChangeEvent evt) { + if(evt.isCancelled()) return; + Block b = evt.getBlock(); + Location l = b.getLocation(); + String[] lines = evt.getLines(); + DynmapPlayer dp = null; + Player p = evt.getPlayer(); + if(p != null) dp = new BukkitPlayer(p); + core.listenerManager.processSignChangeEvent(EventType.SIGN_CHANGE, b.getType().getId(), + BukkitWorld.normalizeWorldName(l.getWorld().getName()), l.getBlockX(), l.getBlockY(), l.getBlockZ(), lines, dp); + } + }, DynmapPlugin.this); + */ + break; + + default: + Log.severe("Unhandled event type: " + type); + return false; + } + + registered.add(type); + return true; + } + @Override + public boolean sendWebChatEvent(String source, String name, String msg) + { + return DynmapCommonAPIListener.fireWebChatEvent(source, name, msg); + } + @Override + public void broadcastMessage(String msg) + { + ITextComponent component = new TextComponentString(msg); + server.getPlayerList().sendMessage(component); + Log.info(stripChatColor(msg)); + } + @Override + public String[] getBiomeIDs() + { + BiomeMap[] b = BiomeMap.values(); + String[] bname = new String[b.length]; + + for (int i = 0; i < bname.length; i++) + { + bname[i] = b[i].toString(); + } + + return bname; + } + @Override + public double getCacheHitRate() + { + if(sscache != null) + return sscache.getHitRate(); + return 0.0; + } + @Override + public void resetCacheStats() + { + if(sscache != null) + sscache.resetStats(); + } + @Override + public DynmapWorld getWorldByName(String wname) + { + return DynmapPlugin.this.getWorldByName(wname); + } + @Override + public DynmapPlayer getOfflinePlayer(String name) + { + /* + OfflinePlayer op = getServer().getOfflinePlayer(name); + if(op != null) { + return new BukkitPlayer(op); + } + */ + return null; + } + @Override + public Set checkPlayerPermissions(String player, Set perms) + { + net.minecraft.server.management.PlayerList scm = server.getPlayerList(); + if (scm == null) return Collections.emptySet(); + UserListBans bl = scm.getBannedPlayers(); + if (bl == null) return Collections.emptySet(); + if(bl.isBanned(getProfileByName(player))) { + return Collections.emptySet(); + } + Set rslt = hasOfflinePermissions(player, perms); + if (rslt == null) { + rslt = new HashSet(); + if(plugin.isOp(player)) { + rslt.addAll(perms); + } + } + return rslt; + } + @Override + public boolean checkPlayerPermission(String player, String perm) + { + net.minecraft.server.management.PlayerList scm = server.getPlayerList(); + if (scm == null) return false; + UserListBans bl = scm.getBannedPlayers(); + if (bl == null) return false; + if(bl.isBanned(getProfileByName(player))) { + return false; + } + return hasOfflinePermission(player, perm); + } + /** + * Render processor helper - used by code running on render threads to request chunk snapshot cache from server/sync thread + */ + @Override + public MapChunkCache createMapChunkCache(DynmapWorld w, List chunks, + boolean blockdata, boolean highesty, boolean biome, boolean rawbiome) + { + ForgeMapChunkCache c = (ForgeMapChunkCache) w.getChunkCache(chunks); + if(c == null) { + return null; + } + if (w.visibility_limits != null) + { + for (VisibilityLimit limit: w.visibility_limits) + { + c.setVisibleRange(limit); + } + + c.setHiddenFillStyle(w.hiddenchunkstyle); + } + + if (w.hidden_limits != null) + { + for (VisibilityLimit limit: w.hidden_limits) + { + c.setHiddenRange(limit); + } + + c.setHiddenFillStyle(w.hiddenchunkstyle); + } + + if (c.setChunkDataTypes(blockdata, biome, highesty, rawbiome) == false) + { + Log.severe("CraftBukkit build does not support biome APIs"); + } + + if (chunks.size() == 0) /* No chunks to get? */ + { + c.loadChunks(0); + return c; + } + + //Now handle any chunks in server thread that are already loaded (on server thread) + final ForgeMapChunkCache cc = c; + Future f = this.callSyncMethod(new Callable() { + public Boolean call() throws Exception { + // Update busy state on world + ForgeWorld fw = (ForgeWorld)cc.getWorld(); + //TODO + //setBusy(fw.getWorld()); + cc.getLoadedChunks(); + return true; + } + }, 0); + try { + f.get(); + } + catch (CancellationException cx) { + return null; + } + catch (ExecutionException xx) { + Log.severe("Exception while loading chunks", xx.getCause()); + return null; + } + catch (Exception ix) { + Log.severe(ix); + return null; + } + if(w.isLoaded() == false) { + return null; + } + // Now, do rest of chunk reading from calling thread + c.readChunks(chunks.size()); + + return c; + } + @Override + public int getMaxPlayers() + { + return server.getMaxPlayers(); + } + @Override + public int getCurrentPlayers() + { + return server.getPlayerList().getCurrentPlayerCount(); + } + + @SubscribeEvent + public void tickEvent(TickEvent.ServerTickEvent event) { + if (event.phase == TickEvent.Phase.START) { + return; + } + cur_tick_starttime = System.nanoTime(); + long elapsed = cur_tick_starttime - lasttick; + lasttick = cur_tick_starttime; + avgticklen = ((avgticklen * 99) / 100) + (elapsed / 100); + tps = (double)1E9 / (double)avgticklen; + // Tick core + if (core != null) { + core.serverTick(tps); + } + + boolean done = false; + TaskRecord tr = null; + + while(!blockupdatequeue.isEmpty()) { + BlockUpdateRec r = blockupdatequeue.remove(); + IBlockState bs = r.w.getBlockState(new BlockPos(r.x, r.y, r.z)); + int idx = Block.BLOCK_STATE_IDS.get(bs); + if(!org.dynmap.hdmap.HDBlockModels.isChangeIgnoredBlock(stateByID[idx])) { + if(onblockchange_with_id) + mapManager.touch(r.wid, r.x, r.y, r.z, "blockchange[" + idx + "]"); + else + mapManager.touch(r.wid, r.x, r.y, r.z, "blockchange"); + } + } + + long now; + + synchronized(schedlock) { + cur_tick++; + now = System.nanoTime(); + tr = runqueue.peek(); + /* Nothing due to run */ + if((tr == null) || (tr.ticktorun > cur_tick) || ((now - cur_tick_starttime) > perTickLimit)) { + done = true; + } + else { + tr = runqueue.poll(); + } + } + while (!done) { + tr.future.run(); + + synchronized(schedlock) { + tr = runqueue.peek(); + now = System.nanoTime(); + /* Nothing due to run */ + if((tr == null) || (tr.ticktorun > cur_tick) || ((now - cur_tick_starttime) > perTickLimit)) { + done = true; + } + else { + tr = runqueue.poll(); + } + } + } + while(!msgqueue.isEmpty()) { + ChatMessage cm = msgqueue.poll(); + DynmapPlayer dp = null; + if(cm.sender != null) + dp = getOrAddPlayer(cm.sender); + else + dp = new ForgePlayer(null); + + core.listenerManager.processChatEvent(EventType.PLAYER_CHAT, dp, cm.message); + } + /* Check for idle worlds */ + if((cur_tick % 20) == 0) { + //TODO + //doIdleOutOfWorlds(); + } + } + + @Override + public boolean isModLoaded(String name) { + boolean loaded = ModList.get().isLoaded(name); + if (loaded) { + modsused.add(name); + } + return loaded; + } + @Override + public String getModVersion(String name) { + Optional mod = ModList.get().getModContainerById(name); // Try case sensitive lookup + if (mod.isPresent()) { + ArtifactVersion vi = mod.get().getModInfo().getVersion(); + return vi.getMajorVersion() + "." + vi.getMinorVersion() + "." + vi.getIncrementalVersion(); + } + return null; + } + @Override + public double getServerTPS() { + return tps; + } + + @Override + public String getServerIP() { + if (server.isSinglePlayer()) + return "0.0.0.0"; + else + return server.getServerHostname(); + } + @Override + public File getModContainerFile(String name) { + ModFileInfo mfi = ModList.get().getModFileById(name); // Try case sensitive lookup + if (mfi != null) { + return mfi.getFile().getFilePath().toFile(); + } + return null; + } + @Override + public List getModList() { + List mil = ModList.get().getMods(); + List lst = new ArrayList(); + for (ModInfo mi : mil) { + lst.add(mi.getModId()); + } + return lst; + } + + @Override + public Map getBlockIDMap() { + Map map = new HashMap(); + return map; + } + + @Override + public InputStream openResource(String modid, String rname) { + if (modid != null) { + ModContainer mc = ModList.get().getModContainerById(modid).get(); + Object mod = (mc != null) ? mc.getMod() : null; + if (mod != null) { + InputStream is = mod.getClass().getClassLoader().getResourceAsStream(rname); + if (is != null) { + return is; + } + } + } + List mcl = ModList.get().getMods(); + for (ModInfo mc : mcl) { + Object mod = ModList.get().getModContainerById(mc.getModId()).get().getMod(); + if (mod == null) continue; + InputStream is = mod.getClass().getClassLoader().getResourceAsStream(rname); + if (is != null) { + return is; + } + } + return null; + } + /** + * Get block unique ID map (module:blockid) + */ + @Override + public Map getBlockUniqueIDMap() { + HashMap map = new HashMap(); + return map; + } + /** + * Get item unique ID map (module:itemid) + */ + @Override + public Map getItemUniqueIDMap() { + HashMap map = new HashMap(); + return map; + } + + } + private static final Gson gson = new GsonBuilder().create(); + + public class TexturesPayload { + public long timestamp; + public String profileId; + public String profileName; + public boolean isPublic; + public Map textures; + + } + public class ProfileTexture { + public String url; + } + + /** + * Player access abstraction class + */ + public class ForgePlayer extends ForgeCommandSender implements DynmapPlayer + { + private EntityPlayer player; + private final String skinurl; + private final UUID uuid; + + + public ForgePlayer(EntityPlayer p) + { + player = p; + String url = null; + if (player != null) { + uuid = player.getUniqueID(); + GameProfile prof = player.getGameProfile(); + if (prof != null) { + Property textureProperty = Iterables.getFirst(prof.getProperties().get("textures"), null); + + if (textureProperty != null) { + TexturesPayload result = null; + try { + String json = new String(Base64.decodeBase64(textureProperty.getValue()), Charsets.UTF_8); + result = gson.fromJson(json, TexturesPayload.class); + } catch (JsonParseException e) { + } + if ((result != null) && (result.textures != null) && (result.textures.containsKey("SKIN"))) { + url = result.textures.get("SKIN").url; + } + } + } + } + else { + uuid = null; + } + skinurl = url; + } + @Override + public boolean isConnected() + { + return true; + } + @Override + public String getName() + { + if(player != null) + return player.getEntity().getName().getString(); + else + return "[Server]"; + } + @Override + public String getDisplayName() + { + if(player != null) { + if (displayName != null) { + try { + return (String) displayName.get(player); + } catch (IllegalArgumentException e) { + } catch (IllegalAccessException e) { + } + } + return player.getDisplayName().getUnformattedComponentText(); + } + else + return "[Server]"; + } + @Override + public boolean isOnline() + { + return true; + } + @Override + public DynmapLocation getLocation() + { + if (player == null) + { + return null; + } + + return toLoc(player.world, player.posX, player.posY, player.posZ); + } + @Override + public String getWorld() + { + if (player == null) + { + return null; + } + + if (player.world != null) + { + return DynmapPlugin.this.getWorld(player.world).getName(); + } + + return null; + } + @Override + public InetSocketAddress getAddress() + { + if((player != null) && (player instanceof EntityPlayerMP)) { + NetHandlerPlayServer nsh = ((EntityPlayerMP)player).connection; + if((nsh != null) && (getNetworkManager(nsh) != null)) { + SocketAddress sa = getNetworkManager(nsh).getRemoteAddress(); + if(sa instanceof InetSocketAddress) { + return (InetSocketAddress)sa; + } + } + } + return null; + } + @Override + public boolean isSneaking() + { + if (player != null) + { + return player.isSneaking(); + } + + return false; + } + @Override + public double getHealth() + { + if (player != null) + { + double h = player.getHealth(); + if(h > 20) h = 20; + return h; // Scale to 20 range + } + else + { + return 0; + } + } + @Override + public int getArmorPoints() + { + if (player != null) + { + return player.getTotalArmorValue(); + } + else + { + return 0; + } + } + @Override + public DynmapLocation getBedSpawnLocation() + { + return null; + } + @Override + public long getLastLoginTime() + { + return 0; + } + @Override + public long getFirstLoginTime() + { + return 0; + } + @Override + public boolean hasPrivilege(String privid) + { + if(player != null) + return hasPerm(player, privid); + return false; + } + @Override + public boolean isOp() + { + return DynmapPlugin.this.isOp(player.getEntity().getName().getString()); + } + @Override + public void sendMessage(String msg) + { + ITextComponent ichatcomponent = new TextComponentString(msg); + player.sendMessage(ichatcomponent); + } + @Override + public boolean isInvisible() { + if(player != null) { + return player.isInvisible(); + } + return false; + } + @Override + public int getSortWeight() { + Integer wt = sortWeights.get(getName()); + if (wt != null) + return wt; + return 0; + } + @Override + public void setSortWeight(int wt) { + if (wt == 0) { + sortWeights.remove(getName()); + } + else { + sortWeights.put(getName(), wt); + } + } + @Override + public boolean hasPermissionNode(String node) { + if(player != null) + return hasPermNode(player, node); + return false; + } + @Override + public String getSkinURL() { + return skinurl; + } + @Override + public UUID getUUID() { + return uuid; + } + } + /* Handler for generic console command sender */ + public class ForgeCommandSender implements DynmapCommandSender + { + private ICommandSource sender; + + protected ForgeCommandSender() { + sender = null; + } + + public ForgeCommandSender(ICommandSource send) + { + sender = send; + } + + @Override + public boolean hasPrivilege(String privid) + { + return true; + } + + @Override + public void sendMessage(String msg) + { + if(sender != null) { + ITextComponent ichatcomponent = new TextComponentString(msg); + sender.sendMessage(ichatcomponent); + } + } + + @Override + public boolean isConnected() + { + return false; + } + @Override + public boolean isOp() + { + return true; + } + @Override + public boolean hasPermissionNode(String node) { + return true; + } + } + + public void loadExtraBiomes(String mcver) { + int cnt = 0; + BiomeMap.loadWellKnownByVersion(mcver); + + Biome[] list = getBiomeList(); + + for(int i = 0; i < list.length; i++) { + Biome bb = list[i]; + if(bb != null) { + String id = bb.getRegistryName().getPath(); + float tmp = bb.getDefaultTemperature(), hum = bb.getDownfall(); + BiomeMap bmap = BiomeMap.byBiomeID(i); + if (bmap.isDefault()) { + BiomeMap m = new BiomeMap(i, id, tmp, hum); + Log.verboseinfo("Add custom biome [" + m.toString() + "] (" + i + ")"); + cnt++; + } + else { + bmap.setTemperature(tmp); + bmap.setRainfall(hum); + } + } + } + if(cnt > 0) + Log.info("Added " + cnt + " custom biome mappings"); + } + + private String[] getBiomeNames() { + Biome[] list = getBiomeList(); + String[] lst = new String[list.length]; + for(int i = 0; i < list.length; i++) { + Biome bb = list[i]; + if (bb != null) { + lst[i] = bb.getRegistryName().getPath(); + } + } + return lst; + } + + public void onEnable() + { + /* Get MC version */ + String mcver = server.getMinecraftVersion(); + + /* Load extra biomes */ + loadExtraBiomes(mcver); + /* Set up player login/quit event handler */ + registerPlayerLoginListener(); + /* Initialize permissions handler */ + permissions = FilePermissions.create(); + if(permissions == null) { + permissions = new OpPermissions(new String[] { "webchat", "marker.icons", "marker.list", "webregister", "stats", "hide.self", "show.self" }); + } + /* Get and initialize data folder */ + File dataDirectory = new File("dynmap"); + + if (dataDirectory.exists() == false) + { + dataDirectory.mkdirs(); + } + + /* Instantiate core */ + if (core == null) + { + core = new DynmapCore(); + } + + /* Inject dependencies */ + core.setPluginJarFile(DynmapMod.jarfile); + core.setPluginVersion(Version.VER); + core.setMinecraftVersion(mcver); + core.setDataFolder(dataDirectory); + core.setServer(fserver); + ForgeMapChunkCache.init(); + core.setTriggerDefault(TRIGGER_DEFAULTS); + core.setBiomeNames(getBiomeNames()); + + if(!core.initConfiguration(null)) + { + return; + } + DynmapCommonAPIListener.apiInitialized(core); + } + + public void onStart() { + initializeBlockStates(); + /* Enable core */ + if (!core.enableCore(null)) + { + return; + } + core_enabled = true; + VersionCheck.runCheck(core); + // Get per tick time limit + perTickLimit = core.getMaxTickUseMS() * 1000000; + // Prep TPS + lasttick = System.nanoTime(); + tps = 20.0; + + /* Register tick handler */ + if(!tickregistered) { + MinecraftForge.EVENT_BUS.register(fserver); + tickregistered = true; + } + + playerList = core.playerList; + sscache = new SnapshotCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache()); + /* Get map manager from core */ + mapManager = core.getMapManager(); + + /* Load saved world definitions */ + loadWorlds(); + + /* Initialized the currently loaded worlds */ + if(server.func_212370_w() != null) { + for (WorldServer world : server.func_212370_w()) { + ForgeWorld w = this.getWorld(world); + /*NOTYET - need rest of forge + if(DimensionManager.getWorld(world.provider.getDimensionId()) == null) { // If not loaded + w.setWorldUnloaded(); + } + */ + } + } + for(ForgeWorld w : worlds.values()) { + if (core.processWorldLoad(w)) { /* Have core process load first - fire event listeners if good load after */ + if(w.isLoaded()) { + core.listenerManager.processWorldEvent(EventType.WORLD_LOAD, w); + } + } + } + core.updateConfigHashcode(); + + /* Register our update trigger events */ + registerEvents(); + Log.info("Register events"); + /* Register command hander */ + Commands cm = server.getCommandManager(); + cm.getDispatcher().register(new DynmapCommand(this)); + cm.getDispatcher().register(new DmapCommand(this)); + cm.getDispatcher().register(new DmarkerCommand(this)); + cm.getDispatcher().register(new DynmapExpCommand(this)); + Log.info("Register commands"); + + /* Submit metrics to mcstats.org */ + initMetrics(); + + //DynmapCommonAPIListener.apiInitialized(core); + + Log.info("Enabled"); + } + + public void onDisable() + { + DynmapCommonAPIListener.apiTerminated(); + + //if (metrics != null) { + // metrics.stop(); + // metrics = null; + //} + /* Save worlds */ + saveWorlds(); + + /* Purge tick queue */ + fserver.runqueue.clear(); + + /* Disable core */ + core.disableCore(); + core_enabled = false; + + if (sscache != null) + { + sscache.cleanup(); + sscache = null; + } + + Log.info("Disabled"); + } + + void onCommand(ICommandSource sender, String cmd, String[] args) + { + DynmapCommandSender dsender; + + if (sender instanceof EntityPlayer) + { + dsender = getOrAddPlayer((EntityPlayer)sender); + } + else + { + dsender = new ForgeCommandSender(sender); + } + + core.processCommand(dsender, cmd, cmd, args); + } + + private DynmapLocation toLoc(World worldObj, double x, double y, double z) + { + return new DynmapLocation(DynmapPlugin.this.getWorld(worldObj).getName(), x, y, z); + } + + public class PlayerTracker { + @SubscribeEvent + public void onPlayerLogin(PlayerLoggedInEvent event) { + if(!core_enabled) return; + final DynmapPlayer dp = getOrAddPlayer(event.getPlayer()); + /* This event can be called from off server thread, so push processing there */ + core.getServer().scheduleServerTask(new Runnable() { + public void run() { + core.listenerManager.processPlayerEvent(EventType.PLAYER_JOIN, dp); + } + }, 2); + } + @SubscribeEvent + public void onPlayerLogout(PlayerLoggedOutEvent event) { + if(!core_enabled) return; + final DynmapPlayer dp = getOrAddPlayer(event.getPlayer()); + final String name = event.getPlayer().getEntity().getName().getString(); + /* This event can be called from off server thread, so push processing there */ + core.getServer().scheduleServerTask(new Runnable() { + public void run() { + core.listenerManager.processPlayerEvent(EventType.PLAYER_QUIT, dp); + players.remove(name); + } + }, 0); + } + @SubscribeEvent + public void onPlayerChangedDimension(PlayerChangedDimensionEvent event) { + if(!core_enabled) return; + getOrAddPlayer(event.getPlayer()); // Freshen player object reference + } + @SubscribeEvent + public void onPlayerRespawn(PlayerRespawnEvent event) { + if(!core_enabled) return; + getOrAddPlayer(event.getPlayer()); // Freshen player object reference + } + } + private PlayerTracker playerTracker = null; + + private void registerPlayerLoginListener() + { + if (playerTracker == null) { + playerTracker = new PlayerTracker(); + MinecraftForge.EVENT_BUS.register(playerTracker); + } + } + + public class WorldTracker { + @SubscribeEvent + public void handleWorldLoad(WorldEvent.Load event) { + if(!core_enabled) return; + IWorld w = event.getWorld(); + if(!(w instanceof WorldServer)) return; + final ForgeWorld fw = getWorld(w); + // This event can be called from off server thread, so push processing there + core.getServer().scheduleServerTask(new Runnable() { + public void run() { + if(core.processWorldLoad(fw)) // Have core process load first - fire event listeners if good load after + core.listenerManager.processWorldEvent(EventType.WORLD_LOAD, fw); + } + }, 0); + } + @SubscribeEvent + public void handleWorldUnload(WorldEvent.Unload event) { + if(!core_enabled) return; + IWorld w = event.getWorld(); + if(!(w instanceof WorldServer)) return; + final ForgeWorld fw = getWorld(w); + if(fw != null) { + // This event can be called from off server thread, so push processing there + core.getServer().scheduleServerTask(new Runnable() { + public void run() { + core.listenerManager.processWorldEvent(EventType.WORLD_UNLOAD, fw); + core.processWorldUnload(fw); + } + }, 0); + // Set world unloaded (needs to be immediate, since it may be invalid after event) + fw.setWorldUnloaded(); + // Clean up tracker + WorldUpdateTracker wut = updateTrackers.remove(fw.getName()); + if(wut != null) wut.world = null; + } + } + + @SubscribeEvent + public void handleChunkLoad(ChunkEvent.Load event) { + if(!core_enabled) return; + if(!onchunkgenerate) return; + IWorld w = event.getWorld(); + if(!(w instanceof WorldServer)) return; + IChunk c = event.getChunk(); + if((c != null) /*TODO && (!c.isTerrainPopulated())*/) { // If new chunk? + ForgeWorld fw = getWorld(w, false); + if(fw == null) { + return; + } + int ymax = 0; + ChunkSection[] sections = c.getSections(); + for(int i = 0; i < sections.length; i++) { + if((sections[i] != null) && (sections[i].isEmpty() == false)) { + ymax = 16*(i+1); + } + } + ChunkPos cp = c.getPos(); + int x = cp.x << 4; + int z = cp.z << 4; + if(ymax > 0) { + mapManager.touchVolume(fw.getName(), x, 0, z, x+15, ymax, z+16, "chunkgenerate"); + } + } + } + + /*TODO + @SubscribeEvent + public void handleChunkPopulate(PopulateChunkEvent.Post event) { + if(!core_enabled) return; + if(!onchunkpopulate) return; + World w = event.getWorld(); + if(!(w instanceof WorldServer)) return; + Chunk c = w.getChunkFromChunkCoords(event.getChunkX(), event.getChunkZ()); + int ymin = 0, ymax = 0; + if(c != null) { + ForgeWorld fw = getWorld(event.getWorld(), false); + if (fw == null) return; + + ExtendedBlockStorage[] sections = c.getBlockStorageArray(); + for(int i = 0; i < sections.length; i++) { + if((sections[i] != null) && (sections[i].isEmpty() == false)) { + ymax = 16*(i+1); + } + } + int x = c.x << 4; + int z = c.z << 4; + if(ymax > 0) + mapManager.touchVolume(fw.getName(), x, ymin, z, x+15, ymax, z+16, "chunkpopulate"); + } + } + */ + } + + private boolean onblockchange = false; + private boolean onlightingchange = false; + private boolean onchunkpopulate = false; + private boolean onchunkgenerate = false; + private boolean onblockchange_with_id = false; + + + public class WorldUpdateTracker implements IWorldEventListener { + String worldid; + IWorld world; + @Override + public void notifyLightSet(BlockPos pos) { + if(sscache != null) + sscache.invalidateSnapshot(worldid, pos.getX(), pos.getY(), pos.getZ()); + if(onlightingchange) { + mapManager.touch(worldid, pos.getX(), pos.getY(), pos.getZ(), "lightingchange"); + } + } + @Override + public void markBlockRangeForRenderUpdate(int x1, int y1, int z1, int x2, int y2, int z2) { + } + @Override + public void onEntityAdded(Entity entityIn) { + } + @Override + public void onEntityRemoved(Entity entityIn) { + } + @Override + public void sendBlockBreakProgress(int breakerId, BlockPos pos, + int progress) { + } + @Override + public void broadcastSound(int p_180440_1_, BlockPos p_180440_2_, + int p_180440_3_) { + } + @Override + public void playSoundToAllNearExcept(EntityPlayer player, + SoundEvent soundIn, SoundCategory category, double x, double y, + double z, float volume, float pitch) { + } + @Override + public void playRecord(SoundEvent soundIn, BlockPos pos) { + } + @Override + public void playEvent(EntityPlayer arg0, int arg1, BlockPos arg2, int arg3) { + } + @Override + public void notifyBlockUpdate(IBlockReader worldIn, BlockPos pos, IBlockState oldState, IBlockState newState, + int flags) { + if(sscache != null) + sscache.invalidateSnapshot(worldid, pos.getX(), pos.getY(), pos.getZ()); + if(onblockchange) { + BlockUpdateRec r = new BlockUpdateRec(); + r.w = world; + r.wid = worldid; + r.x = pos.getX(); r.y = pos.getY(); r.z = pos.getZ(); + blockupdatequeue.add(r); + } + } + @Override + public void addParticle(IParticleData particleData, boolean alwaysRender, double x, double y, double z, + double xSpeed, double ySpeed, double zSpeed) { + // TODO Auto-generated method stub + + } + @Override + public void addParticle(IParticleData particleData, boolean ignoreRange, boolean minimizeLevel, double x, + double y, double z, double xSpeed, double ySpeed, double zSpeed) { + // TODO Auto-generated method stub + + } + } + + private WorldTracker worldTracker = null; + private HashMap updateTrackers = new HashMap(); + + private void registerEvents() + { + if(worldTracker == null) { + worldTracker = new WorldTracker(); + MinecraftForge.EVENT_BUS.register(worldTracker); + } + // To trigger rendering. + onblockchange = core.isTrigger("blockupdate"); + onlightingchange = core.isTrigger("lightingupdate"); + onchunkpopulate = core.isTrigger("chunkpopulate"); + onchunkgenerate = core.isTrigger("chunkgenerate"); + onblockchange_with_id = core.isTrigger("blockupdate-with-id"); + if(onblockchange_with_id) + onblockchange = true; + } + + private ForgeWorld getWorldByName(String name) { + return worlds.get(name); + } + + private ForgeWorld getWorld(IWorld w) { + return getWorld(w, true); + } + + private ForgeWorld getWorld(IWorld w, boolean add_if_not_found) { + if(last_world == w) { + return last_fworld; + } + String wname = ForgeWorld.getWorldName(w); + + for(ForgeWorld fw : worlds.values()) { + if(fw.getRawName().equals(wname)) { + last_world = w; + last_fworld = fw; + if(fw.isLoaded() == false) { + fw.setWorldLoaded(w); + // Add tracker + WorldUpdateTracker wit = new WorldUpdateTracker(); + wit.worldid = fw.getName(); + wit.world = w; + updateTrackers.put(fw.getName(), wit); + w.getWorld().addEventListener(wit); + } + return fw; + } + } + ForgeWorld fw = null; + if(add_if_not_found) { + /* Add to list if not found */ + fw = new ForgeWorld(w); + worlds.put(fw.getName(), fw); + // Add tracker + WorldUpdateTracker wit = new WorldUpdateTracker(); + wit.worldid = fw.getName(); + wit.world = w; + updateTrackers.put(fw.getName(), wit); + w.getWorld().addEventListener(wit); + } + last_world = w; + last_fworld = fw; + return fw; + } + + /* + private void removeWorld(ForgeWorld fw) { + WorldUpdateTracker wit = updateTrackers.remove(fw.getName()); + if(wit != null) { + //fw.getWorld().removeWorldAccess(wit); + } + worlds.remove(fw.getName()); + if(last_fworld == fw) { + last_world = null; + last_fworld = null; + } + } + */ + + private void initMetrics() { + /* + try { + Mod m = DynmapMod.class.getAnnotation(Mod.class); + metrics = new ForgeMetrics(m.name(), m.version()); + ; + ForgeMetrics.Graph features = metrics.createGraph("Features Used"); + + features.addPlotter(new ForgeMetrics.Plotter("Internal Web Server") { + @Override + public int getValue() { + if (!core.configuration.getBoolean("disable-webserver", false)) + return 1; + return 0; + } + }); + features.addPlotter(new ForgeMetrics.Plotter("Login Security") { + @Override + public int getValue() { + if(core.configuration.getBoolean("login-enabled", false)) + return 1; + return 0; + } + }); + features.addPlotter(new ForgeMetrics.Plotter("Player Info Protected") { + @Override + public int getValue() { + if(core.player_info_protected) + return 1; + return 0; + } + }); + + ForgeMetrics.Graph maps = metrics.createGraph("Map Data"); + maps.addPlotter(new ForgeMetrics.Plotter("Worlds") { + @Override + public int getValue() { + if(core.mapManager != null) + return core.mapManager.getWorlds().size(); + return 0; + } + }); + maps.addPlotter(new ForgeMetrics.Plotter("Maps") { + @Override + public int getValue() { + int cnt = 0; + if(core.mapManager != null) { + for(DynmapWorld w :core.mapManager.getWorlds()) { + cnt += w.maps.size(); + } + } + return cnt; + } + }); + maps.addPlotter(new ForgeMetrics.Plotter("HD Maps") { + @Override + public int getValue() { + int cnt = 0; + if(core.mapManager != null) { + for(DynmapWorld w :core.mapManager.getWorlds()) { + for(MapType mt : w.maps) { + if(mt instanceof HDMap) { + cnt++; + } + } + } + } + return cnt; + } + }); + for (String mod : modsused) { + features.addPlotter(new ForgeMetrics.Plotter(mod + " Blocks") { + @Override + public int getValue() { + return 1; + } + }); + } + + metrics.start(); + } catch (IOException e) { + // Failed to submit the stats :-( + } + */ + } + + private void saveWorlds() { + File f = new File(core.getDataFolder(), "forgeworlds.yml"); + ConfigurationNode cn = new ConfigurationNode(f); + ArrayList> lst = new ArrayList>(); + for(DynmapWorld fw : core.mapManager.getWorlds()) { + HashMap vals = new HashMap(); + vals.put("name", fw.getRawName()); + vals.put("height", fw.worldheight); + vals.put("sealevel", fw.sealevel); + vals.put("nether", fw.isNether()); + vals.put("the_end", ((ForgeWorld)fw).isTheEnd()); + vals.put("title", fw.getTitle()); + lst.add(vals); + } + cn.put("worlds", lst); + cn.put("isMCPC", isMCPC); + cn.put("useSaveFolderAsName", useSaveFolder); + cn.put("maxWorldHeight", ForgeWorld.getMaxWorldHeight()); + + cn.save(); + } + private void loadWorlds() { + isMCPC = server.getServerModName().contains("mcpc"); + File f = new File(core.getDataFolder(), "forgeworlds.yml"); + if(f.canRead() == false) { + useSaveFolder = true; + if (isMCPC) { + ForgeWorld.setMCPCMapping(); + } + else { + ForgeWorld.setSaveFolderMapping(); + } + return; + } + ConfigurationNode cn = new ConfigurationNode(f); + cn.load(); + // If defined, use maxWorldHeight + ForgeWorld.setMaxWorldHeight(cn.getInteger("maxWorldHeight", 256)); + + // If existing, only switch to save folder if MCPC+ + useSaveFolder = isMCPC; + // If setting defined, use it + if (cn.containsKey("useSaveFolderAsName")) { + useSaveFolder = cn.getBoolean("useSaveFolderAsName", useSaveFolder); + } + if (isMCPC) { + ForgeWorld.setMCPCMapping(); + } + else if (useSaveFolder) { + ForgeWorld.setSaveFolderMapping(); + } + // If inconsistent between MCPC and non-MCPC + if (isMCPC != cn.getBoolean("isMCPC", false)) { + return; + } + List> lst = cn.getMapList("worlds"); + if(lst == null) { + Log.warning("Discarding bad forgeworlds.yml"); + return; + } + + for(Map world : lst) { + try { + String name = (String)world.get("name"); + int height = (Integer)world.get("height"); + int sealevel = (Integer)world.get("sealevel"); + boolean nether = (Boolean)world.get("nether"); + boolean theend = (Boolean)world.get("the_end"); + String title = (String)world.get("title"); + if(name != null) { + ForgeWorld fw = new ForgeWorld(name, height, sealevel, nether, theend, title); + fw.setWorldUnloaded(); + core.processWorldLoad(fw); + worlds.put(fw.getName(), fw); + } + } catch (Exception x) { + Log.warning("Unable to load saved worlds from forgeworlds.yml"); + return; + } + } + } + public void serverStarted() { + this.onStart(); + if (core != null) { + core.serverStarted(); + } + } +} + +class DynmapCommandHandler extends LiteralArgumentBuilder +{ + private String cmd; + private DynmapPlugin plugin; + + public DynmapCommandHandler(String cmd, DynmapPlugin p) + { + super(cmd); + this.cmd = cmd; + this.plugin = p; + } + +// @Override + public void execute(MinecraftServer server, ICommandSource sender, + String[] args) throws CommandException { + plugin.onCommand(sender, cmd, args); + } + +// @Override + public String getUsage(ICommandSource arg0) { + return "Run /" + cmd + " help for details on using command"; + } +} + +class DynmapCommand extends DynmapCommandHandler { + DynmapCommand(DynmapPlugin p) { + super("dynmap", p); + } +} +class DmapCommand extends DynmapCommandHandler { + DmapCommand(DynmapPlugin p) { + super("dmap", p); + } +} +class DmarkerCommand extends DynmapCommandHandler { + DmarkerCommand(DynmapPlugin p) { + super("dmarker", p); + } +} +class DynmapExpCommand extends DynmapCommandHandler { + DynmapExpCommand(DynmapPlugin p) { + super("dynmapexp", p); + } +} + diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeMapChunkCache.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeMapChunkCache.java new file mode 100644 index 00000000..3d64c4b9 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeMapChunkCache.java @@ -0,0 +1,1588 @@ +package org.dynmap.forge_1_13_2; + +import java.io.DataInputStream; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.ListIterator; +import java.util.Map; +import java.util.Set; + +import net.minecraft.nbt.CompressedStreamTools; +import net.minecraft.nbt.INBTBase; +import net.minecraft.nbt.NBTTagByte; +import net.minecraft.nbt.NBTTagByteArray; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagDouble; +import net.minecraft.nbt.NBTTagFloat; +import net.minecraft.nbt.NBTTagInt; +import net.minecraft.nbt.NBTTagIntArray; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.nbt.NBTTagLong; +import net.minecraft.nbt.NBTTagShort; +import net.minecraft.nbt.NBTTagString; +import net.minecraft.util.math.ChunkPos; +import net.minecraft.world.World; +import net.minecraft.world.WorldServer; +import net.minecraft.world.biome.Biome; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraft.world.chunk.storage.AnvilChunkLoader; +import net.minecraft.world.chunk.storage.IChunkLoader; +import net.minecraft.world.chunk.storage.RegionFileCache; +import net.minecraft.world.gen.ChunkProviderServer; + +import org.dynmap.DynmapChunk; +import org.dynmap.DynmapCore; +import org.dynmap.DynmapWorld; +import org.dynmap.Log; +import org.dynmap.common.BiomeMap; +import org.dynmap.forge_1_13_2.SnapshotCache.SnapshotRec; +import org.dynmap.hdmap.HDBlockModels; +import org.dynmap.renderer.DynmapBlockState; +import org.dynmap.renderer.RenderPatchFactory; +import org.dynmap.utils.DynIntHashMap; +import org.dynmap.utils.MapChunkCache; +import org.dynmap.utils.MapIterator; +import org.dynmap.utils.BlockStep; +import org.dynmap.utils.VisibilityLimit; + +/** + * Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread + */ +public class ForgeMapChunkCache extends MapChunkCache +{ + private static boolean init = false; + private static Field unloadqueue = null; + private static Field currentchunkloader = null; + private static Field updateEntityTick = null; + /* AnvilChunkLoader fields */ + private static Field chunksToRemove = null; // Map + private static Field pendingAnvilChunksCoordinates = null; // Set + private static Method writechunktonbt = null; // writeChunkToNBT(Chunk c, World w, NBTTagCompound nbt) + + /* AnvilChunkLoaderPending fields */ + private static Field chunkCoord = null; + private static Field nbtTag = null; + + private World w; + private DynmapWorld dw; + private ChunkProviderServer cps; + private int nsect; + private List chunks; + private ListIterator iterator; + private int x_min, x_max, z_min, z_max; + private int x_dim; + private boolean biome, biomeraw, highesty, blockdata; + private HiddenChunkStyle hidestyle = HiddenChunkStyle.FILL_AIR; + private List visible_limits = null; + private List hidden_limits = null; + private boolean isempty = true; + private int snapcnt; + private ChunkSnapshot[] snaparray; /* Index = (x-x_min) + ((z-z_min)*x_dim) */ + private DynIntHashMap[] snaptile; + private byte[][] sameneighborbiomecnt; + private BiomeMap[][] biomemap; + private boolean[][] isSectionNotEmpty; /* Indexed by snapshot index, then by section index */ + private Set queue = null; + + private static final BlockStep unstep[] = { BlockStep.X_MINUS, BlockStep.Y_MINUS, BlockStep.Z_MINUS, + BlockStep.X_PLUS, BlockStep.Y_PLUS, BlockStep.Z_PLUS + }; + + private static BiomeMap[] biome_to_bmap; + + private static final int getIndexInChunk(int cx, int cy, int cz) { + return (cy << 8) | (cz << 4) | cx; + } + + /** + * Iterator for traversing map chunk cache (base is for non-snapshot) + */ + public class OurMapIterator implements MapIterator + { + private int x, y, z, chunkindex, bx, bz; + private ChunkSnapshot snap; + private BlockStep laststep; + private DynmapBlockState blk; + private final int worldheight; + private final int x_base; + private final int z_base; + + OurMapIterator(int x0, int y0, int z0) + { + x_base = x_min << 4; + z_base = z_min << 4; + + if (biome) + { + biomePrep(); + } + + initialize(x0, y0, z0); + worldheight = w.getHeight(); + } + @Override + public final void initialize(int x0, int y0, int z0) + { + this.x = x0; + this.y = y0; + this.z = z0; + this.chunkindex = ((x >> 4) - x_min) + (((z >> 4) - z_min) * x_dim); + this.bx = x & 0xF; + this.bz = z & 0xF; + + if((chunkindex >= snapcnt) || (chunkindex < 0)) { + snap = EMPTY; + } + else { + snap = snaparray[chunkindex]; + } + + laststep = BlockStep.Y_MINUS; + + if ((y >= 0) && (y < worldheight)) + { + blk = null; + } + else + { + blk = DynmapBlockState.AIR; + } + } + @Override + public int getBlockSkyLight() + { + try + { + return snap.getBlockSkyLight(bx, y, bz); + } + catch (ArrayIndexOutOfBoundsException aioobx) + { + return 15; + } + } + @Override + public final int getBlockEmittedLight() + { + try + { + return snap.getBlockEmittedLight(bx, y, bz); + } + catch (ArrayIndexOutOfBoundsException aioobx) + { + return 0; + } + } + private void biomePrep() + { + if (sameneighborbiomecnt != null) + { + return; + } + + int x_size = x_dim << 4; + int z_size = (z_max - z_min + 1) << 4; + sameneighborbiomecnt = new byte[x_size][]; + biomemap = new BiomeMap[x_size][]; + + for (int i = 0; i < x_size; i++) + { + sameneighborbiomecnt[i] = new byte[z_size]; + biomemap[i] = new BiomeMap[z_size]; + } + + for (int i = 0; i < x_size; i++) + { + for (int j = 0; j < z_size; j++) + { + if (j == 0) + initialize(i + x_base, 64, z_base); + else + stepPosition(BlockStep.Z_PLUS); + + int bb = snap.getBiome(bx, bz); + BiomeMap bm = BiomeMap.byBiomeID(bb); + + biomemap[i][j] = bm; + int cnt = 0; + + if (i > 0) + { + if (bm == biomemap[i - 1][j]) /* Same as one to left */ + { + cnt++; + sameneighborbiomecnt[i - 1][j]++; + } + + if ((j > 0) && (bm == biomemap[i - 1][j - 1])) + { + cnt++; + sameneighborbiomecnt[i - 1][j - 1]++; + } + + if ((j < (z_size - 1)) && (bm == biomemap[i - 1][j + 1])) + { + cnt++; + sameneighborbiomecnt[i - 1][j + 1]++; + } + } + + if ((j > 0) && (biomemap[i][j] == biomemap[i][j - 1])) /* Same as one to above */ + { + cnt++; + sameneighborbiomecnt[i][j - 1]++; + } + + sameneighborbiomecnt[i][j] = (byte)cnt; + } + } + } + @Override + public final BiomeMap getBiome() + { + try + { + return biomemap[x - x_base][z - z_base]; + } + catch (Exception ex) + { + return BiomeMap.NULL; + } + } + @Override + public final int getSmoothGrassColorMultiplier(int[] colormap) + { + int mult = 0xFFFFFF; + + try + { + int rx = x - x_base; + int rz = z - z_base; + BiomeMap bm = biomemap[rx][rz]; + + if (sameneighborbiomecnt[rx][rz] >= (byte)8) /* All neighbors same? */ + { + mult = bm.getModifiedGrassMultiplier(colormap[bm.biomeLookup()]); + } + else + { + int raccum = 0; + int gaccum = 0; + int baccum = 0; + + for (int xoff = -1; xoff < 2; xoff++) + { + for (int zoff = -1; zoff < 2; zoff++) + { + bm = biomemap[rx + xoff][rz + zoff]; + int rmult = bm.getModifiedGrassMultiplier(colormap[bm.biomeLookup()]); + raccum += (rmult >> 16) & 0xFF; + gaccum += (rmult >> 8) & 0xFF; + baccum += rmult & 0xFF; + } + } + + mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9); + } + } + catch (Exception x) + { + mult = 0xFFFFFF; + } + + return mult; + } + @Override + public final int getSmoothFoliageColorMultiplier(int[] colormap) + { + int mult = 0xFFFFFF; + + try + { + int rx = x - x_base; + int rz = z - z_base; + BiomeMap bm = biomemap[rx][rz]; + + if (sameneighborbiomecnt[rx][rz] >= (byte)8) /* All neighbors same? */ + { + mult = bm.getModifiedFoliageMultiplier(colormap[bm.biomeLookup()]); + } + else + { + int raccum = 0; + int gaccum = 0; + int baccum = 0; + + for (int xoff = -1; xoff < 2; xoff++) + { + for (int zoff = -1; zoff < 2; zoff++) + { + bm = biomemap[rx + xoff][rz + zoff]; + int rmult = bm.getModifiedFoliageMultiplier(colormap[bm.biomeLookup()]); + raccum += (rmult >> 16) & 0xFF; + gaccum += (rmult >> 8) & 0xFF; + baccum += rmult & 0xFF; + } + } + + mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9); + } + } + catch (Exception x) + { + mult = 0xFFFFFF; + } + + return mult; + } + @Override + public final int getSmoothColorMultiplier(int[] colormap, int[] swampmap) + { + int mult = 0xFFFFFF; + + try + { + int rx = x - x_base; + int rz = z - z_base; + BiomeMap bm = biomemap[rx][rz]; + + if (sameneighborbiomecnt[rx][rz] >= (byte)8) /* All neighbors same? */ + { + if (bm == BiomeMap.SWAMPLAND) + { + mult = swampmap[bm.biomeLookup()]; + } + else + { + mult = colormap[bm.biomeLookup()]; + } + } + else + { + int raccum = 0; + int gaccum = 0; + int baccum = 0; + + for (int xoff = -1; xoff < 2; xoff++) + { + for (int zoff = -1; zoff < 2; zoff++) + { + bm = biomemap[rx + xoff][rz + zoff]; + int rmult; + + if (bm == BiomeMap.SWAMPLAND) + { + rmult = swampmap[bm.biomeLookup()]; + } + else + { + rmult = colormap[bm.biomeLookup()]; + } + + raccum += (rmult >> 16) & 0xFF; + gaccum += (rmult >> 8) & 0xFF; + baccum += rmult & 0xFF; + } + } + + mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9); + } + } + catch (Exception x) + { + mult = 0xFFFFFF; + } + + return mult; + } + @Override + public final int getSmoothWaterColorMultiplier() + { + try + { + int rx = x - x_base; + int rz = z - z_base; + BiomeMap bm = biomemap[rx][rz]; + + if (sameneighborbiomecnt[rx][rz] >= (byte)8) /* All neighbors same? */ + { + return bm.getWaterColorMult(); + } + + int raccum = 0; + int gaccum = 0; + int baccum = 0; + + for (int xoff = -1; xoff < 2; xoff++) + { + for (int zoff = -1; zoff < 2; zoff++) + { + bm = biomemap[rx + xoff][rz + zoff]; + int mult = bm.getWaterColorMult(); + raccum += (mult >> 16) & 0xFF; + gaccum += (mult >> 8) & 0xFF; + baccum += mult & 0xFF; + } + } + + return ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9); + } + catch (Exception x) + { + return 0xFFFFFF; + } + } + @Override + public final int getSmoothWaterColorMultiplier(int[] colormap) + { + int mult = 0xFFFFFF; + + try + { + int rx = x - x_base; + int rz = z - z_base; + BiomeMap bm = biomemap[rx][rz]; + + if (sameneighborbiomecnt[rx][rz] >= (byte)8) /* All neighbors same? */ + { + mult = colormap[bm.biomeLookup()]; + } + else + { + int raccum = 0; + int gaccum = 0; + int baccum = 0; + + for (int xoff = -1; xoff < 2; xoff++) + { + for (int zoff = -1; zoff < 2; zoff++) + { + bm = biomemap[rx + xoff][rz + zoff]; + int rmult = colormap[bm.biomeLookup()]; + raccum += (rmult >> 16) & 0xFF; + gaccum += (rmult >> 8) & 0xFF; + baccum += rmult & 0xFF; + } + } + + mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9); + } + } + catch (Exception x) + { + mult = 0xFFFFFF; + } + + return mult; + } + /** + * Step current position in given direction + */ + @Override + public final void stepPosition(BlockStep step) + { + blk = null; + + switch (step.ordinal()) + { + case 0: + x++; + bx++; + + if (bx == 16) /* Next chunk? */ + { + bx = 0; + chunkindex++; + if((chunkindex >= snapcnt) || (chunkindex < 0)) { + snap = EMPTY; + } + else { + snap = snaparray[chunkindex]; + } + } + + break; + + case 1: + y++; + + if (y >= worldheight) + { + blk = DynmapBlockState.AIR; + } + + break; + + case 2: + z++; + bz++; + + if (bz == 16) /* Next chunk? */ + { + bz = 0; + chunkindex += x_dim; + if((chunkindex >= snapcnt) || (chunkindex < 0)) { + snap = EMPTY; + } + else { + snap = snaparray[chunkindex]; + } + } + break; + + case 3: + x--; + bx--; + + if (bx == -1) /* Next chunk? */ + { + bx = 15; + chunkindex--; + if((chunkindex >= snapcnt) || (chunkindex < 0)) { + snap = EMPTY; + } + else { + snap = snaparray[chunkindex]; + } + } + + break; + + case 4: + y--; + + if (y < 0) + { + blk = DynmapBlockState.AIR; + } + + break; + + case 5: + z--; + bz--; + + if (bz == -1) /* Next chunk? */ + { + bz = 15; + chunkindex -= x_dim; + if((chunkindex >= snapcnt) || (chunkindex < 0)) { + snap = EMPTY; + } + else { + snap = snaparray[chunkindex]; + } + } + break; + } + + laststep = step; + } + /** + * Unstep current position to previous position + */ + @Override + public BlockStep unstepPosition() + { + BlockStep ls = laststep; + stepPosition(unstep[ls.ordinal()]); + return ls; + } + /** + * Unstep current position in oppisite director of given step + */ + @Override + public void unstepPosition(BlockStep s) + { + stepPosition(unstep[s.ordinal()]); + } + @Override + public final void setY(int y) + { + if (y > this.y) + { + laststep = BlockStep.Y_PLUS; + } + else + { + laststep = BlockStep.Y_MINUS; + } + + this.y = y; + + if ((y < 0) || (y >= worldheight)) + { + blk = DynmapBlockState.AIR; + } + else + { + blk = null; + } + } + @Override + public final int getX() + { + return x; + } + @Override + public final int getY() + { + return y; + } + @Override + public final int getZ() + { + return z; + } + @Override + public final DynmapBlockState getBlockTypeAt(BlockStep s) + { + if (s == BlockStep.Y_MINUS) + { + if (y > 0) + { + return snap.getBlockType(bx, y - 1, bz); + } + } + else if (s == BlockStep.Y_PLUS) + { + if (y < (worldheight - 1)) + { + return snap.getBlockType(bx, y + 1, bz); + } + } + else + { + BlockStep ls = laststep; + stepPosition(s); + DynmapBlockState tid = snap.getBlockType(bx, y, bz); + unstepPosition(); + laststep = ls; + return tid; + } + + return DynmapBlockState.AIR; + } + @Override + public BlockStep getLastStep() + { + return laststep; + } + @Override + public int getWorldHeight() + { + return worldheight; + } + @Override + public long getBlockKey() + { + return (((chunkindex * worldheight) + y) << 8) | (bx << 4) | bz; + } + @Override + public final boolean isEmptySection() + { + try + { + return !isSectionNotEmpty[chunkindex][y >> 4]; + } + catch (Exception x) + { + initSectionData(chunkindex); + return !isSectionNotEmpty[chunkindex][y >> 4]; + } + } + @Override + public RenderPatchFactory getPatchFactory() { + return HDBlockModels.getPatchDefinitionFactory(); + } + @Override + public Object getBlockTileEntityField(String fieldId) { + try { + int idx = getIndexInChunk(bx,y,bz); + Object[] vals = (Object[])snaptile[chunkindex].get(idx); + for (int i = 0; i < vals.length; i += 2) { + if (vals[i].equals(fieldId)) { + return vals[i+1]; + } + } + } catch (Exception x) { + } + return null; + } + @Override + public DynmapBlockState getBlockTypeAt(int xoff, int yoff, int zoff) { + int xx = this.x + xoff; + int yy = this.y + yoff; + int zz = this.z + zoff; + int idx = ((xx >> 4) - x_min) + (((zz >> 4) - z_min) * x_dim); + try { + return snaparray[idx].getBlockType(xx & 0xF, yy, zz & 0xF); + } catch (Exception x) { + return DynmapBlockState.AIR; + } + } + @Override + public Object getBlockTileEntityFieldAt(String fieldId, int xoff, + int yoff, int zoff) { + return null; + } + @Override + public long getInhabitedTicks() { + try { + return snap.getInhabitedTicks(); + } catch (Exception x) { + return 0; + } + } + @Override + public DynmapBlockState getBlockType() { + if (blk == null) { + blk = snap.getBlockType(bx, y, bz); + } + return blk; + } + } + + private class OurEndMapIterator extends OurMapIterator + { + OurEndMapIterator(int x0, int y0, int z0) + { + super(x0, y0, z0); + } + @Override + public final int getBlockSkyLight() + { + return 15; + } + } + /** + * Chunk cache for representing unloaded chunk (or air) + */ + private static class EmptyChunk extends ChunkSnapshot + { + public EmptyChunk() + { + super(256, 0, 0, 0, 0); + } + /* Need these for interface, but not used */ + @Override + public int getX() + { + return 0; + } + @Override + public int getZ() + { + return 0; + } + @Override + public final DynmapBlockState getBlockType(int x, int y, int z) + { + return DynmapBlockState.AIR; + } + @Override + public final int getBlockSkyLight(int x, int y, int z) + { + return 15; + } + @Override + public final int getBlockEmittedLight(int x, int y, int z) + { + return 0; + } + @Override + public final int getHighestBlockYAt(int x, int z) + { + return 0; + } + @Override + public int getBiome(int x, int z) + { + return -1; + } + @Override + public boolean isSectionEmpty(int sy) + { + return true; + } + } + + /** + * Chunk cache for representing generic stone chunk + */ + private static class PlainChunk extends ChunkSnapshot + { + private DynmapBlockState fill; + + PlainChunk(String fill) + { + super(256, 0, 0, 0, 0); + this.fill = DynmapBlockState.getBaseStateByName(fill); + } + /* Need these for interface, but not used */ + @Override + public int getX() + { + return 0; + } + @Override + public int getZ() + { + return 0; + } + @Override + public int getBiome(int x, int z) + { + return -1; + } + @Override + public final DynmapBlockState getBlockType(int x, int y, int z) + { + if (y < 64) + { + return fill; + } + + return DynmapBlockState.AIR; + } + @Override + public final int getBlockSkyLight(int x, int y, int z) + { + if (y < 64) + { + return 0; + } + + return 15; + } + @Override + public final int getBlockEmittedLight(int x, int y, int z) + { + return 0; + } + @Override + public final int getHighestBlockYAt(int x, int z) + { + return 64; + } + @Override + public boolean isSectionEmpty(int sy) + { + return (sy < 4); + } + } + + private static final EmptyChunk EMPTY = new EmptyChunk(); + private static final PlainChunk STONE = new PlainChunk(DynmapBlockState.STONE_BLOCK); + private static final PlainChunk OCEAN = new PlainChunk(DynmapBlockState.WATER_BLOCK); + + + public static void init() { + if (!init) + { + Field[] f = ChunkProviderServer.class.getDeclaredFields(); + + for(int i = 0; i < f.length; i++) { + if((unloadqueue == null) && f[i].getType().isAssignableFrom(java.util.Set.class)) { + unloadqueue = f[i]; + //Log.info("Found unloadqueue - " + f[i].getName()); + unloadqueue.setAccessible(true); + } + else if((currentchunkloader == null) && f[i].getType().isAssignableFrom(IChunkLoader.class)) { + currentchunkloader = f[i]; + //Log.info("Found currentchunkprovider - " + f[i].getName()); + currentchunkloader.setAccessible(true); + } + } + + f = WorldServer.class.getDeclaredFields(); + for(int i = 0; i < f.length; i++) { + if((updateEntityTick == null) && f[i].getType().isAssignableFrom(int.class)) { + updateEntityTick = f[i]; + //Log.info("Found updateEntityTick - " + f[i].getName()); + updateEntityTick.setAccessible(true); + } + } + + f = AnvilChunkLoader.class.getDeclaredFields(); + for(int i = 0; i < f.length; i++) { + if((chunksToRemove == null) && (f[i].getType().equals(Map.class))) { + chunksToRemove = f[i]; + chunksToRemove.setAccessible(true); + } + else if((pendingAnvilChunksCoordinates == null) && (f[i].getType().equals(Set.class))) { + pendingAnvilChunksCoordinates = f[i]; + pendingAnvilChunksCoordinates.setAccessible(true); + } + } + // Get writeChunkToNBT method + Method[] ma = AnvilChunkLoader.class.getDeclaredMethods(); + for (Method m : ma) { + Class[] p = m.getParameterTypes(); + if ((p.length == 3) && (p[0].equals(Chunk.class)) && (p[1].equals(World.class)) && (p[2].equals(NBTTagCompound.class))) { + writechunktonbt = m; + m.setAccessible(true); + break; + } + } + + if ((unloadqueue == null) || (currentchunkloader == null) || (writechunktonbt == null)) + { + Log.severe("ERROR: cannot find unload queue or chunk provider field - dynmap cannot load chunks"); + } + if (updateEntityTick == null) { + Log.severe("ERROR: cannot find updateEntityTick - dynmap cannot drive entity cleanup when no players are active"); + } + + init = true; + } + } + + /** + * Construct empty cache + */ + public ForgeMapChunkCache() + { + init(); + } + + public void setChunks(ForgeWorld dw, List chunks) + { + this.dw = dw; + this.w = dw.getWorld(); + if(dw.isLoaded()) { + /* Check if world's provider is ChunkProviderServer */ + IChunkProvider cp = this.w.getChunkProvider(); + + if (cp instanceof ChunkProviderServer) + { + cps = (ChunkProviderServer)cp; + } + else + { + Log.severe("Error: world " + dw.getName() + " has unsupported chunk provider"); + } + } + else { + chunks = new ArrayList(); + } + nsect = dw.worldheight >> 4; + this.chunks = chunks; + + /* Compute range */ + if (chunks.size() == 0) + { + this.x_min = 0; + this.x_max = 0; + this.z_min = 0; + this.z_max = 0; + x_dim = 1; + } + else + { + x_min = x_max = chunks.get(0).x; + z_min = z_max = chunks.get(0).z; + + for (DynmapChunk c : chunks) + { + if (c.x > x_max) + { + x_max = c.x; + } + + if (c.x < x_min) + { + x_min = c.x; + } + + if (c.z > z_max) + { + z_max = c.z; + } + + if (c.z < z_min) + { + z_min = c.z; + } + } + + x_dim = x_max - x_min + 1; + } + + snapcnt = x_dim * (z_max-z_min+1); + snaparray = new ChunkSnapshot[snapcnt]; + snaptile = new DynIntHashMap[snapcnt]; + isSectionNotEmpty = new boolean[snapcnt][]; + + try + { + if ((unloadqueue != null) && (cps != null)) + { + queue = (Set)unloadqueue.get(cps); + } + } + catch (IllegalArgumentException iax) + { + } + catch (IllegalAccessException e) + { + } + + } + + private static boolean didError = false; + + public NBTTagCompound readChunk(int x, int z) { + if((cps == null) || (!(cps.chunkLoader instanceof AnvilChunkLoader)) || + (((chunksToRemove == null) || (pendingAnvilChunksCoordinates == null)))) { + if (!didError) { + Log.severe("**** DYNMAP CANNOT READ CHUNKS (UNSUPPORTED CHUNK LOADER) ****"); + didError = true; + } + return null; + } + try { + AnvilChunkLoader acl = (AnvilChunkLoader)cps.chunkLoader; + Map chunkstoremove = null; + Set pendingcoords = null; + + chunkstoremove = (Map)chunksToRemove.get(acl); + pendingcoords = (Set)pendingAnvilChunksCoordinates.get(acl); + + NBTTagCompound rslt = null; + ChunkPos coord = new ChunkPos(x, z); + + if (pendingcoords.contains(coord)) { + for (Object o : chunkstoremove.values()) { + if (chunkCoord == null) { + Field[] f = o.getClass().getDeclaredFields(); + for(Field ff : f) { + if((chunkCoord == null) && (ff.getType().equals(ChunkPos.class))) { + chunkCoord = ff; + chunkCoord.setAccessible(true); + } + else if((nbtTag == null) && (ff.getType().equals(NBTTagCompound.class))) { + nbtTag = ff; + nbtTag.setAccessible(true); + } + } + if ((chunkCoord == null) || (nbtTag == null)) { + Log.severe("Error getting chunkCoord and nbtTag for Forge"); + return null; + } + } + ChunkPos occ = (ChunkPos)chunkCoord.get(o); + + if (occ.equals(coord)) { + rslt = (NBTTagCompound)nbtTag.get(o); + break; + } + } + } + + if (rslt == null) { + DataInputStream str = RegionFileCache.getChunkInputStream(acl.chunkSaveLocation, x, z); + + if (str == null) { + return null; + } + rslt = CompressedStreamTools.read(str); + } + if(rslt != null) + rslt = rslt.getCompound("Level"); + return rslt; + } catch (Exception exc) { + Log.severe(String.format("Error reading chunk: %s,%d,%d", dw.getName(), x, z), exc); + return null; + } + } + + private Object getNBTValue(INBTBase v) { + Object val = null; + switch(v.getId()) { + case 1: // Byte + val = Byte.valueOf(((NBTTagByte)v).getByte()); + break; + case 2: // Short + val = Short.valueOf(((NBTTagShort)v).getShort()); + break; + case 3: // Int + val = Integer.valueOf(((NBTTagInt)v).getInt()); + break; + case 4: // Long + val = Long.valueOf(((NBTTagLong)v).getLong()); + break; + case 5: // Float + val = Float.valueOf(((NBTTagFloat)v).getFloat()); + break; + case 6: // Double + val = Double.valueOf(((NBTTagDouble)v).getDouble()); + break; + case 7: // Byte[] + val = ((NBTTagByteArray)v).getByteArray(); + break; + case 8: // String + val = ((NBTTagString)v).getString(); + break; + case 9: // List + NBTTagList tl = (NBTTagList) v; + ArrayList vlist = new ArrayList(); + int type = tl.getTagType(); + for (int i = 0; i < tl.size(); i++) { + switch (type) { + case 5: + float fv = tl.getFloat(i); + vlist.add(fv); + break; + case 6: + double dv = tl.getDouble(i); + vlist.add(dv); + break; + case 8: + String sv = tl.getString(i); + vlist.add(sv); + break; + case 10: + NBTTagCompound tc = tl.getCompound(i); + vlist.add(getNBTValue(tc)); + break; + case 11: + int[] ia = tl.getIntArray(i); + vlist.add(ia); + break; + } + } + val = vlist; + break; + case 10: // Map + NBTTagCompound tc = (NBTTagCompound) v; + HashMap vmap = new HashMap(); + for (Object t : tc.keySet()) { + String st = (String) t; + INBTBase tg = tc.getTag(st); + vmap.put(st, getNBTValue(tg)); + } + val = vmap; + break; + case 11: // Int[] + val = ((NBTTagIntArray)v).getIntArray(); + break; + } + return val; + } + + private boolean isChunkVisible(DynmapChunk chunk) { + 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; + } + } + } + return vis; + } + + private boolean tryChunkCache(DynmapChunk chunk, boolean vis) { + /* Check if cached chunk snapshot found */ + ChunkSnapshot ss = null; + SnapshotRec ssr = DynmapPlugin.plugin.sscache.getSnapshot(dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty); + if(ssr != null) { + ss = ssr.ss; + if (!vis) + { + if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) + { + ss = STONE; + } + else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) + { + ss = OCEAN; + } + else + { + ss = EMPTY; + } + } + int idx = (chunk.x-x_min) + (chunk.z - z_min)*x_dim; + snaparray[idx] = ss; + snaptile[idx] = ssr.tileData; + } + return (ssr != null); + } + + private boolean isChunkUnloadPending(DynmapChunk chunk) { + boolean isunloadpending = false; + + if (queue != null) + { + long coord = ChunkPos.asLong(chunk.x, chunk.z); + isunloadpending = queue.contains(Long.valueOf(coord)); + } + return isunloadpending; + } + + // Prep snapshot and add to cache + private SnapshotRec prepChunkSnapshot(DynmapChunk chunk, NBTTagCompound nbt) { + ChunkSnapshot ss = new ChunkSnapshot(nbt, dw.worldheight); + DynIntHashMap tileData = new DynIntHashMap(); + + NBTTagList tiles = nbt.getList("TileEntities", 10); + if(tiles == null) tiles = new NBTTagList(); + /* Get tile entity data */ + List vals = new ArrayList(); + for(int tid = 0; tid < tiles.size(); tid++) { + NBTTagCompound tc = tiles.getCompound(tid); + int tx = tc.getInt("x"); + int ty = tc.getInt("y"); + int tz = tc.getInt("z"); + int cx = tx & 0xF; + int cz = tz & 0xF; + DynmapBlockState blk = ss.getBlockType(cx, ty, cz); + String[] te_fields = HDBlockModels.getTileEntityFieldsNeeded(blk); + if(te_fields != null) { + vals.clear(); + for(String id: te_fields) { + INBTBase v = tc.getTag(id); /* Get field */ + if(v != null) { + Object val = getNBTValue(v); + if(val != null) { + vals.add(id); + vals.add(val); + } + } + } + if(vals.size() > 0) { + Object[] vlist = vals.toArray(new Object[vals.size()]); + tileData.put(getIndexInChunk(cx, ty, cz), vlist); + } + } + } + SnapshotRec ssr = new SnapshotRec(); + ssr.ss = ss; + ssr.tileData = tileData; + DynmapPlugin.plugin.sscache.putSnapshot(dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty); + + return ssr; + } + + /** + * Read NBT data from loaded chunks - needs to be called from server/world thread to be safe + * @returns number loaded + */ + public int getLoadedChunks() { + int cnt = 0; + if(!dw.isLoaded()) { + isempty = true; + unloadChunks(); + return 0; + } + ListIterator iter = chunks.listIterator(); + while (iter.hasNext()) { + long startTime = System.nanoTime(); + DynmapChunk chunk = iter.next(); + int chunkindex = (chunk.x-x_min) + (chunk.z - z_min)*x_dim; + if (snaparray[chunkindex] != null) continue; // Skip if already processed + + boolean vis = isChunkVisible(chunk); + + /* Check if cached chunk snapshot found */ + if (tryChunkCache(chunk, vis)) { + endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT); + cnt++; + } + // If chunk is loaded and not being unloaded, we're grabbing its NBT data + else if (cps.chunkExists(chunk.x, chunk.z) && (!isChunkUnloadPending(chunk))) { + ChunkSnapshot ss; + DynIntHashMap tileData; + if (vis) { // If visible + NBTTagCompound nbt = new NBTTagCompound(); + try { + writechunktonbt.invoke(cps.chunkLoader, cps.provideChunk(chunk.x, chunk.z, false, false), w, nbt); + } catch (IllegalAccessException e) { + } catch (IllegalArgumentException e) { + } catch (InvocationTargetException e) { + } + SnapshotRec ssr = prepChunkSnapshot(chunk, nbt); + ss = ssr.ss; + tileData = ssr.tileData; + } + else { + if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) { + ss = STONE; + } + else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) { + ss = OCEAN; + } + else { + ss = EMPTY; + } + tileData = new DynIntHashMap(); + } + snaparray[chunkindex] = ss; + snaptile[chunkindex] = tileData; + endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS); + cnt++; + } + } + return cnt; + } + + @Override + public int loadChunks(int max_to_load) + { + return getLoadedChunks() + readChunks(max_to_load); + + } + + public int readChunks(int max_to_load) + { + if(!dw.isLoaded()) { + isempty = true; + unloadChunks(); + 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(); + + int chunkindex = (chunk.x-x_min) + (chunk.z - z_min)*x_dim; + + if (snaparray[chunkindex] != null) continue; // Skip if already processed + + boolean vis = isChunkVisible(chunk); + + /* Check if cached chunk snapshot found */ + if (tryChunkCache(chunk, vis)) { + endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT); + } + else { + NBTTagCompound nbt = readChunk(chunk.x, chunk.z); + // If read was good + if (nbt != null) { + ChunkSnapshot ss; + DynIntHashMap tileData; + // If hidden + if (!vis) { + if (hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN) { + ss = STONE; + } + else if (hidestyle == HiddenChunkStyle.FILL_OCEAN) { + ss = OCEAN; + } + else { + ss = EMPTY; + } + tileData = new DynIntHashMap(); + } + else { + // Prep snapshot + SnapshotRec ssr = prepChunkSnapshot(chunk, nbt); + ss = ssr.ss; + tileData = ssr.tileData; + } + snaparray[chunkindex] = ss; + snaptile[chunkindex] = tileData; + endChunkLoad(startTime, ChunkStats.UNLOADED_CHUNKS); + } + else { + endChunkLoad(startTime, ChunkStats.UNGENERATED_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; + } + /** + * Test if done loading + */ + public boolean isDoneLoading() + { + if(!dw.isLoaded()) { + return true; + } + if (iterator != null) + { + return !iterator.hasNext(); + } + + return false; + } + /** + * Test if all empty blocks + */ + public boolean isEmpty() + { + return isempty; + } + /** + * Unload chunks + */ + public void unloadChunks() + { + if (snaparray != null) + { + for (int i = 0; i < snaparray.length; i++) + { + snaparray[i] = null; + } + + snaparray = null; + } + } + private void initSectionData(int idx) + { + isSectionNotEmpty[idx] = new boolean[nsect + 1]; + + if (snaparray[idx] != EMPTY) + { + for (int i = 0; i < nsect; i++) + { + if (snaparray[idx].isSectionEmpty(i) == false) + { + isSectionNotEmpty[idx][i] = true; + } + } + } + } + public boolean isEmptySection(int sx, int sy, int sz) + { + int idx = (sx - x_min) + (sz - z_min) * x_dim; + + if (isSectionNotEmpty[idx] == null) + { + initSectionData(idx); + } + + return !isSectionNotEmpty[idx][sy]; + } + + /** + * Get cache iterator + */ + public MapIterator getIterator(int x, int y, int z) + { + if (dw.getEnvironment().equals("the_end")) + { + return new OurEndMapIterator(x, y, z); + } + + return new OurMapIterator(x, y, z); + } + /** + * Set hidden chunk style (default is FILL_AIR) + */ + public void setHiddenFillStyle(HiddenChunkStyle style) + { + this.hidestyle = style; + } + /** + * Add visible area limit - can be called more than once + * Needs to be set before chunks are loaded + * Coordinates are block coordinates + */ + public void setVisibleRange(VisibilityLimit lim) { + if(visible_limits == null) + visible_limits = new ArrayList(); + visible_limits.add(lim); + } + /** + * Add hidden area limit - can be called more than once + * Needs to be set before chunks are loaded + * Coordinates are block coordinates + */ + public void setHiddenRange(VisibilityLimit lim) { + if(hidden_limits == null) + hidden_limits = new ArrayList(); + hidden_limits.add(lim); + } + @Override + public boolean setChunkDataTypes(boolean blockdata, boolean biome, boolean highestblocky, boolean rawbiome) + { + this.biome = biome; + this.biomeraw = rawbiome; + this.highesty = highestblocky; + this.blockdata = blockdata; + return true; + } + @Override + public DynmapWorld getWorld() + { + return dw; + } + + static + { + Biome b[] = DynmapPlugin.getBiomeList(); + BiomeMap[] bm = BiomeMap.values(); + biome_to_bmap = new BiomeMap[256]; + + for (int i = 0; i < biome_to_bmap.length; i++) + { + biome_to_bmap[i] = BiomeMap.NULL; + } + + for (int i = 0; i < b.length; i++) + { + if(b[i] == null) continue; + + String bs = b[i].getTranslationKey(); + + for (int j = 0; j < bm.length; j++) + { + if (bm[j].toString().equals(bs)) + { + biome_to_bmap[i] = bm[j]; + break; + } + } + } + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeWorld.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeWorld.java new file mode 100644 index 00000000..7effec45 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/ForgeWorld.java @@ -0,0 +1,261 @@ +package org.dynmap.forge_1_13_2; +/** + * Forge specific implementation of DynmapWorld + */ +import java.util.List; + +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.dimension.Dimension; +import net.minecraft.world.dimension.DimensionType; +import net.minecraft.world.dimension.EndDimension; +import net.minecraft.world.dimension.NetherDimension; +import net.minecraft.world.gen.Heightmap.Type; +import net.minecraft.world.EnumLightType; +import net.minecraft.world.IWorld; +import net.minecraft.world.World; +import net.minecraft.world.border.WorldBorder; + +import org.dynmap.DynmapChunk; +import org.dynmap.DynmapLocation; +import org.dynmap.DynmapWorld; +import org.dynmap.utils.MapChunkCache; +import org.dynmap.utils.Polygon; + +public class ForgeWorld extends DynmapWorld +{ + private IWorld world; + private final boolean skylight; + private final boolean isnether; + private final boolean istheend; + private final String env; + private DynmapLocation spawnloc = new DynmapLocation(); + private static boolean doMCPCMapping = false; + private static boolean doSaveFolderMapping = false; + private static int maxWorldHeight = 256; // Maximum allows world height + + public static void setMCPCMapping() { + doMCPCMapping = true; + } + public static void setSaveFolderMapping() { + doSaveFolderMapping = true; + } + public static int getMaxWorldHeight() { + return maxWorldHeight; + } + public static void setMaxWorldHeight(int h) { + maxWorldHeight = h; + } + + public static String getWorldName(IWorld w) { + String n; + if (doMCPCMapping) { // MCPC+ mapping + n = w.getWorldInfo().getWorldName(); + } + else if (doSaveFolderMapping) { // New vanilla Forge mapping (consistent with MCPC+) + if (w.getDimension().getType() == DimensionType.OVERWORLD) { + n = w.getWorldInfo().getWorldName(); + } + else { + n = "DIM" + w.getDimension().getType().getId(); + } + } + else { // Legacy mapping + n = w.getWorldInfo().getWorldName(); + Dimension wp = w.getDimension(); + switch(wp.getType().getId()) { + case 0: + break; + case -1: + n += "_nether"; + break; + case 1: + n += "_the_end"; + break; + default: + n += "_" + wp.getType().getId(); + break; + } + } + return n; + } + + public ForgeWorld(IWorld w) + { + this(getWorldName(w), w.getWorld().getHeight(), w.getSeaLevel(), w.getDimension() instanceof NetherDimension, + w.getDimension() instanceof EndDimension, + w.getWorldInfo().getWorldName() + "/" + w.getDimension().getType().toString()); + setWorldLoaded(w); + } + public ForgeWorld(String name, int height, int sealevel, boolean nether, boolean the_end, String deftitle) + { + super(name, (height > maxWorldHeight)?maxWorldHeight:height, sealevel); + world = null; + setTitle(deftitle); + isnether = nether; + istheend = the_end; + skylight = !(isnether || istheend); + + if (isnether) + { + env = "nether"; + } + else if (istheend) + { + env = "the_end"; + } + else + { + env = "normal"; + } + + } + /* Test if world is nether */ + @Override + public boolean isNether() + { + return isnether; + } + public boolean isTheEnd() + { + return istheend; + } + /* Get world spawn location */ + @Override + public DynmapLocation getSpawnLocation() + { + if(world != null) { + BlockPos sloc = world.getSpawnPoint(); + spawnloc.x = sloc.getX(); + spawnloc.y = sloc.getY(); + spawnloc.z = sloc.getZ(); + spawnloc.world = this.getName(); + } + return spawnloc; + } + /* Get world time */ + @Override + public long getTime() + { + if(world != null) + return world.getWorld().getGameTime(); + else + return -1; + } + /* World is storming */ + @Override + public boolean hasStorm() + { + if(world != null) + return world.getWorld().isRaining(); + else + return false; + } + /* World is thundering */ + @Override + public boolean isThundering() + { + if(world != null) + return world.getWorld().isThundering(); + else + return false; + } + /* World is loaded */ + @Override + public boolean isLoaded() + { + return (world != null); + } + /* Set world to unloaded */ + @Override + public void setWorldUnloaded() + { + getSpawnLocation(); + world = null; + } + /* Set world to loaded */ + public void setWorldLoaded(IWorld w) { + world = w; + this.sealevel = w.getSeaLevel(); // Read actual current sealevel from world + // Update lighting table + float[] lt = w.getDimension().getLightBrightnessTable(); + for (int i = 0; i < 16; i++) { + this.setBrightnessTableEntry(i, lt[i]); + } + } + /* Get light level of block */ + @Override + public int getLightLevel(int x, int y, int z) + { + if(world != null) + return world.getLight(new BlockPos(x, y, z)); + else + return -1; + } + /* Get highest Y coord of given location */ + @Override + public int getHighestBlockYAt(int x, int z) + { + if(world != null) { + return world.getWorld().getChunk(x >> 4, z >> 4).getHeightmap(Type.LIGHT_BLOCKING).getHeight(x & 15, z & 15); + } + else + return -1; + } + /* Test if sky light level is requestable */ + @Override + public boolean canGetSkyLightLevel() + { + return skylight; + } + /* Return sky light level */ + @Override + public int getSkyLightLevel(int x, int y, int z) + { + if(world != null) { + return world.getLightFor(EnumLightType.SKY, new BlockPos(x, y, z)); + } + else + return -1; + } + /** + * Get world environment ID (lower case - normal, the_end, nether) + */ + @Override + public String getEnvironment() + { + return env; + } + /** + * Get map chunk cache for world + */ + @Override + public MapChunkCache getChunkCache(List chunks) + { + if(world != null) { + ForgeMapChunkCache c = new ForgeMapChunkCache(); + c.setChunks(this, chunks); + return c; + } + return null; + } + + public World getWorld() + { + return world.getWorld(); + } + @Override + public Polygon getWorldBorder() { + if (world != null) { + WorldBorder wb = world.getWorldBorder(); + if ((wb != null) && (wb.getDiameter() < 5.9E7)) { + Polygon p = new Polygon(); + p.addVertex(wb.minX(), wb.minZ()); + p.addVertex(wb.minX(), wb.maxZ()); + p.addVertex(wb.maxX(), wb.maxZ()); + p.addVertex(wb.maxX(), wb.minZ()); + return p; + } + } + return null; + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Proxy.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Proxy.java new file mode 100644 index 00000000..9a614031 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Proxy.java @@ -0,0 +1,24 @@ +package org.dynmap.forge_1_13_2; + +import net.minecraft.server.MinecraftServer; + +/** + * Server side proxy - methods for creating and cleaning up plugin + */ +public class Proxy +{ + public Proxy() + { + } + public DynmapPlugin startServer(MinecraftServer srv) { + DynmapPlugin plugin = DynmapPlugin.plugin; + if (plugin == null) { + plugin = new DynmapPlugin(srv); + plugin.onEnable(); + } + return plugin; + } + public void stopServer(DynmapPlugin plugin) { + plugin.onDisable(); + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/SnapshotCache.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/SnapshotCache.java new file mode 100644 index 00000000..4f0af710 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/SnapshotCache.java @@ -0,0 +1,191 @@ +package org.dynmap.forge_1_13_2; + +import java.lang.ref.Reference; +import java.lang.ref.ReferenceQueue; +import java.lang.ref.WeakReference; +import java.lang.ref.SoftReference; +import java.util.IdentityHashMap; +import java.util.LinkedHashMap; +import java.util.Map; + +import org.dynmap.utils.DynIntHashMap; + +public class SnapshotCache { + public static class SnapshotRec { + public ChunkSnapshot ss; + public DynIntHashMap tileData; + }; + + private CacheHashMap snapcache; + private ReferenceQueue refqueue; + private long cache_attempts; + private long cache_success; + private boolean softref; + + private static class CacheRec { + Reference ref; + boolean hasbiome; + boolean hasrawbiome; + boolean hasblockdata; + boolean hashighesty; + } + + @SuppressWarnings("serial") + public class CacheHashMap extends LinkedHashMap { + private int limit; + private IdentityHashMap, String> reverselookup; + + public CacheHashMap(int lim) { + super(16, (float)0.75, true); + limit = lim; + reverselookup = new IdentityHashMap, String>(); + } + protected boolean removeEldestEntry(Map.Entry last) { + boolean remove = (size() >= limit); + if(remove && (last != null) && (last.getValue() != null)) { + reverselookup.remove(last.getValue().ref); + } + return remove; + } + } + + /** + * Create snapshot cache + */ + public SnapshotCache(int max_size, boolean softref) { + snapcache = new CacheHashMap(max_size); + refqueue = new ReferenceQueue(); + this.softref = softref; + } + private String getKey(String w, int cx, int cz) { + return w + ":" + cx + ":" + cz; + } + /** + * Invalidate cached snapshot, if in cache + */ + public void invalidateSnapshot(String w, int x, int y, int z) { + String key = getKey(w, x>>4, z>>4); + synchronized(snapcache) { + CacheRec rec = snapcache.remove(key); + if(rec != null) { + snapcache.reverselookup.remove(rec.ref); + rec.ref.clear(); + } + } + //processRefQueue(); + } + /** + * Invalidate cached snapshot, if in cache + */ + public void invalidateSnapshot(String w, int x0, int y0, int z0, int x1, int y1, int z1) { + for(int xx = (x0>>4); xx <= (x1>>4); xx++) { + for(int zz = (z0>>4); zz <= (z1>>4); zz++) { + String key = getKey(w, xx, zz); + synchronized(snapcache) { + CacheRec rec = snapcache.remove(key); + if(rec != null) { + snapcache.reverselookup.remove(rec.ref); + rec.ref.clear(); + } + } + } + } + //processRefQueue(); + } + /** + * Look for chunk snapshot in cache + */ + public SnapshotRec getSnapshot(String w, int chunkx, int chunkz, + boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) { + String key = getKey(w, chunkx, chunkz); + processRefQueue(); + SnapshotRec ss = null; + CacheRec rec; + synchronized(snapcache) { + rec = snapcache.get(key); + if(rec != null) { + ss = rec.ref.get(); + if(ss == null) { + snapcache.reverselookup.remove(rec.ref); + snapcache.remove(key); + } + } + } + if(ss != null) { + if((blockdata && (!rec.hasblockdata)) || + (biome && (!rec.hasbiome)) || + (biomeraw && (!rec.hasrawbiome)) || + (highesty && (!rec.hashighesty))) { + ss = null; + } + } + cache_attempts++; + if(ss != null) cache_success++; + + return ss; + } + /** + * Add chunk snapshot to cache + */ + public void putSnapshot(String w, int chunkx, int chunkz, SnapshotRec ss, + boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) { + String key = getKey(w, chunkx, chunkz); + processRefQueue(); + CacheRec rec = new CacheRec(); + rec.hasblockdata = blockdata; + rec.hasbiome = biome; + rec.hasrawbiome = biomeraw; + rec.hashighesty = highesty; + if (softref) + rec.ref = new SoftReference(ss, refqueue); + else + rec.ref = new WeakReference(ss, refqueue); + synchronized(snapcache) { + CacheRec prevrec = snapcache.put(key, rec); + if(prevrec != null) { + snapcache.reverselookup.remove(prevrec.ref); + } + snapcache.reverselookup.put(rec.ref, key); + } + } + /** + * Process reference queue + */ + private void processRefQueue() { + Reference ref; + while((ref = refqueue.poll()) != null) { + synchronized(snapcache) { + String k = snapcache.reverselookup.remove(ref); + if(k != null) { + snapcache.remove(k); + } + } + } + } + /** + * Get hit rate (percent) + */ + public double getHitRate() { + if(cache_attempts > 0) { + return (100.0*cache_success)/(double)cache_attempts; + } + return 0.0; + } + /** + * Reset cache stats + */ + public void resetStats() { + cache_attempts = cache_success = 0; + } + /** + * Cleanup + */ + public void cleanup() { + if(snapcache != null) { + snapcache.clear(); + snapcache.reverselookup.clear(); + snapcache.reverselookup = null; + snapcache = null; + } + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Version.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Version.java new file mode 100644 index 00000000..5b08ebb7 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/Version.java @@ -0,0 +1,7 @@ +package org.dynmap.forge_1_13_2; + +public class Version { + public static final String VER = "@VERSION@"; + public static final String BUILD_NUMBER = "@BUILD_NUMBER@"; +} + diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/VersionCheck.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/VersionCheck.java new file mode 100644 index 00000000..34872fa6 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/VersionCheck.java @@ -0,0 +1,97 @@ +package org.dynmap.forge_1_13_2; + +import java.io.BufferedReader; +import java.io.InputStreamReader; +import java.net.HttpURLConnection; +import java.net.URL; + +import org.dynmap.DynmapCore; +import org.dynmap.Log; + +public class VersionCheck { + private static final String VERSION_URL = "http://mikeprimm.com/dynmap/releases.php"; + public static void runCheck(final DynmapCore core) { + new Thread(new Runnable() { + public void run() { + doCheck(core); + } + }).start(); + } + + private static int getReleaseVersion(String s) { + int index = s.lastIndexOf('-'); + if(index < 0) + index = s.lastIndexOf('.'); + if(index >= 0) + s = s.substring(0, index); + String[] split = s.split("\\."); + int v = 0; + try { + for(int i = 0; (i < split.length) && (i < 3); i++) { + v += Integer.parseInt(split[i]) << (8 * (2 - i)); + } + } catch (NumberFormatException nfx) {} + return v; + } + + private static int getBuildNumber(String s) { + int index = s.lastIndexOf('-'); + if(index < 0) + index = s.lastIndexOf('.'); + if(index >= 0) + s = s.substring(index+1); + try { + return Integer.parseInt(s); + } catch (NumberFormatException nfx) { + return 99999999; + } + } + + private static void doCheck(DynmapCore core) { + String pluginver = core.getDynmapPluginVersion(); + String platform = core.getDynmapPluginPlatform(); + String platver = core.getDynmapPluginPlatformVersion(); + if((pluginver == null) || (platform == null) || (platver == null)) + return; + HttpURLConnection conn = null; + String loc = VERSION_URL; + int cur_ver = getReleaseVersion(pluginver); + int cur_bn = getBuildNumber(pluginver); + try { + while((loc != null) && (!loc.isEmpty())) { + URL url = new URL(loc); + conn = (HttpURLConnection) url.openConnection(); + conn.setRequestProperty("User-Agent", "Dynmap (" + platform + "/" + platver + "/" + pluginver); + conn.connect(); + loc = conn.getHeaderField("Location"); + } + BufferedReader rdr = new BufferedReader(new InputStreamReader(conn.getInputStream())); + String line = null; + while((line = rdr.readLine()) != null) { + String[] split = line.split(":"); + if(split.length < 4) continue; + /* If our platform and version, or wildcard platform version */ + if(split[0].equals(platform) && (split[1].equals("*") || split[1].equals(platver))) { + int recommended_ver = getReleaseVersion(split[2]); + int recommended_bn = getBuildNumber(split[2]); + if((recommended_ver > cur_ver) || ((recommended_ver == cur_ver) && (recommended_bn > cur_bn))) { /* Newer recommended build */ + Log.info("Version obsolete: new recommended version " + split[2] + " is available."); + } + else if(cur_ver > recommended_ver) { /* Running dev or prerelease? */ + int prerel_ver = getReleaseVersion(split[3]); + int prerel_bn = getBuildNumber(split[3]); + if((prerel_ver > cur_ver) || ((prerel_ver == cur_ver) && (prerel_bn > cur_bn))) { + Log.info("Version obsolete: new prerelease version " + split[3] + " is available."); + } + } + } + } + } catch (Exception x) { + Log.info("Error checking for latest version"); + } finally { + if(conn != null) { + conn.disconnect(); + } + } + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/FilePermissions.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/FilePermissions.java new file mode 100644 index 00000000..caaeb796 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/FilePermissions.java @@ -0,0 +1,104 @@ +package org.dynmap.forge_1_13_2.permissions; + +import java.io.File; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + +import net.minecraft.command.ICommandSource; +import net.minecraft.entity.player.EntityPlayer; + +import org.dynmap.ConfigurationNode; +import org.dynmap.Log; +import org.dynmap.forge_1_13_2.DynmapPlugin; + +public class FilePermissions implements PermissionProvider { + private HashMap> perms; + private Set defperms; + + public static FilePermissions create() { + File f = new File("dynmap/permissions.yml"); + if(!f.exists()) + return null; + ConfigurationNode cfg = new ConfigurationNode(f); + cfg.load(); + + Log.info("Using permissions.yml for access control"); + + return new FilePermissions(cfg); + } + + private FilePermissions(ConfigurationNode cfg) { + perms = new HashMap>(); + for(String k : cfg.keySet()) { + List p = cfg.getStrings(k, null); + if(p != null) { + k = k.toLowerCase(); + HashSet pset = new HashSet(); + for(String perm : p) { + pset.add(perm.toLowerCase()); + } + perms.put(k, pset); + if(k.equals("defaultuser")) { + defperms = pset; + } + } + } + } + + private boolean hasPerm(String player, String perm) { + Set ps = perms.get(player); + if((ps != null) && (ps.contains(perm))) { + return true; + } + if(defperms.contains(perm)) { + return true; + } + return false; + } + @Override + public Set hasOfflinePermissions(String player, Set perms) { + player = player.toLowerCase(); + HashSet rslt = new HashSet(); + if(DynmapPlugin.plugin.isOp(player)) { + rslt.addAll(perms); + } + else { + for(String p : perms) { + if(hasPerm(player, p)) { + rslt.add(p); + } + } + } + return rslt; + } + @Override + public boolean hasOfflinePermission(String player, String perm) { + player = player.toLowerCase(); + if(DynmapPlugin.plugin.isOp(player)) { + return true; + } + else { + return hasPerm(player, perm); + } + } + + @Override + public boolean has(ICommandSource sender, String permission) { + if(sender instanceof EntityPlayer) { + String n = ((EntityPlayer) sender).getName().getString().toLowerCase(); + return hasPerm(n, permission); + } + return true; + } + @Override + public boolean hasPermissionNode(ICommandSource sender, String permission) { + if(sender instanceof EntityPlayer) { + String player = ((EntityPlayer) sender).getName().getString().toLowerCase(); + return DynmapPlugin.plugin.isOp(player); + } + return false; + } + +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/OpPermissions.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/OpPermissions.java new file mode 100644 index 00000000..4877a08a --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/OpPermissions.java @@ -0,0 +1,52 @@ +package org.dynmap.forge_1_13_2.permissions; + +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.command.ICommandSource; +import net.minecraft.entity.player.EntityPlayer; + +import org.dynmap.Log; +import org.dynmap.forge_1_13_2.DynmapPlugin; + +public class OpPermissions implements PermissionProvider { + public HashSet usrCommands = new HashSet(); + + public OpPermissions(String[] usrCommands) { + for (String usrCommand : usrCommands) { + this.usrCommands.add(usrCommand); + } + Log.info("Using ops.txt for access control"); + } + + @Override + public Set hasOfflinePermissions(String player, Set perms) { + HashSet rslt = new HashSet(); + if(DynmapPlugin.plugin.isOp(player)) { + rslt.addAll(perms); + } + return rslt; + } + @Override + public boolean hasOfflinePermission(String player, String perm) { + return DynmapPlugin.plugin.isOp(player); + } + + @Override + public boolean has(ICommandSource sender, String permission) { + if(sender instanceof EntityPlayer) { + if(usrCommands.contains(permission)) { + return true; + } + return DynmapPlugin.plugin.isOp(((EntityPlayer)sender).getEntity().getName().getString()); + } + return true; + } + @Override + public boolean hasPermissionNode(ICommandSource sender, String permission) { + if(sender instanceof EntityPlayer) { + return DynmapPlugin.plugin.isOp(((EntityPlayer)sender).getEntity().getName().getString()); + } + return true; + } +} diff --git a/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/PermissionProvider.java b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/PermissionProvider.java new file mode 100644 index 00000000..a7c26883 --- /dev/null +++ b/forge-1.13.2/src/main/java/org/dynmap/forge_1_13_2/permissions/PermissionProvider.java @@ -0,0 +1,15 @@ +package org.dynmap.forge_1_13_2.permissions; + +import java.util.Set; + +import net.minecraft.command.ICommandSource; + +public interface PermissionProvider { + boolean has(ICommandSource sender, String permission); + boolean hasPermissionNode(ICommandSource sender, String permission); + + Set hasOfflinePermissions(String player, Set perms); + + boolean hasOfflinePermission(String player, String perm); + +} diff --git a/forge-1.13.2/src/main/resources/configuration.txt b/forge-1.13.2/src/main/resources/configuration.txt new file mode 100644 index 00000000..45ee61fe --- /dev/null +++ b/forge-1.13.2/src/main/resources/configuration.txt @@ -0,0 +1,441 @@ +# All paths in this configuration file are relative to Dynmap's data-folder: minecraft_server/dynmap/ + +# All map templates are defined in the templates directory +# To use the HDMap very-low-res (2 ppb) map templates as world defaults, set value to vlowres +# The definitions of these templates are in normal-vlowres.txt, nether-vlowres.txt, and the_end-vlowres.txt +# To use the HDMap low-res (4 ppb) map templates as world defaults, set value to lowres +# The definitions of these templates are in normal-lowres.txt, nether-lowres.txt, and the_end-lowres.txt +# To use the HDMap hi-res (16 ppb) map templates (these can take a VERY long time for initial fullrender), set value to hires +# The definitions of these templates are in normal-hires.txt, nether-hires.txt, and the_end-hires.txt +# To use the HDMap low-res (4 ppb) map templates, with support for boosting resolution selectively to hi-res (16 ppb), set value to low_boost_hi +# The definitions of these templates are in normal-low_boost_hi.txt, nether-low_boost_hi.txt, and the_end-low_boost_hi.txt +# To use the HDMap hi-res (16 ppb) map templates, with support for boosting resolution selectively to vhi-res (32 ppb), set value to hi_boost_vhi +# The definitions of these templates are in normal-hi_boost_vhi.txt, nether-hi_boost_vhi.txt, and the_end-hi_boost_vhi.txt +# To use the HDMap hi-res (16 ppb) map templates, with support for boosting resolution selectively to xhi-res (64 ppb), set value to hi_boost_xhi +# The definitions of these templates are in normal-hi_boost_xhi.txt, nether-hi_boost_xhi.txt, and the_end-hi_boost_xhi.txt +deftemplatesuffix: hires + +# Map storage scheme: only uncommoent one 'type' value +# filetree: classic and default scheme: tree of files, with all map data under the directory indicated by 'tilespath' setting +# sqlite: single SQLite database file (this can get VERY BIG), located at 'dbfile' setting (default is file dynmap.db in data directory) +# mysql: MySQL database, at hostname:port in database, accessed via userid with password +storage: + # Filetree storage (standard tree of image files for maps) + type: filetree + # SQLite db for map storage (uses dbfile as storage location) + #type: sqlite + #dbfile: dynmap.db + # MySQL DB for map storage (at 'hostname':'port' in database 'database' using user 'userid' password 'password' and table prefix 'prefix' + #type: mysql + #hostname: localhost + #port: 3306 + #database: dynmap + #userid: dynmap + #password: dynmap + #prefix: "" + +components: + - class: org.dynmap.ClientConfigurationComponent + + - class: org.dynmap.InternalClientUpdateComponent + sendhealth: true + sendposition: true + allowwebchat: true + webchat-interval: 5 + hidewebchatip: false + trustclientname: false + includehiddenplayers: false + # (optional) if true, color codes in player display names are used + use-name-colors: false + # (optional) if true, player login IDs will be used for web chat when their IPs match + use-player-login-ip: true + # (optional) if use-player-login-ip is true, setting this to true will cause chat messages not matching a known player IP to be ignored + require-player-login-ip: false + # (optional) block player login IDs that are banned from chatting + block-banned-player-chat: true + # Require login for web-to-server chat (requires login-enabled: true) + webchat-requires-login: false + # If set to true, users must have dynmap.webchat permission in order to chat + webchat-permissions: false + # Limit length of single chat messages + chatlengthlimit: 256 + # # Optional - make players hidden when they are inside/underground/in shadows (#=light level: 0=full shadow,15=sky) + # hideifshadow: 4 + # # Optional - make player hidden when they are under cover (#=sky light level,0=underground,15=open to sky) + # hideifundercover: 14 + # # (Optional) if true, players that are crouching/sneaking will be hidden + hideifsneaking: false + # If true, player positions/status is protected (login with ID with dynmap.playermarkers.seeall permission required for info other than self) + protected-player-info: false + # If true, hide players with invisibility potion effects active + hide-if-invisiblity-potion: true + # If true, player names are not shown on map, chat, list + hidenames: false + #- class: org.dynmap.JsonFileClientUpdateComponent + # writeinterval: 1 + # sendhealth: true + # sendposition: true + # allowwebchat: true + # webchat-interval: 5 + # hidewebchatip: false + # includehiddenplayers: false + # use-name-colors: false + # use-player-login-ip: false + # require-player-login-ip: false + # block-banned-player-chat: true + # hideifshadow: 0 + # hideifundercover: 0 + # hideifsneaking: false + # # Require login for web-to-server chat (requires login-enabled: true) + # webchat-requires-login: false + # # If set to true, users must have dynmap.webchat permission in order to chat + # webchat-permissions: false + # # Limit length of single chat messages + # chatlengthlimit: 256 + # hide-if-invisiblity-potion: true + # hidenames: false + + - class: org.dynmap.SimpleWebChatComponent + allowchat: true + # If true, web UI users can supply name for chat using 'playername' URL parameter. 'trustclientname' must also be set true. + allowurlname: false + + # Note: this component is needed for the dmarker commands, and for the Marker API to be available to other plugins + - class: org.dynmap.MarkersComponent + type: markers + showlabel: false + enablesigns: false + # Default marker set for sign markers + default-sign-set: markers + # (optional) add spawn point markers to standard marker layer + showspawn: true + spawnicon: world + spawnlabel: "Spawn" + # (optional) layer for showing offline player's positions (for 'maxofflinetime' minutes after logoff) + showofflineplayers: false + offlinelabel: "Offline" + offlineicon: offlineuser + offlinehidebydefault: true + offlineminzoom: 0 + maxofflinetime: 30 + # (optional) layer for showing player's spawn beds + showspawnbeds: false + spawnbedlabel: "Spawn Beds" + spawnbedicon: bed + spawnbedhidebydefault: true + spawnbedminzoom: 0 + spawnbedformat: "%name%'s bed" + # (optional) Show world border (vanilla 1.8+) + showworldborder: true + + - class: org.dynmap.ClientComponent + type: chat + allowurlname: false + - class: org.dynmap.ClientComponent + type: chatballoon + focuschatballoons: false + - class: org.dynmap.ClientComponent + type: chatbox + showplayerfaces: true + 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 + #visiblelines: 10 + # Optional: send push button + sendbutton: false + - class: org.dynmap.ClientComponent + type: playermarkers + showplayerfaces: true + showplayerhealth: true + # If true, show player body too (only valid if showplayerfaces=true + showplayerbody: false + # Option to make player faces small - don't use with showplayerhealth + smallplayerfaces: false + # Optional - make player faces layer hidden by default + hidebydefault: false + # Optional - ordering priority in layer menu (low goes before high - default is 0) + layerprio: 0 + # Optional - label for player marker layer (default is 'Players') + label: "Players" + + #- class: org.dynmap.ClientComponent + # type: digitalclock + - class: org.dynmap.ClientComponent + type: link + + - class: org.dynmap.ClientComponent + type: timeofdayclock + showdigitalclock: true + #showweather: true + # Mouse pointer world coordinate display + - class: org.dynmap.ClientComponent + type: coord + label: "Location" + hidey: false + show-mcr: false + + # Note: more than one logo component can be defined + #- class: org.dynmap.ClientComponent + # type: logo + # text: "Dynmap" + # #logourl: "images/block_surface.png" + # linkurl: "http://forums.bukkit.org/threads/dynmap.489/" + # # Valid positions: top-left, top-right, bottom-left, bottom-right + # position: bottom-right + + #- class: org.dynmap.ClientComponent + # type: inactive + # timeout: 1800 # in seconds (1800 seconds = 30 minutes) + # redirecturl: inactive.html + # #showmessage: 'You were inactive for too long.' + + #- class: org.dynmap.TestComponent + # stuff: "This is some configuration-value" + +# Treat hiddenplayers.txt as a whitelist for players to be shown on the map? (Default false) +display-whitelist: false + +# How often a tile gets rendered (in seconds). +renderinterval: 1 + +# How many tiles on update queue before accelerate render interval +renderacceleratethreshold: 60 + +# How often to render tiles when backlog is above renderacceleratethreshold +renderaccelerateinterval: 0.2 + +# How many update tiles to work on at once (if not defined, default is 1/2 the number of cores) +tiles-rendered-at-once: 2 + +# If true, use normal priority threads for rendering (versus low priority) - this can keep rendering +# from starving on busy Windows boxes (Linux JVMs pretty much ignore thread priority), but may result +# in more competition for CPU resources with other processes +usenormalthreadpriority: true + +# Save and restore pending tile renders - prevents their loss on server shutdown or /reload +saverestorepending: true + +# Save period for pending jobs (in seconds): periodic saving for crash recovery of jobs +save-pending-period: 900 + +# Zoom-out tile update period - how often to scan for and process tile updates into zoom-out tiles (in seconds) +zoomoutperiod: 30 + +# Control whether zoom out tiles are validated on startup (can be needed if zoomout processing is interrupted, but can be expensive on large maps) +initial-zoomout-validate: true + +# Default delay on processing of updated tiles, in seconds. This can reduce potentially expensive re-rendering +# of frequently updated tiles (such as due to machines, pistons, quarries or other automation). Values can +# also be set on individual worlds and individual maps. +tileupdatedelay: 30 + +# Tile hashing is used to minimize tile file updates when no changes have occurred - set to false to disable +enabletilehash: true + +# Optional - hide ores: render as normal stone (so that they aren't revealed by maps) +#hideores: true + +# Optional - enabled BetterGrass style rendering of grass and snow block sides +#better-grass: true + +# Optional - enable smooth lighting by default on all maps supporting it (can be set per map as lighting option) +smooth-lighting: true + +# Optional - use world provider lighting table (good for custom worlds with custom lighting curves, like nether) +# false=classic Dynmap lighting curve +use-brightness-table: true + +# Optional - render specific block IDs using the texures and models of another block ID: can be used to hide/disguise specific +# blocks (e.g. make ores look like stone, hide chests) or to provide simple support for rendering unsupported custom blocks +block-id-alias: +# "14": 1 +# "15": 1 +# "16": 1 + +# Default image format for HDMaps (png, jpg, jpg-q75, jpg-q80, jpg-q85, jpg-q90, jpg-q95, jpg-q100) +# Has no effect on maps with explicit format settings +image-format: png + +# use-generated-textures: if true, use generated textures (same as client); false is static water/lava textures +# correct-water-lighting: if true, use corrected water lighting (same as client); false is legacy water (darker) +# transparent-leaves: if true, leaves are transparent (lighting-wise): false is needed for some Spout versions that break lighting on leaf blocks +use-generated-textures: true +correct-water-lighting: true +transparent-leaves: true + +# ctm-support: if true, Connected Texture Mod (CTM) in texture packs is enabled (default) +ctm-support: true +# custom-colors-support: if true, Custom Colors in texture packs is enabled (default) +custom-colors-support: true + +# Control loading of player faces (if set to false, skins are never fetched) +#fetchskins: false + +# Control updating of player faces, once loaded (if faces are being managed by other apps or manually) +#refreshskins: false + +# Customize URL used for fetching player skins (%player% is macro for name) +skin-url: "http://skins.minecraft.net/MinecraftSkins/%player%.png" + +# Control behavior for new (1.0+) compass orientation (sunrise moved 90 degrees: east is now what used to be south) +# default is 'newrose' (preserve pre-1.0 maps, rotate rose) +# 'newnorth' is used to rotate maps and rose (requires fullrender of any HDMap map - same as 'newrose' for FlatMap or KzedMap) +compass-mode: newnorth + +# Triggers for automatic updates : blockupdate-with-id is debug for breaking down updates by ID:meta +# To disable, set just 'none' and comment/delete the rest +render-triggers: + - blockupdate + #- blockupdate-with-id + #- lightingupdate + - chunkpopulate + - chunkgenerate + #- none + +# Title for the web page - if not specified, defaults to the server's name (unless it is the default of 'Unknown Server') +#webpage-title: "My Awesome Server Map" + +# The path where the tile-files are placed. +tilespath: web/tiles + +# The path where the web-files are located. +webpath: web + +# The path were the /dynmapexp command exports OBJ ZIP files +exportpath: export + +# The network-interface the webserver will bind to (0.0.0.0 for all interfaces, 127.0.0.1 for only local access). +# If not set, uses same setting as server in server.properties (or 0.0.0.0 if not specified) +#webserver-bindaddress: 0.0.0.0 + +# The TCP-port the webserver will listen on. +webserver-port: 8123 + +# Maximum concurrent session on internal web server - limits resources used in Bukkit server +max-sessions: 30 + +# Disables Webserver portion of Dynmap (Advanced users only) +disable-webserver: false + +# Enable/disable having the web server allow symbolic links (true=compatible with existing code, false=more secure (default)) +allow-symlinks: true + +# Enable login support +login-enabled: false +# Require login to access website (requires login-enabled: true) +login-required: false + +# Period between tile renders for fullrender, in seconds (non-zero to pace fullrenders, lessen CPU load) +timesliceinterval: 0.0 + +# Maximum chunk loads per server tick (1/20th of a second) - reducing this below 90 will impact render performance, but also will reduce server thread load +maxchunkspertick: 200 + +# Progress report interval for fullrender/radiusrender, in tiles. Must be 100 or greater +progressloginterval: 100 + +# Parallel fullrender: if defined, number of concurrent threads used for fullrender or radiusrender +# Note: setting this will result in much more intensive CPU use, some additional memory use. Caution should be used when +# setting this to equal or exceed the number of physical cores on the system. +#parallelrendercnt: 4 + +# Interval the browser should poll for updates. +updaterate: 2000 + +# If nonzero, server will pause fullrender/radiusrender processing when 'fullrenderplayerlimit' or more users are logged in +fullrenderplayerlimit: 0 +# If nonzero, server will pause update render processing when 'updateplayerlimit' or more users are logged in +updateplayerlimit: 0 +# Target limit on server thread use - msec per tick +per-tick-time-limit: 50 +# If TPS of server is below this setting, update renders processing is paused +update-min-tps: 18.0 +# If TPS of server is below this setting, full/radius renders processing is paused +fullrender-min-tps: 18.0 +# If TPS of server is below this setting, zoom out processing is paused +zoomout-min-tps: 18.0 + +showplayerfacesinmenu: true + +# Control whether players that are hidden or not on current map are grayed out (true=yes) +grayplayerswhenhidden: true + +# Set sidebaropened: 'true' to pin menu sidebar opened permanently, 'pinned' to default the sidebar to pinned, but allow it to unpin +#sidebaropened: true + +# Customized HTTP response headers - add 'id: value' pairs to all HTTP response headers (internal web server only) +#http-response-headers: +# Access-Control-Allow-Origin: "my-domain.com" +# X-Custom-Header-Of-Mine: "MyHeaderValue" + +# Trusted proxies for web server - which proxy addresses are trusted to supply valid X-Forwarded-For fields +trusted-proxies: + - "127.0.0.1" + - "0:0:0:0:0:0:0:1" + +joinmessage: "%playername% joined" +quitmessage: "%playername% quit" +spammessage: "You may only chat once every %interval% seconds." +# format for messages from web: %playername% substitutes sender ID (typically IP), %message% includes text +webmsgformat: "&color;2[WEB] %playername%: &color;f%message%" + +# Control whether layer control is presented on the UI (default is true) +showlayercontrol: true + +# Enable checking for banned IPs via banned-ips.txt (internal web server only) +check-banned-ips: true + +# Default selection when map page is loaded +defaultzoom: 0 +defaultworld: world +defaultmap: flat +# (optional) Zoom level and map to switch to when following a player, if possible +#followzoom: 3 +#followmap: surface + +# If true, make persistent record of IP addresses used by player logins, to support web IP to player matching +persist-ids-by-ip: true + +# If true, map text to cyrillic +cyrillic-support: false + +# Messages to customize +msg: + maptypes: "Map Types" + players: "Players" + chatrequireslogin: "Chat Requires Login" + chatnotallowed: "You are not permitted to send chat messages" + hiddennamejoin: "Player joined" + hiddennamequit: "Player quit" + +# URL for client configuration (only need to be tailored for proxies or other non-standard configurations) +url: + # configuration URL + #configuration: "up/configuration" + # update URL + #update: "up/world/{world}/{timestamp}" + # sendmessage URL + #sendmessage: "up/sendmessage" + # login URL + #login: "up/login" + # register URL + #register: "up/register" + # tiles base URL + #tiles: "tiles/" + # markers base URL + #markers: "tiles/" + # Snapshot cache size, in chunks +snapshotcachesize: 500 +# Snapshot cache uses soft references (true), else weak references (false) +soft-ref-cache: true + +# Set to true to enable verbose startup messages - can help with debugging map configuration problems +# Set to false for a much quieter startup log +verbose: false + +# Enables debugging. +#debuggers: +# - class: org.dynmap.debug.LogDebugger +# Debug: dump blocks missing render data +dump-missing-blocks: false diff --git a/forge-1.13.2/src/main/resources/dynmap_at.cfg b/forge-1.13.2/src/main/resources/dynmap_at.cfg new file mode 100644 index 00000000..e97eb6d8 --- /dev/null +++ b/forge-1.13.2/src/main/resources/dynmap_at.cfg @@ -0,0 +1,4 @@ +public net.minecraft.world.gen.ChunkProviderServer field_73247_e # chunkLoader +public net.minecraft.world.chunk.storage.AnvilChunkLoader field_75825_d # chunkSaveLocation +public net.minecraft.world.biome.Biome field_76791_y # biomeName +public net.minecraft.world.chunk.Chunk field_76641_n # lastSaveTime diff --git a/forge-1.13.2/src/main/resources/mcmod.info b/forge-1.13.2/src/main/resources/mcmod.info new file mode 100644 index 00000000..e188b9ab --- /dev/null +++ b/forge-1.13.2/src/main/resources/mcmod.info @@ -0,0 +1,18 @@ +[ +{ + "modid": "Dynmap", + "name": "Dynmap", + "description": "Dynamic, Google Maps style web maps for Minecraft Servers", + "version": "${version}", + "mcversion": "${mcversion}", + "url": "https://forums.dynmap.us", + "updateUrl": "", + "authors": [ + "mikeprimm" + ], + "credits": "Authored by mikeprimm", + "logoFile": "", + "screenshots": [ ], + "dependencies": [] +} +] diff --git a/forge-1.13.2/src/main/resources/permissions.yml.example b/forge-1.13.2/src/main/resources/permissions.yml.example new file mode 100644 index 00000000..a25f9adc --- /dev/null +++ b/forge-1.13.2/src/main/resources/permissions.yml.example @@ -0,0 +1,27 @@ +# +# Sample permissions.yml for dynmap - trivial, flat-file based permissions for dynmap features +# To use, copy this file to dynmap/permissions.yml, and edit appropriate. File is YAML format. +# +# All operators have full permissions to all functions. +# All users receive the permissions under the 'defaultuser' section +# Specific users can be given more permissions by defining a section with their name containing their permisssions +# All permissions correspond to those documented here (https://github.com/webbukkit/dynmap/wiki/Permissions), but +# do NOT have the 'dynmap.' prefix when used here (e.g. 'dynmap.fullrender' permission is just 'fullrender' here). +# +defaultuser: + - render + - show.self + - hide.self + - sendtoweb + - stats + - marker.list + - marker.listsets + - marker.icons + - webregister + - webchat + #- marker.sign + +#playername1: +# - fullrender +# - cancelrender +# - radiusrender diff --git a/settings.gradle b/settings.gradle index 79eb11a2..ad1b2988 100644 --- a/settings.gradle +++ b/settings.gradle @@ -7,6 +7,7 @@ include ':bukkit-helper' include ':dynmap-api' include ':DynmapCore' include ':DynmapCoreAPI' +include ':forge-1.13.2' include ':forge-1.12.2' include ':forge-1.11.2' include ':forge-1.10.2' @@ -21,6 +22,7 @@ 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 project(':DynmapCoreAPI').projectDir = "$rootDir/DynmapCoreAPI" as File +project(':forge-1.13.2').projectDir = "$rootDir/forge-1.13.2" as File project(':forge-1.12.2').projectDir = "$rootDir/forge-1.12.2" as File project(':forge-1.11.2').projectDir = "$rootDir/forge-1.11.2" as File project(':forge-1.10.2').projectDir = "$rootDir/forge-1.10.2" as File