Upstream/dynmap
1
0
Fork 0
mirror of https://github.com/webbukkit/dynmap.git synced 2024-11-24 03:05:28 +01:00
Code Issues Projects Releases Wiki Activity

Drop Fabric and Forge 1.18 builds (just stick with 1.18.2)

Browse Source
This commit is contained in:
Michael Primm 2022-12-12 00:45:14 -06:00
parent 5ddcf1794e
commit a6548ec0b7
61 changed files with 0 additions and 7343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
fabric-1.18/.gitignore vendored
View File

@ -1,32 +0,0 @@
# gradle
.gradle/
build/
out/
classes/
# eclipse
*.launch
# idea
.idea/
*.iml
*.ipr
*.iws
# vscode
.settings/
.vscode/
bin/
.classpath
.project
# fabric
run/
# other
*.log

59
fabric-1.18/build.gradle
View File

@ -1,59 +0,0 @@
plugins {
id 'fabric-loom' version '0.10.65'
}
archivesBaseName = "Dynmap"
version = parent.version
group = parent.group
eclipse {
project {
name = "Dynmap(Fabric-1.18)"
}
}
configurations {
shadow
implementation.extendsFrom(shadow)
}
dependencies {
minecraft "com.mojang:minecraft:${project.minecraft_version}"
mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
compileOnly group: 'com.google.code.findbugs', name: 'jsr305', version: '3.0.2'
shadow project(path: ':DynmapCore', configuration: 'shadow')
}
processResources {
filesMatching('fabric.mod.json') {
expand "version": project.version
}
}
java {
// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
// if it is present.
// If you remove this line, sources will not be generated.
withSourcesJar()
}
jar {
from "LICENSE"
from {
configurations.shadow.collect { it.toString().contains("guava") ? null : it.isDirectory() ? it : zipTree(it) }
}
}
remapJar {
archiveFileName = "${archivesBaseName}-${project.version}-fabric-${project.minecraft_version}.jar"
destinationDirectory = file '../target'
}
remapJar.doLast {
task ->
ant.checksum file: task.archivePath
}

4
fabric-1.18/gradle.properties
View File

@ -1,4 +0,0 @@
minecraft_version=1.18
yarn_mappings=1.18+build.1
loader_version=0.12.12
fabric_version=0.45.1+1.18

50
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/DynmapMod.java
View File

@ -1,50 +0,0 @@
package org.dynmap.fabric_1_18;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.loader.api.FabricLoader;
import net.fabricmc.loader.api.ModContainer;
import org.dynmap.DynmapCore;
import org.dynmap.Log;
import java.io.File;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
public class DynmapMod implements ModInitializer {
private static final String MODID = "dynmap";
private static final ModContainer MOD_CONTAINER = FabricLoader.getInstance().getModContainer(MODID)
.orElseThrow(() -> new RuntimeException("Failed to get mod container: " + MODID));
// The instance of your mod that Fabric uses.
public static DynmapMod instance;
public static DynmapPlugin plugin;
public static File jarfile;
public static String ver;
public static boolean useforcedchunks;
@Override
public void onInitialize() {
instance = this;
Path path = MOD_CONTAINER.getRootPath();
try {
jarfile = new File(DynmapCore.class.getProtectionDomain().getCodeSource().getLocation().toURI());
} catch (URISyntaxException e) {
Log.severe("Unable to get DynmapCore jar path", e);
}
if (path.getFileSystem().provider().getScheme().equals("jar")) {
path = Paths.get(path.getFileSystem().toString());
jarfile = path.toFile();
}
ver = MOD_CONTAINER.getMetadata().getVersion().getFriendlyString();
Log.setLogger(new FabricLogger());
org.dynmap.modsupport.ModSupportImpl.init();
// Initialize the plugin, we will enable it fully when the server starts.
plugin = new DynmapPlugin();
}
}

795
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/DynmapPlugin.java
View File

