Add most new Copper Age blocks (#103)

* Fix rendering of waterlogged ladders and glow lichen

Change-Id: I801243817f2930fcac0f04c67f51a83a5a0e07ef

* Extend spawn detection to account for other spawn points in other dimensions

Change-Id: I4f380dcdb533d1784bf6d4544771cae0064b4e8a

* Add copper generation function to aid in attribute compacting

Change-Id: Ic47c474ec7b988df0f2c67bc714f26894959a324

* Fix iron chain, add copper chain varieties

Change-Id: I21c336f93f64e2355ce233bed4edeab8679ea71b

* Add copper bars

Change-Id: I672f2820706afd847e47ca0ac6327a316cabafc6

* Add variants of lightning rod

Change-Id: I22f16e8fa2bcac2b9a295a9a3e4f0a966eaedbf5

* Add copper lanterns

Change-Id: I62f7c79a78071410162dfc924f2b8cefb39563a1

* Add copper torch

Change-Id: I649bb631884e85b291228f109caf96086f063816

* Add copper chests

Change-Id: Ia3e151946de2e7d4886523a8123f65f62e60dab5

* Add wooden shelves

Change-Id: Ia0d0491ebd0a8d11f9d3175cf589ef2514c253c4

# Conflicts:
#	overviewer_core/textures.py
#	overviewer_core/world.py

* Bump requests version

Change-Id: Ie06bb609008e8a8997da5c0c1160849056c3c9e6

Author: stwalkerster

overviewer.py

@@ -610,7 +610,7 @@ def set_renderchecks(checkname, num):
             "imgquality", "imglossless", "optimizeimg", "rendermode", "worldname_orig", "title",
             "dimension", "changelist", "showspawn", "overlay", "base", "poititle", "maxzoom",
             "showlocationmarker", "minzoom", "center"])
-        tileSetOpts.update({"spawn": w.find_true_spawn()})  # TODO find a better way to do this
+        tileSetOpts.update({"spawn": w.find_true_spawn(render['dimension'])})
         for rset in rsets:
             tset = tileset.TileSet(w, rset, assetMrg, tex, tileSetOpts, tileset_dir)
             tilesets.append(tset)

overviewer_core/settingsValidators.py

@@ -230,30 +230,15 @@ def validateStr(s):
 
 def validateDimension(d):
     """Validates the dimension setting"""
-    valid_dimensions = {
-        'overworld': 'DIM0',
-        'nether': 'DIM-1',
-        'end': 'DIM1'
-    }
 
+    dimension_data = util.get_dimension_data(d)
 
-    
-    if d is None:
+    if dimension_data is None:
         raise ValidationException(
             "Required key 'dimension' was not specified. Must be one of: 'overworld', 'nether', or 'end'"
         )
-    
-    # Convert to lowercase for case-insensitive comparison
-    if isinstance(d, str):
-        d = d.lower()
-    
-    if d not in valid_dimensions:
-        raise ValidationException(
-            "The dimension value must be one of: 'overworld', 'nether', or 'end'. "
-            f"Got '{d}' instead."
-        )
-    
-    return (d, valid_dimensions[d])
+
+    return d, dimension_data[0], dimension_data[1], dimension_data[2]
 
 def validateOutputDir(d):
     checkBadEscape(d)

overviewer_core/textures.py

@@ -1927,8 +1927,8 @@ def slabs(self, blockid, data):
 
     return self.build_slab_block(top, side, data & 8 == 8);
 
-# torch, redstone torch (off), redstone torch(on), soul_torch
-@material(blockid=[50, 75, 76, 1039], data=[1, 2, 3, 4, 5], transparent=True)
+# torch, redstone torch (off), redstone torch(on), soul_torch, copper_torch
+@material(blockid=[50, 75, 76, 1039, 264], data=[1, 2, 3, 4, 5], transparent=True)
 def torches(self, blockid, data):
     # first, rotations
     if self.rotation == 1:
@@ -1956,6 +1956,9 @@ def torches(self, blockid, data):
         small = self.load_image_texture(BLOCKTEXTURE + "redstone_torch.png")
     elif blockid == 1039: # soul torch
         small= self.load_image_texture(BLOCKTEXTURE + "soul_torch.png")
+    elif blockid == 264: # soul torch
+        small= self.load_image_texture(BLOCKTEXTURE + "copper_torch.png")
+
     # compose a torch bigger than the normal
     # (better for doing transformations)
     torch = Image.new("RGBA", (16,16), self.bgcolor)
