referenced more blocks by enum

Author: Lieuwe Westra

overviewer_core/src/iterate.c

@@ -263,7 +263,7 @@ generate_pseudo_data(RenderState* state, uint16_t ancilData) {
          * Note that stained glass encodes 16 colors using 4 bits.  this pushes us over the 8-bits of an uint8_t, 
          * forcing us to use an uint16_t to hold 16 bits of pseudo ancil data
          * */
-        if ((get_data(state, BLOCKS, x, y + 1, z) == 20) || (get_data(state, BLOCKS, x, y + 1, z) == 95)) {
+        if ((get_data(state, BLOCKS, x, y + 1, z) == block_glass) || (get_data(state, BLOCKS, x, y + 1, z) == block_stained_glass)) {
             data = 0;
         } else {
             data = 16;
@@ -278,15 +278,15 @@ generate_pseudo_data(RenderState* state, uint16_t ancilData) {
         uint8_t above_level_data = 0, same_level_data = 0, below_level_data = 0, possibly_connected = 0, final_data = 0;
 
         /* check for air in y+1, no air = no connection with upper level */
-        if (get_data(state, BLOCKS, x, y + 1, z) == 0) {
+        if (get_data(state, BLOCKS, x, y + 1, z) == block_air) {
             above_level_data = check_adjacent_blocks(state, x, y + 1, z, state->block);
         } /* else above_level_data = 0 */
 
         /* check connection with same level (other redstone and trapped chests */
-        same_level_data = check_adjacent_blocks(state, x, y, z, 55) | check_adjacent_blocks(state, x, y, z, 146);
+        same_level_data = check_adjacent_blocks(state, x, y, z, block_redstone_wire) | check_adjacent_blocks(state, x, y, z, block_trapped_chest);
 
         /* check the posibility of connection with y-1 level, check for air */
-        possibly_connected = check_adjacent_blocks(state, x, y, z, 0);
+        possibly_connected = check_adjacent_blocks(state, x, y, z, block_air );
 
         /* check connection with y-1 level */
         below_level_data = check_adjacent_blocks(state, x, y - 1, z, state->block);
@@ -622,7 +622,7 @@ chunk_render(PyObject* self, PyObject* args) {
                 /* if we found a proper texture, render it! */
                 if (t != NULL && t != Py_None) {
                     PyObject *src, *mask, *mask_light;
-                    int32_t do_rand = (state.block == block_tallgrass /*|| state.block == block_red_flower || state.block == block_double_plant*/);
+                    int32_t do_rand = (state.block == block_tallgrass);
                     int32_t randx = 0, randy = 0;
                     src = PyTuple_GetItem(t, 0);
                     mask = PyTuple_GetItem(t, 0);

overviewer_core/src/primitives/base.c

@@ -103,7 +103,7 @@ base_draw(void* data, RenderState* state, PyObject* src, PyObject* mask, PyObjec
      * biome-compliant ones! The tinting is now all done here.
      */
     if (/* grass, but not snowgrass */
-        (state->block == block_grass && get_data(state, BLOCKS, state->x, state->y + 1, state->z) != 78) ||
+        (state->block == block_grass && get_data(state, BLOCKS, state->x, state->y + 1, state->z) != block_snow_layer) ||
         block_class_is_subset(state->block, (mc_block_t[]){block_vine, block_waterlily, block_flowing_water, block_water, block_leaves, block_leaves2},
                               6) ||
         /* tallgrass, but not dead shrubs */

overviewer_core/src/primitives/cave.c

@@ -83,14 +83,14 @@ cave_hidden(void* data, RenderState* state, int32_t x, int32_t y, int32_t z) {
 
     blockID = getArrayShort3D(state->blocks, x, y, z);
     blockUpID = get_data(state, BLOCKS, x, y + 1, z);
-    if (blockID == 9 || blockID == 8 || blockUpID == 9 || blockUpID == 8) {
+    if (blockID == block_water || blockID == block_flowing_water || blockUpID == block_water || blockUpID == block_flowing_water) {
         for (dy = y + 1; dy < (SECTIONS_PER_CHUNK - state->chunky) * 16; dy++) {
             /* go up and check for skylight */
             if (get_data(state, SKYLIGHT, x, dy, z) != 0) {
                 return true;
             }
             blockUpID = get_data(state, BLOCKS, x, dy, z);
-            if (blockUpID != 8 && blockUpID != 9) {
+            if (blockUpID != block_flowing_water && blockUpID != block_water) {
                 /* we are out of the water! and there's no skylight
                  * , i.e. is a cave lake or something similar */
                 break;

overviewer_core/textures.py

@@ -14,8 +14,8 @@
 #    with the Overviewer.  If not, see <http://www.gnu.org/licenses/>.
 
 from collections import OrderedDict
-from locale import normalize
-import copy
+from copy import deepcopy
+from pathlib import Path
 import re
 import sys
 import imp
@@ -841,19 +841,19 @@ def normalize_model(self, modelname):
         match modelname:
             # observer top texture is inconsistent in rotation
             case 'block/loom':
-                self.models[modelname] = copy.deepcopy(self.models[modelname])
+                self.models[modelname] = deepcopy(self.models[modelname])
                 self.models[modelname]['elements'][0]['faces']['up']['texturerotation'] = 180
                 self.models[modelname]['elements'][0]['faces']['down']['texturerotation'] = 180
             case 'block/barrel' | 'block/barrel_open':
-                self.models[modelname] = copy.deepcopy(self.models[modelname])
+                self.models[modelname] = deepcopy(self.models[modelname])
                 self.models[modelname]['elements'][0]['faces']['north']['texture'] = '#up'
                 self.models[modelname]['elements'][0]['faces']['south']['texture'] = '#down'
                 self.models[modelname]['elements'][0]['faces']['down']['texture'] = '#north'
                 self.models[modelname]['elements'][0]['faces']['up']['texture'] = '#south'
                 self.models[modelname]['elements'][0]['faces']['east']['texturerotation'] = 90
                 self.models[modelname]['elements'][0]['faces']['west']['texturerotation'] = 90
             case 'block/dropper_vertical' | 'block/dispenser_vertical':
-                self.models[modelname] = copy.deepcopy(self.models[modelname])
+                self.models[modelname] = deepcopy(self.models[modelname])
                 self.models[modelname]['elements'][0]['faces']['north']['texture'] = '#up'
                 self.models[modelname]['elements'][0]['faces']['up']['texture'] = '#north'
 
@@ -869,6 +869,9 @@ def build_block_from_model(self, modelname, blockstate={}):
 
         img = Image.new("RGBA", (24,24), self.bgcolor)
 
+        if 'elements' not in colmodel:
+            return None
+
         # for each elements
         for elem in colmodel['elements']:
             try:
@@ -5382,11 +5385,11 @@ def hopper(self, blockid, data):
 @material(blockid=168, data=list(range(3)), solid=True)
 def prismarine_block(self, blockid, data):
     if data == 0: # prismarine
-       t = self.build_block_from_model("prismarine")
+       return self.build_block_from_model("prismarine")
     elif data == 1: # prismarine bricks
-       t = self.build_block_from_model("prismarine_bricks")
+       return self.build_block_from_model("prismarine_bricks")
     elif data == 2: # dark prismarine
-       t = self.build_block_from_model("dark_prismarine")
+       return  self.build_block_from_model("dark_prismarine")
     else:
         raise Exception('unexpected prismarine data: ' + str(data))
 

overviewer_core/world.py

@@ -18,12 +18,9 @@
 import os.path
 import logging
 import time
-import random
 import re
-import locale
 
 import numpy
-import math
 
 from . import nbt
 from . import cache
@@ -37,10 +34,11 @@
 class ChunkDoesntExist(Exception):
     pass
 
-
 class UnsupportedVersion(Exception):
     pass
 
+class UnknownBlockException(Exception):
+    pass
 
 def log_other_exceptions(func):
     """A decorator that prints out any errors that are not
@@ -1129,6 +1127,8 @@ def _get_block(self, palette_entry):
                   'purple', 'blue', 'brown', 'green', 'red', 'black']
 
         key = palette_entry['Name']
+        if key not in self._blockmap:
+            raise UnknownBlockException(key)
         (block, data) = self._blockmap[key]
         if key in ['minecraft:redstone_ore', 'minecraft:redstone_lamp']:
             if palette_entry['Properties']['lit'] == 'true':
@@ -1209,8 +1209,8 @@ def _get_block(self, palette_entry):
             data = int(palette_entry['Properties']['age'])
         elif key in ['minecraft:jigsaw']:
             data = {'down_east': 0, 'down_east': 0, 'down_north': 0, 'down_south': 0, 'down_west': 0,
-             'up_east': 1, 'up_north': 1, 'up_south': 1, 'up_west': 1, 'north_up': 2, 'south_up': 3,
-              'west_up': 4, 'east_up': 5}[palette_entry['Properties']['facing']]
+            'up_east': 1, 'up_north': 1, 'up_south': 1, 'up_west': 1, 'north_up': 2, 'south_up': 3,
+            'west_up': 4, 'east_up': 5}[palette_entry['Properties']['orientation']]
         elif (key.endswith('shulker_box') or key.endswith('piston') or
               key in ['minecraft:observer', 'minecraft:dropper', 'minecraft:dispenser',
                       'minecraft:piston_head', 'minecraft:end_rod']):
@@ -1514,7 +1514,7 @@ def _packed_longarray_to_shorts_v116(self, long_array, n, num_palette):
 
         return result
 
-    def _get_blockdata_v118(self, section, unrecognized_block_types, longarray_unpacker):
+    def _get_blockdata_v118(self, section, longarray_unpacker):
         block_states = section['block_states']
         palette = block_states.get('palette')
         block_states_data = block_states.get('data')
@@ -1531,7 +1531,7 @@ def _get_blockdata_v118(self, section, unrecognized_block_types, longarray_unpac
             key = palette[i]
             try:
                 translated_blocks[i], translated_data[i] = self._get_block(key)
-            except KeyError:
+            except UnknownBlockException as e:
                 pass    # We already have initialised arrays with 0 (= air)
 
         # Turn the BlockStates array into a 16x16x16 numpy matrix of shorts.
@@ -1547,7 +1547,7 @@ def _get_blockdata_v118(self, section, unrecognized_block_types, longarray_unpac
 
         return (blocks, data)
 
-    def _get_blockdata_v113(self, section, unrecognized_block_types, longarray_unpacker):
+    def _get_blockdata_v113(self, section, longarray_unpacker):
         # Translate each entry in the palette to a 1.2-era (block, data) int pair.
         num_palette_entries = len(section['Palette'])
         translated_blocks = numpy.zeros((num_palette_entries,), dtype=numpy.uint16) # block IDs
@@ -1556,7 +1556,7 @@ def _get_blockdata_v113(self, section, unrecognized_block_types, longarray_unpac
             key = section['Palette'][i]
             try:
                 translated_blocks[i], translated_data[i] = self._get_block(key)
-            except KeyError:
+            except UnknownBlockException as e:
                 pass    # We already have initialised arrays with 0 (= air)
 
         # Turn the BlockStates array into a 16x16x16 numpy matrix of shorts.
@@ -1719,7 +1719,6 @@ def get_chunk(self, x, z):
         chunk_data['Biomes'] = biomes
         chunk_data['NewBiomes'] = (len(biomes.shape) == 3)
 
-        unrecognized_block_types = {}
         for section in chunk_data['Sections']:
 
             # Turn the skylight array into a 16x16x16 matrix. The array comes
@@ -1755,9 +1754,9 @@ def get_chunk(self, x, z):
                 section['BlockLight'] = blocklight_expanded
 
                 if 'block_states' in section:
-                    (blocks, data) = self._get_blockdata_v118(section, unrecognized_block_types, longarray_unpacker)
+                    (blocks, data) = self._get_blockdata_v118(section, longarray_unpacker)
                 elif 'Palette' in section:
-                    (blocks, data) = self._get_blockdata_v113(section, unrecognized_block_types, longarray_unpacker)
+                    (blocks, data) = self._get_blockdata_v113(section, longarray_unpacker)
                 elif 'Data' in section:
                     (blocks, data) = self._get_blockdata_v112(section)
                 else:   # Special case introduced with 1.14
@@ -1773,9 +1772,6 @@ def get_chunk(self, x, z):
                 logging.debug("Full traceback:", exc_info=1)
                 raise nbt.CorruptChunkError()
 
-        for k in unrecognized_block_types:
-            logging.debug("Found %d blocks of unknown type %s" % (unrecognized_block_types[k], k))
-
         return chunk_data