@ -1,795 +0,0 @@
package org.dynmap.fabric_1_18;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.fabricmc.fabric.api.command.v1.CommandRegistrationCallback;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerChunkEvents;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerWorldEvents;
import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.block.FluidBlock;
import net.minecraft.block.Material;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.Item;
import net.minecraft.network.ClientConnection;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.command.ServerCommandSource;
import net.minecraft.server.network.ServerPlayNetworkHandler;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.util.Identifier;
import net.minecraft.util.collection.IdList;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.ChunkPos;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.EmptyBlockView;
import net.minecraft.world.World;
import net.minecraft.world.WorldAccess;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.ChunkSection;
import net.minecraft.world.chunk.ChunkStatus;
import net.minecraft.world.chunk.WorldChunk;
import org.dynmap.*;
import org.dynmap.common.BiomeMap;
import org.dynmap.common.DynmapCommandSender;
import org.dynmap.common.DynmapListenerManager;
import org.dynmap.common.DynmapPlayer;
import org.dynmap.common.chunk.GenericChunkCache;
import org.dynmap.fabric_1_18.command.DmapCommand;
import org.dynmap.fabric_1_18.command.DmarkerCommand;
import org.dynmap.fabric_1_18.command.DynmapCommand;
import org.dynmap.fabric_1_18.command.DynmapExpCommand;
import org.dynmap.fabric_1_18.event.BlockEvents;
import org.dynmap.fabric_1_18.event.CustomServerChunkEvents;
import org.dynmap.fabric_1_18.event.CustomServerLifecycleEvents;
import org.dynmap.fabric_1_18.event.PlayerEvents;
import org.dynmap.fabric_1_18.mixin.BiomeEffectsAccessor;
import org.dynmap.fabric_1_18.permissions.FilePermissions;
import org.dynmap.fabric_1_18.permissions.OpPermissions;
import org.dynmap.fabric_1_18.permissions.PermissionProvider;
import org.dynmap.permissions.PermissionsHandler;
import org.dynmap.renderer.DynmapBlockState;
import java.io.File;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.regex.Pattern;
public class DynmapPlugin {
// FIXME: Fix package-private fields after splitting is done
DynmapCore core;
private PermissionProvider permissions;
private boolean core_enabled;
public GenericChunkCache sscache;
public PlayerList playerList;
MapManager mapManager;
/**
* Server is set when running and unset at shutdown.
*/
private net.minecraft.server.MinecraftServer server;
public static DynmapPlugin plugin;
ChatHandler chathandler;
private HashMap<String, Integer> sortWeights = new HashMap<String, Integer>();
private HashMap<String, FabricWorld> worlds = new HashMap<String, FabricWorld>();
private WorldAccess last_world;
private FabricWorld last_fworld;
private Map<String, FabricPlayer> players = new HashMap<String, FabricPlayer>();
private FabricServer fserver;
private boolean tickregistered = false;
// TPS calculator
double tps;
long lasttick;
long avgticklen;
// Per tick limit, in nsec
long perTickLimit = (50000000); // 50 ms
private boolean useSaveFolder = true;
private static final String[] TRIGGER_DEFAULTS = {"blockupdate", "chunkpopulate", "chunkgenerate"};
static final Pattern patternControlCode = Pattern.compile("(?i)\\u00A7[0-9A-FK-OR]");
DynmapPlugin() {
plugin = this;
// Fabric events persist between server instances
ServerLifecycleEvents.SERVER_STARTING.register(this::serverStart);
CommandRegistrationCallback.EVENT.register((dispatcher, dedicated) -> registerCommands(dispatcher));
CustomServerLifecycleEvents.SERVER_STARTED_PRE_WORLD_LOAD.register(this::serverStarted);
ServerLifecycleEvents.SERVER_STOPPING.register(this::serverStop);
}
int getSortWeight(String name) {
return sortWeights.getOrDefault(name, 0);
}
void setSortWeight(String name, int wt) {
sortWeights.put(name, wt);
}
void dropSortWeight(String name) {
sortWeights.remove(name);
}
public static class BlockUpdateRec {
WorldAccess w;
String wid;
int x, y, z;
}
ConcurrentLinkedQueue<BlockUpdateRec> blockupdatequeue = new ConcurrentLinkedQueue<BlockUpdateRec>();
public static DynmapBlockState[] stateByID;
/**
* Initialize block states (org.dynmap.blockstate.DynmapBlockState)
*/
public void initializeBlockStates() {
stateByID = new DynmapBlockState[512 * 32]; // Simple map - scale as needed
Arrays.fill(stateByID, DynmapBlockState.AIR); // Default to air
IdList<BlockState> bsids = Block.STATE_IDS;
DynmapBlockState basebs = null;
Block baseb = null;
int baseidx = 0;
Iterator<BlockState> iter = bsids.iterator();
DynmapBlockState.Builder bld = new DynmapBlockState.Builder();
while (iter.hasNext()) {
BlockState bs = iter.next();
int idx = bsids.getRawId(bs);
if (idx >= stateByID.length) {
int plen = stateByID.length;
stateByID = Arrays.copyOf(stateByID, idx*11/10); // grow array by 10%
Arrays.fill(stateByID, plen, stateByID.length, DynmapBlockState.AIR);
}
Block b = bs.getBlock();
// If this is new block vs last, it's the base block state
if (b != baseb) {
basebs = null;
baseidx = idx;
baseb = b;
}
Identifier ui = Registry.BLOCK.getId(b);
if (ui == null) {
continue;
}
String bn = ui.getNamespace() + ":" + ui.getPath();
// Only do defined names, and not "air"
if (!bn.equals(DynmapBlockState.AIR_BLOCK)) {
Material mat = bs.getMaterial();
String statename = "";
for (net.minecraft.state.property.Property<?> p : bs.getProperties()) {
if (statename.length() > 0) {
statename += ",";
}
statename += p.getName() + "=" + bs.get(p).toString();
}
int lightAtten = bs.isOpaqueFullCube(EmptyBlockView.INSTANCE, BlockPos.ORIGIN) ? 15 : (bs.isTranslucent(EmptyBlockView.INSTANCE, BlockPos.ORIGIN) ? 0 : 1);
//Log.info("statename=" + bn + "[" + statename + "], lightAtten=" + lightAtten);
// Fill in base attributes
bld.setBaseState(basebs).setStateIndex(idx - baseidx).setBlockName(bn).setStateName(statename).setMaterial(mat.toString()).setLegacyBlockID(idx).setAttenuatesLight(lightAtten);
if (mat.isSolid()) { bld.setSolid(); }
if (mat == Material.AIR) { bld.setAir(); }
if (mat == Material.WOOD) { bld.setLog(); }
if (mat == Material.LEAVES) { bld.setLeaves(); }
if ((!bs.getFluidState().isEmpty()) && !(bs.getBlock() instanceof FluidBlock)) {
bld.setWaterlogged();
}
DynmapBlockState dbs = bld.build(); // Build state
stateByID[idx] = dbs;
if (basebs == null) { basebs = dbs; }
}
}
// for (int gidx = 0; gidx < DynmapBlockState.getGlobalIndexMax(); gidx++) {
// DynmapBlockState bs = DynmapBlockState.getStateByGlobalIndex(gidx);
// Log.info(gidx + ":" + bs.toString() + ", gidx=" + bs.globalStateIndex + ", sidx=" + bs.stateIndex);
// }
}
public static final Item getItemByID(int id) {
return Item.byRawId(id);
}
public static final ClientConnection getNetworkManager(ServerPlayNetworkHandler nh) {
return nh.connection;
}
FabricPlayer getOrAddPlayer(ServerPlayerEntity player) {
String name = player.getName().getString();
FabricPlayer fp = players.get(name);
if (fp != null) {
fp.player = player;
} else {
fp = new FabricPlayer(this, player);
players.put(name, fp);
}
return fp;
}
static class ChatMessage {
String message;
ServerPlayerEntity sender;
}
ConcurrentLinkedQueue<ChatMessage> msgqueue = new ConcurrentLinkedQueue<ChatMessage>();
public static class ChatHandler {
private final DynmapPlugin plugin;
ChatHandler(DynmapPlugin plugin) {
this.plugin = plugin;
}
public void handleChat(ServerPlayerEntity player, String message) {
if (!message.startsWith("/")) {
ChatMessage cm = new ChatMessage();
cm.message = message;
cm.sender = player;
plugin.msgqueue.add(cm);
}
}
}
public FabricServer getFabricServer() {
return fserver;
}
private void serverStart(MinecraftServer server) {
// Set the server so we don't NPE during setup
this.server = server;
this.fserver = new FabricServer(this, server);
this.onEnable();
}
private void serverStarted(MinecraftServer server) {
this.onStart();
if (core != null) {
core.serverStarted();
}
}
private void serverStop(MinecraftServer server) {
this.onDisable();
this.server = null;
}
public boolean isOp(String player) {
String[] ops = server.getPlayerManager().getOpList().getNames();
for (String op : ops) {
if (op.equalsIgnoreCase(player)) {
return true;
}
}
// TODO: Consider whether cheats are enabled for integrated server
return server.isSingleplayer() && player.equalsIgnoreCase(server.getSinglePlayerName());
}
boolean hasPerm(PlayerEntity psender, String permission) {
PermissionsHandler ph = PermissionsHandler.getHandler();
if ((ph != null) && (psender != null) && ph.hasPermission(psender.getName().getString(), permission)) {
return true;
}
return permissions.has(psender, permission);
}
boolean hasPermNode(PlayerEntity psender, String permission) {
PermissionsHandler ph = PermissionsHandler.getHandler();
if ((ph != null) && (psender != null) && ph.hasPermissionNode(psender.getName().getString(), permission)) {
return true;
}
return permissions.hasPermissionNode(psender, permission);
}
Set<String> hasOfflinePermissions(String player, Set<String> perms) {
Set<String> rslt = null;
PermissionsHandler ph = PermissionsHandler.getHandler();
if (ph != null) {
rslt = ph.hasOfflinePermissions(player, perms);
}
Set<String> rslt2 = hasOfflinePermissions(player, perms);
if ((rslt != null) && (rslt2 != null)) {
Set<String> newrslt = new HashSet<String>(rslt);
newrslt.addAll(rslt2);
rslt = newrslt;
} else if (rslt2 != null) {
rslt = rslt2;
}
return rslt;
}
boolean hasOfflinePermission(String player, String perm) {
PermissionsHandler ph = PermissionsHandler.getHandler();
if (ph != null) {
if (ph.hasOfflinePermission(player, perm)) {
return true;
}
}
return permissions.hasOfflinePermission(player, perm);
}
void setChatHandler(ChatHandler chatHandler) {
plugin.chathandler = chatHandler;
}
public class TexturesPayload {
public long timestamp;
public String profileId;
public String profileName;
public boolean isPublic;
public Map<String, ProfileTexture> textures;
}
public class ProfileTexture {
public String url;
}
public void loadExtraBiomes(String mcver) {
int cnt = 0;
BiomeMap.loadWellKnownByVersion(mcver);
Registry<Biome> biomeRegistry = getFabricServer().getBiomeRegistry();
Biome[] list = getFabricServer().getBiomeList(biomeRegistry);
for (int i = 0; i < list.length; i++) {
Biome bb = list[i];
if (bb != null) {
String id = biomeRegistry.getId(bb).getPath();
String rl = biomeRegistry.getId(bb).toString();
float tmp = bb.getTemperature(), hum = bb.getDownfall();
int watermult = ((BiomeEffectsAccessor) bb.getEffects()).getWaterColor();
Log.verboseinfo("biome[" + i + "]: hum=" + hum + ", tmp=" + tmp + ", mult=" + Integer.toHexString(watermult));
BiomeMap bmap = BiomeMap.NULL;
if (rl != null) { // If resource location, lookup by this
bmap = BiomeMap.byBiomeResourceLocation(rl);
}
else {
bmap = BiomeMap.byBiomeID(i);
}
if (bmap.isDefault() || (bmap == BiomeMap.NULL)) {
bmap = new BiomeMap((rl != null) ? BiomeMap.NO_INDEX : i, id, tmp, hum, rl);
Log.verboseinfo("Add custom biome [" + bmap.toString() + "] (" + i + ")");
cnt++;
}
else {
bmap.setTemperature(tmp);
bmap.setRainfall(hum);
}
if (watermult != -1) {
bmap.setWaterColorMultiplier(watermult);
Log.verboseinfo("Set watercolormult for " + bmap.toString() + " (" + i + ") to " + Integer.toHexString(watermult));
}
bmap.setBiomeObject(bb);
}
}
if (cnt > 0)
Log.info("Added " + cnt + " custom biome mappings");
}
private String[] getBiomeNames() {
Registry<Biome> biomeRegistry = getFabricServer().getBiomeRegistry();
Biome[] list = getFabricServer().getBiomeList(biomeRegistry);
String[] lst = new String[list.length];
for (int i = 0; i < list.length; i++) {
Biome bb = list[i];
if (bb != null) {
lst[i] = biomeRegistry.getId(bb).getPath();
}
}
return lst;
}
public void onEnable() {
/* Get MC version */
String mcver = server.getVersion();
/* Load extra biomes */
loadExtraBiomes(mcver);
/* Set up player login/quit event handler */
registerPlayerLoginListener();
/* Initialize permissions handler */
permissions = FilePermissions.create();
if (permissions == null) {
permissions = new OpPermissions(new String[]{"webchat", "marker.icons", "marker.list", "webregister", "stats", "hide.self", "show.self"});
}
/* Get and initialize data folder */
File dataDirectory = new File("dynmap");
if (!dataDirectory.exists()) {
dataDirectory.mkdirs();
}
/* Instantiate core */
if (core == null) {
core = new DynmapCore();
}
/* Inject dependencies */
core.setPluginJarFile(DynmapMod.jarfile);
core.setPluginVersion(DynmapMod.ver);
core.setMinecraftVersion(mcver);
core.setDataFolder(dataDirectory);
core.setServer(fserver);
core.setTriggerDefault(TRIGGER_DEFAULTS);
core.setBiomeNames(getBiomeNames());
if (!core.initConfiguration(null)) {
return;
}
// Extract default permission example, if needed
File filepermexample = new File(core.getDataFolder(), "permissions.yml.example");
core.createDefaultFileFromResource("/permissions.yml.example", filepermexample);
DynmapCommonAPIListener.apiInitialized(core);
}
private DynmapCommand dynmapCmd;
private DmapCommand dmapCmd;
private DmarkerCommand dmarkerCmd;
private DynmapExpCommand dynmapexpCmd;
public void registerCommands(CommandDispatcher<ServerCommandSource> cd) {
dynmapCmd = new DynmapCommand(this);
dmapCmd = new DmapCommand(this);
dmarkerCmd = new DmarkerCommand(this);
dynmapexpCmd = new DynmapExpCommand(this);
dynmapCmd.register(cd);
dmapCmd.register(cd);
dmarkerCmd.register(cd);
dynmapexpCmd.register(cd);
Log.info("Register commands");
}
public void onStart() {
initializeBlockStates();
/* Enable core */
if (!core.enableCore(null)) {
return;
}
core_enabled = true;
VersionCheck.runCheck(core);
// Get per tick time limit
perTickLimit = core.getMaxTickUseMS() * 1000000;
// Prep TPS
lasttick = System.nanoTime();
tps = 20.0;
/* Register tick handler */
if (!tickregistered) {
ServerTickEvents.END_SERVER_TICK.register(server -> fserver.tickEvent(server));
tickregistered = true;
}
playerList = core.playerList;
sscache = new GenericChunkCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache());
/* Get map manager from core */
mapManager = core.getMapManager();
/* Load saved world definitions */
loadWorlds();
for (FabricWorld w : worlds.values()) {
if (core.processWorldLoad(w)) { /* Have core process load first - fire event listeners if good load after */
if (w.isLoaded()) {
core.listenerManager.processWorldEvent(DynmapListenerManager.EventType.WORLD_LOAD, w);
}
}
}
core.updateConfigHashcode();
/* Register our update trigger events */
registerEvents();
Log.info("Register events");
//DynmapCommonAPIListener.apiInitialized(core);
Log.info("Enabled");
}
public void onDisable() {
DynmapCommonAPIListener.apiTerminated();
//if (metrics != null) {
// metrics.stop();
// metrics = null;
//}
/* Save worlds */
saveWorlds();
/* Purge tick queue */
fserver.clearTaskQueue();
/* Disable core */
core.disableCore();
core_enabled = false;
if (sscache != null) {
sscache.cleanup();
sscache = null;
}
Log.info("Disabled");
}
// TODO: Clean a bit
public void handleCommand(ServerCommandSource commandSource, String cmd, String[] args) throws CommandSyntaxException {
DynmapCommandSender dsender;
ServerPlayerEntity psender = null;
// getPlayer throws a CommandSyntaxException, so getEntity and instanceof for safety
if (commandSource.getEntity() instanceof ServerPlayerEntity) {
psender = commandSource.getPlayer();
}
if (psender != null) {
// FIXME: New Player? Why not query the current player list.
dsender = new FabricPlayer(this, psender);
} else {
dsender = new FabricCommandSender(commandSource);
}
core.processCommand(dsender, cmd, cmd, args);
}
public class PlayerTracker {
public void onPlayerLogin(ServerPlayerEntity player) {
if (!core_enabled) return;
final DynmapPlayer dp = getOrAddPlayer(player);
/* This event can be called from off server thread, so push processing there */
core.getServer().scheduleServerTask(new Runnable() {
public void run() {
core.listenerManager.processPlayerEvent(DynmapListenerManager.EventType.PLAYER_JOIN, dp);
}
}, 2);
}
public void onPlayerLogout(ServerPlayerEntity player) {
if (!core_enabled) return;
final DynmapPlayer dp = getOrAddPlayer(player);
final String name = player.getName().getString();
/* This event can be called from off server thread, so push processing there */
core.getServer().scheduleServerTask(new Runnable() {
public void run() {
core.listenerManager.processPlayerEvent(DynmapListenerManager.EventType.PLAYER_QUIT, dp);
players.remove(name);
}
}, 0);
}
public void onPlayerChangedDimension(ServerPlayerEntity player) {
if (!core_enabled) return;
getOrAddPlayer(player); // Freshen player object reference
}
public void onPlayerRespawn(ServerPlayerEntity player) {
if (!core_enabled) return;
getOrAddPlayer(player); // Freshen player object reference
}
}
private PlayerTracker playerTracker = null;
private void registerPlayerLoginListener() {
if (playerTracker == null) {
playerTracker = new PlayerTracker();
PlayerEvents.PLAYER_LOGGED_IN.register(player -> playerTracker.onPlayerLogin(player));
PlayerEvents.PLAYER_LOGGED_OUT.register(player -> playerTracker.onPlayerLogout(player));
PlayerEvents.PLAYER_CHANGED_DIMENSION.register(player -> playerTracker.onPlayerChangedDimension(player));
PlayerEvents.PLAYER_RESPAWN.register(player -> playerTracker.onPlayerRespawn(player));
}
}
public class WorldTracker {
public void handleWorldLoad(MinecraftServer server, ServerWorld world) {
if (!core_enabled) return;
final FabricWorld fw = getWorld(world);
// This event can be called from off server thread, so push processing there
core.getServer().scheduleServerTask(new Runnable() {
public void run() {
if (core.processWorldLoad(fw)) // Have core process load first - fire event listeners if good load after
core.listenerManager.processWorldEvent(DynmapListenerManager.EventType.WORLD_LOAD, fw);
}
}, 0);
}
public void handleWorldUnload(MinecraftServer server, ServerWorld world) {
if (!core_enabled) return;
final FabricWorld fw = getWorld(world);
if (fw != null) {
// This event can be called from off server thread, so push processing there
core.getServer().scheduleServerTask(new Runnable() {
public void run() {
core.listenerManager.processWorldEvent(DynmapListenerManager.EventType.WORLD_UNLOAD, fw);
core.processWorldUnload(fw);
}
}, 0);
// Set world unloaded (needs to be immediate, since it may be invalid after event)
fw.setWorldUnloaded();
// Clean up tracker
//WorldUpdateTracker wut = updateTrackers.remove(fw.getName());
//if(wut != null) wut.world = null;
}
}
public void handleChunkGenerate(ServerWorld world, Chunk chunk) {
if (!onchunkgenerate) return;
FabricWorld fw = getWorld(world, false);
ChunkPos chunkPos = chunk.getPos();
int ymax = Integer.MIN_VALUE;
int ymin = Integer.MAX_VALUE;
ChunkSection[] sections = chunk.getSectionArray();
for (int i = 0; i < sections.length; i++) {
if ((sections[i] != null) && (!sections[i].isEmpty())) {
int sy = sections[i].getYOffset();
if (sy < ymin) ymin = sy;
if ((sy+16) > ymax) ymax = sy + 16;
}
}
if (ymax != Integer.MIN_VALUE) {
mapManager.touchVolume(fw.getName(),
chunkPos.getStartX(), ymin, chunkPos.getStartZ(),
chunkPos.getEndX(), ymax, chunkPos.getEndZ(),
"chunkgenerate");
//Log.info("New generated chunk detected at %s[%s]".formatted(fw.getName(), chunkPos.getStartPos()));
}
}
public void handleBlockEvent(World world, BlockPos pos) {
if (!core_enabled) return;
if (!onblockchange) return;
if (!(world instanceof ServerWorld)) return;
BlockUpdateRec r = new BlockUpdateRec();
r.w = world;
FabricWorld fw = getWorld(world, false);
if (fw == null) return;
r.wid = fw.getName();
r.x = pos.getX();
r.y = pos.getY();
r.z = pos.getZ();
blockupdatequeue.add(r);
}
}
private WorldTracker worldTracker = null;
private boolean onblockchange = false;
private boolean onchunkpopulate = false;
private boolean onchunkgenerate = false;
boolean onblockchange_with_id = false;
private void registerEvents() {
// To trigger rendering.
onblockchange = core.isTrigger("blockupdate");
onchunkpopulate = core.isTrigger("chunkpopulate");
onchunkgenerate = core.isTrigger("chunkgenerate");
onblockchange_with_id = core.isTrigger("blockupdate-with-id");
if (onblockchange_with_id)
onblockchange = true;
if (worldTracker == null)
worldTracker = new WorldTracker();
if (onchunkpopulate || onchunkgenerate) {
CustomServerChunkEvents.CHUNK_GENERATE.register((world, chunk) -> worldTracker.handleChunkGenerate(world, chunk));
}
if (onblockchange) {
BlockEvents.BLOCK_EVENT.register((world, pos) -> worldTracker.handleBlockEvent(world, pos));
}
ServerWorldEvents.LOAD.register((server, world) -> worldTracker.handleWorldLoad(server, world));
ServerWorldEvents.UNLOAD.register((server, world) -> worldTracker.handleWorldUnload(server, world));
}
FabricWorld getWorldByName(String name) {
return worlds.get(name);
}
FabricWorld getWorld(World w) {
return getWorld(w, true);
}
private FabricWorld getWorld(World w, boolean add_if_not_found) {
if (last_world == w) {
return last_fworld;
}
String wname = FabricWorld.getWorldName(this, w);
for (FabricWorld fw : worlds.values()) {
if (fw.getRawName().equals(wname)) {
last_world = w;
last_fworld = fw;
if (!fw.isLoaded()) {
fw.setWorldLoaded(w);
}
fw.updateWorld(w);
return fw;
}
}
FabricWorld fw = null;
if (add_if_not_found) {
/* Add to list if not found */
fw = new FabricWorld(this, w);
worlds.put(fw.getName(), fw);
}
last_world = w;
last_fworld = fw;
return fw;
}
private void saveWorlds() {
File f = new File(core.getDataFolder(), FabricWorld.SAVED_WORLDS_FILE);
ConfigurationNode cn = new ConfigurationNode(f);
ArrayList<HashMap<String, Object>> lst = new ArrayList<HashMap<String, Object>>();
for (DynmapWorld fw : core.mapManager.getWorlds()) {
HashMap<String, Object> vals = new HashMap<String, Object>();
vals.put("name", fw.getRawName());
vals.put("height", fw.worldheight);
vals.put("miny", fw.minY);
vals.put("sealevel", fw.sealevel);
vals.put("nether", fw.isNether());
vals.put("the_end", ((FabricWorld) fw).isTheEnd());
vals.put("title", fw.getTitle());
lst.add(vals);
}
cn.put("worlds", lst);
cn.put("useSaveFolderAsName", useSaveFolder);
cn.put("maxWorldHeight", FabricWorld.getMaxWorldHeight());
cn.save();
}
private void loadWorlds() {
File f = new File(core.getDataFolder(), FabricWorld.SAVED_WORLDS_FILE);
if (f.canRead() == false) {
useSaveFolder = true;
return;
}
ConfigurationNode cn = new ConfigurationNode(f);
cn.load();
// If defined, use maxWorldHeight
FabricWorld.setMaxWorldHeight(cn.getInteger("maxWorldHeight", 256));
// If setting defined, use it
if (cn.containsKey("useSaveFolderAsName")) {
useSaveFolder = cn.getBoolean("useSaveFolderAsName", useSaveFolder);
}
List<Map<String, Object>> lst = cn.getMapList("worlds");
if (lst == null) {
Log.warning(String.format("Discarding bad %s", FabricWorld.SAVED_WORLDS_FILE));
return;
}
for (Map<String, Object> world : lst) {
try {
String name = (String) world.get("name");
int height = (Integer) world.get("height");
Integer miny = (Integer) world.get("miny");
int sealevel = (Integer) world.get("sealevel");
boolean nether = (Boolean) world.get("nether");
boolean theend = (Boolean) world.get("the_end");
String title = (String) world.get("title");
if (name != null) {
FabricWorld fw = new FabricWorld(this, name, height, sealevel, nether, theend, title, (miny != null) ? miny : 0);
fw.setWorldUnloaded();
core.processWorldLoad(fw);
worlds.put(fw.getName(), fw);
}
} catch (Exception x) {
Log.warning(String.format("Unable to load saved worlds from %s", FabricWorld.SAVED_WORLDS_FILE));
return;
}
}
}
}