@@ -1999,13 +2002,19 @@ def torches(self, blockid, data):
     return img
 
 # lantern
-@material(blockid=[11373, 1038], data=[0, 1], transparent=True)
+@material(blockid=[11373, 1038, 1156,1157,1158,1159], data=[0, 1], transparent=True)
 def lantern(self, blockid, data):
     # get the  multipart texture of the lantern
-    if blockid == 11373:
-        inputtexture = self.load_image_texture(BLOCKTEXTURE + "lantern.png")
-    if blockid == 1038:
-        inputtexture = self.load_image_texture(BLOCKTEXTURE + "soul_lantern.png")
+    texmap = {
+        11373: "lantern.png",
+        1038: "soul_lantern.png",
+        1156: "copper_lantern.png",
+        1157: "exposed_copper_lantern.png",
+        1158: "weathered_copper_lantern.png",
+        1159: "oxidized_copper_lantern.png",
+    }
+
+    inputtexture = self.load_image_texture(BLOCKTEXTURE + texmap[blockid])
 
 
     # # now create a textures, using the parts defined in lantern.json
@@ -2349,7 +2358,7 @@ def rect(tex,coords):
 
 # normal, locked (used in april's fool day), ender and trapped chest
 # NOTE:  locked chest used to be id95 (which is now stained glass)
-@material(blockid=[54, 130, 146], data=list(range(30)), transparent = True)
+@material(blockid=[54, 130, 146, 11425, 11426, 11427, 11428], data=list(range(30)), transparent = True)
 def chests(self, blockid, data):
     # the first 3 bits are the orientation as stored in minecraft, 
     # bits 0x8 and 0x10 indicate which half of the double chest is it.
@@ -2376,12 +2385,20 @@ def chests(self, blockid, data):
         # iterate.c will only return the ancil data (without pseudo 
         # ancil data) for locked and ender chests, so only 
         # ancilData = 2,3,4,5 are used for this blockids
-    
+
+    texture_base_name = {
+        11425: "copper",
+        11426: "copper_exposed",
+        11427: "copper_weathered",
+        11428: "copper_oxidized",
+    }.get(blockid, "normal")
+
     if data & 24 == 0:
-        if blockid == 130: t = self.load_image("assets/minecraft/textures/entity/chest/ender.png")
+        if blockid == 130:
+            t = self.load_image("assets/minecraft/textures/entity/chest/ender.png")
         else:
             try:
-                t = self.load_image("assets/minecraft/textures/entity/chest/normal.png")
+                t = self.load_image(f"assets/minecraft/textures/entity/chest/{texture_base_name}.png")
             except (TextureException, IOError):
                 t = self.load_image("assets/minecraft/textures/entity/chest/chest.png")
 
@@ -2440,8 +2457,8 @@ def chests(self, blockid, data):
         # large chest
         # the textures is no longer in terrain.png, get it from 
         # item/chest.png and get all the needed stuff
-        t_left = self.load_image("assets/minecraft/textures/entity/chest/normal_left.png")
-        t_right = self.load_image("assets/minecraft/textures/entity/chest/normal_right.png")
+        t_left = self.load_image(f"assets/minecraft/textures/entity/chest/{texture_base_name}_left.png")
+        t_right = self.load_image(f"assets/minecraft/textures/entity/chest/{texture_base_name}_right.png")
         # for some reason the 1.15 images are upside down
         t_left = ImageOps.flip(t_left)
         t_right = ImageOps.flip(t_right)
@@ -4852,12 +4869,20 @@ def huge_mushroom(self, blockid, data):
 # iron bars and glass pane
 # TODO glass pane is not a sprite, it has a texture for the side,
 # at the moment is not used
-@material(blockid=[101,102, 160], data=list(range(256)), transparent=True, nospawn=True)
+@material(blockid=[101,102, 160,260,261,262,263], data=list(range(256)), transparent=True, nospawn=True)
 def panes(self, blockid, data):
     # no rotation, uses pseudo data
     if blockid == 101:
         # iron bars
         t = self.load_image_texture(BLOCKTEXTURE + "iron_bars.png")
