# Home ### Creo API {% content-ref url="/spaces/xRLDMt2WJeoRsqzYDx8e" %} [Creo API](https://docs.creoii.dev/creo-api/) {% endcontent-ref %} ### Great Big World {% content-ref url="/spaces/WyJFlNYJSlnxo9vwUUgB" %} [Great Big World](https://docs.creoii.dev/great-big-world/) {% endcontent-ref %} ### Modern Lucky Block {% content-ref url="/spaces/CYFEZ36dx9wiqsIYbAJm" %} [Lucky Block](https://docs.creoii.dev/lucky-block/) {% endcontent-ref %} # Overview [Blocks](/great-big-world/blocks/mud) [Items](/great-big-world/items/glass-shards) [Entities](/great-big-world/entities/skeleton) [Biomes](/great-big-world/biomes/forest) [Structures](/great-big-world/structures/swamp-temple) [Progression](/great-big-world/progression/fractured-portals) [Mechanics](/great-big-world/mechanics/item-variants) [Miscellaneous](/great-big-world/miscellaneous/game-rules) # Mud ## Changes Mud now has a slightly browner texture. # List of Blocks The following is a list of all the new blocks added by Great Big World.
Block IdentifierModIcon
copper_pressure_plateCopper Pressure Plates
exposed_copper_pressure_plateCopper Pressure Plates
weathered_copper_pressure_plateCopper Pressure Plates
oxidized_copper_pressure_plateCopper Pressure Plates
waxed_copper_pressure_plateCopper Pressure Plates
waxed_exposed_copper_pressure_plateCopper Pressure Plates
waxed_weathered_copper_pressure_plateCopper Pressure Plates
waxed_oxidized_copper_pressure_plateCopper Pressure Plates
structure_triggerGBW Core
alterworld_portalThe Alterworld
ancient_pedestalThe Alterworld
reinforced_deepslateThe Alterworld
# Lapis Block
Lapis Block has been retextured to look more raw & unpolished. The original texture has been given to [Polished Lapis](/great-big-world/blocks/polished-lapis) blocks. It can be crafted into Stairs, Slabs, & Walls. # Polished Lapis
Polished Lapis is a decorative block. ### Crafting Polished Lapis is crafted from [Lapis Blocks](/great-big-world/blocks/lapis-block). Polished Lapis can be crafted into Stairs, Slabs, & Walls. # Polished Lapis Bricks
Polished Lapis Bricks are a decorative block. ### Crafting Polished Lapis Bricks are crafted from [Polished Lapis](/great-big-world/blocks/polished-lapis) blocks. Polished Lapis Bricks can be crafted into Stairs, Slabs, & Walls. # Cobblestone Bricks
Cobblestone Bricks are a new decorative block crafted from Cobblestone. It can be further crafted into Stairs, Slabs, Walls, a Pillar variant, a Chiseled variant, & Mossy Cobblestone Bricks. Mossy Cobblestone Bricks can be further crafted into Stairs, Slabs, & Walls. ## Generation Cobblestone Bricks naturally generate & make up most of [Swamp Temples](/great-big-world/structures/swamp-temple). ### Crafting ![](/files/7alfVMGt9UUwppucwgo1)
# Brown Mushroom ## Changes Brown Mushrooms emit a light level of zero, from one. # Candle ## Changes Candles emit soul fire particles when placed on blocks in the `soul_fire_base_blocks` block tag. # Piston ## Changes Pistons can be crafted with any item in the `stone_crafting_materials` item tag. # Item Frame Item Frames are now crafted with 4 Sticks, rather than 8. Item Frames can now be dyed by shift-right-clicking with a Dye item, or by crafting them with a Dye item. Items inside of Item Frames can be rotated in reverse by shift-clicking. Item Frames can also be waxed with Honeycomb to prevent rotation.
# Slab Slabs now have 2 placement modes: normal & vertical. Vertical placement mode allows you to place slabs vertically, allowing more building possibilities while not burdening the player with an extra item. To swap between normal & vertical placement modes, right-click while holding a slab in hand. # Glass Glass has been heavily modified to make it easier to work with & more consistent. Stained Glass has been renamed from \[COLOR] Stained Glass to just \[COLOR] Glass. The same goes for Glass Panes. All tools now break Glass quickly. Glass "shatters" into Cracked Glass when broken, which is insta-mineable. When this happens, a single Glass Shard drops. When the Cracked Glass block is broken, 3 Glass Shards drop. Silk Touch tools allow you to pick up the normal Glass or Cracked Glass blocks. 4 Glass Shards can be crafted back into a single Glass block, meaning breaking a Glass block completely allows you to recraft it. {% embed url="" %} # Copper Pressure Plates
Copper Pressure Plates are similar to regular pressure plate blocks, except for that they emit a signal only when stepping \*off\* of them. The oxidization level affects how long the pulse lasts. Copper Pressure Plates can be waxed, but do not change functionality when waxed. ## Crafting Copper Pressure Plates are crafted with 2 Copper Blocks of the same oxidization level, similarly to all other pressure plates.
{% embed url="" %} # Polished Calcite
Polished Calcite is a new white decorative building block made from raw Calcite. It can be crafted into Stairs, Slabs, & Walls. ## Crafting 4 Calcite make 4 Polished Calcite.
# Ice Bricks
Ice Bricks are a new decoration block coming in 3 variants: regular, packed, or blue. Regular Ice Bricks are translucent. All variants are slippery & come in Stairs, Slabs, & Wall forms. ## Natural Generation All 3 variants of Ice Bricks generate as part of [Ice Temples](/great-big-world/structures/ice-temple). ## Crafting
# Snow Bricks
Snow Bricks are a new decorative block crafted from regular Snow blocks. They come in Stairs, Slabs, & Wall forms. ## Natural Generation Snow Bricks generate as part of [Ice Temples](/great-big-world/structures/ice-temple). ## Crafting
# Hibiscus
Hibiscuses are a new flower unique to Jungle biomes. They come in many different colors & are craftable into each respective color's dye item.
## Crafting
# Hollow Logs
Hollow Logs are a natural log block found in most forest biomes. They are rotatable like regular logs. They can be crawled inside of by sprinting into an open end. They can also be climbed up when placed on the Y-axis. ## Crafting Hollow Logs can be crafted into 2 Planks on their respective type. They can be crafted from their respective base Log type.
## Natural Generation Hollow Logs generate naturally as fallen trees in Oak, Birch, Jungle, Spruce, & Mangrove types.
{% embed url="" %} # Cracked Bricks Most Brick type blocks are now able to be cracked, like Cracked Stone Bricks. This can be done via Smelting or by using a Pickaxe. Bricks -> Cracked Bricks Quartz Bricks -> Cracked Quartz Bricks End Stone Bricks -> Cracked End Stone Bricks Tuff Bricks -> Cracked Tuff Bricks Red Nether Bricks -> Cracked Red Nether Bricks Polished Blackstone Bricks -> Cracked Polished Blackstone Bricks Mud Bricks -> Cracked Mud Bricks # Small Plants Most small plant blocks (Flowers, Mushrooms, etc) are now stackable up to 4 like Turtle Eggs & Sea Pickles. The stacking mechanic is exactly the same. ## Natural Generation Stackable plant blocks generate in random numbers, exponentially more likely to generate with fewer of the respective plant.
# Sculk Blocks Sculk blocks, including the Sculk Sensor & Sculk Shrieker are now rotatable blocks. They can also generate this way, making them more of a threat in the Deep Dark.
# Bamboo Bamboo now deals 1 damage (half a heart) to entities in the way when growing up a stage. This is considered a unique damage type, meaning there are custom death messages for dying this way: * \[PLAYER] was skewered to death * \[PLAYER] was skewered by bamboo while trying to escape \[ATTACKER] # Decorated Pots Decorated Pots can be crafted with dyes to color them. They also support trims, though that feature is not accessible in survival yet.
{% embed url="" %} # Engraved Stone Engraved Stone can be Brushed to learn random [knowledge](/great-big-world/mechanics/knowledge). They can be silk touched to collect & retain the color, though the color can be changed by using a Dye item on them.
# Snow Snow is now snowier! Many blocks can be snowlogged & support different heights. Leaves can now be snowy. Snow now generates under leaves, & on all layers of leaves.
# Sawmill
The Sawmill is a crafting utility block that acts as a Stonecutter alternative for wood type blocks. It is crafted with 2 Planks, any 1 Log in the bottom center, & 1 Iron Ingot. Sawmills can craft most basic wood blocks, as well as [Chiseled Wood](/great-big-world/blocks/chiseled-wood) blocks. # Chiseled Wood
Chiseled Logs, Chiseled Wood, Chiseled Planks ## Crafting These blocks are craftable in the Sawmill.
# Cobbled Deepslate Bricks Cobbled Deepslate Bricks are a new decorative block crafted from Cobbled Deepslate. It can be further crafted into Stairs, Slabs, & Walls. ## Crafting
# Miscellaneous Building Blocks ## Mossy Bricks
## Chiseled Purpur
## Polished Blackstone Pillar
## Cut Copper Walls
# Glass Shards
Glass Shards drop from Glass & Cracked Glass. 4 Glass Shards of the same color can be crafted into a single Glass block. {% embed url="" %} # Netherite Upgrade Smithing Template ## Changes Netherite Upgrade Smithing Template is not used in any recipe, nor is it obtainable in Survival from Bastion loot chests. The method of obtaining applying Netherite Ingots is reverted to the original. # Iron Equipment Iron equipment is adjusted slightly: * Base durability is increased to 451 # Copper Equipment Copper equipment is adjadjusted slightly: * Base durability is increased to 221 # Armor Trims Armor Trims are no longer obtained by finding them in Loot Chests. They are no longer an obtainable item. Instead, they are a type of [Knowledge](/great-big-world/mechanics/knowledge) that can be learned from [Engraved Stone](/great-big-world/blocks/engraved-stone) or [Knowledge Books](/great-big-world/mechanics/item-variants). Once learned, an Armor Trim will be permanently unlocked & can be used in [Anvils](/great-big-world/mechanics/anvil-mechanics) to apply to equipment. # Banner Patterns Banner Patterns are now a form of [Knowledge ](/great-big-world/mechanics/knowledge)that can be learned from [Engraved Stone](/great-big-world/blocks/engraved-stone) or [Knowledge Books](/great-big-world/mechanics/item-variants). # Pottery Sherds Pottery Sherds are now a form of [Knowledge ](/great-big-world/mechanics/knowledge)that can be learned from [Engraved Stone](/great-big-world/blocks/engraved-stone) or [Knowledge Books](/great-big-world/mechanics/item-variants). # Knowledge Books Generate in Loot Chests & provide random [Knowledge ](/great-big-world/mechanics/knowledge)when right-clicked. # Enchanted Books Enchanted Books are now colored based on the first enchantment's associated element. Fire -> Red Earth -> Brown Water -> Cyan Ice -> Light Blue Air -> Pink Lightning -> Yellow Light -> White Dark -> Black Void -> Purple Aether -> Orange
# Skeleton Skeletons are adjusted slightly: * Health is reduced to * They can now run out of Arrows # Creeper Creepers can now spawn on Leaves. # Animal AI Animals in packs will now all panic when one is hurt. If the attacker is known, they will run from the attacker, not randomly # Boats Boats no longer physically collide with Lily Pads, though they still break them. This is to make Boats a more viable transportation item in Swamp biomes. # Forest Forest biomes have had a few changes made: * Oak trees are generally slightly taller, always with at least a 2 block height gap underneath their canopy. * All trees generate in a randomized noise-based randomized pattern. This results in actual [clearings ](/great-big-world/miscellaneous/world#clearings)in Forest biomes. * Tall & Short Grass generate much more frequently, giving Forests a much more grown look. Tall Grass generates much more frequently in clearings. # Rivers River biomes have been split into variants to better fit their environments. | | | | | ------------ | - | - | | River | | | | Cold River | | | | Jungle River | | | | Desert River | | | | Swamp River | | | | Frozen River | | |
# Mangrove Swamp Mangrove Trees now generate in a noise pattern with the goal of opening up routes for players to travel via Boat. Mangrove Trees also generate slightly taller roots to free up more room for Boat travel underneath. # Lush Caves Lush Caves no long generate small Dripleaf. Large Dripleaf now generate intelligently to serve as better natural parkour systems. Each clump generates multiple stalks each 1 block taller than the last, attempting to form a natural staircase.
# Taigas
Taigas now have an adjusted water color to match Bedrock Edition # Swamp Temple Generate in Swampy biomes.
# Ice Temple Generate in Icy biomes, excluding Frozen Oceans/Rivers.
# Shacks Generate in Mountain & Cave biomes. # Fractured Portals Fractured Portals generate in temple structures (Desert, Jungle, Swamp, Ice). The frame will contain one special Reinforced Deepslate block that, when brushed, activates the portal. This is a one time activation per-player. The block remembers every player who uses it. Entering the portal breaks it behind you and sends you to the Alterworld dimension in the same area temporarily. You will be given an effect called Planar Fracture that lasts up to a few minutes. When the effect clears, you are sent back to the empty portal in the Overworld. This gives you a few precious minutes to collect materials only obtainable in the Alterworld to bring them back to the Overworld. This feature is primarily for passive players who do not wish to play progressively, yet still want access to things restricted to the Alterworld.
# Ancient Portals Ancient Portals are found in the central portal frame in Ancient Cities. The structure has been modified to always include all 4 pedestals in front of the portal frame. Activating the portal requires lighting the 4 Ancient Pedestal blocks that sit on top of each pedestal structure. Ancient Pedestals require enchanted items with a power level > 10. Once all 4 Ancient Pedestals are lit, the portal will activate and the items deleted. This portal is a permanent portal to the Alterworld, unlike the Fractured Portals found in temples.
{% embed url="" %} # Item Variants Item variants are a new tooltip field used by similar items to group them together & shorten long item names.
## List of Variants | | | | | ----------- | - | - | | baked | | | | black | | | | blue | | | | brown | | | | chipped | | | | chiseled | | | | coarse | | | | cooked | | | | cracked | | | | cut | | | | cyan | | | | damaged | | | | dead | | | | deepslate | | | | dried | | | | enchanted | | | | exposed | | | | flowering | | | | gray | | | | green | | | | large | | | | light\_blue | | | | light\_gray | | | | lime | | | | magenta | | | | medium | | | | mosaic | | | | mossy | | | | ochre | | | | orange | | | | oxidized | | | | pearlescent | | | | pink | | | | polished | | | | purple | | | | raw | | | | red | | | | small | | | | smooth | | | | stripped | | | | verdant | | | | weathered | | | | white | | | | yelloyellow | | | ## Item Variant Definition The JSON definition for variants is the same as tags: ```json { "values": [ "minecraft:dried_kelp", "minecraft:dried_kelp_block" ] } ``` Files are placed in assets/\[namespace]/variants/ If adding a new variant type, the system will expect a translation for that variant: * variant.item.dried When an item is listed inside a variant definition, it's backend translation key will expect a .variant suffix appended to it: * block.minecraft.dried\_kelp\_block -> block.minecraft.dried\_kelp\_block.variant The variant system adds the translated variant key to the item's tooltip, under the name. It is expected that the item's variant translation simply removes the variant's name from it. * Dried Kelp Block -> Kelp Block # Fluidlogging Waterloggable blocks have been expanded to support Lava as well. This can best be seen naturally when Dripstone generates inside of Lava pools. The mechanics for bucketing fluidloggable blocks remain the same, just with the respective fluid. Flammable blocks fluidlogged with Lava will eventually burn. Additional blocks are now waterloggable.
# Tool Usage Most right-click functionality of tool items (Axes, Shovels, & Pickaxes) has been delayed by a very short time. This is to reduce the chance of accidental right-click effects on blocks while limiting the effect on times when players actually mean to do it. This effect only occurs once per right-click, meaning holding the button down will not continuously delay usage. Pickaxes can now be used to [Crack Brick](/great-big-world/blocks/cracked-bricks) type blocks. # Equipment Upgrading Iron Ingot -> upgrades durability Copper Ingot -> upgrades knockback Gold Ingot -> upgrades enchantability Netherite Ingot -> upgrades knockback resistance
# Anvil Mechanics
Anvils are now used for cosmetic upgrades to items. Dyes can be used to change name color. Armor Trims that you have learned show up on the right. If an Armor Trim is selected, the Dye will be used as the color. Vanilla Armor Trim materials are no longer used to color the trims. # Knowledge The goal of the Knowledge System is to consolidate items or other objects together. This applies to cosmetic items such as Armor Trims, Pottery Sherds, & Banner Patterns, but also to Enchantments. The 3 cosmetic types only need to be learned once per-player, & that player will be able to apply them at their respective workstation to their respective blocks/items. For example, if you learn the Dune armor trim, you will be able to apply that to any armor without using the armor trim item. In fact, the Armor Trim, Pottery Sherd, & Banner Pattern items will be made inaccessible to players in survival. Enchantments are a special case.
# Darkness Nighttime darkness is now affected by the moon phase. A dynamic darkness system calculates how much skylight is in the area & further reduces darkness. This makes nighttime during moonless nights & unlit caves extremely dark. # Seasons The season system affects the Alterworld dimension. By default, a Season lasts 86,400 ticks, or 3 real-world days of game time. Wintertime will cause snow instead of rain & freeze water in every affected biome. # Game Rules showCoordinatesOnDeath / show\_death\_coordinates allowDebugHud / allow\_debug\_hud sleepDuringDay / sleep\_during\_day doSeasonCycle / advance\_seasons seasonLength / season\_length # Settings ## Video Settings **Season Transition Quality**: Controls the frequency of season-based block tint updates during season transitions: High (most intensive), Normal, Low, Instant (least intensive) **Dynamic Darkness Quality**: Controls the radius of the area used to calculate dynamic underground darkness: High (most intensive), Normal, Low (least intensive) # World Loading Screen The world loading screen, which typically displays the text "Loading terrain..." is adjusted to display "Entering the \[DIMENSION]", where \[DIMENSION] is the dimension you are currently loading. # World Creation Options
**Start Time** sets the time of day at world start. **Start Season** sets the [season ](/great-big-world/mechanics/seasons)at world start. **Start Weather** sets the weather at world start. **World Size** sets the world size & border. **Bonus House** spawns the classic Bonus House structure at spawn. If Bonus Chest is enabled, it will spawn inside the house.
{% embed url="" %} # Loot Tables Structure Loot tables have been heavily adjusted. | | | | | ------------------- | - | - | | abandoned mineshaft | | | | desert pyramid | | | | jungle temple | | | | ancient city | | | | nether bridge | | | | bastion treasure | | | {% embed url="" %} # World Type Skyblock # World The world is extended by a further 64 blocks underground, & Ancient City generation height is adjusted for this. Oceans are made slightly deeper to account for the world depth extension. Caves at this level are generally slightly larger & more windy. The Overworld is made greener & brighter towards older Minecraft versions. #### Rivers Rivers can now have trees generate alongside them.
#### **Clearings** Clearings generate in most forest biomes. They are characterized by a lack of trees and an increase in grass density.
# Generic Commands /heal /velocity /gameevent # Overview A multi-purpose api for Minecraft mod and datapack development. Creo API addresses three main issues not typically covered by other libraries. * De-centralization of features, resulting in unnecessary similar or duplicated code from different mods. * Tedious aspects of development that take time away from implementing fun, unique features. * Expanding the powerful, yet lacking, worldgen & datapack system. Here is a list of features implemented: * Nearly 50 new Block, Item, Entity Type, Enchantment, & Biome tags * Expanded version of BlockSettings & ItemSettings for easy modification * Utilities to edit vanilla blocks, items, & entity types * Various Feature/Structure Placement, Density Functions, Placers, & Surface Rules to assist in worldgen * [FastNoise](https://github.com/Auburn/FastNoiseLite/blob/master/Java/FastNoiseLite.java) implementation * Entity Attributes such as Gravity, Max Air, etc * POI State & Block Entity Injection * Customizable Block-Entity collision interactions * Customizable Enchantment Targets * Even more small features * And more to come! # Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-api:") } ``` {% endtab %} {% endtabs %} # Block API Extensions giving blocks more functionality. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-block-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-block-api:") } ``` {% endtab %} {% endtabs %} ## CreoBlock {% code title="CreoBlock.java" %} ```java // Called when an entity is looking at the block. void onLookedAt(World world, BlockState state, BlockHitResult hitResult, Entity looker, double squaredDistance); // Called when a block is placed by a structure block, after data structure blocks have been processed. void onPlacedByStructure(ServerWorldAccess world, BlockPos pos, BlockState state, FluidState fluidState, Random random, BlockPos pivot, StructureTemplate structureTemplate, StructurePlacementData placementData, StructureTemplate.StructureBlockInfo structureBlockInfo); // Determines whether CreoBlock#onAdjacentEntityCollision can be called. boolean canEntityCollideAdjacent(Entity entity, BlockState state, BlockPos pos); // Called when an entity is next to a block but not actually colliding with it. void onAdjacentEntityCollision(Entity entity, BlockState state, BlockPos pos); // Called client-side to render a blockstate as an overlay to the block. BlockState getOverlayState(BlockState state, BlockPos pos, Random random); ``` {% endcode %} ## Spreadable # Block Injection API Injection utilities related to blocks. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-block-injection-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-block-injection-api:") } ``` {% endtab %} {% endtabs %} ## Block Entity Type Injection {% code title="BlockEntityTypeInjection.java" %} ```java public static void inject(BlockEntityType blockEntityType, Block block); public static void inject(BlockEntityType blockEntityType, Block... blocks); ``` {% endcode %} The methods above are used to inject a **BlockEntityType** into a block or group of blocks. ## Point of Interest Type Injection {% code title="PointOfInterestTypeInjection.java" %} ```java public static void inject(RegistryKey poi, BlockState state); public static void inject(RegistryKey poi, Block block); public static void inject(RegistryKey poi, BlockState... states); public static void inject(RegistryKey poi, Block... blocks); ``` {% endcode %} The methods above are used to inject a **PointOfInterestType** into a block, blockstate, or group of either. Injecting into a block will inject the PointOfInterestType into all of its blockstates. ## Block State Property Injection {% code title="BlockStatePropertyInjection.java" %} ```java public static > void inject(Property property, Block block); public static > void inject(Property property, Block... blocks); public static > void inject(Property property, @Nullable T defaultValue, Block block); public static > void inject(Property property, @Nullable T defaultValue, Block... blocks); ``` {% endcode %} The methods above are used to inject BlockState Properties into a block, optionally with a defaultValue. # Content Modification API Utilities to modify vanilla content such as blocks, items, and entities. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-content-modification-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { maven("https://repo1.maven.org/maven2") } dependencies { modImplementation("dev.creoii.creoapi:creo-content-modification-api:") } ``` {% endtab %} {% endtabs %} ## Block Modification {% code title="BlockModification.INSTANCE" %} ```java // Set a new hardness value for the block. void setHardness(Block block, float hardness); // Set a new hardness value for the BlockState. void setHardness(BlockState state, float hardness); // Set a new resistance value for the block. void setResistance(Block block, float resistance); // Set both the hardness and resistance for the block. void setStrength(Block block, float hardness, float resistance); // Set both the hardness and resistance for the block. void setStrength(Block block, float strength); // Set a new SoundGroup for the block. void setSoundGroup(Block block, BlockSoundGroup soundGroup); // Set a new slipperiness value for the block. void setSlipperiness(Block block, float slipperiness); // Set a new luminance value for the block. void setLuminance(Block block, int luminance); // Set a new resistance value for the BlockState. void setLuminance(BlockState state, int luminance); // Set a new MapColor for the block. void setMapColor(Block block, MapColor mapColor); // Set a new MapColor for the BlockState. void setMapColor(BlockState state, MapColor mapColor); // Get the MapColor of the block. MapColor getMapColor(Block block); // Get the MapColor of the BlockState. MapColor getMapColor(BlockState state); // Set a new velocity multiplier value for the block. void setVelocityMultiplier(Block block, float velocityMultiplier); // Set a new jump velocity multiplier value for the block. void setJumpVelocityMultiplier(Block block, float jumpVelocityMultiplier); // Set whether the block has dynamic bounds. void setDynamicBounds(); // Set whether the block ticks randomly. void setRandomTicks(Block block, boolean randomTicks); // Set whether a tool is required to mine the block. void setToolRequired(Block block, boolean toolRequired); // Set whether a tool is required to mine the blockstate. void setToolRequired(BlockState state, boolean toolRequired); // Set the loot table identifier of the block. void setLootTableId(Block block, Identifier lootTableId); // Set whether the block is opaque. void setOpaque(Block block, boolean opaque); // Set whether the blockstate is opaque. void setOpaque(BlockState state, boolean opaque); // Set whether the block can be lit on fire by lava. void setBurnable(Block block, boolean burnable); // Set whether the BlockState can be lit on fire by lava. void setBurnable(BlockState state, boolean burnable); // Set a new PistonBehavior for the block. void setPistonBehavior(Block block, PistonBehavior pistonBehavior); // Set a new PistonBehavior for the BlockState. void setPistonBehavior(BlockState state, PistonBehavior pistonBehavior); // Set a new Instrument for the block. void setInstrument(Block block, Instrument instrument); // Set a new Instrument for the blockstate. void setInstrument(BlockState state, Instrument instrument); // Set whether the block has block break particles. void setBlockBreakParticles(Block block, boolean blockBreakParticles); // Set whether the blockstate has block break particles. void setBlockBreakParticles(BlockState state, boolean blockBreakParticles); // Set whether the block is replaceable. void setReplaceable(Block block, boolean replaceable); // Set whether the blockstate is replaceable. void setReplaceable(BlockState state, boolean replaceable); ``` {% endcode %} ## Item Modification {% code title="ItemModification.INSTANCE" %} ```java // Set the rarity of the item. void setRarity(Item item, Rarity rarity); // Get the rarity of the item. Rarity getRarity(Item item); // Set the max count of the item. void setMaxCount(Item item, int maxCount); // Set the max damage of the item. void setMaxDamage(Item item, int maxDamage); // Set whether the item is fireproof. void setFireproof(Item item, boolean fireproof); // Set the recipe remainder of the item. void setRecipeRemainder(Item item, Item recipeRemainder); // Set the food component of the item. void setFoodComponent(Item item, FoodComponent foodComponent); ``` {% endcode %} ## Entity Type Modification {% code title="EntityTypeModification.INSTANCE" %} ```java // Set the entity type's spawn group. void setSpawnGroup(EntityType entityType, SpawnGroup spawnGroup); // Set the entity type's primary spawn egg color. void setPrimarySpawnEggColor(EntityType entityType, int color); // Get the entity type's primary spawn egg color. int getPrimarySpawnEggColor(EntityType entityType); // Set the entity type's secondary spawn egg color. void setSecondarySpawnEggColor(EntityType entityType, int color); // Get the entity type's secondary spawn egg color. int getSecondarySpawnEggColor(EntityType entityType); // Set whether the entity type is summonable. void setSummonable(EntityType entityType, boolean summonable); // Set whether the entity type is immune to fire damage. void setFireImmune(EntityType entityType, boolean fireImmune); // Set whether the entity type can spawn far from the player. void setSpawnableFarFromPlayer(EntityType entityType, boolean spawnableFarFromPlayer); // Set the entity type's loot table identifier. void setLootTableId(EntityType entityType, Identifier lootTableId); // Set the entity type's dimensions. void setDimensions(EntityType entityType, EntityDimensions dimensions); ``` {% endcode %} ## Enchantment Modification {% code title="EnchantmentModification.INSTANCE" %} ```java // Set the enchantment rarity of the enchantment. void setRarity(Enchantment enchantment, Enchantment.Rarity rarity); // Set the acceptable items of the enchantment. void setAcceptableItems(Enchantment enchantment, Predicate acceptableItemPredicate); // Set the minimum level of the enchantment. void setMinLevel(Enchantment enchantment, int minLevel); // Set the maxiumum level of the enchantment. void setMaxLevel(Enchantment enchantment, int maxLevel); ``` {% endcode %} ## Status Effect Modification {% code title="StatusEffectModification.INSTANCE" %} ```java // Set the status effect's category. void setCategory(StatusEffect statusEffect, StatusEffectCategory category); // Set the status effect's color. void setColor(StatusEffect statusEffect, int color); ``` {% endcode %} # Convention Tags Many new tags bringing easy functionality to blocks, items, entity types, biomes, and more. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-convention-tags:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-convention-tags:") } ``` {% endtab %} {% endtabs %} ## Block Tags **ravager\_breakable:** Blocks that can be broken by a Ravager.\ **beacon\_beam\_ignores:** Blocks that are ignored by a Beacon's beam.\ **signal\_fire\_base\_blocks:** Blocks that cause Campfires to emit signal fire smoke when placed underneath.\ **keeps\_coral\_alive:** Blocks that keep Coral blocks alive when touching.\ **keeps\_farmland\_moist:** Blocks that keep Farmland moist when touching.\ **anvil\_softeners:** Blocks that won't damage Anvils when landed upon.\ **cocoa\_beans\_plantable\_on:** Blocks that Cocoa Beans can be placed and grown on.\ **cactus\_plantable\_on:** Blocks that Cacti can be placed and grown on.\ **nether\_wart\_plantable\_on:** Blocks that Nether Wart can be placed and grown on.\ **conduit\_frame\_base\_blocks:** Blocks which activate Conduits when placed correctly.\ **can\_drip\_through:** Blocks that Dripstone can drip through.\ **eaten\_by\_sheep:** Blocks that are eaten by Sheep, like Short Grass.\ **projectiles\_ignore:** Blocks which projectiles will ignore collision with.\ **invalid\_for\_shulker\_teleport:** Blocks that Shulkers cannot teleport to.\ **shears\_very\_efficient:** Blocks which are mined very quickly by Shears.\ **shears\_less\_efficient:** Blocks which are mined quickly by Shears.\ **weather\_render\_ignores:** Blocks which will not stop weather rendering below them. ## Item Tags **unframeable:** Items which cannot be placed in an Item Frame.\ **tripwire\_ignores:** Items which do not activate Tripwires when on the ground.\ **hopper\_ignores:** Items which cannot be moved by Hoppers.\ **dolphin\_ignores:** Items which cannot be played with by Dolphins.\ **fox\_ignores:** Items which cannot be picked up by Foxes.\ **duplicates\_allays:** Items which duplicate Allays.\ **disables\_shields:** Items which disable Shields on critical hits.\ **enchanting\_fuel:** Items which can be used to fuel enchanting.\ **brewing\_fuel:** Items which can be used to fuel brewing.\ **repairs\_iron\_golems:** Items which repair damaged Iron Golems.\ **respawn\_anchor\_charges:** Items which can be used to charge a Respawn Anchor.\ **fuels\_furnace\_minecarts:** Items which can be used to fuel a Furnace Minecart.\ **blocks\_enderman\_stare:** Items that do not anger Endermen when stared at and worn.\ **repairs\_leather:** Items which can be used to repair leather equipment.\ **repairs\_wood:** Items which can be used to repair wooden equipment.\ **repairs\_chainmail:** Items which can be used to repair chainmail equipment.\ **repairs\_stone:** Items which can be used to repair stone equipment.\ **repairs\_iron:** Items which can be used to repair iron equipment.\ **repairs\_gold:** Items which can be used to repair gold equipment.\ **repairs\_diamond:** Items which can be used to repair diamond equipment.\ **repairs\_netherite:** Items which can be used to repair netherite equipment.\ **repairs\_turtle:** Items which can be used to repair Turtle Helmets. ## Entity Type Tags **zoglin\_ignores:** Entities that are ignored by Zoglins.\ **avoids\_traps:** Entities that do not activate traps such as Pressure Plates.\ **projectiles\_ignore:** Entities which projectiles ignore collision with.\ **collidable:** Entities which can be stood on like Boats & Shulkers.\ **warden\_ignores:** Entities which are ignored by the Warden.\ **scares\_creepers:** Entities which Creepers run away from.\ **tripwire\_ignores:** Entities which do not activate Tripwires.\ **fishing\_rod\_cannot\_hook:** Entities which cannot be hooked by a Fishing Rod. ## Enchantment Tags **Note:** To check whether a Tag contains an Enchantment, see the following example: ```java world.getRegistryManager().getRegistryManager().get(RegistryKeys.ENCHANTMENT).getEntry(Enchantments.UNBREAKING).isIn(CreoEnchantmentTags.TREASURE); ``` The above example will return **true** if the Unbreaking enchantment is listed in the **'treasure'** enchantment tag. *** **cursed:** Enchantments that are considered Curses.\ **treasure:** Enchantments that are considered Treasures.\ **not\_offered\_by\_librarians:** Enchantments that will not be offered by Librarian Villagers.\ **not\_randomly\_selectable:** Enchantments that will not be picked during random selection for Enchanted Books.\ **grindstone\_ignores:** Enchantments that cannot be removed by Grindstones. ## Status Effect Tags **Note:** To check whether a Tag contains an Status Effect, see the following example: ```java world.getRegistryManager().get(RegistryKeys.STATUS_EFFECT).getEntry(StatusEffects.SLOWNESS).isIn(CreoStatusEffectTags.MILK_DOES_NOT_CURE); ``` The above example will return **true** if the Slowness status effect is listed in the **'milk\_does\_not\_cure'** status effect tag. *** **milk\_does\_not\_cure:** Status Effects which cannot be cured by Milk. # Entity Attributes Many new entity attributes for more control over entities. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-entity-attributes:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-entity-attributes:") } ``` {% endtab %} {% endtabs %} ## Gravity ## Swim Speed ## Climbing Speed ## Sneaking Speed ## Jump Strength ## Max Air ## Block Break Cooldown ## Block Place Cooldown # Entity-Block Collision API Modify collision interactions between entities and blocks. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-entity-block-collision-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-entity-block-collision-api:") } ``` {% endtab %} {% endtabs %} ## Entity-Block Collision # Events Event callbacks to hook into vanilla code. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-events:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-events:") } ``` {% endtab %} {% endtabs %} ## Block Events **BlockEvents.PLACE:** Fired when a block is placed.\ **BlockEvents.BREAK:** Fired when a block is broken.\ **BlockEvents.CHANGE:** Fired when a block changes at a position. **CropEvents.GROW:** Fired when a crop grows naturally or when bone-mealed. ## Entity Events **AnimalEntityEvents.PRE\_BREED:** Fired when two Animals breed, before the baby is born.\ **AnimalEntityEvents.POST\_BREED:** Fired when two Animals breed, after the baby is born.\ **AnimalEntityEvents.EAT:** Fired when an animal is fed food.\ **AnimalEntityEvents.GROW\_UP:** Fired when a baby animal grows up.\ **AnimalEntityEvents.LOVE:** Fired when two animals have entered 'love' mode to begin breeding. **EntityEvents.SPAWN:** Fired when an Entity spawns in the world.\ **EntityEvents.WITHIN\_STRUCTURE:** Fired when an Entity is within a structure.\ **EntityEvents.DATA\_TRACK:** Fired when an Entity's tracked data is set. (Removed in 0.4.0)\ **EntityEvents.WRITE\_NBT:** Fired when an Entity's NBT is written. (Removed in 0.4.0)\ **EntityEvents.STRUCK\_BY\_LIGHTNING:** Fired when an entity is struck by a lightning bolt.\ **EntityEvents.CHANGE\_DIMENSION:** Fired when an entity moves to another dimension. This is not called for players. **LivingEntityEvents.DROP\_LOOT:** Fired when a living entity drops loot on death.\ **LivingEntityEvents.EQUIP\_STACK:** Fired when a living entity equips an equipment item.\ **LivingEntityEvents.EAT\_FOOD:** Fired when a living entity eats food. **MobEntityEvents.INITIALIZE:** Fired when a mob is initialized into the world.\ **MobEntityEvents.INIT\_GOALS:** Fired when a mob has its goalSelector and targetSelector initialized. **PlayerEntityEvents.LEVEL\_UP:** Fired when a player levels up.\ **PlayerEntityEvents.RESPAWN:** Fired when a player respawns. **ProjectileEntityEvents.FIRE:** Fired when a projectile is fired.\ **ProjectileEntityEvents.IMPACT:** Fired when a projectile impacts something. ## Item Events **ItemEvents.CRAFT:** Fired when an item is crafted.\ **ItemEvents.ENCHANT:** Fired when an item is enchanted.\ **ItemEvents.PICK\_UP:** Fires when an item is picked up by a player or mob. ## World Events **WorldEvents.EXPLODE:** Fired when an explosion occurs in the world. ## Misc Events **FishingEvents.CAST:** Fired when a Fishing Rod is cast.\ **FishingEvents.REEL\_IN:** Fired when a Fishing Rod has its Fishing Bobber reeled in. **SleepEvents.EXPLODE:** Fired when a Bed explodes.\ **SleepEvents.SLEEP:** Fired when an entity attempts to sleep in a Bed.\ **SleepEvents.WAKE\_UP:** Fired when an entity wakes up from a Bed. **LanguageEvents.LOAD\_TRANSLATION:** Fired when each translation key for a locale is translated and stored. **RecipeEvents.RECIPE\_LOAD:** Fired when a recipe is deserialized, before being loaded into the game. # Food Component API Extensions to the vanilla food component system. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-food-component-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-food-component-api:") } ``` {% endtab %} {% endtabs %} ## CreoFoodComponent An extension of **FoodComponent** that provides even more customizability for food. ```java // How fast it takes to eat the food item. private final int eatSpeed; // Provides a durability bar which decreases each time you eat the food item. private final int eatDurability; // Whether the food item can be eaten while sprinting. private final boolean sprintEdible; // Whether the food heals health or hunger. private final boolean healsHealth; ``` # Item API Extensions giving items more functionality. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-item-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-item-api:") } ``` {% endtab %} {% endtabs %} ## CreoItemSettings An extension of **FabricItemSettings** that provides even more customizability for items. ```java // Delay once the item is dropped until it can be picked up again. private int pickupDelay; // How long it takes for the item to despawn. private int despawnTime; // Whether the item floats or sinks in fluids. private boolean buoyant; // The amount of downwards gravity applied to the item when dropped. private double gravity; // How fast a Hopper transfers the item to another Hopper or container. private int hopperTransferRate; // How fast the item rotates when on the ground. private float rotationModifier; // Makes the item picked up by right-clicking instead of collision. private boolean clickPickup; // What fuel items are required to smelt this item, if smeltable. private RegistryEntryList requiredFuels; ``` ## CreoItem {% code title="CreoItem.java" %} ```java // Determines whether CreoBlock#onAttackThroughBlock can be called. boolean canAttackThroughBlock(ServerPlayerEntity player, ItemStack stack, Entity target); // Called when the item attacks an entity through a block. void onAttackThroughBlock(ServerPlayerEntity player, ItemStack stack, Entity target); ``` {% endcode %} # Mod Compatibility API Utilities to improve compatibility between mods. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-mod-compatibility-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-mod-compatibility-api:") } ``` {% endtab %} {% endtabs %} ## Mod Storage # Registry API Utilities which help registration needs. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-registry-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-registry-api:") } ``` {% endtab %} {% endtabs %} ## Pre-Init Mod Initializer ## Registry Events # Shader Interaction API Interaction with vanilla shaders. ## Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-shader-interaction-api:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-shader-interaction-api:") } ``` {% endtab %} {% endtabs %} ## Shader Interactions ```java // Get the Identifier of the current post processor. public static Identifier getCurrentPostProcessor(); // Set the current post processor. public static void setCurrentPostProcessor(Identifier id); // Clear all post processors from the screen. public static void clearPostProcessors(); ``` This API also includes **Shaders.java** which stores **Identifier** references to all built-in post-processors provided by the vanilla game. # Worldgen Features, surface rules, density functions, noise, and more to improve worldgen capabilities. Setup {% tabs %} {% tab title="Gradle" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation 'dev.creoii.creoapi:creo-worldgen:' } ``` {% endtab %} {% tab title="Kotlin" %} ```gradle repositories { mavenCentral() } dependencies { modImplementation("dev.creoii.creoapi:creo-worldgen:") } ``` {% endtab %} {% endtabs %} ## FastNoise Implementation ## Density Function Types ### FastNoise ## Features ### Composite
Generates any number of features in the same spot. There are three types of composite feature placement, defined under the **'type'** field. * **free** places every feature in the list and returns true no matter what. * **soft** returns true if at least one feature places. * **hard** returns false if at least one feature fails. #### Example ```json { "type": "creo:composite", "config": { "type": "free", "features": [ { "feature": "minecraft:spruce", "placement": [] }, { "feature": "minecraft:patch_berry_bush", "placement": [] } ] } } ``` This example will generate a spruce tree with a patch of berry bushes at the same position. ### Coral Claw
Generates a Coral claw shape. {% code fullWidth="false" %} ```json { "type": "creo:coral_claw", "config": { "to_place": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:stone" } } } } ``` {% endcode %} This example will generate a Coral Claw made completely of Stone. ### Coral Mushroom
Generates a Coral mushroom shape. ```json { "type": "creo:coral_mushroom", "config": { "to_place": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:stone" } } } } ``` This example will generate a Coral Mushroom made completely of Stone. ### Coral Tree
The Coral Tree feature generates a Coral tree shape at the position. ```json { "type": "creo:coral_tree", "config": { "to_place": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:stone" } } } } ``` This example will generate a Coral Tree made completely of Stone. ### Crater Generates a crater shape. ### Pool
Generates a noise-based pool which is raised vertically. There are a number of parameters for this feature type: * **'y\_offset'** specifies an offset to the pool's y-level. * **'rim\_size'** specifies how thick the rim of the pool is. * **'rim\_state'** specifies which block to use for the rim. * **'inner\_state'** specified which block to use inside the pool. * **'height'** specifies how tall the pool is. * **'start\_radius'** specifies how wide the radius at the start of placement. * **'inner\_depth'** specifies how deep the inside of the pool is and raises the floor accordingly. * **'replaceable'** specifies which blocks can be replaced by the pool. * **'solid\_rim'**, if true, fills in any gaps in the rim. ```json { "type": "creo:pool", "config": { "y_offset": -1, "rim_size": { "type": "minecraft:uniform", "value": { "min_inclusive": 0, "max_inclusive": 2 } }, "rim_state": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:calcite" } }, "inner_state": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:water", "Properties": { "level": "0" } } }, "height": { "type": "minecraft:uniform", "value": { "min_inclusive": 2, "max_inclusive": 4 } }, "start_radius": { "type": "minecraft:uniform", "value": { "min_inclusive": 1, "max_inclusive": 2 } }, "inner_depth": { "type": "minecraft:uniform", "value": { "min_inclusive": 2, "max_inclusive": 4 } }, "replaceable": "#minecraft:base_stone_overworld", "solid_rim": true } } ``` This example generates a Pool made of Calcite and filled with Water. It's start radius is either 1 or 2 and it rises between 2 and 4 blocks upwards. ### Spike Generates a large Dripstone spike shape. ### Pillar Generates a Basalt pillar shape. ### Rock Generates a rock shape. ### Blob Spread Generates a Glowstone blob shape. ### Fancy Spike Generates an Ice Spike shape. ### Structure Generates a structure nbt file. ### Giant Log
Generates a giant log. ## Material Conditions ### Density Function ### Exposed ### FastNoise ### Steep ## Placement Modifier Types ### All Of A conditional placement modifier that takes a list of placement modifiers as input and returns true if all of those placement modifiers pass. ### Any Of A conditional placement modifier that takes a list of placement modifiers as input and returns true if at least one of those placement modifiers passes. ### Density Function A conditional placement modifier which returns true if the specified density function value at the block position is within the specified range. ### Distance From Zero A conditional placement modifier which returns true if the block position is further from (0,0,0) than the specified distance. ### FastNoise A conditional placement modifier which returns true if the specified FastNoise value at the block position is within the specified range. ### Height Filter A conditional placement modifier that returns true if the height of the specified heightmap is between the two specified heigh providers. ### Near Structure A conditional placement modifier which returns true if the block position is within range of the specified structure. **Warning:** This placement modifier is expensive and will easily cause lag. ### Noise A conditional placement modifier which returns true if the specified noise value at the block position is within the specified range. ### Not A placement modifier which inverts the result of the input placement modifier. ### Offset A positional placement modifier which offsets the block position by a specified amount. ### Random A conditional placement modifier which returns true or false at random. ### Sky Visible A conditional placement modifier which returns true if the sky is visible at the block position. ### Steep A conditional placement modifier which returns true if the steepness value at the block position is within the specified range. ### Within Structure A conditional placement modifier which returns true if the block position is within the specified structure. **Warning:** This placement modifier is expensive and will easily cause lag. ## Structure Placement Types ### Density Function ### Distance From Pos ### FastNoise ### Fixed A structure placement type that takes a list of block positions and attempts to generate the structure at each one. ### Noise ## Structure Processor Types ### FastNoise ### Noise
```json { "processor_type": "creo:noise", "noise": "minecraft:gravel", "min_threshold": 0.1, "max_threshold": 2 } ``` # Overview The Modern Lucky Block mod provides the ability to create Lucky Block addons using only Datapacks for Minecraft 1.20.6+. #### Disclaimer: This wiki is subject to major changes, as the mod is still in Beta and is still figuring out its structure. ### Why? The original Lucky Block mod has not been updated in a year, and is only available for Minecraft 1.20.2 and below. Furthermore, it does not take advantage of the modern tools that Minecraft provides, namely the Datapack system. The original Lucky Block mod can be found at: {% embed url="" %} Download {% endembed %} {% embed url="" %} Source {% endembed %} {% embed url="" %} Wiki {% endembed %} # Installing Addons A Modern Lucky Block addon is a combination of both a resourcepack and a datapack, including both an **assets/** folder and **data/** folder. To install a Lucky Block addon, first download it from either CurseForge or Modrinth (recommended). The download should provide a zip file. Open it and ensure that you see something like the following:

