Start back-port to 1.12.2

Author: mikeprimm

core/build.gradle

@@ -9,7 +9,7 @@ eclipse {
 
 project.archivesBaseName = "${parent.name}-core"
 
-sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = JavaLanguageVersion.of(8) // Need this here so eclipse task generates correctly.
+sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = 1.8 // Need this here so eclipse task generates correctly.
 
 dependencies {
 	compileOnly 'com.google.code.gson:gson:2.8.0'

forge-1.12.2/.gitignore

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

forge-1.12.2/build.gradle

@@ -0,0 +1,118 @@
+buildscript {
+    repositories {
+        mavenCentral()
+        mavenLocal()
+        
+        maven {
+            name = "forgeFS"
+            url = "http://files.minecraftforge.net/maven"
+        }
+        maven {
+            name = "sonatype"
+            url = "https://oss.sonatype.org/content/repositories/snapshots/"
+        }
+    }
+    dependencies {
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
+    }
+}
+
+apply plugin: 'net.minecraftforge.gradle.forge'
+
+// define the properties file
+ext.configFile = file "build.properties"
+
+configFile.withReader {
+    def prop = new Properties()
+    prop.load(it)
+    project.ext.config = new ConfigSlurper().parse prop
+}
+
+version = "${parent.version}"
+group= "us.dynmap.forge" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+archivesBaseName = "DynmapBlockScan"
+targetCompatibility = '1.8'
+sourceCompatibility = '1.8'
+ext.buildNumber = System.getenv().BUILD_NUMBER ?: "Dev"
+
+minecraft {
+    version = config.minecraft_version + "-" + config.forge_version
+	runDir = "run"
+	mappings = 'snapshot_nodoc_20171021'
+	replaceIn "Version.java"
+    	replace "@VERSION@", parent.version + '-' + project.ext.buildNumber
+    	replace "@BUILD_NUMBER@", project.ext.buildNumber
+}
+
+repositories {
+    mavenLocal()
+    maven { url = "https://repo.mikeprimm.com" }
+}
+
+configurations {
+    dynmap
+    compile.extendsFrom dynmap
+}
+
+dependencies {
+    dynmap "us.dynmap:DynmapCoreAPI:${parent.version}:all"
+    implementation project(path: ":core", configuration: "shadow")
+}
+
+processResources
+{
+    // replace stuff in mcmod.info, nothing else
+    from(sourceSets.main.resources.srcDirs) {
+        include 'mcmod.info'
+                
+        // replace version and mcversion
+        expand(
+        	version: parent.version + '-' + project.ext.buildNumber,
+        	mcversion: config.minecraft_version
+    	)
+    }
+        
+    // copy everything else, thats not the mcmod.info
+    from(sourceSets.main.resources.srcDirs) {
+        exclude 'mcmod.info'
+    }
+    // Move access transformer to META-INF
+    rename '(.+_at.cfg)', 'META-INF/$1'
+}
+
+
+shadowJar {
+    dependencies {
+        include(dependency(':core'))
+        exclude(dependency("us.dynmap:DynmapCoreAPI"))
+        exclude("META-INF/maven/**")
+        exclude("META-INF/services/**")
+        exclude("com/electronwill/**")
+    }
+    archiveName = "${parent.name}-${parent.version}-forge-1.12.2.jar"
+    destinationDir = file '../target'
+}
+
+shadowJar.doLast {
+    task ->
+        ant.checksum file: task.archivePath
+}
+
+
+reobf {
+    shadowJar {
+        mappingType = 'SEARGE'
+    }
+}
+
+task deobfJar(type: Jar) {
+    from sourceSets.main.output
+    classifier = 'dev'
+}
+
+artifacts {
+    archives deobfJar
+}
+
+build.dependsOn(shadowJar)
+

forge-1.12.2/build.properties

@@ -0,0 +1,3 @@
+minecraft_version=1.12.2
+forge_version=14.23.4.2705
+mapping_version=snapshot_nodoc_20171021

forge-1.12.2/src/main/java/org/dynmap/blockscan/BlockStateOverrides.java

@@ -0,0 +1,103 @@
+package org.dynmap.blockscan;
+
+import java.lang.reflect.Type;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.dynmap.blockscan.blockstate.BaseCondition;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+
+// Container for JSON-encoded block state overrides (to handle bogus Mojang block state file name options
+public class BlockStateOverrides {
+	public Map<String, Map<String, BlockStateOverride>> overrides = Collections.emptyMap();
+    public Map<String, Map<String, BlockTintOverride[]>> tinting = Collections.emptyMap();
+	
+	public static class BlockStateOverride {
+		public String baseNameProperty = null;	// If property used for base name, this is property name
+		public String nameSuffix = "";			// If base name has suffix
+		public String blockStateName = null;	// If defined, this is name of block state resource
+		public String blockStateKey = null;  // If defined, condition for matching block state
+        public String blockStateValue = null;  // If defined, condition for matching block state
+	}
+    public static class BlockTintOverride {
+        public BaseCondition state;    // Condition for matching block state (null=all states)
+        public String[] colormap;    // Colormap resource
+        
+        // Custom deserializer
+        public static class Deserializer implements JsonDeserializer<BlockTintOverride> {
+            @Override
+            public BlockTintOverride deserialize(JsonElement element, Type type, JsonDeserializationContext context) throws JsonParseException {
+                BlockTintOverride ovr = new BlockTintOverride();
+                JsonObject obj = element.getAsJsonObject();
+                if (obj.has("state")) {
+                    ovr.state = new BaseCondition(obj.get("state").getAsString());
+                }
+                if (obj.has("colormap")) {
+                    JsonArray ary = obj.getAsJsonArray("colormap");
+                    ovr.colormap = new String[ary.size()];
+                    for (int i = 0; i < ary.size(); i++) {
+                        ovr.colormap[i] = ary.get(i).getAsString();
+                    }
+                }
+                return ovr;
+            }
+        }
+    }
+	
+	public BlockStateOverride getOverride(String modid, String blkid) {
+		Map<String, BlockStateOverride> map = overrides.get(modid);
+		if (map != null) {
+			return map.get(blkid);
+		}
+		return null;
+	}
+	
+    public BlockTintOverride getTinting(String modid, String blkid, Map<String,String> prop) {
+        Map<String, BlockTintOverride[]> modmatch = tinting.get(modid);
+        if (modmatch != null) {
+            BlockTintOverride[] blkmatch = modmatch.get(blkid);
+            if (blkmatch != null) {
+                for (BlockTintOverride ovr : blkmatch) {
+                    if ((ovr.state == null) || (ovr.state.matches(prop))) {
+                        return ovr;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    
+    public void merge(BlockStateOverrides ovr) {
+        // Merge in block state overrides
+        for (Entry<String, Map<String, BlockStateOverride>> mod : ovr.overrides.entrySet()) {
+            String modid = mod.getKey();
+            if (overrides.containsKey(modid) == false) {
+                overrides.put(modid, new HashMap<String, BlockStateOverride>());
+            }
+            Map<String, BlockStateOverride> bso = overrides.get(modid);
+            for (Entry<String, BlockStateOverride> blk : mod.getValue().entrySet()) {
+                bso.put(blk.getKey(), blk.getValue());
+            }
+        }
+        // Merge in tinting overrides
+        for (Entry<String, Map<String, BlockTintOverride[]>> mod : ovr.tinting.entrySet()) {
+            String modid = mod.getKey();
+            if (tinting.containsKey(modid) == false) {
+                tinting.put(modid, new HashMap<String, BlockTintOverride[]>());
+            }
+            Map<String, BlockTintOverride[]> bto = tinting.get(modid);
+            for (Entry<String, BlockTintOverride[]> blk : mod.getValue().entrySet()) {
+                bto.put(blk.getKey(), blk.getValue());
+            }
+        }
+    }
+    
+}

forge-1.12.2/src/main/java/org/dynmap/blockscan/ClientProxy.java

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

forge-1.12.2/src/main/java/org/dynmap/blockscan/DynmapBlockScanMod.java

@@ -0,0 +1,91 @@
+package org.dynmap.blockscan;
+
+import java.io.File;
+import java.util.Map;
+
+import net.minecraft.server.MinecraftServer;
+import net.minecraftforge.common.config.Configuration;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.Mod.EventHandler;
+import net.minecraftforge.fml.common.Mod.Instance;
+import net.minecraftforge.fml.common.SidedProxy;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartedEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.event.FMLServerStoppingEvent;
+import net.minecraftforge.fml.common.network.NetworkCheckHandler;
+import net.minecraftforge.fml.relauncher.Side;
+
+@Mod(modid = "dynmapblockscan", name = "DynmapBlockScan", version = Version.VER)
+public class DynmapBlockScanMod
+{
+    public static DynmapBlockScanPlugin.OurLog logger = new DynmapBlockScanPlugin.OurLog();
+    // The instance of your mod that Forge uses.
+    @Instance("dynmapblockscan")
+    public static DynmapBlockScanMod instance;
+
+    // Says where the client and server 'proxy' code is loaded.
+    @SidedProxy(clientSide = "org.dynmap.blockscan.ClientProxy", serverSide = "org.dynmap.blockscan.Proxy")
+    public static Proxy proxy;
+    
+    public static DynmapBlockScanPlugin plugin;
+    public static File jarfile;
+    public static boolean verboselogging = false;
+    
+    public DynmapBlockScanMod() {
+    }
+    
+    @EventHandler
+    public void preInit(FMLPreInitializationEvent event)
+    {
+        jarfile = event.getSourceFile();
+        // Load configuration file - use suggested (config/DynmapBlockScan.cfg)
+        Configuration cfg = new Configuration(event.getSuggestedConfigurationFile());
+        try {
+            cfg.load();
+            
+           verboselogging = cfg.get("Settings",  "verboselog", false).getBoolean(false);
+        }
+        finally
+        {
+            cfg.save();
+        }
+    }
+
+    @EventHandler
+    public void init(FMLInitializationEvent event)
+    {
+    }
+
+    @EventHandler
+    public void postInit(FMLPostInitializationEvent event)
+    {
+    }
+
+    private MinecraftServer server;
+    @EventHandler
+    public void serverStarting(FMLServerStartingEvent event) {
+        server = event.getServer();
+        if(plugin == null)
+            plugin = proxy.startServer(server);
+        plugin.serverStarting();
+    }
+    
+    @EventHandler
+    public void serverStarted(FMLServerStartedEvent event)
+    {
+        plugin.serverStarted();
+    }
+    @EventHandler
+    public void serverStopping(FMLServerStoppingEvent event)
+    {
+    	proxy.stopServer(plugin);
+    	plugin = null;
+    }
+    @NetworkCheckHandler
+    public boolean netCheckHandler(Map<String, String> mods, Side side) {
+        return true;
+    }    
+}