+    elif blockid == 260:
+        t = self.load_image_texture(BLOCKTEXTURE + "copper_bars.png")
+    elif blockid == 261:
+        t = self.load_image_texture(BLOCKTEXTURE + "exposed_copper_bars.png")
+    elif blockid == 262:
+        t = self.load_image_texture(BLOCKTEXTURE + "weathered_copper_bars.png")
+    elif blockid == 263:
+        t = self.load_image_texture(BLOCKTEXTURE + "oxidized_copper_bars.png")
     elif blockid == 160:
         t = self.load_image_texture(BLOCKTEXTURE + "%s_stained_glass.png" % color_map[data & 0xf])
     else:
@@ -6772,14 +6797,26 @@ def froglight(self, blockid, data):
     return self.build_axis_block(top, side, data)
 
 # Chain
-@material(blockid=11419, data=list(range(3)), solid=True, transparent=True, nospawn=True)
+@material(blockid=[11419,11420,11421,11422,11423,11424], data=list(range(3)), solid=True, transparent=True, nospawn=True)
 def chain(self, blockid, data):
-    # In versions prior to 1.21.10 chain was adequate, versions after 1.21.10 chain may be iron
+    # Updated in 1.21.9:  chain -> iron_chain
+    # Most people are probably going to have newer versions, so let's try new first.
+
+    texture_dict = {
+        11419: "chain",
+        11420: "iron_chain",
+        11421: "copper_chain",
+        11422: "exposed_copper_chain",
+        11423: "weathered_copper_chain",
+        11424: "oxidized_copper_chain",
+    }
+
     try:
-        tex = self.load_image_texture(BLOCKTEXTURE + "chain.png")
-    except:
-        tex = self.load_image_texture(BLOCKTEXTURE + "iron_chain.png")
-    
+        tex = self.load_image_texture(BLOCKTEXTURE + texture_dict[blockid] + ".png")
+    except (TextureException, IOError):
+        # Texture load failed, assume texture doesn't exist.
+        return None
+
     sidetex = Image.new(tex.mode, tex.size, self.bgcolor)
     mask = tex.crop((0, 0, 6, 16))
     alpha_over(sidetex, mask, (5, 0), mask)
@@ -6936,9 +6973,17 @@ def cave_vines(self, blockid, data):
             tex = self.load_image_texture(BLOCKTEXTURE + "cave_vines.png")
     return self.build_sprite(tex)
 
-@material(blockid=1118, data=list(range(6)), transparent=True, solid=True)
+@material(blockid=[1118,1153,1154,1155], data=list(range(6)), transparent=True, solid=True)
 def lightning_rod(self, blockid, data):
-    tex = self.load_image_texture(BLOCKTEXTURE + "lightning_rod.png")
+    texmap = {
+        1118: "lightning_rod",
+        1153: "exposed_lightning_rod",
+        1154: "weathered_lightning_rod",
+        1155: "oxidized_lightning_rod",
+    }
+
+
+    tex = self.load_image_texture(BLOCKTEXTURE + texmap[blockid] + '.png')
     img = Image.new("RGBA", (24, 24), self.bgcolor)
 
     mask = tex.crop((0, 4, 2, 16))
@@ -7600,6 +7645,91 @@ def test_block(self, _, data):
     tex = self.load_image_texture(BLOCKTEXTURE + 'test_block_' + ['start','accept','fail','log'][data] + '.png')
     return self.build_block(tex, tex)
 
