diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt
index 2aedb738a..8f9da3198 100644
--- a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt
+++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/DataGen.kt
@@ -25,6 +25,7 @@ import ru.dbotthepony.mc.otm.datagen.blocks.MatterBankProvider
import ru.dbotthepony.mc.otm.datagen.blocks.MatteryBlockStateProvider
import ru.dbotthepony.mc.otm.datagen.loot.LootModifiers
import ru.dbotthepony.mc.otm.datagen.items.MatteryItemModelProvider
+import ru.dbotthepony.mc.otm.datagen.lang.AddEnglishLanguage
import ru.dbotthepony.mc.otm.datagen.loot.LootTables
import ru.dbotthepony.mc.otm.datagen.loot.TileNbtCopy
import ru.dbotthepony.mc.otm.datagen.models.BlockMatteryModelProvider
@@ -42,6 +43,7 @@ object DataGen {
private lateinit var lootTableProvider: LootTables
private lateinit var recipeProvider: MatteryRecipeProvider
private lateinit var lootModifier: LootModifiers
+ private lateinit var languageProvider: MatteryLanguageProvider
private fun decorativeCubeAll(vararg blocks: Block) {
blockModelProvider.decorativeCubeAll(*blocks)
@@ -111,6 +113,17 @@ object DataGen {
}
private fun decoratives(list: ColoredDecorativeBlock) {
+ for (block in list.coloredBlocks) {
+ decorativeCubeAll(block)
+ lootTableProvider.simpleBlock(block)
+ }
+
+ for (item in list.coloredItems) {
+ itemModelProvider.block(item)
+ }
+ }
+
+ private fun decoratives(list: DecorativeBlock) {
for (block in list.blocks) {
decorativeCubeAll(block)
lootTableProvider.simpleBlock(block)
@@ -131,6 +144,9 @@ object DataGen {
lootTableProvider = LootTables(event.generator)
recipeProvider = MatteryRecipeProvider(event.generator)
lootModifier = LootModifiers(event.generator)
+ languageProvider = MatteryLanguageProvider(event.generator)
+
+ AddEnglishLanguage(languageProvider)
event.generator.addProvider(blockModelProvider)
event.generator.addProvider(itemModelProvider)
@@ -143,16 +159,13 @@ object DataGen {
decorativeCubeAll(MBlocks.CRATE_LIST)
decorativeCubeAll(MBlocks.CARBON_FIBRE_BLOCK)
- decorativeCubeAll(MBlocks.TRITANIUM_BLOCK)
- decorativeCubeAll(MBlocks.VENT)
- decorativeCubeAll(MBlocks.VENT_ALTERNATIVE)
decoratives(MRegistry.TRITANIUM_BLOCK)
decoratives(MRegistry.FLOOR_TILES)
decoratives(MRegistry.VENT)
decoratives(MRegistry.VENT_ALTERNATIVE)
- for (glass in MBlocks.INDUSTRIAL_GLASS_LIST) {
+ for (glass in MRegistry.INDUSTRIAL_GLASS.blocks) {
decorativeCubeAll(glass)
}
@@ -165,7 +178,7 @@ object DataGen {
blockModelProvider.resourceCubeAll(MBlocks.DEEPSLATE_TRITANIUM_ORE)
blockModelProvider.lambda {
- for (crate in MBlocks.CARGO_CRATES_COLORED) {
+ for (crate in MRegistry.CARGO_CRATES.coloredBlocks) {
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}")
@@ -178,8 +191,8 @@ object DataGen {
decorativeColumn(MBlocks.TRITANIUM_STRIPED_BLOCK, "tritanium_striped_block", "tritanium_block")
- for ((i, glass) in MBlocks.INDUSTRIAL_GLASS_PANE_LIST.withIndex()) {
- val name = MBlocks.INDUSTRIAL_GLASS_LIST[i].registryName!!.path
+ for ((i, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.blocks.withIndex()) {
+ val name = MRegistry.INDUSTRIAL_GLASS.blocks[i].registryName!!.path
val textureSide = ResourceLocation(MOD_ID, "block/decorative/$name")
val textureRailing = textureSide
pane(glass, textureSide, textureRailing)
@@ -267,7 +280,7 @@ object DataGen {
block(MBlocks.MATTER_RECYCLER)
lambda {
- for (crate in MBlocks.CARGO_CRATES_COLORED) {
+ for (crate in MRegistry.CARGO_CRATES.coloredBlocks) {
getVariantBuilder(crate).forAllStates {
return@forAllStates arrayOf(
ConfiguredModel.builder()
@@ -357,20 +370,18 @@ object DataGen {
block(MItems.TRITANIUM_STRIPED_BLOCK)
block(MItems.TRITANIUM_RAW_BLOCK)
block(MItems.ITEM_MONITOR)
- block(MItems.TRITANIUM_BLOCK)
- block(MItems.VENT)
- block(MItems.VENT_ALTERNATIVE)
- for (glass in MItems.INDUSTRIAL_GLASS_LIST) {
- block(glass)
- }
+ MRegistry.VENT.items.forEach(this::block)
+ MRegistry.VENT_ALTERNATIVE.items.forEach(this::block)
+ MRegistry.TRITANIUM_BLOCK.items.forEach(this::block)
+ MRegistry.INDUSTRIAL_GLASS.items.forEach(this::block)
for (block in MItems.TRITANIUM_STRIPED_BLOCKS) {
block(block)
}
- for ((i, glass) in MItems.INDUSTRIAL_GLASS_PANE_LIST.withIndex()) {
- generated(glass, ResourceLocation(MOD_ID, "block/decorative/${MItems.INDUSTRIAL_GLASS_LIST[i].registryName!!.path}"))
+ for ((i, glass) in MRegistry.INDUSTRIAL_GLASS_PANE.items.withIndex()) {
+ generated(glass, ResourceLocation(MOD_ID, "block/decorative/${MRegistry.INDUSTRIAL_GLASS.items[i].registryName!!.path}"))
}
blocks(MItems.CRATE_LIST)
@@ -400,7 +411,7 @@ object DataGen {
generated(MItems.MATTER_DUST)
- for (item in MItems.CARGO_CRATES) {
+ for (item in MRegistry.CARGO_CRATES.items) {
block(item, "${item.registryName!!.path}_closed")
}
@@ -513,15 +524,12 @@ object DataGen {
with(lootTableProvider) {
simpleBlocks(MBlocks.CRATE_LIST)
- for (block in MBlocks.CARGO_CRATES) {
- simpleBlock(block)
- }
+ MRegistry.CARGO_CRATES.blocks.forEach(this::simpleBlock)
+ MRegistry.INDUSTRIAL_GLASS.blocks.forEach(this::simpleBlock)
+ MRegistry.INDUSTRIAL_GLASS_PANE.blocks.forEach(this::simpleBlock)
simpleBlock(MBlocks.CARBON_FIBRE_BLOCK)
simpleBlock(MBlocks.TRITANIUM_RAW_BLOCK)
- simpleBlock(MBlocks.TRITANIUM_BLOCK)
- simpleBlock(MBlocks.VENT)
- simpleBlock(MBlocks.VENT_ALTERNATIVE)
simpleBlock(MBlocks.TRITANIUM_STRIPED_BLOCK)
simpleBlock(MBlocks.MATTER_CABLE)
simpleBlock(MBlocks.GRAVITATION_STABILIZER)
@@ -549,37 +557,8 @@ object DataGen {
tile(MBlocks.MATTER_BOTTLER, TileNbtCopy("energy"), TileNbtCopy("battery_container"), TileNbtCopy("work_slots"), TileNbtCopy("work_flow"), TileNbtCopy("matter"))
}
- with(lootTableProvider) {
- for (glass in MBlocks.INDUSTRIAL_GLASS_LIST) {
- simpleBlock(glass)
- }
-
- for (glass in MBlocks.INDUSTRIAL_GLASS_PANE_LIST) {
- simpleBlock(glass)
- }
- }
-
with(recipeProvider) {
- val crates = arrayOf(
- DyeColor.WHITE to MBlocks.CARGO_CRATE_WHITE,
- DyeColor.ORANGE to MBlocks.CARGO_CRATE_ORANGE,
- DyeColor.MAGENTA to MBlocks.CARGO_CRATE_MAGENTA,
- DyeColor.LIGHT_BLUE to MBlocks.CARGO_CRATE_LIGHT_BLUE,
- DyeColor.YELLOW to MBlocks.CARGO_CRATE_YELLOW,
- DyeColor.LIME to MBlocks.CARGO_CRATE_LIME,
- DyeColor.PINK to MBlocks.CARGO_CRATE_PINK,
- DyeColor.GRAY to MBlocks.CARGO_CRATE_GRAY,
- DyeColor.LIGHT_GRAY to MBlocks.CARGO_CRATE_LIGHT_GRAY,
- DyeColor.CYAN to MBlocks.CARGO_CRATE_CYAN,
- DyeColor.PURPLE to MBlocks.CARGO_CRATE_PURPLE,
- DyeColor.BLUE to MBlocks.CARGO_CRATE_BLUE,
- DyeColor.BROWN to MBlocks.CARGO_CRATE_BROWN,
- DyeColor.GREEN to MBlocks.CARGO_CRATE_GREEN,
- DyeColor.RED to MBlocks.CARGO_CRATE_RED,
- DyeColor.BLACK to MBlocks.CARGO_CRATE_BLACK,
- )
-
- for ((dye, crate) in crates) {
+ for ((dye, crate) in MRegistry.CARGO_CRATES.mappedColoredBlocks) {
lambda { _, consumer ->
ShapedRecipeBuilder(crate, 1)
.define('P', MItemTags.PLATE_TRITANIUM)
@@ -600,7 +579,7 @@ object DataGen {
}
lambda { _, consumer ->
- ShapedRecipeBuilder(MItems.CARGO_CRATE, 1)
+ ShapedRecipeBuilder(MRegistry.CARGO_CRATES.item, 1)
.define('P', MItemTags.PLATE_TRITANIUM)
.define('C', Tags.Items.CHESTS)
.pattern("PCP")
@@ -628,17 +607,17 @@ object DataGen {
}
lambda { _, consumer ->
- ShapelessRecipeBuilder(MItems.INDUSTRIAL_GLASS, 8)
+ ShapelessRecipeBuilder(MRegistry.INDUSTRIAL_GLASS.item, 8)
.requires(net.minecraft.world.item.Items.GLASS, 8)
.requires(MItemTags.PLATE_TRITANIUM)
.unlockedBy("has_plate", has(MItemTags.PLATE_TRITANIUM))
.unlockedBy("has_glass", has(net.minecraft.world.item.Items.GLASS))
.save(consumer)
- ShapedRecipeBuilder(MItems.INDUSTRIAL_GLASS_PANE, 16)
- .define('#', MItems.INDUSTRIAL_GLASS)
+ ShapedRecipeBuilder(MRegistry.INDUSTRIAL_GLASS_PANE.item, 16)
+ .define('#', MRegistry.INDUSTRIAL_GLASS.item)
.pattern("###").pattern("###")
- .unlockedBy("has_tritanium_glass", has(MItems.INDUSTRIAL_GLASS))
+ .unlockedBy("has_tritanium_glass", has(MRegistry.INDUSTRIAL_GLASS.item))
.save(consumer)
val mapping = arrayOf(
@@ -680,15 +659,15 @@ object DataGen {
)
for ((i, tag) in mapping.withIndex()) {
- val item = MItems.INDUSTRIAL_GLASS_LIST[i + 1]
- val paneItem = MItems.INDUSTRIAL_GLASS_PANE_LIST[i + 1]
+ val item = MRegistry.INDUSTRIAL_GLASS.coloredItems[i]
+ val paneItem = MRegistry.INDUSTRIAL_GLASS_PANE.coloredItems[i]
val mappedVanilla = mappingUpgradeVanilla[i]
// обычная покраска
ShapelessRecipeBuilder(item, 8)
- .requires(MItems.INDUSTRIAL_GLASS, 8)
+ .requires(MRegistry.INDUSTRIAL_GLASS.item, 8)
.requires(tag)
- .unlockedBy("has_tritanium_glass", has(MItems.INDUSTRIAL_GLASS))
+ .unlockedBy("has_tritanium_glass", has(MRegistry.INDUSTRIAL_GLASS.item))
.save(consumer)
// апгрейд ванильного крашенного стекла
@@ -700,9 +679,9 @@ object DataGen {
.save(consumer, ResourceLocation(MOD_ID, "${item.registryName!!.path}_upgrade"))
ShapelessRecipeBuilder(paneItem, 8)
- .requires(MItems.INDUSTRIAL_GLASS_PANE, 8)
+ .requires(MRegistry.INDUSTRIAL_GLASS_PANE.item, 8)
.requires(tag)
- .unlockedBy("has_tritanium_glass_pane", has(MItems.INDUSTRIAL_GLASS_PANE))
+ .unlockedBy("has_tritanium_glass_pane", has(MRegistry.INDUSTRIAL_GLASS_PANE.item))
.save(consumer)
ShapedRecipeBuilder(paneItem, 16)
diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/MatteryLanguageProvider.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/MatteryLanguageProvider.kt
new file mode 100644
index 000000000..f0e10ba0d
--- /dev/null
+++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/MatteryLanguageProvider.kt
@@ -0,0 +1,241 @@
+package ru.dbotthepony.mc.otm.datagen
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap
+import net.minecraft.data.DataGenerator
+import net.minecraft.world.effect.MobEffect
+import net.minecraft.world.entity.EntityType
+import net.minecraft.world.item.Item
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.enchantment.Enchantment
+import net.minecraft.world.level.block.Block
+import net.minecraftforge.common.data.LanguageProvider
+import ru.dbotthepony.mc.otm.OverdriveThatMatters
+import ru.dbotthepony.mc.otm.android.AndroidFeatureType
+import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.registry.ColoredDecorativeBlock
+
+class MatteryLanguageProvider(private val gen: DataGenerator) {
+ private inner class Slave(language: String) : LanguageProvider(gen, OverdriveThatMatters.MOD_ID, language) {
+ init {
+ gen.addProvider(this)
+ }
+
+ override fun addTranslations() {}
+ }
+
+ private val slaves = Object2ObjectArrayMap<String, Slave>()
+
+ inner class Builder(language: String) {
+ val slave: LanguageProvider = slaves.computeIfAbsent(language, ::Slave)
+
+ fun add(key: String, value: String) = slave.add(key, value)
+ fun add(key: Block, value: String) = slave.add(key, value)
+ fun add(key: Block, suffix: String, value: String) = slave.add("${key.descriptionId}.${suffix}", value)
+ fun add(key: Item, value: String) = slave.add(key, value)
+ fun add(key: Item, suffix: String, value: String) = slave.add("${key.descriptionId}.${suffix}", value)
+ fun add(key: ItemStack, value: String) = slave.add(key, value)
+ fun add(key: Enchantment, value: String) = slave.add(key, value)
+ fun add(key: MobEffect, value: String) = slave.add(key, value)
+ fun add(key: EntityType<*>, value: String) = slave.add(key, value)
+
+ fun death(key: String, value: String) = slave.add("death.attack.$key", value)
+ fun stat(key: String, value: String) = slave.add("stat.${OverdriveThatMatters.MOD_ID}.$key", value)
+
+ fun add(key: AndroidResearchType<*>, value: String) = slave.add(key.displayId, value)
+ fun add(key: AndroidResearchType<*>, suffix: String, value: String) = slave.add("${key.displayId}.$suffix", value)
+
+ fun add(key: AndroidFeatureType<*>, value: String) = slave.add(key.displayId, value)
+ fun add(key: AndroidFeatureType<*>, suffix: String, value: String) = slave.add("${key.displayId}.$suffix", value)
+
+ fun misc(key: String, value: String) = slave.add("otm.$key", value)
+ fun sound(key: String, value: String) = slave.add("otm.sound.$key", value)
+ }
+
+ inner class Colors(
+ language: String,
+
+ val white: String,
+ val orange: String,
+ val magenta: String,
+ val lightBlue: String,
+ val yellow: String,
+ val lime: String,
+ val pink: String,
+ val gray: String,
+ val lightGray: String,
+ val cyan: String,
+ val purple: String,
+ val blue: String,
+ val brown: String,
+ val green: String,
+ val red: String,
+ val black: String,
+ ) {
+ val slave: LanguageProvider = slaves.computeIfAbsent(language, ::Slave)
+
+ fun add(list: ColoredDecorativeBlock, toFormat: String) {
+ slave.add(list.whiteBlock, toFormat.format(white))
+ slave.add(list.orangeBlock, toFormat.format(orange))
+ 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(
+ whiteBlock: Block,
+ orangeBlock: Block,
+ magentaBlock: Block,
+ lightBlueBlock: Block,
+ yellowBlock: Block,
+ limeBlock: Block,
+ pinkBlock: Block,
+ grayBlock: Block,
+ lightGrayBlock: Block,
+ cyanBlock: Block,
+ purpleBlock: Block,
+ blueBlock: Block,
+ brownBlock: Block,
+ greenBlock: Block,
+ redBlock: Block,
+ blackBlock: Block,
+
+ toFormat: String,
+ ) {
+ slave.add(whiteBlock, toFormat.format(white))
+ slave.add(orangeBlock, toFormat.format(orange))
+ slave.add(magentaBlock, toFormat.format(magenta))
+ slave.add(lightBlueBlock, toFormat.format(lightBlue))
+ slave.add(yellowBlock, toFormat.format(yellow))
+ slave.add(limeBlock, toFormat.format(lime))
+ slave.add(pinkBlock, toFormat.format(pink))
+ slave.add(grayBlock, toFormat.format(gray))
+ slave.add(lightGrayBlock, toFormat.format(lightGray))
+ slave.add(cyanBlock, toFormat.format(cyan))
+ slave.add(purpleBlock, toFormat.format(purple))
+ slave.add(blueBlock, toFormat.format(blue))
+ slave.add(brownBlock, toFormat.format(brown))
+ slave.add(greenBlock, toFormat.format(green))
+ slave.add(redBlock, toFormat.format(red))
+ slave.add(blackBlock, toFormat.format(black))
+ }
+
+ fun add(
+ whiteItem: Item,
+ orangeItem: Item,
+ magentaItem: Item,
+ lightBlueItem: Item,
+ yellowItem: Item,
+ limeItem: Item,
+ pinkItem: Item,
+ grayItem: Item,
+ lightGrayItem: Item,
+ cyanItem: Item,
+ purpleItem: Item,
+ blueItem: Item,
+ brownItem: Item,
+ greenItem: Item,
+ redItem: Item,
+ blackItem: Item,
+
+ toFormat: String,
+ ) {
+ slave.add(whiteItem, toFormat.format(white))
+ slave.add(orangeItem, toFormat.format(orange))
+ slave.add(magentaItem, toFormat.format(magenta))
+ slave.add(lightBlueItem, toFormat.format(lightBlue))
+ slave.add(yellowItem, toFormat.format(yellow))
+ slave.add(limeItem, toFormat.format(lime))
+ slave.add(pinkItem, toFormat.format(pink))
+ slave.add(grayItem, toFormat.format(gray))
+ slave.add(lightGrayItem, toFormat.format(lightGray))
+ slave.add(cyanItem, toFormat.format(cyan))
+ slave.add(purpleItem, toFormat.format(purple))
+ slave.add(blueItem, toFormat.format(blue))
+ slave.add(brownItem, toFormat.format(brown))
+ slave.add(greenItem, toFormat.format(green))
+ slave.add(redItem, toFormat.format(red))
+ slave.add(blackItem, toFormat.format(black))
+ }
+
+ fun addBlocks(list: List<Block>, toFormat: String) {
+ add(
+ whiteBlock = list[0],
+ orangeBlock = list[1],
+ magentaBlock = list[2],
+ lightBlueBlock = list[3],
+ yellowBlock = list[4],
+ limeBlock = list[5],
+ pinkBlock = list[6],
+ grayBlock = list[7],
+ lightGrayBlock = list[8],
+ cyanBlock = list[9],
+ purpleBlock = list[10],
+ blueBlock = list[11],
+ brownBlock = list[12],
+ greenBlock = list[13],
+ redBlock = list[14],
+ blackBlock = list[15],
+
+ toFormat = toFormat
+ )
+ }
+
+ fun addItems(list: List<Item>, toFormat: String) {
+ add(
+ whiteItem = list[0],
+ orangeItem = list[1],
+ magentaItem = list[2],
+ lightBlueItem = list[3],
+ yellowItem = list[4],
+ limeItem = list[5],
+ pinkItem = list[6],
+ grayItem = list[7],
+ lightGrayItem = list[8],
+ cyanItem = list[9],
+ purpleItem = list[10],
+ blueItem = list[11],
+ brownItem = list[12],
+ greenItem = list[13],
+ redItem = list[14],
+ blackItem = list[15],
+
+ toFormat = toFormat
+ )
+ }
+ }
+
+ val decorativeEnglish = Colors("en_us",
+ "White",
+ "Orange",
+ "Magenta",
+ "Light Blue",
+ "Yellow",
+ "Lime",
+ "Pink",
+ "Gray",
+ "Light Gray",
+ "Cyan",
+ "Purple",
+ "Blue",
+ "Brown",
+ "Green",
+ "Red",
+ "Black",
+ )
+
+ val english = Builder("en_us")
+ val russian = Builder("ru_ru")
+
+ fun getProvider(language: String): LanguageProvider = slaves.computeIfAbsent(language, ::Slave)
+}
diff --git a/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/English.kt b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/English.kt
new file mode 100644
index 000000000..b51805d82
--- /dev/null
+++ b/src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/English.kt
@@ -0,0 +1,401 @@
+package ru.dbotthepony.mc.otm.datagen.lang
+
+import ru.dbotthepony.mc.otm.datagen.MatteryLanguageProvider
+import ru.dbotthepony.mc.otm.registry.*
+
+private fun decoratives(provider: MatteryLanguageProvider) {
+ provider.decorativeEnglish.add(MRegistry.VENT, "%s Vent")
+ provider.decorativeEnglish.add(MRegistry.VENT_ALTERNATIVE, "%s Alternative Vent")
+
+ provider.decorativeEnglish.add(MRegistry.TRITANIUM_BLOCK, "%s Tritanium Block")
+ provider.decorativeEnglish.add(MRegistry.FLOOR_TILES, "%s Floor Tiles")
+
+ provider.decorativeEnglish.add(MRegistry.INDUSTRIAL_GLASS, "%s Stained Industrial Glass")
+ provider.decorativeEnglish.add(MRegistry.INDUSTRIAL_GLASS_PANE, "%s Stained Industrial Glass Pane")
+
+ provider.decorativeEnglish.add(MRegistry.CARGO_CRATES, "%s Cargo Crate")
+
+ with(provider.english) {
+ add(MRegistry.CARGO_CRATES.block, "Cargo Crate")
+ add(MRegistry.TRITANIUM_BLOCK.block, "Tritanium Block")
+
+ add(MRegistry.INDUSTRIAL_GLASS.block, "Industrial Glass")
+ add(MRegistry.INDUSTRIAL_GLASS_PANE.block, "Industrial Glass Pane")
+
+ add(MRegistry.VENT.block, "Vent")
+ add(MRegistry.VENT_ALTERNATIVE.block, "Alternative Vent")
+ }
+}
+
+private fun sounds(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ sound("rifle_shoot", "Plasma rifle fires")
+ sound("plasma_weapon_overheat", "Plasma weapon overheats")
+ sound("player_become_android", "Player became android")
+ }
+}
+
+private fun misc(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ misc("death_reason", "Decommissioned!")
+
+ misc("item.blackhole_immunity", "Negates gravitational effects of singularities")
+
+ misc("suffix.merge", "%s %s")
+
+ misc("suffix.kilo", "%s k%s")
+ misc("suffix.mega", "%s M%s")
+ misc("suffix.giga", "%s G%s")
+ misc("suffix.tera", "%s T%s")
+ misc("suffix.peta", "%s P%s")
+ misc("suffix.exa", "%s E%s")
+ misc("suffix.zetta", "%s Z%s")
+ misc("suffix.yotta", "%s Y%s")
+
+ misc("suffix.deci", "%s d%s")
+ misc("suffix.centi", "%s c%s")
+ misc("suffix.milli", "%s m%s")
+ misc("suffix.micro", "%s μ%s")
+ misc("suffix.nano", "%s n%s")
+ misc("suffix.pico", "%s p%s")
+ misc("suffix.femto", "%s f%s")
+ misc("suffix.atto", "%s a%s")
+ misc("suffix.zepto", "%s z%s")
+ misc("suffix.yocto", "%s y%s")
+
+ misc("suffix_raw.kilo", "k")
+ misc("suffix_raw.mega", "M")
+ misc("suffix_raw.giga", "G")
+ misc("suffix_raw.tera", "T")
+ misc("suffix_raw.peta", "P")
+ misc("suffix_raw.exa", "E")
+ misc("suffix_raw.zetta", "Z")
+ misc("suffix_raw.yotta", "Y")
+ misc("suffix_raw.deci", "d")
+ misc("suffix_raw.centi", "c")
+ misc("suffix_raw.milli", "m")
+ misc("suffix_raw.micro", "μ")
+ misc("suffix_raw.nano", "n")
+ misc("suffix_raw.pico", "p")
+ misc("suffix_raw.femto", "f")
+ misc("suffix_raw.atto", "a")
+ misc("suffix_raw.zepto", "z")
+ misc("suffix_raw.yocto", "y")
+
+ misc("container.matter_panel.increase_by", "+%s")
+ misc("container.matter_panel.decrease_by", "-%s")
+ misc("container.matter_panel.send", "Send")
+ misc("container.matter_panel.close", "Close")
+ misc("container.matter_panel.cancel_task", "Cancel task")
+ misc("container.matter_panel.cancel", "Cancel")
+ misc("container.matter_panel.label", "Replication request")
+ misc("container.matter_panel.task", "Ongoing replication task")
+ misc("container.matter_panel.task_line", "%s: %s | %s / %s")
+
+ misc("item.power.infinite.storage", "Stored energy: Infinity / Infinity")
+ misc("item.power.infinite.throughput", "Max I/O Infinite / Infinite")
+ misc("item.power.passed", "Passed energy: %s")
+ misc("item.power.average", "Average throughput: %s/t")
+ misc("item.power.last_20_ticks", "Last second: %s")
+ misc("item.power.last_tick", "Last tick: %s")
+
+ misc("item.power.normal.storage", "Stored energy: %s / %s")
+ misc("item.power.normal.throughput", "Max I/O %s / %s")
+
+ misc("item.pattern.stored", "Stored patterns: %s / %s")
+ misc("item.pattern.infinite.stored", "Stored patterns %s")
+ misc("item.pattern.line", "%s [%s%%]")
+ misc("item.pattern.research", "Researched: %s%%")
+
+ misc("item.matter.infinite", "Stored matter: Infinity / Infinity")
+ misc("item.matter.normal", "Stored matter: %s / %s")
+
+ misc("gui.matter_task.total", "Total: %s")
+ misc("gui.matter_task.required", "Left to be done: %s")
+ misc("gui.matter_task.in_progress", "In progress: %s")
+ misc("gui.matter_task.finished", "Finished: %s")
+
+ misc("pill.warning", "WARNING: This will INSTANTLY decommission you upon ingestion!")
+ misc("pill.android", "Take this pill and lose what is holding you back.")
+
+ misc("pill.humane", "Take this pill and wake up in bed none the wiser.")
+
+ misc("pill.oblivion", "Items and Experience spent on research is fully refunded.")
+ misc("pill.message_oblivion", "All android features are removed and all research refunded.")
+
+ misc("pill.heal", "Instantly restores 4 hearts upon ingestion, provides 2 min Absorption V and 8 seconds Regeneration III.")
+ misc("pill.heal_android", "Does nothing to androids.")
+
+ misc("pill.message", "Nothing happened, but you feel exhausted?.. Maybe get rest.")
+ misc("pill.message_finish", "§kONE OF US ONE OF US ONE OF US ONE OF US ONE OF US")
+
+ misc("gui.power.percentage_level", "Energy level: %s%%")
+ misc("gui.level", "%s / %s")
+ misc("gui.power.name", "MtJ")
+
+ misc("gui.power.burn_time", "Burn time left: %s ticks")
+
+ misc("gui.progress_widget", "Progress: %s%%")
+ misc("gui.progress_widget_stuck", "The machine can not work, check configuration")
+
+ misc("gui.total_raw", "Total:")
+
+ misc("gui.matter.percentage_level", "Matter level: %s%%")
+ misc("gui.matter.format", "Matter: %s")
+ misc("gui.matter.format_and_complexity", "%s / Complexity: %s")
+ misc("gui.matter.name", "MtU")
+
+ misc("gui.filter.is_whitelist", "Is Whitelist")
+ misc("gui.filter.match_nbt", "Match NBT")
+ misc("gui.filter.match_tag", "Match Tag")
+
+ misc("gui.android_research", "Research Tree")
+
+ misc("gui.pattern.percentage_level", "Fill level: %s%%")
+ misc("gui.pattern.format", "Stored patterns: %s / %s")
+
+ misc("gui.redstone.ignored", "Redstone mode: Ignored")
+ misc("gui.redstone.low", "Redstone mode: Low")
+ misc("gui.redstone.high", "Redstone mode: High")
+
+ misc("gui.redstone.ignored.description", "Redstone signal does not affect machine's function")
+ misc("gui.redstone.low.description", "Machine work if no redstone signal is present")
+ misc("gui.redstone.high.description", "Machine work only if any redstone signal is present")
+
+ misc("3d2d.gravitation_stabilizer.mass", "Singularity mass: %s")
+ misc("3d2d.gravitation_stabilizer.strength", "Gravitation strength: %s")
+
+ misc("android_station.research.researched", "Researched!")
+ misc("android_station.research.can_be_researched", "Ready to research!")
+ misc("android_station.research.can_not_be_researched", "Can not afford!")
+ misc("android_station.research.xp_cost", "Experience cost: %s levels")
+ misc("android_station.research.item", "Requires %s x%s")
+ misc("android_station.research.missing_predecessors", "%s needs to be researched first")
+
+ misc("filter.yes", "Yes")
+ misc("filter.no", "No")
+
+ misc("matter_bottler.switch_mode", "Switch work mode")
+
+ misc("container.matter_panel.number_input", "Input replication task count")
+ }
+}
+
+private fun death(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ death("otm_become_android", "%1\$s lost their humanity")
+ death("otm_become_humane", "%1\$s regained their humanity")
+ death("otm_event_horizon", "%1\$s never crossed event horizon")
+ death("otm_hawking_radiation", "%1\$s discovered Hawking radiation")
+ death("otm_emp", "%1\$s electronics' fried")
+
+ death("otm_become_android.player", "%1\$s lost their humanity whilst %2\$s tried to reason with them")
+ death("otm_become_humane.player", "%1\$s gained their humanity whilst %2\$s tried to reason with them")
+ death("otm_event_horizon.player", "%1\$s tried to cross event horizon whilst trying to escape %2\$s")
+ death("otm_hawking_radiation.player", "%1\$s disintegrated whilst fighting %2\$s")
+ death("otm_emp.player", "%1\$s blew fuzes of %2\$s")
+ death("otm_emp.player.item", "%1\$s blew fuzes of %2\$s using %3\$s")
+ }
+}
+
+private fun blocks(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ add(MBlocks.ANDROID_STATION, "Android Station")
+ add(MBlocks.BATTERY_BANK, "Battery Bank")
+ add(MBlocks.MATTER_DECOMPOSER, "Matter Decomposer")
+ add(MBlocks.MATTER_CAPACITOR_BANK, "Matter Capacitor Bank")
+ add(MBlocks.MATTER_CABLE, "Matter Network Cable")
+ add(MBlocks.PATTERN_STORAGE, "Pattern Storage")
+ add(MBlocks.MATTER_SCANNER, "Matter Scanner")
+ add(MBlocks.MATTER_PANEL, "Pattern Monitor")
+ add(MBlocks.MATTER_REPLICATOR, "Matter Replicator")
+ add(MBlocks.MATTER_BOTTLER, "Matter Bottler")
+ add(MBlocks.DRIVE_VIEWER, "Drive Viewer")
+ add(MBlocks.BLACK_HOLE, "Local Anomalous Singular Gravitation Field")
+
+ add(MBlocks.ENERGY_COUNTER, "Energy Counter")
+ add(MBlocks.ENERGY_COUNTER, "facing", "Input facing: %s")
+ add(MBlocks.ENERGY_COUNTER, "switch", "Switch input facing")
+ add(MBlocks.ENERGY_COUNTER, "limit", "I/O Limit. -1 means no limit")
+
+ add(MBlocks.CHEMICAL_GENERATOR, "Chemical Generator")
+ add(MBlocks.DRIVE_RACK, "Condensation Drive Rack")
+ add(MBlocks.ITEM_MONITOR, "Item Monitor")
+ add(MBlocks.PLATE_PRESS, "Plate Press")
+
+ add(MBlocks.MATTER_RECYCLER, "Matter Recycler")
+
+ add(MBlocks.CRATE_RED, "Red Container Block")
+ add(MBlocks.CRATE_BLUE, "Blue Container Block")
+ add(MBlocks.CRATE_GREEN, "Green Container Block")
+ add(MBlocks.CRATE_YELLOW, "Yellow Container Block")
+ add(MBlocks.CRATE_BLACK, "Black Container Block")
+ add(MBlocks.CRATE_PINK, "Pink Container Block")
+ add(MBlocks.CRATE_PURPLE, "Purple Container Block")
+
+ add(MBlocks.CARBON_FIBRE_BLOCK, "Carbon fibre Block")
+
+ add(MBlocks.TRITANIUM_STRIPED_BLOCK, "Tritanium Striped Block")
+ add(MBlocks.TRITANIUM_ORE, "Tritanium Ore")
+ add(MBlocks.DEEPSLATE_TRITANIUM_ORE, "Deepslate Tritanium Ore")
+ add(MBlocks.TRITANIUM_RAW_BLOCK, "Raw Tritanium Block")
+
+ add(MBlocks.STORAGE_CABLE, "Storage Cable")
+ add(MBlocks.STORAGE_POWER_SUPPLIER, "Storage Power Supplier")
+ add(MBlocks.STORAGE_BUS, "Storage Bus")
+ add(MBlocks.STORAGE_IMPORTER, "Storage Importer")
+ add(MBlocks.STORAGE_EXPORTER, "Storage Exporter")
+
+ add(MBlocks.GRAVITATION_STABILIZER, "Gravitation Stabilizer")
+ add(MBlocks.GRAVITATION_STABILIZER_LENS, "Gravitation Stabilizer Lens")
+ add(MBlocks.GRAVITATION_STABILIZER, "desc", "Reduces gravitation effects of singularities")
+ add(MBlocks.GRAVITATION_STABILIZER, "desc2", "Requires no power to operate")
+ add(MBlocks.GRAVITATION_STABILIZER, "desc3", "Keep in mind the effect of multiple stabilizers produce exponentially increasing result")
+ add(MBlocks.GRAVITATION_STABILIZER, "desc4", "Too weak gravitation field will cause singularity to melt and evaporate away very fast")
+ }
+}
+
+private fun items(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ add(MItems.NUTRIENT_PASTE, "Nutrient paste")
+
+ add(MItems.BLACK_HOLE_SCANNER, "Singularity Scanner")
+ add(MItems.BLACK_HOLE_SCANNER, "desc", "Scans singularities for their properties")
+ add(MItems.BLACK_HOLE_SCANNER, "desc2", "Hold in hand to determine mass of singularities")
+
+ add(MItems.GRAVITATION_FIELD_LIMITER, "Gravitation Field Limiter")
+ add(MItems.GRAVITATION_FIELD_SENSOR, "Gravitation Field Sensor")
+ add(MItems.PORTABLE_GRAVITATION_STABILIZER, "Portable Gravitation Stabilizer")
+
+ add(MItems.BATTERY_CRUDE, "Crude Battery")
+ add(MItems.BATTERY_BASIC, "Basic Battery")
+ add(MItems.BATTERY_NORMAL, "Ordinary Battery")
+ add(MItems.BATTERY_DENSE, "Dense Battery")
+ add(MItems.BATTERY_CAPACITOR, "Capacitor Battery")
+ add(MItems.BATTERY_CREATIVE, "Creative Battery")
+
+ add(MItems.TRITANIUM_SWORD, "Tritanium Sword")
+ add(MItems.TRITANIUM_PICKAXE, "Tritanium Pickaxe")
+ add(MItems.TRITANIUM_SHOVEL, "Tritanium Shovel")
+ add(MItems.TRITANIUM_AXE, "Tritanium Axe")
+ add(MItems.TRITANIUM_HOE, "Tritanium Hoe")
+
+ add(MItems.TRITANIUM_HELMET, "Tritanium Helmet")
+ add(MItems.TRITANIUM_CHESTPLATE, "Tritanium Chestplate")
+ add(MItems.TRITANIUM_PANTS, "Tritanium Leggings")
+ add(MItems.TRITANIUM_BOOTS, "Tritanium Boots")
+
+ add(MItems.TRITANIUM_INGOT, "Tritanium Ingot")
+ add(MItems.MATTER_IO_PORT, "Matter IO Port")
+ add(MItems.MATTER_TRANSFORM_MATRIX, "Matter Transformation Matrix")
+ add(MItems.ENERGY_BUS, "Energy Bus")
+ add(MItems.ELECTRIC_PARTS, "Electric Parts")
+ add(MItems.MACHINE_FRAME, "Machine Frame")
+ add(MItems.TRITANIUM_PLATE, "Tritanium Plate")
+ add(MItems.IRON_PLATE, "Iron Plate")
+ add(MItems.COPPER_WIRING, "Copper Wiring")
+ add(MItems.GOLD_WIRING, "Gold Wiring")
+ add(MItems.PORTABLE_CONDENSATION_DRIVE_CASING, "Portable Condensation Drive Casing")
+ add(MItems.PORTABLE_DENSE_CONDENSATION_DRIVE_CASING, "Portable Dense Condensation Drive Casing")
+ add(MItems.CIRCUIT_PLATING, "Circuit Plating")
+ add(MItems.BASIC_CONTROL_CIRCUIT, "Basic Control Circuit")
+ add(MItems.ADVANCED_CONTROL_CIRCUIT, "Advanced Control Circuit")
+
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "Gravitational Disruptor")
+
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description", "Once within close proximity of supermassive body, suppresses any gravity in it's radius")
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description2", "Allows collapse of black holes")
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description3", "Doesn't destroy any of mass singularity had acquired, which result in violent explosion of matter!")
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description4", "The explosion %s be contained by %s. Do not even attempt to contain it.")
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description4_clarification", "can not")
+ add(MItems.GRAVITATIONAL_DISRUPTOR, "description4_clarification2", "anything")
+
+ add(MItems.MATTER_DUST, "Matter Dust")
+ add(MItems.MATTER_DUST, "desc", "This item is product of failed decomposition or replication attempt")
+ add(MItems.MATTER_DUST, "desc2", "Throw into matter recycler to get some of it's value back!")
+ add(MItems.MATTER_DUST, "desc3", "Do not smell, throw at strangers or pour on donuts")
+
+ add(MItems.PILL_ANDROID, "Android Pill")
+ add(MItems.PILL_HUMANE, "Humane Pill")
+ add(MItems.PILL_OBLIVION, "Android Factory Reset Pill")
+ add(MItems.PILL_HEAL, "Medical Pill")
+
+ add(MItems.MATTER_CAPACITOR_PARTS, "Matter Capacitor Parts")
+ add(MItems.MATTER_CAPACITOR_BASIC, "Basic Matter Capacitor")
+ add(MItems.MATTER_CAPACITOR_NORMAL, "Matter Capacitor")
+ add(MItems.MATTER_CAPACITOR_DENSE, "Dense Matter Capacitor")
+ add(MItems.MATTER_CAPACITOR_CREATIVE, "Creative Matter Capacitor")
+
+ add(MItems.ENERGY_SWORD, "Powered Cake Slicer")
+ add(MItems.ENERGY_SWORD, "desc", "Needs power to operate")
+ add(MItems.ENERGY_SWORD, "desc2", "Deals extra damage to androids when powered")
+
+ add(MItems.PORTABLE_CONDENSATION_DRIVE, "Portable Condensation Drive")
+ add(MItems.PORTABLE_DENSE_CONDENSATION_DRIVE, "Portable Dense Condensation Drive")
+ add(MItems.PLASMA_RIFLE, "Plasma Rifle")
+ add(MItems.TRITANIUM_ORE_CLUMP, "Raw Tritanium")
+ add(MItems.PATTERN_DRIVE_NORMAL, "Pattern Drive")
+ add(MItems.PATTERN_DRIVE_CREATIVE, "Creative Pattern Drive")
+ }
+}
+
+private fun stats(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ stat("health_regenerated", "Damage Regenerated by Nanobots")
+ stat("damage_absorbed", "Damage Absorbed by Nanobots")
+ stat("power_consumed", "MtJ Burnt as Android")
+ }
+}
+
+private fun research(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ add("android_research.status.requires", "Requires %s to be researched")
+ add("android_research.status.blocks", "Locks %s")
+ add("android_research.status.blocked_by", "Locked by %s")
+
+ add(AndroidResearch.LIMB_OVERCLOCKING[0], "Limb Overclocking %s")
+ add(AndroidResearch.LIMB_OVERCLOCKING[0], "description", "Boosts unit's mobility by %s%% and attack speed by %s%%")
+
+ add(AndroidResearch.AIR_BAGS, "Air Bags")
+ add(AndroidResearch.NANOBOTS, "Nanobots")
+ add(AndroidResearch.AIR_BAGS, "description", "Allows unit to swim in water")
+ add(AndroidResearch.NANOBOTS, "description", "Various useful nanobots for doing various tasks")
+
+ add(AndroidResearch.NANOBOTS_REGENERATION[0], "Regeneration %s")
+ add(AndroidResearch.NANOBOTS_REGENERATION[0], "description", "Nanobots get ability to repair unit's internal systems on the move")
+ add(AndroidResearch.NANOBOTS_REGENERATION[0], "description_improve", "Improves regeneration speed")
+
+ add(AndroidResearch.NANOBOTS_ARMOR, "Nanobots Armor")
+ add(AndroidResearch.NANOBOTS_ARMOR, "description", "Allows nanobots to align themselves in cell shape, reducing incoming damage by a %% by absorbing impacts")
+
+ add(AndroidResearch.NANOBOTS_ARMOR_SPEED[0], "Nanobots Armor Build Speed %s")
+ add(AndroidResearch.NANOBOTS_ARMOR_SPEED[0], "description", "Reduces time required for nanobots to form protection layer")
+
+ add(AndroidResearch.NANOBOTS_ARMOR_STRENGTH[0], "Nanobots Armor Strength %s")
+ add(AndroidResearch.NANOBOTS_ARMOR_STRENGTH[0], "description", "Increases impact absorption strength of nanobots")
+
+ add(AndroidResearch.EXTENDED_REACH, "Extended Reach")
+ add(AndroidResearch.EXTENDED_REACH, "description", "Increases block interaction distance")
+ }
+}
+
+private fun androidFeatures(provider: MatteryLanguageProvider) {
+ with(provider.english) {
+ add(AndroidFeatures.AIR_BAGS, "Air Bags")
+ }
+}
+
+fun AddEnglishLanguage(provider: MatteryLanguageProvider) {
+ decoratives(provider)
+ sounds(provider)
+ misc(provider)
+
+ blocks(provider)
+ items(provider)
+ stats(provider)
+
+ with(provider.english) {
+ add("itemGroup.otm", "Overdrive That Matters")
+ add("itemGroup.otm_decorative", "Overdrive That Matters Decorative")
+ }
+}
diff --git a/src/main/java/ru/dbotthepony/mc/otm/OverdriveThatMatters.java b/src/main/java/ru/dbotthepony/mc/otm/OverdriveThatMatters.java
index af1bec0cb..084f2b459 100644
--- a/src/main/java/ru/dbotthepony/mc/otm/OverdriveThatMatters.java
+++ b/src/main/java/ru/dbotthepony/mc/otm/OverdriveThatMatters.java
@@ -65,7 +65,7 @@ public final class OverdriveThatMatters {
public final CreativeModeTab CREATIVE_TAB_DECORATIVE = new CreativeModeTab("otm_decorative") {
@Override
public ItemStack makeIcon() {
- return new ItemStack(MItems.INSTANCE.getVENT(), 1);
+ return new ItemStack(MRegistry.INSTANCE.getVENT().getItem(), 1);
}
};
diff --git a/src/main/java/ru/dbotthepony/mc/otm/android/AndroidResearchType.java b/src/main/java/ru/dbotthepony/mc/otm/android/AndroidResearchType.java
index adf7dc163..849adface 100644
--- a/src/main/java/ru/dbotthepony/mc/otm/android/AndroidResearchType.java
+++ b/src/main/java/ru/dbotthepony/mc/otm/android/AndroidResearchType.java
@@ -79,10 +79,25 @@ public class AndroidResearchType<T extends AndroidResearch> extends ForgeRegistr
return factory.factory(this, capability);
}
- public Component getDisplayName() {
- if (getRegistryName() == null)
- return new TranslatableComponent("android_research.null.null");
+ private Component displayNameCache;
+ private String displayIdCache;
- return new TranslatableComponent("android_research." + getRegistryName().getNamespace() + "." + getRegistryName().getPath());
+ public Component getDisplayName() {
+ if (displayNameCache == null) {
+ displayNameCache = new TranslatableComponent(getDisplayId());
+ }
+
+ return displayNameCache;
+ }
+
+ public String getDisplayId() {
+ if (displayNameCache == null) {
+ if (getRegistryName() == null)
+ displayIdCache = "android_research.null.null";
+ else
+ displayIdCache = "android_research." + getRegistryName().getNamespace() + "." + getRegistryName().getPath();
+ }
+
+ return displayIdCache;
}
}
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/android/AndroidFeature.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/android/AndroidFeature.kt
index 1905cbdde..4d6d931ea 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/android/AndroidFeature.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/android/AndroidFeature.kt
@@ -26,7 +26,13 @@ open class AndroidFeatureType<T : AndroidFeature> : ForgeRegistryEntry<AndroidFe
open fun isApplicable(android: AndroidCapability) = true
- open val displayName: Component get() = registryName?.let { TranslatableComponent("android_feature.${it.namespace}.${it.path}") } ?: TranslatableComponent("android_feature.null.null")
+ open val displayName: Component by lazy {
+ TranslatableComponent(displayId)
+ }
+
+ open val displayId: String by lazy {
+ registryName?.let { "android_feature.${it.namespace}.${it.path}" } ?: "android_feature.null.null"
+ }
}
abstract class AndroidFeature(val type: AndroidFeatureType<*>, val android: AndroidCapability) : INBTSerializable<CompoundTag> {
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LazyList.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LazyList.kt
index cfbb7ef15..00a7ea3a4 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LazyList.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/LazyList.kt
@@ -1,5 +1,7 @@
package ru.dbotthepony.mc.otm.registry
+import com.google.common.collect.ImmutableSet
+import net.minecraft.world.item.DyeColor
import net.minecraftforge.registries.IForgeRegistryEntry
import net.minecraftforge.registries.RegistryObject
@@ -12,6 +14,18 @@ class LazyList<T>(private vararg val getters: () -> T) : AbstractList<T>() {
}
}
+class LazyMap<K, T>(vararg mValues: Pair<K, () -> T>) : AbstractMap<K, T>() {
+ private inner class Entry(
+ override val key: K,
+ private val getter: () -> T
+ ) : Map.Entry<K, T> {
+ override val value: T
+ get() = getter.invoke()
+ }
+
+ override val entries: Set<Map.Entry<K, T>> = ImmutableSet.copyOf(mValues.map { Entry(it.first, it.second) })
+}
+
class RegistryObjectList<T : IForgeRegistryEntry<T>>(private vararg val getters: RegistryObject<T>) : AbstractList<T>() {
constructor(getters: List<RegistryObject<T>>) : this(*getters.toTypedArray())
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlockEntities.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlockEntities.kt
index 2c473563d..ce0e0cea3 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlockEntities.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlockEntities.kt
@@ -33,23 +33,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,
- MBlocks.CARGO_CRATE,
- MBlocks.CARGO_CRATE_WHITE,
- MBlocks.CARGO_CRATE_ORANGE,
- MBlocks.CARGO_CRATE_MAGENTA,
- MBlocks.CARGO_CRATE_LIGHT_BLUE,
- MBlocks.CARGO_CRATE_YELLOW,
- MBlocks.CARGO_CRATE_LIME,
- MBlocks.CARGO_CRATE_PINK,
- MBlocks.CARGO_CRATE_GRAY,
- MBlocks.CARGO_CRATE_LIGHT_GRAY,
- MBlocks.CARGO_CRATE_CYAN,
- MBlocks.CARGO_CRATE_PURPLE,
- MBlocks.CARGO_CRATE_BLUE,
- MBlocks.CARGO_CRATE_BROWN,
- MBlocks.CARGO_CRATE_GREEN,
- MBlocks.CARGO_CRATE_RED,
- MBlocks.CARGO_CRATE_BLACK,
+ *MRegistry.CARGO_CRATES.blocks.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) }
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlocks.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlocks.kt
index 65e035270..2f79e50be 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlocks.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MBlocks.kt
@@ -30,11 +30,11 @@ object MBlocks {
private fun registerClient(event: FMLClientSetupEvent) {
val translucent = RenderType.translucent()
- for (block in INDUSTRIAL_GLASS_LIST) {
+ for (block in MRegistry.INDUSTRIAL_GLASS.blocks) {
ItemBlockRenderTypes.setRenderLayer(block, translucent)
}
- for (block in INDUSTRIAL_GLASS_PANE_LIST) {
+ for (block in MRegistry.INDUSTRIAL_GLASS_PANE.blocks) {
ItemBlockRenderTypes.setRenderLayer(block, translucent)
}
}
@@ -91,14 +91,6 @@ object MBlocks {
.requiresCorrectToolForDrops()
) }
- val TRITANIUM_BLOCK: Block by registry.register(MNames.TRITANIUM_BLOCK) { Block(
- BlockBehaviour.Properties.of(Material.METAL, MaterialColor.COLOR_LIGHT_BLUE)
- .sound(SoundType.BASALT)
- .requiresCorrectToolForDrops()
- .explosionResistance(80f)
- .strength(4f)
- ) }
-
init {
MRegistry.TRITANIUM_BLOCK.registerBlocks(registry)
}
@@ -111,187 +103,6 @@ object MBlocks {
.strength(4f)
) }
- val CARBON_FIBRE_BLOCK: Block by registry.register(MNames.CARBON_FIBRE_BLOCK) { Block(
- BlockBehaviour.Properties.of(Material.METAL, MaterialColor.COLOR_LIGHT_BLUE)
- .sound(SoundType.BASALT)
- .requiresCorrectToolForDrops()
- .explosionResistance(40f)
- .strength(3f)
- ) }
-
- val VENT: Block by registry.register(MNames.VENT) { Block(
- BlockBehaviour.Properties.of(Material.METAL, MaterialColor.COLOR_LIGHT_BLUE)
- .sound(SoundType.BASALT)
- .requiresCorrectToolForDrops()
- .explosionResistance(20f)
- .strength(1.5f)
- ) }
-
- val VENT_ALTERNATIVE: Block by registry.register(MNames.VENT_ALTERNATIVE) { Block(
- BlockBehaviour.Properties.of(Material.METAL, MaterialColor.COLOR_LIGHT_BLUE)
- .sound(SoundType.BASALT)
- .requiresCorrectToolForDrops()
- .explosionResistance(20f)
- .strength(1.5f)
- ) }
-
- init {
- MRegistry.FLOOR_TILES.registerBlocks(registry)
- MRegistry.VENT.registerBlocks(registry)
- MRegistry.VENT_ALTERNATIVE.registerBlocks(registry)
- }
-
- val CARGO_CRATE: Block by registry.register(MNames.CARGO_CRATE) { CargoCrateBlock(null) }
- val CARGO_CRATE_WHITE: Block by registry.register(MNames.CARGO_CRATE_WHITE) { CargoCrateBlock(DyeColor.WHITE) }
- val CARGO_CRATE_ORANGE: Block by registry.register(MNames.CARGO_CRATE_ORANGE) { CargoCrateBlock(DyeColor.ORANGE) }
- val CARGO_CRATE_MAGENTA: Block by registry.register(MNames.CARGO_CRATE_MAGENTA) { CargoCrateBlock(DyeColor.MAGENTA) }
- val CARGO_CRATE_LIGHT_BLUE: Block by registry.register(MNames.CARGO_CRATE_LIGHT_BLUE) { CargoCrateBlock(DyeColor.LIGHT_BLUE) }
- val CARGO_CRATE_YELLOW: Block by registry.register(MNames.CARGO_CRATE_YELLOW) { CargoCrateBlock(DyeColor.YELLOW) }
- val CARGO_CRATE_LIME: Block by registry.register(MNames.CARGO_CRATE_LIME) { CargoCrateBlock(DyeColor.LIME) }
- val CARGO_CRATE_PINK: Block by registry.register(MNames.CARGO_CRATE_PINK) { CargoCrateBlock(DyeColor.PINK) }
- val CARGO_CRATE_GRAY: Block by registry.register(MNames.CARGO_CRATE_GRAY) { CargoCrateBlock(DyeColor.GRAY) }
- val CARGO_CRATE_LIGHT_GRAY: Block by registry.register(MNames.CARGO_CRATE_LIGHT_GRAY) { CargoCrateBlock(DyeColor.LIGHT_GRAY) }
- val CARGO_CRATE_CYAN: Block by registry.register(MNames.CARGO_CRATE_CYAN) { CargoCrateBlock(DyeColor.CYAN) }
- val CARGO_CRATE_PURPLE: Block by registry.register(MNames.CARGO_CRATE_PURPLE) { CargoCrateBlock(DyeColor.PURPLE) }
- val CARGO_CRATE_BLUE: Block by registry.register(MNames.CARGO_CRATE_BLUE) { CargoCrateBlock(DyeColor.BLUE) }
- val CARGO_CRATE_BROWN: Block by registry.register(MNames.CARGO_CRATE_BROWN) { CargoCrateBlock(DyeColor.BROWN) }
- val CARGO_CRATE_GREEN: Block by registry.register(MNames.CARGO_CRATE_GREEN) { CargoCrateBlock(DyeColor.GREEN) }
- val CARGO_CRATE_RED: Block by registry.register(MNames.CARGO_CRATE_RED) { CargoCrateBlock(DyeColor.RED) }
- val CARGO_CRATE_BLACK: Block by registry.register(MNames.CARGO_CRATE_BLACK) { CargoCrateBlock(DyeColor.BLACK) }
-
- val CARGO_CRATES = LazyList(
- { CARGO_CRATE },
- { CARGO_CRATE_WHITE },
- { CARGO_CRATE_ORANGE },
- { CARGO_CRATE_MAGENTA },
- { CARGO_CRATE_LIGHT_BLUE },
- { CARGO_CRATE_YELLOW },
- { CARGO_CRATE_LIME },
- { CARGO_CRATE_PINK },
- { CARGO_CRATE_GRAY },
- { CARGO_CRATE_LIGHT_GRAY },
- { CARGO_CRATE_CYAN },
- { CARGO_CRATE_PURPLE },
- { CARGO_CRATE_BLUE },
- { CARGO_CRATE_BROWN },
- { CARGO_CRATE_GREEN },
- { CARGO_CRATE_RED },
- { CARGO_CRATE_BLACK },
- )
-
- val CARGO_CRATES_COLORED = LazyList(
- { CARGO_CRATE_WHITE },
- { CARGO_CRATE_ORANGE },
- { CARGO_CRATE_MAGENTA },
- { CARGO_CRATE_LIGHT_BLUE },
- { CARGO_CRATE_YELLOW },
- { CARGO_CRATE_LIME },
- { CARGO_CRATE_PINK },
- { CARGO_CRATE_GRAY },
- { CARGO_CRATE_LIGHT_GRAY },
- { CARGO_CRATE_CYAN },
- { CARGO_CRATE_PURPLE },
- { CARGO_CRATE_BLUE },
- { CARGO_CRATE_BROWN },
- { CARGO_CRATE_GREEN },
- { CARGO_CRATE_RED },
- { CARGO_CRATE_BLACK },
- )
-
- val CRATE_RED: Block by registry.register(MRegistry.CRATE_RED.name) { MRegistry.CRATE_RED.makeBlock() }
- val CRATE_BLUE: Block by registry.register(MRegistry.CRATE_BLUE.name) { MRegistry.CRATE_BLUE.makeBlock() }
- val CRATE_YELLOW: Block by registry.register(MRegistry.CRATE_YELLOW.name) { MRegistry.CRATE_YELLOW.makeBlock() }
- val CRATE_GREEN: Block by registry.register(MRegistry.CRATE_GREEN.name) { MRegistry.CRATE_GREEN.makeBlock() }
- val CRATE_BLACK: Block by registry.register(MRegistry.CRATE_BLACK.name) { MRegistry.CRATE_BLACK.makeBlock() }
- val CRATE_PINK: Block by registry.register(MRegistry.CRATE_PINK.name) { MRegistry.CRATE_PINK.makeBlock() }
- val CRATE_PURPLE: Block by registry.register(MRegistry.CRATE_PURPLE.name) { MRegistry.CRATE_PURPLE.makeBlock() }
-
- val CRATE_LIST = LazyList(
- { CRATE_RED },
- { CRATE_BLUE },
- { CRATE_YELLOW },
- { CRATE_GREEN },
- { CRATE_BLACK },
- { CRATE_PINK },
- { CRATE_PURPLE },
- )
-
- val INDUSTRIAL_GLASS: Block by registry.register(MRegistry.INDUSTRIAL_GLASS.name) { MRegistry.INDUSTRIAL_GLASS.makeBlock() }
- val INDUSTRIAL_GLASS_WHITE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_WHITE.name) { MRegistry.INDUSTRIAL_GLASS_WHITE.makeBlock() }
- val INDUSTRIAL_GLASS_ORANGE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_ORANGE.name) { MRegistry.INDUSTRIAL_GLASS_ORANGE.makeBlock() }
- val INDUSTRIAL_GLASS_MAGENTA: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_MAGENTA.name) { MRegistry.INDUSTRIAL_GLASS_MAGENTA.makeBlock() }
- val INDUSTRIAL_GLASS_LIGHT_BLUE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.name) { MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.makeBlock() }
- val INDUSTRIAL_GLASS_YELLOW: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_YELLOW.name) { MRegistry.INDUSTRIAL_GLASS_YELLOW.makeBlock() }
- val INDUSTRIAL_GLASS_LIME: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIME.name) { MRegistry.INDUSTRIAL_GLASS_LIME.makeBlock() }
- val INDUSTRIAL_GLASS_PINK: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_PINK.name) { MRegistry.INDUSTRIAL_GLASS_PINK.makeBlock() }
- val INDUSTRIAL_GLASS_GRAY: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_GRAY.name) { MRegistry.INDUSTRIAL_GLASS_GRAY.makeBlock() }
- val INDUSTRIAL_GLASS_LIGHT_GRAY: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.name) { MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.makeBlock() }
- val INDUSTRIAL_GLASS_CYAN: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_CYAN.name) { MRegistry.INDUSTRIAL_GLASS_CYAN.makeBlock() }
- val INDUSTRIAL_GLASS_PURPLE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_PURPLE.name) { MRegistry.INDUSTRIAL_GLASS_PURPLE.makeBlock() }
- val INDUSTRIAL_GLASS_BLUE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BLUE.name) { MRegistry.INDUSTRIAL_GLASS_BLUE.makeBlock() }
- val INDUSTRIAL_GLASS_BROWN: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BROWN.name) { MRegistry.INDUSTRIAL_GLASS_BROWN.makeBlock() }
- val INDUSTRIAL_GLASS_GREEN: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_GREEN.name) { MRegistry.INDUSTRIAL_GLASS_GREEN.makeBlock() }
- val INDUSTRIAL_GLASS_RED: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_RED.name) { MRegistry.INDUSTRIAL_GLASS_RED.makeBlock() }
- val INDUSTRIAL_GLASS_BLACK: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BLACK.name) { MRegistry.INDUSTRIAL_GLASS_BLACK.makeBlock() }
-
- val INDUSTRIAL_GLASS_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS.namePane) { MRegistry.INDUSTRIAL_GLASS.makePaneBlock() }
- val INDUSTRIAL_GLASS_WHITE_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_WHITE.namePane) { MRegistry.INDUSTRIAL_GLASS_WHITE.makePaneBlock() }
- val INDUSTRIAL_GLASS_ORANGE_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_ORANGE.namePane) { MRegistry.INDUSTRIAL_GLASS_ORANGE.makePaneBlock() }
- val INDUSTRIAL_GLASS_MAGENTA_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_MAGENTA.namePane) { MRegistry.INDUSTRIAL_GLASS_MAGENTA.makePaneBlock() }
- val INDUSTRIAL_GLASS_LIGHT_BLUE_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.namePane) { MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.makePaneBlock() }
- val INDUSTRIAL_GLASS_YELLOW_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_YELLOW.namePane) { MRegistry.INDUSTRIAL_GLASS_YELLOW.makePaneBlock() }
- val INDUSTRIAL_GLASS_LIME_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIME.namePane) { MRegistry.INDUSTRIAL_GLASS_LIME.makePaneBlock() }
- val INDUSTRIAL_GLASS_PINK_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_PINK.namePane) { MRegistry.INDUSTRIAL_GLASS_PINK.makePaneBlock() }
- val INDUSTRIAL_GLASS_GRAY_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_GRAY.namePane) { MRegistry.INDUSTRIAL_GLASS_GRAY.makePaneBlock() }
- val INDUSTRIAL_GLASS_LIGHT_GRAY_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.namePane) { MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.makePaneBlock() }
- val INDUSTRIAL_GLASS_CYAN_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_CYAN.namePane) { MRegistry.INDUSTRIAL_GLASS_CYAN.makePaneBlock() }
- val INDUSTRIAL_GLASS_PURPLE_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_PURPLE.namePane) { MRegistry.INDUSTRIAL_GLASS_PURPLE.makePaneBlock() }
- val INDUSTRIAL_GLASS_BLUE_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BLUE.namePane) { MRegistry.INDUSTRIAL_GLASS_BLUE.makePaneBlock() }
- val INDUSTRIAL_GLASS_BROWN_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BROWN.namePane) { MRegistry.INDUSTRIAL_GLASS_BROWN.makePaneBlock() }
- val INDUSTRIAL_GLASS_GREEN_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_GREEN.namePane) { MRegistry.INDUSTRIAL_GLASS_GREEN.makePaneBlock() }
- val INDUSTRIAL_GLASS_RED_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_RED.namePane) { MRegistry.INDUSTRIAL_GLASS_RED.makePaneBlock() }
- val INDUSTRIAL_GLASS_BLACK_PANE: Block by registry.register(MRegistry.INDUSTRIAL_GLASS_BLACK.namePane) { MRegistry.INDUSTRIAL_GLASS_BLACK.makePaneBlock() }
-
- val INDUSTRIAL_GLASS_LIST = LazyList(
- { INDUSTRIAL_GLASS },
- { INDUSTRIAL_GLASS_WHITE },
- { INDUSTRIAL_GLASS_ORANGE },
- { INDUSTRIAL_GLASS_MAGENTA },
- { INDUSTRIAL_GLASS_LIGHT_BLUE },
- { INDUSTRIAL_GLASS_YELLOW },
- { INDUSTRIAL_GLASS_LIME },
- { INDUSTRIAL_GLASS_PINK },
- { INDUSTRIAL_GLASS_GRAY },
- { INDUSTRIAL_GLASS_LIGHT_GRAY },
- { INDUSTRIAL_GLASS_CYAN },
- { INDUSTRIAL_GLASS_PURPLE },
- { INDUSTRIAL_GLASS_BLUE },
- { INDUSTRIAL_GLASS_BROWN },
- { INDUSTRIAL_GLASS_GREEN },
- { INDUSTRIAL_GLASS_RED },
- { INDUSTRIAL_GLASS_BLACK },
- )
-
- val INDUSTRIAL_GLASS_PANE_LIST = LazyList(
- { INDUSTRIAL_GLASS_PANE },
- { INDUSTRIAL_GLASS_WHITE_PANE },
- { INDUSTRIAL_GLASS_ORANGE_PANE },
- { INDUSTRIAL_GLASS_MAGENTA_PANE },
- { INDUSTRIAL_GLASS_LIGHT_BLUE_PANE },
- { INDUSTRIAL_GLASS_YELLOW_PANE },
- { INDUSTRIAL_GLASS_LIME_PANE },
- { INDUSTRIAL_GLASS_PINK_PANE },
- { INDUSTRIAL_GLASS_GRAY_PANE },
- { INDUSTRIAL_GLASS_LIGHT_GRAY_PANE },
- { INDUSTRIAL_GLASS_CYAN_PANE },
- { INDUSTRIAL_GLASS_PURPLE_PANE },
- { INDUSTRIAL_GLASS_BLUE_PANE },
- { INDUSTRIAL_GLASS_BROWN_PANE },
- { INDUSTRIAL_GLASS_GREEN_PANE },
- { INDUSTRIAL_GLASS_RED_PANE },
- { INDUSTRIAL_GLASS_BLACK_PANE },
- )
-
val TRITANIUM_STRIPED_BLOCKS: LazyList<Block>
// слишком лень было разбираться дальше ибо деление индекса на 15 не работало
val TRITANIUM_STRIPED_BLOCKS_COLORS: List<String>
@@ -341,4 +152,40 @@ object MBlocks {
TRITANIUM_STRIPED_BLOCKS = LazyList(*listing.toTypedArray())
TRITANIUM_STRIPED_BLOCKS_COLORS = ImmutableList.copyOf(listingColors)
}
+
+ val CARBON_FIBRE_BLOCK: Block by registry.register(MNames.CARBON_FIBRE_BLOCK) { Block(
+ BlockBehaviour.Properties.of(Material.METAL, MaterialColor.COLOR_LIGHT_BLUE)
+ .sound(SoundType.BASALT)
+ .requiresCorrectToolForDrops()
+ .explosionResistance(40f)
+ .strength(3f)
+ ) }
+
+ init {
+ MRegistry.CARGO_CRATES.registerBlocks(registry)
+
+ MRegistry.INDUSTRIAL_GLASS.registerBlocks(registry)
+ MRegistry.INDUSTRIAL_GLASS_PANE.registerBlocks(registry)
+ MRegistry.FLOOR_TILES.registerBlocks(registry)
+ MRegistry.VENT.registerBlocks(registry)
+ MRegistry.VENT_ALTERNATIVE.registerBlocks(registry)
+ }
+
+ val CRATE_RED: Block by registry.register(MRegistry.CRATE_RED.name) { MRegistry.CRATE_RED.makeBlock() }
+ val CRATE_BLUE: Block by registry.register(MRegistry.CRATE_BLUE.name) { MRegistry.CRATE_BLUE.makeBlock() }
+ val CRATE_YELLOW: Block by registry.register(MRegistry.CRATE_YELLOW.name) { MRegistry.CRATE_YELLOW.makeBlock() }
+ val CRATE_GREEN: Block by registry.register(MRegistry.CRATE_GREEN.name) { MRegistry.CRATE_GREEN.makeBlock() }
+ val CRATE_BLACK: Block by registry.register(MRegistry.CRATE_BLACK.name) { MRegistry.CRATE_BLACK.makeBlock() }
+ val CRATE_PINK: Block by registry.register(MRegistry.CRATE_PINK.name) { MRegistry.CRATE_PINK.makeBlock() }
+ val CRATE_PURPLE: Block by registry.register(MRegistry.CRATE_PURPLE.name) { MRegistry.CRATE_PURPLE.makeBlock() }
+
+ val CRATE_LIST = LazyList(
+ { CRATE_RED },
+ { CRATE_BLUE },
+ { CRATE_YELLOW },
+ { CRATE_GREEN },
+ { CRATE_BLACK },
+ { CRATE_PINK },
+ { CRATE_PURPLE },
+ )
}
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItems.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItems.kt
index ca3bf380d..40f119817 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItems.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItems.kt
@@ -237,156 +237,13 @@ object MItems {
{ CRATE_PURPLE },
)
- val CARGO_CRATE: Item by registry.register(MNames.CARGO_CRATE) { BlockItem(MBlocks.CARGO_CRATE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_WHITE: Item by registry.register(MNames.CARGO_CRATE_WHITE) { BlockItem(MBlocks.CARGO_CRATE_WHITE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_ORANGE: Item by registry.register(MNames.CARGO_CRATE_ORANGE) { BlockItem(MBlocks.CARGO_CRATE_ORANGE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_MAGENTA: Item by registry.register(MNames.CARGO_CRATE_MAGENTA) { BlockItem(MBlocks.CARGO_CRATE_MAGENTA, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_LIGHT_BLUE: Item by registry.register(MNames.CARGO_CRATE_LIGHT_BLUE) { BlockItem(MBlocks.CARGO_CRATE_LIGHT_BLUE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_YELLOW: Item by registry.register(MNames.CARGO_CRATE_YELLOW) { BlockItem(MBlocks.CARGO_CRATE_YELLOW, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_LIME: Item by registry.register(MNames.CARGO_CRATE_LIME) { BlockItem(MBlocks.CARGO_CRATE_LIME, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_PINK: Item by registry.register(MNames.CARGO_CRATE_PINK) { BlockItem(MBlocks.CARGO_CRATE_PINK, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_GRAY: Item by registry.register(MNames.CARGO_CRATE_GRAY) { BlockItem(MBlocks.CARGO_CRATE_GRAY, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_LIGHT_GRAY: Item by registry.register(MNames.CARGO_CRATE_LIGHT_GRAY) { BlockItem(MBlocks.CARGO_CRATE_LIGHT_GRAY, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_CYAN: Item by registry.register(MNames.CARGO_CRATE_CYAN) { BlockItem(MBlocks.CARGO_CRATE_CYAN, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_PURPLE: Item by registry.register(MNames.CARGO_CRATE_PURPLE) { BlockItem(MBlocks.CARGO_CRATE_PURPLE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_BLUE: Item by registry.register(MNames.CARGO_CRATE_BLUE) { BlockItem(MBlocks.CARGO_CRATE_BLUE, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_BROWN: Item by registry.register(MNames.CARGO_CRATE_BROWN) { BlockItem(MBlocks.CARGO_CRATE_BROWN, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_GREEN: Item by registry.register(MNames.CARGO_CRATE_GREEN) { BlockItem(MBlocks.CARGO_CRATE_GREEN, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_RED: Item by registry.register(MNames.CARGO_CRATE_RED) { BlockItem(MBlocks.CARGO_CRATE_RED, DEFAULT_PROPERTIES) }
- val CARGO_CRATE_BLACK: Item by registry.register(MNames.CARGO_CRATE_BLACK) { BlockItem(MBlocks.CARGO_CRATE_BLACK, DEFAULT_PROPERTIES) }
-
- val CARGO_CRATES = LazyList(
- { CARGO_CRATE },
- { CARGO_CRATE_WHITE },
- { CARGO_CRATE_ORANGE },
- { CARGO_CRATE_MAGENTA },
- { CARGO_CRATE_LIGHT_BLUE },
- { CARGO_CRATE_YELLOW },
- { CARGO_CRATE_LIME },
- { CARGO_CRATE_PINK },
- { CARGO_CRATE_GRAY },
- { CARGO_CRATE_LIGHT_GRAY },
- { CARGO_CRATE_CYAN },
- { CARGO_CRATE_PURPLE },
- { CARGO_CRATE_BLUE },
- { CARGO_CRATE_BROWN },
- { CARGO_CRATE_GREEN },
- { CARGO_CRATE_RED },
- { CARGO_CRATE_BLACK },
- )
-
- val CARGO_CRATES_COLORED = LazyList(
- { CARGO_CRATE_WHITE },
- { CARGO_CRATE_ORANGE },
- { CARGO_CRATE_MAGENTA },
- { CARGO_CRATE_LIGHT_BLUE },
- { CARGO_CRATE_YELLOW },
- { CARGO_CRATE_LIME },
- { CARGO_CRATE_PINK },
- { CARGO_CRATE_GRAY },
- { CARGO_CRATE_LIGHT_GRAY },
- { CARGO_CRATE_CYAN },
- { CARGO_CRATE_PURPLE },
- { CARGO_CRATE_BLUE },
- { CARGO_CRATE_BROWN },
- { CARGO_CRATE_GREEN },
- { CARGO_CRATE_RED },
- { CARGO_CRATE_BLACK },
- )
-
- val TRITANIUM_BLOCK: Item by registry.register(MNames.TRITANIUM_BLOCK) { BlockItem(MBlocks.TRITANIUM_BLOCK, DEFAULT_PROPERTIES_DECORATIVE) }
-
init {
+ MRegistry.CARGO_CRATES.registerItems(registry)
+
MRegistry.TRITANIUM_BLOCK.registerItems(registry)
}
- val VENT: Item by registry.register(MNames.VENT) { BlockItem(MBlocks.VENT, DEFAULT_PROPERTIES_DECORATIVE) }
- val VENT_ALTERNATIVE: Item by registry.register(MNames.VENT_ALTERNATIVE) { BlockItem(MBlocks.VENT_ALTERNATIVE, DEFAULT_PROPERTIES_DECORATIVE) }
-
val TRITANIUM_STRIPED_BLOCK: Item by registry.register(MNames.TRITANIUM_STRIPED_BLOCK) { BlockItem(MBlocks.TRITANIUM_STRIPED_BLOCK, DEFAULT_PROPERTIES_DECORATIVE) }
- val CARBON_FIBRE_BLOCK: Item by registry.register(MNames.CARBON_FIBRE_BLOCK) { BlockItem(MBlocks.CARBON_FIBRE_BLOCK, DEFAULT_PROPERTIES_DECORATIVE) }
-
- init {
- MRegistry.FLOOR_TILES.registerItems(registry)
- MRegistry.VENT.registerItems(registry)
- MRegistry.VENT_ALTERNATIVE.registerItems(registry)
- }
-
- val INDUSTRIAL_GLASS: Item by registry.register(MRegistry.INDUSTRIAL_GLASS.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_WHITE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_WHITE.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_WHITE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_ORANGE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_ORANGE.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_ORANGE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_MAGENTA: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_MAGENTA.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_MAGENTA, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIGHT_BLUE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIGHT_BLUE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_YELLOW: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_YELLOW.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_YELLOW, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIME: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIME.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIME, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_PINK: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_PINK.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_PINK, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_GRAY: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_GRAY.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_GRAY, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIGHT_GRAY: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIGHT_GRAY, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_CYAN: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_CYAN.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_CYAN, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_PURPLE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_PURPLE.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_PURPLE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BLUE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BLUE.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BLUE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BROWN: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BROWN.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BROWN, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_GREEN: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_GREEN.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_GREEN, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_RED: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_RED.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_RED, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BLACK: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BLACK.name) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BLACK, DEFAULT_PROPERTIES_DECORATIVE) }
-
- val INDUSTRIAL_GLASS_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_WHITE_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_WHITE.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_WHITE_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_ORANGE_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_ORANGE.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_ORANGE_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_MAGENTA_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_MAGENTA.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_MAGENTA_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIGHT_BLUE_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_BLUE.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIGHT_BLUE_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_YELLOW_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_YELLOW.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_YELLOW_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIME_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIME.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIME_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_PINK_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_PINK.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_PINK_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_GRAY_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_GRAY.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_GRAY_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_LIGHT_GRAY_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_LIGHT_GRAY.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_LIGHT_GRAY_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_CYAN_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_CYAN.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_CYAN_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_PURPLE_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_PURPLE.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_PURPLE_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BLUE_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BLUE.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BLUE_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BROWN_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BROWN.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BROWN_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_GREEN_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_GREEN.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_GREEN_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_RED_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_RED.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_RED_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
- val INDUSTRIAL_GLASS_BLACK_PANE: Item by registry.register(MRegistry.INDUSTRIAL_GLASS_BLACK.namePane) { BlockItem(MBlocks.INDUSTRIAL_GLASS_BLACK_PANE, DEFAULT_PROPERTIES_DECORATIVE) }
-
- val INDUSTRIAL_GLASS_LIST = LazyList(
- { INDUSTRIAL_GLASS },
- { INDUSTRIAL_GLASS_WHITE },
- { INDUSTRIAL_GLASS_ORANGE },
- { INDUSTRIAL_GLASS_MAGENTA },
- { INDUSTRIAL_GLASS_LIGHT_BLUE },
- { INDUSTRIAL_GLASS_YELLOW },
- { INDUSTRIAL_GLASS_LIME },
- { INDUSTRIAL_GLASS_PINK },
- { INDUSTRIAL_GLASS_GRAY },
- { INDUSTRIAL_GLASS_LIGHT_GRAY },
- { INDUSTRIAL_GLASS_CYAN },
- { INDUSTRIAL_GLASS_PURPLE },
- { INDUSTRIAL_GLASS_BLUE },
- { INDUSTRIAL_GLASS_BROWN },
- { INDUSTRIAL_GLASS_GREEN },
- { INDUSTRIAL_GLASS_RED },
- { INDUSTRIAL_GLASS_BLACK },
- )
-
- val INDUSTRIAL_GLASS_PANE_LIST = LazyList(
- { INDUSTRIAL_GLASS_PANE },
- { INDUSTRIAL_GLASS_WHITE_PANE },
- { INDUSTRIAL_GLASS_ORANGE_PANE },
- { INDUSTRIAL_GLASS_MAGENTA_PANE },
- { INDUSTRIAL_GLASS_LIGHT_BLUE_PANE },
- { INDUSTRIAL_GLASS_YELLOW_PANE },
- { INDUSTRIAL_GLASS_LIME_PANE },
- { INDUSTRIAL_GLASS_PINK_PANE },
- { INDUSTRIAL_GLASS_GRAY_PANE },
- { INDUSTRIAL_GLASS_LIGHT_GRAY_PANE },
- { INDUSTRIAL_GLASS_CYAN_PANE },
- { INDUSTRIAL_GLASS_PURPLE_PANE },
- { INDUSTRIAL_GLASS_BLUE_PANE },
- { INDUSTRIAL_GLASS_BROWN_PANE },
- { INDUSTRIAL_GLASS_GREEN_PANE },
- { INDUSTRIAL_GLASS_RED_PANE },
- { INDUSTRIAL_GLASS_BLACK_PANE },
- )
val TRITANIUM_STRIPED_BLOCKS: LazyList<Item>
@@ -431,4 +288,15 @@ object MItems {
TRITANIUM_STRIPED_BLOCKS = LazyList(*listing.toTypedArray())
}
+
+ val CARBON_FIBRE_BLOCK: Item by registry.register(MNames.CARBON_FIBRE_BLOCK) { BlockItem(MBlocks.CARBON_FIBRE_BLOCK, DEFAULT_PROPERTIES_DECORATIVE) }
+
+ init {
+ MRegistry.INDUSTRIAL_GLASS.registerItems(registry)
+ MRegistry.INDUSTRIAL_GLASS_PANE.registerItems(registry)
+ MRegistry.FLOOR_TILES.registerItems(registry)
+ MRegistry.VENT.registerItems(registry)
+ MRegistry.VENT_ALTERNATIVE.registerItems(registry)
+ }
+
}
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MNames.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MNames.kt
index 1bf52c07c..11587e8bf 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MNames.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MNames.kt
@@ -60,6 +60,9 @@ object MNames {
const val TRITANIUM_BLOCK = "tritanium_block"
const val TRITANIUM_STRIPED_BLOCK = "tritanium_striped_block"
+ const val INDUSTRIAL_GLASS = "industrial_glass"
+ const val INDUSTRIAL_GLASS_PANE = "industrial_glass_pane"
+
const val CARBON_FIBRE_BLOCK = "carbon_fibre_block"
const val FLOOR_TILES = "floor_tiles"
diff --git a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt
index 52c1e89c6..4f326bd43 100644
--- a/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt
+++ b/src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt
@@ -5,6 +5,7 @@ import net.minecraft.resources.ResourceLocation
import net.minecraft.world.damagesource.DamageSource
import net.minecraft.world.entity.EntityType
import net.minecraft.world.item.BlockItem
+import net.minecraft.world.item.CreativeModeTab
import net.minecraft.world.item.DyeColor
import net.minecraft.world.item.Item
import net.minecraft.world.level.BlockGetter
@@ -23,9 +24,8 @@ import net.minecraftforge.registries.RegistryObject
import ru.dbotthepony.mc.otm.OverdriveThatMatters
import ru.dbotthepony.mc.otm.android.AndroidFeatureType
import ru.dbotthepony.mc.otm.android.AndroidResearchType
+import ru.dbotthepony.mc.otm.block.CargoCrateBlock
import java.util.function.Supplier
-import kotlin.properties.Delegates
-import kotlin.properties.ReadOnlyProperty
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
@@ -38,42 +38,6 @@ class CrateProperties(val color: MaterialColor, val name: String) {
}
}
-class IndustrialGlassProperties(val color: DyeColor?, val name: String, val namePane: String) {
- constructor(color: DyeColor?) : this(color, "industrial_glass${color?.let { "_$it" } ?: ""}", "industrial_glass_pane${color?.let { "_$it" } ?: ""}")
-
- fun makeBlock(): Block {
- val properties = BlockBehaviour.Properties.of(Material.GLASS, if (color != null) color.materialColor else MaterialColor.NONE)
- .strength(1.5f, 35.0f)
- .requiresCorrectToolForDrops()
- .sound(SoundType.GLASS)
- .noOcclusion()
- .isValidSpawn { _: BlockState, _: BlockGetter, _: BlockPos, _: EntityType<*>? -> false }
- .isRedstoneConductor { _: BlockState, _: BlockGetter, _: BlockPos -> false }
- .isSuffocating { _: BlockState, _: BlockGetter, _: BlockPos -> false }
- .isViewBlocking { _: BlockState, _: BlockGetter, _: BlockPos -> false }
-
- if (color != null) {
- return StainedGlassBlock(color, properties)
- }
-
- return GlassBlock(properties)
- }
-
- fun makePaneBlock(): Block {
- val properties = BlockBehaviour.Properties.of(Material.GLASS, if (color != null) color.materialColor else MaterialColor.NONE)
- .strength(1.25f, 5.0f)
- .requiresCorrectToolForDrops()
- .sound(SoundType.GLASS)
- .noOcclusion()
-
- if (color != null) {
- return StainedGlassPaneBlock(color, properties)
- }
-
- return IronBarsBlock(properties)
- }
-}
-
private class RegistryDelegate<V>(private val name: String) {
private var value: Supplier<V>? = null
@@ -107,26 +71,44 @@ private class WriteOnce<V> : ReadWriteProperty<Any, V> {
}
}
-class ColoredDecorativeBlock(
+@Suppress("PropertyName", "unused")
+open class ColoredDecorativeBlock(
val baseName: String,
- private val propertySupplier: (DyeColor) -> BlockBehaviour.Properties
+ private val provider: (DyeColor) -> Block,
+ val itemGroup: CreativeModeTab = OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE
) {
- private var _whiteBlock: RegistryObject<Block> by WriteOnce()
- private var _orangeBlock: RegistryObject<Block> by WriteOnce()
- private var _magentaBlock: RegistryObject<Block> by WriteOnce()
- private var _lightBlueBlock: RegistryObject<Block> by WriteOnce()
- private var _yellowBlock: RegistryObject<Block> by WriteOnce()
- private var _limeBlock: RegistryObject<Block> by WriteOnce()
- private var _pinkBlock: RegistryObject<Block> by WriteOnce()
- private var _grayBlock: RegistryObject<Block> by WriteOnce()
- private var _lightGrayBlock: RegistryObject<Block> by WriteOnce()
- private var _cyanBlock: RegistryObject<Block> by WriteOnce()
- private var _purpleBlock: RegistryObject<Block> by WriteOnce()
- private var _blueBlock: RegistryObject<Block> by WriteOnce()
- private var _brownBlock: RegistryObject<Block> by WriteOnce()
- private var _greenBlock: RegistryObject<Block> by WriteOnce()
- private var _redBlock: RegistryObject<Block> by WriteOnce()
- private var _blackBlock: RegistryObject<Block> by WriteOnce()
+ protected var _whiteBlock: RegistryObject<Block> by WriteOnce()
+ 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()
val orangeBlock: Block get() = _orangeBlock.get()
@@ -145,22 +127,38 @@ class ColoredDecorativeBlock(
val redBlock: Block get() = _redBlock.get()
val blackBlock: Block get() = _blackBlock.get()
- private var _whiteItem: RegistryObject<Item> by WriteOnce()
- private var _orangeItem: RegistryObject<Item> by WriteOnce()
- private var _magentaItem: RegistryObject<Item> by WriteOnce()
- private var _lightBlueItem: RegistryObject<Item> by WriteOnce()
- private var _yellowItem: RegistryObject<Item> by WriteOnce()
- private var _limeItem: RegistryObject<Item> by WriteOnce()
- private var _pinkItem: RegistryObject<Item> by WriteOnce()
- private var _grayItem: RegistryObject<Item> by WriteOnce()
- private var _lightGrayItem: RegistryObject<Item> by WriteOnce()
- private var _cyanItem: RegistryObject<Item> by WriteOnce()
- private var _purpleItem: RegistryObject<Item> by WriteOnce()
- private var _blueItem: RegistryObject<Item> by WriteOnce()
- private var _brownItem: RegistryObject<Item> by WriteOnce()
- private var _greenItem: RegistryObject<Item> by WriteOnce()
- private var _redItem: RegistryObject<Item> by WriteOnce()
- private var _blackItem: RegistryObject<Item> by WriteOnce()
+ 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()
val orangeItem: Item get() = _orangeItem.get()
@@ -179,80 +177,214 @@ class ColoredDecorativeBlock(
val redItem: Item get() = _redItem.get()
val blackItem: Item get() = _blackItem.get()
- val blocks = LazyList(
- { _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 = LazyList(
- { _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() },
- )
-
- fun registerBlocks(registry: DeferredRegister<Block>) {
- _whiteBlock = registry.register("${baseName}_white") { Block(propertySupplier.invoke(DyeColor.WHITE)) }
- _orangeBlock = registry.register("${baseName}_orange") { Block(propertySupplier.invoke(DyeColor.ORANGE)) }
- _magentaBlock = registry.register("${baseName}_magenta") { Block(propertySupplier.invoke(DyeColor.MAGENTA)) }
- _lightBlueBlock = registry.register("${baseName}_light_blue") { Block(propertySupplier.invoke(DyeColor.LIGHT_BLUE)) }
- _yellowBlock = registry.register("${baseName}_yellow") { Block(propertySupplier.invoke(DyeColor.YELLOW)) }
- _limeBlock = registry.register("${baseName}_lime") { Block(propertySupplier.invoke(DyeColor.LIME)) }
- _pinkBlock = registry.register("${baseName}_pink") { Block(propertySupplier.invoke(DyeColor.PINK)) }
- _grayBlock = registry.register("${baseName}_gray") { Block(propertySupplier.invoke(DyeColor.GRAY)) }
- _lightGrayBlock = registry.register("${baseName}_light_gray") { Block(propertySupplier.invoke(DyeColor.LIGHT_GRAY)) }
- _cyanBlock = registry.register("${baseName}_cyan") { Block(propertySupplier.invoke(DyeColor.CYAN)) }
- _purpleBlock = registry.register("${baseName}_purple") { Block(propertySupplier.invoke(DyeColor.PURPLE)) }
- _blueBlock = registry.register("${baseName}_blue") { Block(propertySupplier.invoke(DyeColor.BLUE)) }
- _brownBlock = registry.register("${baseName}_brown") { Block(propertySupplier.invoke(DyeColor.BROWN)) }
- _greenBlock = registry.register("${baseName}_green") { Block(propertySupplier.invoke(DyeColor.GREEN)) }
- _redBlock = registry.register("${baseName}_red") { Block(propertySupplier.invoke(DyeColor.RED)) }
- _blackBlock = registry.register("${baseName}_black") { Block(propertySupplier.invoke(DyeColor.BLACK)) }
+ val coloredBlocks: List<Block> by lazy {
+ LazyList(
+ _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,
+ )
}
- fun registerItems(registry: DeferredRegister<Item>) {
- _whiteItem = registry.register("${baseName}_white") { BlockItem(_whiteBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _orangeItem = registry.register("${baseName}_orange") { BlockItem(_orangeBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _magentaItem = registry.register("${baseName}_magenta") { BlockItem(_magentaBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _lightBlueItem = registry.register("${baseName}_light_blue") { BlockItem(_lightBlueBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _yellowItem = registry.register("${baseName}_yellow") { BlockItem(_yellowBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _limeItem = registry.register("${baseName}_lime") { BlockItem(_limeBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _pinkItem = registry.register("${baseName}_pink") { BlockItem(_pinkBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _grayItem = registry.register("${baseName}_gray") { BlockItem(_grayBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _lightGrayItem = registry.register("${baseName}_light_gray") { BlockItem(_lightGrayBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _cyanItem = registry.register("${baseName}_cyan") { BlockItem(_cyanBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _purpleItem = registry.register("${baseName}_purple") { BlockItem(_purpleBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _blueItem = registry.register("${baseName}_blue") { BlockItem(_blueBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _brownItem = registry.register("${baseName}_brown") { BlockItem(_brownBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _greenItem = registry.register("${baseName}_green") { BlockItem(_greenBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _redItem = registry.register("${baseName}_red") { BlockItem(_redBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
- _blackItem = registry.register("${baseName}_black") { BlockItem(_blackBlock.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
+ val mappedColoredBlocks: Map<DyeColor, Block> by lazy {
+ LazyMap(
+ 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 coloredItems: List<Item> by lazy {
+ LazyList(
+ _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,
+ )
+ }
+
+ val mappedColoredItems: Map<DyeColor, Item> by lazy {
+ LazyMap(
+ 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,
+ )
+ }
+
+ open fun registerBlocks(registry: DeferredRegister<Block>) {
+ _whiteBlock = registry.register("${baseName}_white") { provider.invoke(DyeColor.WHITE) }
+ _orangeBlock = registry.register("${baseName}_orange") { provider.invoke(DyeColor.ORANGE) }
+ _magentaBlock = registry.register("${baseName}_magenta") { provider.invoke(DyeColor.MAGENTA) }
+ _lightBlueBlock = registry.register("${baseName}_light_blue") { provider.invoke(DyeColor.LIGHT_BLUE) }
+ _yellowBlock = registry.register("${baseName}_yellow") { provider.invoke(DyeColor.YELLOW) }
+ _limeBlock = registry.register("${baseName}_lime") { provider.invoke(DyeColor.LIME) }
+ _pinkBlock = registry.register("${baseName}_pink") { provider.invoke(DyeColor.PINK) }
+ _grayBlock = registry.register("${baseName}_gray") { provider.invoke(DyeColor.GRAY) }
+ _lightGrayBlock = registry.register("${baseName}_light_gray") { provider.invoke(DyeColor.LIGHT_GRAY) }
+ _cyanBlock = registry.register("${baseName}_cyan") { provider.invoke(DyeColor.CYAN) }
+ _purpleBlock = registry.register("${baseName}_purple") { provider.invoke(DyeColor.PURPLE) }
+ _blueBlock = registry.register("${baseName}_blue") { provider.invoke(DyeColor.BLUE) }
+ _brownBlock = registry.register("${baseName}_brown") { provider.invoke(DyeColor.BROWN) }
+ _greenBlock = registry.register("${baseName}_green") { provider.invoke(DyeColor.GREEN) }
+ _redBlock = registry.register("${baseName}_red") { provider.invoke(DyeColor.RED) }
+ _blackBlock = registry.register("${baseName}_black") { provider.invoke(DyeColor.BLACK) }
+ }
+
+ private val properties = Item.Properties().tab(itemGroup).stacksTo(64)
+
+ open fun registerItems(registry: DeferredRegister<Item>) {
+ _whiteItem = registry.register("${baseName}_white") { BlockItem(_whiteBlock.get(), properties) }
+ _orangeItem = registry.register("${baseName}_orange") { BlockItem(_orangeBlock.get(), properties) }
+ _magentaItem = registry.register("${baseName}_magenta") { BlockItem(_magentaBlock.get(), properties) }
+ _lightBlueItem = registry.register("${baseName}_light_blue") { BlockItem(_lightBlueBlock.get(), properties) }
+ _yellowItem = registry.register("${baseName}_yellow") { BlockItem(_yellowBlock.get(), properties) }
+ _limeItem = registry.register("${baseName}_lime") { BlockItem(_limeBlock.get(), properties) }
+ _pinkItem = registry.register("${baseName}_pink") { BlockItem(_pinkBlock.get(), properties) }
+ _grayItem = registry.register("${baseName}_gray") { BlockItem(_grayBlock.get(), properties) }
+ _lightGrayItem = registry.register("${baseName}_light_gray") { BlockItem(_lightGrayBlock.get(), properties) }
+ _cyanItem = registry.register("${baseName}_cyan") { BlockItem(_cyanBlock.get(), properties) }
+ _purpleItem = registry.register("${baseName}_purple") { BlockItem(_purpleBlock.get(), properties) }
+ _blueItem = registry.register("${baseName}_blue") { BlockItem(_blueBlock.get(), properties) }
+ _brownItem = registry.register("${baseName}_brown") { BlockItem(_brownBlock.get(), properties) }
+ _greenItem = registry.register("${baseName}_green") { BlockItem(_greenBlock.get(), properties) }
+ _redItem = registry.register("${baseName}_red") { BlockItem(_redBlock.get(), properties) }
+ _blackItem = registry.register("${baseName}_black") { BlockItem(_blackBlock.get(), properties) }
+ }
+
+ companion object {
+ fun simple(baseName: String, provider: (DyeColor) -> BlockBehaviour.Properties, itemGroup: CreativeModeTab = OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE): ColoredDecorativeBlock {
+ return ColoredDecorativeBlock(baseName, {
+ Block(provider.invoke(it))
+ }, itemGroup)
+ }
+ }
+}
+
+class DecorativeBlock(
+ baseName: String,
+ private val provider: (DyeColor?) -> Block,
+ itemGroup: CreativeModeTab = OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE
+) : ColoredDecorativeBlock(baseName, provider, itemGroup) {
+ private var _block: RegistryObject<Block> by WriteOnce()
+ private var _item: RegistryObject<Item> by WriteOnce()
+
+ val block: Block get() = _block.get()
+ val item: Item get() = _item.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) }
+
+ super.registerBlocks(registry)
+ }
+
+ override fun registerItems(registry: DeferredRegister<Item>) {
+ _item = registry.register(baseName) { BlockItem(_block.get(), Item.Properties().tab(OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE).stacksTo(64)) }
+
+ super.registerItems(registry)
+ }
+
+ companion object {
+ fun simple(baseName: String, provider: (DyeColor?) -> BlockBehaviour.Properties, itemGroup: CreativeModeTab = OverdriveThatMatters.INSTANCE.CREATIVE_TAB_DECORATIVE): DecorativeBlock {
+ return DecorativeBlock(baseName, {
+ Block(provider.invoke(it))
+ }, itemGroup)
+ }
}
}
@@ -263,36 +395,38 @@ object MRegistry {
val ANDROID_FEATURES get() = features.get() as ForgeRegistry<AndroidFeatureType<*>>
val ANDROID_RESEARCH get() = research.get() as ForgeRegistry<AndroidResearchType<*>>
- val TRITANIUM_BLOCK = ColoredDecorativeBlock(MNames.TRITANIUM_BLOCK) {
- BlockBehaviour.Properties.of(Material.METAL, it.materialColor)
+ val CARGO_CRATES = DecorativeBlock(MNames.CARGO_CRATE, ::CargoCrateBlock, OverdriveThatMatters.INSTANCE.CREATIVE_TAB)
+
+ val TRITANIUM_BLOCK = DecorativeBlock.simple(MNames.TRITANIUM_BLOCK, {
+ BlockBehaviour.Properties.of(Material.METAL, it?.materialColor ?: MaterialColor.COLOR_LIGHT_BLUE)
.sound(SoundType.BASALT)
.requiresCorrectToolForDrops()
.explosionResistance(80f)
.strength(4f)
- }
+ })
- val VENT = ColoredDecorativeBlock(MNames.VENT) {
- BlockBehaviour.Properties.of(Material.METAL, it.materialColor)
+ val VENT = DecorativeBlock.simple(MNames.VENT, {
+ BlockBehaviour.Properties.of(Material.METAL, it?.materialColor ?: MaterialColor.COLOR_LIGHT_BLUE)
.sound(SoundType.BASALT)
.requiresCorrectToolForDrops()
.explosionResistance(20f)
.strength(1.5f)
- }
+ })
- val VENT_ALTERNATIVE = ColoredDecorativeBlock(MNames.VENT_ALTERNATIVE) {
- BlockBehaviour.Properties.of(Material.METAL, it.materialColor)
+ val VENT_ALTERNATIVE = DecorativeBlock.simple(MNames.VENT_ALTERNATIVE, {
+ BlockBehaviour.Properties.of(Material.METAL, it?.materialColor ?: MaterialColor.COLOR_LIGHT_BLUE)
.sound(SoundType.BASALT)
.requiresCorrectToolForDrops()
.explosionResistance(20f)
.strength(1.5f)
- }
+ })
- val FLOOR_TILES = ColoredDecorativeBlock(MNames.FLOOR_TILES) {
+ val FLOOR_TILES = ColoredDecorativeBlock.simple(MNames.FLOOR_TILES, {
BlockBehaviour.Properties.of(Material.STONE, it.materialColor)
.sound(SoundType.STONE)
.requiresCorrectToolForDrops()
.strength(3f)
- }
+ })
private fun register(event: NewRegistryEvent) {
features.write(RegistryBuilder<AndroidFeatureType<*>>().let {
@@ -308,17 +442,37 @@ object MRegistry {
})
}
- val DAMAGE_BECOME_ANDROID = ImmutableDamageSource(DamageSource("otm_become_android").bypassArmor().bypassInvul().bypassMagic())
- val DAMAGE_BECOME_HUMANE = ImmutableDamageSource(DamageSource("otm_become_humane").bypassArmor().bypassInvul().bypassMagic())
- val DAMAGE_EVENT_HORIZON = ImmutableDamageSource(DamageSource("otm_event_horizon").bypassMagic().bypassArmor())
- val DAMAGE_HAWKING_RADIATION = ImmutableDamageSource(DamageSource("otm_hawking_radiation"))
- const val DAMAGE_EMP_NAME = "otm_emp"
- const val DAMAGE_PLASMA_NAME = "otm_plasma"
- val DAMAGE_EMP: DamageSource = ImmutableDamageSource(EMPDamageSource())
+ val INDUSTRIAL_GLASS = DecorativeBlock(MNames.INDUSTRIAL_GLASS, { color ->
+ val properties = BlockBehaviour.Properties.of(Material.GLASS, if (color != null) color.materialColor else MaterialColor.NONE)
+ .strength(1.5f, 35.0f)
+ .requiresCorrectToolForDrops()
+ .sound(SoundType.GLASS)
+ .noOcclusion()
+ .isValidSpawn { _: BlockState, _: BlockGetter, _: BlockPos, _: EntityType<*>? -> false }
+ .isRedstoneConductor { _: BlockState, _: BlockGetter, _: BlockPos -> false }
+ .isSuffocating { _: BlockState, _: BlockGetter, _: BlockPos -> false }
+ .isViewBlocking { _: BlockState, _: BlockGetter, _: BlockPos -> false }
- init {
- // DAMAGE_HAWKING_RADIATION.bypassMagic().bypassArmor();
- }
+ if (color != null) {
+ return@DecorativeBlock StainedGlassBlock(color, properties)
+ }
+
+ return@DecorativeBlock GlassBlock(properties)
+ })
+
+ val INDUSTRIAL_GLASS_PANE = DecorativeBlock(MNames.INDUSTRIAL_GLASS_PANE, { color ->
+ val properties = BlockBehaviour.Properties.of(Material.GLASS, if (color != null) color.materialColor else MaterialColor.NONE)
+ .strength(1.25f, 5.0f)
+ .requiresCorrectToolForDrops()
+ .sound(SoundType.GLASS)
+ .noOcclusion()
+
+ if (color != null) {
+ return@DecorativeBlock StainedGlassPaneBlock(color, properties)
+ }
+
+ return@DecorativeBlock IronBarsBlock(properties)
+ })
val CRATE_RED = CrateProperties(MaterialColor.COLOR_RED, "crate_red")
val CRATE_BLUE = CrateProperties(MaterialColor.COLOR_BLUE, "crate_blue")
@@ -338,43 +492,17 @@ object MRegistry {
CRATE_PURPLE,
)
- val INDUSTRIAL_GLASS = IndustrialGlassProperties(null)
- val INDUSTRIAL_GLASS_WHITE = IndustrialGlassProperties(DyeColor.WHITE)
- val INDUSTRIAL_GLASS_ORANGE = IndustrialGlassProperties(DyeColor.ORANGE)
- val INDUSTRIAL_GLASS_MAGENTA = IndustrialGlassProperties(DyeColor.MAGENTA)
- val INDUSTRIAL_GLASS_LIGHT_BLUE = IndustrialGlassProperties(DyeColor.LIGHT_BLUE)
- val INDUSTRIAL_GLASS_YELLOW = IndustrialGlassProperties(DyeColor.YELLOW)
- val INDUSTRIAL_GLASS_LIME = IndustrialGlassProperties(DyeColor.LIME)
- val INDUSTRIAL_GLASS_PINK = IndustrialGlassProperties(DyeColor.PINK)
- val INDUSTRIAL_GLASS_GRAY = IndustrialGlassProperties(DyeColor.GRAY)
- val INDUSTRIAL_GLASS_LIGHT_GRAY = IndustrialGlassProperties(DyeColor.LIGHT_GRAY)
- val INDUSTRIAL_GLASS_CYAN = IndustrialGlassProperties(DyeColor.CYAN)
- val INDUSTRIAL_GLASS_PURPLE = IndustrialGlassProperties(DyeColor.PURPLE)
- val INDUSTRIAL_GLASS_BLUE = IndustrialGlassProperties(DyeColor.BLUE)
- val INDUSTRIAL_GLASS_BROWN = IndustrialGlassProperties(DyeColor.BROWN)
- val INDUSTRIAL_GLASS_GREEN = IndustrialGlassProperties(DyeColor.GREEN)
- val INDUSTRIAL_GLASS_RED = IndustrialGlassProperties(DyeColor.RED)
- val INDUSTRIAL_GLASS_BLACK = IndustrialGlassProperties(DyeColor.BLACK)
+ val DAMAGE_BECOME_ANDROID = ImmutableDamageSource(DamageSource("otm_become_android").bypassArmor().bypassInvul().bypassMagic())
+ val DAMAGE_BECOME_HUMANE = ImmutableDamageSource(DamageSource("otm_become_humane").bypassArmor().bypassInvul().bypassMagic())
+ val DAMAGE_EVENT_HORIZON = ImmutableDamageSource(DamageSource("otm_event_horizon").bypassMagic().bypassArmor())
+ val DAMAGE_HAWKING_RADIATION = ImmutableDamageSource(DamageSource("otm_hawking_radiation"))
+ const val DAMAGE_EMP_NAME = "otm_emp"
+ const val DAMAGE_PLASMA_NAME = "otm_plasma"
+ val DAMAGE_EMP: DamageSource = ImmutableDamageSource(EMPDamageSource())
- val INDUSTRIAL_GLASS_LIST = listOf(
- INDUSTRIAL_GLASS,
- INDUSTRIAL_GLASS_WHITE,
- INDUSTRIAL_GLASS_ORANGE,
- INDUSTRIAL_GLASS_MAGENTA,
- INDUSTRIAL_GLASS_LIGHT_BLUE,
- INDUSTRIAL_GLASS_YELLOW,
- INDUSTRIAL_GLASS_LIME,
- INDUSTRIAL_GLASS_PINK,
- INDUSTRIAL_GLASS_GRAY,
- INDUSTRIAL_GLASS_LIGHT_GRAY,
- INDUSTRIAL_GLASS_CYAN,
- INDUSTRIAL_GLASS_PURPLE,
- INDUSTRIAL_GLASS_BLUE,
- INDUSTRIAL_GLASS_BROWN,
- INDUSTRIAL_GLASS_GREEN,
- INDUSTRIAL_GLASS_RED,
- INDUSTRIAL_GLASS_BLACK,
- )
+ init {
+ // DAMAGE_HAWKING_RADIATION.bypassMagic().bypassArmor();
+ }
fun initialize(context: FMLJavaModLoadingContext) {
context.modEventBus.addListener(this::register)
diff --git a/src/main/resources/assets/overdrive_that_matters/lang/en_us.json b/src/main/resources/assets/overdrive_that_matters/lang/en_us.json
deleted file mode 100644
index cfa1c953b..000000000
--- a/src/main/resources/assets/overdrive_that_matters/lang/en_us.json
+++ /dev/null
@@ -1,419 +0,0 @@
-{
- "otm.sound.rifle_shoot": "Plasma rifle fires",
- "otm.sound.plasma_weapon_overheat": "Plasma weapon overheats",
- "otm.sound.player_become_android": "Player became android",
-
- "itemGroup.otm": "Overdrive That Matters",
- "itemGroup.otm_decorative": "Overdrive That Matters Decorative",
-
- "otm.item.blackhole_immunity": "Negates gravitational effects of singularities",
-
- "otm.pill.warning": "WARNING: This will INSTANTLY decommission you upon ingestion!",
- "otm.pill.android": "Take this pill and lose what is holding you back.",
-
- "otm.pill.humane": "Take this pill and wake up in bed none the wiser.",
-
- "otm.pill.oblivion": "Items and Experience spent on research is fully refunded.",
- "otm.pill.message_oblivion": "All android features are removed and all research refunded.",
-
- "otm.pill.heal": "Instantly restores 4 hearts upon ingestion, provides 2 min Absorption V and 8 seconds Regeneration III.",
- "otm.pill.heal_android": "Does nothing to androids.",
-
- "otm.pill.message": "Nothing happened, but you feel exhausted?.. Maybe get rest.",
- "otm.pill.message_finish": "§kONE OF US ONE OF US ONE OF US ONE OF US ONE OF US",
-
- "otm.gui.power.percentage_level": "Energy level: %s%%",
- "otm.gui.level": "%s / %s",
- "otm.gui.power.name": "MtJ",
-
- "otm.gui.power.burn_time": "Burn time left: %s ticks",
-
- "otm.gui.progress_widget": "Progress: %s%%",
- "otm.gui.progress_widget_stuck": "The machine can not work, check configuration",
-
- "otm.gui.total_raw": "Total:",
-
- "otm.gui.matter.percentage_level": "Matter level: %s%%",
- "otm.gui.matter.format": "Matter: %s",
- "otm.gui.matter.format_and_complexity": "%s / Complexity: %s",
- "otm.gui.matter.name": "MtU",
-
- "otm.gui.filter.is_whitelist": "Is Whitelist",
- "otm.gui.filter.match_nbt": "Match NBT",
- "otm.gui.filter.match_tag": "Match Tag",
-
- "otm.gui.android_research": "Research Tree",
-
- "otm.gui.pattern.percentage_level": "Fill level: %s%%",
- "otm.gui.pattern.format": "Stored patterns: %s / %s",
-
- "otm.gui.redstone.ignored": "Redstone mode: Ignored",
- "otm.gui.redstone.low": "Redstone mode: Low",
- "otm.gui.redstone.high": "Redstone mode: High",
-
- "otm.gui.redstone.ignored.description": "Redstone signal does not affect machine's function",
- "otm.gui.redstone.low.description": "Machine work if no redstone signal is present",
- "otm.gui.redstone.high.description": "Machine work only if any redstone signal is present",
-
- "otm.3d2d.gravitation_stabilizer.mass": "Singularity mass: %s",
- "otm.3d2d.gravitation_stabilizer.strength": "Gravitation strength: %s",
-
- "otm.death_reason": "Decommissioned!",
-
- "otm.item.power.infinite.storage": "Stored energy: Infinity / Infinity",
- "otm.item.power.infinite.throughput": "Max I/O Infinite / Infinite",
- "otm.item.power.passed": "Passed energy: %s",
- "otm.item.power.average": "Average throughput: %s/t",
- "otm.item.power.last_20_ticks": "Last second: %s",
- "otm.item.power.last_tick": "Last tick: %s",
-
- "otm.item.power.normal.storage": "Stored energy: %s / %s",
- "otm.item.power.normal.throughput": "Max I/O %s / %s",
-
- "otm.item.pattern.stored": "Stored patterns: %s / %s",
- "otm.item.pattern.infinite.stored": "Stored patterns %s",
- "otm.item.pattern.line": "%s [%s%%]",
- "otm.item.pattern.research": "Researched: %s%%",
-
- "otm.item.matter.infinite": "Stored matter: Infinity / Infinity",
- "otm.item.matter.normal": "Stored matter: %s / %s",
-
- "otm.gui.matter_task.total": "Total: %s",
- "otm.gui.matter_task.required": "Left to be done: %s",
- "otm.gui.matter_task.in_progress": "In progress: %s",
- "otm.gui.matter_task.finished": "Finished: %s",
-
- "otm.android_station.research.researched": "Researched!",
- "otm.android_station.research.can_be_researched": "Ready to research!",
- "otm.android_station.research.can_not_be_researched": "Can not afford!",
- "otm.android_station.research.xp_cost": "Experience cost: %s levels",
- "otm.android_station.research.item": "Requires %s x%s",
- "otm.android_station.research.missing_predecessors": "%s needs to be researched first",
-
- "otm.filter.yes": "Yes",
- "otm.filter.no": "No",
-
- "otm.matter_bottler.switch_mode": "Switch work mode",
-
- "android_feature.overdrive_that_matters.air_bags": "Air Bags",
-
- "android_research.overdrive_that_matters.limb_overclocking": "Limb Overclocking %s",
-
- "android_research.overdrive_that_matters.limb_overclocking.description": "Boosts unit's mobility by %s%% and attack speed by %s%%",
-
- "android_research.status.requires": "Requires %s to be researched",
- "android_research.status.blocks": "Locks %s",
- "android_research.status.blocked_by": "Locked by %s",
-
- "android_research.overdrive_that_matters.air_bags": "Air Bags",
- "android_research.overdrive_that_matters.nanobots": "Nanobots",
- "android_research.overdrive_that_matters.air_bags.description": "Allows unit to swim in water",
- "android_research.overdrive_that_matters.nanobots.description": "Various useful nanobots for doing various tasks",
-
- "android_research.overdrive_that_matters.nanobots_regeneration": "Regeneration %s",
- "android_research.overdrive_that_matters.nanobots_regeneration.description": "Nanobots get ability to repair unit's internal systems on the move",
- "android_research.overdrive_that_matters.nanobots_regeneration.description_improve": "Improves regeneration speed",
-
- "android_research.overdrive_that_matters.nanobots_armor": "Nanobots Armor",
- "android_research.overdrive_that_matters.nanobots_armor.description": "Allows nanobots to align themselves in cell shape, reducing incoming damage by a %% by absorbing impacts",
-
- "android_research.overdrive_that_matters.nanobots_armor_speed": "Nanobots Armor Build Speed %s",
- "android_research.overdrive_that_matters.nanobots_armor_speed.description": "Reduces time required for nanobots to form protection layer",
-
- "android_research.overdrive_that_matters.nanobots_armor_strength": "Nanobots Armor Strength %s",
- "android_research.overdrive_that_matters.nanobots_armor_strength.description": "Increases impact absorption strength of nanobots",
-
- "android_research.overdrive_that_matters.extended_reach": "Extended Reach",
- "android_research.overdrive_that_matters.extended_reach.description": "Increases block interaction distance",
-
- "stat.overdrive_that_matters.health_regenerated": "Damage Regenerated by Nanobots",
- "stat.overdrive_that_matters.damage_absorbed": "Damage Absorbed by Nanobots",
- "stat.overdrive_that_matters.power_consumed": "MtJ Burnt as Android",
-
- "otm.suffix.merge": "%s %s",
-
- "otm.suffix.kilo": "%s k%s",
- "otm.suffix.mega": "%s M%s",
- "otm.suffix.giga": "%s G%s",
- "otm.suffix.tera": "%s T%s",
- "otm.suffix.peta": "%s P%s",
- "otm.suffix.exa": "%s E%s",
- "otm.suffix.zetta": "%s Z%s",
- "otm.suffix.yotta": "%s Y%s",
-
- "otm.suffix.deci": "%s d%s",
- "otm.suffix.centi": "%s c%s",
- "otm.suffix.milli": "%s m%s",
- "otm.suffix.micro": "%s μ%s",
- "otm.suffix.nano": "%s n%s",
- "otm.suffix.pico": "%s p%s",
- "otm.suffix.femto": "%s f%s",
- "otm.suffix.atto": "%s a%s",
- "otm.suffix.zepto": "%s z%s",
- "otm.suffix.yocto": "%s y%s",
-
- "otm.suffix_raw.kilo": "k",
- "otm.suffix_raw.mega": "M",
- "otm.suffix_raw.giga": "G",
- "otm.suffix_raw.tera": "T",
- "otm.suffix_raw.peta": "P",
- "otm.suffix_raw.exa": "E",
- "otm.suffix_raw.zetta": "Z",
- "otm.suffix_raw.yotta": "Y",
- "otm.suffix_raw.deci": "d",
- "otm.suffix_raw.centi": "c",
- "otm.suffix_raw.milli": "m",
- "otm.suffix_raw.micro": "μ",
- "otm.suffix_raw.nano": "n",
- "otm.suffix_raw.pico": "p",
- "otm.suffix_raw.femto": "f",
- "otm.suffix_raw.atto": "a",
- "otm.suffix_raw.zepto": "z",
- "otm.suffix_raw.yocto": "y",
-
- "death.attack.otm_become_android": "%1$s lost their humanity",
- "death.attack.otm_become_humane": "%1$s regained their humanity",
- "death.attack.otm_event_horizon": "%1$s never crossed event horizon",
- "death.attack.otm_hawking_radiation": "%1$s discovered Hawking radiation",
- "death.attack.otm_emp": "%1$s electronics' fried",
-
- "death.attack.otm_become_android.player": "%1$s lost their humanity whilst %2$s tried to reason with them",
- "death.attack.otm_become_humane.player": "%1$s gained their humanity whilst %2$s tried to reason with them",
- "death.attack.otm_event_horizon.player": "%1$s tried to cross event horizon whilst trying to escape %2$s",
- "death.attack.otm_hawking_radiation.player": "%1$s disintegrated whilst fighting %2$s",
- "death.attack.otm_emp.player": "%1$s blew fuzes of %2$s",
- "death.attack.otm_emp.player.item": "%1$s blew fuzes of %2$s using %3$s",
-
- "block.overdrive_that_matters.android_station": "Android Station",
- "block.overdrive_that_matters.battery_bank": "Battery Bank",
- "block.overdrive_that_matters.matter_decomposer": "Matter Decomposer",
- "block.overdrive_that_matters.matter_capacitor_bank": "Matter Capacitor Bank",
- "block.overdrive_that_matters.matter_cable": "Matter Network Cable",
- "block.overdrive_that_matters.pattern_storage": "Pattern Storage",
- "block.overdrive_that_matters.matter_scanner": "Matter Scanner",
- "block.overdrive_that_matters.matter_panel": "Pattern Monitor",
- "block.overdrive_that_matters.matter_replicator": "Matter Replicator",
- "block.overdrive_that_matters.matter_bottler": "Matter Bottler",
- "block.overdrive_that_matters.drive_viewer": "Drive Viewer",
- "block.overdrive_that_matters.black_hole": "Local Anomalous Singular Gravitation Field",
-
- "block.overdrive_that_matters.energy_counter": "Energy Counter",
- "block.overdrive_that_matters.energy_counter.facing": "Input facing: %s",
- "block.overdrive_that_matters.energy_counter.switch": "Switch input facing",
- "block.overdrive_that_matters.energy_counter.limit": "I/O Limit. -1 means no limit",
-
- "block.overdrive_that_matters.chemical_generator": "Chemical Generator",
- "block.overdrive_that_matters.drive_rack": "Condensation Drive Rack",
- "block.overdrive_that_matters.item_monitor": "Item Monitor",
- "block.overdrive_that_matters.plate_press": "Plate Press",
- "block.overdrive_that_matters.gravitation_stabilizer": "Gravitation Stabilizer",
- "block.overdrive_that_matters.gravitation_stabilizer_lens": "Gravitation Stabilizer Lens",
- "block.overdrive_that_matters.gravitation_stabilizer.desc": "Reduces gravitation effects of singularities",
- "block.overdrive_that_matters.gravitation_stabilizer.desc2": "Requires no power to operate",
- "block.overdrive_that_matters.gravitation_stabilizer.desc3": "Keep in mind the effect of multiple stabilizers produce exponentially increasing result",
- "block.overdrive_that_matters.gravitation_stabilizer.desc4": "Too weak gravitation field will cause singularity to melt and evaporate away very fast",
-
- "block.overdrive_that_matters.matter_recycler": "Matter Recycler",
-
- "otm.container.matter_panel.number_input": "Input replication task count",
-
- "otm.container.matter_panel.increase_by": "+%s",
- "otm.container.matter_panel.decrease_by": "-%s",
- "otm.container.matter_panel.send": "Send",
- "otm.container.matter_panel.close": "Close",
- "otm.container.matter_panel.cancel_task": "Cancel task",
- "otm.container.matter_panel.cancel": "Cancel",
- "otm.container.matter_panel.label": "Replication request",
- "otm.container.matter_panel.task": "Ongoing replication task",
- "otm.container.matter_panel.task_line": "%s: %s | %s / %s",
-
- "block.overdrive_that_matters.crate_red": "Red Container Block",
- "block.overdrive_that_matters.crate_blue": "Blue Container Block",
- "block.overdrive_that_matters.crate_green": "Green Container Block",
- "block.overdrive_that_matters.crate_yellow": "Yellow Container Block",
- "block.overdrive_that_matters.crate_black": "Black Container Block",
- "block.overdrive_that_matters.crate_pink": "Pink Container Block",
- "block.overdrive_that_matters.crate_purple": "Purple Container Block",
- "block.overdrive_that_matters.carbon_fibre_block": "Carbon fibre Block",
- "block.overdrive_that_matters.tritanium_block": "Tritanium Block",
- "block.overdrive_that_matters.tritanium_striped_block": "Tritanium Striped Block",
- "block.overdrive_that_matters.cargo_crate": "Cargo Crate",
- "block.overdrive_that_matters.tritanium_ore": "Tritanium Ore",
- "block.overdrive_that_matters.deepslate_tritanium_ore": "Deepslate Tritanium Ore",
- "block.overdrive_that_matters.tritanium_raw_block": "Raw Tritanium Block",
-
- "block.overdrive_that_matters.storage_cable": "Storage Cable",
- "block.overdrive_that_matters.storage_power_supplier": "Storage Power Supplier",
- "block.overdrive_that_matters.storage_bus": "Storage Bus",
- "block.overdrive_that_matters.storage_importer": "Storage Importer",
- "block.overdrive_that_matters.storage_exporter": "Storage Exporter",
-
- "block.overdrive_that_matters.cargo_crate_white": "White Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_orange": "Orange Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_magenta": "Magenta Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_light_blue": "Light Blue Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_yellow": "Yellow Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_lime": "Lime Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_pink": "Pink Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_gray": "Gray Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_light_gray": "Light Gray Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_cyan": "Cyan Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_purple": "Purple Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_blue": "Blue Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_brown": "Brown Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_green": "Green Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_red": "Red Cargo Crate",
- "block.overdrive_that_matters.cargo_crate_black": "Black Cargo Crate",
-
- "block.overdrive_that_matters.tritanium_block_white": "White Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_orange": "Orange Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_magenta": "Magenta Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_light_blue": "Light Blue Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_yellow": "Yellow Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_lime": "Lime Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_pink": "Pink Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_gray": "Gray Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_light_gray": "Light Gray Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_cyan": "Cyan Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_purple": "Purple Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_blue": "Blue Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_brown": "Brown Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_green": "Green Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_red": "Red Tritanium Block",
- "block.overdrive_that_matters.tritanium_block_black": "Black Tritanium Block",
-
- "block.overdrive_that_matters.floor_tiles_white": "White Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_orange": "Orange Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_magenta": "Magenta Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_light_blue": "Light Blue Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_yellow": "Yellow Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_lime": "Lime Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_pink": "Pink Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_gray": "Gray Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_light_gray": "Light Gray Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_cyan": "Cyan Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_purple": "Purple Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_blue": "Blue Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_brown": "Brown Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_green": "Green Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_red": "Red Floor Tiles",
- "block.overdrive_that_matters.floor_tiles_black": "Black Floor Tiles",
-
- "block.overdrive_that_matters.industrial_glass": "Clear Industrial Glass",
-
- "block.overdrive_that_matters.industrial_glass_white": "White Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_orange": "Orange Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_magenta": "Magenta Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_light_blue": "Light Stained Blue Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_yellow": "Yellow Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_lime": "Lime Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_pink": "Pink Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_gray": "Gray Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_light_gray": "Light Stained Gray Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_cyan": "Cyan Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_purple": "Purple Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_blue": "Blue Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_brown": "Brown Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_green": "Green Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_red": "Red Stained Industrial Glass",
- "block.overdrive_that_matters.industrial_glass_black": "Black Stained Industrial Glass",
-
- "block.overdrive_that_matters.industrial_glass_pane": "Clear Industrial Glass Pane",
-
- "block.overdrive_that_matters.industrial_glass_pane_white": "White Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_orange": "Orange Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_magenta": "Magenta Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_light_blue": "Light Stained Blue Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_yellow": "Yellow Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_lime": "Lime Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_pink": "Pink Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_gray": "Gray Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_light_gray": "Light Stained Gray Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_cyan": "Cyan Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_purple": "Purple Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_blue": "Blue Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_brown": "Brown Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_green": "Green Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_red": "Red Stained Industrial Glass Pane",
- "block.overdrive_that_matters.industrial_glass_pane_black": "Black Stained Industrial Glass Pane",
-
- "item.overdrive_that_matters.pill_android": "Android Pill",
- "item.overdrive_that_matters.pill_humane": "Humane Pill",
- "item.overdrive_that_matters.pill_oblivion": "Android Factory Reset Pill",
- "item.overdrive_that_matters.pill_heal": "Medical Pill",
-
- "item.overdrive_that_matters.matter_dust": "Matter Dust",
- "item.overdrive_that_matters.matter_dust.desc": "This item is product of failed decomposition or replication attempt",
- "item.overdrive_that_matters.matter_dust.desc2": "Throw into matter recycler to get some of it's value back!",
- "item.overdrive_that_matters.matter_dust.desc3": "Do not smell, throw at strangers or pour on donuts",
-
- "item.overdrive_that_matters.portable_condensation_drive": "Portable Condensation Drive",
- "item.overdrive_that_matters.portable_dense_condensation_drive": "Portable Dense Condensation Drive",
-
- "item.overdrive_that_matters.nutrient_paste": "Nutrient paste",
- "item.overdrive_that_matters.black_hole_scanner": "Singularity Scanner",
- "item.overdrive_that_matters.black_hole_scanner.desc": "Scans singularities for their properties",
- "item.overdrive_that_matters.black_hole_scanner.desc2": "Hold in hand to determine mass of singularities",
- "item.overdrive_that_matters.gravitation_field_limiter": "Gravitation Field Limiter",
- "item.overdrive_that_matters.gravitation_field_sensor": "Gravitation Field Sensor",
- "item.overdrive_that_matters.portable_gravitation_stabilizer": "Portable Gravitation Stabilizer",
-
- "item.overdrive_that_matters.battery_crude": "Crude Battery",
- "item.overdrive_that_matters.battery_basic": "Basic Battery",
- "item.overdrive_that_matters.battery_normal": "Ordinary Battery",
- "item.overdrive_that_matters.battery_dense": "Dense Battery",
- "item.overdrive_that_matters.battery_capacitor": "Capacitor Battery",
- "item.overdrive_that_matters.battery_creative": "Creative Battery",
-
- "item.overdrive_that_matters.energy_sword": "Powered Cake Slicer",
- "item.overdrive_that_matters.energy_sword.desc": "Needs power to operate",
- "item.overdrive_that_matters.energy_sword.desc2": "Deals extra damage to androids when powered",
-
- "item.overdrive_that_matters.tritanium_sword": "Tritanium Sword",
- "item.overdrive_that_matters.tritanium_pickaxe": "Tritanium Pickaxe",
- "item.overdrive_that_matters.tritanium_shovel": "Tritanium Shovel",
- "item.overdrive_that_matters.tritanium_axe": "Tritanium Axe",
- "item.overdrive_that_matters.tritanium_hoe": "Tritanium Hoe",
-
- "item.overdrive_that_matters.tritanium_helmet": "Tritanium Helmet",
- "item.overdrive_that_matters.tritanium_chestplate": "Tritanium Chestplate",
- "item.overdrive_that_matters.tritanium_pants": "Tritanium Leggings",
- "item.overdrive_that_matters.tritanium_boots": "Tritanium Boots",
-
- "item.overdrive_that_matters.plasma_rifle": "Plasma Rifle",
-
- "item.overdrive_that_matters.matter_capacitor_parts": "Matter Capacitor Parts",
- "item.overdrive_that_matters.matter_capacitor_basic": "Basic Matter Capacitor",
- "item.overdrive_that_matters.matter_capacitor_normal": "Matter Capacitor",
- "item.overdrive_that_matters.matter_capacitor_dense": "Dense Matter Capacitor",
- "item.overdrive_that_matters.matter_capacitor_creative": "Creative Matter Capacitor",
-
- "item.overdrive_that_matters.gravitational_disruptor": "Gravitational Disruptor",
- "item.overdrive_that_matters.gravitational_disruptor.description": "Once within close proximity of supermassive body, suppresses any gravity in it's radius",
- "item.overdrive_that_matters.gravitational_disruptor.description2": "Allows collapse of black holes",
- "item.overdrive_that_matters.gravitational_disruptor.description3": "Doesn't destroy any of mass singularity had acquired, which result in violent explosion of matter!",
- "item.overdrive_that_matters.gravitational_disruptor.description4": "The explosion %s be contained by %s. Do not even attempt to contain it.",
- "item.overdrive_that_matters.gravitational_disruptor.description4_clarification": "can not",
- "item.overdrive_that_matters.gravitational_disruptor.description4_clarification2": "anything",
-
- "item.overdrive_that_matters.tritanium_ore_clump": "Raw Tritanium",
-
- "item.overdrive_that_matters.tritanium_ingot": "Tritanium Ingot",
- "item.overdrive_that_matters.matter_io_port": "Matter IO Port",
- "item.overdrive_that_matters.matter_transform_matrix": "Matter Transformation Matrix",
- "item.overdrive_that_matters.energy_bus": "Energy Bus",
- "item.overdrive_that_matters.electric_parts": "Electric Parts",
- "item.overdrive_that_matters.machine_frame": "Machine Frame",
- "item.overdrive_that_matters.tritanium_plate": "Tritanium Plate",
- "item.overdrive_that_matters.iron_plate": "Iron Plate",
- "item.overdrive_that_matters.copper_wiring": "Copper Wiring",
- "item.overdrive_that_matters.gold_wiring": "Gold Wiring",
- "item.overdrive_that_matters.portable_condensation_drive_casing": "Portable Condensation Drive Casing",
- "item.overdrive_that_matters.portable_dense_condensation_drive_casing": "Portable Dense Condensation Drive Casing",
- "item.overdrive_that_matters.circuit_plating": "Circuit Plating",
- "item.overdrive_that_matters.basic_control_circuit": "Basic Control Circuit",
- "item.overdrive_that_matters.advanced_control_circuit": "Advanced Control Circuit",
-
- "item.overdrive_that_matters.pattern_drive_normal": "Pattern Drive",
- "item.overdrive_that_matters.pattern_drive_creative": "Creative Pattern Drive"
-}
\ No newline at end of file