class Advancement(MCDict): display: Display = mc_basic('display', Display) parent: str = mc_basic('parent', str) criteria: Dict[str, Criteria] = mc_dict('criteria', Criteria.create) requirements: List[List[str]] = mc_list('requirements', list) rewards: Rewards = mc_basic('rewards', Rewards) @staticmethod def populate(criteria: Dict[str, Criteria], display: Display = None, parent: str = None, requirements: List[str] = None, rewards: Rewards = None): adv = Advancement() adv.criteria = criteria if display is not None: adv.display = display if parent is not None: adv.parent = parent if requirements is not None: adv.requirements = requirements if rewards is not None: adv.rewards = rewards return adv
class Icon(MCDict): item: str = mc_basic('item', str) nbt: str = mc_basic('nbt', str) @staticmethod def populate(item: str = ''): icon = Icon() icon.item = item return icon
class Display(MCDict): icon: Icon = mc_basic('icon', Icon) title: TextComponent = mc_basic('title', TextComponent) frame: eFrame = mc_basic('frame', eFrame) background: str = mc_basic('background', str) description: TextComponent = mc_basic('description', TextComponent) show_toast: bool = mc_basic('show_toast', bool) announce_to_chat: bool = mc_basic('announce_to_chat', bool) hidden: bool = mc_basic('hidden', bool) @staticmethod def populate(icon: str, title: str, description: str, frame: str = None, background: str = None, show: bool = None, announce: bool = None, hidden: bool = None): display = Display() display.icon = Icon.populate(icon) display.title = TextComponent.populate(title) display.description = TextComponent.populate(description) if frame is not None: display.frame = eFrame(frame) if background is not None: display.background = background if show is not None: display.show_toast = show if announce is not None: display.announce_to_chat = announce if hidden is not None: display.hidden = hidden return display
class Entry(MCDict, MCInteractable): conditions: List[Condition] = mc_list('conditions', Condition.create) typ: eEntry = mc_basic('type', eEntry) weight: int = mc_basic('weight', int) quality: int = mc_basic('quality', int) def interact(self, info: MCActionInfo): if info.item_type == eItemType.Entry and 'children' in self: interact_with_items(self, 'children', info) elif info.item_type == eItemType.Condition: if 'conditions' in self: interact_with_items(self, 'conditions', info) if 'children' in self: interact_with_subitems(self['children'], info) if info.action_type is eActionType.Delete and self.typ is eEntry.alternatives and not any( 'conditions' in child for child in self['children']): self.typ = eEntry.group if 'functions' in self: interact_with_subitems(self['functions'], info) @staticmethod def create(json_body): typ = json_body['type'] if typ == eEntry.item: return ItemEntry(json_body) elif typ == eEntry.tag: return TagEntry(json_body) elif typ == eEntry.loot_table: return LootTableEntry(json_body) elif typ == eEntry.group: return GroupEntry(json_body) elif typ == eEntry.alternatives: return AlternativesEntry(json_body) elif typ == eEntry.sequence: return SequenceEntry(json_body) elif typ == eEntry.dynamic: return DynamicEntry(json_body) else: return Entry(json_body)
class LootTable(MCDict, MCInteractable): typ: eLootTable = mc_basic('type', eLootTable) pools: List[Pool] = mc_list('pools', Pool) def interact(self, info: MCActionInfo): if 'pools' in self: interact_with_subitems(self.pools, info)
class Pool(MCDict, MCInteractable): conditions: List[Condition] = mc_list('conditions', Condition.create) rolls: Union[IntRange, int] = mc_basic('rolls', init_int_or_range) bonus_rolls: Union[FloatRange, float] = mc_basic('bonus_rolls', init_float_or_range) entries: List[Entry] = mc_list('entries', Entry.create) def interact(self, info: MCActionInfo): if info.item_type == eItemType.Entry and 'entries' in self: interact_with_items(self, 'entries', info) elif info.item_type == eItemType.Condition: if 'conditions' in self: interact_with_items(self, 'conditions', info) if 'entries' in self: interact_with_subitems(self.entries, info)
class AdvItem(dict): selector: str = mc_basic('selector', str) item_selector: str = mc_basic('item_selector', str) adv_item_type: eAdvItemType = mc_basic('adv_item_type', eAdvItemType) title: str = mc_basic('title', str) description: str = mc_basic('description', str) @staticmethod def populate(selector: str, adv_item_type: eAdvItemType, item_selector: str = None, title: str = None, description: str = None): adv_item = AdvItem() adv_item.selector = selector adv_item.adv_item_type = adv_item_type adv_item.item_selector = selector if item_selector is None else item_selector adv_item.title = title adv_item.description = description return adv_item
class TextComponent(MCDict): text: str = mc_basic('text', str) @staticmethod def populate(text: str = ''): tc = TextComponent() tc.text = text return tc
class Criteria(MCDict): trigger_type: eTrigger = mc_basic('trigger', eTrigger) conditions: TriggerConditions = mc_basic('conditions', TriggerConditions) @staticmethod def create(json_dict: dict): criteria = Criteria(json_dict) if 'conditions' in json_dict: criteria.conditions = switch(criteria.trigger_type, json_dict['conditions']) return criteria @staticmethod def populate(trigger_type: eTrigger, conditions: TriggerConditions = None): criteria = Criteria() criteria.trigger_type = trigger_type if conditions is not None: criteria.conditions = conditions return criteria
class Function(MCDict, MCInteractable): function: eFunction = mc_basic('function', eFunction) conditions: List[Condition] = mc_list('conditions', Condition.create) def interact(self, info: MCActionInfo): if info.item_type == eItemType.Condition and 'conditions' in self: interact_with_items(self, 'conditions', info) @staticmethod def create(json_dict): return Function(json_dict)
class Item(MCDict): count: Union[IntRange, int] = mc_basic('count', init_int_or_range) durability: Union[IntRange, int] = mc_basic('durability', init_int_or_range) enchantments: List[Enchantment] = mc_list('enchantments', Enchantment) item_id: str = mc_basic('item', str) nbt: str = mc_basic('nbt', str) potion: str = mc_basic('potion', str) tag: str = mc_basic('tag', str) @staticmethod def populate(count: Union[IntRange, int] = None, durability: Union[IntRange, int] = None, enchantments: List[Enchantment] = None, item_id: str = None, nbt: str = None, potion: str = None, tag: str = None): item = Item() if count is not None: item.count = count if durability is not None: item.durability = durability if enchantments is not None: item.enchantments = enchantments if item is not None: item.item_id = item_id if nbt is not None: item.nbt = nbt if potion is not None: item.potion = potion if tag is not None: item.tag = tag return item
class CraftingShaped(Recipe): pattern: List[str] = mc_list('pattern', str) key: Dict[str, Union[Ingredient, List[Ingredient]]] = mc_dict('key', init_ingredient_or_list) result: Result = mc_basic('result', Result)
class ConstructBeacon(TriggerConditions): level: Union[IntRange, int] = mc_basic('level', init_int_or_range)
class Ingredient(MCDict): item: str = mc_basic('item', str) tag: str = mc_basic('tag', str)
class Recipe(MCDict): typ: eRecipe = mc_basic('type', eRecipe) group: str = mc_basic('group', str)
class EnterBlock(TriggerConditions): block: str = mc_basic('block', str) state: dict = mc_basic('state', dict)
class Result(MCDict): count: int = mc_basic('count', int) item: str = mc_basic('item', str)
class CuredZombieVillager(TriggerConditions): villager: Entity = mc_basic('villager', Entity) zombie: Entity = mc_basic('zombie', Entity)
class Enchantment(MCDict): enchantment: eEnchantment = mc_basic('enchantment', eEnchantment) levels: Union[IntRange, int] = mc_basic('levels', init_int_or_range)
class InventoryChanged(TriggerConditions): req_items: List[Item] = mc_list('items', Item) slots: dict = mc_basic('slots', dict)
class PlayerKilledEntity(TriggerConditions): entity: Entity = mc_basic('entity', Entity) killing_blow: dict = mc_basic('killing_blow', dict)
class EffectsChanged(TriggerConditions): effects: dict = mc_basic('effect', dict)
class FilledBucket(TriggerConditions): item: Item = mc_basic('item', Item)
class EntityHurtPlayer(TriggerConditions): damage: dict = mc_basic('damage', dict)
class ChanneledLightning(TriggerConditions): victims: Entity = mc_basic('victims', Entity)
class Rewards(MCDict): recipes: List[str] = mc_list('recipes', str) loot: List[str] = mc_list('loot', str) experience: int = mc_basic('experience', int) function: str = mc_basic('function', str)
class ChangedDimension(TriggerConditions): frm: eDimension = mc_basic('from', eDimension) to: eDimension = mc_basic('to', eDimension)
class ConsumeItem(TriggerConditions): item: Item = mc_basic('item', Item)
class FishingRodHooked(TriggerConditions): entity: Entity = mc_basic('entity', Entity) item: Item = mc_basic('item', Item) rod: Item = mc_basic('item', Item)
class EnchantedItem(TriggerConditions): item: Item = mc_basic('item', Item) levels: Union[IntRange, int] = mc_basic('levels', init_int_or_range)