Refactor decorative blocks class

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt

@@ -4,6 +4,7 @@ import net.minecraft.core.Direction
 import net.minecraft.data.recipes.ShapedRecipeBuilder
 import net.minecraft.data.recipes.ShapelessRecipeBuilder
 import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.item.DyeColor
 import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.block.IronBarsBlock
 import net.minecraftforge.client.model.generators.ConfiguredModel
@@ -119,21 +120,21 @@ object DataGen {
 	}
 
 	private fun decoratives(list: ColoredDecorativeBlock) {
-		for (block in list.coloredBlocks) {
+		for (block in list.blocks.values) {
 			decorativeCubeAll(block)
 		}
 
-		for (item in list.coloredItems) {
+		for (item in list.items.values) {
 			itemModelProvider.block(item)
 		}
 	}
 
 	private fun decoratives(list: DecorativeBlock) {
-		for (block in list.blocks) {
+		for (block in list.blocks.values) {
 			decorativeCubeAll(block)
 		}
 
-		for (item in list.items) {
+		for (item in list.items.values) {
 			itemModelProvider.block(item)
 		}
 	}
@@ -173,7 +174,7 @@ object DataGen {
 		decoratives(MRegistry.VENT)
 		decoratives(MRegistry.VENT_ALTERNATIVE)
 
-		for (glass in MRegistry.INDUSTRIAL_GLASS.blocks) {
+		for (glass in MRegistry.INDUSTRIAL_GLASS.allBlocks.values) {
 			decorativeCubeAll(glass)
 		}
 
@@ -186,7 +187,7 @@ object DataGen {
 		blockModelProvider.resourceCubeAll(MBlocks.DEEPSLATE_TRITANIUM_ORE)
 
 		blockModelProvider.lambda {
-			for (crate in MRegistry.CARGO_CRATES.coloredBlocks) {
+			for (crate in MRegistry.CARGO_CRATES.blocks.values) {
 				it.withExistingParent("${crate.registryName!!.path}_closed", ResourceLocation(OverdriveThatMatters.MOD_ID, "${MNames.CARGO_CRATE}_closed"))
 					.texture("texture", "block/cargo_crates/${crate.registryName!!.path}")
 					.texture("particle", "block/cargo_crates/${crate.registryName!!.path}")
@@ -199,8 +200,8 @@ object DataGen {
 
 		decorativeColumn(MBlocks.TRITANIUM_STRIPED_BLOCK, "tritanium_striped_block", "tritanium_block")
 
-		for ((i, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.blocks.withIndex()) {
+		for ((color, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.blocks) {
-			val name = MRegistry.INDUSTRIAL_GLASS.blocks[i].registryName!!.path
+			val name = MRegistry.INDUSTRIAL_GLASS.blocks[color]!!.registryName!!.path
 			val textureSide = ResourceLocation(MOD_ID, "block/decorative/$name")
 			val textureRailing = ResourceLocation(MOD_ID, "block/decorative/industrial_glass_frame")
 			pane(glass, textureSide, textureRailing)
@@ -288,7 +289,7 @@ object DataGen {
 			block(MBlocks.MATTER_RECYCLER)
 
 			lambda {
-				for (crate in MRegistry.CARGO_CRATES.coloredBlocks) {
+				for (crate in MRegistry.CARGO_CRATES.allBlocks.values) {
 					getVariantBuilder(crate).forAllStates {
 						return@forAllStates arrayOf(
 							ConfiguredModel.builder()
@@ -379,17 +380,17 @@ object DataGen {
 			block(MItems.TRITANIUM_RAW_BLOCK)
 			block(MItems.ITEM_MONITOR)
 
-			MRegistry.VENT.items.forEach(this::block)
+			MRegistry.VENT.items.values.forEach(this::block)
-			MRegistry.VENT_ALTERNATIVE.items.forEach(this::block)
+			MRegistry.VENT_ALTERNATIVE.items.values.forEach(this::block)
-			MRegistry.TRITANIUM_BLOCK.items.forEach(this::block)
+			MRegistry.TRITANIUM_BLOCK.items.values.forEach(this::block)
-			MRegistry.INDUSTRIAL_GLASS.items.forEach(this::block)
+			MRegistry.INDUSTRIAL_GLASS.items.values.forEach(this::block)
 
-			for (block in MRegistry.TRITANIUM_STRIPED_BLOCK.items) {
+			for (block in MRegistry.TRITANIUM_STRIPED_BLOCK.flatItems) {
 				block(block)
 			}
 
-			for ((i, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.items.withIndex()) {
+			for ((color, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.allItems) {
-				generated(glass, ResourceLocation(MOD_ID, "block/decorative/${MRegistry.INDUSTRIAL_GLASS.items[i].registryName!!.path}"))
+				generated(glass, ResourceLocation(MOD_ID, "block/decorative/${MRegistry.INDUSTRIAL_GLASS.allItems[color]!!.registryName!!.path}"))
 			}
 
 			blocks(MItems.CRATE_LIST)
@@ -435,7 +436,7 @@ object DataGen {
 
 			generated(MItems.MATTER_DUST)
 
-			for (item in MRegistry.CARGO_CRATES.items) {
+			for (item in MRegistry.CARGO_CRATES.allItems.values) {
 				block(item, "${item.registryName!!.path}_closed")
 			}
 
@@ -573,53 +574,34 @@ object DataGen {
 					.unlockedBy("has_tritanium_glass", has(MRegistry.INDUSTRIAL_GLASS.item))
 					.save(consumer)
 
-				val mapping = arrayOf(
+				val mappingUpgradeVanilla = mapOf(
-					Tags.Items.DYES_WHITE,
+					DyeColor.WHITE to net.minecraft.world.item.Items.WHITE_STAINED_GLASS,
-					Tags.Items.DYES_ORANGE,
+					DyeColor.ORANGE to net.minecraft.world.item.Items.ORANGE_STAINED_GLASS,
-					Tags.Items.DYES_MAGENTA,
+					DyeColor.MAGENTA to net.minecraft.world.item.Items.MAGENTA_STAINED_GLASS,
-					Tags.Items.DYES_LIGHT_BLUE,
+					DyeColor.LIGHT_BLUE to net.minecraft.world.item.Items.LIGHT_BLUE_STAINED_GLASS,
-					Tags.Items.DYES_YELLOW,
+					DyeColor.YELLOW to net.minecraft.world.item.Items.YELLOW_STAINED_GLASS,
-					Tags.Items.DYES_LIME,
+					DyeColor.LIME to net.minecraft.world.item.Items.LIME_STAINED_GLASS,
-					Tags.Items.DYES_PINK,
+					DyeColor.PINK to net.minecraft.world.item.Items.PINK_STAINED_GLASS,
-					Tags.Items.DYES_GRAY,
+					DyeColor.GRAY to net.minecraft.world.item.Items.GRAY_STAINED_GLASS,
-					Tags.Items.DYES_LIGHT_GRAY,
+					DyeColor.LIGHT_GRAY to net.minecraft.world.item.Items.LIGHT_GRAY_STAINED_GLASS,
-					Tags.Items.DYES_CYAN,
+					DyeColor.CYAN to net.minecraft.world.item.Items.CYAN_STAINED_GLASS,
-					Tags.Items.DYES_PURPLE,
+					DyeColor.PURPLE to net.minecraft.world.item.Items.PURPLE_STAINED_GLASS,
-					Tags.Items.DYES_BLUE,
+					DyeColor.BLUE to net.minecraft.world.item.Items.BLUE_STAINED_GLASS,
-					Tags.Items.DYES_BROWN,
+					DyeColor.BROWN to net.minecraft.world.item.Items.BROWN_STAINED_GLASS,
-					Tags.Items.DYES_GREEN,
+					DyeColor.GREEN to net.minecraft.world.item.Items.GREEN_STAINED_GLASS,
-					Tags.Items.DYES_RED,
+					DyeColor.RED to net.minecraft.world.item.Items.RED_STAINED_GLASS,
-					Tags.Items.DYES_BLACK,
+					DyeColor.BLACK to net.minecraft.world.item.Items.BLACK_STAINED_GLASS,
 				)
 
-				val mappingUpgradeVanilla = arrayOf(
+				for (color in DyeColor.values()) {
-					net.minecraft.world.item.Items.WHITE_STAINED_GLASS,
+					val item = MRegistry.INDUSTRIAL_GLASS.items[color]!!
-					net.minecraft.world.item.Items.ORANGE_STAINED_GLASS,
+					val paneItem = MRegistry.INDUSTRIAL_GLASS_PANE.items[color]!!
-					net.minecraft.world.item.Items.MAGENTA_STAINED_GLASS,
+					val mappedVanilla = mappingUpgradeVanilla[color]!!
-					net.minecraft.world.item.Items.LIGHT_BLUE_STAINED_GLASS,
-					net.minecraft.world.item.Items.YELLOW_STAINED_GLASS,
-					net.minecraft.world.item.Items.LIME_STAINED_GLASS,
-					net.minecraft.world.item.Items.PINK_STAINED_GLASS,
-					net.minecraft.world.item.Items.GRAY_STAINED_GLASS,
-					net.minecraft.world.item.Items.LIGHT_GRAY_STAINED_GLASS,
-					net.minecraft.world.item.Items.CYAN_STAINED_GLASS,
-					net.minecraft.world.item.Items.PURPLE_STAINED_GLASS,
-					net.minecraft.world.item.Items.BLUE_STAINED_GLASS,
-					net.minecraft.world.item.Items.BROWN_STAINED_GLASS,
-					net.minecraft.world.item.Items.GREEN_STAINED_GLASS,
-					net.minecraft.world.item.Items.RED_STAINED_GLASS,
-					net.minecraft.world.item.Items.BLACK_STAINED_GLASS,
-				)
-
-				for ((i, tag) in mapping.withIndex()) {
-					val item = MRegistry.INDUSTRIAL_GLASS.coloredItems[i]
-					val paneItem = MRegistry.INDUSTRIAL_GLASS_PANE.coloredItems[i]
-					val mappedVanilla = mappingUpgradeVanilla[i]
 
 					// обычная покраска
 					ShapelessRecipeBuilder(item, 8)
 						.requires(MRegistry.INDUSTRIAL_GLASS.item, 8)
-						.requires(tag)
+						.requires(color.tag)
 						.unlockedBy("has_tritanium_glass", has(MRegistry.INDUSTRIAL_GLASS.item))
 						.save(consumer)
 
@@ -633,7 +615,7 @@ object DataGen {
 
 					ShapelessRecipeBuilder(paneItem, 8)
 						.requires(MRegistry.INDUSTRIAL_GLASS_PANE.item, 8)
-						.requires(tag)
+						.requires(color.tag)
 						.unlockedBy("has_tritanium_glass_pane", has(MRegistry.INDUSTRIAL_GLASS_PANE.item))
 						.save(consumer)
 

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/MatteryLanguageProvider.kt

@@ -213,22 +213,9 @@ class MatteryLanguageProvider(private val gen: DataGenerator) {
 			.build()
 
 		fun add(list: ColoredDecorativeBlock, toFormat: String) {
-			slave.add(list.whiteBlock, toFormat.format(white))
+			for ((color, target) in dyeClassPairs) {
-			slave.add(list.orangeBlock, toFormat.format(orange))
+				slave.add(list.blocks[color]!!, toFormat.format(target))
-			slave.add(list.magentaBlock, toFormat.format(magenta))
+			}
-			slave.add(list.lightBlueBlock, toFormat.format(lightBlue))
-			slave.add(list.yellowBlock, toFormat.format(yellow))
-			slave.add(list.limeBlock, toFormat.format(lime))
-			slave.add(list.pinkBlock, toFormat.format(pink))
-			slave.add(list.grayBlock, toFormat.format(gray))
-			slave.add(list.lightGrayBlock, toFormat.format(lightGray))
-			slave.add(list.cyanBlock, toFormat.format(cyan))
-			slave.add(list.purpleBlock, toFormat.format(purple))
-			slave.add(list.blueBlock, toFormat.format(blue))
-			slave.add(list.brownBlock, toFormat.format(brown))
-			slave.add(list.greenBlock, toFormat.format(green))
-			slave.add(list.redBlock, toFormat.format(red))
-			slave.add(list.blackBlock, toFormat.format(black))
 		}
 
 		fun add(

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTables.kt

@@ -101,7 +101,7 @@ class LootTables(generator: DataGenerator) : LootTableProvider(generator) {
 		blocks.forEach(this::dropsSelf)
 	}
 
-	fun dropsSelf(blocks: List<Block>) {
+	fun dropsSelf(blocks: Collection<Block>) {
 		blocks.forEach(this::dropsSelf)
 	}
 

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/loot/LootTablesData.kt

@@ -1,16 +1,11 @@
 package ru.dbotthepony.mc.otm.datagen.loot
 
-import ru.dbotthepony.mc.otm.block.MatteryBlock
 import ru.dbotthepony.mc.otm.block.entity.ChemicalGeneratorBlockEntity
 import ru.dbotthepony.mc.otm.block.entity.EnergyCounterBlockEntity
-import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity
-import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.INVENTORY_KEY
 import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.ENERGY_KEY
-import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.BATTERY_KEY
 import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.MATTER_STORAGE_KEY
 import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.REDSTONE_SETTING_KEY
 import ru.dbotthepony.mc.otm.block.entity.MatteryBlockEntity.Companion.REDSTONE_SIGNAL_KEY
-import ru.dbotthepony.mc.otm.block.entity.MatteryWorkerBlockEntity
 import ru.dbotthepony.mc.otm.block.entity.matter.MatterBottlerBlockEntity
 import ru.dbotthepony.mc.otm.block.entity.storage.AbstractStorageImportExport.Companion.FILTER_KEY
 import ru.dbotthepony.mc.otm.block.entity.storage.StoragePowerSupplierBlockEntity
@@ -20,15 +15,15 @@ import ru.dbotthepony.mc.otm.registry.MRegistry
 fun addLootTables(lootTables: LootTables) {
 	lootTables.dropsSelf(MBlocks.CRATE_LIST)
 
-	lootTables.dropsSelf(MRegistry.CARGO_CRATES.blocks)
+	lootTables.dropsSelf(MRegistry.CARGO_CRATES.blocks.values)
-	lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS.blocks)
+	lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS.blocks.values)
-	lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS_PANE.blocks)
+	lootTables.dropsSelf(MRegistry.INDUSTRIAL_GLASS_PANE.blocks.values)
-	lootTables.dropsSelf(MRegistry.TRITANIUM_BLOCK.blocks)
+	lootTables.dropsSelf(MRegistry.TRITANIUM_BLOCK.blocks.values)
-	lootTables.dropsSelf(MRegistry.VENT.blocks)
+	lootTables.dropsSelf(MRegistry.VENT.blocks.values)
-	lootTables.dropsSelf(MRegistry.VENT_ALTERNATIVE.blocks)
+	lootTables.dropsSelf(MRegistry.VENT_ALTERNATIVE.blocks.values)
-	lootTables.dropsSelf(MRegistry.FLOOR_TILES.coloredBlocks)
+	lootTables.dropsSelf(MRegistry.FLOOR_TILES.blocks.values)
-	lootTables.dropsSelf(MRegistry.UNREFINED_FLOOR_TILES.coloredBlocks)
+	lootTables.dropsSelf(MRegistry.UNREFINED_FLOOR_TILES.blocks.values)
-	lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_BLOCK.blocks)
+	lootTables.dropsSelf(MRegistry.TRITANIUM_STRIPED_BLOCK.flatBlocks)
 
 	lootTables.dropsSelf(MBlocks.CARBON_FIBRE_BLOCK)
 	lootTables.dropsSelf(MBlocks.TRITANIUM_RAW_BLOCK)

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/models/MatteryModelProvider.kt

@@ -67,7 +67,7 @@ class BlockMatteryModelProvider(event: GatherDataEvent) : MatteryModelProvider(e
 		super.registerModels()
 
 		for ((path, texture) in cubeAll) {
-			cubeAll(path, texture)
+			val s = cubeAll(path, texture)
 		}
 
 		for ((path, end, side) in cubeColumn) {

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/recipes/CraftingTableRecipes.kt

@@ -5,10 +5,8 @@ import net.minecraft.data.recipes.ShapedRecipeBuilder
 import net.minecraft.data.recipes.ShapelessRecipeBuilder
 import net.minecraft.data.recipes.SimpleCookingRecipeBuilder
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.world.item.DyeColor
 import net.minecraft.world.item.Items
 import net.minecraft.world.item.crafting.Ingredient
-import net.minecraft.world.level.block.Blocks
 import net.minecraftforge.common.Tags
 import net.minecraftforge.common.Tags.Items.COBBLESTONE
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
@@ -20,7 +18,7 @@ import ru.dbotthepony.mc.otm.core.registryName
 import java.util.function.Consumer
 
 fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
-	for ((dye, crate) in MRegistry.CARGO_CRATES.mappedColoredBlocks) {
+	for ((dye, crate) in MRegistry.CARGO_CRATES.blocks) {
 		ShapedRecipeBuilder(crate, 1)
 			.define('P', MItemTags.PLATE_TRITANIUM)
 			.define('C', Tags.Items.CHESTS)
@@ -77,7 +75,7 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 		.unlockedBy(MItemTags.PLATE_TRITANIUM)
 		.build(consumer)
 
-	for ((color, item) in MRegistry.TRITANIUM_BLOCK.mappedColoredItems) {
+	for ((color, item) in MRegistry.TRITANIUM_BLOCK.items) {
 		MatteryRecipe(item, 8)
 			.row(MRegistry.TRITANIUM_BLOCK.item, MRegistry.TRITANIUM_BLOCK.item, MRegistry.TRITANIUM_BLOCK.item)
 			.row(MRegistry.TRITANIUM_BLOCK.item, color.tag, MRegistry.TRITANIUM_BLOCK.item)
@@ -90,7 +88,7 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 	for ((item, colors) in MRegistry.TRITANIUM_STRIPED_BLOCK.itemsWithColor) {
 		val (base, stripe) = colors
 
-		val original = MRegistry.TRITANIUM_BLOCK.mappedColoredItems[base]!!
+		val original = MRegistry.TRITANIUM_BLOCK.items[base]!!
 
 		MatteryRecipe(item, 8)
 			.row(original, original, original)
@@ -107,7 +105,7 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 		.unlockedBy(MItemTags.PLATE_TRITANIUM)
 		.build(consumer)
 
-	for ((color, item) in MRegistry.VENT.mappedColoredItems) {
+	for ((color, item) in MRegistry.VENT.items) {
 		MatteryRecipe(item, 8)
 			.row(MRegistry.VENT.item, MRegistry.VENT.item, MRegistry.VENT.item)
 			.row(MRegistry.VENT.item, color.tag, MRegistry.VENT.item)
@@ -117,8 +115,8 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 			.build(consumer)
 	}
 
-	for ((color, item) in MRegistry.VENT_ALTERNATIVE.mappedColoredItemsAll) {
+	for ((color, item) in MRegistry.VENT_ALTERNATIVE.allItems) {
-		val other = MRegistry.VENT.mappedColoredItemsAll[color]!!
+		val other = MRegistry.VENT.allItems[color]!!
 		ShapelessRecipeBuilder(item, 1).requires(other).unlockedBy(item).save(consumer)
 		ShapelessRecipeBuilder(other, 1).requires(item).unlockedBy(other).save(consumer, ResourceLocation(OverdriveThatMatters.MOD_ID, "${other.registryName!!.path}_from_alt"))
 	}
@@ -265,7 +263,7 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 		.build(consumer)
 
 	// Напольная плитка
-	for ((color, unrefinedItem) in MRegistry.UNREFINED_FLOOR_TILES.mappedColoredItems) {
+	for ((color, unrefinedItem) in MRegistry.UNREFINED_FLOOR_TILES.items) {
 		MatteryRecipe(unrefinedItem, 24)
 			.row(Items.CLAY, Items.SAND, Items.CLAY)
 			.row(Items.SAND, color.tag, Items.SAND)
@@ -274,13 +272,13 @@ fun addCraftingTableRecipes(consumer: Consumer<FinishedRecipe>) {
 			.build(consumer)
 	}
 
-	for ((color, refinedItem) in MRegistry.FLOOR_TILES.mappedColoredItems) {
+	for ((color, refinedItem) in MRegistry.FLOOR_TILES.items) {
 		SimpleCookingRecipeBuilder.smelting(
-			Ingredient.of(MRegistry.UNREFINED_FLOOR_TILES.mappedColoredItems[color]!!),
+			Ingredient.of(MRegistry.UNREFINED_FLOOR_TILES.items[color]!!),
 			refinedItem,
 			0.15f,
 			200
-		).unlockedBy("has_unrefined_block", has(MRegistry.UNREFINED_FLOOR_TILES.mappedColoredItems[color]!!)).save(consumer)
+		).unlockedBy("has_unrefined_block", has(MRegistry.UNREFINED_FLOOR_TILES.items[color]!!)).save(consumer)
 	}
 
 	// станция андроида

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/Tags.kt

@@ -60,18 +60,18 @@ fun addTags(tagsProvider: TagsProvider) {
 	tagsProvider.requiresPickaxe(MBlocks.TRITANIUM_STRIPED_BLOCK, Tiers.IRON)
 	tagsProvider.requiresPickaxe(MBlocks.CARBON_FIBRE_BLOCK, Tiers.IRON)
 
-	tagsProvider.requiresPickaxe(MRegistry.CARGO_CRATES.blocks, Tiers.IRON)
+	tagsProvider.requiresPickaxe(MRegistry.CARGO_CRATES.blocks.values, Tiers.IRON)
 
-	tagsProvider.requiresPickaxe(MRegistry.VENT.blocks, Tiers.IRON)
+	tagsProvider.requiresPickaxe(MRegistry.VENT.blocks.values, Tiers.IRON)
-	tagsProvider.requiresPickaxe(MRegistry.VENT_ALTERNATIVE.blocks, Tiers.IRON)
+	tagsProvider.requiresPickaxe(MRegistry.VENT_ALTERNATIVE.blocks.values, Tiers.IRON)
-	tagsProvider.requiresPickaxe(MRegistry.TRITANIUM_BLOCK.blocks, Tiers.IRON)
+	tagsProvider.requiresPickaxe(MRegistry.TRITANIUM_BLOCK.blocks.values, Tiers.IRON)
-	tagsProvider.requiresPickaxe(MRegistry.TRITANIUM_STRIPED_BLOCK.blocks, Tiers.IRON)
+	tagsProvider.requiresPickaxe(MRegistry.TRITANIUM_STRIPED_BLOCK.flatBlocks, Tiers.IRON)
-	tagsProvider.requiresPickaxe(MRegistry.FLOOR_TILES.coloredBlocks)
+	tagsProvider.requiresPickaxe(MRegistry.FLOOR_TILES.blocks.values)
 
-	tagsProvider.requiresShovel(MRegistry.UNREFINED_FLOOR_TILES.coloredBlocks)
+	tagsProvider.requiresShovel(MRegistry.UNREFINED_FLOOR_TILES.blocks.values)
 
-	tagsProvider.requiresPickaxe(MRegistry.INDUSTRIAL_GLASS.blocks, Tiers.STONE)
+	tagsProvider.requiresPickaxe(MRegistry.INDUSTRIAL_GLASS.blocks.values, Tiers.STONE)
-	tagsProvider.requiresPickaxe(MRegistry.INDUSTRIAL_GLASS_PANE.blocks, Tiers.STONE)
+	tagsProvider.requiresPickaxe(MRegistry.INDUSTRIAL_GLASS_PANE.blocks.values, Tiers.STONE)
 	tagsProvider.requiresPickaxe(MBlocks.CRATE_LIST, Tiers.STONE)
 
 	tagsProvider.requiresPickaxe(listOf(

src/data/kotlin/ru/dbotthepony/mc/otm/datagen/tags/TagsProvider.kt

@@ -23,9 +23,9 @@ interface MTagAppender<T> {
 		return any
 	}
 
-	fun add(values: List<T>): TagsProvider
+	fun add(values: Collection<T>): TagsProvider
 
-	fun addSafe(values: List<T>): Boolean {
+	fun addSafe(values: Collection<T>): Boolean {
 		var any = false
 		for (value in values) any = addSafe(value)
 		return any
@@ -42,9 +42,9 @@ interface ForgeTagAppender<T> : MTagAppender<T> {
 		return any
 	}
 
-	fun add(key: String, values: List<T>): TagsProvider
+	fun add(key: String, values: Collection<T>): TagsProvider
 
-	fun addSafe(key: String, values: List<T>): Boolean {
+	fun addSafe(key: String, values: Collection<T>): Boolean {
 		var any = false
 		for (value in values) any = addSafe(key, value)
 		return any
@@ -89,7 +89,7 @@ class TagsProvider(
 					return this@TagsProvider
 				}
 
-				override fun add(values: List<T>): TagsProvider {
+				override fun add(values: Collection<T>): TagsProvider {
 					for (value in values) add(value)
 					return this@TagsProvider
 				}
@@ -129,7 +129,7 @@ class TagsProvider(
 					return this@TagsProvider
 				}
 
-				override fun add(key: String, values: List<T>): TagsProvider {
+				override fun add(key: String, values: Collection<T>): TagsProvider {
 					for (value in values) add(key, value)
 					return this@TagsProvider
 				}
@@ -146,7 +146,7 @@ class TagsProvider(
 					return parent.add(*values)
 				}
 
-				override fun add(values: List<T>): TagsProvider {
+				override fun add(values: Collection<T>): TagsProvider {
 					return parent.add(values)
 				}
 			}
@@ -228,7 +228,7 @@ class TagsProvider(
 		return this
 	}
 
-	fun requiresPickaxe(blocks: List<Block>, tier: Tier? = null): TagsProvider {
+	fun requiresPickaxe(blocks: Collection<Block>, tier: Tier? = null): TagsProvider {
 		for (block in blocks) requiresPickaxe(block, tier)
 		return this
 	}
@@ -250,7 +250,7 @@ class TagsProvider(
 		return this
 	}
 
-	fun requiresShovel(blocks: List<Block>, tier: Tier? = null): TagsProvider {
+	fun requiresShovel(blocks: Collection<Block>, tier: Tier? = null): TagsProvider {
 		for (block in blocks) requiresShovel(block, tier)
 		return this
 	}
@@ -267,7 +267,7 @@ class TagsProvider(
 		return this
 	}
 
-	fun requiresAxe(blocks: List<Block>, tier: Tier? = null): TagsProvider {
+	fun requiresAxe(blocks: Collection<Block>, tier: Tier? = null): TagsProvider {
 		for (block in blocks) requiresAxe(block, tier)
 		return this
 	}

src/main/kotlin/ru/dbotthepony/mc/otm/registry/LazyList.kt

@@ -5,9 +5,16 @@ import com.google.common.collect.ImmutableSet
 import net.minecraft.world.item.DyeColor
 import net.minecraftforge.registries.RegistryObject
 
-class LazyList<T>(private val getters: ImmutableList<() -> T>) : AbstractList<T>() {
+class LazyList<T> : AbstractList<T> {
-	constructor(vararg getters: () -> T) : this(ImmutableList.copyOf(getters))
+	private val getters: Array<() -> T>
-	constructor(getters: List<() -> T>) : this(ImmutableList.copyOf(getters))
+
+	constructor(vararg getters: () -> T) : super() {
+		this.getters = Array(getters.size) { getters[it] }
+	}
+
+	constructor(getters: List<() -> T>) : super() {
+		this.getters = Array(getters.size) { getters[it] }
+	}
 
 	override val size: Int
 		get() = getters.size
@@ -24,7 +31,7 @@ class LazyMap<K, T> : AbstractMap<K, T> {
 		entries = ImmutableSet.copyOf(mValues.map { Entry(it.first, it.second) })
 	}
 
-	constructor(mValues: List<Pair<K, () -> T>>) : super() {
+	constructor(mValues: Collection<Pair<K, () -> T>>) : super() {
 		entries = ImmutableSet.copyOf(mValues.map { Entry(it.first, it.second) })
 	}
 
@@ -42,7 +49,7 @@ class LazyMap<K, T> : AbstractMap<K, T> {
 }
 
 class RegistryObjectList<T>(private vararg val getters: RegistryObject<T>) : AbstractList<T>() {
-	constructor(getters: List<RegistryObject<T>>) : this(*getters.toTypedArray())
+	constructor(getters: Collection<RegistryObject<T>>) : this(*getters.toTypedArray())
 
 	override val size: Int
 		get() = getters.size

src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlockEntities.kt

@@ -35,7 +35,7 @@ object MBlockEntities {
 	val BLACK_HOLE: BlockEntityType<*> by registry.register(MNames.BLACK_HOLE) { BlockEntityType.Builder.of(::BlackHoleBlockEntity, MBlocks.BLACK_HOLE).build(null) }
 	val CARGO_CRATE: BlockEntityType<*> by registry.register(MNames.CARGO_CRATE) { BlockEntityType.Builder.of(
 		::CargoCrateBlockEntity,
-		*MRegistry.CARGO_CRATES.blocks.toTypedArray()
+		*MRegistry.CARGO_CRATES.blocks.values.toTypedArray()
 	).build(null) }
 	val DRIVE_RACK: BlockEntityType<*> by registry.register(MNames.DRIVE_RACK) { BlockEntityType.Builder.of(::DriveRackBlockEntity, MBlocks.DRIVE_RACK).build(null) }
 	val ITEM_MONITOR: BlockEntityType<*> by registry.register(MNames.ITEM_MONITOR) { BlockEntityType.Builder.of(::ItemMonitorBlockEntity, MBlocks.ITEM_MONITOR).build(null) }

src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlocks.kt

@@ -33,11 +33,11 @@ object MBlocks {
 	private fun registerClient(event: FMLClientSetupEvent) {
 		val translucent = RenderType.translucent()
 
-		for (block in MRegistry.INDUSTRIAL_GLASS.blocks) {
+		for (block in MRegistry.INDUSTRIAL_GLASS.blocks.values) {
 			ItemBlockRenderTypes.setRenderLayer(block, translucent)
 		}
 
-		for (block in MRegistry.INDUSTRIAL_GLASS_PANE.blocks) {
+		for (block in MRegistry.INDUSTRIAL_GLASS_PANE.blocks.values) {
 			ItemBlockRenderTypes.setRenderLayer(block, translucent)
 		}
 	}

src/main/kotlin/ru/dbotthepony/mc/otm/registry/objects/ColoredDecorativeBlock.kt

@@ -9,9 +9,8 @@ import net.minecraft.world.level.block.state.BlockBehaviour
 import net.minecraftforge.registries.DeferredRegister
 import net.minecraftforge.registries.RegistryObject
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.registry.LazyList
 import ru.dbotthepony.mc.otm.registry.LazyMap
-import ru.dbotthepony.mc.otm.registry.WriteOnce
+import java.util.EnumMap
 
 /**
  * Colored only
@@ -22,228 +21,82 @@ open class ColoredDecorativeBlock(
 	private val provider: (DyeColor) -> Block,
 	itemGroup: CreativeModeTab = OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE
 ) {
-	protected var _whiteBlock: RegistryObject<Block> by WriteOnce()
+	var registeredItems = false
-		private set
-	protected var _orangeBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _magentaBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _lightBlueBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _yellowBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _limeBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _pinkBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _grayBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _lightGrayBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _cyanBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _purpleBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _blueBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _brownBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _greenBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _redBlock: RegistryObject<Block> by WriteOnce()
-		private set
-	protected var _blackBlock: RegistryObject<Block> by WriteOnce()
 		private set
 
-	val whiteBlock: Block get() = _whiteBlock.get()
+	var registeredBlocks = false
-	val orangeBlock: Block get() = _orangeBlock.get()
-	val magentaBlock: Block get() = _magentaBlock.get()
-	val lightBlueBlock: Block get() = _lightBlueBlock.get()
-	val yellowBlock: Block get() = _yellowBlock.get()
-	val limeBlock: Block get() = _limeBlock.get()
-	val pinkBlock: Block get() = _pinkBlock.get()
-	val grayBlock: Block get() = _grayBlock.get()
-	val lightGrayBlock: Block get() = _lightGrayBlock.get()
-	val cyanBlock: Block get() = _cyanBlock.get()
-	val purpleBlock: Block get() = _purpleBlock.get()
-	val blueBlock: Block get() = _blueBlock.get()
-	val brownBlock: Block get() = _brownBlock.get()
-	val greenBlock: Block get() = _greenBlock.get()
-	val redBlock: Block get() = _redBlock.get()
-	val blackBlock: Block get() = _blackBlock.get()
-
-	protected var _whiteItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _orangeItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _magentaItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _lightBlueItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _yellowItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _limeItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _pinkItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _grayItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _lightGrayItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _cyanItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _purpleItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _blueItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _brownItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _greenItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _redItem: RegistryObject<Item> by WriteOnce()
-		private set
-	protected var _blackItem: RegistryObject<Item> by WriteOnce()
 		private set
 
-	val whiteItem: Item get() = _whiteItem.get()
+	protected val itemMap = EnumMap<DyeColor, RegistryObject<Item>>(DyeColor::class.java)
-	val orangeItem: Item get() = _orangeItem.get()
+	protected val blockMap = EnumMap<DyeColor, RegistryObject<Block>>(DyeColor::class.java)
-	val magentaItem: Item get() = _magentaItem.get()
-	val lightBlueItem: Item get() = _lightBlueItem.get()
-	val yellowItem: Item get() = _yellowItem.get()
-	val limeItem: Item get() = _limeItem.get()
-	val pinkItem: Item get() = _pinkItem.get()
-	val grayItem: Item get() = _grayItem.get()
-	val lightGrayItem: Item get() = _lightGrayItem.get()
-	val cyanItem: Item get() = _cyanItem.get()
-	val purpleItem: Item get() = _purpleItem.get()
-	val blueItem: Item get() = _blueItem.get()
-	val brownItem: Item get() = _brownItem.get()
-	val greenItem: Item get() = _greenItem.get()
-	val redItem: Item get() = _redItem.get()
-	val blackItem: Item get() = _blackItem.get()
 
-	val coloredBlocks: List<Block> by lazy {
+	fun getItem(dyeColor: DyeColor): Item {
-		LazyList(
+		check(registeredItems) { "Didn't register items yet" }
-			_whiteBlock::get,
+		return itemMap[dyeColor]!!.get()
-			_orangeBlock::get,
-			_magentaBlock::get,
-			_lightBlueBlock::get,
-			_yellowBlock::get,
-			_limeBlock::get,
-			_pinkBlock::get,
-			_grayBlock::get,
-			_lightGrayBlock::get,
-			_cyanBlock::get,
-			_purpleBlock::get,
-			_blueBlock::get,
-			_brownBlock::get,
-			_greenBlock::get,
-			_redBlock::get,
-			_blackBlock::get,
-		)
 	}
 
-	val mappedColoredBlocks: Map<DyeColor, Block> by lazy {
+	fun getBlock(dyeColor: DyeColor): Block {
-		LazyMap(
+		check(registeredBlocks) { "Didn't register items yet" }
-			DyeColor.WHITE to _whiteBlock::get,
+		return blockMap[dyeColor]!!.get()
-			DyeColor.ORANGE to _orangeBlock::get,
-			DyeColor.MAGENTA to _magentaBlock::get,
-			DyeColor.LIGHT_BLUE to _lightBlueBlock::get,
-			DyeColor.YELLOW to _yellowBlock::get,
-			DyeColor.LIME to _limeBlock::get,
-			DyeColor.PINK to _pinkBlock::get,
-			DyeColor.GRAY to _grayBlock::get,
-			DyeColor.LIGHT_GRAY to _lightGrayBlock::get,
-			DyeColor.CYAN to _cyanBlock::get,
-			DyeColor.PURPLE to _purpleBlock::get,
-			DyeColor.BLUE to _blueBlock::get,
-			DyeColor.BROWN to _brownBlock::get,
-			DyeColor.GREEN to _greenBlock::get,
-			DyeColor.RED to _redBlock::get,
-			DyeColor.BLACK to _blackBlock::get,
-		)
 	}
 
-	val coloredItems: List<Item> by lazy {
+	val blocks: Map<DyeColor, Block> by lazy {
-		LazyList(
+		check(registeredBlocks) { "Didn't register blocks yet" }
-			_whiteItem::get,
+		LazyMap(blockMap.map { it.key to it.value::get })
-			_orangeItem::get,
-			_magentaItem::get,
-			_lightBlueItem::get,
-			_yellowItem::get,
-			_limeItem::get,
-			_pinkItem::get,
-			_grayItem::get,
-			_lightGrayItem::get,
-			_cyanItem::get,
-			_purpleItem::get,
-			_blueItem::get,
-			_brownItem::get,
-			_greenItem::get,
-			_redItem::get,
-			_blackItem::get,
-		)
 	}
 
-	val mappedColoredItems: Map<DyeColor, Item> by lazy {
+	val items: Map<DyeColor, Item> by lazy {
-		LazyMap(
+		check(registeredItems) { "Didn't register items yet" }
-			DyeColor.WHITE to _whiteItem::get,
+		LazyMap(itemMap.map { it.key to it.value::get })
-			DyeColor.ORANGE to _orangeItem::get,
-			DyeColor.MAGENTA to _magentaItem::get,
-			DyeColor.LIGHT_BLUE to _lightBlueItem::get,
-			DyeColor.YELLOW to _yellowItem::get,
-			DyeColor.LIME to _limeItem::get,
-			DyeColor.PINK to _pinkItem::get,
-			DyeColor.GRAY to _grayItem::get,
-			DyeColor.LIGHT_GRAY to _lightGrayItem::get,
-			DyeColor.CYAN to _cyanItem::get,
-			DyeColor.PURPLE to _purpleItem::get,
-			DyeColor.BLUE to _blueItem::get,
-			DyeColor.BROWN to _brownItem::get,
-			DyeColor.GREEN to _greenItem::get,
-			DyeColor.RED to _redItem::get,
-			DyeColor.BLACK to _blackItem::get,
-		)
 	}
 
 	open fun registerBlocks(registry: DeferredRegister<Block>) {
-		_whiteBlock = registry.register("${baseName}_white") { provider.invoke(DyeColor.WHITE) }
+		check(blockMap.isEmpty()) { "( ͡° ͜ʖ ͡°) No. \\(• ε •)/ ( ͠° ل͜ ͡°) ( ͠° ͟ ͟ʖ ͡°) (ง ͠° ͟ل͜ ͡°)ง ( ͡°︺͡°) ('ω')" }
-		_orangeBlock = registry.register("${baseName}_orange") { provider.invoke(DyeColor.ORANGE) }
+
-		_magentaBlock = registry.register("${baseName}_magenta") { provider.invoke(DyeColor.MAGENTA) }
+		blockMap[DyeColor.WHITE] = registry.register("${baseName}_white") { provider.invoke(DyeColor.WHITE) }
-		_lightBlueBlock = registry.register("${baseName}_light_blue") { provider.invoke(DyeColor.LIGHT_BLUE) }
+		blockMap[DyeColor.ORANGE] = registry.register("${baseName}_orange") { provider.invoke(DyeColor.ORANGE) }
-		_yellowBlock = registry.register("${baseName}_yellow") { provider.invoke(DyeColor.YELLOW) }
+		blockMap[DyeColor.MAGENTA] = registry.register("${baseName}_magenta") { provider.invoke(DyeColor.MAGENTA) }
-		_limeBlock = registry.register("${baseName}_lime") { provider.invoke(DyeColor.LIME) }
+		blockMap[DyeColor.LIGHT_BLUE] = registry.register("${baseName}_light_blue") { provider.invoke(DyeColor.LIGHT_BLUE) }
-		_pinkBlock = registry.register("${baseName}_pink") { provider.invoke(DyeColor.PINK) }
+		blockMap[DyeColor.YELLOW] = registry.register("${baseName}_yellow") { provider.invoke(DyeColor.YELLOW) }
-		_grayBlock = registry.register("${baseName}_gray") { provider.invoke(DyeColor.GRAY) }
+		blockMap[DyeColor.LIME] = registry.register("${baseName}_lime") { provider.invoke(DyeColor.LIME) }
-		_lightGrayBlock = registry.register("${baseName}_light_gray") { provider.invoke(DyeColor.LIGHT_GRAY) }
+		blockMap[DyeColor.PINK] = registry.register("${baseName}_pink") { provider.invoke(DyeColor.PINK) }
-		_cyanBlock = registry.register("${baseName}_cyan") { provider.invoke(DyeColor.CYAN) }
+		blockMap[DyeColor.GRAY] = registry.register("${baseName}_gray") { provider.invoke(DyeColor.GRAY) }
-		_purpleBlock = registry.register("${baseName}_purple") { provider.invoke(DyeColor.PURPLE) }
+		blockMap[DyeColor.LIGHT_GRAY] = registry.register("${baseName}_light_gray") { provider.invoke(DyeColor.LIGHT_GRAY) }
-		_blueBlock = registry.register("${baseName}_blue") { provider.invoke(DyeColor.BLUE) }
+		blockMap[DyeColor.CYAN] = registry.register("${baseName}_cyan") { provider.invoke(DyeColor.CYAN) }
-		_brownBlock = registry.register("${baseName}_brown") { provider.invoke(DyeColor.BROWN) }
+		blockMap[DyeColor.PURPLE] = registry.register("${baseName}_purple") { provider.invoke(DyeColor.PURPLE) }
-		_greenBlock = registry.register("${baseName}_green") { provider.invoke(DyeColor.GREEN) }
+		blockMap[DyeColor.BLUE] = registry.register("${baseName}_blue") { provider.invoke(DyeColor.BLUE) }
-		_redBlock = registry.register("${baseName}_red") { provider.invoke(DyeColor.RED) }
+		blockMap[DyeColor.BROWN] = registry.register("${baseName}_brown") { provider.invoke(DyeColor.BROWN) }
-		_blackBlock = registry.register("${baseName}_black") { provider.invoke(DyeColor.BLACK) }
+		blockMap[DyeColor.GREEN] = registry.register("${baseName}_green") { provider.invoke(DyeColor.GREEN) }
+		blockMap[DyeColor.RED] = registry.register("${baseName}_red") { provider.invoke(DyeColor.RED) }
+		blockMap[DyeColor.BLACK] = registry.register("${baseName}_black") { provider.invoke(DyeColor.BLACK) }
+
+		registeredBlocks = true
 	}
 
 	private val properties = Item.Properties().tab(itemGroup).stacksTo(64)
 
 	open fun registerItems(registry: DeferredRegister<Item>) {
-		_whiteItem = registry.register("${baseName}_white") { BlockItem(_whiteBlock.get(), properties) }
+		check(itemMap.isEmpty()) { "( ͡° ͜ʖ ͡°) No. \\(• ε •)/ ( ͠° ل͜ ͡°) ( ͠° ͟ ͟ʖ ͡°) (ง ͠° ͟ل͜ ͡°)ง ( ͡°︺͡°) ('ω')" }
-		_orangeItem = registry.register("${baseName}_orange") { BlockItem(_orangeBlock.get(), properties) }
+		check(registeredBlocks) { "wtffffff???????????" }
-		_magentaItem = registry.register("${baseName}_magenta") { BlockItem(_magentaBlock.get(), properties) }
+
-		_lightBlueItem = registry.register("${baseName}_light_blue") { BlockItem(_lightBlueBlock.get(), properties) }
+		itemMap[DyeColor.WHITE] = registry.register("${baseName}_white") { BlockItem(blockMap[DyeColor.WHITE]!!.get(), properties) }
-		_yellowItem = registry.register("${baseName}_yellow") { BlockItem(_yellowBlock.get(), properties) }
+		itemMap[DyeColor.ORANGE] = registry.register("${baseName}_orange") { BlockItem(blockMap[DyeColor.ORANGE]!!.get(), properties) }
-		_limeItem = registry.register("${baseName}_lime") { BlockItem(_limeBlock.get(), properties) }
+		itemMap[DyeColor.MAGENTA] = registry.register("${baseName}_magenta") { BlockItem(blockMap[DyeColor.MAGENTA]!!.get(), properties) }
-		_pinkItem = registry.register("${baseName}_pink") { BlockItem(_pinkBlock.get(), properties) }
+		itemMap[DyeColor.LIGHT_BLUE] = registry.register("${baseName}_light_blue") { BlockItem(blockMap[DyeColor.LIGHT_BLUE]!!.get(), properties) }
-		_grayItem = registry.register("${baseName}_gray") { BlockItem(_grayBlock.get(), properties) }
+		itemMap[DyeColor.YELLOW] = registry.register("${baseName}_yellow") { BlockItem(blockMap[DyeColor.YELLOW]!!.get(), properties) }
-		_lightGrayItem = registry.register("${baseName}_light_gray") { BlockItem(_lightGrayBlock.get(), properties) }
+		itemMap[DyeColor.LIME] = registry.register("${baseName}_lime") { BlockItem(blockMap[DyeColor.LIME]!!.get(), properties) }
-		_cyanItem = registry.register("${baseName}_cyan") { BlockItem(_cyanBlock.get(), properties) }
+		itemMap[DyeColor.PINK] = registry.register("${baseName}_pink") { BlockItem(blockMap[DyeColor.PINK]!!.get(), properties) }
-		_purpleItem = registry.register("${baseName}_purple") { BlockItem(_purpleBlock.get(), properties) }
+		itemMap[DyeColor.GRAY] = registry.register("${baseName}_gray") { BlockItem(blockMap[DyeColor.GRAY]!!.get(), properties) }
-		_blueItem = registry.register("${baseName}_blue") { BlockItem(_blueBlock.get(), properties) }
+		itemMap[DyeColor.LIGHT_GRAY] = registry.register("${baseName}_light_gray") { BlockItem(blockMap[DyeColor.LIGHT_GRAY]!!.get(), properties) }
-		_brownItem = registry.register("${baseName}_brown") { BlockItem(_brownBlock.get(), properties) }
+		itemMap[DyeColor.CYAN] = registry.register("${baseName}_cyan") { BlockItem(blockMap[DyeColor.CYAN]!!.get(), properties) }
-		_greenItem = registry.register("${baseName}_green") { BlockItem(_greenBlock.get(), properties) }
+		itemMap[DyeColor.PURPLE] = registry.register("${baseName}_purple") { BlockItem(blockMap[DyeColor.PURPLE]!!.get(), properties) }
-		_redItem = registry.register("${baseName}_red") { BlockItem(_redBlock.get(), properties) }
+		itemMap[DyeColor.BLUE] = registry.register("${baseName}_blue") { BlockItem(blockMap[DyeColor.BLUE]!!.get(), properties) }
-		_blackItem = registry.register("${baseName}_black") { BlockItem(_blackBlock.get(), properties) }
+		itemMap[DyeColor.BROWN] = registry.register("${baseName}_brown") { BlockItem(blockMap[DyeColor.BROWN]!!.get(), properties) }
+		itemMap[DyeColor.GREEN] = registry.register("${baseName}_green") { BlockItem(blockMap[DyeColor.GREEN]!!.get(), properties) }
+		itemMap[DyeColor.RED] = registry.register("${baseName}_red") { BlockItem(blockMap[DyeColor.RED]!!.get(), properties) }
+		itemMap[DyeColor.BLACK] = registry.register("${baseName}_black") { BlockItem(blockMap[DyeColor.BLACK]!!.get(), properties) }
+
+		registeredItems = true
 	}
 
 	companion object {

src/main/kotlin/ru/dbotthepony/mc/otm/registry/objects/DecorativeBlock.kt

@@ -9,7 +9,6 @@ import net.minecraft.world.level.block.state.BlockBehaviour
 import net.minecraftforge.registries.DeferredRegister
 import net.minecraftforge.registries.RegistryObject
 import ru.dbotthepony.mc.otm.OverdriveThatMatters
-import ru.dbotthepony.mc.otm.registry.LazyList
 import ru.dbotthepony.mc.otm.registry.LazyMap
 import ru.dbotthepony.mc.otm.registry.WriteOnce
 
@@ -28,110 +27,23 @@ class DecorativeBlock(
 	val block: Block get() = _block.get()
 	val item: Item get() = _item.get()
 
-	val mappedColoredBlocksAll: Map<DyeColor?, Block> by lazy {
+	val allBlocks: Map<DyeColor?, Block> by lazy {
-		LazyMap(
+		check(registeredBlocks) { "Didn't register items yet" }
-			null to _block::get,
+		LazyMap(blockMap.map { it.key to it.value::get }.toMutableList().also { it.add(null to _block::get) })
-			DyeColor.WHITE to _whiteBlock::get,
-			DyeColor.ORANGE to _orangeBlock::get,
-			DyeColor.MAGENTA to _magentaBlock::get,
-			DyeColor.LIGHT_BLUE to _lightBlueBlock::get,
-			DyeColor.YELLOW to _yellowBlock::get,
-			DyeColor.LIME to _limeBlock::get,
-			DyeColor.PINK to _pinkBlock::get,
-			DyeColor.GRAY to _grayBlock::get,
-			DyeColor.LIGHT_GRAY to _lightGrayBlock::get,
-			DyeColor.CYAN to _cyanBlock::get,
-			DyeColor.PURPLE to _purpleBlock::get,
-			DyeColor.BLUE to _blueBlock::get,
-			DyeColor.BROWN to _brownBlock::get,
-			DyeColor.GREEN to _greenBlock::get,
-			DyeColor.RED to _redBlock::get,
-			DyeColor.BLACK to _blackBlock::get,
-		)
 	}
 
-	val mappedColoredItemsAll: Map<DyeColor?, Item> by lazy {
+	val allItems: Map<DyeColor?, Item> by lazy {
-		LazyMap(
+		check(registeredItems) { "Didn't register items yet" }
-			null to _item::get,
+		LazyMap(itemMap.map { it.key to it.value::get }.toMutableList().also { it.add(null to _item::get) })
-			DyeColor.WHITE to _whiteItem::get,
-			DyeColor.ORANGE to _orangeItem::get,
-			DyeColor.MAGENTA to _magentaItem::get,
-			DyeColor.LIGHT_BLUE to _lightBlueItem::get,
-			DyeColor.YELLOW to _yellowItem::get,
-			DyeColor.LIME to _limeItem::get,
-			DyeColor.PINK to _pinkItem::get,
-			DyeColor.GRAY to _grayItem::get,
-			DyeColor.LIGHT_GRAY to _lightGrayItem::get,
-			DyeColor.CYAN to _cyanItem::get,
-			DyeColor.PURPLE to _purpleItem::get,
-			DyeColor.BLUE to _blueItem::get,
-			DyeColor.BROWN to _brownItem::get,
-			DyeColor.GREEN to _greenItem::get,
-			DyeColor.RED to _redItem::get,
-			DyeColor.BLACK to _blackItem::get,
-		)
-	}
-
-	val blocks: List<Block> by lazy {
-		LazyList(
-			_block::get,
-
-			_whiteBlock::get,
-			_orangeBlock::get,
-			_magentaBlock::get,
-			_lightBlueBlock::get,
-			_yellowBlock::get,
-			_limeBlock::get,
-			_pinkBlock::get,
-			_grayBlock::get,
-			_lightGrayBlock::get,
-			_cyanBlock::get,
-			_purpleBlock::get,
-			_blueBlock::get,
-			_brownBlock::get,
-			_greenBlock::get,
-			_redBlock::get,
-			_blackBlock::get,
-		)
-	}
-
-	val items: List<Item> by lazy {
-		LazyList(
-			_item::get,
-
-			_whiteItem::get,
-			_orangeItem::get,
-			_magentaItem::get,
-			_lightBlueItem::get,
-			_yellowItem::get,
-			_limeItem::get,
-			_pinkItem::get,
-			_grayItem::get,
-			_lightGrayItem::get,
-			_cyanItem::get,
-			_purpleItem::get,
-			_blueItem::get,
-			_brownItem::get,
-			_greenItem::get,
-			_redItem::get,
-			_blackItem::get,
-		)
 	}
 
 	override fun registerBlocks(registry: DeferredRegister<Block>) {
-		_block = registry.register(baseName) { provider.invoke(DyeColor.WHITE) }
+		_block = registry.register(baseName) { provider.invoke(null) }
-
 		super.registerBlocks(registry)
 	}
 
 	override fun registerItems(registry: DeferredRegister<Item>) {
-		_item = registry.register(baseName) {
+		_item = registry.register(baseName) { BlockItem(_block.get(), Item.Properties().tab(baseItemGroup).stacksTo(64)) }
-			BlockItem(
-				_block.get(),
-				Item.Properties().tab(baseItemGroup).stacksTo(64)
-			)
-		}
-
 		super.registerItems(registry)
 	}
 

src/main/kotlin/ru/dbotthepony/mc/otm/registry/objects/StripedColoredDecorativeBlock.kt

@@ -25,34 +25,22 @@ class StripedColoredDecorativeBlock(
 	private val mapItems = EnumMap<DyeColor, EnumMap<DyeColor, RegistryObject<Item>>>(DyeColor::class.java)
 
 	fun getBlockNullable(base: DyeColor, stripe: DyeColor): Block? {
-		if (!registeredBlocks) {
+		check(registeredBlocks) { "Didn't register items yet" }
-			throw IllegalStateException("Not yet registered blocks")
-		}
-
 		return mapBlocks.get(base)?.get(stripe)?.get()
 	}
 
 	fun getItemNullable(base: DyeColor, stripe: DyeColor): Item? {
-		if (!registeredItems) {
+		check(registeredItems) { "Didn't register items yet" }
-			throw IllegalStateException("Not yet registered items")
-		}
-
 		return mapItems.get(base)?.get(stripe)?.get()
 	}
 
 	fun getBlock(base: DyeColor, stripe: DyeColor): Block {
-		if (!registeredBlocks) {
+		check(registeredBlocks) { "Didn't register items yet" }
-			throw IllegalStateException("Not yet registered blocks")
-		}
-
 		return mapBlocks.get(base)?.get(stripe)?.get() ?: throw NoSuchElementException("$base colored $stripe striped block does not exist")
 	}
 
 	fun getItem(base: DyeColor, stripe: DyeColor): Item {
-		if (!registeredItems) {
+		check(registeredItems) { "Didn't register items yet" }
-			throw IllegalStateException("Not yet registered items")
-		}
-
 		return mapItems.get(base)?.get(stripe)?.get() ?: throw NoSuchElementException("$base colored $stripe striped item does not exist")
 	}
 
@@ -62,78 +50,38 @@ class StripedColoredDecorativeBlock(
 	var registeredBlocks = false
 		private set
 
-	val items: List<Item> by lazy {
+	val items: Map<DyeColor, Map<DyeColor, Item>> by lazy {
-		if (!registeredItems) {
+		check(registeredItems) { "Didn't register items yet" }
-			throw IllegalStateException("Not yet registered items")
-		}
-
-		val build = ImmutableList.builder<() -> Item>()
-
-		for (children in mapItems.values) {
-			for (registryObject in children.values) {
-				build.add(registryObject::get)
-			}
-		}
-
-		LazyList(build.build())
-	}
-
-	val blocks: List<Block> by lazy {
-		if (!registeredBlocks) {
-			throw IllegalStateException("Not yet registered blocks")
-		}
-
-		val build = ImmutableList.builder<() -> Block>()
-
-		for (children in mapBlocks.values) {
-			for (registryObject in children.values) {
-				build.add(registryObject::get)
-			}
-		}
-
-		LazyList(build.build())
-	}
-
-	val mappedBlocks: Map<DyeColor, Map<DyeColor, Block>> by lazy {
-		if (!registeredBlocks) {
-			throw IllegalStateException("Not yet registered blocks")
-		}
-
-		val builder = ImmutableMap.Builder<DyeColor, Map<DyeColor, Block>>()
-
-		for ((base, children) in mapBlocks) {
-			val result = ArrayList<Pair<DyeColor, () -> Block>>()
-
-			for ((stripe, registryObject) in children) {
-				result.add(stripe to registryObject::get)
-			}
-
-			builder.put(base, LazyMap(result))
-		}
-
-		builder.build()
-	}
-
-	val mappedItems: Map<DyeColor, Map<DyeColor, Item>> by lazy {
-		if (!registeredItems) {
-			throw IllegalStateException("Not yet registered items")
-		}
-
 		val builder = ImmutableMap.Builder<DyeColor, Map<DyeColor, Item>>()
 
 		for ((base, children) in mapItems) {
-			val result = ArrayList<Pair<DyeColor, () -> Item>>()
+			builder.put(base, LazyMap(children.map { it.key to it.value::get }))
-
-			for ((stripe, registryObject) in children) {
-				result.add(stripe to registryObject::get)
-			}
-
-			builder.put(base, LazyMap(result))
 		}
 
 		builder.build()
 	}
 
+	val blocks: Map<DyeColor, Map<DyeColor, Block>> by lazy {
+		check(registeredBlocks) { "Didn't register items yet" }
+		val builder = ImmutableMap.Builder<DyeColor, Map<DyeColor, Block>>()
+
+		for ((base, children) in mapBlocks) {
+			builder.put(base, LazyMap(children.map { it.key to it.value::get }))
+		}
+
+		builder.build()
+	}
+
+	val flatItems: List<Item> by lazy {
+		check(registeredItems) { "Didn't register items yet" }
+		LazyList(mapItems.flatMap { it.value.values }.map { it::get })
+	}
+
+	val flatBlocks: List<Block> by lazy {
+		check(registeredBlocks) { "Didn't register items yet" }
+		LazyList(mapBlocks.flatMap { it.value.values }.map { it::get })
+	}
+
 	fun registerItems(registry: DeferredRegister<Item>) {
 		for (base in DyeColor.values()) {
 			for (stripe in DyeColor.values()) {

src/main/resources/assets/overdrive_that_matters/blockstates/cargo_crate.json

@@ -1,36 +0,0 @@
-{
-	"variants": {
-		"facing=north,open=true": {
-			"model": "overdrive_that_matters:block/cargo_crate_open",
-			"y": 0
-		},
-		"facing=north,open=false": {
-			"model": "overdrive_that_matters:block/cargo_crate_closed",
-			"y": 0
-		},
-		"facing=south,open=true": {
-			"model": "overdrive_that_matters:block/cargo_crate_open",
-			"y": 180
-		},
-		"facing=south,open=false": {
-			"model": "overdrive_that_matters:block/cargo_crate_closed",
-			"y": 180
-		},
-		"facing=west,open=true": {
-			"model": "overdrive_that_matters:block/cargo_crate_open",
-			"y": 270
-		},
-		"facing=west,open=false": {
-			"model": "overdrive_that_matters:block/cargo_crate_closed",
-			"y": 270
-		},
-		"facing=east,open=true": {
-			"model": "overdrive_that_matters:block/cargo_crate_open",
-			"y": 90
-		},
-		"facing=east,open=false": {
-			"model": "overdrive_that_matters:block/cargo_crate_closed",
-			"y": 90
-		}
-	}
-}