Please migrate to https://github.com/vberlier/beet
A python library for programmatically creating and editing Minecraft data packs. Requires python 3.7.
from mcpack import DataPack, Function
pack = DataPack('My cool pack', 'This is the description of my pack.')
pack['my_cool_pack:hello'] = Function(
'say Hello, world!\n'
'give @s minecraft:dead_bush\n'
)
pack.dump('.minecraft/saves/New World/datapacks')
Make sure that you're using python 3.7 or above. The package can be installed with pip
.
$ pip install mcpack
Check out the examples for a quick overview.
The DataPack
class represents a minecraft data pack.
from mcpack import DataPack
pack = DataPack('Test', 'Test description.')
print(pack.name) # 'Test'
print(pack.description) # 'Test description.'
print(pack.pack_format) # 1
print(pack.namespaces) # defaultdict(<class 'mcpack.Namespace'>, {})
You can load already existing data packs using the load
class method.
from mcpack import DataPack
pack = DataPack.load('.minecraft/save/New World/datapacks/Test')
The dump
method allows you to generate the actual Minecraft data pack. The method will raise a ValueError
if the data pack already exists. You can explicitly overwrite the existing data pack by setting the overwrite
argument to True
.
from mcpack import DataPack
pack = DataPack('Test', 'Test description.')
pack.dump('.minecraft/save/New World/datapacks')
pack.dump('.minecraft/save/New World/datapacks', overwrite=True)
Namespace
objects hold references to data pack items using a separate dictionary for each type of item.
from mcpack import Namespace
namespace = Namespace()
print(namespace.advancements) # {}
print(namespace.functions) # {}
print(namespace.loot_tables) # {}
print(namespace.recipes) # {}
print(namespace.structures) # {}
print(namespace.block_tags) # {}
print(namespace.item_tags) # {}
print(namespace.fluid_tags) # {}
print(namespace.function_tags) # {}
print(namespace.entity_type_tags) # {}
You can add namespaces to DataPack
objects using the namespaces
attribute. Note that you won't usually need to create namespaces yourself. If you want to edit a namespace, you just need to retrieve it and the defaultdict
will create an empty namespace for you if it doesn't already exist.
from mcpack import DataPack
pack = DataPack('Test', 'Test description.')
print(pack.namespaces['test']) # Namespace(...)
To make things even more convenient, the __getitem__
and __setitem__
methods of DataPack
objects are mapped to the namespaces
attribute. It means that you can access namespaces directly from the DataPack
object.
print(pack['test']) # Namespace(...)
Adding items to namespaces is pretty straight-forward. Simply add them to their respective dictionaries.
from mcpack import (DataPack, Advancement, Function, LootTable, Recipe,
Structure, BlockTag, ItemTag, FluidTag, FunctionTag,
EntityTypeTag)
pack = DataPack('Test', 'Test description.')
pack['test'].advancements['foo'] = Advancement(...)
pack['test'].functions['foo/spam'] = Function(...)
pack['test'].loot_tables['foo/egg'] = LootTable(...)
pack['test'].recipes['bar'] = Recipe(...)
pack['test'].structures['bar/spam'] = Structure(...)
pack['test'].block_tags['bar/egg'] = BlockTag(...)
pack['test'].item_tags['baz'] = ItemTag(...)
pack['test'].fluid_tags['baz/spam'] = FluidTag(...)
pack['test'].function_tags['baz/egg'] = FunctionTag(...)
pack['test'].entity_type_tags['qux'] = EntityTypeTag(...)
You can also use the DataPack
object directly. The __setitem__
method actually checks if the key looks like namespace:path
and dispatches the item automatically. We can now simplify the previous piece of code quite a bit.
from mcpack import (DataPack, Advancement, Function, LootTable, Recipe,
Structure, BlockTag, ItemTag, FluidTag, FunctionTag,
EntityTypeTag)
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = Advancement(...)
pack['test:foo/spam'] = Function(...)
pack['test:foo/egg'] = LootTable(...)
pack['test:bar'] = Recipe(...)
pack['test:bar/spam'] = Structure(...)
pack['test:bar/egg'] = BlockTag(...)
pack['test:baz'] = ItemTag(...)
pack['test:baz/spam'] = FluidTag(...)
pack['test:baz/egg'] = FunctionTag(...)
pack['test:qux'] = EntityTypeTag(...)
Advancement
objects represent Minecraft advancements.
from mcpack import DataPack, Advancement
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = Advancement()
advancement = pack['test'].advancements['foo']
print(advancement.display) # None
print(advancement.parent) # None
print(advancement.criteria) # {}
print(advancement.requirements) # None
print(advancement.rewards) # None
All the attributes can be set in the constructor. They mirror the root properties of the advancement JSON file format.
Check out the wiki for further details.
Function
objects represent Minecraft functions.
from mcpack import DataPack, Function
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = Function()
function = pack['test'].functions['foo']
print(function.body) # ''
The body
attribute can be set in the constructor. The body of the function corresponds to the content of the actual .mcfunction
file.
Check out the wiki for further details.
LootTable
objects represent Minecraft loot tables.
from mcpack import DataPack, LootTable
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = LootTable()
loot_table = pack['test'].loot_tables['foo']
print(loot_table.pools) # []
print(loot_table.type) # 'generic'
print(loot_table.functions) # None
All the attributes can be set in the constructor. They mirror the root properties of the loot table JSON file format.
Check out the wiki for further details.
Recipe
objects represent Minecraft recipes.
from mcpack import DataPack, Recipe
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = Recipe()
recipe = pack['test'].recipes['foo']
print(recipe.type) # 'crafting_shaped'
print(recipe.group) # None
print(recipe.pattern) # []
print(recipe.key) # {}
print(recipe.ingredient) # None
print(recipe.ingredients) # None
print(recipe.result) # {}
print(recipe.experience) # None
print(recipe.cookingtime) # None
print(recipe.count) # None
All the attributes can be set in the constructor. They mirror the root properties of the recipe JSON file format.
Check out the wiki for further details.
Structure
objects represent Minecraft structures.
from mcpack import DataPack, Structure
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = Structure()
structure = pack['test'].structures['foo']
print(structure.data_version) # Int(1503)
print(structure.author) # String('')
print(structure.size) # List[Int]([0, 0, 0])
print(structure.palette) # List[State]([])
print(structure.palettes) # List[List[State]]([])
print(structure.blocks) # List[Block]([])
print(structure.entities) # List[Entity]([])
All the attributes can be set in the constructor. They mirror the root properties of the structure NBT file format. mcpack
uses nbtlib
to manipulate nbt data. The Structure
class inherits from an nbtlib
schema that takes care of wrapping python values with the appropriate nbt tags.
Check out the wiki for further details.
BlockTag
, ItemTag
, FluidTag
, FunctionTag
and EntityTypeTag
objects represent Minecraft block, item, fluid, function and entity type tags respectively. They are all identical in structure, the only difference between them is the namespace directory they get written to.
from mcpack import DataPack, BlockTag
pack = DataPack('Test', 'Test description.')
pack['test:foo'] = BlockTag()
block_tag = pack['test'].block_tags['foo']
print(block_tag.values) # []
print(block_tag.replace) # False
The values
and replace
attributes can be set in the constructor. They mirror the root properties of the tag JSON file format.
Check out the wiki for further details.
Contributions are welcome. This project uses poetry
so you'll need to install it first if you want to be able to work with the project locally.
$ curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
You should now be able to install the required dependencies.
$ poetry install
You can run the tests with poetry run pytest
.
$ poetry run pytest
The project can also download the latest minecraft releases and run tests against the vanilla data pack. You can enable these tests by using the --vanilla
flag.
$ poetry run pytest --vanilla
License - MIT