13
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricAdapter.java
View File

@ -1,13 +0,0 @@
package org.dynmap.fabric_1_18;
import net.minecraft.server.world.ServerWorld;
import org.dynmap.DynmapLocation;
public final class FabricAdapter {
public static DynmapLocation toDynmapLocation(DynmapPlugin plugin, ServerWorld world, double x, double y, double z) {
return new DynmapLocation(plugin.getWorld(world).getName(), x, y, z);
}
private FabricAdapter() {
}
}

47
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricCommandSender.java
View File

@ -1,47 +0,0 @@
package org.dynmap.fabric_1_18;
import net.minecraft.server.command.ServerCommandSource;
import net.minecraft.text.LiteralText;
import net.minecraft.text.Text;
import org.dynmap.common.DynmapCommandSender;
/* Handler for generic console command sender */
public class FabricCommandSender implements DynmapCommandSender {
private ServerCommandSource sender;
protected FabricCommandSender() {
sender = null;
}
public FabricCommandSender(ServerCommandSource send) {
sender = send;
}
@Override
public boolean hasPrivilege(String privid) {
return true;
}
@Override
public void sendMessage(String msg) {
if (sender != null) {
Text ichatcomponent = new LiteralText(msg);
sender.sendFeedback(ichatcomponent, false);
}
}
@Override
public boolean isConnected() {
return false;
}
@Override
public boolean isOp() {
return true;
}
@Override
public boolean hasPermissionNode(String node) {
return true;
}
}

49
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricLogger.java
View File

@ -1,49 +0,0 @@
package org.dynmap.fabric_1_18;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.dynmap.utils.DynmapLogger;
public class FabricLogger implements DynmapLogger {
Logger log;
public static final String DM = "[Dynmap] ";
FabricLogger() {
log = LogManager.getLogger("Dynmap");
}
@Override
public void info(String s) {
log.info(DM + s);
}
@Override
public void severe(Throwable t) {
log.fatal(t);
}
@Override
public void severe(String s) {
log.fatal(DM + s);
}
@Override
public void severe(String s, Throwable t) {
log.fatal(DM + s, t);
}
@Override
public void verboseinfo(String s) {
log.info(DM + s);
}
@Override
public void warning(String s) {
log.warn(DM + s);
}
@Override
public void warning(String s, Throwable t) {
log.warn(DM + s, t);
}
}

115
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricMapChunkCache.java
View File

@ -1,115 +0,0 @@
package org.dynmap.fabric_1_18;
import net.minecraft.nbt.*;
import net.minecraft.server.world.ServerChunkManager;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.server.world.ThreadedAnvilChunkStorage;
import net.minecraft.util.collection.PackedIntegerArray;
import net.minecraft.util.math.ChunkPos;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.WordPackedArray;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.ChunkSerializer;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import net.minecraft.world.biome.BiomeEffects;
import net.minecraft.world.chunk.ChunkManager;
import net.minecraft.world.chunk.ChunkStatus;
import org.dynmap.DynmapChunk;
import org.dynmap.DynmapCore;
import org.dynmap.DynmapWorld;
import org.dynmap.Log;
import org.dynmap.common.BiomeMap;
import org.dynmap.common.chunk.GenericChunk;
import org.dynmap.common.chunk.GenericChunkSection;
import org.dynmap.common.chunk.GenericMapChunkCache;
import org.dynmap.hdmap.HDBlockModels;
import org.dynmap.renderer.DynmapBlockState;
import org.dynmap.renderer.RenderPatchFactory;
import org.dynmap.utils.*;
import java.lang.reflect.Field;
import java.util.*;
/**
* Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread
*/
public class FabricMapChunkCache extends GenericMapChunkCache {
private World w;
private ServerChunkManager cps;
/**
* Construct empty cache
*/
public FabricMapChunkCache(DynmapPlugin plugin) {
super(plugin.sscache);
}
public void setChunks(FabricWorld dw, List<DynmapChunk> chunks) {
this.w = dw.getWorld();
if (dw.isLoaded()) {
/* Check if world's provider is ServerChunkManager */
ChunkManager cp = this.w.getChunkManager();
if (cp instanceof ServerChunkManager) {
cps = (ServerChunkManager) cp;
} else {
Log.severe("Error: world " + dw.getName() + " has unsupported chunk provider");
}
}
super.setChunks(dw, chunks);
}
// Load generic chunk from existing and already loaded chunk
protected GenericChunk getLoadedChunk(DynmapChunk chunk) {
GenericChunk gc = null;
if (cps.isChunkLoaded(chunk.x, chunk.z)) {
NbtCompound nbt = null;
try {
nbt = ChunkSerializer.serialize((ServerWorld) w, cps.getWorldChunk(chunk.x, chunk.z, false));
} catch (NullPointerException e) {
// TODO: find out why this is happening and why it only seems to happen since 1.16.2
Log.severe("ChunkSerializer.serialize threw a NullPointerException", e);
}
if (nbt != null) {
gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
}
}
return gc;
}
private NbtCompound readChunk(int x, int z) {
try {
ThreadedAnvilChunkStorage acl = cps.threadedAnvilChunkStorage;
ChunkPos coord = new ChunkPos(x, z);
return acl.getNbt(coord);
} catch (Exception exc) {
Log.severe(String.format("Error reading chunk: %s,%d,%d", dw.getName(), x, z), exc);
return null;
}
}
// Load generic chunk from unloaded chunk
protected GenericChunk loadChunk(DynmapChunk chunk) {
GenericChunk gc = null;
NbtCompound nbt = readChunk(chunk.x, chunk.z);
// If read was good
if (nbt != null) {
gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
}
return gc;
}
@Override
public int getFoliageColor(BiomeMap bm, int[] colormap, int x, int z) {
return bm.<Biome>getBiomeObject().map(Biome::getEffects).flatMap(BiomeEffects::getFoliageColor).orElse(colormap[bm.biomeLookup()]);
}
@Override
public int getGrassColor(BiomeMap bm, int[] colormap, int x, int z) {
BiomeEffects effects = bm.<Biome>getBiomeObject().map(Biome::getEffects).orElse(null);
if (effects == null) return colormap[bm.biomeLookup()];
return effects.getGrassColorModifier().getModifiedGrassColor(x, z, effects.getGrassColor().orElse(colormap[bm.biomeLookup()]));
}
}

252
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricPlayer.java
View File

@ -1,252 +0,0 @@
package org.dynmap.fabric_1_18;
import com.google.common.collect.Iterables;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonParseException;
import com.mojang.authlib.GameProfile;
import com.mojang.authlib.properties.Property;
import net.minecraft.network.packet.s2c.play.SubtitleS2CPacket;
import net.minecraft.network.packet.s2c.play.TitleFadeS2CPacket;
import net.minecraft.network.packet.s2c.play.TitleS2CPacket;
import net.minecraft.server.network.ServerPlayNetworkHandler;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.text.LiteralText;
import net.minecraft.text.Text;
import net.minecraft.util.Util;
import net.minecraft.util.math.Vec3d;
import org.dynmap.DynmapLocation;
import org.dynmap.common.DynmapPlayer;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.UUID;
/**
* Player access abstraction class
*/
public class FabricPlayer extends FabricCommandSender implements DynmapPlayer {
private static final Gson GSON = new GsonBuilder().create();
private final DynmapPlugin plugin;
// FIXME: Proper setter
ServerPlayerEntity player;
private final String skinurl;
private final UUID uuid;
public FabricPlayer(DynmapPlugin plugin, ServerPlayerEntity player) {
this.plugin = plugin;
this.player = player;
String url = null;
if (this.player != null) {
uuid = this.player.getUuid();
GameProfile prof = this.player.getGameProfile();
if (prof != null) {
Property textureProperty = Iterables.getFirst(prof.getProperties().get("textures"), null);
if (textureProperty != null) {
DynmapPlugin.TexturesPayload result = null;
try {
String json = new String(Base64.getDecoder().decode(textureProperty.getValue()), StandardCharsets.UTF_8);
result = GSON.fromJson(json, DynmapPlugin.TexturesPayload.class);
} catch (JsonParseException e) {
}
if ((result != null) && (result.textures != null) && (result.textures.containsKey("SKIN"))) {
url = result.textures.get("SKIN").url;
}
}
}
} else {
uuid = null;
}
skinurl = url;
}
@Override
public boolean isConnected() {
return true;
}
@Override
public String getName() {
if (player != null) {
String n = player.getName().getString();
;
return n;
} else
return "[Server]";
}
@Override
public String getDisplayName() {
if (player != null) {
String n = player.getDisplayName().getString();
return n;
} else
return "[Server]";
}
@Override
public boolean isOnline() {
return true;
}
@Override
public DynmapLocation getLocation() {
if (player == null) {
return null;
}
Vec3d pos = player.getPos();
return FabricAdapter.toDynmapLocation(plugin, player.getWorld(), pos.getX(), pos.getY(), pos.getZ());
}
@Override
public String getWorld() {
if (player == null) {
return null;
}
if (player.world != null) {
return plugin.getWorld(player.world).getName();
}
return null;
}
@Override
public InetSocketAddress getAddress() {
if (player != null) {
ServerPlayNetworkHandler networkHandler = player.networkHandler;
if ((networkHandler != null) && (networkHandler.getConnection() != null)) {
SocketAddress sa = networkHandler.getConnection().getAddress();
if (sa instanceof InetSocketAddress) {
return (InetSocketAddress) sa;
}
}
}
return null;
}
@Override
public boolean isSneaking() {
if (player != null) {
return player.isSneaking();
}
return false;
}
@Override
public double getHealth() {
if (player != null) {
double h = player.getHealth();
if (h > 20) h = 20;
return h; // Scale to 20 range
} else {
return 0;
}
}
@Override
public int getArmorPoints() {
if (player != null) {
return player.getArmor();
} else {
return 0;
}
}
@Override
public DynmapLocation getBedSpawnLocation() {
return null;
}
@Override
public long getLastLoginTime() {
return 0;
}
@Override
public long getFirstLoginTime() {
return 0;
}
@Override
public boolean hasPrivilege(String privid) {
if (player != null)
return plugin.hasPerm(player, privid);
return false;
}
@Override
public boolean isOp() {
return plugin.isOp(player.getName().getString());
}
@Override
public void sendMessage(String msg) {
Text ichatcomponent = new LiteralText(msg);
player.sendSystemMessage(ichatcomponent, Util.NIL_UUID);
}
@Override
public boolean isInvisible() {
if (player != null) {
return player.isInvisible();
}
return false;
}
@Override
public int getSortWeight() {
return plugin.getSortWeight(getName());
}
@Override
public void setSortWeight(int wt) {
if (wt == 0) {
plugin.dropSortWeight(getName());
} else {
plugin.setSortWeight(getName(), wt);
}
}
@Override
public boolean hasPermissionNode(String node) {
return player != null && plugin.hasPermNode(player, node);
}
@Override
public String getSkinURL() {
return skinurl;
}
@Override
public UUID getUUID() {
return uuid;
}
/**
* Send title and subtitle text (called from server thread)
*/
@Override
public void sendTitleText(String title, String subtitle, int fadeInTicks, int stayTicks, int fadeOutTicks) {
if (player != null) {
ServerPlayerEntity player = this.player;
TitleFadeS2CPacket times = new TitleFadeS2CPacket(fadeInTicks, stayTicks, fadeOutTicks);
player.networkHandler.sendPacket(times);
if (title != null) {
TitleS2CPacket titlepkt = new TitleS2CPacket(new LiteralText(title));
player.networkHandler.sendPacket(titlepkt);
}
if (subtitle != null) {
SubtitleS2CPacket subtitlepkt = new SubtitleS2CPacket(new LiteralText(subtitle));
player.networkHandler.sendPacket(subtitlepkt);
}
}
}
}

