Add Forge 1.16.4 build

This commit is contained in:
Mike Primm 2021-01-09 17:25:34 -06:00
parent 34348a6d16
commit 246c1754cc
20 changed files with 5267 additions and 0 deletions

2
forge-1.16.4/.gitignore vendored Normal file
View File

@ -0,0 +1,2 @@
/build/
/bin/

87
forge-1.16.4/build.gradle Normal file
View File

@ -0,0 +1,87 @@
buildscript {
repositories {
maven { url = 'https://files.minecraftforge.net/maven' }
jcenter()
mavenCentral()
}
dependencies {
classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '3.+', changing: true
}
}
apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'eclipse'
apply plugin: 'com.github.johnrengelman.shadow'
sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
ext.buildNumber = System.getenv().BUILD_NUMBER ?: "Dev"
minecraft {
mappings channel: 'snapshot', version: '20201028-1.16.3'
accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
runs {
server {
workingDirectory project.file('run').canonicalPath
}
}
}
project.archivesBaseName = "${project.archivesBaseName}-forge-1.16.2"
dependencies {
compile project(path: ":DynmapCore", configuration: "shadow")
minecraft 'net.minecraftforge:forge:1.16.4-35.1.36'
}
processResources
{
inputs.property "version", project.version + '-' + project.ext.buildNumber
// replace stuff in mcmod.info, nothing else
from(sourceSets.main.resources.srcDirs) {
include 'META-INF/mods.toml'
// replace version and mcversion
expand(
version: project.version + '-' + project.ext.buildNumber,
mcversion: "1.16.4"
)
}
// copy everything else, thats not the mcmod.info
from(sourceSets.main.resources.srcDirs) {
exclude 'META-INF/mods.toml'
}
}
shadowJar {
dependencies {
include(dependency(':DynmapCore'))
}
archiveName = "Dynmap-${parent.version}-forge-1.16.4.jar"
destinationDir = file '../target'
}
shadowJar.doLast {
task ->
ant.checksum file: task.archivePath
}
afterEvaluate {
reobf {
shadowJar {
mappings = createMcpToSrg.output
}
}
}
task deobfJar(type: Jar) {
from sourceSets.main.output
classifier = 'dev'
}
artifacts {
archives deobfJar
}
build.dependsOn(shadowJar)

View File

