Implement GlowMapRenderer.render() (#608)

Related to #572

Author: Pr0methean

src/main/java/net/glowstone/block/BuiltinMaterialValueManager.java

@@ -89,5 +89,10 @@ public int getFireResistance() {
         public double getSlipperiness() {
             return 0.6;
         }
+
+        @Override
+        public byte getBaseMapColor() {
+            return ((Number) get("baseMapColor")).byteValue();
+        }
     }
 }

src/main/java/net/glowstone/block/MaterialValueManager.java

@@ -58,5 +58,13 @@ interface ValueCollection {
          * @return the slipperiness
          */
         double getSlipperiness();
+
+        /**
+         * Returns the base map color for this value. Map pixels with this as the highest block can
+         * be this value plus 0 to 3.
+         *
+         * @return the base map color for this material
+         */
+        byte getBaseMapColor();
     }
 }

src/main/java/net/glowstone/map/GlowMapCanvas.java

@@ -20,19 +20,36 @@ public final class GlowMapCanvas implements MapCanvas {
     private MapCursorCollection cursors = new MapCursorCollection();
     private byte[] base;
 
+    /**
+     * Creates a new GlowMapCanvas for the given {@link MapView} and applies all updates seen by the
+     * given player.
+     *
+     * @param mapView The {@link MapView} to associate with this canvas and render
+     * @param player The player to pass to {@link MapRenderer#render(MapView, MapCanvas, Player)}
+     * @return a new, rendered {@link GlowMapCanvas}
+     */
     public static GlowMapCanvas createAndRender(MapView mapView, Player player) {
         GlowMapCanvas out = new GlowMapCanvas(mapView);
-        for (MapRenderer renderer : mapView.getRenderers()) {
-            renderer.initialize(mapView);
-            renderer.render(mapView, out, player);
-        }
+        out.update(player);
         return out;
     }
 
     protected GlowMapCanvas(MapView mapView) {
         this.mapView = mapView;
     }
 
+    /**
+     * Applies all updates seen by the given player according to the {@link MapView}'s renderers.
+     *
+     * @param player The player to pass to {@link MapRenderer#render(MapView, MapCanvas, Player)}
+     */
+    public void update(Player player) {
+        for (MapRenderer renderer : mapView.getRenderers()) {
+            renderer.initialize(mapView);
+            renderer.render(mapView, this, player);
+        }
+    }
+
     @Override
     public MapView getMapView() {
         return mapView;
@@ -93,6 +110,11 @@ public void drawText(int x, int y, MapFont font, String text) {
         throw new UnsupportedOperationException("Not supported yet.");
     }
 
+    /**
+     * Converts a snapshot of this canvas to a {@link Section} for transmission to the client.
+     *
+     * @return a {@link Section} holding a copy of this canvas's contents
+     */
     public Section toSection() {
         return new Section(MAP_SIZE, MAP_SIZE, mapView.getCenterX(), mapView.getCenterZ(), buffer.clone());
     }

src/main/java/net/glowstone/map/GlowMapRenderer.java

@@ -1,5 +1,14 @@
 package net.glowstone.map;
 
+import static net.glowstone.map.GlowMapCanvas.MAP_SIZE;
+
+import net.glowstone.GlowServer;
+import net.glowstone.block.GlowBlock;
+import net.glowstone.block.MaterialValueManager.ValueCollection;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
 import org.bukkit.map.MapCanvas;
 import org.bukkit.map.MapRenderer;
@@ -10,6 +19,7 @@
  */
 public final class GlowMapRenderer extends MapRenderer {
 
+    private static final int MAP_SIGHT_DISTANCE_SQUARED = 64 * 64;
     private final GlowMapView map;
 
     public GlowMapRenderer(GlowMapView map) {
@@ -19,7 +29,47 @@ public GlowMapRenderer(GlowMapView map) {
 
     @Override
     public void render(MapView map, MapCanvas canvas, Player player) {
-        // todo
+        World world = map.getWorld();
+        int scaleShift = map.getScale().getValue();
+        Location playerLoc = player.getLocation();
+        int playerX = playerLoc.getBlockX();
+        int playerZ = playerLoc.getBlockZ();
+        int cornerX = map.getCenterX() - ((MAP_SIZE / 2) << scaleShift);
+        int cornerZ = map.getCenterZ() - ((MAP_SIZE / 2) << scaleShift);
+        for (int pixelX = 0; pixelX < MAP_SIZE; pixelX++) {
+            for (int pixelY = 0; pixelY < MAP_SIZE; pixelY++) {
+                int worldX = cornerX + (pixelX << scaleShift);
+                int worldZ = cornerZ + (pixelY << scaleShift);
+                if (((worldX - playerX) * (worldX - playerX)
+                        + (worldZ - playerZ) * (worldZ - playerZ)) < MAP_SIGHT_DISTANCE_SQUARED) {
+                    // TODO: Should the highest block be skipped over if it's e.g. a flower or a
+                    // technical block?
+                    byte blockColor =
+                        colorFor(world.getHighestBlockAt(worldX, worldZ), worldX, worldZ);
+                    canvas.setPixel(pixelX, pixelY, blockColor);
+                }
+            }
+        }
+    }
+
+    /**
+     * Based on https://minecraft.gamepedia.com/Slime#.22Slime_chunks.22 but simplified (doesn't
+     * instantiate a Random, and doesn't vary with the world seed. Designed to be reproducible, so
+     * that updating a map doesn't change the color unless the map contents have changed.
+     */
+    private static byte pseudoRandomShade(int worldX, int worldZ) {
+        return (byte) ((
+                ((worldX * worldX * 0x4c1906) + (worldX * 0x5ac0db) + ((worldZ * worldZ) * 0x4307a7)
+                + (worldZ * 0x5f24f))) % 4);
     }
 
+    private static byte colorFor(Block block, int worldX, int worldZ) {
+        // TODO: Some blocks vary in map color based on block states (e.g. wood species)
+        ValueCollection materialValues;
+        materialValues = block instanceof GlowBlock ? ((GlowBlock) block).getMaterialValues()
+            : ((GlowServer) Bukkit.getServer()).getMaterialValueManager()
+                .getValues(block.getType());
+        byte base_color = materialValues.getBaseMapColor();
+        return (byte) (base_color | pseudoRandomShade(worldX, worldZ));
+    }
 }

src/main/resources/builtin/materialValues.yml

@@ -4,21 +4,29 @@ default:
   lightOpacity: 255
   flameResistance: -1
   fireResistance: -1
+  baseMapColor: 44
 values:
+  # Incomplete:
+  # hardness, blastResistance, lightOpacity, flameResistance, fireResistance, baseMapColor
   AIR:
     lightOpacity: 0
+    baseMapColor: 0
   STONE:
     blastResistance: 30
     hardness: 1.5
+    baseMapColor: 44
   GRASS:
     blastResistance: 3
     hardness: 0.6
+    baseMapColor: 4
   DIRT:
     blastResistance: 2.5
     hardness: 0.5
+    baseMapColor: 40
   COBBLESTONE:
     blastResistance: 30
     hardness: 2
+    baseMapColor: 44
   WOOD:
     flameResistance: 5
     fireResistance: 20
@@ -34,6 +42,7 @@ values:
     lightOpacity: 3
     hardness: 100
     blastResistance: 500
+    baseMapColor: 48
   STATIONARY_WATER:
     lightOpacity: 3
     hardness: 100