mirror of
https://github.com/webbukkit/dynmap.git
synced 2024-11-13 22:05:12 +01:00
Drop forge 1.13.2 (apologies to the 2 folks that might care...)
This commit is contained in:
Mike Primm
parent
1f8bd81894
commit
f27fbc9f3e
3
forge-1.13.2/.gitignore
vendored
3
forge-1.13.2/.gitignore
vendored
@ -1,3 +0,0 @@
|
||||
/build/
|
||||
/.gradle/
|
||||
/bin/
|
||||
@ -1,85 +0,0 @@
|
||||
buildscript {
|
||||
repositories {
|
||||
maven { url = 'https://files.minecraftforge.net/maven' }
|
||||
maven { url "https://repo.mikeprimm.com" }
|
||||
jcenter()
|
||||
mavenCentral()
|
||||
maven {url = "https://oss.sonatype.org/content/repositories/snapshots/"}
|
||||
}
|
||||
dependencies {
|
||||
classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.+', changing: true
|
||||
}
|
||||
}
|
||||
|
||||
apply plugin: 'net.minecraftforge.gradle'
|
||||
apply plugin: 'com.github.johnrengelman.shadow'
|
||||
apply plugin: 'eclipse'
|
||||
|
||||
eclipse {
|
||||
project {
|
||||
name = "Dynmap(Forge-1.13.2)"
|
||||
}
|
||||
}
|
||||
|
||||
dependencies {
|
||||
implementation project(path: ":DynmapCore", configuration: "shadow")
|
||||
minecraft 'net.minecraftforge:forge:1.13.2-25.0.219'
|
||||
}
|
||||
|
||||
sourceCompatibility = 1.8
|
||||
targetCompatibility = 1.8
|
||||
ext.buildNumber = System.getenv().BUILD_NUMBER ?: "Dev"
|
||||
|
||||
minecraft {
|
||||
mappings channel: 'stable', version: '47-1.13.2'
|
||||
runs {
|
||||
server {
|
||||
workingDirectory project.file('run').canonicalPath
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
project.archivesBaseName = "${project.archivesBaseName}-forge-1.13.2"
|
||||
|
||||
processResources
|
||||
{
|
||||
filesMatching('META-INF/mods.toml') {
|
||||
// replace version and mcversion
|
||||
expand(
|
||||
version: project.version + '-' + project.ext.buildNumber,
|
||||
mcversion: "1.13.2"
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
shadowJar {
|
||||
dependencies {
|
||||
include(dependency(':DynmapCore'))
|
||||
}
|
||||
archiveName = "Dynmap-${parent.version}-forge-1.13.2.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)
|
||||
@ -1,263 +0,0 @@
|
||||
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;
|
||||
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(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.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 */
|
||||
NBTTagList sect = nbt.getList("Sections", 10);
|
||||
for (int i = 0; i < sect.size(); i++) {
|
||||
NBTTagCompound sec = sect.getCompound(i);
|
||||
int secnum = sec.getByte("Y");
|
||||
if (secnum >= this.sectionCnt) {
|
||||
//Log.info("Section " + (int) secnum + " above world height " + worldheight);
|
||||
continue;
|
||||
}
|
||||
if (secnum < 0)
|
||||
continue;
|
||||
//Log.info("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)) {
|
||||
NBTTagList plist = sec.getList("Palette", 10);
|
||||
long[] statelist = sec.getLongArray("BlockStates");
|
||||
palette = new DynmapBlockState[plist.size()];
|
||||
for (int pi = 0; pi < plist.size(); pi++) {
|
||||
NBTTagCompound tc = plist.getCompound(pi);
|
||||
String pname = tc.getString("Name");
|
||||
if (tc.contains("Properties")) {
|
||||
StringBuilder statestr = new StringBuilder();
|
||||
NBTTagCompound 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 bitsperblock = (statelist.length * 64) / 4096;
|
||||
BitArray db = new BitArray(bitsperblock, 4096, statelist);
|
||||
if (bitsperblock > 8) { // Not palette
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
states[j] = DynmapBlockState.getStateByGlobalIndex(db.getAt(j));
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (int j = 0; j < 4096; j++) {
|
||||
int v = 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) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
@ -1,6 +0,0 @@
|
||||
package org.dynmap.forge_1_13_2;
|
||||
|
||||
public class ClientProxy extends Proxy {
|
||||
public ClientProxy() {
|
||||
}
|
||||
}
|
||||
@ -1,133 +0,0 @@
|
||||
package org.dynmap.forge_1_13_2;
|
||||
|
||||
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_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.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 {
|
||||
// Log.warning("[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(event.getCommandDispatcher());
|
||||
}
|
||||
|
||||
@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
@ -1,261 +0,0 @@
|
||||
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().getDayTime();
|
||||
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<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;
|
||||
}
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
@ -1,191 +0,0 @@
|
||||
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<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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,97 +0,0 @@
|
||||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1,103 +0,0 @@
|
||||
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.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<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(EntityPlayer psender, String permission) {
|
||||
if(psender != null) {
|
||||
String n = psender.getName().getString().toLowerCase();
|
||||
return hasPerm(n, permission);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
@Override
|
||||
public boolean hasPermissionNode(EntityPlayer psender, String permission) {
|
||||
if(psender != null) {
|
||||
String player = psender.getName().getString().toLowerCase();
|
||||
return DynmapPlugin.plugin.isOp(player);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,51 +0,0 @@
|
||||
package org.dynmap.forge_1_13_2.permissions;
|
||||
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
|
||||
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<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(EntityPlayer 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(EntityPlayer psender, String permission) {
|
||||
if(psender != null) {
|
||||
return DynmapPlugin.plugin.isOp(psender.getEntity().getName().getString());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@ -1,15 +0,0 @@
|
||||
package org.dynmap.forge_1_13_2.permissions;
|
||||
|
||||
import java.util.Set;
|
||||
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
|
||||
public interface PermissionProvider {
|
||||
boolean has(EntityPlayer sender, String permission);
|
||||
boolean hasPermissionNode(EntityPlayer sender, String permission);
|
||||
|
||||
Set<String> hasOfflinePermissions(String player, Set<String> perms);
|
||||
|
||||
boolean hasOfflinePermission(String player, String perm);
|
||||
|
||||
}
|
||||
@ -1,25 +0,0 @@
|
||||
modLoader="javafml"
|
||||
loaderVersion="[25,)"
|
||||
issueTrackerURL="https://github.com/webbukkit/dynmap/issues"
|
||||
[[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="[25,)"
|
||||
ordering="NONE"
|
||||
# Side this dependency is applied on - BOTH, CLIENT or SERVER
|
||||
side="SERVER"
|
||||
[[dependencies.dynmap]]
|
||||
modId="minecraft"
|
||||
mandatory=true
|
||||
versionRange="[1.13.2]"
|
||||
ordering="NONE"
|
||||
side="SERVER"
|
||||
@ -1,492 +0,0 @@
|
||||
# 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
|
||||
|
||||
# Set default tile scale (0 = 128px x 128x, 1 = 256px x 256px, 2 = 512px x 512px, 3 = 1024px x 1024px, 4 = 2048px x 2048px) - 0 is default
|
||||
# Note: changing this value will result in all maps that use the default value being required to be fully rendered
|
||||
#defaulttilescale: 0
|
||||
|
||||
# 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
|
||||
# mariadb: MariaDB database, at hostname:port in database, accessed via userid with password
|
||||
# postgres: PostgreSQL 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: ""
|
||||
#
|
||||
# AWS S3 backet web site
|
||||
#type: aws_s3
|
||||
#bucketname: "dynmap-bucket-name"
|
||||
#region: us-east-1
|
||||
#aws_access_key_id: "<aws-access-key-id>"
|
||||
#aws_secret_access_key: "<aws-secret-access-key>"
|
||||
#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 or largeplayerfaces
|
||||
smallplayerfaces: false
|
||||
# Option to make player faces larger - don't use with showplayerhealth or smallplayerfaces
|
||||
largeplayerfaces: 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, webp-l),
|
||||
# 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, %uuid% for UUID)
|
||||
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
|
||||
|
||||
# If set to false, disable extraction of webpath content (good if using custom web UI or 3rd party web UI)
|
||||
# Note: web interface is unsupported in this configuration - you're on your own
|
||||
update-webpath-files: true
|
||||
|
||||
# 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
|
||||
|
||||
# Published public URL for Dynmap server (allows users to use 'dynmap url' command to get public URL usable to access server
|
||||
# If not set, 'dynmap url' will not return anything. URL should be fully qualified (e.g. https://mc.westeroscraft.com/)
|
||||
#publicURL: http://my.greatserver.com/dynmap
|
||||
|
||||
# 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
|
||||
|
||||
# Log4J defense: string substituted for attempts to use macros in web chat
|
||||
hackAttemptBlurb: "(IaM5uchA1337Haxr-Ban Me!)"
|
||||
@ -1,6 +0,0 @@
|
||||
{
|
||||
"pack": {
|
||||
"description": "Dynmap resources",
|
||||
"pack_format": 4
|
||||
}
|
||||
}
|
||||
@ -1,27 +0,0 @@
|
||||
#
|
||||
# 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
|
||||
@ -32,7 +32,6 @@ include ':forge-1.17.1'
|
||||
include ':forge-1.16.5'
|
||||
include ':forge-1.15.2'
|
||||
include ':forge-1.14.4'
|
||||
include ':forge-1.13.2'
|
||||
|
||||
project(':spigot').projectDir = "$rootDir/spigot" as File
|
||||
project(':bukkit-helper-113-2').projectDir = "$rootDir/bukkit-helper-113-2" as File
|
||||
@ -58,5 +57,4 @@ project(':forge-1.17.1').projectDir = "$rootDir/forge-1.17.1" as File
|
||||
project(':forge-1.16.5').projectDir = "$rootDir/forge-1.16.5" as File
|
||||
project(':forge-1.15.2').projectDir = "$rootDir/forge-1.15.2" as File
|
||||
project(':forge-1.14.4').projectDir = "$rootDir/forge-1.14.4" as File
|
||||
project(':forge-1.13.2').projectDir = "$rootDir/forge-1.13.2" as File
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user