609
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricServer.java
View File

@ -1,609 +0,0 @@
package org.dynmap.fabric_1_18;
import com.mojang.authlib.GameProfile;
import net.fabricmc.loader.api.FabricLoader;
import net.fabricmc.loader.api.ModContainer;
import net.minecraft.block.AbstractSignBlock;
import net.minecraft.block.Block;
import net.minecraft.block.BlockState;
import net.minecraft.network.MessageType;
import net.minecraft.server.BannedIpList;
import net.minecraft.server.BannedPlayerList;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.PlayerManager;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.text.LiteralText;
import net.minecraft.text.Text;
import net.minecraft.util.UserCache;
import net.minecraft.util.Util;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.World;
import net.minecraft.world.biome.Biome;
import org.dynmap.DynmapChunk;
import org.dynmap.DynmapCommonAPIListener;
import org.dynmap.DynmapWorld;
import org.dynmap.Log;
import org.dynmap.common.BiomeMap;
import org.dynmap.common.DynmapListenerManager;
import org.dynmap.common.DynmapPlayer;
import org.dynmap.common.DynmapServerInterface;
import org.dynmap.fabric_1_18.event.BlockEvents;
import org.dynmap.fabric_1_18.event.ServerChatEvents;
import org.dynmap.utils.MapChunkCache;
import org.dynmap.utils.VisibilityLimit;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
/**
* Server access abstraction class
*/
public class FabricServer extends DynmapServerInterface {
/* Server thread scheduler */
private final Object schedlock = new Object();
private final DynmapPlugin plugin;
private final MinecraftServer server;
private final Registry<Biome> biomeRegistry;
private long cur_tick;
private long next_id;
private long cur_tick_starttime;
private PriorityQueue<TaskRecord> runqueue = new PriorityQueue<TaskRecord>();
public FabricServer(DynmapPlugin plugin, MinecraftServer server) {
this.plugin = plugin;
this.server = server;
this.biomeRegistry = server.getRegistryManager().get(Registry.BIOME_KEY);
}
private Optional<GameProfile> getProfileByName(String player) {
UserCache cache = server.getUserCache();
return cache.findByName(player);
}
public final Registry<Biome> getBiomeRegistry() {
return biomeRegistry;
}
private Biome[] biomelist = null;
public final Biome[] getBiomeList(Registry<Biome> biomeRegistry) {
if (biomelist == null) {
biomelist = new Biome[256];
Iterator<Biome> iter = biomeRegistry.iterator();
while (iter.hasNext()) {
Biome b = iter.next();
int bidx = biomeRegistry.getRawId(b);
if (bidx >= biomelist.length) {
biomelist = Arrays.copyOf(biomelist, bidx + biomelist.length);
}
biomelist[bidx] = b;
}
}
return biomelist;
}
@Override
public int getBlockIDAt(String wname, int x, int y, int z) {
return -1;
}
@SuppressWarnings("deprecation") /* Not much I can do... fix this if it breaks. */
@Override
public int isSignAt(String wname, int x, int y, int z) {
World world = plugin.getWorldByName(wname).getWorld();
BlockPos pos = new BlockPos(x, y, z);
if (!world.isChunkLoaded(pos))
return -1;
Block block = world.getBlockState(pos).getBlock();
return (block instanceof AbstractSignBlock ? 1 : 0);
}
@Override
public void scheduleServerTask(Runnable run, long delay) {
/* Add task record to queue */
synchronized (schedlock) {
TaskRecord tr = new TaskRecord(cur_tick + delay, next_id++, new FutureTask<Object>(run, null));
runqueue.add(tr);
}
}
@Override
public DynmapPlayer[] getOnlinePlayers() {
if (server.getPlayerManager() == null) return new DynmapPlayer[0];
List<ServerPlayerEntity> players = server.getPlayerManager().getPlayerList();
int playerCount = players.size();
DynmapPlayer[] dplay = new DynmapPlayer[players.size()];
for (int i = 0; i < playerCount; i++) {
ServerPlayerEntity player = players.get(i);
dplay[i] = plugin.getOrAddPlayer(player);
}
return dplay;
}
@Override
public void reload() {
plugin.onDisable();
plugin.onEnable();
plugin.onStart();
}
@Override
public DynmapPlayer getPlayer(String name) {
List<ServerPlayerEntity> players = server.getPlayerManager().getPlayerList();
for (ServerPlayerEntity player : players) {
if (player.getName().getString().equalsIgnoreCase(name)) {
return plugin.getOrAddPlayer(player);
}
}
return null;
}
@Override
public Set<String> getIPBans() {
BannedIpList bl = server.getPlayerManager().getIpBanList();
Set<String> ips = new HashSet<String>();
for (String s : bl.getNames()) {
ips.add(s);
}
return ips;
}
@Override
public <T> Future<T> callSyncMethod(Callable<T> task) {
return callSyncMethod(task, 0);
}
public <T> Future<T> callSyncMethod(Callable<T> task, long delay) {
FutureTask<T> ft = new FutureTask<T>(task);
/* Add task record to queue */
synchronized (schedlock) {
TaskRecord tr = new TaskRecord(cur_tick + delay, next_id++, ft);
runqueue.add(tr);
}
return ft;
}
void clearTaskQueue() {
this.runqueue.clear();
}
@Override
public String getServerName() {
String sn;
if (server.isSingleplayer())
sn = "Integrated";
else
sn = server.getServerIp();
if (sn == null) sn = "Unknown Server";
return sn;
}
@Override
public boolean isPlayerBanned(String pid) {
PlayerManager scm = server.getPlayerManager();
BannedPlayerList bl = scm.getUserBanList();
try {
return bl.contains(getProfileByName(pid).get());
} catch (NoSuchElementException e) {
/* If this profile doesn't exist, default to "banned" for good measure. */
return true;
}
}
@Override
public String stripChatColor(String s) {
return DynmapPlugin.patternControlCode.matcher(s).replaceAll("");
}
private Set<DynmapListenerManager.EventType> registered = new HashSet<DynmapListenerManager.EventType>();
@Override
public boolean requestEventNotification(DynmapListenerManager.EventType type) {
if (registered.contains(type)) {
return true;
}
switch (type) {
case WORLD_LOAD:
case WORLD_UNLOAD:
/* Already called for normal world activation/deactivation */
break;
case WORLD_SPAWN_CHANGE:
/*TODO
pm.registerEvents(new Listener() {
@EventHandler(priority=EventPriority.MONITOR)
public void onSpawnChange(SpawnChangeEvent evt) {
DynmapWorld w = new BukkitWorld(evt.getWorld());
core.listenerManager.processWorldEvent(EventType.WORLD_SPAWN_CHANGE, w);
}
}, DynmapPlugin.this);
*/
break;
case PLAYER_JOIN:
case PLAYER_QUIT:
/* Already handled */
break;
case PLAYER_BED_LEAVE:
/*TODO
pm.registerEvents(new Listener() {
@EventHandler(priority=EventPriority.MONITOR)
public void onPlayerBedLeave(PlayerBedLeaveEvent evt) {
DynmapPlayer p = new BukkitPlayer(evt.getPlayer());
core.listenerManager.processPlayerEvent(EventType.PLAYER_BED_LEAVE, p);
}
}, DynmapPlugin.this);
*/
break;
case PLAYER_CHAT:
if (plugin.chathandler == null) {
plugin.setChatHandler(new DynmapPlugin.ChatHandler(plugin));
ServerChatEvents.EVENT.register((player, message) -> plugin.chathandler.handleChat(player, message));
}
break;
case BLOCK_BREAK:
/* Already handled by BlockEvents logic */
break;
case SIGN_CHANGE:
BlockEvents.SIGN_CHANGE_EVENT.register((world, pos, lines, material, player) -> {
plugin.core.processSignChange("fabric", FabricWorld.getWorldName(plugin, world),
pos.getX(), pos.getY(), pos.getZ(), lines, player.getName().asString());
});
break;
default:
Log.severe("Unhandled event type: " + type);
return false;
}
registered.add(type);
return true;
}
@Override
public boolean sendWebChatEvent(String source, String name, String msg) {
return DynmapCommonAPIListener.fireWebChatEvent(source, name, msg);
}
@Override
public void broadcastMessage(String msg) {
Text component = new LiteralText(msg);
server.getPlayerManager().broadcast(component, MessageType.SYSTEM, Util.NIL_UUID);
Log.info(stripChatColor(msg));
}
@Override
public String[] getBiomeIDs() {
BiomeMap[] b = BiomeMap.values();
String[] bname = new String[b.length];
for (int i = 0; i < bname.length; i++) {
bname[i] = b[i].toString();
}
return bname;
}
@Override
public double getCacheHitRate() {
if (plugin.sscache != null)
return plugin.sscache.getHitRate();
return 0.0;
}
@Override
public void resetCacheStats() {
if (plugin.sscache != null)
plugin.sscache.resetStats();
}
@Override
public DynmapWorld getWorldByName(String wname) {
return plugin.getWorldByName(wname);
}
@Override
public DynmapPlayer getOfflinePlayer(String name) {
/*
OfflinePlayer op = getServer().getOfflinePlayer(name);
if(op != null) {
return new BukkitPlayer(op);
}
*/
return null;
}
@Override
public Set<String> checkPlayerPermissions(String player, Set<String> perms) {
if (isPlayerBanned(player)) {
return Collections.emptySet();
}
Set<String> rslt = plugin.hasOfflinePermissions(player, perms);
if (rslt == null) {
rslt = new HashSet<String>();
if (plugin.isOp(player)) {
rslt.addAll(perms);
}
}
return rslt;
}
@Override
public boolean checkPlayerPermission(String player, String perm) {
if (isPlayerBanned(player)) {
return false;
}
return plugin.hasOfflinePermission(player, perm);
}
/**
* Render processor helper - used by code running on render threads to request chunk snapshot cache from server/sync thread
*/
@Override
public MapChunkCache createMapChunkCache(DynmapWorld w, List<DynmapChunk> chunks,
boolean blockdata, boolean highesty, boolean biome, boolean rawbiome) {
FabricMapChunkCache c = (FabricMapChunkCache) w.getChunkCache(chunks);
if (c == null) {
return null;
}
if (w.visibility_limits != null) {
for (VisibilityLimit limit : w.visibility_limits) {
c.setVisibleRange(limit);
}
c.setHiddenFillStyle(w.hiddenchunkstyle);
}
if (w.hidden_limits != null) {
for (VisibilityLimit limit : w.hidden_limits) {
c.setHiddenRange(limit);
}
c.setHiddenFillStyle(w.hiddenchunkstyle);
}
if (!c.setChunkDataTypes(blockdata, biome, highesty, rawbiome)) {
Log.severe("CraftBukkit build does not support biome APIs");
}
if (chunks.size() == 0) /* No chunks to get? */ {
c.loadChunks(0);
return c;
}
//Now handle any chunks in server thread that are already loaded (on server thread)
final FabricMapChunkCache cc = c;
Future<Boolean> f = this.callSyncMethod(new Callable<Boolean>() {
public Boolean call() throws Exception {
// Update busy state on world
//FabricWorld fw = (FabricWorld) cc.getWorld();
//TODO
//setBusy(fw.getWorld());
cc.getLoadedChunks();
return true;
}
}, 0);
try {
f.get();
} catch (CancellationException cx) {
return null;
} catch (InterruptedException cx) {
return null;
} catch (ExecutionException xx) {
Log.severe("Exception while loading chunks", xx.getCause());
return null;
} catch (Exception ix) {
Log.severe(ix);
return null;
}
if (!w.isLoaded()) {
return null;
}
// Now, do rest of chunk reading from calling thread
c.readChunks(chunks.size());
return c;
}
@Override
public int getMaxPlayers() {
return server.getMaxPlayerCount();
}
@Override
public int getCurrentPlayers() {
return server.getPlayerManager().getCurrentPlayerCount();
}
public void tickEvent(MinecraftServer server) {
cur_tick_starttime = System.nanoTime();
long elapsed = cur_tick_starttime - plugin.lasttick;
plugin.lasttick = cur_tick_starttime;
plugin.avgticklen = ((plugin.avgticklen * 99) / 100) + (elapsed / 100);
plugin.tps = (double) 1E9 / (double) plugin.avgticklen;
// Tick core
if (plugin.core != null) {
plugin.core.serverTick(plugin.tps);
}
boolean done = false;
TaskRecord tr = null;
while (!plugin.blockupdatequeue.isEmpty()) {
DynmapPlugin.BlockUpdateRec r = plugin.blockupdatequeue.remove();
BlockState bs = r.w.getBlockState(new BlockPos(r.x, r.y, r.z));
int idx = Block.STATE_IDS.getRawId(bs);
if (!org.dynmap.hdmap.HDBlockModels.isChangeIgnoredBlock(DynmapPlugin.stateByID[idx])) {
if (plugin.onblockchange_with_id)
plugin.mapManager.touch(r.wid, r.x, r.y, r.z, "blockchange[" + idx + "]");
else
plugin.mapManager.touch(r.wid, r.x, r.y, r.z, "blockchange");
}
}
long now;
synchronized (schedlock) {
cur_tick++;
now = System.nanoTime();
tr = runqueue.peek();
/* Nothing due to run */
if ((tr == null) || (tr.getTickToRun() > cur_tick) || ((now - cur_tick_starttime) > plugin.perTickLimit)) {
done = true;
} else {
tr = runqueue.poll();
}
}
while (!done) {
tr.run();
synchronized (schedlock) {
tr = runqueue.peek();
now = System.nanoTime();
/* Nothing due to run */
if ((tr == null) || (tr.getTickToRun() > cur_tick) || ((now - cur_tick_starttime) > plugin.perTickLimit)) {
done = true;
} else {
tr = runqueue.poll();
}
}
}
while (!plugin.msgqueue.isEmpty()) {
DynmapPlugin.ChatMessage cm = plugin.msgqueue.poll();
DynmapPlayer dp = null;
if (cm.sender != null)
dp = plugin.getOrAddPlayer(cm.sender);
else
dp = new FabricPlayer(plugin, null);
plugin.core.listenerManager.processChatEvent(DynmapListenerManager.EventType.PLAYER_CHAT, dp, cm.message);
}
// Check for generated chunks
if ((cur_tick % 20) == 0) {
}
}
private Optional<ModContainer> getModContainerById(String id) {
return FabricLoader.getInstance().getModContainer(id);
}
@Override
public boolean isModLoaded(String name) {
return FabricLoader.getInstance().getModContainer(name).isPresent();
}
@Override
public String getModVersion(String name) {
Optional<ModContainer> mod = getModContainerById(name); // Try case sensitive lookup
return mod.map(modContainer -> modContainer.getMetadata().getVersion().getFriendlyString()).orElse(null);
}
@Override
public double getServerTPS() {
return plugin.tps;
}
@Override
public String getServerIP() {
if (server.isSingleplayer())
return "0.0.0.0";
else
return server.getServerIp();
}
@Override
public File getModContainerFile(String name) {
Optional<ModContainer> container = getModContainerById(name); // Try case sensitive lookup
if (container.isPresent()) {
Path path = container.get().getRootPath();
if (path.getFileSystem().provider().getScheme().equals("jar")) {
path = Paths.get(path.getFileSystem().toString());
}
return path.toFile();
}
return null;
}
@Override
public List<String> getModList() {
return FabricLoader.getInstance()
.getAllMods()
.stream()
.map(container -> container.getMetadata().getId())
.collect(Collectors.toList());
}
@Override
public Map<Integer, String> getBlockIDMap() {
Map<Integer, String> map = new HashMap<Integer, String>();
return map;
}
@Override
public InputStream openResource(String modid, String rname) {
if (modid == null) modid = "minecraft";
if ("minecraft".equals(modid)) {
return MinecraftServer.class.getClassLoader().getResourceAsStream(rname);
} else {
if (rname.startsWith("/") || rname.startsWith("\\")) {
rname = rname.substring(1);
}
final String finalModid = modid;
final String finalRname = rname;
return getModContainerById(modid).map(container -> {
try {
return Files.newInputStream(container.getPath(finalRname));
} catch (IOException e) {
Log.severe("Failed to load resource of mod :" + finalModid, e);
return null;
}
}).orElse(null);
}
}
/**
* Get block unique ID map (module:blockid)
*/
@Override
public Map<String, Integer> getBlockUniqueIDMap() {
HashMap<String, Integer> map = new HashMap<String, Integer>();
return map;
}
/**
* Get item unique ID map (module:itemid)
*/
@Override
public Map<String, Integer> getItemUniqueIDMap() {
HashMap<String, Integer> map = new HashMap<String, Integer>();
return map;
}
}

