DBot/overdrive_that_matters
DBot/overdrive_that_matters
3
1
Fork 0
Code Issues 63 Pull Requests Packages Releases Wiki Activity

Clean up registry, Language datagen

Browse Source
This commit is contained in:
DBotThePony 2022-05-21 15:36:18 +07:00
parent d0c1a7ec5a
commit 9185473df6
Signed by: DBot
GPG Key ID: DCC23B5715498507
13 changed files with 1110 additions and 1043 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -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)

241
src/data/kotlin/ru/dbotthepony/mc/otm/datagen/MatteryLanguageProvider.kt Normal file
View File

@ -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)
}

401
src/data/kotlin/ru/dbotthepony/mc/otm/datagen/lang/English.kt Normal file
View File

@ -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")
}
}

2
src/main/java/ru/dbotthepony/mc/otm/OverdriveThatMatters.java
View File

@ -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);
}
};

23
src/main/java/ru/dbotthepony/mc/otm/android/AndroidResearchType.java
View File

@ -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;
}
}

8
src/main/kotlin/ru/dbotthepony/mc/otm/android/AndroidFeature.kt
View File

@ -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> {

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

@ -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())

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

@ -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) }

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

@ -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 },
)
}

158
src/main/kotlin/ru/dbotthepony/mc/otm/registry/MItems.kt
View File

@ -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)
}
}

3
src/main/kotlin/ru/dbotthepony/mc/otm/registry/MNames.kt
View File

@ -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"

530
src/main/kotlin/ru/dbotthepony/mc/otm/registry/MRegistry.kt
View File

@ -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)

419
src/main/resources/assets/overdrive_that_matters/lang/en_us.json
View File

@ -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"
}