@ -0,0 +1,286 @@
package org.dynmap.forge_1_16_4;
import java.util.Arrays;
import org.dynmap.Log;
import org.dynmap.renderer.DynmapBlockState;
import org.dynmap.utils.DataBitsPacked;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.nbt.ListNBT;
import net.minecraft.util.BitArray;
/**
* 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+1];
/* 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(CompoundNBT 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.contains("InhabitedTime")) {
this.inhabitedTicks = nbt.getLong("InhabitedTime");
}
else {
this.inhabitedTicks = 0;
}
/* Allocate arrays indexed by section */
this.section = new Section[this.sectionCnt+1];
/* Fill with empty data */
for (int i = 0; i <= this.sectionCnt; i++) {
this.section[i] = empty_section;
}
/* Get sections */
ListNBT sect = nbt.getList("Sections", 10);
for (int i = 0; i < sect.size(); i++) {
CompoundNBT sec = sect.getCompound(i);
int secnum = sec.getByte("Y");
if (secnum >= this.sectionCnt) {
//Log.info("Section " + (int) secnum + " above world height " + worldheight);
continue;
}
if (secnum < 0)
continue;
//System.out.println("section(" + secnum + ")=" + sec.asString());
// Create normal section to initialize
StdSection cursect = new StdSection();
this.section[secnum] = cursect;
DynmapBlockState[] states = cursect.states;
DynmapBlockState[] palette = null;
// If we've got palette and block states list, process non-empty section
if (sec.contains("Palette", 9) && sec.contains("BlockStates", 12)) {
ListNBT plist = sec.getList("Palette", 10);
long[] statelist = sec.getLongArray("BlockStates");
palette = new DynmapBlockState[plist.size()];
for (int pi = 0; pi < plist.size(); pi++) {
CompoundNBT tc = plist.getCompound(pi);
String pname = tc.getString("Name");
if (tc.contains("Properties")) {
StringBuilder statestr = new StringBuilder();
CompoundNBT prop = tc.getCompound("Properties");
for (String pid : prop.keySet()) {
if (statestr.length() > 0) statestr.append(',');
statestr.append(pid).append('=').append(prop.get(pid).getString());
}
palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
}
if (palette[pi] == null) {
palette[pi] = DynmapBlockState.getBaseStateByName(pname);
}
if (palette[pi] == null) {
palette[pi] = DynmapBlockState.AIR;
}
}
int recsperblock = (4096 + statelist.length - 1) / statelist.length;
int bitsperblock = 64 / recsperblock;
BitArray db = null;
DataBitsPacked dbp = null;
try {
db = new BitArray(bitsperblock, 4096, statelist);
} catch (Exception x) { // Handle legacy encoded
bitsperblock = (statelist.length * 64) / 4096;
dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
}
if (bitsperblock > 8) { // Not palette
for (int j = 0; j < 4096; j++) {
int v = (dbp != null) ? dbp.getAt(j) : db.getAt(j);
states[j] = DynmapBlockState.getStateByGlobalIndex(v);
}
}
else {
for (int j = 0; j < 4096; j++) {
int v = (dbp != null) ? dbp.getAt(j) : db.getAt(j);
states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
}
}
}
if (sec.contains("BlockLight")) {
cursect.emitlight = sec.getByteArray("BlockLight");
}
if (sec.contains("SkyLight")) {
cursect.skylight = sec.getByteArray("SkyLight");
}
}
/* Get biome data */
this.biome = new int[COLUMNS_PER_CHUNK];
if (nbt.contains("Biomes")) {
int[] bb = nbt.getIntArray("Biomes");
if (bb != null) {
// If v1.15+ format
if (bb.length > COLUMNS_PER_CHUNK) {
// For now, just pad the grid with the first 16
for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
int bv = bb[off + 64]; // Offset to y=64
if (bv < 0) bv = 0;
this.biome[i] = bv;
}
}
else { // Else, older chunks
for (int i = 0; i < bb.length; i++) {
int bv = bb[i];
if (bv < 0) bv = 0;
this.biome[i] = 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;
}
}

View File

@ -0,0 +1,6 @@
package org.dynmap.forge_1_16_4;
public class ClientProxy extends Proxy {
public ClientProxy() {
}
}

View File

@ -0,0 +1,133 @@
package org.dynmap.forge_1_16_4;
import java.io.File;
import org.apache.commons.lang3.tuple.Pair;
import org.dynmap.DynmapCommonAPI;
import org.dynmap.DynmapCommonAPIListener;
import org.dynmap.Log;
import org.dynmap.forge_1_16_4.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.ExtensionPoint;
import net.minecraftforge.fml.ModList;
import net.minecraftforge.fml.ModLoadingContext;
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;
import net.minecraftforge.fml.network.FMLNetworkConstants;
@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 String ver;
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<Ticket> 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);
ModLoadingContext.get().registerExtensionPoint(ExtensionPoint.DISPLAYTEST, () -> Pair.of(() -> FMLNetworkConstants.IGNORESERVERONLY, (a, b) -> true));
Log.setLogger(new OurLog());
org.dynmap.modsupport.ModSupportImpl.init();
}
public void setup(final FMLCommonSetupEvent event)
{
//TOOO
jarfile = ModList.get().getModFileById("dynmap").getFile().getFilePath().toFile();
ver = ModList.get().getModContainerById("dynmap").get().getModInfo().getVersion().toString();
//// 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();
if(plugin == null)
plugin = proxy.startServer(server);
plugin.onStarting(server.getCommandManager().getDispatcher());
}
@SubscribeEvent
public void onServerStarted(FMLServerStartedEvent event) {
DynmapCommonAPIListener.register(new APICallback());
plugin.serverStarted();
}
@SubscribeEvent
public void serverStopping(FMLServerStoppingEvent event)
{
proxy.stopServer(plugin);
plugin = null;
}
}

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,234 @@
package org.dynmap.forge_1_16_4;
/**
* Forge specific implementation of DynmapWorld
*/
import java.util.List;
import net.minecraft.util.RegistryKey;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.gen.Heightmap.Type;
import net.minecraft.world.IServerWorld;
import net.minecraft.world.IWorld;
import net.minecraft.world.LightType;
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 IServerWorld world;
private final boolean skylight;
private final boolean isnether;
private final boolean istheend;
private final String env;
private DynmapLocation spawnloc = new DynmapLocation();
private static int maxWorldHeight = 256; // Maximum allows world height
public static int getMaxWorldHeight() {
return maxWorldHeight;
}
public static void setMaxWorldHeight(int h) {
maxWorldHeight = h;
}
public static String getWorldName(IServerWorld w) {
RegistryKey<World> rk = w.getWorld().getDimensionKey();
if (rk == World.OVERWORLD) { // Overworld?
return w.getWorld().getServer().getServerConfiguration().getWorldName();
}
else if (rk == World.THE_END) {
return "DIM1";
}
else if (rk == World.THE_NETHER) {
return "DIM-1";
}
else {
return rk.getRegistryName().getNamespace() + "_" + rk.getRegistryName().getPath();
}
}
public ForgeWorld(IServerWorld w)
{
this(getWorldName(w), w.getWorld().getHeight(),
w.getWorld().getSeaLevel(),
w.getWorld().getDimensionKey() == World.THE_NETHER,
w.getWorld().getDimensionKey() == World.THE_END,
w.getWorld().getDimensionKey().getRegistryName().getPath());
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) {
spawnloc.x = world.getWorldInfo().getSpawnX();
spawnloc.y = world.getWorldInfo().getSpawnY();
spawnloc.z = world.getWorldInfo().getSpawnZ();
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(IServerWorld w) {
world = w;
this.sealevel = w.getSeaLevel(); // Read actual current sealevel from world
// Update lighting table
for (int i = 0; i < 16; i++) {
this.setBrightnessTableEntry(i, w.getWorld().getDimensionType().getAmbientLight(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.MOTION_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(LightType.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<DynmapChunk> 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;
}
}

View File

@ -0,0 +1,24 @@
package org.dynmap.forge_1_16_4;
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();
}
}

View File

@ -0,0 +1,191 @@
package org.dynmap.forge_1_16_4;
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<SnapshotRec> refqueue;
private long cache_attempts;
private long cache_success;
private boolean softref;
private static class CacheRec {
Reference<SnapshotRec> ref;
boolean hasbiome;
boolean hasrawbiome;
boolean hasblockdata;
boolean hashighesty;
}
@SuppressWarnings("serial")
public class CacheHashMap extends LinkedHashMap<String, CacheRec> {
private int limit;
private IdentityHashMap<Reference<SnapshotRec>, String> reverselookup;
public CacheHashMap(int lim) {
super(16, (float)0.75, true);
limit = lim;
reverselookup = new IdentityHashMap<Reference<SnapshotRec>, String>();
}
protected boolean removeEldestEntry(Map.Entry<String, CacheRec> 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<SnapshotRec>();
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<SnapshotRec>(ss, refqueue);
else
rec.ref = new WeakReference<SnapshotRec>(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<? extends SnapshotRec> 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;
}
}
}

View File

@ -0,0 +1,97 @@
package org.dynmap.forge_1_16_4;
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();
}
}
}
}