229
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/FabricWorld.java
View File

@ -1,229 +0,0 @@
package org.dynmap.fabric_1_18;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.registry.RegistryKey;
import net.minecraft.world.Heightmap;
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;
import java.util.List;
public class FabricWorld extends DynmapWorld {
// TODO: Store this relative to World saves for integrated server
public static final String SAVED_WORLDS_FILE = "fabricworlds.yml";
private final DynmapPlugin plugin;
private World 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 = 320; // Maximum allows world height
public static int getMaxWorldHeight() {
return maxWorldHeight;
}
public static void setMaxWorldHeight(int h) {
maxWorldHeight = h;
}
public static String getWorldName(DynmapPlugin plugin, World w) {
RegistryKey<World> rk = w.getRegistryKey();
if (rk == World.OVERWORLD) { // Overworld?
return w.getServer().getSaveProperties().getLevelName();
} else if (rk == World.END) {
return "DIM1";
} else if (rk == World.NETHER) {
return "DIM-1";
} else {
return rk.getValue().getNamespace() + "_" + rk.getValue().getPath();
}
}
public void updateWorld(World w) {
this.updateWorldHeights(w.getHeight(), w.getDimension().getMinimumY(), w.getSeaLevel());
}
public FabricWorld(DynmapPlugin plugin, World w) {
this(plugin, getWorldName(plugin, w), w.getHeight(),
w.getSeaLevel(),
w.getRegistryKey() == World.NETHER,
w.getRegistryKey() == World.END,
w.getRegistryKey().getValue().getPath(),
w.getDimension().getMinimumY());
setWorldLoaded(w);
}
public FabricWorld(DynmapPlugin plugin, String name, int height, int sealevel, boolean nether, boolean the_end, String deftitle, int miny) {
super(name, (height > maxWorldHeight) ? maxWorldHeight : height, sealevel, miny);
this.plugin = plugin;
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.getLevelProperties().getSpawnX();
spawnloc.y = world.getLevelProperties().getSpawnY();
spawnloc.z = world.getLevelProperties().getSpawnZ();
spawnloc.world = this.getName();
}
return spawnloc;
}
/* Get world time */
@Override
public long getTime() {
if (world != null)
return world.getTimeOfDay();
else
return -1;
}
/* World is storming */
@Override
public boolean hasStorm() {
if (world != null)
return world.isRaining();
else
return false;
}
/* World is thundering */
@Override
public boolean isThundering() {
if (world != null)
return world.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(World 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.getDimension().getBrightness(i));
}
}
/* Get light level of block */
@Override
public int getLightLevel(int x, int y, int z) {
if (world != null)
return world.getLightLevel(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.getChunk(x >> 4, z >> 4).getHeightmap(Heightmap.Type.MOTION_BLOCKING).get(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.getLightLevel(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) {
FabricMapChunkCache c = new FabricMapChunkCache(plugin);
c.setChunks(this, chunks);
return c;
}
return null;
}
public World getWorld() {
return world;
}
@Override
public Polygon getWorldBorder() {
if (world != null) {
WorldBorder wb = world.getWorldBorder();
if ((wb != null) && (wb.getSize() < 5.9E7)) {
Polygon p = new Polygon();
p.addVertex(wb.getBoundWest(), wb.getBoundNorth());
p.addVertex(wb.getBoundWest(), wb.getBoundSouth());
p.addVertex(wb.getBoundEast(), wb.getBoundSouth());
p.addVertex(wb.getBoundEast(), wb.getBoundNorth());
return p;
}
}
return null;
}
}

126
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/NBT.java
View File

@ -1,126 +0,0 @@
package org.dynmap.fabric_1_18;
import org.dynmap.common.chunk.GenericBitStorage;
import org.dynmap.common.chunk.GenericNBTCompound;
import org.dynmap.common.chunk.GenericNBTList;
import java.util.Set;
import net.minecraft.nbt.NbtCompound;
import net.minecraft.nbt.NbtList;
import net.minecraft.util.collection.PackedIntegerArray;
public class NBT {
public static class NBTCompound implements GenericNBTCompound {
private final NbtCompound obj;
public NBTCompound(NbtCompound t) {
this.obj = t;
}
@Override
public Set<String> getAllKeys() {
return obj.getKeys();
}
@Override
public boolean contains(String s) {
return obj.contains(s);
}
@Override
public boolean contains(String s, int i) {
return obj.contains(s, i);
}
@Override
public byte getByte(String s) {
return obj.getByte(s);
}
@Override
public short getShort(String s) {
return obj.getShort(s);
}
@Override
public int getInt(String s) {
return obj.getInt(s);
}
@Override
public long getLong(String s) {
return obj.getLong(s);
}
@Override
public float getFloat(String s) {
return obj.getFloat(s);
}
@Override
public double getDouble(String s) {
return obj.getDouble(s);
}
@Override
public String getString(String s) {
return obj.getString(s);
}
@Override
public byte[] getByteArray(String s) {
return obj.getByteArray(s);
}
@Override
public int[] getIntArray(String s) {
return obj.getIntArray(s);
}
@Override
public long[] getLongArray(String s) {
return obj.getLongArray(s);
}
@Override
public GenericNBTCompound getCompound(String s) {
return new NBTCompound(obj.getCompound(s));
}
@Override
public GenericNBTList getList(String s, int i) {
return new NBTList(obj.getList(s, i));
}
@Override
public boolean getBoolean(String s) {
return obj.getBoolean(s);
}
@Override
public String getAsString(String s) {
return obj.get(s).asString();
}
@Override
public GenericBitStorage makeBitStorage(int bits, int count, long[] data) {
return new OurBitStorage(bits, count, data);
}
public String toString() {
return obj.toString();
}
}
public static class NBTList implements GenericNBTList {
private final NbtList obj;
public NBTList(NbtList t) {
obj = t;
}
@Override
public int size() {
return obj.size();
}
@Override
public String getString(int idx) {
return obj.getString(idx);
}
@Override
public GenericNBTCompound getCompound(int idx) {
return new NBTCompound(obj.getCompound(idx));
}
public String toString() {
return obj.toString();
}
}
public static class OurBitStorage implements GenericBitStorage {
private final PackedIntegerArray bs;
public OurBitStorage(int bits, int count, long[] data) {
bs = new PackedIntegerArray(bits, count, data);
}
@Override
public int get(int idx) {
return bs.get(idx);
}
}
}

38
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/TaskRecord.java
View File

@ -1,38 +0,0 @@
package org.dynmap.fabric_1_18;
import java.util.concurrent.FutureTask;
class TaskRecord implements Comparable<TaskRecord> {
TaskRecord(long ticktorun, long id, FutureTask<?> future) {
this.ticktorun = ticktorun;
this.id = id;
this.future = future;
}
private final long ticktorun;
private final long id;
private final FutureTask<?> future;
void run() {
this.future.run();
}
long getTickToRun() {
return this.ticktorun;
}
@Override
public int compareTo(TaskRecord o) {
if (this.ticktorun < o.ticktorun) {
return -1;
} else if (this.ticktorun > o.ticktorun) {
return 1;
} else if (this.id < o.id) {
return -1;
} else if (this.id > o.id) {
return 1;
} else {
return 0;
}
}
}

98
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/VersionCheck.java
View File

@ -1,98 +0,0 @@
package org.dynmap.fabric_1_18;
import org.dynmap.DynmapCore;
import org.dynmap.Log;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
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();
}
}
}
}

5
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/access/ProtoChunkAccessor.java
View File

@ -1,5 +0,0 @@
package org.dynmap.fabric_1_18.access;
public interface ProtoChunkAccessor {
boolean getTouchedByWorldGen();
}