+@material(blockid=list(range(12700, 12712)), data=list(range(0b111)), transparent=True)
+def shelf(self, block_id, data):
+    texmap = {
+        12700: 'oak_shelf',
+        12701: 'spruce_shelf',
+        12702: 'birch_shelf',
+        12703: 'jungle_shelf',
+        12704: 'acacia_shelf',
+        12705: 'dark_oak_shelf',
+        12706: 'crimson_shelf',
+        12707: 'warped_shelf',
+        12708: 'mangrove_shelf',
+        12709: 'cherry_shelf',
+        12710: 'bamboo_shelf',
+        12711: 'pale_oak_shelf',
+    }
+
+    tex = self.load_image(BLOCKTEXTURE + texmap[block_id] + '.png')
+
+    powered = (data & 0b100) == 0b100
+    direction = data & 0b011
+
+    direction = (direction + self.rotation) % 4
+
+    front = Image.new("RGBA", (16, 16), self.bgcolor)
+    alpha_over(front, tex.crop((0, 0, 16, 16)), (0, 0))
+
+    if powered:
+        # fake this for now
+        chain = 'center'
+
+        if chain == 'left':
+            alpha_over(front, tex.crop((0, 16, 16, 23)), (0, 4))
+            pass
+        elif chain == 'right':
+            alpha_over(front, tex.crop((16, 16, 32, 24)), (0, 4))
+            pass
+        elif chain == 'center':
+            alpha_over(front, tex.crop((0, 24, 16, 34)), (0, 4))
+            pass
+        elif chain == 'none':
+            alpha_over(front, tex.crop((16, 24, 32, 32)), (0, 4))
+            pass
+
+    rear = Image.new("RGBA", (16, 16), self.bgcolor)
+    alpha_over(rear, tex.crop((16, 0, 32, 16)), (0, 0))
+
+    right = Image.new("RGBA", (16, 16), self.bgcolor)
+    alpha_over(right, tex.crop((28, 0, 32, 16)), (0, 0))
+
+    left = Image.new("RGBA", (16, 16), self.bgcolor)
+    alpha_over(left, tex.crop((16, 0, 20, 16)), (0, 0))
+
+    top = Image.new("RGBA", (16, 16), self.bgcolor)
+    alpha_over(top, tex.crop((16, 7, 32, 12)), (0, 0))
+
+    # None == front; we handle this later
+    sides = [left, None, right, rear]
+
+    for i in range(direction):
+        sides = sides[1:] + sides[:1]
+        top = top.rotate(270)
+
+    # Make the sides line up properly
+    if sides[2] is None:
+        sides[1] = sides[1].transpose(Image.FLIP_LEFT_RIGHT)
+        sides[3] = sides[3].transpose(Image.FLIP_LEFT_RIGHT)
+
+    if sides[3] is None:
+        sides[0] = sides[0].transpose(Image.FLIP_LEFT_RIGHT)
+        sides[2] = sides[2].transpose(Image.FLIP_LEFT_RIGHT)
+
+    block = self.build_full_block(top, sides[3], sides[2], sides[0], sides[1])
+
+    # stitch on the front in the correct place
+    if sides[0] is None:
+        front = self.transform_image_side(front)
+        alpha_over(block, front, (9, 2), front)
+
+    if sides[1] is None:
+        front = self.transform_image_side(front.transpose(Image.FLIP_LEFT_RIGHT)).transpose(Image.FLIP_LEFT_RIGHT)
+        alpha_over(block, front, (3, 2), front)
+
+    return block
+
 
 sprite(blockid=11385, imagename=BLOCKTEXTURE + "oak_sapling.png")
 sprite(blockid=11386, imagename=BLOCKTEXTURE + "spruce_sapling.png")

overviewer_core/tileset.py

@@ -620,8 +620,7 @@ def bgcolorformat(color):
         if isOverlay:
             d.update({"tilesets": self.options.get("overlay")})
 
-        # DIM0 means overworld
-        if self.regionset.get_type() == "DIM0" and self.options.get("showspawn", True):
+        if self.options.get("showspawn", True):
             d.update({"spawn": self.options.get("spawn")})
         else:
             d.update({"spawn": False})

overviewer_core/util.py

@@ -25,6 +25,30 @@
 from string import hexdigits
 from subprocess import PIPE, Popen
 
+DIMENSION_INFO = {
+    "minecraft:overworld": ("DIM0", 0, "minecraft:overworld"),
+    "minecraft:the_end": ("DIM1", 1, "minecraft:the_end"),
+    "minecraft:the_nether": ("DIM-1", -1, "minecraft:the_nether"),
+}
+
+
+def get_dimension_data(dimension):
+    if isinstance(dimension, int):
+        for dim_name, (folder, dim_id, _) in DIMENSION_INFO.items():
+            if dim_id == dimension:
+                return DIMENSION_INFO[dim_name]
+    elif isinstance(dimension, str):
+        if dimension in DIMENSION_INFO:
+            return DIMENSION_INFO[dimension]
+        elif dimension in ("overworld"):
+            return DIMENSION_INFO["minecraft:overworld"]
+        elif dimension in ("the_end", "end"):
+            return DIMENSION_INFO["minecraft:the_end"]
+        elif dimension in ("the_nether", "nether"):
+            return DIMENSION_INFO["minecraft:the_nether"]
+
+    return None
+
 
 def get_program_path():
     # Check if running as a frozen executable (e.g., created with PyInstaller)