Example Lucky Block addon file structure

When you have confirmed this, move the entire zip file to your Minecraft run directory (typically **AppData/Roaming/.minecraft/**). {% hint style="info" %} On Windows, press Win+R and enter "appdata" to get to this location. {% endhint %} In the .minecraft folder, create a new folder called **addons** if it does not already exist. Place the zip file into the addons folder to load it in game. You're all set! Have fun playing with the Modern Lucky Block mod :) # Creating Addons To create a Lucky Block Addon, you must first create a new folder. Copy the following folder structure:

Example Addon Folder Structure

The **lucky\_block.json** file in the root of your datapack (in the namespace directory) defines the actual addon. The "**outcome**" folder defines various drops (see [Outcomes](/lucky-block/outcomes/outcomes)). Everything else is either vanilla assets or data. A Lucky Block Addon can then be put inside of the "**addons"** folder in your game's run directory (typically **.minecraft**) to load it in game. ### Example To see an example Datapack Lucky Block Addon, see the following: {% embed url="" %} Example Lucky Block Datapack Addon {% endembed %} {% code title="lucky\_block.json" %} ```json { "id": "lucky:lucky_block", // required "activations": [ // optional "break_creative", "break_survival", "right_click", "power" ], "settings": { // optional "hardness": 0.2, "resistance": 20.0, "rarity": "rare" }, "item_luck": { // optional "minecraft:diamond": 12, "minecraft:diamond_block": 100, "minecraft:emerald": 8, "minecraft:emerald_block": 80, "minecraft:gold_ingot": 6, "minecraft:gold_block": 60, "minecraft:iron_ingot": 3, "minecraft:iron_block": 30, "minecraft:golden_carrot": 30, "minecraft:golden_apple": 40, "minecraft:enchanted_golden_apple": 100, "minecraft:nether_star": 100, "minecraft:rotten_flesh": -5, "minecraft:spider_eye": -10, "minecraft:fermented_spider_eye": -20, "minecraft:poisonous_potato": -10, "minecraft:pufferfish": -20 }, "debug": true // optional } ``` {% endcode %} ### Id ```json "id": "lucky:lucky_block" ``` The only required field is the "**id**" field. This defines the id of your lucky block addon, block, and item. ### Activations Activations determine how a Lucky Block is "opened" or "activated". This field is optional, and defaults to **\["break\_survival", "power"]**. * **break\_survival**: lucky block activates when broken in survival * **break\_creative**: lucky block activates when broken in creative * **power**: lucky block activates when powered by Redstone * **right\_click**: lucky block activates when right-clicked ### Settings ```json "settings": { "hardness": 0.2, "resistance": 20.0, "rarity": "rare" } ``` An optional field which defines block & item settings. ```json "hardness": 0.2 ``` Defines the block hardness. See below for more information. {% embed url="" %} Block Hardness {% endembed %} ```json "resistance": 0.2 ``` Defines the block blast resistance. See below for more information. {% embed url="" %} Block Blast Resistance {% endembed %} ```json "rarity": "rare" ``` Defines the item rarity. See below for more information. {% embed url="" %} Item Rarity {% endembed %} ### Item Luck ```json "item_luck": { "minecraft:diamond": 12, "minecraft:diamond_block": 100, "minecraft:emerald": 8, "minecraft:emerald_block": 80, "minecraft:gold_ingot": 6, "minecraft:gold_block": 60, "minecraft:iron_ingot": 3, "minecraft:iron_block": 30, "minecraft:golden_carrot": 30, "minecraft:golden_apple": 40, "minecraft:enchanted_golden_apple": 100, "minecraft:nether_star": 100, "minecraft:rotten_flesh": -5, "minecraft:spider_eye": -10, "minecraft:fermented_spider_eye": -20, "minecraft:poisonous_potato": -10, "minecraft:pufferfish": -20 } ``` An optional field which defines values for luck crafting. Maps item ids to an integer value between -100 and 100. ### Debug Defaults to false, this field should be used when testing Lucky Blocks. When true, it will print messages in the console: * Outcome Id when activating a block * Outcome Ids when loading outcomes on world load * Lucky Block Ids during initial game load # Upcoming Features ## Functions Used to modify outcome objects, such as BlockStates, Entities, ItemStacks, etc. This is intended mostly as an alternative to the component system for Entities & Blocks. | Id | Default Target | Parameters | Use Case | | ------------------------- | -------------------------- | ---------------------------------- | -------------------------------------------------------------------------------------- | | set\_age | ageable entities | age | set age of animal | | set\_count | all | count | set count of anything | | distribute\_count | all | functions, total\_count | uses the count from all functions to determine a proportional amount to the total | | group | all | functions | run multiple functions once | | loop | all | function | run the function over time at an interval; for example: once every 1s | | random\_count | all | function, count | run the function multiple times | | random\_split | all | valid\_function, invalid\_function | runs a function for all valid targets and a different function for all invalid targets | | set\_pos | all | pos | set position of anything | | set\_color | colorables | color | dye sheep, shulkers, items, blocks, etc | | set\_charged | creepers | charged | make creepers charged | | set\_direction | directionals | direction | set direction of blocks, entities, or structures | | set\_velocity | entities, particles | velocity | set velocity of entity | | add\_passenger | entities | passenger | add a passenger to entity | | set\_nbt | entities/block entities | nbt | only because nbt still exists, please please remove it mojang | | set\_goat\_horns | goats | horns | set goat horns on goat | | set\_components | items | components | item modifications | | set\_name | items/entities | name | set name of item or entity | | add\_enchantments | items | enchantments | set enchantments of item | | add\_status\_effects | living entities | status\_effects | add status effect to entity | | set\_equipment | living entities | slot->item | set mob equipment | | set\_attribute\_modifiers | living entities/items | attribute->value | set max health, armor, etc of the spawned mob or of the itemstack | | set\_level | enchantments | level | set level of enchantment | | set\_target | mobs | target | angering & setting target of mobs | | set\_owner | pets | owner | taming pets, ender pearls | | set\_sitting | pets | sitting | make pets sit | | set\_rotation | rotationals | rotation | setting initial mob rotation | | set\_sheared | sheep | sheared | make sheep sheared | | set\_variant | variant entities | variant | frog variants, fox variants, tropical fish, axolotls, etc | | set\_size | slimes, salmon, pufferfish | size | sets the size of the entity | | set\_saddle | rideables | saddle | adds a saddle to the entity so they can be ridden | | set\_villager\_data | villagers | profession, rank, trades | sets villager data | | set\_baby | animals | baby | makes the animal a baby | | set\_item | item frames, foxes | stack | sets the entity's single held item when not using equipment slots | | initialize\_mobs | mobs | data | default mob spawning mechanics: skeleton bows, horse stats, etc | ## Boolean Providers Return a boolean value, usable in any codec-based object. | Id | Parameters | Description | | ------ | ---------- | --------------------- | | simple | value | returns a boolean | | random | N/A | returns true or false | ## Color Providers Return a color value, usable in any codec-based object. | Id | Parameters | Description | | ------ | ---------- | ---------------------- | | simple | color | returns a color | | random | colors | returns a random color | ## Entity Providers Return an Entity value, usable in any codec-based object. | Id | Parameters | Description | | ----------------- | ---------- | --------------------------------------------------- | | random\_in\_shape | shape | returns a random player in the shape | | target | provider | returns the current target entity of the provided | | attacker | provider | returns the current attacker entity of the provided | | owner | provider | returns the owner entity of the provided | | random\_passenger | provider | returns a random passenger entity of the provided | ## Stack Providers Return an ItemStack value, usable in any codec-based object. | Id | Parameters | Description | | ------ | ----------------- | ------------------------------------------------- | | simple | stack, components | returns an itemstack | | random | stacks | returns a random itemstack from the provided list | ## Text Providers Return a text value, usable in any codec-based object. | Id | Parameters | Description | | -------- | ---------- | --------------------------------------- | | simple | text | returns a basic text | | random | texts | returns a random text | | compound | texts | returns a combination of multiple texts | ## Vec Providers Return a Vec3d value, usable in any codec-based object. | | | Description | | -------------------- | -------------- | --------------------------------------------------- | | constant | vec | returns a vector | | random | vecs | returns a random vector | | random\_in\_shape | shape | returns a random vector within the shape | | clamp\_to\_heightmap | vec, heightmap | clamps the vector to the heightmap | | random\_velocity | power, pitch | returns a velocity vector, based on power and pitch | # Outcomes Outcomes are what occur when you break a Lucky Block. To define outcomes, place **.json** files in the "**outcome/"** directory of your datapack. Below is a simple definition for an empty outcome. Nice. {% code title="boring\_outcome.json" %} ```json { "type": "lucky:none" } ``` {% endcode %} All outcomes can also define three additional fields: **luck**, **chance**, and **delay**. {% code title="slightly\_more\_interesting\_outcome.json" %} ```json { "type": "lucky:none", "luck": 2, "chance": 10, "delay": 20 } ``` {% endcode %} ### Luck ```json "luck": 2 ``` Luck determines how the luck component of your Luck Block chooses an outcome. Higher outcome luck values correspond with higher luck component values. Lower outcome luck values correspond with lower luck component values. The outcome luck field can range from -2 to 2. The luck component value ranges from -100 to 100. ### Chance ```json "chance": 10 ``` Chance determines how often the outcome will be picked, regardless of luck. The above example results in the outcome being 10x as likely. If the chance value was **0.1**, then the outcome will be 10x less likely. ### Delay ```json "delay": 20 ``` Delay determines how long after the block is broken the outcome takes effect. The above example results in the outcome executing 20 ticks, or 1 second, after the block is broken. ### Pos ```json "pos": [0, 0, 0] ``` Pos determines where in the world the outcome is executed. This field is available for most outcomes. The following outcomes **do not** support "pos": * lucky:group * lucky:message * lucky:none * lucky:random This field also accepts a Vec Provider as an input. ### Reinit ```json "reinit": true ``` Reinit resets part of the outcome. | Outcome | Reinit Effect | | -------- | ------------------------------------------------- | | Entity | Resets entity position if spawning >1 entities | | Item | Resets item position if spawning >1 items | | Particle | Resets particle position if spawning >1 particles | # Advancement Outcome The advancement outcome grants an advancement to the opening player. ```json { "type": "lucky:advancement", "advancement": "adventure/hero_of_the_village" } ``` This simple outcome will grant the Hero of the Village advancement to the opening player. # Block Outcome The block outcome places a block/blocks in the world. ```json { "type": "lucky:block", "state_provider": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:beacon" } } } ``` This simple outcome will place a Beacon in the world. ```json { "type": "lucky:block", "state_provider": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:stone" } }, "shape": { "type": "lucky:cube", "size": [3, 3, 3] } } ``` This outcome will place Stone blocks in the shape of a 3x3x3 cube. ```json { "type": "lucky:block", "state_provider": { "type": "minecraft:simple_state_provider", "state": { "Name": "minecraft:chest" } }, "block_entity": { "id": "minecraft:chest", "LootTable": "minecraft:chests/bastion_treasure" } } ``` This outcome will place a Chest filled with the **minecraft:chests/bastion\_treasure** loot table. # Command Outcome The command outcome executes a command string in the world. ```json { "type": "lucky:command", "command": "/difficulty hard" } ``` This outcome changes the difficulty to hard. **Note: While the command outcome can be used to replicate many other outcomes, it is typically ideal to use the other outcomes over the command outcome. Reserve the use of this only for necessary situations. See below for a list of reasons to use it:** * Modifying game rules * Changing the difficulty * Executing .mcfunction files # Difficulty Outcome The difficulty outcome changes the world difficulty. ```json { "type": "lucky:difficulty", "difficulty": "hard" } ``` This simple outcome changes the game difficulty to hard. # Effect Outcome The effect outcome applies Status Effects to mobs. See for information about Status Effects. ```json { "type": "lucky:effect", "status_effect": { "id": "minecraft:slowness", "amplifier": 4, "duration": 600 } } ``` This outcome applies Slowness III to the breaking player for 600 ticks, or 30 seconds. ```json { "type": "lucky:effect", "status_effect": { "id": "minecraft:slowness", "amplifier": 4, "duration": 600 }, "shape": { "type": "lucky:cube", "size": [3, 3, 3] } } ``` This outcome applies the same status effect to all mobs within a 3x3x3 cube around the Lucky Block. # Entity Outcome The entity outcome spawns an entity in the world. ```json { "type": "lucky:entity", "entity_type": "minecraft:creeper" } ``` This outcome spawns 10 Creepers. ```json { "type": "lucky:entity", "entity_type": "minecraft:creeper", "count": 10, "nbt": { "powered": true, "ignited": true, "CustomName": "{'text':'Lucky Creeper'}", "CustomNameVisible": true } } ``` This outcome spawns 10 Creepers that are charged, ignited, and have the custom name "Lucky Creeper". # Explosion Outcome The explosion outcome creates an explosion in the world. ```json { "type": "lucky:explosion", "luck": -2, "explosion": { "power": 6 } } ``` This outcome creates a simple large explosion with a power of 6. For reference, regular Tnt has a power of 4. 
{
  "type": "lucky:explosion",
  "luck": -2,
  "explosion": {
    "power": 6,
    "create_fire": true,
    "behavior": "wind_charge"
  }
}
This outcome creates a fiery explosion that does not directly damage entities, rather launching them upwards (like a wind charge). 
{
  "type": "lucky:explosion",
  "luck": -2,
  "explosion": {
    "particle": {
      "type": "minecraft:sonic_boom"
    },
    "emitter_particle": {
      "type": "minecraft:sonic_boom"
    },
    "sound_event": "minecraft:entity.ghast.scream"
  }
}
This outcome creates a regular explosion using regular and soul fire flame particles, as well as the Ghast scream sound instead of the explosion sound. # Feature Outcome The feature outcome places a feature in the world. 
{
  "type": "lucky:feature",
  "feature": "minecraft:tall_mangrove"
}
This outcome will generate a tall mangrove tree in the world. **Note: This outcome will not always place the feature. Certain features require hardcoded conditions to place successfully. The following features will not place every time:** * Amethyst Geodes * Large Dripstone # Group Outcome The group outcome executes multiple outcomes in order during the same game tick. ```json { "type": "lucky:group", "outcomes": [ { "type": "lucky:item", "item": "minecraft:netherite_sword" }, { "type": "lucky:item", "item": "minecraft:netherite_shovel" }, { "type": "lucky:item", "item": "minecraft:netherite_pickaxe" }, { "type": "lucky:item", "item": "minecraft:netherite_axe" }, { "type": "lucky:item", "item": "minecraft:netherite_hoe" } ] } ``` This outcome spawns all Netherite tools on the ground. ### Weight The "weight" field (defaults to **1**) is used to order the outcomes. ```json { "type": "lucky:group", "outcomes": [ { "type": "lucky:item", "item": "minecraft:netherite_sword", "weight": 10 }, { "type": "lucky:item", "item": "minecraft:netherite_shovel" }, { "type": "lucky:item", "item": "minecraft:netherite_pickaxe", "weight": 0 }, { "type": "lucky:item", "item": "minecraft:netherite_axe", "weight": { "type": "minecraft:uniform", "max_inclusive": 11, "min_inclusive": 0 } }, { "type": "lucky:item", "item": "minecraft:netherite_hoe" } ] } ``` This outcome has a small chance to drop the Netherite Axe first, or to not drop it at all. The Netherite Pickaxe will never drop. The Netherite Sword will almost always drop first. In this scenario, "weight" does not change much, but for other outcome types this can have more impact. # Item Outcome The item outcome spawns items on the ground. ```json { "type": "lucky:item", "item": "minecraft:end_portal_frame", "count": { "type": "minecraft:uniform", "min_inclusive": 2, "max_inclusive": 6 } } ``` This outcome spawns between 2 and 6 End Portal Frame items on the ground. ```json { "type": "lucky:item", "item": "minecraft:enchanted_book", "components": { "minecraft:stored_enchantments": { "levels": { "minecraft:protection": 1 } } } } ``` This outcome spawns an Enchanted Book with the Protection 1 Enchantment. --- [Next Page](/llms-full.txt/1)