9
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/command/DmapCommand.java
View File

@ -1,9 +0,0 @@
package org.dynmap.fabric_1_18.command;
import org.dynmap.fabric_1_18.DynmapPlugin;
public class DmapCommand extends DynmapCommandExecutor {
public DmapCommand(DynmapPlugin p) {
super("dmap", p);
}
}

9
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/command/DmarkerCommand.java
View File

@ -1,9 +0,0 @@
package org.dynmap.fabric_1_18.command;
import org.dynmap.fabric_1_18.DynmapPlugin;
public class DmarkerCommand extends DynmapCommandExecutor {
public DmarkerCommand(DynmapPlugin p) {
super("dmarker", p);
}
}

9
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/command/DynmapCommand.java
View File

@ -1,9 +0,0 @@
package org.dynmap.fabric_1_18.command;
import org.dynmap.fabric_1_18.DynmapPlugin;
public class DynmapCommand extends DynmapCommandExecutor {
public DynmapCommand(DynmapPlugin p) {
super("dynmap", p);
}
}

63
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/command/DynmapCommandExecutor.java
View File

@ -1,63 +0,0 @@
package org.dynmap.fabric_1_18.command;
import com.mojang.brigadier.Command;
import com.mojang.brigadier.CommandDispatcher;
import com.mojang.brigadier.context.CommandContext;
import com.mojang.brigadier.exceptions.CommandSyntaxException;
import com.mojang.brigadier.tree.ArgumentCommandNode;
import com.mojang.brigadier.tree.LiteralCommandNode;
import com.mojang.brigadier.tree.RootCommandNode;
import net.minecraft.server.command.ServerCommandSource;
import org.dynmap.fabric_1_18.DynmapPlugin;
import java.util.Arrays;
import static com.mojang.brigadier.arguments.StringArgumentType.greedyString;
import static net.minecraft.server.command.CommandManager.argument;
import static net.minecraft.server.command.CommandManager.literal;
public class DynmapCommandExecutor implements Command<ServerCommandSource> {
private final String cmd;
private final DynmapPlugin plugin;
DynmapCommandExecutor(String cmd, DynmapPlugin plugin) {
this.cmd = cmd;
this.plugin = plugin;
}
public void register(CommandDispatcher<ServerCommandSource> dispatcher) {
final RootCommandNode<ServerCommandSource> root = dispatcher.getRoot();
final LiteralCommandNode<ServerCommandSource> command = literal(this.cmd)
.executes(this)
.build();
final ArgumentCommandNode<ServerCommandSource, String> args = argument("args", greedyString())
.executes(this)
.build();
// So this becomes "cmd" [args]
command.addChild(args);
// Add command to the command dispatcher via root node.
root.addChild(command);
}
@Override
public int run(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
// Commands in brigadier may be proxied in Minecraft via a syntax like `/execute ... ... run dmap [args]`
// Dynmap will fail to parse this properly, so we find the starting position of the actual command being parsed after any forks or redirects.
// The start position of the range specifies where the actual command dynmap has registered starts
int start = context.getRange().getStart();
String dynmapInput = context.getInput().substring(start);
String[] args = dynmapInput.split("\\s+");
plugin.handleCommand(context.getSource(), cmd, Arrays.copyOfRange(args, 1, args.length));
return 1;
}
// @Override // TODO: Usage?
public String getUsage(ServerCommandSource commandSource) {
return "Run /" + cmd + " help for details on using command";
}
}

9
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/command/DynmapExpCommand.java
View File

@ -1,9 +0,0 @@
package org.dynmap.fabric_1_18.command;
import org.dynmap.fabric_1_18.DynmapPlugin;
public class DynmapExpCommand extends DynmapCommandExecutor {
public DynmapExpCommand(DynmapPlugin p) {
super("dynmapexp", p);
}
}

40
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/event/BlockEvents.java
View File

@ -1,40 +0,0 @@
package org.dynmap.fabric_1_18.event;
import net.fabricmc.fabric.api.event.Event;
import net.fabricmc.fabric.api.event.EventFactory;
import net.minecraft.block.Material;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
public class BlockEvents {
private BlockEvents() {
}
public static Event<BlockCallback> BLOCK_EVENT = EventFactory.createArrayBacked(BlockCallback.class,
(listeners) -> (world, pos) -> {
for (BlockCallback callback : listeners) {
callback.onBlockEvent(world, pos);
}
}
);
public static Event<SignChangeCallback> SIGN_CHANGE_EVENT = EventFactory.createArrayBacked(SignChangeCallback.class,
(listeners) -> (world, pos, lines, material, player) -> {
for (SignChangeCallback callback : listeners) {
callback.onSignChange(world, pos, lines, material, player);
}
}
);
@FunctionalInterface
public interface BlockCallback {
void onBlockEvent(World world, BlockPos pos);
}
@FunctionalInterface
public interface SignChangeCallback {
void onSignChange(ServerWorld world, BlockPos pos, String[] lines, Material material, ServerPlayerEntity player);
}
}

21
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/event/CustomServerChunkEvents.java
View File

@ -1,21 +0,0 @@
package org.dynmap.fabric_1_18.event;
import net.fabricmc.fabric.api.event.Event;
import net.fabricmc.fabric.api.event.EventFactory;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.world.chunk.Chunk;
public class CustomServerChunkEvents {
public static Event<ChunkGenerate> CHUNK_GENERATE = EventFactory.createArrayBacked(ChunkGenerate.class,
(listeners) -> (world, chunk) -> {
for (ChunkGenerate callback : listeners) {
callback.onChunkGenerate(world, chunk);
}
}
);
@FunctionalInterface
public interface ChunkGenerate {
void onChunkGenerate(ServerWorld world, Chunk chunk);
}
}

14
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/event/CustomServerLifecycleEvents.java
View File

@ -1,14 +0,0 @@
package org.dynmap.fabric_1_18.event;
import net.fabricmc.fabric.api.event.Event;
import net.fabricmc.fabric.api.event.EventFactory;
import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
public class CustomServerLifecycleEvents {
public static final Event<ServerLifecycleEvents.ServerStarted> SERVER_STARTED_PRE_WORLD_LOAD =
EventFactory.createArrayBacked(ServerLifecycleEvents.ServerStarted.class, (callbacks) -> (server) -> {
for (ServerLifecycleEvents.ServerStarted callback : callbacks) {
callback.onServerStarted(server);
}
});
}

62
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/event/PlayerEvents.java
View File

@ -1,62 +0,0 @@
package org.dynmap.fabric_1_18.event;
import net.fabricmc.fabric.api.event.Event;
import net.fabricmc.fabric.api.event.EventFactory;
import net.minecraft.server.network.ServerPlayerEntity;
public class PlayerEvents {
private PlayerEvents() {
}
public static Event<PlayerLoggedIn> PLAYER_LOGGED_IN = EventFactory.createArrayBacked(PlayerLoggedIn.class,
(listeners) -> (player) -> {
for (PlayerLoggedIn callback : listeners) {
callback.onPlayerLoggedIn(player);
}
}
);
public static Event<PlayerLoggedOut> PLAYER_LOGGED_OUT = EventFactory.createArrayBacked(PlayerLoggedOut.class,
(listeners) -> (player) -> {
for (PlayerLoggedOut callback : listeners) {
callback.onPlayerLoggedOut(player);
}
}
);
public static Event<PlayerChangedDimension> PLAYER_CHANGED_DIMENSION = EventFactory.createArrayBacked(PlayerChangedDimension.class,
(listeners) -> (player) -> {
for (PlayerChangedDimension callback : listeners) {
callback.onPlayerChangedDimension(player);
}
}
);
public static Event<PlayerRespawn> PLAYER_RESPAWN = EventFactory.createArrayBacked(PlayerRespawn.class,
(listeners) -> (player) -> {
for (PlayerRespawn callback : listeners) {
callback.onPlayerRespawn(player);
}
}
);
@FunctionalInterface
public interface PlayerLoggedIn {
void onPlayerLoggedIn(ServerPlayerEntity player);
}
@FunctionalInterface
public interface PlayerLoggedOut {
void onPlayerLoggedOut(ServerPlayerEntity player);
}
@FunctionalInterface
public interface PlayerChangedDimension {
void onPlayerChangedDimension(ServerPlayerEntity player);
}
@FunctionalInterface
public interface PlayerRespawn {
void onPlayerRespawn(ServerPlayerEntity player);
}
}

23
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/event/ServerChatEvents.java
View File

@ -1,23 +0,0 @@
package org.dynmap.fabric_1_18.event;
import net.fabricmc.fabric.api.event.Event;
import net.fabricmc.fabric.api.event.EventFactory;
import net.minecraft.server.network.ServerPlayerEntity;
public class ServerChatEvents {
private ServerChatEvents() {
}
public static Event<ServerChatCallback> EVENT = EventFactory.createArrayBacked(ServerChatCallback.class,
(listeners) -> (player, message) -> {
for (ServerChatCallback callback : listeners) {
callback.onChatMessage(player, message);
}
}
);
@FunctionalInterface
public interface ServerChatCallback {
void onChatMessage(ServerPlayerEntity player, String message);
}
}

11
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/BiomeEffectsAccessor.java
View File

@ -1,11 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.world.biome.BiomeEffects;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.gen.Accessor;
@Mixin(BiomeEffects.class)
public interface BiomeEffectsAccessor {
@Accessor
int getWaterColor();
}

16
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/MinecraftServerMixin.java
View File

@ -1,16 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.server.MinecraftServer;
import org.dynmap.fabric_1_18.event.CustomServerLifecycleEvents;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
@Mixin(MinecraftServer.class)
public class MinecraftServerMixin {
@Inject(method = "loadWorld", at = @At("HEAD"))
protected void loadWorld(CallbackInfo info) {
CustomServerLifecycleEvents.SERVER_STARTED_PRE_WORLD_LOAD.invoker().onServerStarted((MinecraftServer) (Object) this);
}
}

29
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/PlayerManagerMixin.java
View File

@ -1,29 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.network.ClientConnection;
import net.minecraft.server.PlayerManager;
import net.minecraft.server.network.ServerPlayerEntity;
import org.dynmap.fabric_1_18.event.PlayerEvents;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(PlayerManager.class)
public class PlayerManagerMixin {
@Inject(method = "onPlayerConnect", at = @At("TAIL"))
public void onPlayerConnect(ClientConnection connection, ServerPlayerEntity player, CallbackInfo info) {
PlayerEvents.PLAYER_LOGGED_IN.invoker().onPlayerLoggedIn(player);
}
@Inject(method = "remove", at = @At("HEAD"))
public void remove(ServerPlayerEntity player, CallbackInfo info) {
PlayerEvents.PLAYER_LOGGED_OUT.invoker().onPlayerLoggedOut(player);
}
@Inject(method = "respawnPlayer", at = @At("RETURN"))
public void respawnPlayer(ServerPlayerEntity player, boolean alive, CallbackInfoReturnable<ServerPlayerEntity> info) {
PlayerEvents.PLAYER_RESPAWN.invoker().onPlayerRespawn(info.getReturnValue());
}
}

30
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/ProtoChunkMixin.java
View File

@ -1,30 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.block.BlockState;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.chunk.ProtoChunk;
import org.dynmap.fabric_1_18.access.ProtoChunkAccessor;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(ProtoChunk.class)
public class ProtoChunkMixin implements ProtoChunkAccessor {
private boolean touchedByWorldGen = false;
@Inject(
method = "setBlockState",
at = @At(
value = "INVOKE",
target = "Lnet/minecraft/world/chunk/ChunkSection;setBlockState(IIILnet/minecraft/block/BlockState;)Lnet/minecraft/block/BlockState;"
)
)
public void setBlockState(BlockPos pos, BlockState state, boolean moved, CallbackInfoReturnable<BlockState> info) {
touchedByWorldGen = true;
}
public boolean getTouchedByWorldGen() {
return touchedByWorldGen;
}
}

66
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/ServerPlayNetworkHandlerMixin.java
View File

@ -1,66 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.block.BlockState;
import net.minecraft.block.entity.BlockEntity;
import net.minecraft.block.entity.SignBlockEntity;
import net.minecraft.network.packet.c2s.play.UpdateSignC2SPacket;
import net.minecraft.server.filter.TextStream;
import net.minecraft.server.network.ServerPlayNetworkHandler;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.text.LiteralText;
import net.minecraft.util.math.BlockPos;
import java.util.List;
import org.dynmap.fabric_1_18.event.BlockEvents;
import org.dynmap.fabric_1_18.event.ServerChatEvents;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
@Mixin(ServerPlayNetworkHandler.class)
public abstract class ServerPlayNetworkHandlerMixin {
@Shadow
public ServerPlayerEntity player;
@Inject(
method = "handleMessage",
at = @At(
value = "INVOKE",
target = "Lnet/minecraft/server/PlayerManager;broadcast(Lnet/minecraft/text/Text;Ljava/util/function/Function;Lnet/minecraft/network/MessageType;Ljava/util/UUID;)V",
shift = At.Shift.BEFORE
)
)
public void onGameMessage(TextStream.Message message, CallbackInfo info) {
ServerChatEvents.EVENT.invoker().onChatMessage(player, message.getRaw());
}
@Inject(
method = "onSignUpdate",
at = @At(
value = "INVOKE",
target = "Lnet/minecraft/block/entity/SignBlockEntity;markDirty()V",
shift = At.Shift.BEFORE
),
locals = LocalCapture.CAPTURE_FAILHARD
)
public void onSignUpdate(UpdateSignC2SPacket packet, List<TextStream.Message> signText, CallbackInfo info,
ServerWorld serverWorld, BlockPos blockPos, BlockState blockState, BlockEntity blockEntity, SignBlockEntity signBlockEntity)
{
// Pull the raw text from the input.
String[] rawTexts = new String[4];
for (int i=0; i<signText.size(); i++)
rawTexts[i] = signText.get(i).getRaw();
// Fire the event.
BlockEvents.SIGN_CHANGE_EVENT.invoker().onSignChange(serverWorld, blockPos, rawTexts, blockState.getMaterial(), player);
// Put the (possibly updated) texts in the sign. Ignore filtering (is this OK?).
for (int i=0; i<signText.size(); i++)
signBlockEntity.setTextOnRow(i, new LiteralText(rawTexts[i]));
}
}

