All block shapes & collisions (#22)

* start adding shapes

* add more collision stuff

* DiscreteCubeMerger

* more mergers

* start adding BitSetDiscreteVoxelShape::join

* i love rust :smiley: :smiley: :smiley:

* r

* IT COMPILES????

* fix warning

* fix error

* fix more clippy issues

* add box_shape

* more shape stuff

* make DiscreteVoxelShape an enum

* Update shape.rs

* also make VoxelShape an enum

* implement BitSet::clear

* add more missing things

* it compiles

W

* start block shape codegen

* optimize shape codegen

* make az-block/blocks.rs look better (broken)

* almost new block macro

* make the codegen not generate 'type'

* try to fix

* work more on the blocks macro

* wait it compiles

* fix clippy issues

* shapes codegen works

* well it's almost working

* simplify some shape codegen

* enum type names are correct

* W it compiles

* cargo check no longer warns

* fix some clippy issues

* start making it so the shape impl is on BlockStates

* insane code

* new impl compiles

* fix wrong find_bits + TESTS PASS!

* add a test for slab collision

* fix clippy issues

* ok rust

* fix error that happens when on stairs

* add test for top slabs

* start adding join_is_not_empty

* add more to join_is_not_empty

* top slabs still don't work!!

* x..=0 doesn't work in rust :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley: :smiley:

* remove comment since i added more useful names

* remove some printlns

* fix walls in some configurations erroring

* fix some warnings

* change comment to \`\`\`ignore instead of \`\`\`no_run

* players are .6 wide not .8

* fix clippy's complaints

* i missed one clippy warning

3 files changed, 212 insertions, 67 deletions

diff --git a/codegen/lib/code/blocks.py b/codegen/lib/code/blocks.py
index 7dc85137..c32a3bbc 100644
--- a/codegen/lib/code/blocks.py
+++ b/codegen/lib/code/blocks.py
@@ -1,6 +1,7 @@
-from typing import Optional
-from lib.utils import to_snake_case, upper_first_letter, get_dir_location, to_camel_case
+from lib.utils import get_dir_location, to_camel_case
+from lib.code.utils import clean_property_name
 from ..mappings import Mappings
+from typing import Optional
 import re
 
 BLOCKS_RS_DIR = get_dir_location('../azalea-block/src/blocks.rs')
@@ -19,49 +20,6 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
     new_make_block_states_macro_code = []
     new_make_block_states_macro_code.append('make_block_states! {')
 
-    def get_property_struct_name(property: Optional[dict], block_data_burger: dict, property_variants: list[str]) -> str:
-        # these are hardcoded because otherwise they cause conflicts
-        # some names inspired by https://github.com/feather-rs/feather/blob/main/feather/blocks/src/generated/table.rs
-        if property_variants == ['north', 'east', 'south', 'west', 'up', 'down']:
-            return 'FacingCubic'
-        if property_variants == ['north', 'south', 'west', 'east']:
-            return 'FacingCardinal'
-        if property_variants == ['top', 'bottom']:
-            return 'TopBottom'
-        if property_variants == ['north_south', 'east_west', 'ascending_east', 'ascending_west', 'ascending_north', 'ascending_south']:
-            return 'RailShape'
-        if property_variants == ['straight', 'inner_left', 'inner_right', 'outer_left', 'outer_right']:
-            return 'StairShape'
-        if property_variants == ['normal', 'sticky']:
-            return 'PistonType'
-        if property_variants == ['x', 'z']:
-            return 'AxisXZ'
-        if property_variants == ['single', 'left', 'right']:
-            return 'ChestType'
-        if property_variants == ['compare', 'subtract']:
-            return 'ComparatorType'
-
-        if property is None:
-            return ''.join(map(to_camel_case, property_variants))
-
-        property_name = None
-        for class_name in [block_data_burger['class']] + block_data_burger['super']:
-            property_name = mappings.get_field(
-                class_name, property['field_name'])
-            if property_name:
-                break
-        assert property_name
-        property_name = to_camel_case(property_name.lower())
-        if property['type'] == 'int':
-            property_name = to_camel_case(
-                block_data_burger['text_id']) + property_name
-
-        # if property_variants == ['none', 'low', 'tall']:
-
-        if property_variants == ['up', 'side', 'none']:
-            property_name = 'Wire' + to_camel_case(property_name)
-
-        return property_name
 
     # Find properties
     properties = {}
@@ -87,7 +45,7 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
                     'Warning: The reports have states for a block, but Burger doesn\'t!', block_data_burger)
 
             property_struct_name = get_property_struct_name(
-                property_burger, block_data_burger, property_variants)
+                property_burger, block_data_burger, property_variants, mappings)
 
             if property_struct_name in properties:
                 if not properties[property_struct_name] == property_variants:
@@ -99,14 +57,7 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
 
             block_properties[property_struct_name] = property_variants
 
-            # if the name ends with _<number>, remove that part
-            ending = property_name.split('_')[-1]
-            if ending.isdigit():
-                property_name = property_name[:-(len(ending) + 1)]
-
-            # `type` is a reserved keyword, so we use kind instead ¯\_(ツ)_/¯
-            if property_name == 'type':
-                property_name = 'kind'
+            property_name = clean_property_name(property_name)
             property_struct_names_to_names[property_struct_name] = property_name
 
         properties.update(block_properties)
@@ -120,15 +71,20 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
         #     Ceiling,
         # },
         property_name = property_struct_names_to_names[property_struct_name]
-        new_make_block_states_macro_code.append(
-            f'        "{property_name}" => {property_struct_name} {{')
 
-        for variant in property_variants:
-            new_make_block_states_macro_code.append(
-                f'            {to_camel_case(variant)},')
+        # if the only variants are true and false, we can just make it a normal boolean
+        if property_variants == ['true', 'false']:
+            property_shape_code = 'bool'
+        else:
+            property_shape_code = f'{property_struct_name} {{\n'
+            for variant in property_variants:
+                property_shape_code += f'            {to_camel_case(variant)},\n'
+            property_shape_code += '        }'
 
         new_make_block_states_macro_code.append(
-            f'        }},')
+            f'        "{property_name}" => {property_shape_code},')
+
+
     new_make_block_states_macro_code.append('    },')
 
     # Block codegen
@@ -145,9 +101,8 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
             if state.get('default'):
                 default_property_variants = state.get('properties', {})
 
-        # TODO: use burger to generate the blockbehavior
-        new_make_block_states_macro_code.append(
-            f'        {block_id} => BlockBehavior::default(), {{')
+
+        properties_code = '{'
         for property_name in list(block_data_report.get('properties', {}).keys()):
             property_burger = None
             for property in block_data_burger.get('states', []):
@@ -159,11 +114,33 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
             property_variants = block_data_report['properties'][property_name]
 
             property_struct_name = get_property_struct_name(
-                property_burger, block_data_burger, property_variants)
+                property_burger, block_data_burger, property_variants, mappings)
+
+            is_boolean_property = property_variants == ['true', 'false']
+
+            if is_boolean_property:
+                # if it's a boolean, keep the type lowercase
+                # (so it's either `true` or `false`)
+                property_default_type = property_default
+            else:
+                property_default_type = f'{property_struct_name}::{to_camel_case(property_default)}'
+
             assert property_default is not None
-            new_make_block_states_macro_code.append(
-                f'            {property_struct_name}={to_camel_case(property_default)},')
-        new_make_block_states_macro_code.append('        },')
+
+            property_name = clean_property_name(property_name)
+            this_property_code = f'{property_name}: {property_default_type}'
+
+            properties_code += f'\n            {this_property_code},'
+        # if there's nothing inside the properties, keep it in one line
+        if properties_code == '{':
+            properties_code += '}'
+        else:
+            properties_code += '\n        }'
+
+        # TODO: use burger to generate the blockbehavior
+        new_make_block_states_macro_code.append(
+            f'        {block_id} => BlockBehavior::default(), {properties_code},')
+
     new_make_block_states_macro_code.append('    }')
     new_make_block_states_macro_code.append('}')
 
@@ -185,3 +162,47 @@ def generate_blocks(blocks_burger: dict, blocks_report: dict, ordered_blocks: li
 
     with open(BLOCKS_RS_DIR, 'w') as f:
         f.write('\n'.join(new_code))
+
+def get_property_struct_name(property: Optional[dict], block_data_burger: dict, property_variants: list[str], mappings: Mappings) -> str:
+    # these are hardcoded because otherwise they cause conflicts
+    # some names inspired by https://github.com/feather-rs/feather/blob/main/feather/blocks/src/generated/table.rs
+    if property_variants == ['north', 'east', 'south', 'west', 'up', 'down']:
+        return 'FacingCubic'
+    if property_variants == ['north', 'south', 'west', 'east']:
+        return 'FacingCardinal'
+    if property_variants == ['top', 'bottom']:
+        return 'TopBottom'
+    if property_variants == ['north_south', 'east_west', 'ascending_east', 'ascending_west', 'ascending_north', 'ascending_south']:
+        return 'RailShape'
+    if property_variants == ['straight', 'inner_left', 'inner_right', 'outer_left', 'outer_right']:
+        return 'StairShape'
+    if property_variants == ['normal', 'sticky']:
+        return 'PistonType'
+    if property_variants == ['x', 'z']:
+        return 'AxisXZ'
+    if property_variants == ['single', 'left', 'right']:
+        return 'ChestType'
+    if property_variants == ['compare', 'subtract']:
+        return 'ComparatorType'
+
+    if property is None:
+        return ''.join(map(to_camel_case, property_variants))
+
+    property_name = None
+    for class_name in [block_data_burger['class']] + block_data_burger['super']:
+        property_name = mappings.get_field(
+            class_name, property['field_name'])
+        if property_name:
+            break
+    assert property_name
+    property_name = to_camel_case(property_name.lower())
+    if property['type'] == 'int':
+        property_name = to_camel_case(
+            block_data_burger['text_id']) + property_name
+
+    # if property_variants == ['none', 'low', 'tall']:
+
+    if property_variants == ['up', 'side', 'none']:
+        property_name = 'Wire' + to_camel_case(property_name)
+
+    return property_name
diff --git a/codegen/lib/code/shapes.py b/codegen/lib/code/shapes.py
new file mode 100644
index 00000000..e65e4028
--- /dev/null
+++ b/codegen/lib/code/shapes.py
@@ -0,0 +1,110 @@
+from lib.utils import get_dir_location, to_camel_case
+from lib.code.utils import clean_property_name
+from .blocks import get_property_struct_name
+from ..mappings import Mappings
+
+COLLISION_BLOCKS_RS_DIR = get_dir_location(
+    '../azalea-physics/src/collision/blocks.rs')
+
+
+def generate_block_shapes(blocks: dict, shapes: dict, block_states_report, block_datas_burger, mappings: Mappings):
+    code = generate_block_shapes_code(blocks, shapes, block_states_report, block_datas_burger, mappings)
+    with open(COLLISION_BLOCKS_RS_DIR, 'w') as f:
+        f.write(code)
+
+
+def generate_block_shapes_code(blocks: dict, shapes: dict, block_states_report, block_datas_burger, mappings: Mappings):
+    # look at downloads/generator-mod-*/blockCollisionShapes.json for format of blocks and shapes
+
+    generated_shape_code = ''
+    # we make several lazy_static! blocks so it doesn't complain about
+    # recursion and hopefully the compiler can paralleize it?
+    generated_shape_code += 'lazy_static! {'
+    for i, (shape_id, shape) in enumerate(sorted(shapes.items(), key=lambda shape: int(shape[0]))):
+        if i > 0 and i % 10 == 0:
+            generated_shape_code += '}\nlazy_static! {'
+        generated_shape_code += generate_code_for_shape(shape_id, shape)
+    generated_shape_code += '}'
+
+    # BlockState::PurpurStairs_NorthTopStraightTrue => &SHAPE24,
+    generated_match_inner_code = ''
+    shape_ids_to_variants = {}
+    for block_id, shape_ids in blocks.items():
+        if isinstance(shape_ids, int):
+            shape_ids = [shape_ids]
+        block_report_data = block_states_report['minecraft:' + block_id]
+        block_data_burger = block_datas_burger[block_id]
+
+        for possible_state, shape_id in zip(block_report_data['states'], shape_ids):
+            variant_values = []
+            for value in tuple(possible_state.get('properties', {}).values()):
+                variant_values.append(to_camel_case(value))
+            
+            if variant_values == []:
+                variant_name = to_camel_case(block_id)
+            else:
+                variant_name = f'{to_camel_case(block_id)}_{"".join(variant_values)}'
+
+            if shape_id not in shape_ids_to_variants:
+                shape_ids_to_variants[shape_id] = []
+            shape_ids_to_variants[shape_id].append(f'BlockState::{variant_name}')
+    # shape 1 is the most common so we have a _ => &SHAPE1 at the end
+    del shape_ids_to_variants[1]
+    for shape_id, variants in shape_ids_to_variants.items():
+        generated_match_inner_code += f'{"|".join(variants)} => &SHAPE{shape_id},\n'
+
+
+    return f'''
+//! Autogenerated block collisions for every block
+
+// This file is generated from codegen/lib/code/block_shapes.py. If you want to
+// modify it, change that file.
+
+#![allow(clippy::explicit_auto_deref)]
+
+use super::VoxelShape;
+use crate::collision::{{self, Shapes}};
+use azalea_block::*;
+use lazy_static::lazy_static;
+
+trait BlockWithShape {{
+    fn shape(&self) -> &'static VoxelShape;
+}}
+
+{generated_shape_code}
+
+impl BlockWithShape for BlockState {{
+    fn shape(&self) -> &'static VoxelShape {{
+        match self {{
+            {generated_match_inner_code}_ => &SHAPE1
+        }}
+    }}
+}}
+'''
+
+
+def generate_code_for_shape(shape_id: str, parts: list[list[float]]):
+    def make_arguments(part: list[float]):
+        return ', '.join(map(lambda n: str(n).rstrip('0'), part))
+    code = ''
+    code += f'static ref SHAPE{shape_id}: VoxelShape = '
+    steps = []
+    if parts == []:
+        steps.append('collision::empty_shape()')
+    else:
+        steps.append(f'collision::box_shape({make_arguments(parts[0])})')
+        for part in parts[1:]:
+            steps.append(
+                f'Shapes::or(s, collision::box_shape({make_arguments(part)}))')
+
+    if len(steps) == 1:
+        code += steps[0]
+    else:
+        code += '{\n'
+        for step in steps[:-1]:
+            code += f'    let s = {step};\n'
+        code += f'    {steps[-1]}\n'
+        code += '};\n'
+    return code
+
+
diff --git a/codegen/lib/code/utils.py b/codegen/lib/code/utils.py
index e4671488..d91e0634 100644
--- a/codegen/lib/code/utils.py
+++ b/codegen/lib/code/utils.py
@@ -147,3 +147,17 @@ def write_packet_file(state, packet_name_snake_case, code):
 
 def fmt():
     os.system(f'cd {get_dir_location("..")} && cargo fmt')
+
+
+def clean_property_name(property_name):
+    # if the name ends with _<number>, remove that part
+    ending = property_name.split('_')[-1]
+    if ending.isdigit():
+        property_name = property_name[:-(len(ending) + 1)]
+
+    # `type` is a reserved keyword, so we use kind instead ¯\_(ツ)_/¯
+    if property_name == 'type':
+        property_name = 'kind'
+    
+    return property_name
+