View File

@ -0,0 +1,103 @@
package org.dynmap.forge_1_16_4.permissions;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import net.minecraft.entity.player.PlayerEntity;
import org.dynmap.ConfigurationNode;
import org.dynmap.Log;
import org.dynmap.forge_1_16_4.DynmapPlugin;
public class FilePermissions implements PermissionProvider {
private HashMap<String, Set<String>> perms;
private Set<String> 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<String,Set<String>>();
for(String k : cfg.keySet()) {
List<String> p = cfg.getStrings(k, null);
if(p != null) {
k = k.toLowerCase();
HashSet<String> pset = new HashSet<String>();
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<String> ps = perms.get(player);
if((ps != null) && (ps.contains(perm))) {
return true;
}
if(defperms.contains(perm)) {
return true;
}
return false;
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
player = player.toLowerCase();
HashSet<String> rslt = new HashSet<String>();
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(PlayerEntity psender, String permission) {
if(psender != null) {
String n = psender.getName().getString().toLowerCase();
return hasPerm(n, permission);
}
return true;
}
@Override
public boolean hasPermissionNode(PlayerEntity psender, String permission) {
if(psender != null) {
String player = psender.getName().getString().toLowerCase();
return DynmapPlugin.plugin.isOp(player);
}
return false;
}
}

View File

@ -0,0 +1,51 @@
package org.dynmap.forge_1_16_4.permissions;
import java.util.HashSet;
import java.util.Set;
import net.minecraft.entity.player.PlayerEntity;
import org.dynmap.Log;
import org.dynmap.forge_1_16_4.DynmapPlugin;
public class OpPermissions implements PermissionProvider {
public HashSet<String> usrCommands = new HashSet<String>();
public OpPermissions(String[] usrCommands) {
for (String usrCommand : usrCommands) {
this.usrCommands.add(usrCommand);
}
Log.info("Using ops.txt for access control");
}
@Override
public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
HashSet<String> rslt = new HashSet<String>();
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(PlayerEntity psender, String permission) {
if(psender != null) {
if(usrCommands.contains(permission)) {
return true;
}
return DynmapPlugin.plugin.isOp(psender.getEntity().getName().getString());
}
return true;
}
@Override
public boolean hasPermissionNode(PlayerEntity psender, String permission) {
if(psender != null) {
return DynmapPlugin.plugin.isOp(psender.getEntity().getName().getString());
}
return true;
}
}

View File

@ -0,0 +1,15 @@
package org.dynmap.forge_1_16_4.permissions;
import java.util.Set;
import net.minecraft.entity.player.PlayerEntity;
public interface PermissionProvider {
boolean has(PlayerEntity sender, String permission);
boolean hasPermissionNode(PlayerEntity sender, String permission);
Set<String> hasOfflinePermissions(String player, Set<String> perms);
boolean hasOfflinePermission(String player, String perm);
}

View File

@ -0,0 +1,3 @@
public net.minecraft.world.server.ChunkManager field_219251_e # loaded chunk list
public net.minecraft.world.server.ChunkManager field_219252_f # loaded chunk list
public net.minecraft.world.biome.BiomeAmbience field_235206_c_ # waterColor

View File

@ -0,0 +1,26 @@
modLoader="javafml"
loaderVersion="[35,)"
issueTrackerURL="https://github.com/webbukkit/dynmap/issues"
license="Apache Public License v2"
[[mods]]
modId="dynmap"
version="${version}"
displayName="Dynmap"
authors="mikeprimm"
description='''
Dynamic, Google-maps style rendered maps for your Minecraft server
'''
[[dependencies.dynmap]]
modId="forge"
mandatory=true
versionRange="[35,)"
ordering="NONE"
# Side this dependency is applied on - BOTH, CLIENT or SERVER
side="SERVER"
[[dependencies.dynmap]]
modId="minecraft"
mandatory=true
versionRange="[1.16.4,1.17)"
ordering="NONE"
side="SERVER"

View File

@ -0,0 +1,465 @@
# 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
worldborderlabel: "Border"
- 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
# Optional: 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
show-chunk: 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 names using the textures and models of another block name: 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-alias:
# "minecraft:quartz_ore": "stone"
# "diamond_ore": "coal_ore"
# Default image format for HDMaps (png, jpg, jpg-q75, jpg-q80, jpg-q85, jpg-q90, jpg-q95, jpg-q100, webp, webp-q75, webp-q80, webp-q85, webp-q90, webp-q95, webp-q100),
# Note: any webp format requires the presence of the 'webp command line tools' (cwebp, dwebp) (https://developers.google.com/speed/webp/download)
#
# Has no effect on maps with explicit format settings
image-format: jpg-q90
# If cwebp or dwebp are not on the PATH, use these settings to provide their full path. Do not use these settings if the tools are on the PATH
# For Windows, include .exe
#
#cwebpPath: /usr/bin/cwebp
#dwebpPath: /usr/bin/dwebp
# 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
# Player enter/exit title messages for map markers
#
# Processing period - how often to check player positions vs markers - default is 1000ms (1 second)
#enterexitperiod: 1000
# Title message fade in time, in ticks (0.05 second intervals) - default is 10 (1/2 second)
#titleFadeIn: 10
# Title message stay time, in ticks (0.05 second intervals) - default is 70 (3.5 seconds)
#titleStay: 70
# Title message fade out time, in ticks (0.05 seocnd intervals) - default is 20 (1 second)
#titleFadeOut: 20
# Enter/exit messages use on screen titles (true - default), if false chat messages are sent instead
#enterexitUseTitle: true
# Set true if new enter messages should supercede pending exit messages (vs being queued in order), default false
#enterReplacesExits: 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

View File

@ -0,0 +1,6 @@
{
"pack": {
"description": "Dynmap resources",
"pack_format": 6
}
}

View File

@ -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

View File

@ -15,6 +15,7 @@ include ':fabric-1.16.4'
include ':fabric-1.16.2'
include ':fabric-1.16.1'
include ':fabric-1.15.2'
include ':forge-1.16.4'
include ':forge-1.16.3'
include ':forge-1.16.2'
include ':forge-1.16.1'
@ -40,6 +41,7 @@ project(':fabric-1.16.4').projectDir = "$rootDir/fabric-1.16.4" as File
project(':fabric-1.16.2').projectDir = "$rootDir/fabric-1.16.2" as File
project(':fabric-1.16.1').projectDir = "$rootDir/fabric-1.16.1" as File
project(':fabric-1.15.2').projectDir = "$rootDir/fabric-1.15.2" as File
project(':forge-1.16.4').projectDir = "$rootDir/forge-1.16.4" as File
project(':forge-1.16.3').projectDir = "$rootDir/forge-1.16.3" as File
project(':forge-1.16.2').projectDir = "$rootDir/forge-1.16.2" as File
project(':forge-1.16.1').projectDir = "$rootDir/forge-1.16.1" as File