30
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/ServerPlayerEntityMixin.java
View File

@ -1,30 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.entity.Entity;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.server.world.ServerWorld;
import org.dynmap.fabric_1_18.event.PlayerEvents;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(ServerPlayerEntity.class)
public class ServerPlayerEntityMixin {
@Inject(method = "teleport", at = @At("RETURN"))
public void teleport(ServerWorld targetWorld, double x, double y, double z, float yaw, float pitch, CallbackInfo info) {
ServerPlayerEntity player = (ServerPlayerEntity) (Object) this;
if (targetWorld != player.world) {
PlayerEvents.PLAYER_CHANGED_DIMENSION.invoker().onPlayerChangedDimension(player);
}
}
@Inject(method = "moveToWorld", at = @At("RETURN"))
public void moveToWorld(ServerWorld destination, CallbackInfoReturnable<Entity> info) {
ServerPlayerEntity player = (ServerPlayerEntity) (Object) this;
if (player.getRemovalReason() == null) {
PlayerEvents.PLAYER_CHANGED_DIMENSION.invoker().onPlayerChangedDimension(player);
}
}
}

32
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/ThreadedAnvilChunkStorageMixin.java
View File

@ -1,32 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.server.world.ChunkHolder;
import net.minecraft.server.world.ServerWorld;
import net.minecraft.server.world.ThreadedAnvilChunkStorage;
import net.minecraft.world.chunk.Chunk;
import org.dynmap.fabric_1_18.access.ProtoChunkAccessor;
import org.dynmap.fabric_1_18.event.CustomServerChunkEvents;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(value = ThreadedAnvilChunkStorage.class, priority = 666 /* fire before Fabric API CHUNK_LOAD event */)
public abstract class ThreadedAnvilChunkStorageMixin {
@Final
@Shadow
ServerWorld world;
@Inject(
/* Same place as fabric-lifecycle-events-v1 event CHUNK_LOAD (we will fire before it) */
method = "method_17227",
at = @At("TAIL")
)
private void onChunkGenerate(ChunkHolder chunkHolder, Chunk protoChunk, CallbackInfoReturnable<Chunk> callbackInfoReturnable) {
if (((ProtoChunkAccessor)protoChunk).getTouchedByWorldGen()) {
CustomServerChunkEvents.CHUNK_GENERATE.invoker().onChunkGenerate(this.world, callbackInfoReturnable.getReturnValue());
}
}
}

25
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/mixin/WorldChunkMixin.java
View File

@ -1,25 +0,0 @@
package org.dynmap.fabric_1_18.mixin;
import net.minecraft.block.BlockState;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraft.world.chunk.WorldChunk;
import org.dynmap.fabric_1_18.event.BlockEvents;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
@Mixin(WorldChunk.class)
public abstract class WorldChunkMixin {
@Shadow
public abstract World getWorld();
@Inject(method = "setBlockState", at = @At("RETURN"))
public void setBlockState(BlockPos pos, BlockState state, boolean moved, CallbackInfoReturnable<BlockState> info) {
if (info.getReturnValue() != null) {
BlockEvents.BLOCK_EVENT.invoker().onBlockEvent(this.getWorld(), pos);
}
}
}

103
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/permissions/FilePermissions.java
View File

@ -1,103 +0,0 @@
package org.dynmap.fabric_1_18.permissions;
import net.minecraft.entity.player.PlayerEntity;
import org.dynmap.ConfigurationNode;
import org.dynmap.Log;
import org.dynmap.fabric_1_18.DynmapPlugin;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
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;
}
}

52
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/permissions/OpPermissions.java
View File

@ -1,52 +0,0 @@
package org.dynmap.fabric_1_18.permissions;
import net.minecraft.entity.player.PlayerEntity;
import org.dynmap.Log;
import org.dynmap.fabric_1_18.DynmapPlugin;
import java.util.HashSet;
import java.util.Set;
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.getName().getString());
}
return true;
}
@Override
public boolean hasPermissionNode(PlayerEntity psender, String permission) {
if (psender != null) {
return DynmapPlugin.plugin.isOp(psender.getName().getString());
}
return true;
}
}

16
fabric-1.18/src/main/java/org/dynmap/fabric_1_18/permissions/PermissionProvider.java
View File

@ -1,16 +0,0 @@
package org.dynmap.fabric_1_18.permissions;
import net.minecraft.entity.player.PlayerEntity;
import java.util.Set;
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);
}

BIN
fabric-1.18/src/main/resources/assets/dynmap/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 33 KiB

494
fabric-1.18/src/main/resources/configuration.txt
View File

@ -1,494 +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
- 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
# This now supports both IP address, and subnet ranges (e.g. 192.168.1.0/24 or 202.24.0.0/14 )
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
# Send this message if the player does not have permission to use the command
noPermissionMsg: "You don't have permission to use this command!"
# 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!)"

19
fabric-1.18/src/main/resources/dynmap.mixins.json
View File

@ -1,19 +0,0 @@
{
"required": true,
"minVersion": "0.8",
"package": "org.dynmap.fabric_1_18.mixin",
"compatibilityLevel": "JAVA_16",
"mixins": [
"BiomeEffectsAccessor",
"MinecraftServerMixin",
"PlayerManagerMixin",
"ProtoChunkMixin",
"ServerPlayerEntityMixin",
"ServerPlayNetworkHandlerMixin",
"ThreadedAnvilChunkStorageMixin",
"WorldChunkMixin"
],
"injectors": {
"defaultRequire": 1
}
}

33
fabric-1.18/src/main/resources/fabric.mod.json
View File

@ -1,33 +0,0 @@
{
"schemaVersion": 1,
"id": "dynmap",
"version": "${version}",
"name": "Dynmap",
"description": "Dynamic, Google-maps style rendered maps for your Minecraft server",
"authors": [
"mikeprimm",
"LolHens",
"i509VCB"
],
"contact": {
"homepage": "https://github.com/webbukkit/dynmap",
"sources": "https://github.com/webbukkit/dynmap"
},
"license": "Apache-2.0",
"icon": "assets/dynmap/icon.png",
"environment": "*",
"entrypoints": {
"main": [
"org.dynmap.fabric_1_18.DynmapMod"
]
},
"mixins": [
"dynmap.mixins.json"
],
"depends": {
"fabricloader": ">=0.12.12",
"fabric": ">=0.43.1",
"minecraft": "1.18.x"
}
}

27
fabric-1.18/src/main/resources/permissions.yml.example
View File

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

2
forge-1.18/.gitignore vendored
View File

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

92
forge-1.18/build.gradle
View File

