def stmt(self, stmt):
name = escape_name(stmt.arg)
if stmt.keyword == 'grouping':
name = '%s_Grouping' % camel_case(name)
elif stmt.keyword == 'identity':
name = '%s_Identity' % camel_case(name)
elif stmt.keyword == 'rpc':
name = camel_case(name) + 'Rpc'
else:
name = camel_case(name)
if iskeyword(name):
name = '%s_' % name
self.name = name
if self.name.startswith('_'):
self.name = '%s%s' % ('Y', name)
self._stmt = stmt
desc = stmt.search_one('description')
if desc is not None:
self.comment = desc.arg
if stmt.keyword == 'module':
self._module = stmt
else:
self._module = stmt.i_module
def convert_owner_name(self, stmt):
name = escape_name(stmt.arg)
if stmt.keyword == 'grouping':
name = '%s_Grouping' % camel_case(name)
elif stmt.keyword == 'identity':
name = '%s_Identity' % camel_case(name)
elif stmt.keyword == 'rpc':
name = camel_case(name) + 'Rpc'
else:
name = camel_case(name)
if iskeyword(name):
name = '%s_' % name
if name.startswith('_'):
name = '%s%s' % ('Y', name)
return name
def stmt(self, stmt):
self._stmt = stmt
# the name of the numeration is derived either from the typedef
# or the leaf under which it is defined
leaf_or_typedef = stmt
while leaf_or_typedef.parent is not None and not leaf_or_typedef.keyword in ('leaf', 'leaf-list', 'typedef'):
leaf_or_typedef = leaf_or_typedef.parent
name = '%sEnum' % camel_case(escape_name(leaf_or_typedef.arg))
if iskeyword(name):
name = '%s_' % name
if name[0] == '_':
name = 'Y%s' % name
self.name = name
desc = stmt.search_one('description')
if desc is not None:
self.comment = desc.arg
else:
desc = leaf_or_typedef.search_one('description')
if desc is not None:
self.comment = desc.arg
for enum_stmt in stmt.search('enum'):
literal = EnumLiteral()
literal.stmt = enum_stmt
self.literals.append(literal)
def stmt(self, stmt):
self._stmt = stmt
self._dictionary = {}
self._pos_map = {}
# the name of the enumeration is derived either from the typedef
# or the leaf under which it is defined
leaf_or_typedef = stmt
while leaf_or_typedef.parent is not None and not leaf_or_typedef.keyword in ('leaf', 'leaf-list', 'typedef'):
leaf_or_typedef = leaf_or_typedef.parent
name = '%s_Bits' % camel_case(leaf_or_typedef.arg)
if iskeyword(name):
name = '%s_' % name
self.name = name
desc = stmt.search_one('description')
if desc is not None:
self.comment = desc.arg
else:
desc = leaf_or_typedef.search_one('description')
if desc is not None:
self.comment = desc.arg
for bit_stmt in stmt.search('bit'):
self._dictionary[bit_stmt.arg] = False
pos_stmt = bit_stmt.search_one('position')
if pos_stmt is not None:
self._pos_map[bit_stmt.arg] = pos_stmt.arg
def main():
particles = []
ids = {}
names = {}
types = load_minecraft_json("protocol.json",
"1.16")["types"]["particleData"][1]['fields']
print(types)
for particle in load_minecraft_json("particles.json", "1.16"):
variant = camel_case(particle['name'])
id = str(particle['id'])
if id in types.keys():
data = types[id]
print(data[1])
particles.append(generate_particle_data(variant, data[1]))
else:
particles.append(variant)
ids[variant] = id
names[variant] = particle['name']
output_data = generate_enum("Particle", particles)
output_data += generate_enum_property("Particle", "id", "u32", ids, True)
output_data += generate_enum_property("Particle", "name", "&str", names,
True, "&'static str")
output("crates/core/src/particle.rs", output_data)
def register_files(self, property, root_path, pattern, lifestyle_type = "UNKNOWN"):
if (lifestyle_type == "UNKNOWN"): lifestyle_type = self.default_lifestyle_type
self.assert_valid_lifestyle_type(lifestyle_type)
all_classes = []
for module_path in common.locate(pattern, root=root_path):
module = reflection.get_module_from_path(module_path)
class_name = common.camel_case(module.__name__)
cls = reflection.get_class_for_module(module, class_name)
if cls == None:
raise AttributeError("The class %s could not be found in file %s. Please make sure that the class has the same name as the file, but Camel Cased." % (class_name, module_path))
all_classes.append(cls)
component_definition = "indirect", lifestyle_type, all_classes, None, None
self.components[property] = component_definition
from common import load_minecraft_json, load_feather_json, camel_case, generate_enum, generate_enum_property, output
from re import compile
blocks = load_minecraft_json("blocks.json")
simplified_block = load_feather_json("simplified_block.json")
regexes = {}
for name, regex in simplified_block['regexes'].items():
regexes[name] = compile(regex)
variants = []
mapping = {}
for name in regexes:
variants.append(camel_case(name))
for block in blocks:
name = block['name']
block_variant = camel_case(name)
# Detect which SimplifiedBlockKind matches this block.
found = False
for simplified, regex in regexes.items():
if regex.match(name) is not None:
mapping[block_variant] = "SimplifiedBlockKind::" + camel_case(simplified)
found = True
break
if not found:
# Default to block variant
variants.append(block_variant)
mapping[block_variant] = "SimplifiedBlockKind::" + block_variant
from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output
entities = []
ids = {}
internal_ids = {}
names = {}
display_names = {}
bboxes = {}
for entity in load_minecraft_json("entities.json"):
variant = camel_case(entity['name'])
entities.append(variant)
ids[variant] = entity['id']
internal_ids[variant] = entity['internalId']
names[variant] = entity['name']
display_names[variant] = entity['displayName']
width = entity['width']
height = entity['height']
bboxes[
variant] = f"vek::Aabb {{ min: vek::Vec3::zero(), max: vek::Vec3::new({width} as f64, {height} as f64, {width} as f64), }}"
output_data = generate_enum("EntityKind", entities)
output_data += generate_enum_property("EntityKind", "id", "u32", ids, True)
output_data += generate_enum_property("EntityKind", "internal_id", "u32",
internal_ids, True)
output_data += generate_enum_property("EntityKind", "name", "&str", names,
True, "&'static str")
output_data += generate_enum_property("EntityKind", "display_name", "&str",
display_names, True, "&'static str")
output_data += generate_enum_property("EntityKind", "bounding_box",
from common import load_minecraft_json, output, generate_enum, generate_enum_property, camel_case
particles = []
ids = {}
names = {}
for particle in load_minecraft_json("particles.json", "1.16"):
variant = camel_case(particle['name'])
particles.append(variant)
ids[variant] = particle['id']
names[variant] = particle['name']
output_data = generate_enum("Particle", particles)
output_data += generate_enum_property("Particle", "id", "u32", ids, True)
output_data += generate_enum_property("Particle", "name", "&str", names, True, "&'static str")
output("crates/core/src/particle.rs", output_data)
import common as common
data = common.load_minecraft_json("particles.json", "1.16")
particles = []
ids = {}
names = {}
for particle in data:
variant = common.camel_case(particle['name'])
particles.append(variant)
ids[variant] = particle['id']
names[variant] = particle['name']
output = common.generate_enum("Particle", particles)
output += common.generate_enum_property("Particle", "id", "u32", ids, True)
output += common.generate_enum_property("Particle", "name", "&str", names, True, "&'static str")
common.output("src/particle.rs", output)
# Generation of the Biome enum. Uses minecraft-data/biomes.json.
import common
data = common.load_minecraft_json("biomes.json")
variants = []
ids = {}
names = {}
display_names = {}
rainfalls = {}
temperatures = {}
for biome in data:
variant = common.camel_case(biome['name'])
variants.append(variant)
ids[variant] = biome['id']
names[variant] = biome['name']
display_names[variant] = biome['displayName']
rainfalls[variant] = biome['rainfall']
temperatures[variant] = biome['temperature']
output = common.generate_enum("Biome", variants)
output += common.generate_enum_property("Biome", "id", "u32", ids, True)
output += common.generate_enum_property("Biome", "name", "&str", names, True,
"&'static str")
output += common.generate_enum_property("Biome", "display_name", "&str",
display_names, True, "&'static str")
output += common.generate_enum_property("Biome", "rainfall", "f32", rainfalls)
output += common.generate_enum_property("Biome", "temperature", "f32",
temperatures)
from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output
# build item ID => item kind index
item_kinds_by_id = {}
for item in load_minecraft_json("items.json"):
item_kinds_by_id[item['id']] = camel_case(item['name'])
# Build material name => dig multipliers index
material_dig_multipliers = {}
for name, material in load_minecraft_json("materials.json").items():
dig_multipliers = {}
for item_id, multiplier in material.items():
dig_multipliers[item_kinds_by_id[int(item_id)]] = float(multiplier)
material_dig_multipliers[name] = dig_multipliers
# Build material dig multipliers constants
material_constants = ""
material_constant_refs = {}
for name, dig_multipliers in material_dig_multipliers.items():
dm = ""
for item, multiplier in dig_multipliers.items():
dm += f"(libcraft_items::Item::{item}, {multiplier}_f32),"
constant = f"DIG_MULTIPLIERS_{name}"
material_constants += f"#[allow(dead_code, non_upper_case_globals)] const {constant}: &[(libcraft_items::Item, f32)] = &[{dm}];"
material_constant_refs[name] = constant
blocks = []
ids = {}
names = {}
display_names = {}
hardnesses = {}
from pathlib import Path
import common
import collections
data = common.load_feather_json("inventory.json")
# Areas
areas = []
for area in data['areas']:
areas.append(common.camel_case(area))
# Windows
windows = []
names = {}
inventories = {}
area_offsets = collections.OrderedDict()
for name, window in data['windows'].items():
variant = common.camel_case(name)
windows.append(variant)
names[variant] = name
inventories[variant] = window['inventories']
ao = collections.OrderedDict()
slot_counter = 0
for inventory_and_area, number_of_slots in window['slots'].items():
parts = inventory_and_area.split(":")
inventory = parts[0]
area_in_inventory = parts[1]
ao[(inventory, area_in_inventory)] = (slot_counter, number_of_slots)
"""Generation of the Biome enum. Uses minecraft-data/biomes.json."""
from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output
variants = []
ids = {}
names = {}
display_names = {}
rainfalls = {}
temperatures = {}
for biome in load_minecraft_json("biomes.json"):
variant = camel_case(biome['name'])
variants.append(variant)
ids[variant] = biome['id']
names[variant] = biome['name']
display_names[variant] = biome['displayName']
rainfalls[variant] = biome['rainfall']
temperatures[variant] = biome['temperature']
output_data = generate_enum("Biome", variants)
output_data += generate_enum_property("Biome", "id", "u32", ids, True)
output_data += generate_enum_property("Biome", "name", "&str", names, True,
"&'static str")
output_data += generate_enum_property("Biome", "display_name", "&str",
display_names, True, "&'static str")
output_data += generate_enum_property("Biome", "rainfall", "f32", rainfalls)
output_data += generate_enum_property("Biome", "temperature", "f32",
temperatures)
output("crates/core/src/biome.rs", output_data)
import common
data = common.load_minecraft_json("items.json", "1.16.2")
items = []
ids = {}
names = {}
display_names = {}
stack_sizes = {}
durabilities = {}
for item in data:
variant = common.camel_case(item['name'])
items.append(variant)
ids[variant] = item['id']
names[variant] = item['name']
display_names[variant] = item['displayName']
stack_sizes[variant] = item['stackSize']
durability = item.get('durability')
if durability is None:
durabilities[variant] = "None"
else:
durabilities[variant] = f"Some({durability})"
output = common.generate_enum("Item", items)
output += common.generate_enum_property("Item", "id", "u32", ids, True)
output += common.generate_enum_property("Item", "name", "&str", names, True,
"&'static str")
output += common.generate_enum_property("Item", "display_name", "&str",
display_names, True, "&'static str")
import common
import re
blocks = common.load_minecraft_json("blocks.json")
simplified_block = common.load_feather_json("simplified_block.json")
regexes = {}
for name, regex in simplified_block['regexes'].items():
regexes[name] = re.compile(regex)
variants = []
mapping = {}
for name in regexes:
variants.append(common.camel_case(name))
for block in blocks:
name = block['name']
block_variant = common.camel_case(name)
# Detect which SimplifiedBlockKind matches this block.
found = False
for simplified, regex in regexes.items():
if regex.match(name) is not None:
mapping[
block_variant] = "SimplifiedBlockKind::" + common.camel_case(
simplified)
found = True
break
if not found:
# Default to block variant
from common import load_minecraft_json, camel_case, generate_enum, generate_enum_property, output
items = []
ids = {}
names = {}
display_names = {}
stack_sizes = {}
durabilities = {}
for item in load_minecraft_json("items.json", "1.16.2"):
variant = camel_case(item['name'])
items.append(variant)
ids[variant] = item['id']
names[variant] = item['name']
display_names[variant] = item['displayName']
stack_sizes[variant] = item['stackSize']
durability = item.get('durability')
if durability is None:
durabilities[variant] = "None"
else:
durabilities[variant] = f"Some({durability})"
output_data = "#[derive(serde::Serialize, serde::Deserialize)]" + generate_enum("Item", items)
output_data += generate_enum_property("Item", "id", "u32", ids, True)
output_data += generate_enum_property("Item", "name", "&str", names, True, "&'static str")
output_data += generate_enum_property("Item", "display_name", "&str", display_names, False, "&'static str")
output_data += generate_enum_property("Item", "stack_size", "u32", stack_sizes)
output_data += generate_enum_property("Item", "durability", "Option<u32>", durabilities)
output("crates/items/src/item.rs", output_data)
import common
data = common.load_minecraft_json("entities.json", "1.16.2")
entities = []
ids = {}
internal_ids = {}
names = {}
display_names = {}
bboxes = {}
for entity in data:
variant = common.camel_case(entity['name'])
entities.append(variant)
ids[variant] = entity['id']
internal_ids[variant] = entity['internalId']
names[variant] = entity['name']
display_names[variant] = entity['displayName']
width = entity['width']
height = entity['height']
bboxes[
variant] = f"vek::Aabb {{ min: vek::Vec3::zero(), max: vek::Vec3::new({width} as f64, {height} as f64, {width} as f64), }}"
output = common.generate_enum("EntityKind", entities)
output += common.generate_enum_property("EntityKind", "id", "u32", ids, True)
output += common.generate_enum_property("EntityKind", "internal_id", "u32",
internal_ids, True)
output += common.generate_enum_property("EntityKind", "name", "&str", names,
True, "&'static str")
output += common.generate_enum_property("EntityKind", "display_name", "&str",