@ -1,92 +0,0 @@
buildscript {
repositories {
maven { url = 'https://files.minecraftforge.net/maven' }
jcenter()
mavenCentral()
}
dependencies {
classpath group: 'net.minecraftforge.gradle', name: 'ForgeGradle', version: '5.1.+', changing: true
}
}
apply plugin: 'net.minecraftforge.gradle'
apply plugin: 'com.github.johnrengelman.shadow'
apply plugin: 'eclipse'
eclipse {
project {
name = "Dynmap(Forge-1.18)"
}
}
sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaLanguageVersion.of(17) // Need this here so eclipse task generates correctly.
println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + '(' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
ext.buildNumber = System.getenv().BUILD_NUMBER ?: "Dev"
minecraft {
mappings channel: 'official', version: '1.18'
accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
runs {
server {
workingDirectory project.file('run').canonicalPath
}
}
}
project.archivesBaseName = "${project.archivesBaseName}-forge-1.18"
dependencies {
implementation project(path: ":DynmapCore", configuration: "shadow")
implementation project(path: ':DynmapCoreAPI')
minecraft 'net.minecraftforge:forge:1.18-38.0.12'
}
processResources
{
filesMatching('META-INF/mods.toml') {
// replace version and mcversion
expand(
version: project.version + '-' + project.ext.buildNumber,
mcversion: "1.18"
)
}
}
shadowJar {
dependencies {
include(dependency(':DynmapCore'))
include(dependency("commons-codec:commons-codec:"))
exclude("META-INF/maven/**")
exclude("META-INF/services/**")
}
relocate('org.apache.commons.codec', 'org.dynmap.forge_1_18.commons.codec')
archiveName = "Dynmap-${parent.version}-forge-1.18.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)

6
forge-1.18/src/main/java/org/dynmap/forge_1_18/ClientProxy.java
View File

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

136
forge-1.18/src/main/java/org/dynmap/forge_1_18/DynmapMod.java
View File

@ -1,136 +0,0 @@
package org.dynmap.forge_1_18;
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_18.DynmapPlugin.OurLog;
import net.minecraft.server.MinecraftServer;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.common.MinecraftForge;
import net.minecraftforge.event.server.ServerAboutToStartEvent;
import net.minecraftforge.event.server.ServerStartedEvent;
import net.minecraftforge.event.server.ServerStartingEvent;
import net.minecraftforge.event.server.ServerStoppingEvent;
import net.minecraftforge.eventbus.api.SubscribeEvent;
import net.minecraftforge.fml.DistExecutor;
import net.minecraftforge.fml.IExtensionPoint;
import net.minecraftforge.fml.ModList;
import net.minecraftforge.fml.ModLoadingContext;
import net.minecraftforge.fml.StartupMessageManager;
import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
import net.minecraftforge.fml.event.lifecycle.FMLLoadCompleteEvent;
import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
import net.minecraftforge.network.NetworkConstants;;
@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(IExtensionPoint.DisplayTest.class,
()->new IExtensionPoint.DisplayTest(()->NetworkConstants.IGNORESERVERONLY, (remote, isServer)-> 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.info("[Dynmap] World loading using forced chunks is disabled");
//}
}
private MinecraftServer server;
@SubscribeEvent
public void onServerStarting(ServerAboutToStartEvent event) {
server = event.getServer();
if(plugin == null)
plugin = proxy.startServer(server);
plugin.onStarting(server.getCommands().getDispatcher());
}
@SubscribeEvent
public void onServerStarted(ServerStartedEvent event) {
DynmapCommonAPIListener.register(new APICallback());
plugin.serverStarted();
}
@SubscribeEvent
public void serverStopping(ServerStoppingEvent event)
{
proxy.stopServer(plugin);
plugin = null;
}
}

2018
forge-1.18/src/main/java/org/dynmap/forge_1_18/DynmapPlugin.java
View File

File diff suppressed because it is too large Load Diff

105
forge-1.18/src/main/java/org/dynmap/forge_1_18/ForgeMapChunkCache.java
View File

@ -1,105 +0,0 @@
package org.dynmap.forge_1_18;
import java.util.List;
import net.minecraft.world.level.biome.Biome;
import net.minecraft.world.level.biome.BiomeSpecialEffects;
import org.dynmap.DynmapChunk;
import org.dynmap.Log;
import org.dynmap.common.BiomeMap;
import org.dynmap.common.chunk.GenericChunk;
import org.dynmap.common.chunk.GenericChunkCache;
import org.dynmap.common.chunk.GenericMapChunkCache;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.server.level.ServerChunkCache;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.ChunkPos;
import net.minecraft.world.level.chunk.ChunkAccess;
import net.minecraft.world.level.chunk.ChunkStatus;
import net.minecraft.world.level.chunk.storage.ChunkSerializer;
/**
* Container for managing chunks - dependent upon using chunk snapshots, since
* rendering is off server thread
*/
public class ForgeMapChunkCache extends GenericMapChunkCache {
private ServerLevel w;
private ServerChunkCache cps;
/**
* Construct empty cache
*/
public ForgeMapChunkCache(GenericChunkCache cc) {
super(cc);
}
// Load generic chunk from existing and already loaded chunk
protected GenericChunk getLoadedChunk(DynmapChunk chunk) {
GenericChunk gc = null;
ChunkAccess ch = cps.getChunk(chunk.x, chunk.z, ChunkStatus.FULL, false);
if (ch != null) {
CompoundTag nbt = ChunkSerializer.write(w, ch);
if (nbt != null) {
gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
}
}
return gc;
}
// Load generic chunk from unloaded chunk
protected GenericChunk loadChunk(DynmapChunk chunk) {
GenericChunk gc = null;
CompoundTag nbt = readChunk(chunk.x, chunk.z);
// If read was good
if (nbt != null) {
gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
}
return gc;
}
public void setChunks(ForgeWorld dw, List<DynmapChunk> chunks) {
this.w = dw.getWorld();
if (dw.isLoaded()) {
/* Check if world's provider is ServerChunkProvider */
cps = this.w.getChunkSource();
}
super.setChunks(dw, chunks);
}
private CompoundTag readChunk(int x, int z) {
try {
CompoundTag rslt = cps.chunkMap.readChunk(new ChunkPos(x, z));
if (rslt != null) {
if (rslt.contains("Level")) {
rslt = rslt.getCompound("Level");
}
// Don't load uncooked chunks
String stat = rslt.getString("Status");
ChunkStatus cs = ChunkStatus.byName(stat);
if ((stat == null) ||
// Needs to be at least lighted
(!cs.isOrAfter(ChunkStatus.LIGHT))) {
rslt = null;
}
}
// Log.info(String.format("loadChunk(%d,%d)=%s", x, z, (rslt != null) ?
// rslt.toString() : "null"));
return rslt;
} catch (Exception exc) {
Log.severe(String.format("Error reading chunk: %s,%d,%d", dw.getName(), x, z), exc);
return null;
}
}
@Override
public int getFoliageColor(BiomeMap bm, int[] colormap, int x, int z) {
return bm.<Biome>getBiomeObject().map(Biome::getSpecialEffects)
.flatMap(BiomeSpecialEffects::getFoliageColorOverride)
.orElse(colormap[bm.biomeLookup()]);
}
@Override
public int getGrassColor(BiomeMap bm, int[] colormap, int x, int z) {
BiomeSpecialEffects effects = bm.<Biome>getBiomeObject().map(Biome::getSpecialEffects).orElse(null);
if (effects == null) return colormap[bm.biomeLookup()];
return effects.getGrassColorModifier().modifyColor(x, z, effects.getGrassColorOverride().orElse(colormap[bm.biomeLookup()]));
}
}

244
forge-1.18/src/main/java/org/dynmap/forge_1_18/ForgeWorld.java
View File

@ -1,244 +0,0 @@
package org.dynmap.forge_1_18;
/**
* Forge specific implementation of DynmapWorld
*/
import java.util.List;
import net.minecraft.world.level.ServerLevelAccessor;
import net.minecraft.world.level.border.WorldBorder;
import net.minecraft.world.level.levelgen.Heightmap;
import net.minecraft.core.BlockPos;
import net.minecraft.resources.ResourceKey;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.level.Level;
import net.minecraft.world.level.LightLayer;
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 ServerLevelAccessor 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 = 320; // Maximum allows world height
public static int getMaxWorldHeight() {
return maxWorldHeight;
}
public static void setMaxWorldHeight(int h) {
maxWorldHeight = h;
}
public static String getWorldName(ServerLevelAccessor w) {
ResourceKey<Level> rk = w.getLevel().dimension();
String id = rk.location().getNamespace() + "_" + rk.location().getPath();
if (id.equals("minecraft_overworld")) { // Overworld?
return w.getLevel().serverLevelData.getLevelName();
}
else if (id.equals("minecraft_the_end")) {
return "DIM1";
}
else if (id.equals("minecraft_the_nether")) {
return "DIM-1";
}
else {
return id;
}
}
public void updateWorld(ServerLevelAccessor w) {
this.updateWorldHeights(w.getLevel().getHeight(), w.getLevel().dimensionType().minY(), w.getLevel().getSeaLevel());
}
public ForgeWorld(ServerLevelAccessor w)
{
this(getWorldName(w),
w.getLevel().getHeight(),
w.getLevel().getSeaLevel(),
w.getLevel().dimension() == Level.NETHER,
w.getLevel().dimension() == Level.END,
getWorldName(w),
w.getLevel().dimensionType().minY());
setWorldLoaded(w);
}
public ForgeWorld(String name, int height, int sealevel, boolean nether, boolean the_end, String deftitle, int miny)
{
super(name, (height > maxWorldHeight)?maxWorldHeight:height, sealevel, miny);
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";
}
//Log.info(getName() + ": skylight=" + skylight + ", height=" + this.worldheight + ", isnether=" + isnether + ", istheend=" + istheend);
}
/* 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 p = world.getLevel().getSharedSpawnPos();
spawnloc.x = p.getX();
spawnloc.y = p.getY();
spawnloc.z = p.getZ();
spawnloc.world = this.getName();
}
return spawnloc;
}
/* Get world time */
@Override
public long getTime()
{
if(world != null)
return world.getLevel().getDayTime();
else
return -1;
}
/* World is storming */
@Override
public boolean hasStorm()
{
if(world != null)
return world.getLevel().isRaining();
else
return false;
}
/* World is thundering */
@Override
public boolean isThundering()
{
if(world != null)
return world.getLevel().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(ServerLevelAccessor w) {
world = w;
this.sealevel = w.getLevel().getSeaLevel(); // Read actual current sealevel from world
// Update lighting table
for (int i = 0; i < 16; i++) {
float light = w.getLevel().dimensionType().brightness(i);
this.setBrightnessTableEntry(i, light);
//Log.info(getName() + ": light " + i + " = " + light);
}
}
/* Get light level of block */
@Override
public int getLightLevel(int x, int y, int z)
{
if(world != null)
return world.getLevel().getLightEngine().getRawBrightness(new BlockPos(x, y, z), 0);
else
return -1;
}
/* Get highest Y coord of given location */
@Override
public int getHighestBlockYAt(int x, int z)
{
if(world != null) {
return world.getLevel().getChunk(x >> 4, z >> 4).getHeight(Heightmap.Types.MOTION_BLOCKING, 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.getLevel().getBrightness(LightLayer.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(DynmapPlugin.plugin.sscache);
c.setChunks(this, chunks);
return c;
}
return null;
}
public ServerLevel getWorld()
{
return world.getLevel();
}
@Override
public Polygon getWorldBorder() {
if (world != null) {
WorldBorder wb = world.getWorldBorder();
if ((wb != null) && (wb.getSize() < 5.9E7)) {
Polygon p = new Polygon();
p.addVertex(wb.getMinX(), wb.getMinZ());
p.addVertex(wb.getMinX(), wb.getMaxZ());
p.addVertex(wb.getMaxX(), wb.getMaxZ());
p.addVertex(wb.getMaxX(), wb.getMinZ());
return p;
}
}
return null;
}
}

126
forge-1.18/src/main/java/org/dynmap/forge_1_18/NBT.java
View File

@ -1,126 +0,0 @@
package org.dynmap.forge_1_18;
import org.dynmap.common.chunk.GenericBitStorage;
import org.dynmap.common.chunk.GenericNBTCompound;
import org.dynmap.common.chunk.GenericNBTList;
import java.util.Set;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.nbt.ListTag;
import net.minecraft.util.SimpleBitStorage;
public class NBT {
public static class NBTCompound implements GenericNBTCompound {
private final CompoundTag obj;
public NBTCompound(CompoundTag t) {
this.obj = t;
}
@Override
public Set<String> getAllKeys() {
return obj.getAllKeys();
}
@Override
public boolean contains(String s) {
return obj.contains(s);
}
@Override
public boolean contains(String s, int i) {
return obj.contains(s, i);
}
@Override
public byte getByte(String s) {
return obj.getByte(s);
}
@Override
public short getShort(String s) {
return obj.getShort(s);
}
@Override
public int getInt(String s) {
return obj.getInt(s);
}
@Override
public long getLong(String s) {
return obj.getLong(s);
}
@Override
public float getFloat(String s) {
return obj.getFloat(s);
}
@Override
public double getDouble(String s) {
return obj.getDouble(s);
}
@Override
public String getString(String s) {
return obj.getString(s);
}
@Override
public byte[] getByteArray(String s) {
return obj.getByteArray(s);
}
@Override
public int[] getIntArray(String s) {
return obj.getIntArray(s);
}
@Override
public long[] getLongArray(String s) {
return obj.getLongArray(s);
}
@Override
public GenericNBTCompound getCompound(String s) {
return new NBTCompound(obj.getCompound(s));
}
@Override
public GenericNBTList getList(String s, int i) {
return new NBTList(obj.getList(s, i));
}
@Override
public boolean getBoolean(String s) {
return obj.getBoolean(s);
}
@Override
public String getAsString(String s) {
return obj.get(s).getAsString();
}
@Override
public GenericBitStorage makeBitStorage(int bits, int count, long[] data) {
return new OurBitStorage(bits, count, data);
}
public String toString() {
return obj.toString();
}
}
public static class NBTList implements GenericNBTList {
private final ListTag obj;
public NBTList(ListTag t) {
obj = t;
}
@Override
public int size() {
return obj.size();
}
@Override
public String getString(int idx) {
return obj.getString(idx);
}
@Override
public GenericNBTCompound getCompound(int idx) {
return new NBTCompound(obj.getCompound(idx));
}
public String toString() {
return obj.toString();
}
}
public static class OurBitStorage implements GenericBitStorage {
private final SimpleBitStorage bs;
public OurBitStorage(int bits, int count, long[] data) {
bs = new SimpleBitStorage(bits, count, data);
}
@Override
public int get(int idx) {
return bs.get(idx);
}
}
}

24
forge-1.18/src/main/java/org/dynmap/forge_1_18/Proxy.java
View File

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

97
forge-1.18/src/main/java/org/dynmap/forge_1_18/VersionCheck.java
View File

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

103
forge-1.18/src/main/java/org/dynmap/forge_1_18/permissions/FilePermissions.java
View File

@ -1,103 +0,0 @@
package org.dynmap.forge_1_18.permissions;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.dynmap.ConfigurationNode;
import org.dynmap.Log;
import org.dynmap.forge_1_18.DynmapPlugin;
import net.minecraft.server.level.ServerPlayer;
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(ServerPlayer psender, String permission) {
if(psender != null) {
String n = psender.getName().getString().toLowerCase();
return hasPerm(n, permission);
}
return true;
}
@Override
public boolean hasPermissionNode(ServerPlayer psender, String permission) {
if(psender != null) {
String player = psender.getName().getString().toLowerCase();
return DynmapPlugin.plugin.isOp(player);
}
return false;
}
}

51
forge-1.18/src/main/java/org/dynmap/forge_1_18/permissions/OpPermissions.java
View File

@ -1,51 +0,0 @@
package org.dynmap.forge_1_18.permissions;
import java.util.HashSet;
import java.util.Set;
import org.dynmap.Log;
import org.dynmap.forge_1_18.DynmapPlugin;
import net.minecraft.server.level.ServerPlayer;
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(ServerPlayer psender, String permission) {
if(psender != null) {
if(usrCommands.contains(permission)) {
return true;
}
return DynmapPlugin.plugin.isOp(psender.getName().getString());
}
return true;
}
@Override
public boolean hasPermissionNode(ServerPlayer psender, String permission) {
if(psender != null) {
return DynmapPlugin.plugin.isOp(psender.getName().getString());
}
return true;
}
}

15
forge-1.18/src/main/java/org/dynmap/forge_1_18/permissions/PermissionProvider.java
View File

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

4
forge-1.18/src/main/resources/META-INF/accesstransformer.cfg
View File

@ -1,4 +0,0 @@
public net.minecraft.world.level.biome.BiomeSpecialEffects$Builder f_48006_ # waterColor
public net.minecraft.server.level.ServerLevel f_8549_ # serverLevelData
public net.minecraft.server.level.ChunkMap f_140130_ # visibleChunkMap
public net.minecraft.server.level.ChunkMap m_140427_(Lnet/minecraft/world/level/ChunkPos;)Lnet/minecraft/nbt/CompoundTag; # readChunk(

26
forge-1.18/src/main/resources/META-INF/mods.toml
View File

@ -1,26 +0,0 @@
modLoader="javafml"
loaderVersion="[38,)"
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="[38,)"
ordering="NONE"
# Side this dependency is applied on - BOTH, CLIENT or SERVER
side="SERVER"
[[dependencies.dynmap]]
modId="minecraft"
mandatory=true
versionRange="[1.18,1.18.2)"
ordering="NONE"
side="SERVER"

496
forge-1.18/src/main/resources/configuration.txt
View File

@ -1,496 +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),
# 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
# This now supports both IP address, and subnet ranges (e.g. 192.168.1.0/24 or 202.24.0.0/14 )
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
# Send this message if the player does not have permission to use the command
noPermissionMsg: "You don't have permission to use this command!"
# 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!)"

6
forge-1.18/src/main/resources/pack.mcmeta
View File

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

27
forge-1.18/src/main/resources/permissions.yml.example
View File

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

2
settings.gradle
View File

@ -29,7 +29,6 @@ include ':fabric-1.19.3'
include ':fabric-1.19.1'
include ':fabric-1.19'
include ':fabric-1.18.2'
include ':fabric-1.18'
include ':fabric-1.17.1'
include ':fabric-1.16.4'
include ':fabric-1.15.2'
@ -38,7 +37,6 @@ include ':forge-1.19.3'
include ':forge-1.19.2'
include ':forge-1.19'
include ':forge-1.18.2'
include ':forge-1.18'
include ':forge-1.17.1'
include ':forge-1.16.5'
include ':forge-1.15.2'